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

relationalai/experimental/paths/path_algorithms/usp-old.py

@@ -0,0 +1,130 @@
+# For builder components.
+from relationalai.semantics import Integer, define, max, sum, not_
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+
+
+def compute_usp(g: Graph, Source, Target, max_length = None):
+    # Computes the Union of Shortest Paths (USP) from a source set to a destination set
+    # USP is a subgraph of the original graph
+
+    edge = g.Edge
+    Node = g.Node
+
+    n, d = Integer.ref(), Integer.ref()
+    tgt, u, v, w = Node.ref(), g.Node.ref(), g.Node.ref(), g.Node.ref()
+
+    if max_length is None:
+        ball = ball_upto(g, Source, Target)
+        usp_nodes = g.model.Relationship(f"Node {{{Node}}} is in the USP")
+        usp = g.model.Relationship(f"Edge {{{Node}}} to {{{Node}}} is in the USP")
+        boundary = g.model.Relationship(f"Target node {{{Node}}} is in the boundary of the ball")
+
+        # propagate backwards to find the nodes that are in the USP:
+        define(boundary(tgt)).where(
+            Target(tgt),
+            ball(n, tgt)
+        )
+
+        define(usp_nodes(tgt)).where(
+            boundary(tgt)
+        )
+
+        define(usp_nodes(u)).where(
+            usp(u, v)
+        )
+
+        define(usp(u, v)).where(
+            usp_nodes(v),
+            ball(d, v),
+            ball(d - 1, u),
+            edge(u, v)
+        )
+    else:
+        ball = ball_with_repetition(g, Source, max_length)
+        max_dist = g.model.Relationship("The maximum distance of a target node form the source nodes is {Integer}")
+        usp = g.model.Relationship(f"{{{Node}}} at distance {{Integer}} from the source nodes is connected with {{{Node}}}")
+        boundary = g.model.Relationship(f"Target pair {{{Node}}} {{Integer}} is in the boundary of the ball")
+
+        define(max_dist(max(n))).where(
+            ball(n, tgt),
+            Target(tgt)
+        )
+
+        define(boundary(tgt, n)).where(
+            max_dist(n),
+            Target(tgt),
+            ball(n, tgt)
+        )
+
+        define(usp(u, n, tgt)).where(
+            boundary(tgt, n + 1),
+            ball(n, u),
+            edge(u, v)
+        )
+
+        define(usp(u, n, v)).where(
+            usp(v, n + 1, w),
+            ball(n, u),
+            edge(u, v)
+        )
+
+
+    return usp, boundary
+
+
+
+
+def compute_nsp_from_usp(g: Graph, usp, Source, Target, Boundary):
+    Node = g.Node
+
+    n, m = Integer.ref(), Integer.ref()
+    tgt, u, v = Node.ref(), Node.ref(), Node.ref()
+
+    if usp._arity() == 2:
+        nsp = g.model.Relationship(f"Number of shortest paths from {{{Node}}} to destination is {{Integer}}")
+
+        define(nsp(tgt, 1)).where(
+            Boundary(tgt)
+        )
+
+        define(nsp(tgt, 1)).where(
+            Target(tgt),
+            Source(tgt)
+        )
+
+        define(nsp(u, sum(v, n).per(u))).where(
+            nsp(v, n),
+            usp(u, v)
+        )
+    else:
+        nsp = g.model.Relationship(f"Number of shortest paths from pair {{{Node}}} {{Integer}} to destination is {{Integer}}")
+
+        define(nsp(tgt, n, 1)).where(
+            Boundary(tgt, n)
+        )
+
+        define(nsp(u, n, sum(v, n + 1, m).per(u, n))).where(
+            nsp(v, n + 1, m),
+            usp(u, n, v),
+            not_(Target(u))
+        )
+
+        define(nsp(u, n, 1 + sum(v, n + 1, m).per(u, n))).where(
+            nsp(v, n + 1, m),
+            usp(u, n, v),
+            Target(u),
+            not_(Boundary(u, n))
+        )
+
+    return nsp
+
+
+def compute_nsp(g: Graph, Source, Target, max_length = None):
+    # Computes the number of shortest paths (NSP) from a source set to a destination set
+
+    usp, Boundary  = compute_usp(g, Source, Target, max_length)
+    nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
+
+    return nsp

relationalai/experimental/paths/path_algorithms/usp-tuple.py

