relationalai 0.13.0__py3-none-any.whl → 0.13.0.dev0__py3-none-any.whl

relationalai/experimental/pathfinder/bridge.py

@@ -1,226 +0,0 @@
-from typing import Callable
-
-
-from relationalai.dsl import Type, Symbol, create_vars, create_var, next_id, global_ns
-from relationalai.std import rel
-from relationalai.debugging import logger
-
-from relationalai.experimental.pathfinder.rpq import RPQ
-from relationalai.experimental.pathfinder.utils import get_model
-from relationalai.experimental.pathfinder.datalog import install_program
-from relationalai.experimental.pathfinder.compiler import (
-    compile_conn, compile_product_graph
-)
-from relationalai.experimental.pathfinder.api import (
-    make_config_relation, make_input_relation
-)
-
-import importlib.resources as pkg_resources
-
-# Dictionary to keep track of models with Pathfinder already installed
-PATHFINDER_INSTALLED = {}
-
-# -----------------------------------------------------------------------------------------
-# Installing the Pathfinder source code
-# -----------------------------------------------------------------------------------------
-# Whilst the Package manager is not yet available, the Pathfinder is installed from manually
-# prepared single source file (present in the current directory). Ideally, we want to use a
-# single version but for comparative benchmarking and potential bug fixes we ensure that
-# multiple versions can be installed and used.
-# ----------------------------------------------------------------------------------------
-def ensure_pathfinder_installed(model, options) -> str:
-
-    pathfinder_lib_version = options['pathfinder_lib_version']
-
-    key = (model.name, pathfinder_lib_version)
-
-    if not PATHFINDER_INSTALLED.get(key, False):
-        source = get_pathfinder_source_code(pathfinder_lib_version)
-
-        logger.info(f'Installing Pathfinder source version {pathfinder_lib_version}')
-
-        module_name = f"pathfinder_v{pathfinder_lib_version.replace('.', '_')}"
-
-        # replace `pathfinder` with versioned module name in Rel source:
-        import re
-        source = re.sub(r'\bpathfinder\b', module_name, source)
-
-        model.install_raw(source, name=module_name, overwrite=True)
-        PATHFINDER_INSTALLED[key] = module_name
-
-    return PATHFINDER_INSTALLED[key]
-
-def get_pathfinder_source_code(version):
-    try:
-        resource_name = f"pathfinder-v{version}.rel"
-        with pkg_resources.open_text('relationalai.experimental.pathfinder', resource_name) as file:
-            return file.read()
-    except FileNotFoundError:
-        raise Exception("Pathfinder source file not found.")
-
-# -----------------------------------------------------------------------------------------
-# Pathfinder invocation
-# -----------------------------------------------------------------------------------------
-# The invocation of pathfinder consists of installing the logic and calling the appropriate
-# method of the `pathfinder` module. The invocation is parameterized by various input
-# options.
-# -----------------------------------------------------------------------------------------
-# The main entry point for invoking the pathfinder i.e., installing the logic for
-# constructing the paths (if not does already). Returns the dedicated Path type containing
-# all paths matching the input compiled pattern, as controlled by the options.
-# ----------------------------------------------------------------------------------------
-def invoke_pathfinder(pattern: RPQ, options):
-    logger.info("Invoking pathfinder with options:")
-    for option in options:
-        logger.info(f" * {option}: {options[option]}")
-
-    model = get_model(options)
-    # make sure pathfinder is installed
-    pathfinder_module = ensure_pathfinder_installed(model, options)
-    pathfinder = getattr(global_ns, pathfinder_module)
-
-    # use a unique identifier for all compiled types and relations
-    pq_id = next_id()
-    # source and target relations
-    source_rel = f"pq_source_{pq_id}"
-    source = getattr(rel, source_rel)
-    target_rel = f"pq_target_{pq_id}"
-    target = getattr(rel, target_rel)
-
-    # use the connectivity relation to find the source or target nodes unless specified
-    conn = None
-    if options['source'] is None or options['target'] is None:
-        conn_program = compile_conn(pattern, options)
-        conn_rel = conn_program.root_rel['conn_rel']
-        # connectivity relation
-        conn = getattr(rel, conn_rel)
-        # installing connectivity pattern rules
-        install_program(model, conn_program, {**options, 'suppress_groundedness_test': True})
-
-    define_endpoint_relations(source, target, model, conn, options)
-
-    pg_program = compile_product_graph(pattern, source_rel, target_rel, options)
-    pg_graph_rel = pg_program.root_rel['pg_graph_rel']
-    pg_source_rel = pg_program.root_rel['pg_source_rel']
-    pg_target_rel = pg_program.root_rel['pg_target_rel']
-    edge_label_map = pg_program.edge_label_map
-    pg_graph = getattr(rel, pg_graph_rel)
-    pg_source = getattr(rel, pg_source_rel)
-    pg_target = getattr(rel, pg_target_rel)
-    install_program(model, pg_program, options)
-
-    # output types
-    Path = model.Type(f"Path{pq_id}")
-    PathPosition = model.Type(f"PathPosition{pq_id}")
-    PathEdge = model.Type(f"PathEdge{pq_id}")
-    PathEdgeLabelMap = model.Type(f"PathEdgeLabelMap{pq_id}")
-
-    # creating edge label map
-    define_edge_label_mapping(model, edge_label_map, PathEdgeLabelMap, options)
-
-    input_relation = make_input_relation(model, pg_graph, pg_source, pg_target)
-    config_relation = make_config_relation(model, options)
-    with model.rule(dynamic=True):
-        path_id, kind, index, value = create_vars(4)
-        pathfinder.find_paths(
-            input_relation,
-            config_relation,
-            path_id,
-            kind,
-            index,
-            value
-        )
-
-        path = Path.add(path_id=path_id)
-
-        map_path_positions(PathPosition, path, kind, index, value)
-
-        map_edge_labels(PathEdgeLabelMap, PathEdge, path, edge_label_map, kind, index, value)
-
-    connect_edge_positions(model, Path, PathEdge, PathPosition)
-
-    return Path()
-
-def map_path_positions(PathPosition, path, kind, index, value):
-    with kind == Symbol("node"):
-        pos = PathPosition.add(path=path, index=index)
-        pos.set(node=value)
-        path.position.add(pos)
-
-def map_edge_labels(PathEdgeLabelMap, PathEdge, path, edge_label_map, kind, index, value):
-    if len(edge_label_map) != 0:
-        with kind == Symbol("edge_label"):
-            lab = PathEdgeLabelMap(pq_edge_label=value)
-            edge = PathEdge.add(path=path, index=index)
-            edge.set(label=lab.label, direction=lab.direction, property=lab.property)
-            path.edge.add(edge)
-
-def connect_edge_positions(model, Path, PathEdge, PathPosition):
-    with model.rule():
-        path = Path()
-        e = PathEdge(path=path)
-        from_pos = PathPosition(path=path, index=e.index-1)
-        to_pos = PathPosition(path=path, index=e.index)
-        e.set(from_node=from_pos.node, to_node=to_pos.node)
-
-def define_endpoint_relations(source, target, model, conn, options):
-    if options['source'] is None and options['target'] is None:
-        assert conn is not None
-        with model.rule():
-            x, y = create_vars(2)
-            conn(x, y)
-            source.add(x)
-            target.add(y)
-        return
-
-    assert options['source'] is not None or options['target'] is not None
-
-    if options['source'] is not None:
-         define_relation_from_spec(source, options['source'], model)
-
-    if options['target'] is not None:
-        define_relation_from_spec(target, options['target'], model)
-
-    if options['source'] is None:
-        define_relation_with_conn(source, 'backward', conn, target, model)
-
-    if options['target'] is None:
-        define_relation_with_conn(target, 'forward', conn, source, model)
-
-
-def define_relation_from_spec(relation, relation_spec, model):
-    if isinstance(relation_spec, Type):
-        with model.rule():
-            x = relation_spec()
-            relation.add(x)
-    else:
-        assert isinstance(relation_spec, Callable)
-        with model.rule():
-            x = create_var()
-            relation_spec(x)
-            relation.add(x)
-
-def define_relation_with_conn(relation, direction, conn, opposite_relation, model):
-    assert conn is not None
-
-    with model.rule(dynamic=True):
-        x, y = create_vars(2)
-        conn(x, y)
-        if direction == 'forward':
-            opposite_relation(x)
-            relation.add(y)
-        else:
-            opposite_relation(y)
-            relation.add(x)
-
-def define_edge_label_mapping(model, edge_label_map, PathEdgeLabelMap, options):
-    if len(edge_label_map) == 0:
-        return
-    with model.rule(dynamic=True):
-        for pq_edge_label in edge_label_map:
-            edge_label = edge_label_map[pq_edge_label]
-            label = str(edge_label)
-            property = edge_label.label
-            direction = edge_label.direction
-            label_map = PathEdgeLabelMap.add(pq_edge_label=pq_edge_label)
-            label_map.set(label=label, direction=direction, property=property)

