Merge pull request #39 from kris7t/partial-interpretation

Implement partial interpretation based model generation
author: Kristóf Marussy <marussy@mit.bme.hu> 2023-09-14 19:29:36 +0200
committer: GitHub <noreply@github.com> 2023-09-14 19:29:36 +0200
commit: 98ed3b6db5f4e51961a161050cc31c66015116e8 (patch)
tree: 8bfd6d9bc8d6ed23b9eb0f889dd40b6c24fe8f92 /subprojects/viatra-runtime-localsearch
parent: Merge pull request #38 from nagilooh/design-space-exploration (diff)
parent: Merge remote-tracking branch 'upstream/main' into partial-interpretation (diff)
download: refinery-98ed3b6db5f4e51961a161050cc31c66015116e8.tar.gz
refinery-98ed3b6db5f4e51961a161050cc31c66015116e8.tar.zst
refinery-98ed3b6db5f4e51961a161050cc31c66015116e8.zip
76 files changed, 8410 insertions, 0 deletions
diff --git a/subprojects/viatra-runtime-localsearch/about.html b/subprojects/viatra-runtime-localsearch/about.html
new file mode 100644
index 00000000..d1d5593a
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/about.html
@@ -0,0 +1,26 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
+<html>
+<!--
+  Copyright (c) 2017, Eclipse.org Foundation, Inc.
+  SPDX-License-Identifier: LicenseRef-EPL-Steward
+-->
+<head>
+<title>About</title>
+<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+<p>March 18, 2019</p>
+<h3>License</h3>
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/org/documents/epl-v20.php">http://www.eclipse.org/legal/epl-v20.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+</body>
+</html>
diff --git a/subprojects/viatra-runtime-localsearch/build.gradle.kts b/subprojects/viatra-runtime-localsearch/build.gradle.kts
new file mode 100644
index 00000000..31c0c634
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/build.gradle.kts
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+plugins {
+        id("tools.refinery.gradle.java-library")
+}
+dependencies {
+        implementation(project(":refinery-viatra-runtime"))
+        implementation(libs.slf4j.log4j)
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/ExecutionLoggerAdapter.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/ExecutionLoggerAdapter.java
new file mode 100644
index 00000000..bfb76d9a
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/ExecutionLoggerAdapter.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, 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.viatra.runtime.localsearch;
+import tools.refinery.viatra.runtime.localsearch.matcher.ILocalSearchAdapter;
+import tools.refinery.viatra.runtime.localsearch.matcher.LocalSearchMatcher;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlan;
+import java.util.Optional;
+import java.util.function.Consumer;
+/**
+ * @since 2.0
+ */
+public final class ExecutionLoggerAdapter implements ILocalSearchAdapter {
+    volatile String indentation = "";
+    private final Consumer<String> outputConsumer;
+    public ExecutionLoggerAdapter(Consumer<String> outputConsumer) {
+        this.outputConsumer = outputConsumer;
+    }
+    private void logMessage(String message) {
+        outputConsumer.accept(message);
+    }
+    private void logMessage(String message, Object...args) {
+        outputConsumer.accept(String.format(message, args));
+    }
+    @Override
+    public void patternMatchingStarted(LocalSearchMatcher lsMatcher) {
+        logMessage(indentation + "[ START] " + lsMatcher.getQuerySpecification().getFullyQualifiedName());
+    }
+    @Override
+    public void noMoreMatchesAvailable(LocalSearchMatcher lsMatcher) {
+        logMessage(indentation + "[FINISH] " + lsMatcher.getQuerySpecification().getFullyQualifiedName());
+    }
+    @Override
+    public void planChanged(Optional<SearchPlan> oldPlan, Optional<SearchPlan> newPlan) {
+        logMessage(indentation + "[  PLAN] " + newPlan.map(p -> p.getSourceBody().getPattern().getFullyQualifiedName()).orElse(""));
+        logMessage(indentation + newPlan.map(SearchPlan::toString).map(s -> s.replace("\n", "\n" + indentation)).orElse(""));
+    }
+    @Override
+    public void operationSelected(SearchPlan plan, ISearchOperation operation, MatchingFrame frame, boolean isBacktrack) {
+        String category = isBacktrack ? "[  BACK] "  : "[SELECT] ";
+       logMessage(indentation + category + operation.toString());
+        if (operation instanceof IPatternMatcherOperation) {
+            indentation = indentation + "\t";
+        }
+    }
+    @Override
+    public void operationExecuted(SearchPlan plan, ISearchOperation operation, MatchingFrame frame,
+            boolean isSuccessful) {
+        if (operation instanceof IPatternMatcherOperation && indentation.length() > 0) {
+            indentation = indentation.substring(1);
+        }
+        logMessage(indentation + "[    %s] %s %s", isSuccessful ? "OK" : "NO", operation.toString(), frame.toString());
+    }
+    @Override
+    public void matchFound(SearchPlan plan, MatchingFrame frame) {
+        logMessage(indentation + "[ MATCH] " + plan.getSourceBody().getPattern().getFullyQualifiedName() + " " + frame.toString());
+    }
+    @Override
+    public void duplicateMatchFound(MatchingFrame frame) {
+        logMessage(indentation + "[ DUPL.] " + frame.toString());
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/MatchingFrame.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/MatchingFrame.java
new file mode 100644
index 00000000..bdbc663c
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/MatchingFrame.java
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Akos Horvath, Gergely Varro Zoltan Ujhelyi 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.viatra.runtime.localsearch;
+import tools.refinery.viatra.runtime.matchers.tuple.IModifiableTuple;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileTuple;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+/**
+ * A MatchingFrame is a Volatile Tuple implementation used by the local search engine internally.
+ */
+public class MatchingFrame extends VolatileTuple implements IModifiableTuple {
+    /**
+     * The array that physically holds the values.
+     */
+    private Object[] frame;
+    /**
+     * @since 1.7
+     */
+    public MatchingFrame(int frameSize) {
+        this.frame = new Object[frameSize];
+    }
+    /**
+     * Creates a copy of another matching frame; the two frames can be updated separately
+     * @param other
+     * @since 1.7
+     */
+    public MatchingFrame(MatchingFrame other) {
+        this.frame = Arrays.copyOf(other.frame, other.frame.length);
+    }
+    /**
+     * Returns the value stored inside the matching frame.
+     *
+     * @param position
+     * @return the element stored in the selected position in the frame, or null if it is not yet set
+     * @throws IndexOutOfBoundsException
+     *             if position is negative
+     * @throws IllegalArgumentException
+     *             if the position is larger then the length of the frame
+     */
+    public Object getValue(int position) {
+        Preconditions.checkElementIndex(position, frame.length);
+        return frame[position];
+    }
+    /**
+     * Sets the value of the variable at the given position. For internal use in LS matching only.
+     *
+     * @param position the position of the variable within the frame
+     * @param value the value to be set for the variable
+     */
+    public void setValue(int position, Object value) {
+        Preconditions.checkElementIndex(position, frame.length);
+        frame[position] = value;
+    }
+    public boolean testAndSetValue(Integer position, Object value) {
+        Preconditions.checkElementIndex(position, frame.length);
+        if (frame[position] == null) {
+            frame[position] = value;
+            return true;
+        } else {
+            return frame[position].equals(value);
+        }
+    }
+    @Override
+    public String toString() {
+        return Arrays.stream(frame).map(this::stringRepresentation).collect(Collectors.joining(", ", "[", "]"));
+    }
+    private String stringRepresentation(Object obj) {
+        if (obj == null) {
+            return "_";
+        }
+        return obj.toString();
+    }
+    @Override
+    public int getSize() {
+        return frame.length;
+    }
+    @Override
+    public Object get(int index) {
+        return getValue(index);
+    }
+    @Override
+    public Object[] getElements() {
+        return Arrays.copyOf(frame, frame.length);
+    }
+    @Override
+    public void set(int index, Object value) {
+        frame[index] = value;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/exceptions/LocalSearchException.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/exceptions/LocalSearchException.java
new file mode 100644
index 00000000..c239e766
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/exceptions/LocalSearchException.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.exceptions;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+/**
+ * @author Zoltan Ujhelyi, Akos Horvath
+ * 
+ */
+public class LocalSearchException extends ViatraQueryRuntimeException {
+    private static final long serialVersionUID = -2585896573351435974L;
+    public static final String PLAN_EXECUTION_ERROR = "Error while executing search plan";
+    public static final String TYPE_ERROR = "Invalid type of variable";
+    public LocalSearchException(String description, Throwable rootException) {
+        super(description, rootException);
+    }
+    public LocalSearchException(String description) {
+        super(description);
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/CallWithAdornment.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/CallWithAdornment.java
new file mode 100644
index 00000000..0cabeb97
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/CallWithAdornment.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, 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.viatra.runtime.localsearch.matcher;
+import java.util.HashSet;
+import java.util.Set;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * Immutable data that represents the role of a pattern call within an LS query plan.
+ *  
+ * <p> The call is expressed as the {@link PConstraint} {@link #call} (implementing {@link IQueryReference}), 
+ * while the stored {@link #adornment} records the way it will be used within a search plan (specifically, 
+ * pattern parameters within the adornment will have their values known at the point of evaluating the constraint).
+ * 
+ * 
+ * @author Gabor Bergmann
+ * @since 2.1
+ */
+public class CallWithAdornment {
+    private final IQueryReference call;
+    private final Set<PParameter> adornment;
+    public CallWithAdornment(IQueryReference call, Set<PParameter> adornment) {
+        this.call = call;
+        this.adornment = new HashSet<>(adornment);
+    }
+    public IQueryReference getCall() {
+        return call;
+    }
+    public Set<PParameter> getAdornment() {
+        return adornment;
+    }
+    
+    
+    public PQuery getReferredQuery() {
+        return call.getReferredQuery();
+    }
+    
+    public MatcherReference getMatcherReference() {
+        return new MatcherReference(getReferredQuery(), adornment);
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ILocalSearchAdaptable.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ILocalSearchAdaptable.java
new file mode 100644
index 00000000..f4b28ed0
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ILocalSearchAdaptable.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Peter Lunk, 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.viatra.runtime.localsearch.matcher;
+import java.util.List;
+/**
+ * @author Zoltan Ujhelyi
+ *
+ */
+public interface ILocalSearchAdaptable {
+    List<ILocalSearchAdapter> getAdapters();
+    void addAdapter(ILocalSearchAdapter adapter);
+    void removeAdapter(ILocalSearchAdapter adapter);
+    void removeAdapters(List<ILocalSearchAdapter> adapter);
+    void addAdapters(List<ILocalSearchAdapter> adapter);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ILocalSearchAdapter.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ILocalSearchAdapter.java
new file mode 100644
index 00000000..df64b5f1
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ILocalSearchAdapter.java
@@ -0,0 +1,120 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.matcher;
+import java.util.Optional;
+import tools.refinery.viatra.runtime.localsearch.ExecutionLoggerAdapter;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlan;
+import tools.refinery.viatra.runtime.localsearch.profiler.LocalSearchProfilerAdapter;
+/**
+ * A local search adapter allows external code to follow the internal executions of the local search matcher. Possible
+ * implementations of the interface include profilers and debuggers.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. A few shortcomings have been found for this interface late during the development
+ * lifecycle of version 2.0 whose solution might need breaking possible future implementors. Because of this, right now
+ * it is not recommended to provide implementations outside of VIATRA. If necessary, have a look at the built-in
+ * adapters that should fulfill most cases in the meantime. See bugs https://bugs.eclipse.org/bugs/show_bug.cgi?id=535101
+ * and https://bugs.eclipse.org/bugs/show_bug.cgi?id=535102 for details.
+ * 
+ * @author Marton Bur
+ * @see ExecutionLoggerAdapter
+ * @see LocalSearchProfilerAdapter
+ *
+ */
+public interface ILocalSearchAdapter {
+    /**
+     * 
+     * @since 1.2
+     */
+    default void adapterRegistered(ILocalSearchAdaptable adaptable) {};
+    /**
+     * 
+     * @since 1.2
+     */
+    default void adapterUnregistered(ILocalSearchAdaptable adaptable) {};
+    
+    /**
+     * Callback method to indicate the start of a matching process
+     *
+     * @param lsMatcher the local search matcher that starts the matching
+     */
+    default void patternMatchingStarted(LocalSearchMatcher lsMatcher) {};
+    /**
+     * Callback method to indicate the end of a matching process
+     * </p>
+     * <strong>WARNING</strong>: It is not guaranteed that this method will be called;
+     * it is possible that a match process will end after a match is found and no other matches are accessed.
+     * 
+     * @param lsMatcher the local search matcher that finished
+     * @since 2.0
+     */
+    default void noMoreMatchesAvailable(LocalSearchMatcher lsMatcher) {};
+    /**
+     * Callback method to indicate switching to a new plan during the execution of a pattern matching
+     * 
+     * @param oldPlan the plan that is finished. Value is null when the first plan is starting.
+     * @param newPlan the plan that will begin execution
+     * @since 2.0
+     */
+    default void planChanged(Optional<SearchPlan> oldPlan, Optional<SearchPlan> newPlan) {};
+    
+    /**
+     * Callback method to indicate the selection of an operation to execute
+     * 
+     * @param plan the current plan executor
+     * @param frame the current matching frame
+     * @param isBacktrack if true, the selected operation was reached via backtracking
+     * @since 2.0
+     */
+    default void operationSelected(SearchPlan plan, ISearchOperation operation, MatchingFrame frame, boolean isBacktrack) {};
+    /**
+     * Callback method to indicate that an operation is executed
+     * 
+     * @param plan the current plan
+     * @param frame the current matching frame
+     * @param isSuccessful if true, the operation executed successfully, or false if the execution failed and backtracking will happen
+     * @since 2.0
+     */
+    default void operationExecuted(SearchPlan plan, ISearchOperation operation, MatchingFrame frame, boolean isSuccessful) {};
+    /**
+     * Callback that is used to indicate that a match has been found
+     * 
+     * @param plan the search plan executor that found the match
+     * @param frame the frame that holds the substitutions of the variables that match 
+     * @since 2.0
+     */
+    default void matchFound(SearchPlan plan, MatchingFrame frame) {};
+    /**
+     * Callback that is used to indicate that the previously reported match has been found as a duplicate, thus will be ignored from the match results.
+     * 
+     * @param plan the search plan executor that found the match
+     * @param frame the frame that holds the substitutions of the variables that match 
+     * @since 2.0
+     */
+    default void duplicateMatchFound(MatchingFrame frame) {};
+    /**
+     * Callback method to indicate that a search plan is initialized in an executor with the given frame and starting operation
+     * 
+     * @param searchPlan
+     * @param frame
+     * @since 2.0
+     */
+    default void executorInitializing(SearchPlan searchPlan, MatchingFrame frame) {};
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ISearchContext.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ISearchContext.java
new file mode 100644
index 00000000..71aa4aac
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/ISearchContext.java
@@ -0,0 +1,120 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.matcher;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.localsearch.matcher.integration.IAdornmentProvider;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.util.ICache;
+import tools.refinery.viatra.runtime.matchers.util.IProvider;
+import java.util.Collections;
+/**
+ * The {@link ISearchContext} interface allows search operations to reuse platform services such as the indexer.
+ *
+ * @author Zoltan Ujhelyi
+ * @noreference This interface is not intended to be referenced by clients.
+ * @noimplement This interface is not intended to be implemented by clients.
+ * @noextend This interface is not intended to be extended by clients.
+ *
+ */
+public interface ISearchContext {
+    /**
+     * Provides access to the generic query runtime context of the current engine
+     * @since 1.7
+     */
+    IQueryRuntimeContext getRuntimeContext();
+    /**
+     * Returns a matcher for a selected query specification.
+     *
+     * @throws ViatraQueryRuntimeException
+     * @since 1.5
+     */
+    IQueryResultProvider getMatcher(CallWithAdornment dependency);
+    /**
+     * Allows search operations to cache values through the entire lifecycle of the local search backend. The values are
+     * calculated if not cached before using the given provider, or returned from the cache accordingly.
+     *
+     * @since 1.7
+     */
+    <T> T accessBackendLevelCache(Object key, Class<? extends T> clazz, IProvider<T> valueProvider);
+    /**
+     * Returns the engine-specific logger
+     *
+     * @since 2.0
+     */
+    Logger getLogger();
+    /**
+     * @noreference This class is not intended to be referenced by clients.
+     * @noimplement This interface is not intended to be implemented by clients.
+     * @noextend This interface is not intended to be extended by clients.
+     */
+    public class SearchContext implements ISearchContext {
+        private final IQueryRuntimeContext runtimeContext;
+        private final ICache backendLevelCache;
+        private final Logger logger;
+        private final ResultProviderRequestor resultProviderRequestor;
+        /**
+         * Initializes a search context using an arbitrary backend context
+         */
+        public SearchContext(IQueryBackendContext backendContext, ICache backendLevelCache,
+                ResultProviderRequestor resultProviderRequestor) {
+            this.resultProviderRequestor = resultProviderRequestor;
+            this.runtimeContext = backendContext.getRuntimeContext();
+            this.logger = backendContext.getLogger();
+            this.backendLevelCache = backendLevelCache;
+        }
+        /**
+         * @throws ViatraQueryRuntimeException
+         * @since 2.1
+         */
+        @Override
+        public IQueryResultProvider getMatcher(CallWithAdornment dependency) {
+            // Inject adornment for referenced pattern
+            IAdornmentProvider adornmentProvider = query -> {
+                if (query.equals(dependency.getReferredQuery())){
+                    return Collections.singleton(dependency.getAdornment());
+                }
+                return Collections.emptySet();
+            };
+            return resultProviderRequestor.requestResultProvider(dependency.getCall(),
+                    IAdornmentProvider.toHint(adornmentProvider));
+        }
+        @Override
+        public <T> T accessBackendLevelCache(Object key, Class<? extends T> clazz, IProvider<T> valueProvider) {
+            return backendLevelCache.getValue(key, clazz, valueProvider);
+        }
+        public IQueryRuntimeContext getRuntimeContext() {
+            return runtimeContext;
+        }
+        @Override
+        public Logger getLogger() {
+            return logger;
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/LocalSearchMatcher.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/LocalSearchMatcher.java
new file mode 100644
index 00000000..e31d7b5c
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/LocalSearchMatcher.java
@@ -0,0 +1,301 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Marton Bur, 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.viatra.runtime.localsearch.matcher;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.plan.IPlanDescriptor;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlan;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlanExecutor;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * @author Zoltan Ujhelyi
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+public final class LocalSearchMatcher implements ILocalSearchAdaptable {
+    private final List<SearchPlanExecutor> plan;
+    private final IPlanDescriptor planDescriptor;
+    private final List<ILocalSearchAdapter> adapters;
+    /**
+     * @since 2.0
+     */
+    public List<SearchPlanExecutor> getPlan() {
+        return plan;
+    }
+    
+    @Override
+    public List<ILocalSearchAdapter> getAdapters() {
+        return new ArrayList<>(adapters);
+    }
+    
+    private abstract class PlanExecutionIterator implements Iterator<Tuple> {
+        protected final Iterator<SearchPlanExecutor> planIterator;
+        
+        protected SearchPlanExecutor currentPlan;
+        protected MatchingFrame frame;
+        protected final Set<ITuple> matchSet;
+        protected VolatileModifiableMaskedTuple parametersOfFrameView; 
+        private boolean isNextMatchCalculated;
+        
+        public PlanExecutionIterator(final Iterator<SearchPlanExecutor> planIterator) {
+            this.planIterator = planIterator;
+            isNextMatchCalculated = false;
+            matchSet = new HashSet<>();
+        }
+        protected boolean selectNextPlan() {
+            if(currentPlan != null) {
+                currentPlan.removeAdapters(adapters);
+            }
+            boolean validPlanSelected = false;
+            
+            SearchPlanExecutor nextPlan = null;
+            
+            while (!validPlanSelected && planIterator.hasNext()) {
+                nextPlan = planIterator.next();
+                nextPlan.addAdapters(adapters);
+                nextPlan.resetPlan();
+                
+                validPlanSelected = initializeMatchingFrame(nextPlan);
+            }
+            
+            if (validPlanSelected) {
+                for (ILocalSearchAdapter adapter : adapters) {
+                    adapter.planChanged(Optional.ofNullable(currentPlan).map(SearchPlanExecutor::getSearchPlan),
+                            Optional.ofNullable(nextPlan).map(SearchPlanExecutor::getSearchPlan));
+                }
+                currentPlan = nextPlan;
+                return true;
+            } else {
+                currentPlan = null;
+                return false;
+            }
+        }
+        protected abstract boolean initializeMatchingFrame(SearchPlanExecutor nextPlan);
+        private boolean findNextNewMatchInCurrentPlan() {
+            boolean foundMatch = currentPlan.execute(frame);
+            while (foundMatch && matchSet.contains(parametersOfFrameView)) {
+                for (ILocalSearchAdapter adapter : adapters) {
+                    adapter.duplicateMatchFound(frame);
+                }
+                foundMatch = currentPlan.execute(frame);
+            }
+            return foundMatch;
+        }
+        
+        @Override
+        public boolean hasNext() {
+            if (isNextMatchCalculated) {
+                return true;
+            }
+            if (currentPlan == null) {
+                return false;
+            }
+            boolean foundMatch = findNextNewMatchInCurrentPlan();
+            
+            while (!foundMatch && planIterator.hasNext()) {
+                foundMatch = selectNextPlan() && findNextNewMatchInCurrentPlan();
+            }
+            if (!foundMatch) {
+                for (ILocalSearchAdapter adapter : adapters) {
+                    adapter.noMoreMatchesAvailable(LocalSearchMatcher.this);
+                }
+            }
+            isNextMatchCalculated = foundMatch;
+            return foundMatch;
+        }
+        @Override
+        public Tuple next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException("No more matches available.");
+            }
+            isNextMatchCalculated = false;
+            final Tuple match = parametersOfFrameView.toImmutable();
+            matchSet.add(match);
+            return match;
+        }
+    }
+    private class PlanExecutionIteratorWithArrayParameters extends PlanExecutionIterator {
+        
+        private final Object[] parameterValues;
+        
+        public PlanExecutionIteratorWithArrayParameters(Iterator<SearchPlanExecutor> planIterator, final Object[] parameterValues) {
+            super(planIterator);
+            this.parameterValues = parameterValues;
+            selectNextPlan();
+        }
+        
+        protected boolean initializeMatchingFrame(SearchPlanExecutor nextPlan) {
+            frame = new MatchingFrame(nextPlan.getVariableMapping().size());
+            parametersOfFrameView = new VolatileModifiableMaskedTuple(frame, nextPlan.getParameterMask());
+            for (int i = 0; i < parameterValues.length; i++) {
+                Object valueToSet = parameterValues[i];
+                if (valueToSet != null) {
+                    Object oldValue = parametersOfFrameView.get(i);
+                    if (oldValue == null) {
+                        parametersOfFrameView.set(i, valueToSet);
+                    } else if (!Objects.equals(valueToSet, oldValue)) {
+                        // Initial value setting resulted in contradictory values. This can happen because two parameter
+                        // variables have been unified but the call provides different values for the parameters.
+                        return false;
+                    }
+                    // If oldValue is not null but equal to newValue, the setting can be ignored
+                }
+            }
+            
+            return true;
+        }
+    }
+    private class PlanExecutionIteratorWithTupleParameters extends PlanExecutionIterator {
+        
+        private final ITuple parameterValues;
+        private final TupleMask parameterSeedMask;
+        
+        public PlanExecutionIteratorWithTupleParameters(Iterator<SearchPlanExecutor> planIterator, final TupleMask parameterSeedMask, final ITuple parameterValues) {
+            super(planIterator);
+            this.parameterSeedMask = parameterSeedMask;
+            this.parameterValues = parameterValues;
+            selectNextPlan();
+        }
+        
+        protected boolean initializeMatchingFrame(SearchPlanExecutor nextPlan) {
+            frame = new MatchingFrame(nextPlan.getVariableMapping().size());
+            parametersOfFrameView = new VolatileModifiableMaskedTuple(frame, nextPlan.getParameterMask());
+            for (int i = 0; i < parameterSeedMask.getSize(); i++) {
+                int index = parameterSeedMask.indices[i];
+                Object valueToSet = parameterValues.get(i);
+                if (valueToSet != null) {
+                    Object oldValue = parametersOfFrameView.get(index);
+                    if (oldValue == null) {
+                        parametersOfFrameView.set(index, valueToSet);
+                    } else if (!Objects.equals(valueToSet, oldValue)) {
+                        // Initial value setting resulted in contradictory values. This can happen because two parameter
+                        // variables have been unified but the call provides different values for the parameters.
+                        return false;
+                    }
+                    // If oldValue is not null but equal to newValue, the setting can be ignored
+                }
+            }
+            
+            return true;
+        }
+    }
+    /**
+     * @since 2.0
+     */
+    public LocalSearchMatcher(ISearchContext searchContext, IPlanDescriptor planDescriptor, List<SearchPlan> plan) {
+        Preconditions.checkArgument(planDescriptor != null, "Cannot initialize matcher with null query.");
+        this.planDescriptor = planDescriptor;
+        this.plan = plan.stream().map(p -> new SearchPlanExecutor(p, searchContext)).collect(Collectors.toList());
+        this.adapters = new LinkedList<>();
+    }
+    
+    @Override
+    public void addAdapter(ILocalSearchAdapter adapter) {
+        this.adapters.add(adapter);
+        adapter.adapterRegistered(this);
+    }
+    @Override
+    public void removeAdapter(ILocalSearchAdapter adapter) {
+        this.adapters.remove(adapter);
+        adapter.adapterUnregistered(this);
+    }
+    
+    @Override
+    public void addAdapters(List<ILocalSearchAdapter> adapters) {
+        this.adapters.addAll(adapters);
+        for (ILocalSearchAdapter adapter : adapters) {
+            adapter.adapterRegistered(this);
+        }
+    }
+    @Override
+    public void removeAdapters(List<ILocalSearchAdapter> adapters) {
+        this.adapters.removeAll(adapters);
+        for (ILocalSearchAdapter adapter : adapters) {
+            adapter.adapterUnregistered(this);
+        }
+    }
+    
+    public int getParameterCount() {
+        return planDescriptor.getQuery().getParameters().size();
+    }
+    private void matchingStarted() {
+        for (ILocalSearchAdapter adapter : adapters) {
+            adapter.patternMatchingStarted(this);
+        }
+    }
+    /**
+     * @since 2.0
+     */
+    public Stream<Tuple> streamMatches(final Object[] parameterValues) {
+        matchingStarted();
+        PlanExecutionIterator it = new PlanExecutionIteratorWithArrayParameters(plan.iterator(), parameterValues);
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it,
+                Spliterator.IMMUTABLE | Spliterator.NONNULL | Spliterator.DISTINCT), false);
+    }
+    
+    /**
+     * @since 2.0
+     */
+    public Stream<Tuple> streamMatches(TupleMask parameterSeedMask, final ITuple parameterValues) {
+        matchingStarted();
+        PlanExecutionIterator it = new PlanExecutionIteratorWithTupleParameters(
+                plan.iterator(), parameterSeedMask, parameterValues);
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it,
+                Spliterator.IMMUTABLE | Spliterator.NONNULL | Spliterator.DISTINCT), false);
+    }
+    
+    /**
+     * Returns the query specification this matcher used as source for the implementation
+     * @return never null
+     */
+    public PQuery getQuerySpecification() {
+        return planDescriptor.getQuery();
+    }
+    
+    
+    /**
+     * @since 1.5
+     */
+    public IPlanDescriptor getPlanDescriptor() {
+        return planDescriptor;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/MatcherReference.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/MatcherReference.java
new file mode 100644
index 00000000..6bf25192
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/MatcherReference.java
@@ -0,0 +1,97 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Zoltan Ujhelyi, Marton Bur, 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.viatra.runtime.localsearch.matcher;
+import java.util.Set;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+public class MatcherReference {
+    final PQuery query;
+    final Set<PParameter> adornment;
+    
+    /**
+     * Hints that can override the callee's own hints. This field is intentionally left out from hashCode and equals
+     */
+    final QueryEvaluationHint hints;
+        
+    /**
+     * @since 1.4
+     */
+    public MatcherReference(PQuery query, Set<PParameter> adornment, QueryEvaluationHint hints) {
+        super();
+        this.query = query;
+        this.adornment = adornment;
+        this.hints = hints;
+    }
+    
+    public MatcherReference(PQuery query, Set<PParameter> adornment){
+        this(query, adornment, null);
+    }
+    
+    public PQuery getQuery() {
+        return query;
+    }
+    public Set<PParameter> getAdornment() {
+        return adornment;
+    }
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        
+        result = prime * result + ((adornment == null) ? 0 : adornment.hashCode());
+        result = prime * result + ((query == null) ? 0 : query.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        MatcherReference other = (MatcherReference) obj;
+        if (adornment == null) {
+            if (other.adornment != null)
+                return false;
+        } else if (!adornment.equals(other.adornment))
+            return false;
+        if (query == null) {
+            if (other.query != null)
+                return false;
+        } else if (!query.equals(other.query))
+            return false;
+        return true;
+    }
+    
+    /**
+     * @return the hints to override the called reference's own hints with. Can be null.
+     * @since 1.4
+     */
+    public QueryEvaluationHint getHints() {
+        return hints;
+    }
+    
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(query.getFullyQualifiedName());
+        sb.append("(");
+        for(PParameter p : query.getParameters()){
+            sb.append(adornment.contains(p) ? "b" : "f");
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+    
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/AbstractLocalSearchResultProvider.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/AbstractLocalSearchResultProvider.java
new file mode 100644
index 00000000..1ae24d2d
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/AbstractLocalSearchResultProvider.java
@@ -0,0 +1,532 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.matcher.integration;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import tools.refinery.viatra.runtime.localsearch.exceptions.LocalSearchException;
+import tools.refinery.viatra.runtime.localsearch.matcher.CallWithAdornment;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.matcher.LocalSearchMatcher;
+import tools.refinery.viatra.runtime.localsearch.matcher.MatcherReference;
+import tools.refinery.viatra.runtime.localsearch.plan.IPlanDescriptor;
+import tools.refinery.viatra.runtime.localsearch.plan.IPlanProvider;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlan;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlanForBody;
+import tools.refinery.viatra.runtime.localsearch.planner.compiler.IOperationCompiler;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.IMatcherCapability;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackend;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.backend.IUpdateable;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.backend.QueryHintOption;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.context.IndexingService;
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.planning.helpers.FunctionalDependencyHelper;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQueries;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IFlattenCallPredicate;
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Accuracy;
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public abstract class AbstractLocalSearchResultProvider implements IQueryResultProvider {
+    
+    protected final LocalSearchBackend backend;
+    protected final IQueryBackendContext backendContext;
+    protected final IQueryRuntimeContext runtimeContext;
+    protected final PQuery query;
+    protected final QueryEvaluationHint userHints;
+    protected final Map<PQuery, LocalSearchHints> hintCache = new HashMap<>();
+    protected final IPlanProvider planProvider;
+    private static final String PLAN_CACHE_KEY = AbstractLocalSearchResultProvider.class.getName() + "#planCache"; 
+    private final Map<MatcherReference, IPlanDescriptor> planCache;
+    protected final ISearchContext searchContext;
+    /**
+     * @since 2.1
+     */
+    protected ResultProviderRequestor resultProviderRequestor;
+    /**
+     * @since 1.5
+     */
+    @SuppressWarnings({ "unchecked"})
+    public AbstractLocalSearchResultProvider(LocalSearchBackend backend, IQueryBackendContext context, PQuery query,
+            IPlanProvider planProvider, QueryEvaluationHint userHints) {
+        this.backend = backend;
+        this.backendContext = context;
+        this.query = query;
+        this.planProvider = planProvider;
+        this.userHints = userHints;
+        this.runtimeContext = context.getRuntimeContext();
+        this.resultProviderRequestor = backend.getResultProviderRequestor(query, userHints);
+        this.searchContext = new ISearchContext.SearchContext(backendContext, backend.getCache(), resultProviderRequestor);
+        this.planCache = backend.getCache().getValue(PLAN_CACHE_KEY, Map.class, HashMap::new);
+    }
+    
+    protected abstract IOperationCompiler getOperationCompiler(IQueryBackendContext backendContext, LocalSearchHints configuration);
+    
+    private IQueryRuntimeContext getRuntimeContext() {
+        return backend.getRuntimeContext();
+    }
+    private LocalSearchMatcher createMatcher(IPlanDescriptor plan, final ISearchContext searchContext) {
+        List<SearchPlan> executors = plan.getPlan().stream()
+                .map(input -> new SearchPlan(input.getBody(), input.getCompiledOperations(), input.calculateParameterMask(),
+                        input.getVariableKeys()))
+                .collect(Collectors.toList());
+        return new LocalSearchMatcher(searchContext, plan, executors);
+    }
+    private IPlanDescriptor getOrCreatePlan(MatcherReference key, IQueryBackendContext backendContext, IOperationCompiler compiler, LocalSearchHints configuration, IPlanProvider planProvider) {
+        if (planCache.containsKey(key)){
+            return planCache.get(key);
+        } else {
+            IPlanDescriptor plan = planProvider.getPlan(backendContext, compiler, 
+                    resultProviderRequestor, configuration, key);
+            planCache.put(key, plan);
+            return plan;
+        }
+    }
+    
+    private IPlanDescriptor getOrCreatePlan(MatcherReference key, IPlanProvider planProvider) {
+        if (planCache.containsKey(key)){
+            return planCache.get(key);
+        } else {
+            LocalSearchHints configuration = overrideDefaultHints(key.getQuery());
+            IOperationCompiler compiler = getOperationCompiler(backendContext, configuration);
+            IPlanDescriptor plan = planProvider.getPlan(backendContext, compiler, 
+                    resultProviderRequestor, configuration, key);
+            planCache.put(key, plan);
+            return plan;
+        }
+    }
+    
+    private LocalSearchHints overrideDefaultHints(PQuery pQuery) {
+        if (hintCache.containsKey(pQuery)) {
+            return hintCache.get(pQuery);
+        } else {
+            LocalSearchHints hint = LocalSearchHints.getDefaultOverriddenBy(
+                    computeOverridingHints(pQuery));
+            hintCache.put(pQuery, hint);
+            return hint;
+        }
+    }
+    /** 
+     * Combine with {@link QueryHintOption#getValueOrDefault(QueryEvaluationHint)} to access 
+     * hint settings not covered by {@link LocalSearchHints} 
+     */
+    private QueryEvaluationHint computeOverridingHints(PQuery pQuery) {
+        return backendContext.getHintProvider().getQueryEvaluationHint(pQuery).overrideBy(userHints);
+    }
+    /**
+     * Prepare this result provider. This phase is separated from the constructor to allow the backend to cache its instance before
+     * requesting preparation for its dependencies.
+     * @since 1.5
+     */
+    public void prepare() {
+        try {
+            runtimeContext.coalesceTraversals(() -> {
+                LocalSearchHints configuration = overrideDefaultHints(query);
+                if (configuration.isUseBase()) {
+                    indexInitializationBeforePlanning();
+                }
+                prepareDirectDependencies();
+                runtimeContext.executeAfterTraversal(AbstractLocalSearchResultProvider.this::preparePlansForExpectedAdornments);
+                return null;
+            });
+        } catch (InvocationTargetException e) {
+            throw new QueryProcessingException("Error while building required indexes: {1}", new String[]{e.getTargetException().getMessage()}, "Error while building required indexes.", query, e);
+        }
+    }
+    protected void preparePlansForExpectedAdornments() {
+        // Plan for possible adornments
+        for (Set<PParameter> adornment : overrideDefaultHints(query).getAdornmentProvider().getAdornments(query)) {
+            MatcherReference reference = new MatcherReference(query, adornment, userHints);
+            LocalSearchHints configuration = overrideDefaultHints(query);
+            IOperationCompiler compiler = getOperationCompiler(backendContext, configuration);
+            IPlanDescriptor plan = getOrCreatePlan(reference, backendContext, compiler, configuration, planProvider);
+            // Index keys
+            try {
+                if (configuration.isUseBase()) {
+                    indexKeys(plan.getIteratedKeys());
+                }
+            } catch (InvocationTargetException e) {
+                throw new QueryProcessingException(e.getMessage(), null, e.getMessage(), query, e);
+            }
+            //Prepare dependencies
+            for(SearchPlanForBody body: plan.getPlan()){
+                for(CallWithAdornment dependency : body.getDependencies()){
+                    searchContext.getMatcher(dependency);
+                }
+            }
+        }
+    }
+    protected void prepareDirectDependencies() {
+        // Do not prepare for any adornment at this point
+        IAdornmentProvider adornmentProvider = input -> Collections.emptySet();
+        QueryEvaluationHint adornmentHint = IAdornmentProvider.toHint(adornmentProvider);
+        for(IQueryReference call : getDirectDependencies()){
+            resultProviderRequestor.requestResultProvider(call, adornmentHint);
+        }
+    }
+    /**
+     * This method is called before planning start to allow indexing. It is important to note that this method is called
+     * inside a coalesceTraversals block, meaning (1) it is safe to add multiple registration requests as necessary, but
+     * (2) no value or statistics is available from the index.
+     * 
+     * @throws ViatraQueryRuntimeException
+     */
+    protected void indexInitializationBeforePlanning() {
+        // By default, no indexing is necessary
+    }
+    
+    /**
+     * Collects and indexes all types _directly_ referred by the PQuery {@link #query}. Types indirect
+     * @param requiredIndexingServices
+     */
+    protected void indexReferredTypesOfQuery(PQuery query, IndexingService requiredIndexingServices) {
+        PQueries.directlyRequiredTypesOfQuery(query, true /*only enumerables are considered for indexing */).forEach(
+                inputKey -> runtimeContext.ensureIndexed(inputKey, requiredIndexingServices)
+        );
+    }
+    
+    private Set<IQueryReference> getDirectDependencies() {
+        IFlattenCallPredicate flattenPredicate = overrideDefaultHints(query).getFlattenCallPredicate();
+        Queue<PQuery> queue = new LinkedList<>();
+        Set<PQuery> visited = new HashSet<>();
+        Set<IQueryReference> result = new HashSet<>();
+        queue.add(query);
+        
+        while(!queue.isEmpty()){
+            PQuery next = queue.poll();
+            visited.add(next);
+            for(PBody body : next.getDisjunctBodies().getBodies()){
+                for (IQueryReference call : body.getConstraintsOfType(IQueryReference.class)) {
+                    if (call instanceof PositivePatternCall && 
+                            flattenPredicate.shouldFlatten((PositivePatternCall) call)) 
+                    {
+                        PQuery dep = ((PositivePatternCall) call).getReferredQuery();
+                        if (!visited.contains(dep)){
+                            queue.add(dep);
+                        }
+                    } else {
+                        result.add(call);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    private LocalSearchMatcher initializeMatcher(Object[] parameters) {
+        return newLocalSearchMatcher(parameters);
+    }
+    
+    private LocalSearchMatcher initializeMatcher(TupleMask parameterSeedMask) {
+        return newLocalSearchMatcher(parameterSeedMask.transformUnique(query.getParameters()));
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public LocalSearchMatcher newLocalSearchMatcher(ITuple parameters) {
+        final Set<PParameter> adornment = new HashSet<>();
+        for (int i = 0; i < parameters.getSize(); i++) {
+            if (parameters.get(i) != null) {
+                adornment.add(query.getParameters().get(i));
+            }
+        }
+        
+        return newLocalSearchMatcher(adornment);
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public LocalSearchMatcher newLocalSearchMatcher(Object[] parameters) {
+        final Set<PParameter> adornment = new HashSet<>();
+        for (int i = 0; i < parameters.length; i++) {
+            if (parameters[i] != null) {
+                adornment.add(query.getParameters().get(i));
+            }
+        }
+    
+        return newLocalSearchMatcher(adornment);
+    }
+    private LocalSearchMatcher newLocalSearchMatcher(final Set<PParameter> adornment) {
+        final MatcherReference reference = new MatcherReference(query, adornment, userHints);
+        
+        IPlanDescriptor plan = getOrCreatePlan(reference, planProvider);
+        if (overrideDefaultHints(reference.getQuery()).isUseBase()){
+            try {
+                indexKeys(plan.getIteratedKeys());
+            } catch (InvocationTargetException e) {
+                throw new LocalSearchException("Could not index keys", e);
+            }
+        }
+        
+        LocalSearchMatcher matcher = createMatcher(plan, searchContext);
+        matcher.addAdapters(backend.getAdapters());
+        return matcher;
+    }
+    private void indexKeys(final Iterable<IInputKey> keys) throws InvocationTargetException {
+        final IQueryRuntimeContext qrc = getRuntimeContext();
+        qrc.coalesceTraversals(new Callable<Void>() {
+    
+            @Override
+            public Void call() throws Exception {
+                for(IInputKey key : keys){
+                    if (key.isEnumerable()) {
+                        qrc.ensureIndexed(key, IndexingService.INSTANCES);
+                    }
+                }
+                return null;
+            }
+        });
+    }
+    @Override
+    public boolean hasMatch(Object[] parameters) {
+        final LocalSearchMatcher matcher = initializeMatcher(parameters);
+        return matcher.streamMatches(parameters).findAny().isPresent();
+    }
+    @Override
+    public boolean hasMatch(TupleMask parameterSeedMask, ITuple parameters) {
+        final LocalSearchMatcher matcher = initializeMatcher(parameterSeedMask);
+        return matcher.streamMatches(parameterSeedMask, parameters).findAny().isPresent();
+    }
+    @Override
+    public Optional<Tuple> getOneArbitraryMatch(Object[] parameters) {
+        final LocalSearchMatcher matcher = initializeMatcher(parameters);
+        return matcher.streamMatches(parameters).findAny();
+    }
+    @Override
+    public Optional<Tuple> getOneArbitraryMatch(TupleMask parameterSeedMask, ITuple parameters) {
+        final LocalSearchMatcher matcher = initializeMatcher(parameterSeedMask);
+        return matcher.streamMatches(parameterSeedMask, parameters).findAny();
+    }
+    @Override
+    public int countMatches(Object[] parameters) {
+        final LocalSearchMatcher matcher = initializeMatcher(parameters);
+        // Count returns long; casting to int - in case of integer overflow casting will throw the exception
+        return (int) matcher.streamMatches(parameters).count();
+    }
+    
+    @Override
+    public int countMatches(TupleMask parameterSeedMask, ITuple parameters) {
+        final LocalSearchMatcher matcher = initializeMatcher(parameterSeedMask);
+        // Count returns long; casting to int - in case of integer overflow casting will throw the exception
+        return (int) matcher.streamMatches(parameterSeedMask, parameters).count();
+    }
+        
+    private static final double ESTIMATE_CEILING = Long.MAX_VALUE / 16.0;
+    
+    @Override
+    public Optional<Long> estimateCardinality(TupleMask groupMask, Accuracy requiredAccuracy) {
+        if (Accuracy.BEST_UPPER_BOUND.atLeastAsPreciseAs(requiredAccuracy)) { // approximate using parameter types
+            final List<PParameter> parameters = query.getParameters();
+            final Map<Set<Integer>, Set<Integer>> dependencies = backendContext.getQueryAnalyzer()
+                    .getProjectedFunctionalDependencies(query, false);
+            
+            List<Integer> projectionIndices = groupMask.getIndicesAsList();
+            
+            return estimateParameterCombinations(requiredAccuracy, parameters, dependencies, 
+                    projectionIndices,
+                    Collections.emptySet() /* No parameters with fixed value */).map(Double::longValue);
+        }        
+        else return Optional.empty();
+    }
+    
+    @Override
+    public Optional<Double> estimateAverageBucketSize(TupleMask groupMask, Accuracy requiredAccuracy) {
+        if (Accuracy.BEST_UPPER_BOUND.atLeastAsPreciseAs(requiredAccuracy)) { // approximate using parameter types            
+            final List<PParameter> parameters = query.getParameters();
+            final Map<Set<Integer>, Set<Integer>> dependencies = backendContext.getQueryAnalyzer()
+                    .getProjectedFunctionalDependencies(query, false);
+            
+            // all parameters used for the estimation - determinized order
+            final List<Integer> allParameterIndices = 
+                    IntStream.range(0, parameters.size()).boxed().collect(Collectors.toList());
+            
+            // some free parameters are functionally determined by bound parameters
+            final Set<Integer> boundOrImplied = FunctionalDependencyHelper.closureOf(groupMask.getIndicesAsList(),
+                    dependencies);
+            
+            return estimateParameterCombinations(requiredAccuracy, parameters, dependencies, 
+                    allParameterIndices,
+                    boundOrImplied);
+        }
+        else return Optional.empty();
+    }
+    
+    /**
+     * @since 2.1
+     * @noreference This method is not intended to be referenced by clients.
+     */
+    public double estimateCost(TupleMask inputBindingMask) {
+        // TODO this is currently an abstract cost, not really a branching factor
+        
+        HashSet<PParameter> adornment = new HashSet<>(inputBindingMask.transform(query.getParameters()));
+        final MatcherReference reference = new MatcherReference(query, adornment, userHints);
+        IPlanDescriptor plan = getOrCreatePlan(reference, planProvider);
+        return plan.getPlan().stream().mapToDouble(SearchPlanForBody::getCost).sum();
+    }
+    /**
+     * Approximates using parameter types
+     */
+    private Optional<Double> estimateParameterCombinations(
+            Accuracy requiredAccuracy, 
+            final List<PParameter> parameters,
+            final Map<Set<Integer>, Set<Integer>> functionalDependencies,
+            final Collection<Integer> parameterIndicesToEstimate, 
+            final Set<Integer> otherDeterminingIndices) 
+    {
+        // keep order deterministic
+        LinkedHashSet<Integer> freeParameterIndices = new LinkedHashSet<>(parameterIndicesToEstimate);
+        
+        // determining indices are bound
+        freeParameterIndices.removeAll(otherDeterminingIndices);
+        
+        // some free parameters are functionally determined by other free parameters
+        for (Integer candidateForRemoval : new ArrayList<>(freeParameterIndices)) {
+            List<Integer> others = Stream.concat(
+                    otherDeterminingIndices.stream(), 
+                    freeParameterIndices.stream().filter(index -> !Objects.equals(index, candidateForRemoval))
+            ).collect(Collectors.toList());
+            Set<Integer> othersClosure = FunctionalDependencyHelper.closureOf(others, functionalDependencies);
+            if (othersClosure.contains(candidateForRemoval)) { 
+                // other parameters functionally determine this mone, does not count towards estimate
+                freeParameterIndices.remove(candidateForRemoval);
+            }
+        }
+        
+        
+        Optional<Double> result = Optional.of(1.0);
+        // TODO this is currently works with declared types only. For better results, information from
+        // the Type inferrer should be included in the PSystem
+        for (int i = 0; (i < parameters.size()); i++) {
+            final IInputKey type = parameters.get(i).getDeclaredUnaryType();
+            if (freeParameterIndices.contains(i) && type != null) {
+                result = result.flatMap(accumulator ->
+                runtimeContext.estimateCardinality(type, TupleMask.identity(1), requiredAccuracy).map(multiplier ->
+                    Math.min(accumulator * multiplier, ESTIMATE_CEILING /* avoid overflow */)
+                ));                    
+            }
+        }
+        // TODO better approximate cardinality based on plan, branching factors, etc.
+        return result;
+    }
+    
+    @Override
+    public Stream<Tuple> getAllMatches(Object[] parameters) {
+        final LocalSearchMatcher matcher = initializeMatcher(parameters);
+        return matcher.streamMatches(parameters);
+    }
+    
+    @Override
+    public Stream<Tuple> getAllMatches(TupleMask parameterSeedMask, ITuple parameters) {
+        final LocalSearchMatcher matcher = initializeMatcher(parameterSeedMask);
+        return matcher.streamMatches(parameterSeedMask, parameters);
+    }
+    @Override
+    public IQueryBackend getQueryBackend() {
+        return backend;
+    }
+    @Override
+    public void addUpdateListener(IUpdateable listener, Object listenerTag, boolean fireNow) {
+        // throw new UnsupportedOperationException(UPDATE_LISTENER_NOT_SUPPORTED);
+    }
+    @Override
+    public void removeUpdateListener(Object listenerTag) {
+        // throw new UnsupportedOperationException(UPDATE_LISTENER_NOT_SUPPORTED);
+    }
+    /**
+     * @since 1.4
+     */
+    public IMatcherCapability getCapabilites() {
+        LocalSearchHints configuration = overrideDefaultHints(query);
+        return configuration;
+    }
+    
+    /**
+     * Forgets all stored plans in this result provider. If no plans are stored, nothing happens.
+     * 
+     * @since 2.0
+     * @noreference This method is not intended to be referenced by clients; it should only used by {@link LocalSearchBackend}.
+     */
+    public void forgetAllPlans() {
+        planCache.clear();
+    }
+    
+    /**
+     * Returns a search plan for a given adornment if exists
+     * 
+     * @return a search plan for the pattern with the given adornment, or null if none exists
+     * @since 2.0
+     * @noreference This method is not intended to be referenced by clients; it should only used by {@link LocalSearchBackend}.
+     */
+    public IPlanDescriptor getSearchPlan(Set<PParameter> adornment) {
+        return planCache.get(new MatcherReference(query, adornment));
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/AllValidAdornments.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/AllValidAdornments.java
new file mode 100644
index 00000000..f801163e
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/AllValidAdornments.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs 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.viatra.runtime.localsearch.matcher.integration;
+import java.util.Set;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameterDirection;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQueries;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.util.Sets;
+/**
+ * This implementation calculates all valid adornments for the given query, respecting the parameter direction constraints.
+ * 
+ * @author Grill Balázs
+ * @since 1.5
+ */
+public class AllValidAdornments implements IAdornmentProvider {
+    @Override
+    public Iterable<Set<PParameter>> getAdornments(PQuery query) {
+        final Set<PParameter> ins = query.getParameters().stream().filter(PQueries.parameterDirectionPredicate(PParameterDirection.IN)).collect(Collectors.toSet()); 
+        Set<PParameter> inouts = query.getParameters().stream().filter(PQueries.parameterDirectionPredicate(PParameterDirection.INOUT)).collect(Collectors.toSet()); 
+        Set<? extends Set<PParameter>> possibleInouts = Sets.powerSet(inouts);
+        return possibleInouts.stream().map(input -> Sets.union(ins, input)).collect(Collectors.toSet());
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/DontFlattenDisjunctive.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/DontFlattenDisjunctive.java
new file mode 100644
index 00000000..bf1b61b5
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/DontFlattenDisjunctive.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, 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.viatra.runtime.localsearch.matcher.integration;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IFlattenCallPredicate;
+/**
+ * Forbids flattening of patterns that have more than one body.
+ * 
+ * @since 2.1
+ * @author Gabor Bergmann
+ *
+ */
+public class DontFlattenDisjunctive implements IFlattenCallPredicate {
+    @Override
+    public boolean shouldFlatten(PositivePatternCall positivePatternCall) {
+        return 1 >= positivePatternCall.getReferredQuery().getDisjunctBodies().getBodies().size();
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/DontFlattenIncrementalPredicate.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/DontFlattenIncrementalPredicate.java
new file mode 100644
index 00000000..1b918528
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/DontFlattenIncrementalPredicate.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs 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.viatra.runtime.localsearch.matcher.integration;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint.BackendRequirement;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IFlattenCallPredicate;
+/**
+ * This implementation forbids flattening of patterns marked to be executed with a caching / incremental backend. 
+ * This makes is possible for the user to configure hybrid matching via using 
+ * the 'search' and 'incremental keywords in the pattern definition file.
+ * 
+ * @since 1.5
+ *
+ */
+public class DontFlattenIncrementalPredicate implements IFlattenCallPredicate {
+    @Override
+    public boolean shouldFlatten(PositivePatternCall positivePatternCall) {
+        QueryEvaluationHint evaluationHints = positivePatternCall.getReferredQuery().getEvaluationHints();
+        if (evaluationHints == null) return true;
+        
+        BackendRequirement backendRequirementType = evaluationHints.getQueryBackendRequirementType();
+        switch(backendRequirementType) {
+        case DEFAULT_CACHING:
+            return false;
+        case SPECIFIC:
+            return !evaluationHints.getQueryBackendFactory().isCaching();
+        case UNSPECIFIED:
+        case DEFAULT_SEARCH:
+        default:
+            return true;
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/GenericLocalSearchResultProvider.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/GenericLocalSearchResultProvider.java
new file mode 100644
index 00000000..ed6c1e5f
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/GenericLocalSearchResultProvider.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Marton Bur, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.matcher.integration;
+import tools.refinery.viatra.runtime.localsearch.plan.IPlanProvider;
+import tools.refinery.viatra.runtime.localsearch.planner.compiler.GenericOperationCompiler;
+import tools.refinery.viatra.runtime.localsearch.planner.compiler.IOperationCompiler;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.context.IndexingService;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public class GenericLocalSearchResultProvider extends AbstractLocalSearchResultProvider {
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public GenericLocalSearchResultProvider(LocalSearchBackend backend, IQueryBackendContext context, PQuery query,
+            IPlanProvider planProvider, QueryEvaluationHint userHints) {
+        super(backend, context, query, planProvider, userHints);
+    }
+    @Override
+    protected void indexInitializationBeforePlanning() {
+        super.indexInitializationBeforePlanning();
+        
+        indexReferredTypesOfQuery(query, IndexingService.INSTANCES);
+        indexReferredTypesOfQuery(query, IndexingService.STATISTICS);
+    }
+    @Override
+    protected IOperationCompiler getOperationCompiler(IQueryBackendContext backendContext,
+            LocalSearchHints configuration) {
+        return new GenericOperationCompiler(runtimeContext);
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/IAdornmentProvider.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/IAdornmentProvider.java
new file mode 100644
index 00000000..86058be0
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/IAdornmentProvider.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs 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.viatra.runtime.localsearch.matcher.integration;
+import java.util.Collections;
+import java.util.Set;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint.BackendRequirement;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * An adornment provider is used to define the adornments the pattern matcher should prepare for.
+ *  
+ * <p>A default implementation is available in {@link AllValidAdornments} that describes all 
+ * adornments fulfilling the parameter direction declarations; 
+ * another default option (with better performance but restricted applicability) is {@link LazyPlanningAdornments}.
+ * 
+ * <br><br>
+ * 
+ * Users may implement this interface to limit the number of prepared plans based on some runtime information:
+ * 
+ * <pre>
+ * class SomeAdornments{
+ * 
+ *     public Iterable&lt;Set&lt;{@link PParameter}>> getAdornments({@link PQuery} query){
+ *         if (SomeGeneratedQuerySpecification.instance().getInternalQueryRepresentation().equals(query)){
+ *             return Collections.singleton(Sets.filter(Sets.newHashSet(query.getParameters()), new Predicate<PParameter>() {
+ *
+ *                  &#64;Override
+ *                  public boolean apply(PParameter input) {
+ *                      // Decide whether this particular parameter will be bound
+ *                      return false;
+ *                  }
+ *              }));
+ *         }
+ *         // Returning an empty iterable is safe for unknown queries
+ *         return Collections.emptySet();
+ *     }
+ * 
+ * }
+ * </pre>
+ * 
+ * @author Grill Balázs
+ * @since 1.5
+ *
+ */
+public interface IAdornmentProvider {
+    /**
+     * The bound parameter sets
+     */
+    public Iterable<Set<PParameter>> getAdornments(PQuery query);
+    
+    /**
+     * @return a simple hint that only overrides the adornment provider
+     * @since 2.1
+     */
+    public static QueryEvaluationHint toHint(IAdornmentProvider adornmentProvider) {
+        return new QueryEvaluationHint(
+                Collections.singletonMap(LocalSearchHintOptions.ADORNMENT_PROVIDER, adornmentProvider), 
+                BackendRequirement.UNSPECIFIED);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LazyPlanningAdornments.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LazyPlanningAdornments.java
new file mode 100644
index 00000000..30b3689f
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LazyPlanningAdornments.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, 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.viatra.runtime.localsearch.matcher.integration;
+import java.util.Collections;
+import java.util.Set;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * This adornment provider does not trigger the preparation of any plans. 
+ * Actual query plans will be computed on demand, when the first actual match request is made with a given adornment.
+ * 
+ * <p> Caution: this is a safe default adornment provider for {@link GenericLocalSearchResultProvider} only; 
+ * do not use for the EMF-specific LS backend. 
+ * 
+ * <p> The benefits is in execution time: query planning costs for adornments are postponed until first usage 
+ * or even entirely avoided (when adornment is never used in practice).  
+ * However, query evaluation time may become less predictable, as the first matcher call (with a given adornment) 
+ * will include the planning cost. 
+ * For benchmarking or other purposes where this is not desirable, use an adornment provider that demands plan precomputation for all necessary adornments. 
+ * 
+ * @author Gabor Bergmann
+ * @since 2.1
+ *
+ */
+public class LazyPlanningAdornments implements IAdornmentProvider {
+    @Override
+    public Iterable<Set<PParameter>> getAdornments(PQuery query) {
+        return Collections.emptySet();
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchBackend.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchBackend.java
new file mode 100644
index 00000000..ae51e2b0
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchBackend.java
@@ -0,0 +1,259 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Marton Bur, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.matcher.integration;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+import tools.refinery.viatra.runtime.localsearch.exceptions.LocalSearchException;
+import tools.refinery.viatra.runtime.localsearch.matcher.ILocalSearchAdapter;
+import tools.refinery.viatra.runtime.localsearch.plan.IPlanDescriptor;
+import tools.refinery.viatra.runtime.localsearch.plan.IPlanProvider;
+import tools.refinery.viatra.runtime.localsearch.plan.SimplePlanProvider;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.IMatcherCapability;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackend;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendHintProvider;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.psystem.analysis.QueryAnalyzer;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.ICache;
+import tools.refinery.viatra.runtime.matchers.util.PurgableCache;
+/**
+ * @author Marton Bur, Zoltan Ujhelyi
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public abstract class LocalSearchBackend implements IQueryBackend {
+    IQueryBackendContext context;
+    IPlanProvider planProvider;
+    private final Set<ILocalSearchAdapter> adapters = new HashSet<>();
+    
+    private final PurgableCache generalCache;
+    
+    private final Map<PQuery, List<AbstractLocalSearchResultProvider>> resultProviderCache = CollectionsFactory.createMap();
+    
+    
+    /**
+     * @since 1.5
+     */
+    public LocalSearchBackend(IQueryBackendContext context) {
+        super();
+        this.context = context;
+        this.generalCache = new PurgableCache();
+        this.planProvider = new SimplePlanProvider(context.getLogger());
+    }
+    @Override
+    public void flushUpdates() {
+        
+    }
+    
+    @Override
+    public IQueryResultProvider getResultProvider(PQuery query) {
+        return getResultProvider(query, null);
+    }
+    
+    /**
+     * @since 1.4
+     */
+    @Override
+    public IQueryResultProvider getResultProvider(PQuery query, QueryEvaluationHint hints) {
+        
+        final QueryEvaluationHint callHints = getHintProvider().getQueryEvaluationHint(query).overrideBy(hints);
+        IMatcherCapability requestedCapability = context.getRequiredMatcherCapability(query, callHints);
+        for(AbstractLocalSearchResultProvider existingResultProvider : resultProviderCache.getOrDefault(query, Collections.emptyList())){
+            if (requestedCapability.canBeSubstitute(existingResultProvider.getCapabilites())){
+                return existingResultProvider;
+            }
+        }
+        
+        AbstractLocalSearchResultProvider resultProvider = initializeResultProvider(query, hints);
+        resultProviderCache.computeIfAbsent(query, k->new ArrayList<>()).add(resultProvider);
+        resultProvider.prepare();
+        return resultProvider;
+    }
+    
+    /**
+     * Returns a requestor that this backend uses while processing pattern calls <i>from</i> this query.
+     * @noreference This method is not intended to be referenced by clients.
+     * @since 2.1
+     */
+    public ResultProviderRequestor getResultProviderRequestor(PQuery query, QueryEvaluationHint userHints) {
+        QueryEvaluationHint hintOnQuery = 
+                context.getHintProvider().getQueryEvaluationHint(query).overrideBy(userHints);
+        LocalSearchHints defaultsApplied = LocalSearchHints.getDefaultOverriddenBy(hintOnQuery);
+        return new ResultProviderRequestor(this, 
+                context.getResultProviderAccess(), 
+                context.getHintProvider(), 
+                defaultsApplied.getCallDelegationStrategy(), 
+                userHints, 
+                /* no global overrides */ null);
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException 
+     * @since 1.7
+     */
+    protected abstract AbstractLocalSearchResultProvider initializeResultProvider(PQuery query, QueryEvaluationHint hints);
+    
+    @Override
+    public void dispose() {  
+        resultProviderCache.clear();
+        generalCache.purge();
+    }
+    @Override
+    public boolean isCaching() {
+        return false;
+    }
+    /**
+     * @since 2.0
+     */
+    @Override
+    public AbstractLocalSearchResultProvider peekExistingResultProvider(PQuery query) {
+        return resultProviderCache.getOrDefault(query, Collections.emptyList()).stream().findAny().orElse(null);
+    }
+    /**
+     * @since 1.4
+     */
+    public IQueryRuntimeContext getRuntimeContext() {
+        return context.getRuntimeContext();
+    }
+    
+    
+    /**
+     * @since 1.5
+     */
+    public QueryAnalyzer getQueryAnalyzer() {
+        return context.getQueryAnalyzer();
+    }
+    /**
+     * @since 1.4
+     */
+    public IQueryBackendHintProvider getHintProvider() {
+        return context.getHintProvider();
+    }
+    
+    /**
+     * @since 1.5
+     */
+    public void addAdapter(ILocalSearchAdapter adapter){
+        adapters.add(adapter);
+    }
+    
+    /**
+     * @since 1.5
+     */
+    public void removeAdapter(ILocalSearchAdapter adapter){
+        adapters.remove(adapter);
+    }
+    
+    /**
+     * Return a copy of the current adapters
+     * @since 1.7
+     */
+    public List<ILocalSearchAdapter> getAdapters() {
+        return new ArrayList<>(adapters);
+    }
+    
+    /**
+     * @since 1.5
+     */
+    public IQueryBackendContext getBackendContext() {
+        return context;
+    }
+    
+    /**
+     * Returns the internal cache of the backend
+     * @since 1.7
+     * @noreference This method is not intended to be referenced by clients.
+     */
+    public ICache getCache() {
+        return generalCache;
+    }
+    
+    /**
+     * Updates the previously stored search plans for one or more given queries, computing a new set of plans if
+     * necessary. The new plans created are the same that would be created by executing prepare on the given query
+     * definitions.
+     * 
+     * @since 2.0
+     */
+    public void recomputePlans(PQuery... queries) {
+        recomputePlans(Arrays.stream(queries).flatMap(query -> resultProviderCache.getOrDefault(query, Collections.emptyList()).stream()));
+    }
+    
+    /**
+     * Updates the previously stored search plans for one or more given queries, computing a new set of plans if
+     * necessary The new plans created are the same that would be created by executing prepare on the given query
+     * definitions.
+     * 
+     * @since 2.0
+     */
+    public void recomputePlans(Collection<PQuery> queries) {
+        recomputePlans(queries.stream().flatMap(query -> resultProviderCache.getOrDefault(query, Collections.emptyList()).stream()));
+    }
+    
+    /**
+     * Updates the previously stored search plans for one or more given queries, computing a new set of plans if
+     * necessary The new plans created are the same that would be created by executing prepare on the given query
+     * definitions.
+     * 
+     * @since 2.0
+     */
+    public void recomputePlans() {
+        recomputePlans(resultProviderCache.values().stream().flatMap(List::stream));
+    }
+    
+    private void recomputePlans(Stream<AbstractLocalSearchResultProvider> resultProviders) {
+        try {
+            context.getRuntimeContext().coalesceTraversals(() -> {
+                resultProviders.forEach(resultProvider -> {
+                    resultProvider.forgetAllPlans();
+                    resultProvider.prepare();
+                });
+                return null;
+            });
+        } catch (InvocationTargetException e) {
+            throw new LocalSearchException("Error while rebuilding plans: " + e.getMessage(), e);
+        }
+    }
+    
+    /**
+     * Returns a search plan for a given query and adornment if such plan is already calculated.
+     * 
+     * @return a previously calculated search plan for the given query and adornment, or null if no such plan exists
+     * @since 2.0
+     */
+    public IPlanDescriptor getSearchPlan(PQuery query, Set<PParameter> adornment) {
+        final AbstractLocalSearchResultProvider resultProvider = peekExistingResultProvider(query);
+        return (resultProvider == null) ? null : resultProvider.getSearchPlan(adornment);
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchGenericBackendFactory.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchGenericBackendFactory.java
new file mode 100644
index 00000000..1dd08f98
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchGenericBackendFactory.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Marton Bur, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.matcher.integration;
+import tools.refinery.viatra.runtime.matchers.backend.IMatcherCapability;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackend;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactory;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * @author Marton Bur, Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public enum LocalSearchGenericBackendFactory implements IQueryBackendFactory {
+    
+    INSTANCE;
+    
+    /**
+     * @since 1.5
+     */
+    @Override
+    public IQueryBackend create(IQueryBackendContext context) {
+        return new LocalSearchBackend(context) {
+            
+            @Override
+            protected AbstractLocalSearchResultProvider initializeResultProvider(PQuery query, QueryEvaluationHint hints) {
+                return new GenericLocalSearchResultProvider(this, context, query, planProvider, hints);
+            }
+            
+            @Override
+            public IQueryBackendFactory getFactory() {
+                return INSTANCE;
+            }
+            
+        };
+    }
+    
+    @Override
+    public Class<? extends IQueryBackend> getBackendClass() {
+        return LocalSearchBackend.class;
+    }
+    /**
+     * @since 1.4
+     */
+    @Override
+    public IMatcherCapability calculateRequiredCapability(PQuery query, QueryEvaluationHint hint) {
+        return LocalSearchHints.parse(hint);
+    }
+    @Override
+    public boolean isCaching() {
+        return false;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchGenericBackendFactoryProvider.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchGenericBackendFactoryProvider.java
new file mode 100644
index 00000000..ea422d91
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchGenericBackendFactoryProvider.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, 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.viatra.runtime.localsearch.matcher.integration;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactory;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactoryProvider;
+/**
+ * @since 2.0
+ */
+public class LocalSearchGenericBackendFactoryProvider implements IQueryBackendFactoryProvider {
+    
+    @Override
+    public IQueryBackendFactory getFactory() {
+        return LocalSearchGenericBackendFactory.INSTANCE;
+    }
+    
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHintOptions.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHintOptions.java
new file mode 100644
index 00000000..43462204
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHintOptions.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs 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.viatra.runtime.localsearch.matcher.integration;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.ICostFunction;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.impl.IndexerBasedConstraintCostFunction;
+import tools.refinery.viatra.runtime.matchers.backend.ICallDelegationStrategy;
+import tools.refinery.viatra.runtime.matchers.backend.QueryHintOption;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IFlattenCallPredicate;
+/**
+ * 
+ * @author Gabor Bergmann
+ * @since 1.5
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+public final class LocalSearchHintOptions {
+    
+    private LocalSearchHintOptions() {
+        // Private constructor for utility class
+    }
+    
+    public static final QueryHintOption<Boolean> USE_BASE_INDEX = 
+            hintOption("USE_BASE_INDEX", true);
+    
+    // This key can be used to influence the core planner algorithm
+    public static final QueryHintOption<Integer> PLANNER_TABLE_ROW_COUNT = 
+            hintOption("PLANNER_TABLE_ROW_COUNT", 4);
+    /**
+     * Cost function to be used by the planner. Must implement {@link ICostFunction}
+     * @since 1.4
+     */
+    public static final QueryHintOption<ICostFunction> PLANNER_COST_FUNCTION = 
+            hintOption("PLANNER_COST_FUNCTION", new IndexerBasedConstraintCostFunction());
+    /**
+     * Predicate to decide whether to flatten specific positive pattern calls {@link IFlattenCallPredicate}
+     * @since 1.4
+     */
+    public static final QueryHintOption<IFlattenCallPredicate> FLATTEN_CALL_PREDICATE = 
+            hintOption("FLATTEN_CALL_PREDICATE", new DontFlattenDisjunctive());
+    /**
+     * Strategy to decide how hints (most importantly, backend selection) propagate across pattern calls. 
+     * Must implement {@link ICallDelegationStrategy}.
+     * @since 2.1
+     */
+    public static final QueryHintOption<ICallDelegationStrategy> CALL_DELEGATION_STRATEGY = 
+            hintOption("CALL_DELEGATION_STRATEGY", ICallDelegationStrategy.FULL_BACKEND_ADHESION);
+    
+    /**
+     * A provider of expected adornments {@link IAdornmentProvider}. 
+     * 
+     * The safe default is {@link AllValidAdornments}; 
+     * however, the generic backend variant may safely use {@link LazyPlanningAdornments} instead. 
+     * 
+     * @since 1.5
+     */
+    public static final QueryHintOption<IAdornmentProvider> ADORNMENT_PROVIDER = 
+            hintOption("ADORNMENT_PROVIDER", new AllValidAdornments());
+    
+    // internal helper for conciseness
+    private static <T, V extends T> QueryHintOption<T> hintOption(String hintKeyLocalName, V defaultValue) {
+        return new QueryHintOption<>(LocalSearchHintOptions.class, hintKeyLocalName, defaultValue);
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHints.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHints.java
new file mode 100644
index 00000000..5f3895be
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/matcher/integration/LocalSearchHints.java
@@ -0,0 +1,306 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.matcher.integration;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.ICostFunction;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.impl.IndexerBasedConstraintCostFunction;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.impl.StatisticsBasedConstraintCostFunction;
+import tools.refinery.viatra.runtime.matchers.backend.*;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IFlattenCallPredicate;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IRewriterTraceCollector;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.NopTraceCollector;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import static tools.refinery.viatra.runtime.localsearch.matcher.integration.LocalSearchHintOptions.*;
+import static tools.refinery.viatra.runtime.matchers.backend.CommonQueryHintOptions.normalizationTraceCollector;
+/**
+ * Type safe builder and extractor for Local search specific hints
+ *
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public final class LocalSearchHints implements IMatcherCapability {
+    private Boolean useBase = null;
+    private Integer rowCount = null;
+    private ICostFunction costFunction = null;
+    private IFlattenCallPredicate flattenCallPredicate = null;
+    private ICallDelegationStrategy callDelegationStrategy = null;
+    private IAdornmentProvider adornmentProvider = null;
+    private IRewriterTraceCollector traceCollector = NopTraceCollector.INSTANCE;
+    private IQueryBackendFactory backendFactory = null;
+    private LocalSearchHints() {}
+    /**
+     * Return the default settings overridden by the given hints
+     */
+    public static LocalSearchHints getDefaultOverriddenBy(QueryEvaluationHint overridingHint){
+        return parse(getDefault().build(overridingHint));
+    }
+    /**
+     * Default settings which are considered the most safe, providing a reasonable performance for most of the cases. Assumes the availability of the base indexer.
+     */
+    public static LocalSearchHints getDefault(){
+        return getDefaultGeneric();
+    }
+    /**
+     * Initializes the generic (not EMF specific) search backend with the default settings
+     * @since 1.7
+     */
+    public static LocalSearchHints getDefaultGeneric(){
+        LocalSearchHints result = new LocalSearchHints();
+        result.useBase = true; // Should be unused; but a false value might cause surprises as an engine-default hint
+        result.rowCount = 4;
+        result.costFunction = new IndexerBasedConstraintCostFunction(StatisticsBasedConstraintCostFunction.INVERSE_NAVIGATION_PENALTY_GENERIC);
+        result.flattenCallPredicate = FLATTEN_CALL_PREDICATE.getDefaultValue();
+        result.callDelegationStrategy = ICallDelegationStrategy.FULL_BACKEND_ADHESION;
+        result.adornmentProvider = new LazyPlanningAdornments();
+        result.backendFactory = LocalSearchGenericBackendFactory.INSTANCE;
+        return result;
+    }
+    /**
+     * Initializes the default search backend with hybrid-enabled settings
+     * @since 2.1
+     */
+    public static LocalSearchHints getDefaultHybrid(){
+        LocalSearchHints result = getDefault();
+        result.callDelegationStrategy = ICallDelegationStrategy.PARTIAL_BACKEND_ADHESION;
+        result.flattenCallPredicate = new IFlattenCallPredicate.And(
+                new DontFlattenIncrementalPredicate(), new DontFlattenDisjunctive());
+        return result;
+    }
+    /**
+     * Initializes the generic (not EMF specific) search backend with hybrid-enabled settings
+     * @since 2.1
+     */
+    public static LocalSearchHints getDefaultGenericHybrid(){
+        LocalSearchHints result = getDefaultGeneric();
+        result.callDelegationStrategy = ICallDelegationStrategy.PARTIAL_BACKEND_ADHESION;
+        result.flattenCallPredicate = new IFlattenCallPredicate.And(
+                new DontFlattenIncrementalPredicate(), new DontFlattenDisjunctive());
+        return result;
+    }
+    public static LocalSearchHints parse(QueryEvaluationHint hint){
+        LocalSearchHints result = new LocalSearchHints();
+        result.useBase = USE_BASE_INDEX.getValueOrNull(hint);
+        result.rowCount = PLANNER_TABLE_ROW_COUNT.getValueOrNull(hint);
+        result.flattenCallPredicate = FLATTEN_CALL_PREDICATE.getValueOrNull(hint);
+        result.callDelegationStrategy = CALL_DELEGATION_STRATEGY.getValueOrNull(hint);
+        result.costFunction = PLANNER_COST_FUNCTION.getValueOrNull(hint);
+        result.adornmentProvider = ADORNMENT_PROVIDER.getValueOrNull(hint);
+        result.traceCollector = normalizationTraceCollector.getValueOrDefault(hint);
+        return result;
+    }
+    private Map<QueryHintOption<?>, Object> calculateHintMap() {
+        Map<QueryHintOption<?>, Object> map = new HashMap<>();
+        if (useBase != null){
+            USE_BASE_INDEX.insertOverridingValue(map, useBase);
+        }
+        if (rowCount != null){
+            PLANNER_TABLE_ROW_COUNT.insertOverridingValue(map, rowCount);
+        }
+        if (costFunction != null){
+            PLANNER_COST_FUNCTION.insertOverridingValue(map, costFunction);
+        }
+        if (flattenCallPredicate != null){
+            FLATTEN_CALL_PREDICATE.insertOverridingValue(map, flattenCallPredicate);
+        }
+        if (callDelegationStrategy != null){
+            CALL_DELEGATION_STRATEGY.insertOverridingValue(map, callDelegationStrategy);
+        }
+        if (adornmentProvider != null){
+            ADORNMENT_PROVIDER.insertOverridingValue(map, adornmentProvider);
+        }
+        if (traceCollector != null){
+            normalizationTraceCollector.insertOverridingValue(map, traceCollector);
+        }
+        return map;
+    }
+    public QueryEvaluationHint build(){
+        Map<QueryHintOption<?>, Object> map = calculateHintMap();
+        return new QueryEvaluationHint(map, backendFactory);
+    }
+    /**
+     * @since 1.7
+     */
+    public QueryEvaluationHint build(QueryEvaluationHint overridingHint) {
+        if (overridingHint == null)
+            return build();
+        IQueryBackendFactory factory = (overridingHint.getQueryBackendFactory() == null)
+                ? this.backendFactory
+                : overridingHint.getQueryBackendFactory();
+        Map<QueryHintOption<?>, Object> hints = calculateHintMap();
+        if (overridingHint.getBackendHintSettings() != null) {
+            hints.putAll(overridingHint.getBackendHintSettings());
+        }
+        return new QueryEvaluationHint(hints, factory);
+    }
+    public boolean isUseBase() {
+        return useBase;
+    }
+    public ICostFunction getCostFunction() {
+        return costFunction;
+    }
+    public IFlattenCallPredicate getFlattenCallPredicate() {
+        return flattenCallPredicate;
+    }
+    /**
+     * @since 2.1
+     */
+    public ICallDelegationStrategy getCallDelegationStrategy() {
+        return callDelegationStrategy;
+    }
+    public Integer getRowCount() {
+        return rowCount;
+    }
+    /**
+     * @since 1.5
+     */
+    public IAdornmentProvider getAdornmentProvider() {
+        return adornmentProvider;
+    }
+    /**
+     * @since 1.6
+     */
+    public IRewriterTraceCollector getTraceCollector() {
+        return traceCollector == null ? normalizationTraceCollector.getDefaultValue() : traceCollector;
+    }
+    public LocalSearchHints setUseBase(boolean useBase) {
+        this.useBase = useBase;
+        return this;
+    }
+    public LocalSearchHints setRowCount(int rowCount) {
+        this.rowCount = rowCount;
+        return this;
+    }
+    public LocalSearchHints setCostFunction(ICostFunction costFunction) {
+        this.costFunction = costFunction;
+        return this;
+    }
+    public LocalSearchHints setFlattenCallPredicate(IFlattenCallPredicate flattenCallPredicate) {
+        this.flattenCallPredicate = flattenCallPredicate;
+        return this;
+    }
+    /**
+     * @since 2.1
+     */
+    public LocalSearchHints setCallDelegationStrategy(ICallDelegationStrategy callDelegationStrategy) {
+        this.callDelegationStrategy = callDelegationStrategy;
+        return this;
+    }
+    /**
+     * @since 1.6
+     */
+    public LocalSearchHints setTraceCollector(IRewriterTraceCollector traceCollector) {
+        this.traceCollector = traceCollector;
+        return this;
+    }
+    /**
+     * @since 1.5
+     */
+    public LocalSearchHints setAdornmentProvider(IAdornmentProvider adornmentProvider) {
+        this.adornmentProvider = adornmentProvider;
+        return this;
+    }
+    public static LocalSearchHints customizeUseBase(boolean useBase){
+        return new LocalSearchHints().setUseBase(useBase);
+    }
+    public static LocalSearchHints customizeRowCount(int rowCount){
+        return new LocalSearchHints().setRowCount(rowCount);
+    }
+    public static LocalSearchHints customizeCostFunction(ICostFunction costFunction){
+        return new LocalSearchHints().setCostFunction(costFunction);
+    }
+    public static LocalSearchHints customizeFlattenCallPredicate(IFlattenCallPredicate predicate){
+        return new LocalSearchHints().setFlattenCallPredicate(predicate);
+    }
+    /**
+     * @since 2.1
+     */
+    public static LocalSearchHints customizeCallDelegationStrategy(ICallDelegationStrategy strategy){
+        return new LocalSearchHints().setCallDelegationStrategy(strategy);
+    }
+    /**
+     * @since 1.5
+     */
+    public static LocalSearchHints customizeAdornmentProvider(IAdornmentProvider adornmentProvider){
+        return new LocalSearchHints().setAdornmentProvider(adornmentProvider);
+    }
+    /**
+     * @since 1.6
+     */
+    public static LocalSearchHints customizeTraceCollector(IRewriterTraceCollector traceCollector){
+        return new LocalSearchHints().setTraceCollector(traceCollector);
+    }
+    @Override
+    public boolean canBeSubstitute(IMatcherCapability capability) {
+        if (capability instanceof LocalSearchHints){
+            LocalSearchHints other = (LocalSearchHints)capability;
+            /*
+             * We allow substitution of matchers if their functionally relevant settings are equal.
+             */
+            return Objects.equals(other.useBase, useBase);
+        }
+        /*
+         * For any other cases (e.g. for Rete), we cannot assume
+         * that matchers created by LS are functionally equivalent.
+         */
+        return false;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/CheckOperationExecutor.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/CheckOperationExecutor.java
new file mode 100644
index 00000000..295ac110
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/CheckOperationExecutor.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation.ISearchOperationExecutor;
+/**
+ * Abstract base class for search operations that check only the already set variables.
+ * 
+ * @noextend This class is not intended to be subclassed by clients.
+ * @since 2.0
+ */
+public abstract class CheckOperationExecutor implements ISearchOperationExecutor {
+    /**
+     * The executed field ensures that the second call of the check always returns false, resulting in a quick
+     * backtracking.
+     */
+    private boolean executed;
+    @Override
+    public void onInitialize(MatchingFrame frame, ISearchContext context) {
+        executed = false;
+    }
+    @Override
+    public void onBacktrack(MatchingFrame frame, ISearchContext context) {
+    }
+    @Override
+    public boolean execute(MatchingFrame frame, ISearchContext context) {
+        executed = executed ? false : check(frame, context);
+        return executed;
+    }
+    /**
+     * Executes the checking operation
+     * @since 1.7
+     */
+    protected abstract boolean check(MatchingFrame frame, ISearchContext context) ;
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ExtendOperationExecutor.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ExtendOperationExecutor.java
new file mode 100644
index 00000000..a72c30dd
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ExtendOperationExecutor.java
@@ -0,0 +1,77 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Akos Horvath, Istvan Rath and Daniel Varro
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
+ * 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.viatra.runtime.localsearch.operations;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.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
+ * @noextend This class is not intended to be subclassed by clients.
+ * @since 2.0
+ */
+public 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
+     */
+    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 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/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/IIteratingSearchOperation.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/IIteratingSearchOperation.java
new file mode 100644
index 00000000..6fee0097
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/IIteratingSearchOperation.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+/**
+ * Denotes a {@link ISearchOperation} which involves iterating over an instances of an {@link IInputKey}
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public interface IIteratingSearchOperation extends ISearchOperation{
+    /**
+     * Get the {@link IInputKey} which instances this operation iterates upon.
+     */
+    public IInputKey getIteratedInputKey();
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/IPatternMatcherOperation.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/IPatternMatcherOperation.java
new file mode 100644
index 00000000..d8106329
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/IPatternMatcherOperation.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+/**
+ * Marker interface for pattern matcher call operations, such as positive and negative pattern calls or match aggregators.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ */
+public interface IPatternMatcherOperation {
+    /**
+     * Returns the precomputed call information associated with the current operation
+     * @since 2.0
+     */
+    CallInformation getCallInformation();
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ISearchOperation.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ISearchOperation.java
new file mode 100644
index 00000000..eb6243ed
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/ISearchOperation.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+/**
+ * Represents a search operation executable by the LS engine. It is expected that an operation can be shared among
+ * multiple LS matchers, but the created executors are not.
+ * 
+ * @author Zoltan Ujhelyi
+ * 
+ */
+public interface ISearchOperation {
+    /**
+     * Initializes a new operation executor for the given operation. Repeated calls must return different executor
+     * instances.
+     * 
+     * @since 2.0
+     */
+    public ISearchOperationExecutor createExecutor();
+    
+    /**
+     * 
+     * @since 2.0
+     *
+     */
+    public interface ISearchOperationExecutor {
+        
+        /**
+         * Returns the stateless operation this executor was initialized from
+         */
+        ISearchOperation getOperation();
+        
+        /**
+         * During the execution of the corresponding plan, the onInitialize callback is evaluated before the execution of
+         * the operation may begin. Operations may use this method to initialize its internal data structures.
+         * 
+         * @throws ViatraQueryRuntimeException
+         */
+        void onInitialize(MatchingFrame frame, ISearchContext context);
+    
+        /**
+         * After the execution of the operation failed and {@link #execute(MatchingFrame, ISearchContext)} returns false, the onBacktrack
+         * callback is evaluated. Operations may use this method to clean up any temporary structures, and make the
+         * operation ready for a new execution.
+         * 
+         * @throws ViatraQueryRuntimeException
+         */
+        void onBacktrack(MatchingFrame frame, ISearchContext context);
+    
+        /**
+         * 
+         * @param frame
+         * @param context
+         * @return true if successful, or false if backtracking needed
+         * @throws ViatraQueryRuntimeException
+         */
+        boolean execute(MatchingFrame frame, ISearchContext context);
+    }
+    /**
+     * 
+     * @return the ordered list of the variable numbers that are affected by the search operation
+     */
+    List<Integer> getVariablePositions();
+    /**
+     * Creates a string representation of the search operation by replacing the variable numbers according to the
+     * parameter function. It is expected that the provided function does return a non-null value for each variable
+     * index that is returned by {@link #getVariablePositions()}; otherwise a {@link NullPointerException} will be
+     * thrown during the calculation of the string.
+     * 
+     * @since 2.0
+     */
+    String toString(Function<Integer, String> variableMapping);
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/MatchingFrameValueProvider.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/MatchingFrameValueProvider.java
new file mode 100644
index 00000000..38f62129
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/MatchingFrameValueProvider.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations;
+import java.util.Map;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.matchers.psystem.IValueProvider;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * 
+ * 
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class MatchingFrameValueProvider implements IValueProvider {
+    
+    final Map<String, Integer> nameMap;
+    final MatchingFrame frame;
+    
+    public MatchingFrameValueProvider(MatchingFrame frame, Map<String, Integer> nameMap) {
+        super();
+        this.frame = frame;
+        this.nameMap = nameMap;
+    }
+    @Override
+    public Object getValue(String variableName) {
+        Integer index = nameMap.get(variableName);
+        Preconditions.checkArgument(index != null, "Unknown parameter variable name");
+        return frame.get(index);
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/AggregatorCheck.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/AggregatorCheck.java
new file mode 100644
index 00000000..4d631635
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/AggregatorCheck.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.operations.check;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.AggregatorConstraint;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+/**
+ * Calculates the aggregated value of a column based on the given {@link AggregatorConstraint}
+ * 
+ * @author Balázs Grill
+ * @since 1.4
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class AggregatorCheck implements ISearchOperation, IPatternMatcherOperation {
+    private class Executor extends CheckOperationExecutor {
+        
+        private final VolatileModifiableMaskedTuple maskedTuple;
+        private IQueryResultProvider matcher;
+        
+        public Executor() {
+            super();
+            this.maskedTuple = new VolatileModifiableMaskedTuple(information.getThinFrameMask());
+        }
+        
+        @Override
+        public void onInitialize(MatchingFrame frame, ISearchContext context) {
+            super.onInitialize(frame, context);
+            maskedTuple.updateTuple(frame);
+            matcher = context.getMatcher(information.getCallWithAdornment());
+        }
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            IMultisetAggregationOperator<?, ?, ?> operator = aggregator.getAggregator().getOperator();
+            Object result = aggregate(operator, aggregator.getAggregatedColumn(), frame);
+            return result == null ? false : Objects.equals(frame.getValue(position), result);
+        }
+        @SuppressWarnings("unchecked")
+        private <Domain, Accumulator, AggregateResult> AggregateResult aggregate(
+                IMultisetAggregationOperator<Domain, Accumulator, AggregateResult> operator, int aggregatedColumn,
+                MatchingFrame initialFrame) {
+            maskedTuple.updateTuple(initialFrame);
+            final Stream<Domain> valueStream = matcher.getAllMatches(information.getParameterMask(), maskedTuple)
+                    .map(match -> (Domain) match.get(aggregatedColumn));
+            return operator.aggregateStream(valueStream);
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return AggregatorCheck.this;
+        }
+    }
+    
+    private final int position;
+    private final AggregatorConstraint aggregator;
+    private final CallInformation information;
+    
+    /**
+     * @since 1.7
+     */
+    public AggregatorCheck(CallInformation information, AggregatorConstraint aggregator, int position) {
+        super();
+        this.information = information;
+        this.position = position;
+        this.aggregator = aggregator;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return Collections.singletonList(position);
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "check     "+variableMapping.apply(position)+" = " + aggregator.getAggregator().getOperator().getName() + " find " + information.toString(variableMapping);
+    }
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/BinaryTransitiveClosureCheck.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/BinaryTransitiveClosureCheck.java
new file mode 100644
index 00000000..8f818542
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/BinaryTransitiveClosureCheck.java
@@ -0,0 +1,135 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.check;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Queue;
+import java.util.Set;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+/**
+ * Checking for a transitive closure expressed as a local search pattern matcher. The matched pattern must have two
+ * parameters of the same model type.
+ * 
+ * @author Zoltan Ujhelyi
+ * @noextend This class is not intended to be subclassed by clients.
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ * 
+ */
+public class BinaryTransitiveClosureCheck implements ISearchOperation, IPatternMatcherOperation {
+    private class Executor extends CheckOperationExecutor {
+        
+        @Override
+        public void onInitialize(MatchingFrame frame, ISearchContext context) {
+            super.onInitialize(frame, context);
+            matcher = context.getMatcher(information.getCallWithAdornment());
+            // Note: second parameter is NOT bound during execution, but the first is
+        }
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            if (checkReflexive(frame)) {
+                return true;
+            }
+            
+            Object targetValue = frame.get(targetPosition);
+            Queue<Object> sourcesToEvaluate = new LinkedList<>();
+            sourcesToEvaluate.add(frame.get(sourcePosition));
+            Set<Object> sourceEvaluated = new HashSet<>();
+            final Object[] mappedFrame = new Object[] {null, null};
+            while (!sourcesToEvaluate.isEmpty()) {
+                Object currentValue = sourcesToEvaluate.poll();
+                sourceEvaluated.add(currentValue);
+                mappedFrame[0] = currentValue;
+                for (Tuple match : (Iterable<Tuple>) () -> matcher.getAllMatches(mappedFrame).iterator()) {
+                    Object foundTarget = match.get(1);
+                    if (targetValue.equals(foundTarget)) {
+                        return true;
+                    } else if (!sourceEvaluated.contains(foundTarget)) {
+                        sourcesToEvaluate.add(foundTarget);
+                    }
+                }
+            }
+            return false;
+        }
+        
+        protected boolean checkReflexive(MatchingFrame frame) {
+            return reflexive && Objects.equals(frame.get(sourcePosition), frame.get(targetPosition));
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return BinaryTransitiveClosureCheck.this;
+        }
+    }
+    
+    private final CallInformation information; 
+    private IQueryResultProvider matcher;
+    private final int sourcePosition;
+    private final int targetPosition;
+    private final boolean reflexive;
+    
+    /**
+     * The source position will be matched in the called pattern to the first parameter; while target to the second.
+     * </p>
+     * <strong>NOTE</strong>: the reflexive check call does not include the parameter type checks; appropriate type checks should be
+     * added as necessary by the operation compiler.
+     * 
+     * @since 2.0
+     */
+    public BinaryTransitiveClosureCheck(CallInformation information, int sourcePosition, int targetPosition, boolean reflexive) {
+        super();
+        this.sourcePosition = sourcePosition;
+        this.targetPosition = targetPosition;
+        this.information = information;
+        this.reflexive = reflexive;
+    }
+    
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        String c = information.toString(variableMapping);
+        int p = c.indexOf('(');
+        String modifier = reflexive ? "*" : "+";
+        return "check     find "+c.substring(0, p)+ modifier +c.substring(p);
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return Arrays.asList(sourcePosition, targetPosition);
+    }
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CheckConstant.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CheckConstant.java
new file mode 100644
index 00000000..4ce48af0
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CheckConstant.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.check;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+/**
+ * This operation handles constants in search plans by checking if a variable is bound to a certain constant value. Such
+ * operations should be executed as early as possible during plan execution.
+ * 
+ * @author Marton Bur
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class CheckConstant implements ISearchOperation {
+    private class Executor extends CheckOperationExecutor {
+        
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            return frame.get(position).equals(value);
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return CheckConstant.this;
+        }
+    }
+    
+    private int position;
+    private Object value;
+    public CheckConstant(int position, Object value) {
+        this.position = position;
+        this.value = value;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return Collections.singletonList(position);
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "check     constant "+variableMapping.apply(position)+"='"+value+"'";
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CheckPositivePatternCall.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CheckPositivePatternCall.java
new file mode 100644
index 00000000..5f9b688a
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CheckPositivePatternCall.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations.check;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+/**
+ * @author Grill Balázs
+ * @since 1.4
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class CheckPositivePatternCall implements ISearchOperation, IPatternMatcherOperation {
+    private class Executor extends CheckOperationExecutor {
+        
+        private final VolatileModifiableMaskedTuple maskedTuple;
+        private IQueryResultProvider matcher;
+        
+        public Executor() {
+            super();
+            this.maskedTuple = new VolatileModifiableMaskedTuple(information.getThinFrameMask());
+        }
+        @Override
+        public void onInitialize(MatchingFrame frame, ISearchContext context) {
+            super.onInitialize(frame, context);
+            maskedTuple.updateTuple(frame);
+            matcher = context.getMatcher(information.getCallWithAdornment());
+        }
+        
+        /**
+         * @since 1.5
+         */
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            return matcher.hasMatch(information.getParameterMask(), maskedTuple);
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return CheckPositivePatternCall.this;
+        }
+    }
+    
+    private final CallInformation information; 
+    /**
+     * @since 1.7
+     */
+    public CheckPositivePatternCall(CallInformation information) {
+        super();
+        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(Function<Integer, String> variableMapping) {
+        return "check     find "+information.toString(variableMapping);
+    }
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CountCheck.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CountCheck.java
new file mode 100644
index 00000000..d74c1c6f
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/CountCheck.java
@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.check;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+/**
+ * Calculates the count of matches for a called matcher
+ * 
+ * @author Zoltan Ujhelyi
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class CountCheck implements ISearchOperation, IPatternMatcherOperation {
+    private class Executor extends CheckOperationExecutor {
+        
+        private final VolatileModifiableMaskedTuple maskedTuple;
+        private IQueryResultProvider matcher;
+        
+        public Executor() {
+            maskedTuple = new VolatileModifiableMaskedTuple(information.getThinFrameMask());
+        }
+        
+        @Override
+        public void onInitialize(MatchingFrame frame, ISearchContext context) {
+            super.onInitialize(frame, context);
+            maskedTuple.updateTuple(frame);
+            matcher = context.getMatcher(information.getCallWithAdornment());
+        }
+        
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            int count = matcher.countMatches(information.getParameterMask(), maskedTuple);
+            return ((Integer)frame.getValue(position)) == count;
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return CountCheck.this;
+        }
+    }
+    
+    private final int position;
+    private final CallInformation information;
+    
+    /**
+     * @since 1.7
+     */
+    public CountCheck(CallInformation information, int position) {
+        super();
+        this.information = information;
+        this.position = position;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return Collections.singletonList(position);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "check     "+variableMapping.apply(position)+" = count find "+ information.toString(variableMapping);
+    }
+    
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/ExpressionCheck.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/ExpressionCheck.java
new file mode 100644
index 00000000..fc9efdca
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/ExpressionCheck.java
@@ -0,0 +1,78 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.check;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.MatchingFrameValueProvider;
+import tools.refinery.viatra.runtime.matchers.psystem.IExpressionEvaluator;
+/**
+ * @author Zoltan Ujhelyi
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class ExpressionCheck implements ISearchOperation {
+    private class Executor extends CheckOperationExecutor {
+        
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            try {
+                boolean result = (Boolean) evaluator.evaluateExpression(new MatchingFrameValueProvider(frame, nameMap));
+                return result;
+            } catch (Exception e) {
+                context.getLogger().warn("Error while evaluating expression", e);
+                return false;
+            }
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return ExpressionCheck.this;
+        }
+    }
+    
+    IExpressionEvaluator evaluator;
+    Map<String, Integer> nameMap;
+    public ExpressionCheck(IExpressionEvaluator evaluator, Map<String, Integer> nameMap) {
+        super();
+        this.evaluator = evaluator;
+        this.nameMap = nameMap;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        // XXX not sure if this is the correct implementation to get the affected variable indicies
+        return new ArrayList<>(nameMap.values());
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "check     expression "+evaluator.getShortDescription();
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/ExpressionEvalCheck.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/ExpressionEvalCheck.java
new file mode 100644
index 00000000..5b1bca10
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/ExpressionEvalCheck.java
@@ -0,0 +1,95 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations.check;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.MatchingFrameValueProvider;
+import tools.refinery.viatra.runtime.matchers.psystem.IExpressionEvaluator;
+/**
+ * @author Grill Balázs
+ * @since 1.3
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class ExpressionEvalCheck implements ISearchOperation {
+    private class Executor extends CheckOperationExecutor {
+        
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            try {
+                Object result = evaluator.evaluateExpression(new MatchingFrameValueProvider(frame, nameMap));
+                if (!unwind && result != null) {
+                    Object currentValue = frame.get(outputPosition);
+                    return result.equals(currentValue);
+                } else if (unwind && result instanceof Set<?>) {
+                    Object currentValue = frame.get(outputPosition);
+                    return ((Set<?>)result).contains(currentValue);
+                }
+            } catch (Exception e) {
+                context.getLogger().warn("Error while evaluating expression", e);
+            }
+            return false;
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return ExpressionEvalCheck.this;
+        }
+    }
+    
+    private final int outputPosition;
+    private final IExpressionEvaluator evaluator;
+    private final Map<String, Integer> nameMap;
+    private final boolean unwind;
+    
+    public ExpressionEvalCheck(IExpressionEvaluator evaluator, Map<String, Integer> nameMap, int position) {
+        this(evaluator, nameMap, false, position);
+    }
+    
+    /**
+     * @since 2.7
+     */
+    public ExpressionEvalCheck(IExpressionEvaluator evaluator, Map<String, Integer> nameMap, boolean unwind, int position) {
+        this.evaluator = evaluator;
+        this.nameMap = nameMap;
+        this.unwind = unwind;
+        this.outputPosition = position;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        // XXX not sure if this is the correct implementation to get the affected variable indicies
+        return new ArrayList<>(nameMap.values());
+    }
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "check     "+variableMapping.apply(outputPosition)+" = expression "+evaluator.getShortDescription();
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/InequalityCheck.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/InequalityCheck.java
new file mode 100644
index 00000000..3f30c3c4
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/InequalityCheck.java
@@ -0,0 +1,77 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.check;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.exceptions.LocalSearchException;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+/**
+ * @author Zoltan Ujhelyi
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class InequalityCheck implements ISearchOperation {
+    private class Executor extends CheckOperationExecutor {
+        
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            Object source = frame.getValue(sourceLocation);
+            Object target = frame.getValue(targetLocation);
+            if (source == null) {
+                throw new LocalSearchException("Source not bound.");
+            }
+            if (target == null) {
+                throw new LocalSearchException("Target not bound");
+            }
+            return !source.equals(target);
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return InequalityCheck.this;
+        }
+    }
+    
+    int sourceLocation;
+    int targetLocation;
+    public InequalityCheck(int sourceLocation, int targetLocation) {
+        super();
+        this.sourceLocation = sourceLocation;
+        this.targetLocation = targetLocation;
+    }
+    
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "check     "+variableMapping.apply(sourceLocation)+" != "+variableMapping.apply(targetLocation);
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return Arrays.asList(sourceLocation, targetLocation);
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/NACOperation.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/NACOperation.java
new file mode 100644
index 00000000..3759e1d1
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/check/NACOperation.java
@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.check;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+/**
+ * @author Zoltan Ujhelyi
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class NACOperation implements ISearchOperation, IPatternMatcherOperation {
+    private class Executor extends CheckOperationExecutor {
+        private final VolatileModifiableMaskedTuple maskedTuple;
+        private IQueryResultProvider matcher;
+        
+        private Executor() {
+            this.maskedTuple = new VolatileModifiableMaskedTuple(information.getThinFrameMask());
+        }
+        
+        @Override
+        public void onInitialize(MatchingFrame frame, ISearchContext context) {
+            super.onInitialize(frame, context);
+            maskedTuple.updateTuple(frame);
+            matcher = context.getMatcher(information.getCallWithAdornment());
+        }
+        
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            return !matcher.hasMatch(information.getParameterMask(), maskedTuple);
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return NACOperation.this;
+        }
+    }
+    
+    private final CallInformation information;
+    /**
+     * @since 1.7
+     */
+    public NACOperation(CallInformation information) {
+        super();
+        this.information = information;
+    }
+    
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "check     neg find "+information.toString(variableMapping);
+    }
+    
+    @Override
+    public List<Integer> getVariablePositions() {
+        return information.getVariablePositions();
+    }
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/AggregatorExtend.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/AggregatorExtend.java
new file mode 100644
index 00000000..c2e75b7a
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/AggregatorExtend.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.operations.extend;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.AggregatorConstraint;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+/**
+ * Calculates the aggregated value of a column based on the given {@link AggregatorConstraint}
+ * 
+ * @author Balázs Grill
+ * @since 1.4
+ */
+public class AggregatorExtend  implements ISearchOperation, IPatternMatcherOperation{
+    private class Executor extends SingleValueExtendOperationExecutor<Object> {
+        private final VolatileModifiableMaskedTuple maskedTuple;
+        private IQueryResultProvider matcher;
+        
+        public Executor(int position) {
+            super(position);
+            this.maskedTuple = new VolatileModifiableMaskedTuple(information.getThinFrameMask());
+        }
+        
+        @Override
+        public Iterator<?> getIterator(MatchingFrame frame, ISearchContext context) {
+            maskedTuple.updateTuple(frame);
+            matcher = context.getMatcher(information.getCallWithAdornment());
+            Object aggregate = aggregate(aggregator.getAggregator().getOperator(), aggregator.getAggregatedColumn());
+            return aggregate == null ? Collections.emptyIterator() : Collections.singletonList(aggregate).iterator();
+            
+        }
+        
+        @SuppressWarnings("unchecked")
+        private <Domain, Accumulator, AggregateResult> AggregateResult aggregate(
+                IMultisetAggregationOperator<Domain, Accumulator, AggregateResult> operator, int aggregatedColumn) {
+            final Stream<Domain> valueStream = matcher.getAllMatches(information.getParameterMask(), maskedTuple)
+                    .map(match -> (Domain) match.get(aggregatedColumn));
+            return operator.aggregateStream(valueStream);
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return AggregatorExtend.this;
+        }
+    }
+    
+    private final AggregatorConstraint aggregator;
+    private final CallInformation information; 
+    private final int position;
+    
+    /**
+     * @since 1.7
+     */
+    public AggregatorExtend(CallInformation information, AggregatorConstraint aggregator, int position) {
+        this.aggregator = aggregator;
+        this.information = information;
+        this.position = position;
+    }
+    
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor(position);
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return Arrays.asList(position);
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "extend    -"+variableMapping.apply(position)+" = " + aggregator.getAggregator().getOperator().getName()+" find " + information.toString(variableMapping);
+    }
+    
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/CountOperation.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/CountOperation.java
new file mode 100644
index 00000000..08ecc8d6
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/CountOperation.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.extend;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+/**
+ * Calculates the count of matches for a called matcher
+ * 
+ * @author Zoltan Ujhelyi
+ */
+public class CountOperation implements ISearchOperation, IPatternMatcherOperation{
+    private class Executor extends SingleValueExtendOperationExecutor<Integer>  {
+        private final VolatileModifiableMaskedTuple maskedTuple;
+        private IQueryResultProvider matcher;
+        
+        public Executor(int position) {
+            super(position);
+            maskedTuple = new VolatileModifiableMaskedTuple(information.getThinFrameMask());
+        }
+        
+        @Override
+        public Iterator<Integer> getIterator(MatchingFrame frame, ISearchContext context) {
+            matcher = context.getMatcher(information.getCallWithAdornment());
+            maskedTuple.updateTuple(frame);
+            return Collections.singletonList(matcher.countMatches(information.getParameterMask(), maskedTuple)).iterator();
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return CountOperation.this;
+        }
+    }
+    
+    private final CallInformation information;
+    private final int position; 
+    
+    /**
+     * @since 1.7
+     */
+    public CountOperation(CallInformation information, int position) {
+        this.information = information;
+        this.position = position;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor(position);
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return information.getVariablePositions();
+    }
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "extend    -"+variableMapping.apply(position)+" = count find " + information.toString(variableMapping);
+    }
+    
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExpressionEval.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExpressionEval.java
new file mode 100644
index 00000000..7186f4ac
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExpressionEval.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.extend;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.MatchingFrameValueProvider;
+import tools.refinery.viatra.runtime.matchers.psystem.IExpressionEvaluator;
+/**
+ * Calculates the result of an expression and stores it inside a variable for future reference.
+ * 
+ * @author Zoltan Ujhelyi
+ * 
+ */
+public class ExpressionEval implements ISearchOperation {
+    private class Executor extends SingleValueExtendOperationExecutor<Object> {
+        public Executor(int position) {
+            super(position);
+        }
+        
+        @Override
+        public Iterator<?> getIterator(MatchingFrame frame, ISearchContext context) {
+            try {
+                Object result = evaluator.evaluateExpression(new MatchingFrameValueProvider(frame, nameMap));
+                if (!unwind && result != null){
+                    return Collections.singletonList(result).iterator();
+                } else if (unwind && result instanceof Set<?>) {
+                    return ((Set<?>)result).iterator();
+                } else {
+                    return Collections.emptyIterator();
+                }
+            } catch (Exception e) {
+                context.getLogger().warn("Error while evaluating expression", e);
+                return Collections.emptyIterator();
+            }
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return ExpressionEval.this;
+        }
+    }
+    
+    private final IExpressionEvaluator evaluator;
+    private final boolean unwind;
+    private final Map<String, Integer> nameMap;
+    private final int position;
+    public ExpressionEval(IExpressionEvaluator evaluator, Map<String, Integer> nameMap, int position) {
+        this(evaluator, nameMap, false, position);
+    }
+    
+    /**
+     * @since 2.7
+     */
+    public ExpressionEval(IExpressionEvaluator evaluator, Map<String, Integer> nameMap, boolean unwind, int position) {
+        this.evaluator = evaluator;
+        this.nameMap = nameMap;
+        this.unwind = unwind;
+        this.position = position;
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "extend    -"+variableMapping.apply(position)+" = expression "+evaluator.getShortDescription();
+    }
+    
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor(position);
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        // XXX not sure if this is the correct implementation to get the affected variable indicies
+        List<Integer> variables = new ArrayList<>();
+        variables.addAll(nameMap.values());
+        return variables;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendBinaryTransitiveClosure.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendBinaryTransitiveClosure.java
new file mode 100644
index 00000000..1250e84e
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendBinaryTransitiveClosure.java
@@ -0,0 +1,185 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.extend;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+/**
+ * Checking for a transitive closure expressed as a local search pattern matcher. The matched pattern must have two
+ * parameters of the same model type.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ * 
+ */
+public abstract class ExtendBinaryTransitiveClosure implements ISearchOperation, IPatternMatcherOperation {
+    private class Executor extends SingleValueExtendOperationExecutor<Object> {
+        public Executor(int position) {
+            super(position);
+        }
+        
+        @Override
+        public Iterator<?> getIterator(MatchingFrame frame, ISearchContext context) {
+            // Note: second parameter is NOT bound during execution, but the first is
+            IQueryResultProvider matcher = context.getMatcher(information.getCallWithAdornment());
+            Queue<Object> seedsToEvaluate = new LinkedList<>();
+            final Object seedValue = frame.get(seedPosition);
+            seedsToEvaluate.add(seedValue);
+            Set<Object> seedsEvaluated = new HashSet<>();
+            Set<Object> targetsFound = new HashSet<>();
+            if (reflexive) {
+                targetsFound.add(seedValue);
+            }
+            while(!seedsToEvaluate.isEmpty()) {
+                Object currentValue = seedsToEvaluate.poll();
+                seedsEvaluated.add(currentValue);
+                final Object[] mappedFrame = calculateCallFrame(currentValue);
+                matcher.getAllMatches(mappedFrame).forEach(match -> {
+                    Object foundTarget = getTarget(match);
+                    targetsFound.add(foundTarget);
+                    if (!seedsEvaluated.contains(foundTarget)) {
+                        seedsToEvaluate.add(foundTarget);
+                    }
+                });
+            }
+            return targetsFound.iterator();
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return ExtendBinaryTransitiveClosure.this;
+        }
+    }
+    
+    /**
+     * Calculates the transitive closure of a pattern match in a forward direction (first parameter bound, second
+     * unbound).
+     * </p>
+     * <strong>Note</strong>: In case the call is reflexive, it is expected that the bound parameter already matches the universe type of the call. 
+     * 
+     * @since 1.7
+     */
+    public static class Forward extends ExtendBinaryTransitiveClosure {
+        private Object[] seedFrame = new Object[2];
+        
+        /**
+         * @since 2.0
+         */
+        public Forward(CallInformation information, int sourcePosition, int targetPosition, boolean reflexive) {
+            super(information, sourcePosition, targetPosition, reflexive);
+        }
+        protected Object[] calculateCallFrame(Object seed) {
+            seedFrame[0] = seed;
+            seedFrame[1] = null;
+            return seedFrame;
+        }
+        protected Object getTarget(Tuple frame) {
+            return frame.get(1);
+        }
+    }
+    /**
+     * Calculates the transitive closure of a pattern match in a backward direction (first parameter unbound, second
+     * bound)
+     * </p>
+     * <strong>Note</strong>: In case the call is reflexive, it is expected that the bound parameter already matches the universe type of the call.
+     * 
+     * @since 2.0
+     */
+    public static class Backward extends ExtendBinaryTransitiveClosure {
+        private Object[] seedFrame = new Object[2];
+        /**
+         * @since 2.0
+         */
+        public Backward(CallInformation information, int sourcePosition, int targetPosition, boolean reflexive) {
+            super(information, targetPosition, sourcePosition, reflexive);
+        }
+        protected Object[] calculateCallFrame(Object seed) {
+            seedFrame[0] = null;
+            seedFrame[1] = seed;
+            return seedFrame;
+        }
+        protected Object getTarget(Tuple frame) {
+            return frame.get(0);
+        }
+    }
+    private final int seedPosition;
+    private final int targetPosition;
+    private final CallInformation information;
+    private final boolean reflexive;
+    /**
+     * The source position will be matched in the called pattern to the first parameter; while target to the second.
+     * @since 2.0
+     */
+    protected ExtendBinaryTransitiveClosure(CallInformation information, int seedPosition, int targetPosition, boolean reflexive) {
+        this.information = information;
+        this.seedPosition = seedPosition;
+        this.targetPosition = targetPosition;
+        this.reflexive = reflexive;
+    }
+    protected abstract Object[] calculateCallFrame(Object seed);
+    protected abstract Object getTarget(Tuple frame);
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor(targetPosition);
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        String c = information.toString(variableMapping);
+        int p = c.indexOf('(');
+        return "extend    find " + c.substring(0, p) + "+" + c.substring(p);
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return Arrays.asList(seedPosition, targetPosition);
+    }
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendConstant.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendConstant.java
new file mode 100644
index 00000000..455236f3
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendConstant.java
@@ -0,0 +1,75 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.operations.extend;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+/**
+ * This operation handles constants in search plans by binding a variable to a constant value. Such operations should be
+ * executed as early as possible during plan execution.
+ * 
+ * @author Marton Bur
+ *
+ */
+public class ExtendConstant implements ISearchOperation {
+    private class Executor extends SingleValueExtendOperationExecutor<Object> {
+        public Executor(int position) {
+            super(position);
+        }
+        @Override
+        public Iterator<?> getIterator(MatchingFrame frame, ISearchContext context) {
+            return Collections.singletonList(value).iterator();
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return ExtendConstant.this;
+        }
+    }
+    
+    private final Object value;
+    private final int position;
+    public ExtendConstant(int position, Object value) {
+        this.position = position;
+        this.value = value;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor(position);
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return Arrays.asList(position);
+    }
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "extend    constant -"+variableMapping.apply(position)+"='"+value+"'";
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendPositivePatternCall.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendPositivePatternCall.java
new file mode 100644
index 00000000..690a3241
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/ExtendPositivePatternCall.java
@@ -0,0 +1,118 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations.extend;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.ExtendOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.IPatternMatcherOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+/**
+ * @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(Function<Integer, String> variableMapping) {
+        return "extend find " + information.toString(variableMapping);
+    }
+    
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/SingleValueExtendOperationExecutor.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/SingleValueExtendOperationExecutor.java
new file mode 100644
index 00000000..a04ffcca
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/extend/SingleValueExtendOperationExecutor.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, 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.viatra.runtime.localsearch.operations.extend;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.ExtendOperationExecutor;
+/**
+ * @since 2.0
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public abstract class SingleValueExtendOperationExecutor<T> extends ExtendOperationExecutor<T> {
+    protected int position;
+    
+    /**
+     * @param position the frame position all values are to be added
+     */
+    public SingleValueExtendOperationExecutor(int position) {
+        super();
+        this.position = position;
+    }
+    @Override
+    protected final boolean fillInValue(T newValue, MatchingFrame frame, ISearchContext context) {
+        frame.setValue(position, newValue);
+        return true;
+    }
+    @Override
+    protected final void cleanup(MatchingFrame frame, ISearchContext context) {
+        frame.setValue(position, null);
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeCheck.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeCheck.java
new file mode 100644
index 00000000..2b189c57
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeCheck.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations.generic;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.CheckOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.IIteratingSearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileMaskedTuple;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class GenericTypeCheck implements ISearchOperation, IIteratingSearchOperation {
+    
+    private class Executor extends CheckOperationExecutor {
+        private VolatileMaskedTuple maskedTuple;
+        
+        private Executor() {
+            this.maskedTuple = new VolatileMaskedTuple(callMask);
+        }
+        
+        @Override
+        protected boolean check(MatchingFrame frame, ISearchContext context) {
+            maskedTuple.updateTuple(frame);
+            return context.getRuntimeContext().containsTuple(type, maskedTuple);
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return GenericTypeCheck.this;
+        }
+    }
+    private final IInputKey type;
+    private final List<Integer> positionList;
+    private final TupleMask callMask;
+    public GenericTypeCheck(IInputKey type, int[] positions, TupleMask callMask) {
+        this.callMask = callMask;
+        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.type = type;
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return positionList;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "check     " + type.getPrettyPrintableName() + "("
+                + positionList.stream().map(input -> String.format("+%s", variableMapping.apply(input))).collect(Collectors.joining(", "))
+                + ")";
+    }
+    @Override
+    public IInputKey getIteratedInputKey() {
+        return type;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeExtend.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeExtend.java
new file mode 100644
index 00000000..dfc3e9ad
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeExtend.java
@@ -0,0 +1,145 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations.generic;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.ExtendOperationExecutor;
+import tools.refinery.viatra.runtime.localsearch.operations.IIteratingSearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileMaskedTuple;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+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(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/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeExtendSingleValue.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeExtendSingleValue.java
new file mode 100644
index 00000000..45e4fd0e
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/generic/GenericTypeExtendSingleValue.java
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations.generic;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.IIteratingSearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.extend.SingleValueExtendOperationExecutor;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.VolatileMaskedTuple;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class GenericTypeExtendSingleValue implements IIteratingSearchOperation {
+    private class Executor extends  SingleValueExtendOperationExecutor<Object> {
+        
+        private final VolatileMaskedTuple maskedTuple;
+        
+        public Executor(int position) {
+            super(position);
+            this.maskedTuple = new VolatileMaskedTuple(callMask);
+        }
+        @Override
+        protected Iterator<? extends Object> getIterator(MatchingFrame frame, ISearchContext context) {
+            maskedTuple.updateTuple(frame);
+            return context.getRuntimeContext().enumerateValues(type, indexerMask, maskedTuple).iterator();
+        }
+        
+        @Override
+        public ISearchOperation getOperation() {
+            return GenericTypeExtendSingleValue.this;
+        }
+    }
+    
+    private final IInputKey type;
+    private final List<Integer> positionList;
+    private final TupleMask indexerMask;
+    private final TupleMask callMask;
+    private final int unboundVariableIndex;
+    /**
+     * 
+     * @param type
+     *            the type to execute the extend operation on
+     * @param positions
+     *            the parameter positions that represent the variables of the input key
+     */
+    public GenericTypeExtendSingleValue(IInputKey type, int[] positions, TupleMask callMask, TupleMask indexerMask, int unboundVariableIndex) {
+        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.unboundVariableIndex = unboundVariableIndex;
+        this.positionList = Collections.unmodifiableList(modifiablePositionList);
+        this.type = type;
+        this.callMask = callMask;
+        this.indexerMask = indexerMask;
+    }
+    @Override
+    public IInputKey getIteratedInputKey() {
+        return type;
+    }
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor(unboundVariableIndex);
+    }
+    @Override
+    public List<Integer> getVariablePositions() {
+        return positionList;
+    }
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    @Override
+    public String toString(Function<Integer, String> variableMapping) {
+        return "extend    " + type.getPrettyPrintableName() + "("
+                + positionList.stream().map(
+                        input -> String.format("%s%s", Objects.equals(input, unboundVariableIndex) ? "-" : "+", variableMapping.apply(input)))
+                        .collect(Collectors.joining(", "))
+                + ")";
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/util/CallInformation.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/util/CallInformation.java
new file mode 100644
index 00000000..b141a7b0
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/operations/util/CallInformation.java
@@ -0,0 +1,186 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.operations.util;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.matcher.CallWithAdornment;
+import tools.refinery.viatra.runtime.localsearch.matcher.MatcherReference;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.PatternCallBasedDeferred;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.BinaryReflexiveTransitiveClosure;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+/**
+ * This class stores a precompiled version of call-related metadata and masks for local search operations
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ */
+public final class CallInformation {
+    private final TupleMask fullFrameMask;   
+    private final TupleMask thinFrameMask;   
+    private final TupleMask parameterMask;
+    private final int[] freeParameterIndices;
+    
+    private final Map<PParameter, Integer> mapping = new HashMap<>();
+    private final Set<PParameter> adornment = new HashSet<>();
+    private final PQuery referredQuery;
+    private final MatcherReference matcherReference;
+    private final IQueryReference call;
+    private CallWithAdornment callWithAdornment;
+    
+    public static CallInformation create(PatternCallBasedDeferred constraint, Map<PVariable, Integer> variableMapping, Set<Integer> bindings) {
+        return new CallInformation(constraint.getActualParametersTuple(), constraint, bindings, variableMapping);
+    }
+    
+    public static CallInformation create(PositivePatternCall pCall, Map<PVariable, Integer> variableMapping, Set<Integer> bindings) {
+        return new CallInformation(pCall.getVariablesTuple(), pCall, bindings, variableMapping);
+    }
+    
+    public static CallInformation create(BinaryTransitiveClosure constraint, Map<PVariable, Integer> variableMapping, Set<Integer> bindings) {
+        return new CallInformation(constraint.getVariablesTuple(), constraint, bindings, variableMapping);
+    }
+    
+    /**
+     * @since 2.0
+     */
+    public static CallInformation create(BinaryReflexiveTransitiveClosure constraint, Map<PVariable, Integer> variableMapping, Set<Integer> bindings) {
+        return new CallInformation(constraint.getVariablesTuple(), constraint, bindings, variableMapping);
+    }
+    
+    private CallInformation(Tuple actualParameters, IQueryReference call, final Set<Integer> bindings,
+            Map<PVariable, Integer> variableMapping) {
+        this.call = call;
+        this.referredQuery = call.getReferredQuery();
+        int keySize = actualParameters.getSize();
+        List<Integer> parameterMaskIndices = new ArrayList<>();
+        int[] fullParameterMaskIndices = new int[keySize];
+        for (int i = 0; i < keySize; i++) {
+            PParameter symbolicParameter = referredQuery.getParameters().get(i);
+            PVariable parameter = (PVariable) actualParameters.get(i);
+            Integer originalFrameIndex = variableMapping.get(parameter);
+            mapping.put(symbolicParameter, originalFrameIndex);
+            fullParameterMaskIndices[i] = originalFrameIndex;
+            if (bindings.contains(originalFrameIndex)) {
+                parameterMaskIndices.add(originalFrameIndex);
+                adornment.add(symbolicParameter);
+            }
+        }
+        
+        thinFrameMask = TupleMask.fromSelectedIndices(variableMapping.size(), parameterMaskIndices);
+        fullFrameMask = TupleMask.fromSelectedIndices(variableMapping.size(), fullParameterMaskIndices);
+        
+        // This second iteration is necessary as we don't know beforehand the number of bound parameters
+        int[] boundParameterIndices = new int[adornment.size()];
+        int boundIndex = 0;
+        freeParameterIndices = new int[keySize - adornment.size()];
+        int freeIndex = 0;
+        for (int i = 0; i < keySize; i++) {
+            if (bindings.contains(variableMapping.get(actualParameters.get(i)))) {
+                boundParameterIndices[boundIndex] = i;
+                boundIndex++;
+            } else {
+                freeParameterIndices[freeIndex] = i;
+                freeIndex++;
+            }
+        }
+        parameterMask = TupleMask.fromSelectedIndices(keySize, boundParameterIndices);
+        callWithAdornment = new CallWithAdornment(call, adornment);
+        matcherReference = callWithAdornment.getMatcherReference();
+    }
+    /** 
+     * Returns a mask describing how the bound variables of a Matching Frame are mapped to parameter indexes
+     */
+    public TupleMask getThinFrameMask() {
+        return thinFrameMask;
+    }
+    
+    /** 
+     * Returns a mask describing how all variables of a Matching Frame are mapped to parameter indexes
+     */
+    public TupleMask getFullFrameMask() {
+        return fullFrameMask;
+    }
+    
+    /**
+     * Returns a mask describing the adornment the called pattern uses
+     */
+    public TupleMask getParameterMask() {
+        return parameterMask;
+    }
+    
+    public MatcherReference getReference() {
+        return matcherReference;
+    }
+    
+    /**
+     * @since 2.1
+     */
+    public IQueryReference getCall() {
+        return call;
+    }
+    
+    /**
+     * @since 2.1
+     */
+    public CallWithAdornment getCallWithAdornment() {
+        return callWithAdornment;
+    }
+    /**
+     * Returns the parameter indices that are unbound before the call
+     */
+    public int[] getFreeParameterIndices() {
+        return freeParameterIndices;
+    }
+    
+    public List<Integer> getVariablePositions() {
+        List<Integer> variables = new ArrayList<>(mapping.size());
+        for(PParameter p : referredQuery.getParameters()){
+            variables.add(mapping.get(p));
+        }
+        return variables;
+    }
+    
+    
+    
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+    
+    /**
+     * @since 2.0
+     */
+    public String toString(Function<Integer, String> variableMapping) {
+        return referredQuery.getFullyQualifiedName() + "("
+                + referredQuery.getParameters().stream().map(
+                        input -> (adornment.contains(input) ? "+" : "-") + variableMapping.apply(mapping.get(input)))
+                        .collect(Collectors.joining(","))
+                + ")";
+    }
+    
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/IPlanDescriptor.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/IPlanDescriptor.java
new file mode 100644
index 00000000..987996c9
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/IPlanDescriptor.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.plan;
+import java.util.Collection;
+import java.util.Set;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * Denotes an executable plan
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public interface IPlanDescriptor {
+    /**
+     * The query which this plan implements
+     */
+    public PQuery getQuery();
+    
+    /**
+     * The executable search plans for each body in the query
+     * @since 2.0
+     */
+    public Collection<SearchPlanForBody> getPlan();
+    
+    /**
+     * The set of parameters this plan assumes to be bound
+     */
+    public Set<PParameter> getAdornment();
+    
+    /**
+     * The collection of {@link IInputKey}s which needs to be iterated during the execution of this plan. For optimal
+     * performance, instances of these keys might be indexed.
+     */
+    public Set<IInputKey> getIteratedKeys();
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/IPlanProvider.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/IPlanProvider.java
new file mode 100644
index 00000000..b74282ca
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/IPlanProvider.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.plan;
+import tools.refinery.viatra.runtime.localsearch.matcher.MatcherReference;
+import tools.refinery.viatra.runtime.localsearch.matcher.integration.LocalSearchHints;
+import tools.refinery.viatra.runtime.localsearch.planner.compiler.IOperationCompiler;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+/**
+ * @author Grill Balázs
+ * @since 1.4
+ * @noreference This interface is not intended to be referenced by clients.
+ */
+public interface IPlanProvider {
+    /**
+     * @throws ViatraQueryRuntimeException
+     * @since 2.1
+     */
+    public IPlanDescriptor getPlan(IQueryBackendContext backend, IOperationCompiler compiler, 
+            ResultProviderRequestor resultProviderRequestor,
+            LocalSearchHints configuration, MatcherReference key);
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/PlanDescriptor.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/PlanDescriptor.java
new file mode 100644
index 00000000..a5565546
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/PlanDescriptor.java
@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.plan;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.operations.IIteratingSearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public class PlanDescriptor implements IPlanDescriptor {
+    private final PQuery pquery;
+    private final List<SearchPlanForBody> plan;
+    private final Set<PParameter> adornment;
+    private Set<IInputKey> iteratedKeys = null;
+    
+    public PlanDescriptor(PQuery pquery, Collection<SearchPlanForBody> plan, Set<PParameter> adornment) {
+        this.pquery = pquery;
+        this.plan = new ArrayList<>(plan);
+        this.adornment = adornment;
+    }
+    @Override
+    public PQuery getQuery() {
+        return pquery;
+    }
+    @Override
+    public Collection<SearchPlanForBody> getPlan() {
+        return plan;
+    }
+    @Override
+    public Set<PParameter> getAdornment() {
+        return adornment;
+    }
+    @Override
+    public Set<IInputKey> getIteratedKeys() {
+        if (iteratedKeys == null){
+            Set<IInputKey> keys = new HashSet<>();
+            for(SearchPlanForBody bodyPlan : plan){
+                for(ISearchOperation operation : bodyPlan.getCompiledOperations()){
+                    if (operation instanceof IIteratingSearchOperation){
+                        keys.add(((IIteratingSearchOperation) operation).getIteratedInputKey());
+                    }
+                }
+            }
+            iteratedKeys = Collections.unmodifiableSet(keys);
+        }
+        return iteratedKeys;
+    }
+    
+    @Override
+    public String toString() {
+        return new StringBuilder().append("Plan for ").append(pquery.getFullyQualifiedName()).append("(")
+        .append(adornment.stream().map(PParameter::getName).collect(Collectors.joining(",")))
+        .append("{")
+        .append(plan.stream().map(Object::toString).collect(Collectors.joining("}\n{")))
+        .append("}")
+        .toString();
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlan.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlan.java
new file mode 100644
index 00000000..3159f707
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlan.java
@@ -0,0 +1,99 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.plan;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+/**
+ * A SearchPlan stores a collection of SearchPlanOperations for a fixed order of variables.
+ * 
+ * @author Zoltan Ujhelyi
+ * 
+ */
+public class SearchPlan {
+    private final List<ISearchOperation> operations;
+    private final Map<Integer, PVariable> variableMapping;
+    private final TupleMask parameterMask;
+    private final PBody body;
+    
+    /**
+     * @since 2.0
+     */
+    public SearchPlan(PBody body, List<ISearchOperation> operations, TupleMask parameterMask, Map<PVariable, Integer> variableMapping) {
+        this.body = body;
+        this.operations = Collections.unmodifiableList(new ArrayList<>(operations));
+        this.parameterMask = parameterMask;
+        this.variableMapping = Collections.unmodifiableMap(variableMapping.entrySet().stream()
+                .collect(Collectors.toMap(Entry::getValue, Entry::getKey)));
+    }
+    /**
+     * Returns an immutable list of operations stored in the plan.
+     * @return the operations
+     */
+    public List<ISearchOperation> getOperations() {
+        return operations;
+    }
+    /**
+     * Returns an immutable map of variable mappings for the plan
+     * @since 2.0
+     */
+    public Map<Integer, PVariable> getVariableMapping() {
+        return variableMapping;
+    }
+    /**
+     * Returns the index of a given operation in the plan
+     * @since 2.0
+     */
+    public int getOperationIndex(ISearchOperation operation) {
+        return operations.indexOf(operation);
+    }
+    /**
+     * @since 2.0
+     */
+    public TupleMask getParameterMask() {
+        return parameterMask;
+    }
+    
+    /**
+     * @since 2.0
+     */
+    public PBody getSourceBody() {
+        return body;
+    }
+    
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+            
+        sb.append("{\n");
+        for(ISearchOperation operation : this.getOperations()){
+            sb.append("\t");
+            sb.append(operation);
+            sb.append("\n");
+        }
+        sb.append("}");
+        return sb.toString();
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlanExecutor.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlanExecutor.java
new file mode 100644
index 00000000..4a4e2450
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlanExecutor.java
@@ -0,0 +1,210 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Akos Horvath, Gergely Varro Zoltan Ujhelyi 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.viatra.runtime.localsearch.plan;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.stream.Collectors;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.exceptions.LocalSearchException;
+import tools.refinery.viatra.runtime.localsearch.matcher.ILocalSearchAdaptable;
+import tools.refinery.viatra.runtime.localsearch.matcher.ILocalSearchAdapter;
+import tools.refinery.viatra.runtime.localsearch.matcher.ISearchContext;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation.ISearchOperationExecutor;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * A search plan executor is used to execute {@link SearchPlan} instances.
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+public class SearchPlanExecutor implements ILocalSearchAdaptable {
+    private int currentOperation;
+    private final List<ISearchOperationExecutor> operations;
+    private final SearchPlan plan;
+    private final ISearchContext context;
+    private final List<ILocalSearchAdapter> adapters = new CopyOnWriteArrayList<>();
+    /**
+     * @since 2.0
+     */
+    public Map<Integer, PVariable> getVariableMapping() {
+        return plan.getVariableMapping();
+    }
+    public int getCurrentOperation() {
+        return currentOperation;
+    }
+    
+    public SearchPlan getSearchPlan() {
+        return plan;
+    }
+    
+    /**
+     * @since 1.7
+     */
+    public TupleMask getParameterMask() {
+        return plan.getParameterMask();
+    }
+    @Override
+    public void addAdapters(List<ILocalSearchAdapter> adapters) {
+        for(ILocalSearchAdapter adapter : adapters){
+            if (!this.adapters.contains(adapter)){
+                this.adapters.add(adapter);
+                adapter.adapterRegistered(this);
+            }
+        }
+    }
+    @Override
+    public void removeAdapters(List<ILocalSearchAdapter> adapters) {
+        for (ILocalSearchAdapter adapter : adapters) {
+            if (this.adapters.remove(adapter)){
+                adapter.adapterUnregistered(this);
+            }
+        }
+    }
+    /**
+     * @since 2.0
+     */
+    public SearchPlanExecutor(SearchPlan plan, ISearchContext context) {
+        Preconditions.checkArgument(context != null, "Context cannot be null");
+        this.plan = plan;
+        this.context = context;
+        operations = plan.getOperations().stream().map(ISearchOperation::createExecutor).collect(Collectors.toList());
+        this.currentOperation = -1;
+    }
+   
+    private void init(MatchingFrame frame) {
+        if (currentOperation == -1) {
+            currentOperation++;
+            ISearchOperationExecutor operation = operations.get(currentOperation);
+            if (!adapters.isEmpty()){
+                for (ILocalSearchAdapter adapter : adapters) {
+                    adapter.executorInitializing(plan, frame);
+                }
+            }
+            operation.onInitialize(frame, context);
+        } else if (currentOperation == operations.size()) {
+            currentOperation--;
+        } else {
+            throw new LocalSearchException(LocalSearchException.PLAN_EXECUTION_ERROR);
+        }
+    }
+    /**
+     * Calculates the cost of the search plan.
+     */
+    public double cost() {
+        /* default generated stub */
+        return 0.0;
+    }
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public boolean execute(MatchingFrame frame) {
+        int upperBound = operations.size() - 1;
+        init(frame);
+        operationSelected(frame, currentOperation, false);
+        while (currentOperation >= 0 && currentOperation <= upperBound) {
+            if (operations.get(currentOperation).execute(frame, context)) {
+                operationExecuted(frame, currentOperation, true);
+                currentOperation++;
+                operationSelected(frame, currentOperation, false);
+                if (currentOperation <= upperBound) {
+                    ISearchOperationExecutor operation = operations.get(currentOperation);
+                    operation.onInitialize(frame, context);
+                }
+            } else {
+                operationExecuted(frame, currentOperation, false);
+                ISearchOperationExecutor operation = operations.get(currentOperation);
+                operation.onBacktrack(frame, context);
+                currentOperation--;
+                operationSelected(frame, currentOperation, true);
+            }
+        }
+        boolean matchFound = currentOperation > upperBound;
+        if (matchFound && !adapters.isEmpty()) {
+            for (ILocalSearchAdapter adapter : adapters) {
+                adapter.matchFound(plan, frame);
+            }
+        }
+        return matchFound;
+    }
+    
+    public void resetPlan() {
+        currentOperation = -1;
+    }
+    
+    public void printDebugInformation() {
+        for (int i = 0; i < operations.size(); i++) {
+            Logger.getRootLogger().debug("[" + i + "]\t" + operations.get(i).toString());
+        }
+    }
+    
+    private void operationExecuted(MatchingFrame frame, int operationIndex, boolean isSuccessful) {
+        if (!adapters.isEmpty()){
+            for (ILocalSearchAdapter adapter : adapters) {
+                adapter.operationExecuted(plan, operations.get(operationIndex).getOperation(), frame, isSuccessful);
+            }
+        }
+    }
+    
+    private void operationSelected(MatchingFrame frame, int operationIndex, boolean isBacktrack) {
+        if (!adapters.isEmpty() && operationIndex >= 0 && operationIndex < operations.size()){
+            for (ILocalSearchAdapter adapter : adapters) {
+                adapter.operationSelected(plan, operations.get(operationIndex).getOperation(), frame, isBacktrack);
+            }
+        }
+    }
+    public ISearchContext getContext() {
+        return context;
+    }
+    @Override
+    public List<ILocalSearchAdapter> getAdapters() {
+        return Collections.<ILocalSearchAdapter>unmodifiableList(this.adapters);
+    }
+    @Override
+    public void addAdapter(ILocalSearchAdapter adapter) {
+        addAdapters(Collections.singletonList(adapter));
+    }
+    @Override
+    public void removeAdapter(ILocalSearchAdapter adapter) {
+        removeAdapters(Collections.singletonList(adapter));
+    }
+    @Override
+    public String toString() {
+        if (operations == null) {
+            return "Unspecified plan";
+        } else {
+            return operations.stream().map(Object::toString).collect(Collectors.joining("\n"));
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlanForBody.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlanForBody.java
new file mode 100644
index 00000000..e0300da4
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SearchPlanForBody.java
@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, 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.viatra.runtime.localsearch.plan;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.matcher.CallWithAdornment;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+/**
+ * This class is responsible for storing the results of the planner and operation compiler for a selected body.
+ * @since 2.0
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+public class SearchPlanForBody {
+    private final PBody body;
+    private final Map<PVariable, Integer> variableKeys;
+    private final int[] parameterKeys;
+    private final SubPlan plan;
+    private final List<ISearchOperation> compiledOperations;
+    private final Collection<CallWithAdornment> dependencies;
+    private final double cost;
+    private final Object internalRepresentation;
+    
+    /**
+     * @since 2.1
+     */
+    public SearchPlanForBody(PBody body, Map<PVariable, Integer> variableKeys,
+            SubPlan plan, List<ISearchOperation> compiledOperations, Collection<CallWithAdornment> dependencies,
+            Object internalRepresentation, double cost) {
+        super();
+        this.body = body;
+        this.variableKeys = variableKeys;
+        this.plan = plan;
+        this.internalRepresentation = internalRepresentation;
+        this.cost = cost;
+        List<PVariable> parameters = body.getSymbolicParameterVariables();
+        parameterKeys = new int[parameters.size()];
+        for (int i=0; i<parameters.size(); i++) {
+            parameterKeys[i] = variableKeys.get(parameters.get(i));
+        }
+        this.compiledOperations = new ArrayList<>(compiledOperations.size()+1);
+        this.compiledOperations.addAll(compiledOperations);
+        
+        this.dependencies = new ArrayList<>(dependencies);
+    }
+    public PBody getBody() {
+        return body;
+    }
+    public Map<PVariable, Integer> getVariableKeys() {
+        return variableKeys;
+    }
+    public int[] getParameterKeys() {
+        return Arrays.copyOf(parameterKeys, parameterKeys.length);
+    }
+    public List<ISearchOperation> getCompiledOperations() {
+        return compiledOperations;
+    }
+    public SubPlan getPlan() {
+        return plan;
+    }
+    
+    public Collection<CallWithAdornment> getDependencies() {
+        return dependencies;
+    }
+    
+    public TupleMask calculateParameterMask() {
+        return TupleMask.fromSelectedIndices(variableKeys.size(), parameterKeys);
+    }
+    
+    @Override
+    public String toString() {
+        return compiledOperations.stream().map(Object::toString).collect(Collectors.joining("\n"));
+    }
+    /**
+     * @since 2.1
+     */
+    public double getCost() {
+        return cost;
+    }
+    /**
+     * @return The internal representation of the search plan, if any, for traceability
+     * @since 2.1
+     */
+    public Object getInternalRepresentation() {
+        return internalRepresentation;
+    }
+    
+    
+    
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SimplePlanProvider.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SimplePlanProvider.java
new file mode 100644
index 00000000..ed31bcb0
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/plan/SimplePlanProvider.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.plan;
+import java.util.Collection;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.localsearch.matcher.MatcherReference;
+import tools.refinery.viatra.runtime.localsearch.matcher.integration.LocalSearchHints;
+import tools.refinery.viatra.runtime.localsearch.planner.LocalSearchPlanner;
+import tools.refinery.viatra.runtime.localsearch.planner.compiler.IOperationCompiler;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+/**
+ * A plan provider implementation which caches previously calculated plans to avoid re-planning for the same adornment
+ * 
+ * @author Grill Balázs
+ * @since 1.7
+ *
+ */
+public class SimplePlanProvider implements IPlanProvider {
+    private final Logger logger;
+    
+    public SimplePlanProvider(Logger logger) {
+        this.logger = logger;
+    }
+    
+    @Override
+    public IPlanDescriptor getPlan(IQueryBackendContext backend, IOperationCompiler compiler, 
+            final ResultProviderRequestor resultRequestor,
+            final LocalSearchHints configuration, MatcherReference key) {
+        
+        LocalSearchPlanner planner = new LocalSearchPlanner(backend, compiler, logger, configuration, resultRequestor);
+        
+        Collection<SearchPlanForBody> plansForBodies = planner.plan(key.getQuery(), key.getAdornment());
+      
+        IPlanDescriptor plan = new PlanDescriptor(key.getQuery(), plansForBodies, key.getAdornment());
+        return plan;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/ILocalSearchPlanner.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/ILocalSearchPlanner.java
new file mode 100644
index 00000000..dfd9a3c8
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/ILocalSearchPlanner.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.planner;
+import java.util.Collection;
+import java.util.Set;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlanForBody;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ */
+public interface ILocalSearchPlanner {
+    /**
+     * Creates executable plans for the provided query. It is required to call one of the
+     * <code>initializePlanner()</code> methods before calling this method.
+     * 
+     * @param querySpec
+     * @param boundParameters
+     *            a set of bound parameters
+     * @return a mapping between ISearchOperation list and a mapping, that holds a PVariable-Integer mapping for the
+     *         list of ISearchOperations
+     * @throws ViatraQueryRuntimeException
+     */
+    Collection<SearchPlanForBody> plan(PQuery querySpec, Set<PParameter> boundParameters);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/ISearchPlanCodeGenerator.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/ISearchPlanCodeGenerator.java
new file mode 100644
index 00000000..72218337
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/ISearchPlanCodeGenerator.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.planner;
+import java.util.List;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+/**
+ * @author Marton Bur
+ *
+ */
+public interface ISearchPlanCodeGenerator {
+    void compile(List<List<ISearchOperation>> plans);
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/LocalSearchPlanner.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/LocalSearchPlanner.java
new file mode 100644
index 00000000..f44be655
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/LocalSearchPlanner.java
@@ -0,0 +1,140 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.planner;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.localsearch.matcher.integration.LocalSearchHints;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlanForBody;
+import tools.refinery.viatra.runtime.localsearch.planner.compiler.IOperationCompiler;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.PBodyNormalizer;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.PDisjunctionRewriter;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.PDisjunctionRewriterCacher;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.PQueryFlattener;
+/**
+ * 
+ * @author Marton Bur
+ * @noreference This class is not intended to be referenced by clients.
+ */
+public class LocalSearchPlanner implements ILocalSearchPlanner {
+    // Externally set tools for planning
+    private final PDisjunctionRewriter preprocessor;
+    private final LocalSearchRuntimeBasedStrategy plannerStrategy;
+    private final IQueryRuntimeContext runtimeContext;
+    private final LocalSearchHints configuration;
+    private final IOperationCompiler operationCompiler;
+    private final IQueryBackendContext context;
+    private final ResultProviderRequestor resultRequestor;
+    
+    /**
+     * @param resultRequestor 
+     * @since 1.7
+     */
+    public LocalSearchPlanner(IQueryBackendContext backendContext, IOperationCompiler compiler, Logger logger, 
+            final LocalSearchHints configuration, ResultProviderRequestor resultRequestor) 
+    {
+        this.runtimeContext = backendContext.getRuntimeContext();
+        this.configuration = configuration;
+        this.operationCompiler = compiler;
+        this.resultRequestor = resultRequestor;
+        PQueryFlattener flattener = new PQueryFlattener(configuration.getFlattenCallPredicate());
+        /*
+         * TODO https://bugs.eclipse.org/bugs/show_bug.cgi?id=439358: The normalizer is initialized with the false
+         * parameter to turn off unary constraint elimination to work around an issue related to plan ordering: the
+         * current implementation of the feature target checking operations expect that the source types were checked
+         * before. However, this causes duplicate constraint checks in the search plan that might affect performance
+         * negatively.
+         */
+        PBodyNormalizer normalizer = new PBodyNormalizer(runtimeContext.getMetaContext()) {
+            
+            @Override
+            protected boolean shouldCalculateImpliedTypes(PQuery query) {
+                return false;
+            }
+        };
+        preprocessor = new PDisjunctionRewriterCacher(flattener, normalizer);
+        plannerStrategy = new LocalSearchRuntimeBasedStrategy();
+        context = backendContext;
+    }
+    /**
+     * Creates executable plans for the provided query. It is required to call one of the
+     * <code>initializePlanner()</code> methods before calling this method.
+     * 
+     * @param querySpec
+     * @param boundParameters
+     *            a set of bound parameters
+     * @return a mapping between ISearchOperation list and a mapping, that holds a PVariable-Integer mapping for the
+     *         list of ISearchOperations
+     */
+    @Override
+    public Collection<SearchPlanForBody> plan(PQuery querySpec, Set<PParameter> boundParameters) {
+        // 1. Preparation
+        preprocessor.setTraceCollector(configuration.getTraceCollector());
+        Set<PBody> normalizedBodies = preprocessor.rewrite(querySpec.getDisjunctBodies()).getBodies();
+        List<SearchPlanForBody> plansForBodies = new ArrayList<>(normalizedBodies.size());
+        for (PBody normalizedBody : normalizedBodies) {
+            // 2. Plan creation
+            // Context has matchers for the referred Queries (IQuerySpecifications)
+            Set<PVariable> boundVariables = calculatePatternAdornmentForPlanner(boundParameters, normalizedBody);
+            PlanState searchPlanInternal = plannerStrategy.plan(normalizedBody, boundVariables, context, resultRequestor, configuration);
+            SubPlan plan = plannerStrategy.convertPlan(boundVariables, searchPlanInternal);
+            // 3. PConstraint -> POperation compilation step
+            // * Pay extra caution to extend operations, when more than one variables are unbound
+            List<ISearchOperation> compiledOperations = operationCompiler.compile(plan, boundParameters);
+            // Store the variable mappings for the plans for debug purposes (traceability information)
+            SearchPlanForBody compiledPlan = new SearchPlanForBody(normalizedBody,
+                    operationCompiler.getVariableMappings(), plan, compiledOperations,
+                    operationCompiler.getDependencies(), 
+                    searchPlanInternal, searchPlanInternal.getCost());
+            plansForBodies.add(compiledPlan);
+        }
+        return plansForBodies;
+    }
+    private Set<PVariable> calculatePatternAdornmentForPlanner(Set<PParameter> boundParameters, PBody normalizedBody) {
+        Map<PParameter, PVariable> parameterMapping = new HashMap<>();
+        for (ExportedParameter constraint : normalizedBody.getSymbolicParameters()) {
+            parameterMapping.put(constraint.getPatternParameter(), constraint.getParameterVariable());
+        }
+        Set<PVariable> boundVariables = new HashSet<>();
+        for (PParameter parameter : boundParameters) {
+            PVariable mappedParameter = parameterMapping.get(parameter);
+            boundVariables.add(mappedParameter);
+        }
+        return boundVariables;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/LocalSearchRuntimeBasedStrategy.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/LocalSearchRuntimeBasedStrategy.java
new file mode 100644
index 00000000..1bebe37e
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/LocalSearchRuntimeBasedStrategy.java
@@ -0,0 +1,257 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.planner;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import tools.refinery.viatra.runtime.localsearch.matcher.integration.LocalSearchHints;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.ICostFunction;
+import tools.refinery.viatra.runtime.localsearch.planner.util.OperationCostComparator;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlanFactory;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PApply;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PProject;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PStart;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.util.Sets;
+/**
+ * This class contains the logic for local search plan calculation based on costs of the operations.
+ * Its name refers to the fact that the strategy tries to use as much information as available about
+ * the model on which the matching is initiated. When no runtime info is available, it falls back to 
+ * the information available from the metamodel durint operation cost calculation.
+ * 
+ * The implementation is based on the paper "Gergely Varró, Frederik Deckwerth, Martin Wieber, and Andy Schürr: 
+ * An algorithm for generating model-sensitive search plans for pattern matching on EMF models" 
+ * (DOI: 10.1007/s10270-013-0372-2)
+ * 
+ * @author Marton Bur
+ * @noreference This class is not intended to be referenced by clients.
+ */
+public class LocalSearchRuntimeBasedStrategy {
+    
+    private final OperationCostComparator infoComparator = new OperationCostComparator();
+    /**
+     * Converts a plan to the standard format
+     */
+    protected SubPlan convertPlan(Set<PVariable> initialBoundVariables, PlanState searchPlan) {
+        PBody pBody;
+        pBody = searchPlan.getAssociatedPBody();
+        
+        // Create a starting plan
+        SubPlanFactory subPlanFactory = new SubPlanFactory(pBody);
+        // We assume that the adornment (now the bound variables) is previously set
+        SubPlan plan = subPlanFactory.createSubPlan(new PStart(initialBoundVariables));
+        List<PConstraintInfo> operations = searchPlan.getOperations();
+        for (PConstraintInfo pConstraintPlanInfo : operations) {
+            PConstraint pConstraint = pConstraintPlanInfo.getConstraint();
+            plan = subPlanFactory.createSubPlan(new PApply(pConstraint), plan);
+        }
+        return subPlanFactory.createSubPlan(new PProject(pBody.getSymbolicParameterVariables()), plan);
+    }
+    /**
+     * The implementation of a local search-based algorithm to create a search plan for a flattened (and normalized)
+     * PBody
+     * @param pBody for which the plan is to be created
+     * @param initialBoundVariables variables that are known to have already assigned values
+     * @param context the backend context
+     * @param resultProviderRequestor requestor for accessing result providers of called patterns
+     * @param configuration the planner configuration
+     * @return the complete search plan for the given {@link PBody}
+     * @since 2.1
+     */
+    protected PlanState plan(PBody pBody, Set<PVariable> initialBoundVariables,
+            IQueryBackendContext context, final ResultProviderRequestor resultProviderRequestor,
+            LocalSearchHints configuration) {
+        final ICostFunction costFunction = configuration.getCostFunction();
+        PConstraintInfoInferrer pConstraintInfoInferrer = new PConstraintInfoInferrer(
+                configuration.isUseBase(), context, resultProviderRequestor, costFunction::apply);
+        
+        // Create mask infos
+        Set<PConstraint> constraintSet = pBody.getConstraints();
+        List<PConstraintInfo> constraintInfos = 
+                pConstraintInfoInferrer.createPConstraintInfos(constraintSet);
+        
+        // Calculate the characteristic function
+        // The characteristic function tells whether a given adornment is backward reachable from the (B)* state, where
+        // each variable is bound.
+        // The characteristic function is represented as a set of set of variables
+        // TODO this calculation is not not implemented yet, thus the contents of the returned set is not considered later
+        List<Set<PVariable>> reachableBoundVariableSets = reachabilityAnalysis(pBody, constraintInfos);
+        int k = configuration.getRowCount();
+        PlanState searchPlan = calculateSearchPlan(pBody, initialBoundVariables, k, reachableBoundVariableSets, constraintInfos);
+        return searchPlan;
+    }
+    private PlanState calculateSearchPlan(PBody pBody, Set<PVariable> initialBoundVariables, int k,
+            List<Set<PVariable>> reachableBoundVariableSets, List<PConstraintInfo> allMaskInfos) {
+        List<PConstraintInfo> allPotentialExtendInfos = new ArrayList<>();
+        List<PConstraintInfo> allPotentialCheckInfos = new ArrayList<>();
+        Map<PVariable, List<PConstraintInfo>> checkOpsByVariables = new HashMap<>();
+        Map<PVariable, Collection<PConstraintInfo>> extendOpsByBoundVariables = new HashMap<>();
+        
+        for (PConstraintInfo op : allMaskInfos) {
+            if (op.getFreeVariables().isEmpty()) { // CHECK
+                allPotentialCheckInfos.add(op);
+            } else { // EXTEND
+                allPotentialExtendInfos.add(op);
+                for (PVariable variable : op.getBoundVariables()) {
+                    extendOpsByBoundVariables.computeIfAbsent(variable, v -> new ArrayList<>()).add(op);
+                }
+            }
+        }
+        // For CHECKs only, we must start from lists that are ordered by the cost of the constraint application
+        Collections.sort(allPotentialCheckInfos, infoComparator);  // costs are eagerly needed for check ops          
+        for (PConstraintInfo op : allPotentialCheckInfos) {
+            for (PVariable variable : op.getBoundVariables()) {
+                checkOpsByVariables.computeIfAbsent(variable, v -> new ArrayList<>()).add(op);
+            }
+        }
+        // costs are not needed for extend ops until they are first applied (TODO make cost computaiton on demand) 
+        
+        
+        // rename for better understanding
+        Set<PVariable> boundVariables = initialBoundVariables;
+        Set<PVariable> freeVariables = Sets.difference(pBody.getUniqueVariables(), initialBoundVariables);
+        int variableCount = pBody.getUniqueVariables().size();
+        int n = freeVariables.size();
+        List<List<PlanState>> stateTable = initializeStateTable(k, n);
+        // Set initial state: begin with an empty operation list
+        PlanState initialState = new PlanState(pBody, boundVariables);
+        
+        // Initial state creation, categorizes all operations; add present checks to operationsList
+        initialState.updateExtends(allPotentialExtendInfos);
+        initialState.applyChecks(allPotentialCheckInfos);
+        stateTable.get(n).add(0, initialState);
+        
+        // stateTable.get(0) will contain the states with adornment B*
+        for (int i = n; i > 0; i--) {
+            for (int j = 0; j < k && j < stateTable.get(i).size(); j++) {
+                PlanState currentState = stateTable.get(i).get(j);
+                for (PConstraintInfo constraintInfo : currentState.getPresentExtends()) {
+                    // for each present EXTEND operation
+                    PlanState newState = calculateNextState(currentState, constraintInfo);
+                    // also eagerly perform any CHECK operations that become applicable (extends still deferred)
+                    newState.applyChecksBasedOnDelta(checkOpsByVariables);
+                    
+                    if(currentState.getBoundVariables().size() == newState.getBoundVariables().size()){
+                        // This means no variable binding was done, go on with the next constraint info
+                        continue;
+                    }
+                    int i2 = variableCount - newState.getBoundVariables().size();
+                    
+                    List<Integer> newIndices = determineIndices(stateTable, i2, newState, k);
+                    int a = newIndices.get(0);
+                    int c = newIndices.get(1);
+                    if (checkInsertCondition(stateTable.get(i2), newState, reachableBoundVariableSets, a, c, k)) {
+                        updateExtends(newState, currentState, extendOpsByBoundVariables); // preprocess next steps 
+                        insert(stateTable,i2, newState, a, c, k);
+                    }
+                }
+            }
+        }
+        return stateTable.get(0).get(0);
+    }
+    private List<List<PlanState>> initializeStateTable(int k, int n) {
+        List<List<PlanState>> stateTable = new ArrayList<>();
+        // Initialize state table and fill it with null
+        for (int i = 0; i <= n ; i++) {
+            stateTable.add(new ArrayList<>());
+        }
+        return stateTable;
+    }
+    private void insert(List<List<PlanState>> stateTable, int idx, PlanState newState, int a, int c, int k) {
+        stateTable.get(idx).add(c, newState);
+        while(stateTable.get(idx).size() > k){
+            // Truncate back to size k when grows too big
+            stateTable.set(idx, stateTable.get(idx).subList(0, k));
+        }
+    }
+    private void updateExtends(PlanState newState, PlanState currentState,  
+            Map<PVariable, ? extends Collection<PConstraintInfo>> extendOpsByBoundVariables) 
+    {
+        List<PConstraintInfo> presentExtends = currentState.getPresentExtends();
+        // Recategorize operations
+        newState.updateExtendsBasedOnDelta(presentExtends, extendOpsByBoundVariables);
+        
+        return;
+    }
+    private boolean checkInsertCondition(List<PlanState> list, PlanState newState,
+            List<Set<PVariable>> reachableBoundVariableSets, int a, int c, int k) {
+//        boolean isAmongBestK = (a == (k + 1)) && c < a && reachableBoundVariableSets.contains(newState.getBoundVariables());
+        boolean isAmongBestK = a == k && c < a ;
+        boolean isBetterThanCurrent = a < k && c <= a;
+        return isAmongBestK || isBetterThanCurrent;
+    }
+    private List<Integer> determineIndices(List<List<PlanState>> stateTable, int i2, PlanState newState, int k) {
+        int a = k;
+        int c = 0;
+        List<Integer> acIndices = new ArrayList<>();
+        for (int j = 0; j < k; j++) {
+            if (j < stateTable.get(i2).size()) {
+                PlanState stateInTable = stateTable.get(i2).get(j);
+                if (newState.getBoundVariables().equals(stateInTable.getBoundVariables())) {
+                    // The new state has the same adornment as the stored one - they are not adornment disjoint
+                    a = j;
+                }
+                if (newState.getCost() >= stateInTable.getCost()) {
+                    c = j + 1;
+                }
+            } else {
+                break;
+            }
+        }
+        acIndices.add(a);
+        acIndices.add(c);
+        return acIndices;
+    }
+    private PlanState calculateNextState(PlanState currentState, PConstraintInfo constraintInfo) {
+        return currentState.cloneWithApplied(constraintInfo);
+    }
+    private List<Set<PVariable>> reachabilityAnalysis(PBody pBody, List<PConstraintInfo> constraintInfos) {
+        // TODO implement reachability analisys, also save/persist the results somewhere
+        List<Set<PVariable>> reachableBoundVariableSets = new ArrayList<>();
+        return reachableBoundVariableSets;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintCategory.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintCategory.java
new file mode 100644
index 00000000..b98dd12e
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintCategory.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Marton Bur, 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.viatra.runtime.localsearch.planner;
+/**
+ * Expresses the state of a PConstraint application 
+ * condition with respect to a given adornment.
+ * 
+ * @author Marton Bur
+ * @noreference This enum is not intended to be referenced by clients.
+ */
+public enum PConstraintCategory {
+    /*
+     * During plan creation an operation is considered a past 
+     * operation, if an already bound variable is free in the
+     * mask of the operation.
+     * (Mask of the operation: the required binding state of 
+     * the affected variables)
+     */
+    PAST, 
+    /*
+     * The binding states of the variables in the operation 
+     * mask correspond to the current binding states of the 
+     * variables in the search plan
+     */
+    PRESENT, 
+    /*
+     * There is at least one bound variable in the mask of 
+     * a future operation that is still free at the current 
+     * state of the plan. Also, a future operation can't be 
+     * PAST.
+     */
+    FUTURE;
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintInfo.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintInfo.java
new file mode 100644
index 00000000..c2c76ef2
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintInfo.java
@@ -0,0 +1,142 @@
+/** 
+ * Copyright (c) 2010-2015, Marton Bur, Zoltan Ujhelyi, Akos Horvath, Istvan Rath and Danil 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.viatra.runtime.localsearch.planner;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.function.Function;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.IConstraintEvaluationContext;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryResultProviderAccess;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.analysis.QueryAnalyzer;
+/** 
+ * Wraps a PConstraint together with information required for the planner. Currently contains information about the expected binding state of
+ * the affected variables also called application condition, and the cost of the enforcement, based on the meta and/or the runtime context.
+ *  
+ * @author Marton Bur
+ * @noreference This class is not intended to be referenced by clients.
+ */
+public class PConstraintInfo implements IConstraintEvaluationContext {
+    private PConstraint constraint;
+    private Set<PVariable> boundMaskVariables;
+    private Set<PVariable> freeMaskVariables;
+    private Set<PConstraintInfo> sameWithDifferentBindings;
+    private IQueryRuntimeContext runtimeContext;
+    private QueryAnalyzer queryAnalyzer;
+    private IQueryResultProviderAccess resultProviderAccess;
+    private ResultProviderRequestor resultRequestor;
+    private Double cost;
+    private Function<IConstraintEvaluationContext, Double> costFunction;
+    
+    /** 
+     * Instantiates the wrapper
+     * @param constraintfor which the information is added and stored
+     * @param boundMaskVariables the bound variables in the operation mask
+     * @param freeMaskVariables the free variables in the operation mask
+     * @param sameWithDifferentBindings during the planning process, multiple operation adornments are considered for a constraint, so that it
+     * is represented by multiple plan infos. This parameter contains all plan infos that are for the same
+     * constraint, but with different adornment
+     * @param context the query backend context
+     */
+    public PConstraintInfo(PConstraint constraint, Set<PVariable> boundMaskVariables, Set<PVariable> freeMaskVariables,
+        Set<PConstraintInfo> sameWithDifferentBindings, 
+        IQueryBackendContext context,
+        ResultProviderRequestor resultRequestor,
+        Function<IConstraintEvaluationContext, Double> costFunction) {
+        this.constraint = constraint;
+        this.costFunction = costFunction;
+        this.boundMaskVariables = new LinkedHashSet<>(boundMaskVariables);
+        this.freeMaskVariables = new LinkedHashSet<>(freeMaskVariables);
+        this.sameWithDifferentBindings = sameWithDifferentBindings;
+        this.resultRequestor = resultRequestor;
+        this.runtimeContext = context.getRuntimeContext();
+        this.queryAnalyzer = context.getQueryAnalyzer();
+        this.resultProviderAccess = context.getResultProviderAccess();
+        this.cost = null; // cost will be computed lazily (esp. important for pattern calls)
+    }
+    
+    @Override
+    public IQueryRuntimeContext getRuntimeContext() {
+        return runtimeContext;
+    }
+    @Override
+    public QueryAnalyzer getQueryAnalyzer() {
+        return queryAnalyzer;
+    }
+    @Override
+    public PConstraint getConstraint() {
+        return constraint;
+    }
+    @Override
+    public Set<PVariable> getFreeVariables() {
+        return freeMaskVariables;
+    }
+    @Override
+    public Set<PVariable> getBoundVariables() {
+        return boundMaskVariables;
+    }
+    public Set<PConstraintInfo> getSameWithDifferentBindings() {
+        return sameWithDifferentBindings;
+    }
+    public double getCost() {
+        if (cost == null) {
+            // Calculate cost of the constraint based on its type
+            cost = costFunction.apply(this);
+        }
+        return cost;
+    }
+    public PConstraintCategory getCategory(PBody pBody, Set<PVariable> boundVariables) {
+        if (!Collections.disjoint(boundVariables, this.freeMaskVariables)) {
+            return PConstraintCategory.PAST;
+        } else if (!boundVariables.containsAll(this.boundMaskVariables)) {
+            return PConstraintCategory.FUTURE;
+        } else {
+            return PConstraintCategory.PRESENT;
+        }
+    }
+    @Override
+    public String toString() {
+        return String.format("%s, bound variables: %s, cost: \"%.2f\"", constraint.toString(), boundMaskVariables.toString(), cost);
+    }
+    /**
+     * @deprecated use {@link #resultProviderRequestor()}
+     */
+    @Override
+    @Deprecated
+    public IQueryResultProviderAccess resultProviderAccess() {
+        return resultProviderAccess;
+    }
+    
+    @Override
+    public ResultProviderRequestor resultProviderRequestor() {
+        return resultRequestor;
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintInfoInferrer.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintInfoInferrer.java
new file mode 100644
index 00000000..eeac07ce
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PConstraintInfoInferrer.java
@@ -0,0 +1,278 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.planner;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.IConstraintEvaluationContext;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.*;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.AbstractTransitiveClosure;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameterDirection;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.Sets;
+import java.util.*;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+/**
+ * @author Grill Balázs
+ * @noreference This class is not intended to be referenced by clients.
+ */
+class PConstraintInfoInferrer {
+    private static final Predicate<PVariable> SINGLE_USE_VARIABLE = input -> input != null && input.getReferringConstraints().size() == 1;
+    private final boolean useIndex;
+    private final Function<IConstraintEvaluationContext, Double> costFunction;
+    private final IQueryBackendContext context;
+    private final ResultProviderRequestor resultRequestor;
+    public PConstraintInfoInferrer(boolean useIndex,
+            IQueryBackendContext backendContext,
+            ResultProviderRequestor resultRequestor,
+            Function<IConstraintEvaluationContext, Double> costFunction) {
+        this.useIndex = useIndex;
+        this.context = backendContext;
+        this.resultRequestor = resultRequestor;
+        this.costFunction = costFunction;
+    }
+    /**
+     * Create all possible application condition for all constraint
+     *
+     * @param constraintSet the set of constraints
+     * @return a collection of the wrapper PConstraintInfo objects with all the allowed application conditions
+     */
+    public List<PConstraintInfo> createPConstraintInfos(Set<PConstraint> constraintSet) {
+        List<PConstraintInfo> constraintInfos = new ArrayList<>();
+        for (PConstraint pConstraint : constraintSet) {
+            createPConstraintInfoDispatch(constraintInfos, pConstraint);
+        }
+        return constraintInfos;
+    }
+    private void createPConstraintInfoDispatch(List<PConstraintInfo> resultList, PConstraint pConstraint){
+        if(pConstraint instanceof ExportedParameter){
+            createConstraintInfoExportedParameter(resultList, (ExportedParameter) pConstraint);
+        } else if(pConstraint instanceof TypeConstraint){
+            createConstraintInfoTypeConstraint(resultList, (TypeConstraint)pConstraint);
+        } else if(pConstraint instanceof TypeFilterConstraint){
+            createConstraintInfoTypeFilterConstraint(resultList, (TypeFilterConstraint)pConstraint);
+        } else if(pConstraint instanceof ConstantValue){
+            createConstraintInfoConstantValue(resultList, (ConstantValue)pConstraint);
+        } else if (pConstraint instanceof Inequality){
+            createConstraintInfoInequality(resultList, (Inequality) pConstraint);
+        } else if (pConstraint instanceof ExpressionEvaluation){
+            createConstraintInfoExpressionEvaluation(resultList, (ExpressionEvaluation)pConstraint);
+        } else if (pConstraint instanceof AggregatorConstraint){
+            createConstraintInfoAggregatorConstraint(resultList, pConstraint, ((AggregatorConstraint) pConstraint).getResultVariable());
+        } else if (pConstraint instanceof PatternMatchCounter){
+            createConstraintInfoAggregatorConstraint(resultList, pConstraint, ((PatternMatchCounter) pConstraint).getResultVariable());
+        } else if (pConstraint instanceof PositivePatternCall){
+            createConstraintInfoPositivePatternCall(resultList, (PositivePatternCall) pConstraint);
+        } else if (pConstraint instanceof AbstractTransitiveClosure) {
+            createConstraintInfoBinaryTransitiveClosure(resultList, (AbstractTransitiveClosure) pConstraint);
+        } else{
+            createConstraintInfoGeneric(resultList, pConstraint);
+        }
+    }
+    private void createConstraintInfoConstantValue(List<PConstraintInfo> resultList,
+            ConstantValue pConstraint) {
+        // A ConstantValue constraint has a single variable, which is allowed to be unbound
+        // (extending through ConstantValue is considered a cheap operation)
+        Set<PVariable> affectedVariables = pConstraint.getAffectedVariables();
+        Set<? extends Set<PVariable>> bindings = Sets.powerSet(affectedVariables);
+        doCreateConstraintInfos(resultList, pConstraint, affectedVariables, bindings);
+    }
+    private void createConstraintInfoPositivePatternCall(List<PConstraintInfo> resultList,
+            PositivePatternCall pCall) {
+        // A pattern call can have any of its variables unbound
+        Set<PVariable> affectedVariables = pCall.getAffectedVariables();
+        // IN parameters cannot be unbound and
+        // OUT parameters cannot be bound
+        Tuple variables = pCall.getVariablesTuple();
+        final Set<PVariable> inVariables = new HashSet<>();
+        Set<PVariable> inoutVariables = new HashSet<>();
+        List<PParameter> parameters = pCall.getReferredQuery().getParameters();
+        for(int i=0;i<parameters.size();i++){
+            switch(parameters.get(i).getDirection()){
+            case IN:
+                inVariables.add((PVariable) variables.get(i));
+                break;
+            case INOUT:
+                inoutVariables.add((PVariable) variables.get(i));
+                break;
+            case OUT:
+            default:
+                break;
+            }
+        }
+        Iterable<Set<PVariable>> bindings = Sets.powerSet(inoutVariables).stream()
+                .map(input -> Stream.concat(input.stream(), inVariables.stream()).collect(Collectors.toSet()))
+                .collect(Collectors.toSet());
+        doCreateConstraintInfos(resultList, pCall, affectedVariables, bindings);
+    }
+    private void createConstraintInfoBinaryTransitiveClosure(List<PConstraintInfo> resultList,
+            AbstractTransitiveClosure closure) {
+        // A pattern call can have any of its variables unbound
+        List<PParameter> parameters = closure.getReferredQuery().getParameters();
+        Tuple variables = closure.getVariablesTuple();
+        Set<Set<PVariable>> bindings = new HashSet<>();
+        PVariable firstVariable = (PVariable) variables.get(0);
+        PVariable secondVariable = (PVariable) variables.get(1);
+        // Check is always supported
+        bindings.add(new HashSet<>(Arrays.asList(firstVariable, secondVariable)));
+        // If first parameter is not bound mandatorily, it can be left out
+        if (parameters.get(0).getDirection() != PParameterDirection.IN) {
+            bindings.add(Collections.singleton(secondVariable));
+        }
+        // If second parameter is not bound mandatorily, it can be left out
+        if (parameters.get(1).getDirection() != PParameterDirection.IN) {
+            bindings.add(Collections.singleton(firstVariable));
+        }
+        doCreateConstraintInfos(resultList, closure, closure.getAffectedVariables(), bindings);
+    }
+    private void createConstraintInfoExportedParameter(List<PConstraintInfo> resultList,
+            ExportedParameter parameter) {
+        // In case of an exported parameter constraint, the parameter must be bound in order to execute
+        Set<PVariable> affectedVariables = parameter.getAffectedVariables();
+        doCreateConstraintInfos(resultList, parameter, affectedVariables, Collections.singleton(affectedVariables));
+    }
+    private void createConstraintInfoExpressionEvaluation(List<PConstraintInfo> resultList,
+            ExpressionEvaluation expressionEvaluation) {
+        // An expression evaluation can only have its output variable unbound. All other variables shall be bound
+        PVariable output = expressionEvaluation.getOutputVariable();
+        Set<Set<PVariable>> bindings = new HashSet<>();
+        Set<PVariable> affectedVariables = expressionEvaluation.getAffectedVariables();
+        // All variables bound -> check
+        bindings.add(affectedVariables);
+        // Output variable is not bound -> extend
+        bindings.add(affectedVariables.stream().filter(var -> !Objects.equals(var, output)).collect(Collectors.toSet()));
+        doCreateConstraintInfos(resultList, expressionEvaluation, affectedVariables, bindings);
+    }
+    private void createConstraintInfoTypeFilterConstraint(List<PConstraintInfo> resultList,
+            TypeFilterConstraint filter){
+        // In case of type filter, all affected variables must be bound in order to execute
+        Set<PVariable> affectedVariables = filter.getAffectedVariables();
+        doCreateConstraintInfos(resultList, filter, affectedVariables, Collections.singleton(affectedVariables));
+    }
+    private void createConstraintInfoInequality(List<PConstraintInfo> resultList,
+            Inequality inequality){
+        // In case of inequality, all affected variables must be bound in order to execute
+        Set<PVariable> affectedVariables = inequality.getAffectedVariables();
+        doCreateConstraintInfos(resultList, inequality, affectedVariables, Collections.singleton(affectedVariables));
+    }
+    private void createConstraintInfoAggregatorConstraint(List<PConstraintInfo> resultList,
+            PConstraint pConstraint, PVariable resultVariable){
+        Set<PVariable> affectedVariables = pConstraint.getAffectedVariables();
+        // The only variables which can be unbound are single-use
+        Set<PVariable> canBeUnboundVariables =
+                Stream.concat(Stream.of(resultVariable), affectedVariables.stream().filter(SINGLE_USE_VARIABLE)).collect(Collectors.toSet());
+        Set<Set<PVariable>> bindings = calculatePossibleBindings(canBeUnboundVariables, affectedVariables);
+        doCreateConstraintInfos(resultList, pConstraint, affectedVariables, bindings);
+    }
+    /**
+     *
+     * @param canBeUnboundVariables Variables which are allowed to be unbound
+     * @param affectedVariables All affected variables
+     * @return The set of possible bound variable sets
+     */
+    private Set<Set<PVariable>> calculatePossibleBindings(Set<PVariable> canBeUnboundVariables, Set<PVariable> affectedVariables){
+        final Set<PVariable> mustBindVariables = affectedVariables.stream().filter(input -> !canBeUnboundVariables.contains(input)).collect(Collectors.toSet());
+        return Sets.powerSet(canBeUnboundVariables).stream()
+                .map(input -> {
+                    //some variables have to be bound before executing this constraint
+                    Set<PVariable> result= new HashSet<>(input);
+                    result.addAll(mustBindVariables);
+                    return result;
+                })
+                .collect(Collectors.toSet());
+    }
+    private void createConstraintInfoGeneric(List<PConstraintInfo> resultList, PConstraint pConstraint){
+        Set<PVariable> affectedVariables = pConstraint.getAffectedVariables();
+        // The only variables which can be unbound are single use variables
+        Set<PVariable> canBeUnboundVariables = affectedVariables.stream().filter(SINGLE_USE_VARIABLE).collect(Collectors.toSet());
+        Set<Set<PVariable>> bindings = calculatePossibleBindings(canBeUnboundVariables, affectedVariables);
+        doCreateConstraintInfos(resultList, pConstraint, affectedVariables, bindings);
+    }
+    private void createConstraintInfoTypeConstraint(List<PConstraintInfo> resultList,
+            TypeConstraint typeConstraint) {
+        Set<PVariable> affectedVariables = typeConstraint.getAffectedVariables();
+        Set<? extends Set<PVariable>> bindings = null;
+        IInputKey inputKey = typeConstraint.getSupplierKey();
+        if(inputKey.isEnumerable()){
+            bindings = Sets.powerSet(affectedVariables);
+        }else{
+            // For not enumerable types, this constraint can only be a check
+            bindings = Collections.singleton(affectedVariables);
+        }
+        doCreateConstraintInfos(resultList, typeConstraint, affectedVariables, bindings);
+    }
+    private void doCreateConstraintInfos(List<PConstraintInfo> constraintInfos,
+            PConstraint pConstraint, Set<PVariable> affectedVariables, Iterable<? extends Set<PVariable>> bindings) {
+        Set<PConstraintInfo> sameWithDifferentBindings = new HashSet<>();
+        for (Set<PVariable> boundVariables : bindings) {
+            PConstraintInfo info = new PConstraintInfo(pConstraint, boundVariables,
+                    affectedVariables.stream().filter(input -> !boundVariables.contains(input)).collect(Collectors.toSet()),
+                    sameWithDifferentBindings, context, resultRequestor, costFunction);
+            constraintInfos.add(info);
+            sameWithDifferentBindings.add(info);
+        }
+    }
+    private Set<Set<PVariable>> excludeUnnavigableOperationMasks(TypeConstraint typeConstraint, Set<? extends Set<PVariable>> bindings) {
+        PVariable firstVariable = typeConstraint.getVariableInTuple(0);
+        return bindings.stream().filter(
+                boundVariablesSet -> (boundVariablesSet.isEmpty() || boundVariablesSet.contains(firstVariable)))
+                .collect(Collectors.toSet());
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PlanState.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PlanState.java
new file mode 100644
index 00000000..e93b07bc
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/PlanState.java
@@ -0,0 +1,283 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Marton Bur, 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.viatra.runtime.localsearch.planner;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import tools.refinery.viatra.runtime.localsearch.planner.util.OperationCostComparator;
+import tools.refinery.viatra.runtime.matchers.algorithms.OrderedIterableMerge;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+/**
+ * This class represents the state of the plan during planning.
+ * 
+ * <p> A PlanState represents a sequence of operations (operationsList) and caches the computed cost 
+ * for this operation sequence. The list and the cost are initialized in the constructor. 
+ * However, #categorizeChecks() also updates the operations list (by suffixing checks)
+ * 
+ * @author Marton Bur
+ * @noreference This class is not intended to be referenced by clients.
+ */
+public class PlanState {
+    private final PBody pBody;
+    private final List<PConstraintInfo> operationsList;
+    private final Set<PVariable> boundVariables;
+    private final Collection<PVariable> deltaVariables; /* bound since ancestor plan */
+    private final Set<PConstraint> enforcedConstraints;
+    
+    private double cummulativeProduct;
+    private double cost;
+    private static Comparator<PConstraintInfo> infoComparator = new OperationCostComparator();
+    /*
+     * For a short explanation of past, present and future operations,
+     * see class 
+     */
+    private List<PConstraintInfo> presentExtends;
+    /**
+     * Creates an initial state
+     */
+    public PlanState(PBody pBody, Set<PVariable> boundVariables) {
+        this(pBody, new ArrayList<>(), boundVariables, boundVariables /* also the delta */, 
+                0.0 /* initial cost */, 1.0 /*initial branch count */);
+    }
+    
+    public PlanState cloneWithApplied(PConstraintInfo op) {
+        // Create operation list based on the current state
+        ArrayList<PConstraintInfo> newOperationsList =  
+                // pre-reserve excess capacity for later addition of CHECK ops
+                new ArrayList<>(pBody.getConstraints().size());
+        newOperationsList.addAll(this.getOperations());
+        newOperationsList.add(op);
+        
+        // Bind the variables of the op
+        Collection<PVariable> deltaVariables = op.getFreeVariables();
+        Set<PVariable> allBoundVariables =
+                // pre-reserve exact capacity as variables are known 
+                // (will not be affected by adding CHECK ops later)
+                new HashSet<>(this.getBoundVariables().size() + deltaVariables.size());
+        allBoundVariables.addAll(this.getBoundVariables());
+        allBoundVariables.addAll(deltaVariables);
+        
+        PlanState newState = new PlanState(getAssociatedPBody(), newOperationsList, allBoundVariables, deltaVariables,
+                cost, cummulativeProduct);
+        newState.accountNewOperation(op);
+        return newState;
+    }
+    private PlanState(PBody pBody, List<PConstraintInfo> operationsList, 
+            Set<PVariable> boundVariables, Collection<PVariable> deltaVariables, 
+            double cost, double cummulativeProduct) 
+    {
+        this.pBody = pBody;
+        this.operationsList = operationsList;
+        this.boundVariables = boundVariables;
+        this.enforcedConstraints = new HashSet<>();
+        this.deltaVariables = deltaVariables;
+        this.cost = cost;
+        this.cummulativeProduct = cummulativeProduct;
+    }
+    // NOT included for EXTEND: bind all variables of op
+    private void accountNewOperation(PConstraintInfo constraintInfo) {
+        this.enforcedConstraints.add(constraintInfo.getConstraint());
+        accountCost(constraintInfo);
+    }
+    private void accountCost(PConstraintInfo constraintInfo) {
+        double constraintCost = constraintInfo.getCost();
+        double branchFactor = constraintCost;
+        if (constraintCost > 0){
+            cost += cummulativeProduct * constraintCost;
+            cummulativeProduct *= branchFactor;
+        }
+    }
+    public Set<PConstraint> getEnforcedConstraints() {
+        return enforcedConstraints;
+    }
+    /**
+     * Re-categorizes given extend operations into already applied or no longer applicable ones (discarded), 
+     * immediately applicable ones (saved as presently viable extends), 
+     * and not yet applicable ones (discarded).
+     * 
+     * @param allPotentialExtendInfos all other extends that may be applicable 
+     * to this plan state now or in the future;
+     * MUST consist of "extend" constraint applications only (at least one free variable)
+     */
+    public void updateExtends(Iterable<PConstraintInfo> allPotentialExtendInfos) {
+        presentExtends = new ArrayList<>();
+        
+        
+        // categorize future/present extend constraint infos
+        for (PConstraintInfo op : allPotentialExtendInfos) {
+            updateExtendInternal(op);
+        }
+    }
+    /**
+     * Re-categorizes given extend operations into already applied or no longer applicable ones (discarded), 
+     * immediately applicable ones (saved as presently viable extends),
+     * and not yet applicable ones (discarded).
+     * 
+     * @param extendOpsByBoundVariables all EXTEND operations indexed by affected <i>bound</i> variables
+     * MUST consist of "extend" constraint applications only (at least one free variable)
+     */
+    public void updateExtendsBasedOnDelta(
+            Iterable<PConstraintInfo> previousPresentExtends, 
+            Map<PVariable, ? extends Collection<PConstraintInfo>> extendOpsByBoundVariables) 
+    {
+        presentExtends = new ArrayList<>();
+        if (operationsList.isEmpty())
+            throw new IllegalStateException("Not applicable as starting step");     
+        
+        for (PConstraintInfo extend: previousPresentExtends) {
+            updateExtendInternal(extend);
+        }
+        
+        Set<PConstraintInfo> affectedExtends = new HashSet<>();
+        for (PVariable variable : deltaVariables) {
+            // only those check ops may become applicable that have an affected variable in the delta
+            Collection<PConstraintInfo> extendsForVariable = extendOpsByBoundVariables.get(variable);
+            if (null != extendsForVariable) {
+                affectedExtends.addAll(extendsForVariable);
+            }
+        }
+        for (PConstraintInfo extend: affectedExtends) {
+            updateExtendInternal(extend);
+        }
+    }
+    
+    private void updateExtendInternal(PConstraintInfo op) {
+        if(!enforcedConstraints.contains(op.getConstraint())) {
+            categorizeExtend(op);                
+        }
+    }
+    
+    /**
+     * Check operations that newly became applicable (see {@link #getDeltaVariables()}) 
+     * are appended to operations lists.
+     * 
+     * <p> Will never discover degenerate checks (of PConstraints with zero variables),
+     * so must not use on initial state.
+     * 
+     * @param allPotentialCheckInfos all CHECK operations
+     * MUST consist of "check" constraint applications only (no free variables) 
+     * and must be iterable in decreasing order of cost
+     * 
+     * 
+     */
+    public void applyChecks(List<PConstraintInfo> allPotentialCheckInfos) {
+        applyChecksInternal(allPotentialCheckInfos);        
+    }
+ 
+    /**
+     * Immediately applicable checks are appended to operations lists.
+     * 
+     * @param checkOpsByVariables all CHECK operations indexed by affected variables
+     * MUST consist of "check" constraint applications only (no free variables) 
+     * and each bucket must be iterable in decreasing order of cost
+     */
+    public void applyChecksBasedOnDelta(Map<PVariable, List<PConstraintInfo>> checkOpsByVariables) {
+        if (operationsList.isEmpty())
+            throw new IllegalStateException("Not applicable as starting step");     
+        
+        Iterable<PConstraintInfo> affectedChecks = Collections.emptyList();
+        
+        for (PVariable variable : deltaVariables) {
+            // only those check ops may become applicable that have an affected variable in the delta
+            List<PConstraintInfo> checksForVariable = checkOpsByVariables.get(variable);
+            if (null != checksForVariable) {
+                affectedChecks = OrderedIterableMerge.mergeUniques(affectedChecks, checksForVariable, infoComparator);
+            }
+        }
+        
+        // checks retain their order, no re-sorting needed
+        applyChecksInternal(affectedChecks);
+    }
+    private void applyChecksInternal(Iterable<PConstraintInfo> checks) {
+        for (PConstraintInfo checkInfo : checks) {
+            if (this.boundVariables.containsAll(checkInfo.getBoundVariables()) &&
+                    !enforcedConstraints.contains(checkInfo.getConstraint())) 
+            {
+                operationsList.add(checkInfo);
+                accountNewOperation(checkInfo);                    
+            }
+        }
+    }
+    private void categorizeExtend(PConstraintInfo constraintInfo) {
+        PConstraintCategory category = constraintInfo.getCategory(pBody, boundVariables);
+        if (category == PConstraintCategory.PRESENT) {
+            presentExtends.add(constraintInfo);
+        } else {
+            // do not categorize past/future operations
+        }
+    }
+    public PBody getAssociatedPBody() {
+        return pBody;
+    }
+    public List<PConstraintInfo> getOperations() {
+        return operationsList;
+    }
+    public Set<PVariable> getBoundVariables() {
+        return boundVariables;
+    }
+    /**
+     * @return the derived cost of the plan contained in the state
+     */
+    public double getCost() {
+        return cost;
+    }
+    
+    /**
+     * @return cumulative branching factor
+     * @since 2.1
+     */
+    public double getCummulativeProduct() {
+        return cummulativeProduct;
+    }
+    public List<PConstraintInfo> getPresentExtends() {
+        return presentExtends;
+    }
+    /**
+     * Contains only those variables that are added by the newest extend 
+     * (or the initially bound ones if no extend yet)
+     */
+    public Collection<PVariable> getDeltaVariables() {
+        return deltaVariables;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/AbstractOperationCompiler.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/AbstractOperationCompiler.java
new file mode 100644
index 00000000..73312dc9
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/AbstractOperationCompiler.java
@@ -0,0 +1,430 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.planner.compiler;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import tools.refinery.viatra.runtime.localsearch.matcher.CallWithAdornment;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.check.AggregatorCheck;
+import tools.refinery.viatra.runtime.localsearch.operations.check.BinaryTransitiveClosureCheck;
+import tools.refinery.viatra.runtime.localsearch.operations.check.CheckConstant;
+import tools.refinery.viatra.runtime.localsearch.operations.check.CheckPositivePatternCall;
+import tools.refinery.viatra.runtime.localsearch.operations.check.CountCheck;
+import tools.refinery.viatra.runtime.localsearch.operations.check.ExpressionCheck;
+import tools.refinery.viatra.runtime.localsearch.operations.check.ExpressionEvalCheck;
+import tools.refinery.viatra.runtime.localsearch.operations.check.InequalityCheck;
+import tools.refinery.viatra.runtime.localsearch.operations.check.NACOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.extend.AggregatorExtend;
+import tools.refinery.viatra.runtime.localsearch.operations.extend.CountOperation;
+import tools.refinery.viatra.runtime.localsearch.operations.extend.ExpressionEval;
+import tools.refinery.viatra.runtime.localsearch.operations.extend.ExtendBinaryTransitiveClosure;
+import tools.refinery.viatra.runtime.localsearch.operations.extend.ExtendConstant;
+import tools.refinery.viatra.runtime.localsearch.operations.extend.ExtendPositivePatternCall;
+import tools.refinery.viatra.runtime.localsearch.operations.util.CallInformation;
+import tools.refinery.viatra.runtime.localsearch.planner.util.CompilerHelper;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PApply;
+import tools.refinery.viatra.runtime.matchers.planning.operations.POperation;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PProject;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PStart;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.AggregatorConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.Inequality;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.PatternMatchCounter;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.BinaryReflexiveTransitiveClosure;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public abstract class AbstractOperationCompiler implements IOperationCompiler {
+    
+    protected static final String UNSUPPORTED_TYPE_MESSAGE = "Unsupported type: ";
+    protected abstract void createExtend(TypeConstraint typeConstraint, Map<PVariable, Integer> variableMapping);
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    protected abstract void createCheck(TypeConstraint typeConstraint, Map<PVariable, Integer> variableMapping);
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    protected abstract void createCheck(TypeFilterConstraint typeConstraint, Map<PVariable, Integer> variableMapping);
+    /**
+     * @since 2.0
+     * @throws ViatraQueryRuntimeException
+     */
+    protected abstract void createUnaryTypeCheck(IInputKey type, int position);
+    
+    protected List<ISearchOperation> operations;
+    protected Set<CallWithAdornment> dependencies = new HashSet<>();
+    protected Map<PConstraint, Set<Integer>> variableBindings;
+    private Map<PVariable, Integer> variableMappings;
+    protected final IQueryRuntimeContext runtimeContext;
+    public AbstractOperationCompiler(IQueryRuntimeContext runtimeContext) {
+        this.runtimeContext = runtimeContext;
+    }
+    /**
+     * Compiles a plan of <code>POperation</code>s to a list of type <code>List&ltISearchOperation></code>
+     * 
+     * @param plan
+     * @param boundParameters
+     * @return an ordered list of POperations that make up the compiled search plan
+     * @throws ViatraQueryRuntimeException
+     */
+    @Override
+    public List<ISearchOperation> compile(SubPlan plan, Set<PParameter> boundParameters) {
+    
+        variableMappings = CompilerHelper.createVariableMapping(plan);
+        variableBindings = CompilerHelper.cacheVariableBindings(plan, variableMappings, boundParameters);
+    
+        operations = new ArrayList<>();
+    
+        List<POperation> operationList = CompilerHelper.createOperationsList(plan);
+        for (POperation pOperation : operationList) {
+            compile(pOperation, variableMappings);
+        }
+    
+        return operations;
+    }
+    private void compile(POperation pOperation, Map<PVariable, Integer> variableMapping) {
+    
+        if (pOperation instanceof PApply) {
+            PApply pApply = (PApply) pOperation;
+            PConstraint pConstraint = pApply.getPConstraint();
+           
+            if (isCheck(pConstraint, variableMapping)) {
+                // check
+                createCheckDispatcher(pConstraint, variableMapping);
+            } else {
+                // extend
+                createExtendDispatcher(pConstraint, variableMapping);
+            }
+    
+        } else if (pOperation instanceof PStart) {
+            // nop
+        } else if (pOperation instanceof PProject) {
+            // nop
+        } else {
+            throw new QueryProcessingException("PStart, PApply or PProject was expected, received: " + pOperation.getClass(), null,"Unexpected POperation type", null);
+        }
+    
+    }
+    private void createCheckDispatcher(PConstraint pConstraint, Map<PVariable, Integer> variableMapping) {
+        
+        
+        // DeferredPConstraint subclasses
+    
+        // Equalities are normalized
+    
+        if (pConstraint instanceof Inequality) {
+            createCheck((Inequality) pConstraint, variableMapping);
+        } else if (pConstraint instanceof PositivePatternCall){
+            createCheck((PositivePatternCall) pConstraint, variableMapping);
+        } else if (pConstraint instanceof NegativePatternCall) {
+            createCheck((NegativePatternCall) pConstraint,variableMapping);
+        } else if (pConstraint instanceof AggregatorConstraint) {
+            createCheck((AggregatorConstraint) pConstraint, variableMapping);
+        } else if (pConstraint instanceof PatternMatchCounter) {
+            createCheck((PatternMatchCounter) pConstraint, variableMapping);
+        } else if (pConstraint instanceof ExpressionEvaluation) {
+            createCheck((ExpressionEvaluation) pConstraint, variableMapping);
+        } else if (pConstraint instanceof TypeFilterConstraint) {
+            createCheck((TypeFilterConstraint) pConstraint,variableMapping);
+        } else if (pConstraint instanceof ExportedParameter) {
+            // Nothing to do here
+        } else
+        
+        // EnumerablePConstraint subclasses
+    
+        if (pConstraint instanceof BinaryTransitiveClosure) {
+            createCheck((BinaryTransitiveClosure) pConstraint, variableMapping);
+        } else if (pConstraint instanceof BinaryReflexiveTransitiveClosure) {
+            createCheck((BinaryReflexiveTransitiveClosure)pConstraint, variableMapping);
+        } else if (pConstraint instanceof ConstantValue) {
+            createCheck((ConstantValue) pConstraint, variableMapping);
+        } else if (pConstraint instanceof TypeConstraint) {
+            createCheck((TypeConstraint) pConstraint,variableMapping);
+        }  else {
+            String msg = "Unsupported Check constraint: "+pConstraint.toString();
+            throw new QueryProcessingException(msg, null, msg, null);
+        }
+    
+    }
+    
+    protected void createExtendDispatcher(PConstraint pConstraint, Map<PVariable, Integer> variableMapping) {
+    
+        // DeferredPConstraint subclasses
+        
+        // Equalities are normalized
+        if (pConstraint instanceof PositivePatternCall) {
+            createExtend((PositivePatternCall)pConstraint, variableMapping);
+        } else if (pConstraint instanceof AggregatorConstraint) {
+            createExtend((AggregatorConstraint) pConstraint, variableMapping);
+        } else if (pConstraint instanceof PatternMatchCounter) {
+            createExtend((PatternMatchCounter) pConstraint, variableMapping);
+        } else if (pConstraint instanceof ExpressionEvaluation) {
+            createExtend((ExpressionEvaluation) pConstraint, variableMapping);
+        } else if (pConstraint instanceof ExportedParameter) {
+            // ExportedParameters are compiled to NOP
+        } else
+        
+        // EnumerablePConstraint subclasses
+    
+        if (pConstraint instanceof ConstantValue) {
+            createExtend((ConstantValue) pConstraint, variableMapping);
+        } else if (pConstraint instanceof TypeConstraint) {
+            createExtend((TypeConstraint) pConstraint, variableMapping);
+        } else if (pConstraint instanceof BinaryTransitiveClosure) {
+            createExtend((BinaryTransitiveClosure)pConstraint, variableMapping);
+        } else if (pConstraint instanceof BinaryReflexiveTransitiveClosure) {
+            createExtend((BinaryReflexiveTransitiveClosure)pConstraint, variableMapping);
+        } else {
+            String msg = "Unsupported Extend constraint: "+pConstraint.toString();
+            throw new QueryProcessingException(msg, null, msg, null);
+        }
+    }
+    
+    private boolean isCheck(PConstraint pConstraint, final Map<PVariable, Integer> variableMapping) {
+        if (pConstraint instanceof NegativePatternCall){
+            return true;
+        }else if (pConstraint instanceof PositivePatternCall){
+            // Positive pattern call is check if all non-single used variables are bound
+            List<Integer> callVariables = pConstraint.getAffectedVariables().stream()
+                .filter(input -> input.getReferringConstraints().size() > 1)
+                .map(variableMapping::get)
+                .collect(Collectors.toList());
+            return variableBindings.get(pConstraint).containsAll(callVariables);
+        }else if (pConstraint instanceof AggregatorConstraint){
+            PVariable outputvar = ((AggregatorConstraint) pConstraint).getResultVariable();
+            return variableBindings.get(pConstraint).contains(variableMapping.get(outputvar));
+        }else if (pConstraint instanceof PatternMatchCounter){
+            PVariable outputvar = ((PatternMatchCounter) pConstraint).getResultVariable();
+            return variableBindings.get(pConstraint).contains(variableMapping.get(outputvar));
+        }else if (pConstraint instanceof ExpressionEvaluation){
+            PVariable outputvar = ((ExpressionEvaluation) pConstraint).getOutputVariable();
+            return outputvar == null || variableBindings.get(pConstraint).contains(variableMapping.get(outputvar));
+        } else {
+            // In other cases, all variables shall be bound to be a check
+            Set<PVariable> affectedVariables = pConstraint.getAffectedVariables();
+            Set<Integer> varIndices = new HashSet<>();
+            for (PVariable variable : affectedVariables) {
+                varIndices.add(variableMapping.get(variable));
+            }
+            return variableBindings.get(pConstraint).containsAll(varIndices);
+        }
+    }
+    @Override
+    public Set<CallWithAdornment> getDependencies() {
+        return dependencies;
+    }
+    /**
+     * @return the cached variable bindings for the previously created plan
+     */
+    @Override
+    public Map<PVariable, Integer> getVariableMappings() {
+        return variableMappings;
+    }
+    protected void createCheck(PatternMatchCounter counter, Map<PVariable, Integer> variableMapping) {
+        CallInformation information = CallInformation.create(counter, variableMapping, variableBindings.get(counter));
+        operations.add(new CountCheck(information, variableMapping.get(counter.getResultVariable())));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    protected void createCheck(PositivePatternCall pCall, Map<PVariable, Integer> variableMapping) {
+        CallInformation information = CallInformation.create(pCall, variableMapping, variableBindings.get(pCall));
+        operations.add(new CheckPositivePatternCall(information));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    protected void createCheck(ConstantValue constant, Map<PVariable, Integer> variableMapping) {
+        int position = variableMapping.get(constant.getVariablesTuple().get(0));
+        operations.add(new CheckConstant(position, constant.getSupplierKey()));
+    }
+    protected void createCheck(BinaryTransitiveClosure binaryTransitiveClosure, Map<PVariable, Integer> variableMapping) {
+        int sourcePosition = variableMapping.get(binaryTransitiveClosure.getVariablesTuple().get(0));
+        int targetPosition = variableMapping.get(binaryTransitiveClosure.getVariablesTuple().get(1));
+        
+        //The second parameter is NOT bound during execution!
+        CallInformation information = CallInformation.create(binaryTransitiveClosure, variableMapping, Stream.of(sourcePosition).collect(Collectors.toSet()));
+        operations.add(new BinaryTransitiveClosureCheck(information, sourcePosition, targetPosition, false));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    
+    /**
+     * @since 2.0
+     */
+    protected void createCheck(BinaryReflexiveTransitiveClosure binaryTransitiveClosure, Map<PVariable, Integer> variableMapping) {
+        int sourcePosition = variableMapping.get(binaryTransitiveClosure.getVariablesTuple().get(0));
+        int targetPosition = variableMapping.get(binaryTransitiveClosure.getVariablesTuple().get(1));
+        
+        //The second parameter is NOT bound during execution!
+        CallInformation information = CallInformation.create(binaryTransitiveClosure, variableMapping, Stream.of(sourcePosition).collect(Collectors.toSet()));
+        createUnaryTypeCheck(binaryTransitiveClosure.getUniverseType(), sourcePosition);
+        operations.add(new BinaryTransitiveClosureCheck(information, sourcePosition, targetPosition, true));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    protected void createCheck(ExpressionEvaluation expressionEvaluation, Map<PVariable, Integer> variableMapping) {
+        // Fill unbound variables with null; simply copy all variables. Unbound variables will be null anyway
+        Iterable<String> inputParameterNames = expressionEvaluation.getEvaluator().getInputParameterNames();
+        Map<String, Integer> nameMap = new HashMap<>();
+        
+        for (String pVariableName : inputParameterNames) {
+            PVariable pVariable = expressionEvaluation.getPSystem().getVariableByNameChecked(pVariableName);
+            nameMap.put(pVariableName, variableMapping.get(pVariable));
+        }
+        
+        // output variable can be null; if null it is an ExpressionCheck
+        if(expressionEvaluation.getOutputVariable() == null){
+            operations.add(new ExpressionCheck(expressionEvaluation.getEvaluator(), nameMap));
+        } else {
+            operations.add(new ExpressionEvalCheck(expressionEvaluation.getEvaluator(), nameMap, expressionEvaluation.isUnwinding(), variableMapping.get(expressionEvaluation.getOutputVariable())));
+        }
+    }
+    protected void createCheck(AggregatorConstraint aggregator, Map<PVariable, Integer> variableMapping) {
+        CallInformation information = CallInformation.create(aggregator, variableMapping, variableBindings.get(aggregator));
+        operations.add(new AggregatorCheck(information, aggregator, variableMapping.get(aggregator.getResultVariable())));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    protected void createCheck(NegativePatternCall negativePatternCall, Map<PVariable, Integer> variableMapping) {
+        CallInformation information = CallInformation.create(negativePatternCall, variableMapping, variableBindings.get(negativePatternCall));
+        operations.add(new NACOperation(information));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    protected void createCheck(Inequality inequality, Map<PVariable, Integer> variableMapping) {
+        operations.add(new InequalityCheck(variableMapping.get(inequality.getWho()), variableMapping.get(inequality.getWithWhom())));
+    }
+    protected void createExtend(PositivePatternCall pCall, Map<PVariable, Integer> variableMapping) {
+        CallInformation information = CallInformation.create(pCall, variableMapping, variableBindings.get(pCall));
+        operations.add(new ExtendPositivePatternCall(information));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    protected void createExtend(BinaryTransitiveClosure binaryTransitiveClosure, Map<PVariable, Integer> variableMapping) {
+        int sourcePosition = variableMapping.get(binaryTransitiveClosure.getVariablesTuple().get(0));
+        int targetPosition = variableMapping.get(binaryTransitiveClosure.getVariablesTuple().get(1));
+        
+        boolean sourceBound = variableBindings.get(binaryTransitiveClosure).contains(sourcePosition);
+        boolean targetBound = variableBindings.get(binaryTransitiveClosure).contains(targetPosition);
+        
+        CallInformation information = CallInformation.create(binaryTransitiveClosure, variableMapping, variableBindings.get(binaryTransitiveClosure));
+        
+        if (sourceBound && !targetBound) {
+            operations.add(new ExtendBinaryTransitiveClosure.Forward(information, sourcePosition, targetPosition, false));
+            dependencies.add(information.getCallWithAdornment());            
+        } else if (!sourceBound && targetBound) {
+            operations.add(new ExtendBinaryTransitiveClosure.Backward(information, sourcePosition, targetPosition, false));
+            dependencies.add(information.getCallWithAdornment());                        
+        } else {
+            String msg = "Binary transitive closure not supported with two unbound parameters";
+            throw new QueryProcessingException(msg, null, msg, binaryTransitiveClosure.getPSystem().getPattern());
+        }
+    }
+    
+    /**
+     * @since 2.0
+     */
+    protected void createExtend(BinaryReflexiveTransitiveClosure binaryTransitiveClosure, Map<PVariable, Integer> variableMapping) {
+        int sourcePosition = variableMapping.get(binaryTransitiveClosure.getVariablesTuple().get(0));
+        int targetPosition = variableMapping.get(binaryTransitiveClosure.getVariablesTuple().get(1));
+        
+        boolean sourceBound = variableBindings.get(binaryTransitiveClosure).contains(sourcePosition);
+        boolean targetBound = variableBindings.get(binaryTransitiveClosure).contains(targetPosition);
+        
+        CallInformation information = CallInformation.create(binaryTransitiveClosure, variableMapping, variableBindings.get(binaryTransitiveClosure));
+        
+        if (sourceBound && !targetBound) {
+            createUnaryTypeCheck(binaryTransitiveClosure.getUniverseType(), sourcePosition);
+            operations.add(new ExtendBinaryTransitiveClosure.Forward(information, sourcePosition, targetPosition, true));
+            dependencies.add(information.getCallWithAdornment());            
+        } else if (!sourceBound && targetBound) {
+            createUnaryTypeCheck(binaryTransitiveClosure.getUniverseType(), targetPosition);
+            operations.add(new ExtendBinaryTransitiveClosure.Backward(information, sourcePosition, targetPosition, true));
+            dependencies.add(information.getCallWithAdornment());                        
+        } else {
+            String msg = "Binary reflective transitive closure not supported with two unbound parameters";
+            throw new QueryProcessingException(msg, null, msg, binaryTransitiveClosure.getPSystem().getPattern());
+        }
+    }
+    protected void createExtend(ConstantValue constant, Map<PVariable, Integer> variableMapping) {
+        int position = variableMapping.get(constant.getVariablesTuple().get(0));
+        operations.add(new ExtendConstant(position, constant.getSupplierKey()));        
+    }
+    protected void createExtend(ExpressionEvaluation expressionEvaluation, Map<PVariable, Integer> variableMapping) {
+        // Fill unbound variables with null; simply copy all variables. Unbound variables will be null anyway
+        Iterable<String> inputParameterNames = expressionEvaluation.getEvaluator().getInputParameterNames();
+        Map<String, Integer> nameMap = new HashMap<>();
+        
+        for (String pVariableName : inputParameterNames) {
+            PVariable pVariable = expressionEvaluation.getPSystem().getVariableByNameChecked(pVariableName);
+            nameMap.put(pVariableName, variableMapping.get(pVariable));
+        }
+        
+        // output variable can be null; if null it is an ExpressionCheck
+        if(expressionEvaluation.getOutputVariable() == null){
+            operations.add(new ExpressionCheck(expressionEvaluation.getEvaluator(), nameMap));
+        } else {
+            operations.add(new ExpressionEval(expressionEvaluation.getEvaluator(), nameMap, expressionEvaluation.isUnwinding(), variableMapping.get(expressionEvaluation.getOutputVariable())));
+        }
+    }
+    protected void createExtend(AggregatorConstraint aggregator, Map<PVariable, Integer> variableMapping) {
+        CallInformation information = CallInformation.create(aggregator, variableMapping, variableBindings.get(aggregator));
+        operations.add(new AggregatorExtend(information, aggregator, variableMapping.get(aggregator.getResultVariable())));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    protected void createExtend(PatternMatchCounter patternMatchCounter, Map<PVariable, Integer> variableMapping) {
+        CallInformation information = CallInformation.create(patternMatchCounter, variableMapping, variableBindings.get(patternMatchCounter));
+        operations.add(new CountOperation(information, variableMapping.get(patternMatchCounter.getResultVariable())));
+        dependencies.add(information.getCallWithAdornment());
+    }
+    
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/GenericOperationCompiler.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/GenericOperationCompiler.java
new file mode 100644
index 00000000..d86982e9
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/GenericOperationCompiler.java
@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
+ * 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.viatra.runtime.localsearch.planner.compiler;
+import tools.refinery.viatra.runtime.localsearch.operations.generic.GenericTypeCheck;
+import tools.refinery.viatra.runtime.localsearch.operations.generic.GenericTypeExtend;
+import tools.refinery.viatra.runtime.localsearch.operations.generic.GenericTypeExtendSingleValue;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import java.util.*;
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public class GenericOperationCompiler extends AbstractOperationCompiler {
+    public GenericOperationCompiler(IQueryRuntimeContext runtimeContext) {
+        super(runtimeContext);
+    }
+    @Override
+    protected void createCheck(TypeFilterConstraint typeConstraint, Map<PVariable, Integer> variableMapping) {
+        IInputKey inputKey = typeConstraint.getInputKey();
+        Tuple tuple = typeConstraint.getVariablesTuple();
+        int[] positions = new int[tuple.getSize()];
+        for (int i = 0; i < tuple.getSize(); i++) {
+            PVariable variable = (PVariable) tuple.get(i);
+            positions[i] = variableMapping.get(variable);
+        }
+        operations.add(new GenericTypeCheck(inputKey, positions, TupleMask.fromSelectedIndices(variableMapping.size(), positions)));
+    }
+    @Override
+    protected void createCheck(TypeConstraint typeConstraint, Map<PVariable, Integer> variableMapping) {
+        IInputKey inputKey = typeConstraint.getSupplierKey();
+        Tuple tuple = typeConstraint.getVariablesTuple();
+        int[] positions = new int[tuple.getSize()];
+        for (int i = 0; i < tuple.getSize(); i++) {
+            PVariable variable = (PVariable) tuple.get(i);
+            positions[i] = variableMapping.get(variable);
+        }
+        operations.add(new GenericTypeCheck(inputKey, positions, TupleMask.fromSelectedIndices(variableMapping.size(), positions)));
+    }
+    @Override
+    protected void createUnaryTypeCheck(IInputKey inputKey, int position) {
+        int[] positions = new int[] {position};
+        operations.add(new GenericTypeCheck(inputKey, positions, TupleMask.fromSelectedIndices(1, positions)));
+    }
+    @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 {
+            operations.add(new GenericTypeExtend(inputKey, positions, callMask, indexerMask, unboundVariables));
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/IOperationCompiler.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/IOperationCompiler.java
new file mode 100644
index 00000000..625a7eb2
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/compiler/IOperationCompiler.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * 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.viatra.runtime.localsearch.planner.compiler;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import tools.refinery.viatra.runtime.localsearch.matcher.CallWithAdornment;
+import tools.refinery.viatra.runtime.localsearch.matcher.MatcherReference;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+/**
+ * An operation compiler is responsible for creating executable search plans from the subplan structure.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public interface IOperationCompiler {
+    /**
+     * Compiles a plan of <code>POperation</code>s to a list of type <code>List&ltISearchOperation></code>
+     * 
+     * @param plan
+     * @param boundParameters
+     * @return an ordered list of POperations that make up the compiled search plan
+     * @throws ViatraQueryRuntimeException 
+     */
+    List<ISearchOperation> compile(SubPlan plan, Set<PParameter> boundParameters);
+    /**
+     * Replaces previous method returning {@link MatcherReference}
+     * @since 2.1
+     */
+    Set<CallWithAdornment> getDependencies();
+    /**
+     * @return the cached variable bindings for the previously created plan
+     */
+    Map<PVariable, Integer> getVariableMappings();
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/IConstraintEvaluationContext.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/IConstraintEvaluationContext.java
new file mode 100644
index 00000000..9b44612b
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/IConstraintEvaluationContext.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.planner.cost;
+import tools.refinery.viatra.runtime.matchers.backend.ResultProviderRequestor;
+import tools.refinery.viatra.runtime.matchers.context.IQueryResultProviderAccess;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import java.util.Collection;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.analysis.QueryAnalyzer;
+/**
+ * This interface denotes the evaluation context of a constraint, intended for cost estimation. Provides access to information
+ * on which the cost function can base its calculation.
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ * @noimplement
+ */
+public interface IConstraintEvaluationContext {
+    /**
+     * Get the constraint to be evaluated
+     */
+    public PConstraint getConstraint();
+    /**
+     * Unbound variables at the time of evaluating the constraint
+     */
+    public Collection<PVariable> getFreeVariables();
+    /**
+     * Bound variables at the time of evaluating the constraint
+     */
+    public Collection<PVariable> getBoundVariables();
+    
+    public IQueryRuntimeContext getRuntimeContext();
+    
+    /**
+     * @since 1.5
+     */
+    public QueryAnalyzer getQueryAnalyzer();
+    
+    /**
+     * @deprecated use {@link #resultProviderRequestor()}
+     * @since 1.5
+     */
+    @Deprecated
+    public IQueryResultProviderAccess resultProviderAccess();
+    
+    /**
+     * @since 2.1
+     */
+    public ResultProviderRequestor resultProviderRequestor();
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/ICostFunction.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/ICostFunction.java
new file mode 100644
index 00000000..4d9d0708
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/ICostFunction.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.planner.cost;
+/**
+ * Common interface for cost function implementation
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public interface ICostFunction{
+    public double apply(IConstraintEvaluationContext input);
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/HybridMatcherConstraintCostFunction.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/HybridMatcherConstraintCostFunction.java
new file mode 100644
index 00000000..df9292f0
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/HybridMatcherConstraintCostFunction.java
@@ -0,0 +1,91 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.planner.cost.impl;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.IConstraintEvaluationContext;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+/**
+ * This cost function is intended to be used on hybrid configuration, with the strict restriction than any
+ * non-flattened positive pattern call is executed with Rete engine. This implementation provides the exact number
+ * of matches by invoking the result provider for the called pattern.
+ * 
+ * @deprecated {@link StatisticsBasedConstraintCostFunction} should use {@link IQueryResultProvider#estimateCardinality(tools.refinery.viatra.runtime.matchers.tuple.TupleMask, org.eclipse.viatra.query.runtime.matchers.util.Accuracy)} 
+ */
+@Deprecated
+public class HybridMatcherConstraintCostFunction extends IndexerBasedConstraintCostFunction {
+    
+    @Override
+    protected double _calculateCost(PositivePatternCall patternCall, IConstraintEvaluationContext context) {
+        // Determine local constant constraints which is used to filter results
+        Tuple variables = patternCall.getVariablesTuple();
+        Set<Object> variablesSet = variables.getDistinctElements();
+        final Map<PVariable, Object> constantMap = new HashMap<>();
+        for (PConstraint _constraint : patternCall.getPSystem().getConstraints()) {
+            if (_constraint instanceof ConstantValue){
+                ConstantValue constraint = (ConstantValue) _constraint;
+                PVariable variable = (PVariable) constraint.getVariablesTuple().get(0);
+                if (variablesSet.contains(variable) && context.getBoundVariables().contains(variable)) {
+                    constantMap.put(variable, constraint.getSupplierKey());
+                }
+            }
+        }
+        
+        // Determine filter
+        Object[] filter = new Object[variables.getSize()];
+        for(int i=0; i < variables.getSize(); i++){
+            filter[i] = constantMap.get(variables.get(i));
+        }
+        // aggregate keys are the bound and not filtered variables
+        // These will be fixed in runtime, but unknown at planning time
+        // This is represented by indices to ease working with result tuples
+        final Map<Object, Integer> variableIndices = variables.invertIndex();
+        List<Integer> aggregateKeys = context.getBoundVariables().stream()
+                .filter(input -> !constantMap.containsKey(input))
+                .map(variableIndices::get)
+                .collect(Collectors.toList());
+        IQueryResultProvider resultProvider = context.resultProviderRequestor().requestResultProvider(patternCall, null);
+        Map<Tuple, Integer> aggregatedCounts = new HashMap<>();
+        
+        // Iterate over all matches and count together matches that has equal values on
+        // aggregateKeys positions. The cost of the pattern call is considered to be the
+        // Maximum of these counted values
+        
+        int result = 0;
+        // NOTE: a stream is not an iterable (cannot be iterated more than once), so to use it in a for-loop
+        // it has to be wrapped; in the following line a lambda is used to implement Iterable#iterator()
+        for (Tuple match : (Iterable<Tuple>) () -> resultProvider.getAllMatches(filter).iterator()) {
+            Tuple extracted = Tuples.flatTupleOf(aggregateKeys.stream().map(match::get).toArray());
+            int count = (aggregatedCounts.containsKey(extracted)) 
+                ? aggregatedCounts.get(extracted) + 1
+                : 1;                
+            aggregatedCounts.put(extracted, count);
+            if (result < count) {
+                result = count;
+            }
+        }
+        return result;
+    }
+    
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/IndexerBasedConstraintCostFunction.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/IndexerBasedConstraintCostFunction.java
new file mode 100644
index 00000000..9e2c8680
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/IndexerBasedConstraintCostFunction.java
@@ -0,0 +1,49 @@
+/** 
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.planner.cost.impl;
+import java.util.Optional;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.IConstraintEvaluationContext;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Accuracy;
+/**
+ * Cost function which calculates cost based on the cardinality of items in the runtime model, provided by the base indexer
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ */
+public class IndexerBasedConstraintCostFunction extends StatisticsBasedConstraintCostFunction {
+    
+    
+    
+    /**
+     * 
+     */
+    public IndexerBasedConstraintCostFunction() {
+        super();
+    }
+    /**
+     * @param inverseNavigationPenalty
+     * @since 2.1
+     */
+    public IndexerBasedConstraintCostFunction(double inverseNavigationPenalty) {
+        super(inverseNavigationPenalty);
+    }
+    @Override
+    public Optional<Long> projectionSize(IConstraintEvaluationContext input, IInputKey supplierKey, TupleMask groupMask, Accuracy requiredAccuracy) {
+        return input.getRuntimeContext().estimateCardinality(supplierKey, groupMask, requiredAccuracy);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/StatisticsBasedConstraintCostFunction.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/StatisticsBasedConstraintCostFunction.java
new file mode 100644
index 00000000..873be31d
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/StatisticsBasedConstraintCostFunction.java
@@ -0,0 +1,413 @@
+/**
+ * Copyright (c) 2010-2016, Grill Balázs, 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.viatra.runtime.localsearch.planner.cost.impl;
+import static tools.refinery.viatra.runtime.matchers.planning.helpers.StatisticsHelper.min;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import tools.refinery.viatra.runtime.localsearch.matcher.integration.AbstractLocalSearchResultProvider;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.IConstraintEvaluationContext;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.ICostFunction;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.planning.helpers.FunctionalDependencyHelper;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.analysis.QueryAnalyzer;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.AggregatorConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.Inequality;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.PatternMatchCounter;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.BinaryReflexiveTransitiveClosure;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Accuracy;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * Cost function which calculates cost based on the cardinality of items in the runtime model
+ * 
+ * <p> To provide custom statistics, override 
+ *  {@link #projectionSize(IConstraintEvaluationContext, IInputKey, TupleMask, Accuracy)} 
+ *  and {@link #bucketSize(IQueryReference, IConstraintEvaluationContext, TupleMask)}.
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ */
+public abstract class StatisticsBasedConstraintCostFunction implements ICostFunction {
+    protected static final double MAX_COST = 250.0;
+    protected static final double DEFAULT_COST = StatisticsBasedConstraintCostFunction.MAX_COST - 100.0;
+        
+    /**
+     * @since 2.1
+     */
+    public static final double INVERSE_NAVIGATION_PENALTY_DEFAULT = 0.10;
+    /**
+     * @since 2.1
+     */
+    public static final double INVERSE_NAVIGATION_PENALTY_GENERIC = 0.01;
+    /**
+     * @since 2.7
+     */
+    public static final double EVAL_UNWIND_EXTENSION_FACTOR = 3.0;
+    
+    private final double inverseNavigationPenalty;
+    
+    
+    /**
+     * @since 2.1
+     */
+    public StatisticsBasedConstraintCostFunction(double inverseNavigationPenalty) {
+        super();
+        this.inverseNavigationPenalty = inverseNavigationPenalty;
+    }
+    public StatisticsBasedConstraintCostFunction() {
+        this(INVERSE_NAVIGATION_PENALTY_DEFAULT);
+    }
+    /**
+     * @deprecated call and implement {@link #projectionSize(IConstraintEvaluationContext, IInputKey, TupleMask, Accuracy)} instead
+     */
+    @Deprecated
+    public long countTuples(final IConstraintEvaluationContext input, final IInputKey supplierKey) {
+        return projectionSize(input, supplierKey, TupleMask.identity(supplierKey.getArity()), Accuracy.EXACT_COUNT).orElse(-1L);
+    }
+    
+    /**
+     * Override this to provide custom statistics on edge/node counts.
+     * New implementors shall implement this instead of {@link #countTuples(IConstraintEvaluationContext, IInputKey)}
+     * @since 2.1
+     */
+    public Optional<Long> projectionSize(final IConstraintEvaluationContext input, final IInputKey supplierKey,
+            final TupleMask groupMask, Accuracy requiredAccuracy) {
+        long legacyCount = countTuples(input, supplierKey);
+        return legacyCount < 0 ? Optional.empty() : Optional.of(legacyCount);
+    }
+    /**
+     * Override this to provide custom estimates for match set sizes of called patterns.
+     * @since 2.1
+     */
+    public Optional<Double> bucketSize(final IQueryReference patternCall,
+            final IConstraintEvaluationContext input, TupleMask projMask) {
+        IQueryResultProvider resultProvider = input.resultProviderRequestor().requestResultProvider(patternCall, null);
+        // TODO hack: use LS cost instead of true bucket size estimate
+        if (resultProvider instanceof AbstractLocalSearchResultProvider) {
+            double estimatedCost = ((AbstractLocalSearchResultProvider) resultProvider).estimateCost(projMask);
+            return Optional.of(estimatedCost);
+        } else {            
+            return resultProvider.estimateAverageBucketSize(projMask, Accuracy.APPROXIMATION);
+        }
+    }
+   
+    
+    @Override
+    public double apply(final IConstraintEvaluationContext input) {
+        return this.calculateCost(input.getConstraint(), input);
+    }
+    protected double _calculateCost(final ConstantValue constant, final IConstraintEvaluationContext input) {
+        return 0.0f;
+    }
+    protected double _calculateCost(final TypeConstraint constraint, final IConstraintEvaluationContext input) {
+        final Collection<PVariable> freeMaskVariables = input.getFreeVariables();
+        final Collection<PVariable> boundMaskVariables = input.getBoundVariables();
+        IInputKey supplierKey = constraint.getSupplierKey();
+        long arity = supplierKey.getArity();
+        if ((arity == 1)) {
+            // unary constraint
+            return calculateUnaryConstraintCost(constraint, input);
+        } else if ((arity == 2)) {
+            // binary constraint
+            PVariable srcVariable = ((PVariable) constraint.getVariablesTuple().get(0));
+            PVariable dstVariable = ((PVariable) constraint.getVariablesTuple().get(1));
+            boolean isInverse = false;
+            // Check if inverse navigation is needed along the edge
+            if ((freeMaskVariables.contains(srcVariable) && boundMaskVariables.contains(dstVariable))) {
+                isInverse = true;
+            }
+            double binaryExtendCost = calculateBinaryCost(supplierKey, srcVariable, dstVariable, isInverse, input);
+            // Make inverse navigation slightly more expensive than forward navigation
+            // See https://bugs.eclipse.org/bugs/show_bug.cgi?id=501078
+            return (isInverse) ? binaryExtendCost + inverseNavigationPenalty : binaryExtendCost;
+        } else {
+            // n-ary constraint
+            throw new UnsupportedOperationException("Cost calculation for arity " + arity + " is not implemented yet");
+        }
+    }
+    
+    /**
+     * @deprecated use/implement {@link #calculateBinaryCost(IInputKey, PVariable, PVariable, boolean, IConstraintEvaluationContext)} instead
+     */
+    @Deprecated
+    protected double calculateBinaryExtendCost(final IInputKey supplierKey, final PVariable srcVariable,
+            final PVariable dstVariable, final boolean isInverse, long edgeCount /* TODO remove */,
+            final IConstraintEvaluationContext input) {
+        throw new UnsupportedOperationException();
+    }
+    
+    /**
+     * @since 2.1
+     */
+    protected double calculateBinaryCost(final IInputKey supplierKey, final PVariable srcVariable,
+            final PVariable dstVariable, final boolean isInverse, 
+            final IConstraintEvaluationContext input) {
+        final Collection<PVariable> freeMaskVariables = input.getFreeVariables();
+        final PConstraint constraint = input.getConstraint();
+        
+//        IQueryMetaContext metaContext = input.getRuntimeContext().getMetaContext();
+//        Collection<InputKeyImplication> implications = metaContext.getImplications(supplierKey);
+        Optional<Long> edgeUpper = projectionSize(input,   supplierKey,    TupleMask.identity(2),          Accuracy.BEST_UPPER_BOUND);
+        Optional<Long> srcUpper  = projectionSize(input,   supplierKey,    TupleMask.selectSingle(0, 2),   Accuracy.BEST_UPPER_BOUND);
+        Optional<Long> dstUpper  = projectionSize(input,   supplierKey,    TupleMask.selectSingle(1, 2),   Accuracy.BEST_UPPER_BOUND);
+        if (freeMaskVariables.contains(srcVariable) && freeMaskVariables.contains(dstVariable)) {
+            Double branchCount = edgeUpper.map(Long::doubleValue).orElse(
+                    srcUpper.map(Long::doubleValue).orElse(DEFAULT_COST)
+                    *
+                    dstUpper.map(Long::doubleValue).orElse(DEFAULT_COST)
+            );      
+            return branchCount;
+            
+        } else {
+            
+            Optional<Long> srcLower  = projectionSize(input,   supplierKey,    TupleMask.selectSingle(0, 2),   Accuracy.APPROXIMATION);
+            Optional<Long> dstLower  = projectionSize(input,   supplierKey,    TupleMask.selectSingle(1, 2),   Accuracy.APPROXIMATION);
+            
+            List<Optional<Long>> nodeLower = Arrays.asList(srcLower, dstLower);
+            List<Optional<Long>> nodeUpper = Arrays.asList(srcUpper, dstUpper);
+            
+            int from = isInverse ? 1 : 0;
+            int to   = isInverse ? 0 : 1;
+            
+            Optional<Double> costEstimate = Optional.empty();
+            
+            if (!freeMaskVariables.contains(srcVariable) && !freeMaskVariables.contains(dstVariable)) {
+                // both variables bound, this is a simple check
+                costEstimate = min(costEstimate, 0.9);
+            } // TODO use bucket size estimation in the runtime context
+            costEstimate = min(costEstimate, 
+                edgeUpper.flatMap(edges -> 
+                nodeLower.get(from).map(fromNodes ->
+                    // amortize edges over start nodes
+                    (fromNodes == 0) ? 0.0 : (((double) edges) / fromNodes)
+            )));
+            if (navigatesThroughFunctionalDependencyInverse(input, constraint)) {
+                costEstimate = min(costEstimate, nodeUpper.get(to).flatMap(toNodes -> 
+                        nodeLower.get(from).map(fromNodes ->
+                        // due to a reverse functional dependency, the destination count is an upper bound for the edge count
+                        (fromNodes == 0) ? 0.0 : ((double) toNodes) / fromNodes
+                    )));
+            }
+            if (! edgeUpper.isPresent()) {
+                costEstimate = min(costEstimate, nodeUpper.get(to).flatMap(toNodes -> 
+                        nodeLower.get(from).map(fromNodes ->
+                        // If count is 0, no such element exists in the model, so there will be no branching
+                        // TODO rethink, why dstNodeCount / srcNodeCount instead of dstNodeCount? 
+                        // The universally valid bound would be something like sparseEdgeEstimate = dstNodeCount + 1.0
+                        // If we assume sparseness, we can reduce it by a SPARSENESS_FACTOR (e.g. 0.1). 
+                        // Alternatively, discount dstNodeCount * srcNodeCount on a SPARSENESS_EXPONENT (e.g 0.75) and then amortize over srcNodeCount.
+                        fromNodes != 0 ? Math.max(1.0, ((double) toNodes) / fromNodes) : 1.0
+                    )));
+            } 
+            if (navigatesThroughFunctionalDependency(input, constraint)) {
+                // At most one destination value
+                costEstimate = min(costEstimate, 1.0); 
+            }
+            
+            return costEstimate.orElse(DEFAULT_COST);
+        }
+    }
+    /**
+     * @since 1.7
+     */
+    protected boolean navigatesThroughFunctionalDependency(final IConstraintEvaluationContext input,
+            final PConstraint constraint) {
+        return navigatesThroughFunctionalDependency(input, constraint, input.getBoundVariables(), input.getFreeVariables());
+    }
+    /**
+     * @since 2.1
+     */
+    protected boolean navigatesThroughFunctionalDependencyInverse(final IConstraintEvaluationContext input,
+            final PConstraint constraint) {
+        return navigatesThroughFunctionalDependency(input, constraint, input.getFreeVariables(), input.getBoundVariables());
+    }
+    /**
+     * @since 2.1
+     */
+    protected boolean navigatesThroughFunctionalDependency(final IConstraintEvaluationContext input,
+            final PConstraint constraint, Collection<PVariable> determining, Collection<PVariable> determined) {
+        final QueryAnalyzer queryAnalyzer = input.getQueryAnalyzer();
+        final Map<Set<PVariable>, Set<PVariable>> functionalDependencies = queryAnalyzer
+                .getFunctionalDependencies(Collections.singleton(constraint), false);
+        final Set<PVariable> impliedVariables = FunctionalDependencyHelper.closureOf(determining,
+                functionalDependencies);
+        return ((impliedVariables != null) && impliedVariables.containsAll(determined));
+    }
+    
+    protected double calculateUnaryConstraintCost(final TypeConstraint constraint,
+            final IConstraintEvaluationContext input) {
+        PVariable variable = (PVariable) constraint.getVariablesTuple().get(0);
+        if (input.getBoundVariables().contains(variable)) {
+            return 0.9;
+        } else {
+            return projectionSize(input, constraint.getSupplierKey(), TupleMask.identity(1), Accuracy.APPROXIMATION)
+                    .map(count -> 1.0 + count).orElse(DEFAULT_COST);
+        }
+    }
+    protected double _calculateCost(final ExportedParameter exportedParam, final IConstraintEvaluationContext input) {
+        return 0.0;
+    }
+    protected double _calculateCost(final TypeFilterConstraint exportedParam,
+            final IConstraintEvaluationContext input) {
+        return 0.0;
+    }
+    protected double _calculateCost(final PositivePatternCall patternCall, final IConstraintEvaluationContext input) {
+        final List<Integer> boundPositions = new ArrayList<>();
+        final List<PParameter> parameters = patternCall.getReferredQuery().getParameters();
+        for (int i = 0; (i < parameters.size()); i++) {
+            final PVariable variable = patternCall.getVariableInTuple(i);
+            if (input.getBoundVariables().contains(variable)) boundPositions.add(i);
+        }
+        TupleMask projMask = TupleMask.fromSelectedIndices(parameters.size(), boundPositions);
+        
+        return bucketSize(patternCall, input, projMask).orElse(DEFAULT_COST);        
+    }
+    /**
+     * @since 1.7
+     */
+    protected double _calculateCost(final ExpressionEvaluation evaluation, final IConstraintEvaluationContext input) {
+        // Even if there are multiple results here, if all output variable is bound eval unwind will not result in
+        // multiple branches in search graph
+        final double multiplier = evaluation.isUnwinding() && !input.getFreeVariables().isEmpty()
+                ? EVAL_UNWIND_EXTENSION_FACTOR
+                : 1.0;
+        return _calculateCost((PConstraint) evaluation, input) * multiplier;
+    }
+    
+    /**
+     * @since 1.7
+     */
+    protected double _calculateCost(final Inequality inequality, final IConstraintEvaluationContext input) {
+        return _calculateCost((PConstraint)inequality, input);
+    }
+    
+    /**
+     * @since 1.7
+     */
+    protected double _calculateCost(final AggregatorConstraint aggregator, final IConstraintEvaluationContext input) {
+        return _calculateCost((PConstraint)aggregator, input);
+    }
+    
+    /**
+     * @since 1.7
+     */
+    protected double _calculateCost(final NegativePatternCall call, final IConstraintEvaluationContext input) {
+        return _calculateCost((PConstraint)call, input);
+    }
+    
+    /**
+     * @since 1.7
+     */
+    protected double _calculateCost(final PatternMatchCounter counter, final IConstraintEvaluationContext input) {
+        return _calculateCost((PConstraint)counter, input);
+    }
+    
+    /**
+     * @since 1.7
+     */
+    protected double _calculateCost(final BinaryTransitiveClosure closure, final IConstraintEvaluationContext input) {
+        // if (input.getFreeVariables().size() == 1) return 3.0; 
+        return StatisticsBasedConstraintCostFunction.DEFAULT_COST;
+    }
+    
+    /**
+     * @since 2.0
+     */
+    protected double _calculateCost(final BinaryReflexiveTransitiveClosure closure, final IConstraintEvaluationContext input) {
+        // if (input.getFreeVariables().size() == 1) return 3.0; 
+        return StatisticsBasedConstraintCostFunction.DEFAULT_COST;
+    }
+    
+    /**
+     * Default cost calculation strategy
+     */
+    protected double _calculateCost(final PConstraint constraint, final IConstraintEvaluationContext input) {
+        if (input.getFreeVariables().isEmpty()) {
+            return 1.0;
+        } else {
+            return StatisticsBasedConstraintCostFunction.DEFAULT_COST;
+        }
+    }
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public double calculateCost(final PConstraint constraint, final IConstraintEvaluationContext input) {
+        Preconditions.checkArgument(constraint != null, "Set constraint value correctly");
+        if (constraint instanceof ExportedParameter) {
+            return _calculateCost((ExportedParameter) constraint, input);
+        } else if (constraint instanceof TypeFilterConstraint) {
+            return _calculateCost((TypeFilterConstraint) constraint, input);
+        } else if (constraint instanceof ConstantValue) {
+            return _calculateCost((ConstantValue) constraint, input);
+        } else if (constraint instanceof PositivePatternCall) {
+            return _calculateCost((PositivePatternCall) constraint, input);
+        } else if (constraint instanceof TypeConstraint) {
+            return _calculateCost((TypeConstraint) constraint, input);
+        } else if (constraint instanceof ExpressionEvaluation) {
+            return _calculateCost((ExpressionEvaluation) constraint, input);
+        } else if (constraint instanceof Inequality) {
+            return _calculateCost((Inequality) constraint, input);
+        } else if (constraint instanceof AggregatorConstraint) {
+            return _calculateCost((AggregatorConstraint) constraint, input);
+        } else if (constraint instanceof NegativePatternCall) {
+            return _calculateCost((NegativePatternCall) constraint, input);
+        } else if (constraint instanceof PatternMatchCounter) {
+            return _calculateCost((PatternMatchCounter) constraint, input);
+        } else if (constraint instanceof BinaryTransitiveClosure) {
+            return _calculateCost((BinaryTransitiveClosure) constraint, input);
+        } else if (constraint instanceof BinaryReflexiveTransitiveClosure) {
+            return _calculateCost((BinaryReflexiveTransitiveClosure) constraint, input);
+        } else {
+            // Default cost calculation
+            return _calculateCost(constraint, input);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/VariableBindingBasedCostFunction.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/VariableBindingBasedCostFunction.java
new file mode 100644
index 00000000..a517af25
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/cost/impl/VariableBindingBasedCostFunction.java
@@ -0,0 +1,95 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Balazs Grill, Akos Horvath, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.planner.cost.impl;
+import java.util.Set;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.IConstraintEvaluationContext;
+import tools.refinery.viatra.runtime.localsearch.planner.cost.ICostFunction;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.AggregatorConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.ConstantValue;
+/**
+ * This class can be used to calculate cost of application of a constraint with a given adornment.
+ * 
+ * For now the logic is based on the following principles:
+ * 
+ * <li>The transitive closures, NACs and count finds are the most expensive operations
+ * 
+ * <li>The number of free variables increase the cost
+ * 
+ * <li>If all the variables of a constraint are free, then its cost equals to twice the number of its parameter
+ * variables. This solves the problem of unnecessary iteration over instances at the beginning of a plan (thus causing
+ * very long run times when executing the plan) by applying constraints based on structural features as soon as
+ * possible.
+ * 
+ * <br>
+ * 
+ * @author Marton Bur
+ * @since 1.4
+ *
+ */
+public class VariableBindingBasedCostFunction implements ICostFunction {
+    // Static cost definitions
+    private static int MAX = 1000;
+    private static int exportedParameterCost = MAX - 20;
+    private static int binaryTransitiveClosureCost = MAX - 50;
+    private static int nacCost = MAX - 100;
+    private static int aggregatorCost = MAX - 200;
+    private static int constantCost = 0;
+    
+    @Override
+    public double apply(IConstraintEvaluationContext input) {
+        PConstraint constraint = input.getConstraint();
+        Set<PVariable> affectedVariables = constraint.getAffectedVariables();
+        int cost = 0;
+        // For constants the cost is determined to be 0.0
+        // The following constraints should be checks:
+        // * Binary transitive closure
+        // * NAC
+        // * count
+        // * exported parameter - only a metadata
+        if (constraint instanceof ConstantValue) {
+            cost = constantCost;
+        } else if (constraint instanceof BinaryTransitiveClosure) {
+            cost = binaryTransitiveClosureCost;
+        } else if (constraint instanceof NegativePatternCall) {
+            cost = nacCost;
+        } else if (constraint instanceof AggregatorConstraint) {
+            cost = aggregatorCost;
+        } else if (constraint instanceof ExportedParameter) {
+            cost = exportedParameterCost;
+        } else {
+            // In case of other constraints count the number of unbound variables
+            for (PVariable pVariable : affectedVariables) {
+                if (input.getFreeVariables().contains(pVariable)) {
+                    // For each free variable ('without-value-variable') increase cost
+                    cost += 1;
+                }
+            }
+            if (cost == affectedVariables.size()) {
+                // If all the variables are free, double the cost.
+                // This ensures that iteration costs more
+                cost *= 2;
+            }
+        }
+        return Float.valueOf(cost);
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/util/CompilerHelper.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/util/CompilerHelper.java
new file mode 100644
index 00000000..9b4e9ea5
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/util/CompilerHelper.java
@@ -0,0 +1,209 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Daniel Segesdi, Akos Horvath, Zoltan Ujhelyi, 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.viatra.runtime.localsearch.planner.util;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PApply;
+import tools.refinery.viatra.runtime.matchers.planning.operations.POperation;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+/**
+ * 
+ * Helper methods for compiling SubPlans
+ * 
+ * @author Marton Bur
+ *
+ */
+public class CompilerHelper {
+    private CompilerHelper() {/*Utility class constructor*/}
+    
+    private static boolean isUserSpecified(PVariable var) {
+        return !var.isVirtual() && !var.getName().startsWith("_"); 
+    }
+    
+    public static Map<PVariable, Integer> createVariableMapping(SubPlan plan) {
+        Map<PVariable, Integer> variableMapping = new HashMap<>();
+        int variableNumber = 0;
+        // Important note: this list might contain duplications when parameters are made equal inside the pattern
+        // This is the expected and normal behavior
+        List<PVariable> symbolicParameterVariables = plan.getBody().getSymbolicParameterVariables();
+        for (PVariable pVariable : symbolicParameterVariables) {
+            if (!variableMapping.containsKey(pVariable)) {
+                variableMapping.put(pVariable, variableNumber++);
+            }
+        }
+        List<PVariable> allVariables = new ArrayList<>(plan.getBody().getUniqueVariables());
+        Collections.sort(allVariables, (left, right) -> {
+                    boolean leftUserSpecified = isUserSpecified(left);
+                    boolean rightUserSpecified = isUserSpecified(right);
+                    if (leftUserSpecified && !rightUserSpecified) {
+                        return -1;
+                    } else if (!leftUserSpecified && rightUserSpecified) {
+                        return +1;
+                    } else {
+                        return left.getName().compareTo(right.getName());
+                    }
+                });
+        for (PVariable pVariable : allVariables) {
+            if (!variableMapping.containsKey(pVariable)) {
+                variableMapping.put(pVariable, variableNumber++);
+            }
+        }
+        return variableMapping;
+    }
+    public static Map<PConstraint, Set<Integer>> cacheVariableBindings(SubPlan plan,
+            Map<PVariable, Integer> variableMappings, Set<PParameter> adornment) {
+        Set<Integer> externallyBoundVariables = getVariableIndicesForParameters(plan, variableMappings,
+                adornment);
+        Map<PConstraint, Set<Integer>> variableBindings = new HashMap<>();
+        List<SubPlan> allPlansInHierarchy = getAllParentPlans(plan);
+        for (SubPlan subPlan : allPlansInHierarchy) {
+            POperation operation = subPlan.getOperation();
+            if (operation instanceof PApply) {
+                PConstraint pConstraint = ((PApply) operation).getPConstraint();
+                Set<Integer> boundVariableIndices = getParametersBoundByParentPlan(variableMappings, subPlan);
+                boundVariableIndices.addAll(externallyBoundVariables);
+                
+                variableBindings.put(pConstraint, boundVariableIndices);
+            }
+        }
+        return variableBindings;
+    }
+    /**
+     * Returns the list of variable indexes that are bound by the parent plan.
+     */
+    private static Set<Integer> getParametersBoundByParentPlan(Map<PVariable, Integer> variableMappings,
+            SubPlan subPlan) {
+        if (!subPlan.getParentPlans().isEmpty()) {
+            SubPlan parentPlan = subPlan.getParentPlans().get(0);
+            Set<PConstraint> enforcedConstraints = parentPlan.getAllEnforcedConstraints();
+            Set<PVariable> affectedVariables = getAffectedVariables(enforcedConstraints);
+            return getVariableIndices(variableMappings, affectedVariables);
+        }
+        return Collections.emptySet();
+    }
+    /**
+     * @param plan
+     * @return all the ancestor plans including the given plan
+     */
+    private static List<SubPlan> getAllParentPlans(SubPlan plan) {
+        SubPlan currentPlan = plan;
+        List<SubPlan> allPlans = new ArrayList<>();
+        allPlans.add(plan);
+        while (!currentPlan.getParentPlans().isEmpty()) {
+            // In the local search it is assumed that only a single parent exists
+            currentPlan = currentPlan.getParentPlans().get(0);
+            allPlans.add(currentPlan);
+        }
+        return allPlans;
+    }
+    /**
+     * @param variableMappings
+     *            the mapping between variables and their indices
+     * @param variables
+     *            variables to get the indices for
+     * @return the set of variable indices for the given variables
+     */
+    private static Set<Integer> getVariableIndices(Map<PVariable, Integer> variableMappings,
+            Iterable<PVariable> variables) {
+        Set<Integer> variableIndices = new HashSet<>();
+        for (PVariable pVariable : variables) {
+            variableIndices.add(variableMappings.get(pVariable));
+        }
+        return variableIndices;
+    }
+    /**
+     * Returns all affected variables of the given PConstraints.
+     */
+    private static Set<PVariable> getAffectedVariables(Set<PConstraint> pConstraints) {
+        Set<PVariable> allDeducedVariables = new HashSet<>();
+        for (PConstraint pConstraint : pConstraints) {
+            allDeducedVariables.addAll(pConstraint.getAffectedVariables());
+        }
+        return allDeducedVariables;
+    }
+    /**
+     * Transforms the index of a parameter into the index of a variable of the normalized body.
+     * 
+     * @param plan
+     *            the SubPlan containing the original body and its parameters
+     * @param variableMappings
+     *            the mapping of PVariables to their indices
+     * @param parameters
+     *            a set of parameters
+     * @return the index of the variable corresponding to the parameter at the given index
+     */
+    private static Set<Integer> getVariableIndicesForParameters(SubPlan plan,
+            Map<PVariable, Integer> variableMappings, Set<PParameter> parameters) {
+        Map<PParameter, PVariable> parameterMapping = new HashMap<>();
+        for (ExportedParameter constraint : plan.getBody().getSymbolicParameters()) {
+            parameterMapping.put(constraint.getPatternParameter(), constraint.getParameterVariable());
+        }
+        
+        Set<Integer> variableIndices = new HashSet<>();
+        for (PParameter parameter : parameters) {
+            PVariable parameterVariable = parameterMapping.get(parameter);
+            if (parameterVariable == null) {
+                // XXX In case of older (pre-1.4) VIATRA versions, PParameters were not stable, see bug 498348
+                parameterVariable = plan.getBody().getVariableByNameChecked(parameter.getName());
+            }
+            Integer variableIndex = variableMappings.get(parameterVariable);
+            variableIndices.add(variableIndex);
+        }
+        return variableIndices;
+    }
+    /**
+     * Extracts the operations from a SubPlan into a list of POperations in the order of execution
+     * 
+     * @param plan
+     *            the SubPlan from wich the POperations should be extracted
+     * @return list of POperations extracted from the <code>plan</code>
+     */
+    public static List<POperation> createOperationsList(SubPlan plan) {
+        List<POperation> operationsList = new ArrayList<>();
+        while (plan.getParentPlans().size() > 0) {
+            operationsList.add(plan.getOperation());
+            SubPlan parentPlan = plan.getParentPlans().get(0);
+            plan = parentPlan;
+        }
+        operationsList.add(plan.getOperation());
+        
+        Collections.reverse(operationsList);
+        return operationsList; 
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/util/OperationCostComparator.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/util/OperationCostComparator.java
new file mode 100644
index 00000000..58f4fc41
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/planner/util/OperationCostComparator.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Marton Bur, Zoltan Ujhelyi, Akos Horvath, Istvan Rath and Danil 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.viatra.runtime.localsearch.planner.util;
+import java.util.Comparator;
+import tools.refinery.viatra.runtime.localsearch.planner.PConstraintInfo;
+/**
+ * @author Marton Bur
+ *
+ */
+public class OperationCostComparator implements Comparator<PConstraintInfo>{
+    @Override
+    public int compare(PConstraintInfo o1, PConstraintInfo o2) {
+        return Double.compare(o1.getCost(), o2.getCost());
+    }
+}
diff --git a/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/profiler/LocalSearchProfilerAdapter.java b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/profiler/LocalSearchProfilerAdapter.java
new file mode 100644
index 00000000..8c50c694
--- /dev/null
+++ b/subprojects/viatra-runtime-localsearch/src/main/java/tools/refinery/viatra/runtime/localsearch/profiler/LocalSearchProfilerAdapter.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs 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.viatra.runtime.localsearch.profiler;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import tools.refinery.viatra.runtime.localsearch.MatchingFrame;
+import tools.refinery.viatra.runtime.localsearch.matcher.ILocalSearchAdapter;
+import tools.refinery.viatra.runtime.localsearch.matcher.LocalSearchMatcher;
+import tools.refinery.viatra.runtime.localsearch.matcher.MatcherReference;
+import tools.refinery.viatra.runtime.localsearch.operations.ISearchOperation;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlan;
+import tools.refinery.viatra.runtime.localsearch.plan.SearchPlanExecutor;
+/**
+ * This is a simple {@link ILocalSearchAdapter} which capable of counting
+ * each search operation execution then printing it in human readably form 
+ * (along with the executed plans) using {@link #toString()}
+ * @author Grill Balázs
+ * @since 1.5
+ *
+ */
+public class LocalSearchProfilerAdapter implements ILocalSearchAdapter {
+    private final Map<MatcherReference, List<SearchPlan>> planReference = new HashMap<>();
+    
+    private final Map<ISearchOperation, Integer> successfulOperationCounts = new HashMap<>();
+    private final Map<ISearchOperation, Integer> failedOperationCounts = new HashMap<>();
+    @Override
+    public void patternMatchingStarted(LocalSearchMatcher lsMatcher) {
+        MatcherReference key = new MatcherReference(lsMatcher.getPlanDescriptor().getQuery(),
+                lsMatcher.getPlanDescriptor().getAdornment());
+        planReference.put(key, lsMatcher.getPlan().stream().map(SearchPlanExecutor::getSearchPlan).collect(Collectors.toList()));
+    }
+    @Override
+    public void operationExecuted(SearchPlan plan, ISearchOperation operation, MatchingFrame frame, boolean isSuccessful) {
+        Map<ISearchOperation, Integer> counts = isSuccessful ? successfulOperationCounts : failedOperationCounts;
+        counts.merge(operation, 
+                /*no previous entry*/1, 
+                /*increase previous value*/(oldValue, v) -> oldValue + 1);
+    }
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (java.util.Map.Entry<MatcherReference, List<SearchPlan>> entry: planReference.entrySet()){
+            sb.append(entry.getKey());
+            sb.append("\n");
+            
+            sb.append(entry.getValue());
+            
+            List<SearchPlan> bodies = entry.getValue();
+            sb.append("{\n");
+            for(int i=0;i<bodies.size();i++){
+                sb.append("\tbody #");sb.append(i);sb.append("(\n");
+                for(ISearchOperation operation : bodies.get(i).getOperations()){
+                    final int successCount = successfulOperationCounts.computeIfAbsent(operation, op -> 0);
+                    final int failCount = failedOperationCounts.computeIfAbsent(operation, op -> 0);
+                    sb.append("\t\t");sb.append(successCount);
+                    sb.append("\t");sb.append(failCount);
+                    sb.append("\t");sb.append(successCount + failCount);
+                    sb.append("\t");sb.append(operation);
+                    sb.append("\n");
+                }
+                sb.append("\t)\n");
+            }
+            sb.append("}\n");
+        }
+        return sb.toString();
+    }
+    
+}
author	Kristóf Marussy <marussy@mit.bme.hu>	2023-09-14 19:29:36 +0200
committer	GitHub <noreply@github.com>	2023-09-14 19:29:36 +0200
commit	98ed3b6db5f4e51961a161050cc31c66015116e8 (patch)
tree	8bfd6d9bc8d6ed23b9eb0f889dd40b6c24fe8f92 /subprojects/viatra-runtime-localsearch
parent	Merge pull request #38 from nagilooh/design-space-exploration (diff)
parent	Merge remote-tracking branch 'upstream/main' into partial-interpretation (diff)
download	refinery-98ed3b6db5f4e51961a161050cc31c66015116e8.tar.gz refinery-98ed3b6db5f4e51961a161050cc31c66015116e8.tar.zst refinery-98ed3b6db5f4e51961a161050cc31c66015116e8.zip