@@ -0,0 +1,183 @@
+# For builder components.
+from relationalai.semantics import Model, Integer, define, max, sum, select, not_
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+
+
+def compute_usp(g: Graph, Source, Target, max_length = None):
+    # Computes the Union of Shortest Paths (USP) from a source set to a destination set
+    # USP is a subgraph of the original graph
+
+    edge = g.Edge
+    Node = g.Node
+
+    n, d = Integer.ref(), Integer.ref()
+    tgt, u, v = Node.ref(), g.Node.ref(), g.Node.ref()
+
+    if max_length is None:
+        ball = ball_upto(g, Source, Target)
+        usp_nodes = g.model.Relationship(f"usp_nodes1 {{{Node}}}")
+        usp = g.model.Relationship(f"usp1 {{{Node}}} {{{Node}}}")
+        boundary = g.model.Relationship(f"boundary1 {{{Node}}}")
+
+        # propagate backwards to find the nodes that are in the USP:
+        define(boundary(tgt)).where(
+            Target(tgt),
+            ball(n, tgt)
+        )
+
+        define(usp_nodes(tgt)).where(
+            boundary(tgt)
+        )
+
+        define(usp_nodes(u)).where(
+            usp(u, v)
+        )
+
+        define(usp(u, v)).where(
+            usp_nodes(v),
+            ball(d, v),
+            ball(d - 1, u),
+            edge(u, v)
+        )
+    else:
+        ball = ball_with_repetition(g, Source, max_length)
+        max_dist = g.model.Relationship("max_dist1 {Integer}")
+        NodeDist = g.model.Concept("NodeDist")
+        usp = g.model.Relationship(f"usp2 {{{NodeDist}}} {{{NodeDist}}}")
+        boundary = g.model.Relationship(f"boundary2 {{{NodeDist}}}")
+
+        define(NodeDist.new(node = u, layer = n)).where(
+            ball(n, u)
+        )
+
+        define(max_dist(max(n))).where(
+            ball(n, tgt),
+            Target(tgt)
+        )
+
+        uu, vv, ww = NodeDist.ref(), NodeDist.ref(), NodeDist.ref()
+
+        define(boundary(uu)).where(
+            NodeDist(uu),
+            max_dist(n),
+            Target(tgt),
+            ball(n, tgt),
+            uu.node == tgt,
+            uu.layer == n
+        )
+
+        define(usp(uu, vv)).where(
+            boundary(vv),
+            NodeDist(uu),
+            vv.node == v,
+            vv.layer == n + 1,
+            uu.node == u,
+            uu.layer == n,
+            ball(n, u),
+            edge(u, v)
+        )
+
+        define(usp(uu, vv)).where(
+            usp(vv, ww),
+            vv.node == v,
+            vv.layer == n + 1,
+            uu.node == u,
+            uu.layer == n,
+            ball(n, u),
+            edge(u, v)
+        )
+
+
+    return usp, boundary
+
+
+
+
+def compute_nsp_from_usp(g: Graph, usp, Source, Target, Boundary):
+    Node = g.Node
+
+    n, m = Integer.ref(), Integer.ref()
+    tgt, u, v = Node.ref(), Node.ref(), Node.ref()
+
+    """if max_dist is None:
+        nsp = g.model.Relationship(f"nsp2 {{{Node}}} {{Integer}}")
+        define(nsp(tgt, 1)).where(
+            Target(tgt),
+            usp(u, tgt)
+        )
+
+        define(nsp(tgt, 1)).where(
+            Target(tgt),
+            Source(tgt)
+        )
+
+        define(nsp(u, sum(v, n).per(u))).where(
+            nsp(v, n),
+            usp(u, v)
+        )
+    else:
+    """
+    nsp = g.model.Relationship(f"nsp1 {{{Node}}} {{Integer}} {{Integer}}")
+
+    define(nsp(tgt, n, 1)).where(
+        Boundary(tgt, n)
+    )
+
+    define(nsp(u, n, sum(v, n + 1, m).per(u, n))).where(
+        nsp(v, n + 1, m),
+        usp(u, n, v),
+        not_(Target(u))
+    )
+
+    define(nsp(u, n, 1 + sum(v, n + 1, m).per(u, n))).where(
+        nsp(v, n + 1, m),
+        usp(u, n, v),
+        Target(u),
+        not_(Boundary(u, n))
+    )
+
+    return nsp
+
+
+def compute_nsp(g: Graph, Source, Target, max_length = None):
+    # Computes the number of shortest paths (NSP) from a source set to a destination set
+
+    if max_length is None:
+        usp, Boundary = compute_usp(g, Source, Target)
+        nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
+    else:
+        usp, Boundary  = compute_usp(g, Source, Target, max_length)
+        nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
+
+    return nsp
+
+
+model = Model("test_usp_nsp_single", dry_run=False)
+
+grid1 = Graph.construct_grid(model, 2, "undirected")
+
+source1 = grid1.Node.new(row = 1, col = 1)
+target1 = grid1.Node.new(row = 2, col = 2)
+
+Source1 = model.Concept("Source1", extends=[grid1.Node])
+Target1 = model.Concept("Target1", extends=[grid1.Node])
+
+define(Source1(source1))
+define(Target1(target1))
+define(Target1(source1))
+
+usp, boundary = compute_usp(grid1, Source1, Target1, 4)
+
+usp.inspect()
+#nsp = compute_nsp(grid1, Source1, Target1, 4)
+
+
+u, v = grid1.Node.ref(), grid1.Node.ref(),
+n, m = Integer.ref(), Integer.ref()
+
+select(u, v).where(usp(u, v)).inspect()
+
+
+# select(u.row, u.col, n, m).where(nsp(u, n, m)).inspect()

