74 files changed, 8370 insertions, 0 deletions

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();
+    }
+    
+}