spization 1.0.0__py3-none-any.whl

spization/__init__.py

@@ -0,0 +1,3 @@
+from spization import algorithms, modular_decomposition, objects, utils
+
+__all__ = ["algorithms", "objects", "utils", "modular_decomposition"]

spization/__internals/general/__init__.py

@@ -0,0 +1,53 @@
+from functools import reduce
+from itertools import chain
+from typing import Callable, Iterable
+
+
+def get_only[T](container: Iterable[T]) -> T:
+    c = list(container)
+    if len(c) != 1:
+        raise ValueError(f"Container must only have 1 item, has {len(c)}")
+    return c[0]
+
+
+def get_any[T](container: Iterable[T]) -> T:
+    return next(iter(container))
+
+
+def must[T](value: T | None) -> T:
+    if value is None:
+        raise ValueError("Used must() on a None value.")
+    return value
+
+
+def flatmap[T, U](
+    func: Callable[[T], Iterable[U]], iterable: Iterable[T]
+) -> Iterable[U]:
+    return chain.from_iterable(map(func, iterable))
+
+
+def are_all_equal[T](iterable: Iterable[T]) -> bool:
+    iterator = iter(iterable)
+    try:
+        first = next(iterator)
+    except StopIteration:
+        return True
+    return all(first == x for x in iterator)
+
+
+def are_all_disjoint[T](iterable: Iterable[set[T] | frozenset[T]]) -> bool:
+    sets = list(iterable)
+    if not sets:
+        return True
+    union = reduce(lambda x, y: x.union(y), sets)
+    return len(union) == sum(len(s) for s in sets)
+
+
+__all__ = [
+    "get_any",
+    "get_only",
+    "must",
+    "flatmap",
+    "are_all_equal",
+    "are_all_disjoint",
+]

spization/__internals/graph/__init__.py

@@ -0,0 +1,27 @@
+from .add_nodes_and_edges import add_edges, add_node, add_nodes
+from .longest_path_lengths_from_source import longest_path_lengths_from_source
+from .lowest_common_ancestor import lowest_common_ancestor
+from .properties import (
+    is_2_terminal_dag,
+    is_compatible_graph,
+    is_single_sourced,
+    is_transitively_closed_dag,
+)
+from .sinks import sinks
+from .sources import sources
+from .strata_sort import strata_sort
+
+__all__ = [
+    "longest_path_lengths_from_source",
+    "lowest_common_ancestor",
+    "is_2_terminal_dag",
+    "is_compatible_graph",
+    "is_single_sourced",
+    "is_transitively_closed_dag",
+    "sinks",
+    "sources",
+    "strata_sort",
+    "add_edges",
+    "add_node",
+    "add_nodes",
+]

spization/__internals/graph/add_nodes_and_edges.py

@@ -0,0 +1,20 @@
+from typing import Iterable
+
+from networkx import DiGraph
+
+from spization.objects import DiEdge, Node
+
+
+def add_node(g: DiGraph) -> Node:
+    n = max(g.nodes(), default=-1) + 1
+    g.add_node(n)
+    return n
+
+
+def add_nodes(g: DiGraph, n: int) -> list[Node]:
+    return [add_node(g) for _ in range(n)]
+
+
+def add_edges(g: DiGraph, edges: Iterable[DiEdge]) -> None:
+    for edge in edges:
+        g.add_edge(edge[0], edge[1])

spization/__internals/graph/longest_path_lengths_from_source.py

@@ -0,0 +1,39 @@
+import networkx as nx
+from multimethod import multimethod
+from networkx import DiGraph
+
+from spization.__internals.general import get_only
+from spization.objects import Node
+
+from .properties import is_single_sourced
+from .sources import sources
+
+
+@multimethod
+def longest_path_lengths_from_source(g: DiGraph) -> dict[Node, int]:
+    assert is_single_sourced(g)
+    dist: dict[Node, int] = dict.fromkeys(g.nodes, -1)
+    root: Node = get_only(sources(g))
+    dist[root] = 0
+    topo_order = nx.topological_sort(g)
+    for n in topo_order:
+        if n == root:
+            continue
+        dist[n] = 1 + max(dist[p] for p in g.predecessors(n))
+    return dist
+
+
+@multimethod
+def longest_path_lengths_from_source(
+    g: DiGraph, cost_map: dict[Node, int | float]
+) -> dict[Node, int | float]:
+    assert is_single_sourced(g)
+    dist: dict[Node, int | float] = dict.fromkeys(g.nodes, -1)
+    root: Node = get_only(sources(g))
+    dist[root] = cost_map[root]
+    topo_order = nx.topological_sort(g)
+    for n in topo_order:
+        if n == root:
+            continue
+        dist[n] = cost_map[n] + max(dist[p] for p in g.predecessors(n))
+    return dist