relationalai/experimental/paths/path_algorithms/usp.py

@@ -0,0 +1,150 @@
+# For builder components.
+from relationalai.semantics import Integer, define, sum, not_
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_upto import ball_upto
+from relationalai.experimental.paths.path_algorithms.one_sided_ball_repetition import ball_with_repetition
+
+
+def compute_usp(g: Graph, Source, Target, max_length=None):
+    # Computes the Union of Shortest Paths (USP) from a source set to a destination set
+    # USP is a subgraph of the original graph
+
+    edge = g.Edge
+    Node = g.Node
+
+    n, d = Integer.ref(), Integer.ref()
+    tgt, u, v = Node.ref(), g.Node.ref(), g.Node.ref()
+
+    ball = ball_upto(g, Source, Target, max_length)
+    usp_nodes = g.model.Relationship(f"usp_nodes {{{Node}}}")
+    usp = g.model.Relationship(f"usp {{{Node}}} {{{Node}}}")
+    boundary = g.model.Relationship(f"usp_boundary {{{Node}}}")
+
+    # propagate backwards to find the nodes that are in the USP:
+    define(boundary(tgt)).where(
+        Target(tgt),
+        ball(n, tgt)
+    )
+
+    define(usp_nodes(tgt)).where(
+        boundary(tgt)
+    )
+
+    define(usp_nodes(u)).where(
+        usp(u, v)
+    )
+
+    define(usp(u, v)).where(
+        usp_nodes(v),
+        ball(d, v),
+        ball(d - 1, u),
+        edge(u, v)
+    )
+
+    return usp, boundary
+
+
+def compute_uw(g: Graph, Source, Target, max_length):
+    # Computes the Union of Walks (UW) up to a given length from a source set to a destination set
+
+    edge = g.Edge
+    Node = g.Node
+
+    n = Integer.ref()
+    tgt, u, v, w = Node.ref(), g.Node.ref(), g.Node.ref(), g.Node.ref()
+
+    ball = ball_with_repetition(g, Source, max_length)
+    uw = g.model.Relationship(f"uw {{{Node}}} {{Integer}} {{{Node}}}")
+    boundary = g.model.Relationship(f"boundary {{{Node}}} {{Integer}}")
+
+    define(uw(u, n, tgt)).where(
+        Target(tgt),
+        ball(n + 1, tgt),
+        ball(n, u),
+        edge(u, tgt)
+    )
+
+    define(uw(u, n, v)).where(
+        uw(v, n + 1, w),
+        ball(n, u),
+        edge(u, v)
+    )
+
+    define(boundary(tgt, n)).where(
+        Target(tgt),
+        ball(n, tgt),
+        not_(uw(tgt, n, u))
+    )
+
+    return uw, boundary
+
+
+def compute_nsp_from_usp(g: Graph, usp, Source, Target, Boundary):
+    Node = g.Node
+
+    n = Integer.ref()
+    tgt, u, v = Node.ref(), Node.ref(), Node.ref()
+
+    nsp = g.model.Relationship(f"num_shortest {{{Node}}} {{Integer}}")
+
+    define(nsp(tgt, 1)).where(
+        Boundary(tgt)
+    )
+
+    define(nsp(tgt, 1)).where(
+        Target(tgt),
+        Source(tgt)
+    )
+
+    define(nsp(u, sum(v, n).per(u))).where(
+        nsp(v, n),
+        usp(u, v)
+    )
+
+    return nsp
+
+
+def compute_nw_from_uw(g: Graph, usp, Target, Boundary):
+    Node = g.Node
+
+    n, m = Integer.ref(), Integer.ref()
+    tgt, u, v = Node.ref(), Node.ref(), Node.ref()
+
+    nw = g.model.Relationship(f"num_walks {{{Node}}} {{Integer}} {{Integer}}")
+
+    define(nw(tgt, n, 1)).where(
+        Boundary(tgt, n)
+    )
+
+    define(nw(u, n, sum(v, n + 1, m).per(u, n))).where(
+        nw(v, n + 1, m),
+        usp(u, n, v),
+        not_(Target(u))
+    )
+
+    define(nw(u, n, 1 + sum(v, n + 1, m).per(u, n))).where(
+        nw(v, n + 1, m),
+        usp(u, n, v),
+        Target(u),
+        not_(Boundary(u, n))
+    )
+
+    return nw
+
+
+def compute_nsp(g: Graph, Source, Target):
+    # Computes the number of shortest paths (NSP) from a source set to a destination set
+
+    usp, Boundary  = compute_usp(g, Source, Target)
+    nsp = compute_nsp_from_usp(g, usp, Source, Target, Boundary)
+
+    return nsp
+
+
+def compute_nw(g: Graph, Source, Target, max_length):
+    # Computes the number of shortest paths (NSP) from a source set to a destination set
+
+    uw, Boundary  = compute_uw(g, Source, Target, max_length)
+    nw = compute_nw_from_uw(g, uw, Target, Boundary)
+
+    return nw

