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

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

@@ -1,130 +0,0 @@
-# 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

@@ -1,183 +0,0 @@
-# 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

@@ -1,150 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-"""
-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