spization/__internals/graph/lowest_common_ancestor.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+import networkx as nx
+from networkx import DiGraph
+
+from spization.__internals.general import get_any
+from spization.objects import Node
+
+
+def lowest_common_ancestor(g: DiGraph, nodes: set[Node]) -> Optional[Node]:
+    assert all(n in g.nodes() for n in nodes)
+    lca: Optional[Node] = get_any(nodes)
+    for n in nodes:
+        lca = nx.lowest_common_ancestor(g, lca, n)
+        if lca is None:
+            return lca
+    return lca

spization/__internals/graph/properties.py

@@ -0,0 +1,34 @@
+import networkx as nx
+from networkx import DiGraph
+
+from spization.objects import Node
+
+from .sinks import sinks
+from .sources import sources
+
+
+def is_2_terminal_dag(g: DiGraph) -> bool:
+    if not nx.is_directed_acyclic_graph(g):
+        return False
+
+    return len(sources(g)) == 1 and len(sinks(g)) == 1
+
+
+def is_compatible_graph(g: DiGraph) -> bool:
+    return all(isinstance(node, Node) for node in g.nodes())
+
+
+def is_single_sourced(g: DiGraph) -> bool:
+    return len(sources(g)) == 1
+
+
+def is_transitively_closed(g: DiGraph) -> bool:
+    for node in g.nodes():
+        for descendant in nx.descendants(g, node):
+            if not g.has_edge(node, descendant):
+                return False
+    return True
+
+
+def is_transitively_closed_dag(g: DiGraph) -> bool:
+    return nx.is_directed_acyclic_graph(g) and is_transitively_closed(g)

spization/__internals/graph/sinks.py

@@ -0,0 +1,7 @@
+from networkx import DiGraph
+
+from spization.objects import Node
+
+
+def sinks(g: DiGraph) -> set[Node]:
+    return {node for node, out_degree in g.out_degree() if out_degree == 0}

spization/__internals/graph/sources.py

@@ -0,0 +1,7 @@
+from networkx import DiGraph
+
+from spization.objects import Node
+
+
+def sources(g: DiGraph) -> set[Node]:
+    return {node for node, in_degree in g.in_degree() if in_degree == 0}

spization/__internals/graph/strata_sort.py

@@ -0,0 +1,10 @@
+from networkx import DiGraph
+
+from spization.objects import Node
+
+from .longest_path_lengths_from_source import longest_path_lengths_from_source
+
+
+def strata_sort(g: DiGraph) -> list[Node]:
+    depth_map: dict[Node, int] = longest_path_lengths_from_source(g)
+    return sorted(depth_map.keys(), key=lambda node: depth_map[node])

spization/__internals/sp/__init__.py

@@ -0,0 +1,14 @@
+from .cbc_decomposition import (
+    BipartiteComponent,
+    CompleteBipartiteCompositeDecomposition,
+    cbc_decomposition,
+)
+from .inverse_line_graph import InverseLineGraphResult, inverse_line_graph
+
+__all__ = [
+    "inverse_line_graph",
+    "InverseLineGraphResult",
+    "cbc_decomposition",
+    "CompleteBipartiteCompositeDecomposition",
+    "BipartiteComponent",
+]

spization/__internals/sp/cbc_decomposition.py