relationalai/experimental/pathfinder/compiler.py

@@ -1,416 +0,0 @@
-
-from abc import ABC
-from typing import Dict, List, Iterable
-
-from relationalai.debugging import logger
-from relationalai.dsl import next_id
-
-from relationalai.experimental.pathfinder.options import DEFAULT_OPTIONS
-from relationalai.experimental.pathfinder.rpq import RPQ
-from relationalai.experimental.pathfinder.filter import (
-    NodeFilter, NodeLabel, EdgeLabel, AnonymousNodeFilter
-)
-from relationalai.experimental.pathfinder.automaton import prepare_automaton
-from relationalai.experimental.pathfinder.transition import EdgeTransition, NodeTransition
-
-from relationalai.experimental.pathfinder.datalog import (
-    ConstantEqualityAtom, Rule, RelAtom, AnonymousFilterAtom,
-    VariableEqualityAtom, Atom, DatalogProgram
-)
-
-# =========================================================================================
-# Compiling a pattern into Rel programs
-# =========================================================================================
-#
-# We compile a RPQ pattern into two kinds of programs:
-# 1. A program that computes the connectivity relation of the input automaton.
-# 2. A program that computes the product graph of the input automaton and a knowledge graph.
-#
-# We illustrate the compilation process on the following example pattern:
-# -----------------------------------------------------------------------------------------
-# Running example
-# -----------------------------------------------------------------------------------------
-# An example of the program generation is presented on the pattern below.
-#
-# path(Odd, star('-[A]->', Even)) | path('<-[B]-', N)
-#
-# which is parsed into the following RPQ
-#
-# ╷ Union
-# ├──┐ Concat
-# │  ├──╴ Node(Odd)
-# │  └──┐ Star
-# │     └──┐ Concat
-# │        ├──╴ Edge(-[A]→) [pos=1]
-# │        └──╴ Node(Even)
-# └──┐ Concat
-#    ├──╴ Edge(←[B]-) [pos=2]
-#    └──╴ Node(N)
-#
-# The RPQ is compiled into the following automaton (with transitions explicitly labeled):
-# * states: 0 1 2
-# * init: 0
-# * delta:
-#    - 0
-#       → 1
-#         ⊨(Odd)=[-[A]→]=()⇒    (t1)
-#       → 2
-#         ⊨()=[←[B]-]=()⇒       (t2)
-#    - 1
-#       → 1
-#         ⊨(Even)=[-[A]→]=()⇒   (t3)
-# * final:
-#    - 0
-#       ⊨(Odd)⇒                 (f1)
-#    - 1
-#       ⊨(Even)⇒                (f2)
-#    - 2
-#       ⊨(N)⇒                   (f3)
-#
-# =========================================================================================
-# 1. Connectivity Program
-# =========================================================================================
-# The Rel connectivity program defines a binary relation `pq_conn(x, y)` that selects the
-# nodes `y` reachable from `x` with the automaton having an accepting run. The program has
-# two independent uses:
-# 1. When the RPQ is meant to be evaluated as a connectivity query, the program is used to
-#    evaluate the query.
-# 2. When the RPQ is meant to produce paths but the user does not specify the source or
-#    target nodes to be used during evaluation.
-#
-# The program consists of binary predicates `pq_conn_from_q(x, y)` that selects the nodes
-# `y` reachable from `x` with the automaton having a run from state `q` to an accepting
-# state. Note that when the automaton has cycles, the program may be recursive. To make sure
-# that each introduced predicate is grounded we may "contract" the final node transitions of
-# an accepting state `q` with every incoming transition of `q` (note that the final node
-# transitions may be ungrounded). As a consequence, an accepting state `q` that does not
-# have any outgoing transitions, called an _exit state_, does not need its own dedicated
-# `pq_conn_fom_q` predicate. At this time, we decorate every predicate with `@no_inline`
-# attribute to prevent any inlining. Diligent inlining may be beneficial for performance but
-# is left for future work.
-#
-# -----------------------------------------------------------------------------------------
-# In the running example, the state 2 is an exit state. Also note that the initial state is
-# also a final state, thus the automaton accepts empty paths (consisting of a single node
-# with type OddNode). The compiled Rel program follows. (All relations have `@no_inline`
-# attribute that we omit here for brevity)
-#
-# // The main connectivity predicate
-# def pq_conn(x0, x1): pq_conn_from_0(x0, x1)
-#
-# // Accepting empty paths with node transition f1
-# def pq_conn(x0, x1): x0 = x1 ∧ Odd(x0)
-#
-# // Paths from state 0 going through t1 to state 1
-# def pq_conn_from_0(x0, x2): A(x0, x1) ∧ Odd(x0) ∧ pq_conn_from_1(x1, x2)
-#
-# // Paths from state 0 through t1 (to state 1) and terminating with f2
-# def pq_conn_from_0(x0, x1): A(x0, x1) ∧ Odd(x0) ∧ Even(x1)
-#
-# // Paths from state 0 through t2 (to state 1) and terminating with f3
-# def pq_conn_from_0(x0, x1): A(x0, x1) ∧ Even(x0) ∧ Even(x1)
-#
-# // Paths from state 1 through t3 to state 1
-# def pq_conn_from_1(x0, x2): A(x0, x1) ∧ Even(x0) ∧ pq_conn_from_1(x1, x2)
-#
-# // Paths from state 1 through t3 and terminating with f2
-# def pq_conn_from_1(x0, x1): A(x0, x1) ∧ Even(x0) ∧ Even(x1)
-#
-# =========================================================================================
-# 2. Product Graph Program
-# =========================================================================================
-# The Product Graph program defines a relation `pg_graph` of arity 5 that defines the set of
-# edges in the product graph: `pg_graph(q, p, a, n, m)` holds iff the product graph has an
-# edge from `(q, n)` to `(p, m)` and the hash value of the edge label is `a`. The program
-# also defines two unary relations `pg_source(n, q)` and `pg_target(n, q)` that define the
-# source and target nodes of the product graph. The computation of the product graph is
-# based on the input finite automaton corresponding to the RPQ and additionally two
-# relations `source` and `target` with the sets of source and target nodes of the knowledge
-# graph.
-#
-# The program is used to compute the product graph of the automaton and a knowledge graph.
-# The program is used when the user specifies the source and target nodes to be used during
-# evaluation.
-#
-# -----------------------------------------------------------------------------------------
-# In the running example, the compiled Rel program follows
-#
-# // Source nodes of the product graph
-# def pg_source(x0, x1): source(x0) x1 = 0
-#
-# // Target nodes of the product graph
-# def pg_target(x0, x1): target(x0) ∧ x1 = 0 ∧ Odd(x0)
-# def pg_target(x0, x1): target(x0) ∧ x1 = 1 ∧ Even(x0)
-# def pg_target(x0, x1): target(x0) ∧ x1 = 2 ∧ N(x0)
-#
-# // Edges of the product graph
-# def pg_graph(x0, x1, x2, x3, x4): x0 = 0 ∧ x1 = 1 ∧ x2 = hash(-[A]→) ∧ A(x3, x4) ∧ Odd(x3)
-# def pg_graph(x0, x1, x2, x3, x4): x0 = 0 ∧ x1 = 2 ∧ x2 = hash(←[B]-) ∧ B(x4, x3)
-# def pg_graph(x0, x1, x2, x3, x4): x0 = 1 ∧ x1 = 1 ∧ x2 = hash(-[A]→) ∧ A(x3, x4) ∧ Even(x3)
-#
-# =========================================================================================
-
-
-class RPQCompiler(ABC):
-    def __init__(self, pattern: RPQ, options):
-        self.a = prepare_automaton(pattern, options)
-
-        self.prog_id = next_id()
-
-        self.rules: List[Rule] = []
-        self.rel_attrs: Dict[str, List[str]] = dict()
-
-    def yield_node_filters_atoms(self, filters: Iterable[NodeFilter], x: int):
-        for f in filters:
-            if isinstance(f, NodeLabel):
-                yield RelAtom(f.label, (x,))
-            elif isinstance(f, AnonymousNodeFilter):
-                yield AnonymousFilterAtom(f._unary_function, (x,))
-
-    def yield_edge_transition_atoms(self, t, x, y):
-        edge_label = t.get_label()
-        if edge_label.direction == 'forward':
-            yield RelAtom(edge_label.label, (x, y))
-        else:
-            yield RelAtom(edge_label.label, (y, x))
-
-        if t.has_anon_edge_filters():
-            for f in t.get_anon_edge_filters():
-                yield AnonymousFilterAtom(f.binary_function, (x, y))
-
-        if t.has_src_filters():
-            yield from self.yield_node_filters_atoms(t.src_filters, x)
-
-        if t.has_trg_filters():
-            yield from self.yield_node_filters_atoms(t.trg_filters, y)
-
-    def add_rule(self, head: RelAtom, body: List[Atom], n=None):
-        if n is None:
-            var_refs = set(head.vars).union([v for a in body for v in a.vars])
-            n = len(var_refs)
-        self.rules.append(Rule(head, n, body))
-        logger.info(f"Added rule: {self.rules[-1]}")
-
-# Prepares (decorates) relations and gathers their definitions.
-class ConnCompiler(RPQCompiler):
-    def __init__(self, pattern: RPQ, options):
-        super().__init__(pattern, options)
-
-        self.edge_transition_id = dict()
-        self.final_transition_id = dict()
-
-        self.rules: List[Rule] = []
-        self.rel_attrs: Dict[str, List[str]] = dict()
-
-        # self.main_conn_rel is the name of the binary connectivity relation `pq_conn` such
-        # that `pq_conn(x, y)` holds iff there is a path from x to y with the automaton
-        # having an accepting run (from an initial state to a final state).
-        self.main_conn_rel = f'pq_{self.prog_id}_conn'
-
-        # maps state q to the name of a binary connectivity relation `pg_conn_from_q` such
-        # that `pg_conn_from_q(x, y)` holds iff there is a path from x to y with the
-        # automaton having an accepting run when starting in state q.
-        self.conn_rel: Dict[int, str] = dict()
-
-        logger.debug("Initializing PyRel Connectivity Predicate emitter")
-        logger.debug(self.a)
-
-        self.prepare_relations()
-
-
-    # -------------------------------------------------------------------------------------
-    # Prepare relations for states, transitions, and final states with necessary decorators
-    # -------------------------------------------------------------------------------------
-    def prepare_relations(self):
-        self.rel_attrs[self.main_conn_rel] = ['@track', '@no_inline']
-
-        for q in self.a.states:
-            self.prepare_state_conn_relation(q)
-
-    def prepare_state_conn_relation(self, q):
-        if self.a.is_exit(q):
-            # the state does not outgoing edge-transitions but only ungrounded final node
-            # transitions: we will not create an ungrounded  connectivity relation for it
-            # but instead we will always contract it with the preceding transition.
-            return
-
-        self.conn_rel[q] = f'pq_{self.prog_id}_conn_from_{q}'
-        self.rel_attrs[self.conn_rel[q]] = ['@no_inline']
-
-    # -------------------------------------------------------------------------------------
-    # Create rules from the automaton
-    # -------------------------------------------------------------------------------------
-    def make_rules(self):
-        self.make_main_conn_rule()
-
-        for q in self.a.delta:
-            for p in self.a.delta[q]:
-                for t in self.a.delta[q][p]:
-                    self.make_edge_rules(q, p, t)
-
-    def make_main_conn_rule(self):
-        q_0 = self.a.get_initial_state()
-        if not self.a.is_exit(q_0):
-            init_conn_rel = self.conn_rel[q_0]
-            self.add_rule(
-                head = RelAtom(self.main_conn_rel, (0, 1)),
-                body = [RelAtom(init_conn_rel, (0, 1))]
-            )
-        if q_0 in self.a.final:
-            for e in self.a.final[q_0]:
-                self.add_rule(
-                    head = RelAtom(self.main_conn_rel, (0, 1)),
-                    body = [
-                        VariableEqualityAtom((0, 1)),
-                        *self.yield_node_filters_atoms(e.filters, 0)
-                    ]
-                )
-
-    def make_edge_rules(self, q, p, t: EdgeTransition):
-        if not self.a.is_exit(p):
-            self.make_transition_rule(q, p, t)
-
-        if p in self.a.final:
-            for e in self.a.final[p]:
-                self.make_transition_final_rule(q, t, e)
-
-    def make_transition_rule(self, q, p, t: EdgeTransition):
-        assert not self.a.is_exit(p)
-
-        conn_q_rel = self.conn_rel[q]
-        conn_p_rel = self.conn_rel[p]
-
-        self.add_rule(
-            head = RelAtom(conn_q_rel, (0, 2)),
-            body = [
-                *self.yield_edge_transition_atoms(t, 0, 1),
-                RelAtom(conn_p_rel, (1, 2))
-            ]
-        )
-
-    def make_transition_final_rule(self, q, t: EdgeTransition, e: NodeTransition):
-        conn_q_rel = self.conn_rel[q]
-
-        self.add_rule(
-            head = RelAtom(conn_q_rel, (0, 1)),
-            body = [
-                *self.yield_edge_transition_atoms(t, 0, 1),
-                *self.yield_node_filters_atoms(e._filters, 1)
-            ]
-        )
-
-def compile_conn(pattern, options=DEFAULT_OPTIONS) -> DatalogProgram:
-    compiler = ConnCompiler(pattern, options)
-    compiler.make_rules()
-
-    program = DatalogProgram(
-        root_rel = {'conn_rel': compiler.main_conn_rel},
-        rel_attrs = compiler.rel_attrs,
-        rules = compiler.rules,
-        edge_label_map = None
-    )
-
-    return program
-
-
-class ProductGraphCompiler(RPQCompiler):
-    def __init__(self, pattern: RPQ, source_rel: str, target_rel: str, options):
-        super().__init__(pattern, options)
-
-        self.source_rel = source_rel
-        self.target_rel = target_rel
-
-        # The name of the relation with the edges in the product graph of the knowledge
-        # graph and the input automaton. The relation has arity `5` and contains a tuple
-        # `(q, p, a, n, m)` iff the product graph has an edge from `(q, n)` to `(p, m)` and
-        # the hash value of the edge label is `a`.
-        self.pg_graph_rel = f'pg_{self.prog_id}_graph'
-
-        # The relation names of the source and target nodes of the product graph; arity 2,
-        # each contains pairs `(n, q)`, where `n` is the node of the knowledge graph and `q`
-        # is a state of the automaton.
-        self.pg_source_rel = f'pg_{self.prog_id}_source'
-        self.pg_target_rel = f'pg_{self.prog_id}_target'
-
-        self.rel_attrs[self.pg_graph_rel] = ['@pipeline']
-        self.rel_attrs[self.pg_source_rel] = ['@pipeline']
-        self.rel_attrs[self.pg_target_rel] = ['@pipeline']
-
-        # maps hashes of edge labels to edge labels
-        self.pg_edge_label_map: Dict[int, EdgeLabel] = {
-            hash(lab): lab for lab in self.a.alphabet
-        }
-
-        logger.info("Initializing PyRel Product Graph emitter")
-        logger.info(self.a)
-
-
-    # -------------------------------------------------------------------------------------
-    # Prepare definitions of the 3 main relations
-    # -------------------------------------------------------------------------------------
-
-    def make_rules(self):
-        self.make_pg_source_rules()
-        self.make_pg_graph_rules()
-        self.make_pg_target_rules()
-
-    def make_pg_source_rules(self):
-        for q in self.a.init:
-            # pg_source(n, x) ← source_rel(n) ∧ x = q
-            self.add_rule(
-                head = RelAtom(self.pg_source_rel, (0, 1)),
-                body = [
-                    RelAtom(self.source_rel, (0,)),
-                    ConstantEqualityAtom((1, q))
-                ]
-            )
-
-    def make_pg_target_rules(self):
-        for q in self.a.final:
-            for e in self.a.final[q]:
-                # pg_target(n, x) ← target_rel(n) ∧ x = q ∧ e(n)
-                self.add_rule(
-                    head = RelAtom(self.pg_target_rel, (0, 1)),
-                    body = [
-                        RelAtom(self.target_rel, (0,)),
-                        ConstantEqualityAtom((1, q)),
-                        *self.yield_node_filters_atoms(e.filters, 0)
-                    ]
-                )
-
-    def make_pg_graph_rules(self):
-        for q in self.a.delta:
-            for p in self.a.delta[q]:
-                for t in self.a.delta[q][p]:
-                    # pg_edge(x, y, a, n, m) ← q = x ∧ p = y ∧ a = #label(t) ∧ t(n, m)
-                    self.add_rule(
-                        head = RelAtom(self.pg_graph_rel, (0, 1, 2, 3, 4)),
-                        body = [
-                            ConstantEqualityAtom((0, q)),
-                            ConstantEqualityAtom((1, p)),
-                            ConstantEqualityAtom((2, hash(t.get_label()))),
-                            *self.yield_edge_transition_atoms(t, 3, 4)
-                        ]
-                    )
-
-
-def compile_product_graph(pattern: RPQ, source_rel: str, target_rel: str, options=DEFAULT_OPTIONS) -> DatalogProgram:
-    compiler = ProductGraphCompiler(pattern, source_rel, target_rel, options)
-    compiler.make_rules()
-
-    logger.info('Mapping edge labels:')
-    for pq_edge_label in compiler.pg_edge_label_map:
-            logger.info(f" * {pq_edge_label} is {compiler.pg_edge_label_map[pq_edge_label]}")
-
-    program = DatalogProgram(
-        root_rel = {
-            'pg_graph_rel': compiler.pg_graph_rel,
-            'pg_source_rel': compiler.pg_source_rel,
-            'pg_target_rel': compiler.pg_target_rel
-        },
-        rel_attrs = compiler.rel_attrs,
-        rules = compiler.rules,
-        edge_label_map = compiler.pg_edge_label_map
-    )
-
-    return program