relationalai/experimental/paths/product_graph.py

@@ -0,0 +1,93 @@
+"""
+Product graph implementation for automaton-based path finding.
+"""
+
+from relationalai.semantics import Integer, where, define, Relationship, String
+
+from .graph import Graph
+
+
+def create_product_graph(graph, automaton):
+    """
+    Create a product graph based on an automaton specification.
+
+    Args:
+        model: The RelationalAI model
+        automaton_spec: List of automaton transitions (src_state, dst_state, label/filter)
+        node: Node concept from the original graph
+        edge: Edge relationship from the original graph
+
+    Returns:
+        Tuple of (ProductGraphNode, product_graph) representing the product graph concepts
+    """
+    model = graph.model
+    Node = graph.Node
+    Edge = graph.Edge
+
+    # Define product graph for path finding
+    ProductGraphNode = model.Concept("ProductNode")
+    ProductGraphEdge = model.Relationship(f"pg_edge {{{ProductGraphNode}}} {{{ProductGraphNode}}}")
+
+    ProductGraphNode.orig_node = Relationship(f"orig_node {{{ProductGraphNode}}} {{{Node}}}")
+    ProductGraphNode.state = Relationship(f"state {{{ProductGraphNode}}} {{Integer}}")
+    ProductGraphNode.identify_by(ProductGraphNode.state, ProductGraphNode.orig_node)
+
+    # NB: Modifying `automaton` object
+    # Add automaton transitions to the model
+    automaton.transition = model.Relationship("automaton {Integer} {Integer} {String}")
+
+    # Create references for use in rules
+    state1, state2 = Integer.ref(), Integer.ref()
+    node1, node2 = Node.ref(), Node.ref()
+
+    # Create a rule for each automaton transition:
+    for state1 in automaton.delta:  # delta is the dict containing automaton transitions
+        for state2 in automaton.delta[state1]:
+            for transition in automaton.delta[state1][state2]:
+                label = transition.get_label().label
+
+                define(automaton.transition(state1, state2, label))
+
+                source_filters = transition.src_filters
+
+                where(
+                    ProductGraphNode.state == state1,
+                    ProductGraphNode.orig_node == node1,
+                    Edge(node1, node2, label),
+                    *([f(node1) for f in source_filters])
+                    ).define(
+                        ProductGraphNode.new(state=state2, orig_node=node2),
+                        ProductGraphEdge(ProductGraphNode, ProductGraphNode.new(state=state2, orig_node=node2))
+                    )
+
+    return Graph(model, ProductGraphNode, ProductGraphEdge)
+
+
+def project_product_graph_paths_to_original_graph(product_graph, product_graph_paths, automaton):
+
+    model = product_graph.model
+    ProductGraphNode = product_graph.Node
+
+    # extract Node type of original graph:
+    Node = ProductGraphNode.orig_node._fields[1].type_str
+
+    # print("Node type in original graph:", Node)
+
+
+    # Project path down from product graph to original graph
+    projected_paths = model.Relationship(f"projected {{Integer}} {{Integer}} {{String}} {{{Node}}}")
+
+    k = Integer.ref()
+    product_graph_node2 = ProductGraphNode.ref()
+    label = String.ref()
+
+    i = Integer.ref()
+
+    define(projected_paths(i, 0, "", ProductGraphNode.orig_node)).where(product_graph_paths(i, 0, ProductGraphNode))
+    define(projected_paths(i, k, label, product_graph_node2.orig_node)).where(
+        product_graph_paths(i, k - 1, ProductGraphNode),
+        product_graph_paths(i, k, product_graph_node2),
+        automaton.transition(ProductGraphNode.state, product_graph_node2.state, label)
+    )
+
+    return projected_paths