@@ -0,0 +1,93 @@
+from collections import deque
+from dataclasses import dataclass
+from typing import Optional
+
+from networkx import DiGraph
+
+from spization.__internals.general import get_only
+from spization.__internals.graph import sinks, sources
+from spization.objects import DiEdge, Node
+
+
+@dataclass(frozen=True)
+class BipartiteComponent:
+    head_nodes: frozenset[Node]
+    tail_nodes: frozenset[Node]
+
+
+CompleteBipartiteCompositeDecomposition = set[BipartiteComponent]
+
+
+def is_complete_bipartite_digraph(g: DiGraph, head: frozenset[Node]) -> bool:
+    sinks = set(g.nodes) - head
+    for source in head:
+        for sink in sinks:
+            if not g.has_edge(source, sink):
+                return False
+    return True
+
+
+def cbc_decomposition(g: DiGraph) -> Optional[CompleteBipartiteCompositeDecomposition]:
+    edges_to_process = deque(sorted(g.edges()))
+
+    already_in_a_head: set[Node] = set()
+    already_in_a_tail: set[Node] = set()
+    already_processed: set[DiEdge] = set()
+    result: CompleteBipartiteCompositeDecomposition = set()
+
+    while edges_to_process:
+        e = edges_to_process.pop()
+        if e in already_processed:
+            continue
+
+        head = frozenset(g.predecessors(e[1]))
+        tail = frozenset(g.successors(e[0]))
+
+        if head & tail:
+            return None
+
+        from_head_to_tail = {(u, v) for u in head for v in tail if g.has_edge(u, v)}
+
+        subgraph = g.subgraph(head | tail)
+
+        if not is_complete_bipartite_digraph(subgraph, head):
+            return None
+
+        for u, v in subgraph.edges():
+            if (u, v) not in from_head_to_tail:
+                return None
+
+        out_edges = {(u, v) for u in head for v in g.successors(u)}
+        if out_edges != from_head_to_tail:
+            return None
+
+        in_edges = {(u, v) for v in tail for u in g.predecessors(v)}
+        if in_edges != from_head_to_tail:
+            return None
+
+        result.add(BipartiteComponent(head, tail))
+
+        already_processed |= from_head_to_tail
+        already_in_a_head.update(head)
+        already_in_a_tail.update(tail)
+
+    assert already_in_a_head == set(g.nodes) - sinks(g)
+    assert already_in_a_tail == set(g.nodes) - sources(g)
+
+    return result
+
+
+def get_component_containing_node_in_head(
+    cbc: CompleteBipartiteCompositeDecomposition, n: Node
+) -> Optional[BipartiteComponent]:
+    found: set[BipartiteComponent] = set(filter(lambda bc: n in bc.head_nodes, cbc))
+    assert len(found) <= 1
+    return get_only(found) if found else None
+
+
+def get_component_containing_node_in_tail(
+    cbc: CompleteBipartiteCompositeDecomposition, n: Node
+) -> Optional[BipartiteComponent]:
+    found: set[BipartiteComponent] = set(filter(lambda bc: n in bc.tail_nodes, cbc))
+    assert len(found) <= 1
+    return get_only(found) if found else None

spization/__internals/sp/inverse_line_graph.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from bidict import bidict
+from networkx import DiGraph, MultiDiGraph
+
+from spization.__internals.graph import add_node, sinks, sources
+from spization.__internals.sp.cbc_decomposition import (
+    BipartiteComponent,
+    cbc_decomposition,
+    get_component_containing_node_in_head,
+    get_component_containing_node_in_tail,
+)
+from spization.objects import MultiDiEdge, Node, SerialParallelDecomposition
+
+
+@dataclass
+class InverseLineGraphResult:
+    graph: MultiDiGraph
+    inverse_edge_to_line_node_map: bidict[MultiDiEdge, SerialParallelDecomposition]
+
+
+def inverse_line_graph(g: DiGraph) -> Optional[InverseLineGraphResult]:
+    cbc_decomp = cbc_decomposition(g)
+    if cbc_decomp is None:
+        return None
+
+    result_graph = MultiDiGraph()
+    alpha: Node = add_node(result_graph)
+    omega: Node = add_node(result_graph)
+
+    component_nodes = bidict(
+        {bi_comp: add_node(result_graph) for bi_comp in cbc_decomp}
+    )
+
+    def h(n: Node) -> BipartiteComponent:
+        cmp = get_component_containing_node_in_head(cbc_decomp, n)
+        assert cmp is not None
+        return cmp
+
+    def t(n: Node) -> BipartiteComponent:
+        cmp = get_component_containing_node_in_tail(cbc_decomp, n)
+        assert cmp is not None
+        return cmp
+
+    srcs = sources(g)
+    snks = sinks(g)
+
+    def src_for_node(v: Node) -> Node:
+        return alpha if v in srcs else component_nodes[t(v)]
+
+    def dst_for_node(v: Node) -> Node:
+        return omega if v in snks else component_nodes[h(v)]
+
+    inverse_edge_to_line_node: bidict[MultiDiEdge, SerialParallelDecomposition] = bidict()
+
+    for v in g.nodes:
+        src, dst = src_for_node(v), dst_for_node(v)
+        idx = result_graph.add_edge(src, dst)
+        edge: MultiDiEdge = (src, dst, idx)
+        inverse_edge_to_line_node[edge] = v
+
+    return InverseLineGraphResult(result_graph, inverse_edge_to_line_node)

spization/algorithms/__init__.py

@@ -0,0 +1,12 @@
+from .flexible_sync import flexible_sync
+from .naive_strata_sync import naive_strata_sync
+from .pure_node_dup import pure_node_dup, tree_pure_node_dup
+from .spanish_strata_sync import spanish_strata_sync
+
+__all__ = [
+    "naive_strata_sync",
+    "pure_node_dup",
+    "tree_pure_node_dup",
+    "spanish_strata_sync",
+    "flexible_sync",
+]

spization/algorithms/flexible_sync.py

@@ -0,0 +1,208 @@
+import networkx as nx
+from networkx import DiGraph
+
+from spization.__internals.general import get_only, must
+from spization.__internals.graph import (
+    is_compatible_graph,
+    is_single_sourced,
+    longest_path_lengths_from_source,
+    lowest_common_ancestor,
+    sources,
+)
+from spization.objects import (
+    Node,
+    NodeRole,
+    SerialParallelDecomposition,
+    get_initial_node_role_map,
+)
+from spization.utils import (
+    contract_out_nodes_of_role,
+    critical_path_cost,
+    dependencies_are_maintained,
+    get_critical_path_cost_map,
+    spg_to_sp,
+)
+
+
+def get_component(SP: DiGraph, nodes: set[Node]) -> set[Node]:
+    parents = set().union(*[SP.predecessors(node) for node in nodes])
+    children = set().union(*[nx.descendants(SP, p) for p in parents])
+    other_parents = set().union(*[SP.predecessors(c) for c in children])
+    return parents | children | other_parents
+
+
+def get_forest(
+    SP: DiGraph, handle: Node, component: set[Node], node_roles: dict[Node, NodeRole]
+) -> set[Node]:
+    subtrees = [
+        (set(nx.descendants(SP, node)) | {node}) for node in SP.successors(handle)
+    ]
+    subtrees = [subtree for subtree in subtrees if subtree & component]
+    forest = set().union(*subtrees) | {handle}
+    forest = {node for node in forest if node_roles[node] != NodeRole.SYNC}
+    return forest
+
+
+def get_up_and_down(
+    nodes: set[Node],
+    SP: DiGraph,
+    forest: set[Node],
+    cost_map: dict[Node, float],
+    node_roles: dict[Node, NodeRole],
+) -> tuple[set[Node], set[Node], set[Node], set[Node]]:
+    SP = contract_out_nodes_of_role(SP, NodeRole.SYNC, node_roles)
+
+    base_down = set(nodes)
+    base_up = set().union(*[nx.ancestors(SP, node) for node in nodes]) & forest
+    assignable_nodes = forest - (base_up | base_down)
+    critical_path_cost_map = get_critical_path_cost_map(SP.subgraph(forest), cost_map)
+
+    def get_partitions():
+        bipartitions = set()
+        bipartitions.add((frozenset(base_up), frozenset(base_down | assignable_nodes)))
+        for node in assignable_nodes:
+            reference_cost = critical_path_cost_map[node]
+            up = base_up | {
+                node
+                for node in assignable_nodes
+                if critical_path_cost_map[node] <= reference_cost
+            }
+            down = (base_down | assignable_nodes) - up
+            bipartitions.add((frozenset(up), frozenset(down)))
+        return bipartitions
+
+    bipartitions = get_partitions()
+
+    def is_valid_bipartition(up: set[Node], down: set[Node]) -> bool:
+        for node in nodes:
+            if node not in down:
+                return False
+
+        for node in SP.nodes():
+            if node in down:
+                if any(child in up for child in SP.successors(node)):
+                    return False
+                parents = SP.predecessors(node)
+                if any(p in forest and p not in up and p not in down for p in parents):
+                    return False
+        return True
+
+    valid_partitions = [
+        (up, down) for up, down in bipartitions if is_valid_bipartition(up, down)
+    ]
+
+    assert valid_partitions
+
+    def partition_cost(
+        partition: tuple[set[Node], set[Node]],
+    ) -> tuple[float, float, float]:
+        up, down = partition
+        up_cost = critical_path_cost(SP.subgraph(up), cost_map)
+        down_cost = critical_path_cost(SP.subgraph(down), cost_map)
+        return (up_cost + down_cost, down_cost, len(down))
+
+    best_up, best_down = min(valid_partitions, key=partition_cost)
+    up_subgraph = SP.subgraph(best_up)
+    up_frontier = {node for node in best_up if up_subgraph.out_degree(node) == 0}
+
+    down_subgraph = SP.subgraph(best_down)
+    down_frontier = {node for node in best_down if down_subgraph.in_degree(node) == 0}
+
+    return best_up, best_down, up_frontier, down_frontier
+
+
+def edges_to_remove(
+    SP: DiGraph, up: set[Node], down: set[Node], node_roles: dict[Node, NodeRole]
+) -> set[tuple[Node, Node]]:
+    to_remove = set()
+    for u in up:
+        for v in SP.successors(u):
+            if v in down:
+                to_remove.add((u, v))
+    for node in list(SP.nodes()):
+        if (
+            node_roles[node] == NodeRole.SYNC
+            and all(p in up for p in SP.predecessors(node))
+            and all(s in down for s in SP.successors(node))
+        ):
+            SP.remove_node(node)
+    return to_remove
+
+
+def edges_to_add(up: set[Node], down: set[Node], sync: Node) -> set[tuple[Node, Node]]:
+    to_add: set[tuple[Node, Node]] = set()
+    for u in up:
+        to_add.add((u, sync))
+    for d in down:
+        to_add.add((sync, d))
+    return to_add
+
+
+def get_next_nodes(SP: DiGraph, g: DiGraph, cost_map: dict[Node, float]) -> set[Node]:
+    sp_longest_paths = longest_path_lengths_from_source(SP, cost_map)
+
+    candidate_nodes: set[Node] = {
+        node
+        for node in g.nodes()
+        if node not in SP.nodes()
+        and all(parent in SP.nodes() for parent in g.predecessors(node))
+    }
+
+    assert candidate_nodes
+
+    critical_path_costs = {}
+    for node in candidate_nodes:
+        parent_costs = {sp_longest_paths[parent] for parent in g.predecessors(node)}
+        critical_path_costs[node] = cost_map[node] + max(parent_costs)
+
+    ref_node = min(
+        critical_path_costs.keys(),
+        key=lambda node: (critical_path_costs.get(node), node),
+    )
+
+    nodes = {ref_node}
+    for node in candidate_nodes:
+        if g.predecessors(node) == g.predecessors(ref_node):
+            nodes.add(node)
+    return nodes
+
+
+def flexible_sync(
+    g: DiGraph, cost_map: dict[Node, float]
+) -> SerialParallelDecomposition:
+    assert is_single_sourced(g) and is_compatible_graph(g)
+    g = nx.transitive_reduction(g)
+    node_roles = get_initial_node_role_map(g.nodes)
+    next_sync = max(g.nodes(), default=-1) + 1
+    SP = DiGraph()
+    cost_map = cost_map.copy()
+    root: Node = get_only(sources(g))
+    SP.add_node(root)
+    node = root
+    while not set(g.nodes).issubset(SP.nodes):
+        nodes = get_next_nodes(SP, g, cost_map)
+        SP.add_nodes_from(nodes)
+        for node in nodes:
+            SP.add_edges_from(g.in_edges(node))
+        SP = nx.transitive_reduction(
+            SP
+        )
+        component: set[Node] = get_component(SP, nodes)
+        handle = must(lowest_common_ancestor(SP, component))
+        forest: set[Node] = get_forest(SP, handle, component, node_roles)
+        up, down, up_frontier, down_frontier = get_up_and_down(
+            nodes, SP, forest, cost_map, node_roles
+        )
+
+        sync = next_sync
+        next_sync += 1
+        SP.add_node(sync)
+        node_roles[sync] = NodeRole.SYNC
+        cost_map[sync] = 0
+        SP.remove_edges_from(edges_to_remove(SP, up, down, node_roles))
+        SP.add_edges_from(edges_to_add(up_frontier, down_frontier, sync))
+    SP = contract_out_nodes_of_role(SP, NodeRole.SYNC, node_roles)
+    decomp = spg_to_sp(SP)
+    assert decomp is not None
+    assert dependencies_are_maintained(g, decomp)
+    return decomp

spization/algorithms/naive_strata_sync.py

@@ -0,0 +1,37 @@
+from collections import defaultdict
+
+from networkx import DiGraph
+
+from spization.__internals.graph import (
+    is_2_terminal_dag,
+    is_compatible_graph,
+    longest_path_lengths_from_source,
+)
+from spization.objects import (
+    Node,
+    SerialParallelDecomposition,
+)
+from spization.utils import (
+    normalize,
+    sp_parallel_composition,
+    sp_serial_composition,
+)
+
+
+def naive_strata_sync(g: DiGraph) -> SerialParallelDecomposition:
+    assert is_2_terminal_dag(g) and is_compatible_graph(g)
+
+    longest_path_lengths: dict[Node, int] = longest_path_lengths_from_source(g)
+
+    groups = defaultdict(list)
+    for node, length in longest_path_lengths.items():
+        groups[length].append(node)
+
+    sp: SerialParallelDecomposition = sp_serial_composition(
+        [
+            sp_parallel_composition(list(group))
+            for _, group in sorted(groups.items(), key=lambda t: t[0])
+        ]
+    )
+    sp = normalize(sp)
+    return sp