Partitioned graphs

Project.toml

@@ -9,9 +9,11 @@ Dictionaries = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 GraphsFlows = "06909019-6f44-4949-96fc-b9d9aaa02889"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SimpleTraits = "699a6c99-e7fa-54fc-8d76-47d257e15c1d"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SplitApplyCombine = "03a91e81-4c3e-53e1-a0a4-9c0c8f19dd66"
+Suppressor = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
 SymRCM = "286e6d88-80af-4590-acc9-0001b223b9bd"
 
 [compat]
@@ -24,6 +26,8 @@ SimpleTraits = "0.9"
 SparseArrays = "1.7"
 SplitApplyCombine = "1.2.2"
 SymRCM = "0.2.1"
+Suppressor = "0.2"
+Requires = "1.3"
 julia = "1.7"
 
 [extras]

examples/partitioning.jl

@@ -0,0 +1,16 @@
+using NamedGraphs
+using KaHyPar
+using Metis
+
+g = named_grid((4, 4))
+npartitions = 4
+
+pg_kahypar = PartitionedGraph(g; npartitions, backend="KaHyPar")
+pg_metis = PartitionedGraph(g; npartitions, backend="Metis")
+
+@show length(vertices(pg_kahypar.partitioned_graph)) ==
+  length(vertices(pg_metis.partitioned_graph)) ==
+  npartitions
+
+@show typeof(pg_kahypar) <: PartitionedGraph
+@show typeof(pg_metis) <: PartitionedGraph

src/Graphs/partitionedgraphs/abstractpartitionedge.jl

@@ -0,0 +1,7 @@
+abstract type AbstractPartitionEdge{V} <: AbstractNamedEdge{V} end
+
+parent(pe::AbstractPartitionEdge) = not_implemented()
+src(pe::AbstractPartitionEdge) = not_implemented()
+dst(pe::AbstractPartitionEdge) = not_implemented()
+
+#Don't have the vertices wrapped. But wrap them with source and edge.

src/Graphs/partitionedgraphs/abstractpartitionedgraph.jl

@@ -0,0 +1,168 @@
+abstract type AbstractPartitionedGraph{V,PV} <: AbstractNamedGraph{V} end
+
+#Needed for interface
+partitioned_graph(pg::AbstractPartitionedGraph) = not_implemented()
+graph(pg::AbstractPartitionedGraph) = not_implemented()
+function vertices(pg::AbstractPartitionedGraph, partition_vertex::AbstractPartitionVertex)
+  return not_implemented()
+end
+which_partition(pg::AbstractPartitionedGraph, vertex) = not_implemented()
+copy(pg::AbstractPartitionedGraph) = not_implemented()
+delete_from_vertex_map!(pg::AbstractPartitionedGraph, vertex) = not_implemented()
+insert_to_vertex_map!(pg::AbstractPartitionedGraph, vertex) = not_implemented()
+partition_edge(pg::AbstractPartitionedGraph, edge::AbstractEdge) = not_implemented()
+function edges(pg::AbstractPartitionedGraph, partition_edge::AbstractPartitionEdge)
+  return not_implemented()
+end
+
+vertices(pg::AbstractPartitionedGraph) = vertices(graph(pg))
+parent_graph(pg::AbstractPartitionedGraph) = parent_graph(graph(pg))
+function vertex_to_parent_vertex(pg::AbstractPartitionedGraph, vertex)
+  return vertex_to_parent_vertex(graph(pg), vertex)
+end
+edgetype(pg::AbstractPartitionedGraph) = edgetype(graph(pg))
+function parent_graph_type(G::Type{<:AbstractPartitionedGraph})
+  return fieldtype(fieldtype(G, :graph), :parent_graph)
+end
+directed_graph(G::Type{<:AbstractPartitionedGraph}) = directed_graph(fieldtype(G, :graph))
+function undirected_graph(G::Type{<:AbstractPartitionedGraph})
+  return unddirected_graph(fieldtype(G, :graph))
+end
+function has_vertex(pg::AbstractPartitionedGraph, partition_vertex::AbstractPartitionVertex)
+  return has_vertex(partitioned_graph(pg), parent(partition_vertex))
+end
+function has_edge(pg::AbstractPartitionedGraph, edge::AbstractPartitionEdge)
+  return has_edge(partitioned_graph(pg), parent(partition_edge))
+end
+
+function is_boundary_edge(pg::AbstractPartitionedGraph, edge::AbstractEdge)
+  p_edge = partition_edge(pg, edge)
+  return src(p_edge) == dst(p_edge)
+end
+
+function add_edge!(pg::AbstractPartitionedGraph, edge::AbstractEdge)
+  add_edge!(graph(pg), edge)
+  pg_edge = parent(partition_edge(pg, edge))
+  if src(pg_edge) != dst(pg_edge)
+    add_edge!(partitioned_graph(pg), pg_edge)
+  end
+end
+
+function rem_edge!(pg::AbstractPartitionedGraph, edge::AbstractEdge)
+  pg_edge = partition_edge(pg, edge)
+  if has_edge(partitioned_graph(pg), pg_edge)
+    g_edges = edges(pg, pg_edge)
+    if length(g_edges) == 1
+      rem_edge!(partitioned_graph(pg), pg_edge)
+    end
+  end
+
+  return rem_edge!(graph(pg), edge)
+end
+
+function rem_edge!(pg::AbstractPartitionedGraph, partition_edge::AbstractPartitionEdge)
+  return rem_edges!(pg, edges(pg, parent(partition_edge)))
+end
+
+function rem_edge(pg::AbstractPartitionedGraph, partition_edge::AbstractPartitionEdge)
+  pg_new = copy(pg)
+  rem_partition_edge!(pg_new, partition_edge)
+  return pg_new
+end
+
+function rem_partition_edges!(
+  pg::AbstractPartitionedGraph, partition_edges::Vector{AbstractPartitionEdge}
+)
+  for pe in partition_edges
+    rem_edge!(pg, pe)
+  end
+end
+
+function rem_partition_edges(
+  pg::AbstractPartitionedGraph, partition_edges::Vector{AbstractPartitionEdge}
+)
+  pg_new = copy(pg)
+  rem_partition_edges!(pg_new, partition_edges)
+  return pg_new
+end
+
+#Vertex addition and removal. I think it's important not to allow addition of a vertex without specification of PV
+function add_vertex!(
+  pg::AbstractPartitionedGraph, vertex, partition_vertex::AbstractPartitionVertex
+)
+  add_vertex!(graph(pg), vertex)
+  add_vertex!(partitioned_graph(pg), parent(partition_vertex))
+
+  return insert_to_vertex_map!(pg, vertex, partition_vertex)
+end
+
+function add_vertices!(
+  pg::AbstractPartitionedGraph,
+  vertices::Vector,
+  partition_vertices::Vector{V} where {V<:AbstractPartitionVertex},
+)
+  @assert length(vertices) == length(partition_vertices)
+  for (v, pv) in zip(vertices, partition_vertices)
+    add_vertex!(pg, v, pv)
+  end
+end
+
+function add_vertices!(
+  pg::AbstractPartitionedGraph, vertices::Vector, partition_vertex::AbstractPartitionVertex
+)
+  return add_vertices!(pg, vertices, fill(partition_vertex, length(vertices)))
+end
+
+function rem_vertex!(pg::AbstractPartitionedGraph, vertex)
+  rem_vertex!(graph(pg), vertex)
+  pv = which_partition(pg, vertex)
+  if length(vertices(pg, pv)) == 1
+    rem_vertex!(partitioned_graph(pg), parent(pv))
+  end
+  return delete_from_vertex_map!(pg, vertex)
+end
+
+function rem_vertex!(
+  pg::AbstractPartitionedGraph, partition_vertex::AbstractPartitionVertex
+)
+  return rem_vertices!(pg, vertices(pg, partition_vertex))
+end
+
+function rem_vertex(pg::AbstractPartitionedGraph, partition_vertex::AbstractPartitionVertex)
+  pg_new = copy(pg)
+  rem_vertex!(pg_new, partition_vertex)
+  return pg_new
+end
+
+function rem_vertices!(
+  pg::AbstractPartitionedGraph, partition_vertices::Vector{AbstractPartitionVertex}
+)
+  for pv in partition_vertices
+    rem_vertex!(pg, pv)
+  end
+end
+
+function rem_vertices(
+  pg::AbstractPartitionedGraph, partition_vertices::Vector{AbstractPartitionVertex}
+)
+  pg_new = copy(rem_partition_vertex)
+  rem_vertices!(pg_new, partition_vertices)
+  return pg_new
+end
+
+function add_vertex!(pg::AbstractPartitionedGraph, vertex)
+  return error("Need to specify a partition where the new vertex will go.")
+end
+
+function (pg1::AbstractPartitionedGraph == pg2::AbstractPartitionedGraph)
+  if fieldnames(typeof(pg1)) != fieldnames(typeof(pg1))
+    return false
+  end
+
+  for field in fieldnames(typeof(pg1))
+    if getfield(pg1, field) != getfield(pg2, field)
+      return false
+    end
+  end
+  return true
+end

src/Graphs/partitionedgraphs/abstractpartitionvertex.jl

@@ -0,0 +1,4 @@
+abstract type AbstractPartitionVertex{V} <: Any where {V} end
+
+#Parent, wrap, unwrap, vertex?
+parent(pv::AbstractPartitionVertex) = not_implemented()

src/Graphs/partitionedgraphs/partitionedge.jl

@@ -0,0 +1,8 @@
+struct PartitionEdge{V,E<:AbstractEdge{V}} <: AbstractPartitionEdge{V}
+  edge::E
+end
+
+parent(pe::PartitionEdge) = getfield(pe, :edge)
+src(pe::PartitionEdge) = PartitionVertex(src(parent(pe)))
+dst(pe::PartitionEdge) = PartitionVertex(dst(parent(pe)))
+PartitionEdge(p::Pair) = PartitionEdge(NamedEdge(p.first => p.second))

src/Graphs/partitionedgraphs/partitionedgraph.jl

@@ -0,0 +1,167 @@
+struct PartitionedGraph{V,PV,G<:AbstractNamedGraph{V},PG<:AbstractNamedGraph{PV}} <:
+       AbstractPartitionedGraph{V,PV}
+  graph::G
+  partitioned_graph::PG
+  partitioned_vertices::Dictionary{PV,Vector{V}}
+  which_partition::Dictionary{V,PV}
+end
+
+##Constructors.
+function PartitionedGraph{V,PV,G,PG}(
+  g::AbstractNamedGraph{V}, partitioned_vertices::Dictionary{PV,Vector{V}}
+) where {V,PV,G<:AbstractNamedGraph{V},PG<:AbstractNamedGraph{PV}}
+  pvs = keys(partitioned_vertices)
+  pg = NamedGraph(pvs)
+  which_partition = Dictionary{V,PV}()
+  for v in vertices(g)
+    v_pvs = Set(findall(pv -> v ∈ partitioned_vertices[pv], pvs))
+    @assert length(v_pvs) == 1
+    insert!(which_partition, v, first(v_pvs))
+  end
+
+  for e in edges(g)
+    pv_src, pv_dst = which_partition[src(e)], which_partition[dst(e)]
+    pe = NamedEdge(pv_src => pv_dst)
+    if pv_src != pv_dst && !has_edge(pg, pe)
+      add_edge!(pg, pe)
+    end
+  end
+
+  return PartitionedGraph(g, pg, partitioned_vertices, which_partition)
+end
+
+function PartitionedGraph(
+  g::AbstractNamedGraph{V}, partitioned_vertices::Dictionary{PV,Vector{V}}
+) where {V,PV}
+  return PartitionedGraph{V,PV,NamedGraph{V},NamedGraph{PV}}(g, partitioned_vertices)
+end
+
+function PartitionedGraph{V,Int64,G,NamedGraph{Int64}}(
+  g::AbstractNamedGraph{V}, partitioned_vertices::Vector{Vector{V}}
+) where {V,G<:NamedGraph{V}}
+  partitioned_vertices_dict = Dictionary{Int64,Vector{V}}(
+    [i for i in 1:length(partitioned_vertices)], partitioned_vertices
+  )
+  return PartitionedGraph{V,Int64,NamedGraph{V},NamedGraph{Int64}}(
+    g, partitioned_vertices_dict
+  )
+end
+
+function PartitionedGraph(
+  g::AbstractNamedGraph{V}, partition_vertices::Vector{Vector{V}}
+) where {V}
+  return PartitionedGraph{V,Int64,NamedGraph{V},NamedGraph{Int64}}(g, partition_vertices)
+end
+
+function PartitionedGraph{V,V,G,G}(vertices::Vector{V}) where {V,G<:NamedGraph{V}}
+  return PartitionedGraph(NamedGraph{V}(vertices), [[v] for v in vertices])
+end
+
+function PartitionedGraph(vertices::Vector{V}) where {V}
+  return PartitionedGraph{V,V,NamedGraph{V},NamedGraph{V}}(vertices)
+end
+
+function PartitionedGraph(
+  g::AbstractNamedGraph{V};
+  npartitions=nothing,
+  nvertices_per_partition=nothing,
+  backend=current_partitioning_backend(),
+  kwargs...,
+) where {V}
+  partitioned_vertices = partition_vertices(
+    g; npartitions, nvertices_per_partition, backend, kwargs...
+  )
+  return PartitionedGraph(g, partitioned_vertices)
+end
+
+#Needed for interface
+partitioned_graph(pg::PartitionedGraph) = getfield(pg, :partitioned_graph)
+graph(pg::PartitionedGraph) = getfield(pg, :graph)
+partitioned_vertices(pg::PartitionedGraph) = getfield(pg, :partitioned_vertices)
+which_partition(pg::PartitionedGraph) = getfield(pg, :which_partition)
+function vertices(pg::PartitionedGraph, partition_vert::PartitionVertex)
+  return partitioned_vertices(pg)[parent(partition_vert)]
+end
+function vertices(
+  pg::PartitionedGraph, partition_verts::Vector{V}
+) where {V<:PartitionVertex}
+  return unique(reduce(vcat, [vertices(pg, pv) for pv in partition_verts]))
+end
+function which_partition(pg::PartitionedGraph, vertex)
+  return PartitionVertex(which_partition(pg)[vertex])
+end
+
+function partition_edge(pg::PartitionedGraph, edge::AbstractEdge)
+  return PartitionEdge(
+    parent(which_partition(pg, src(edge))) => parent(which_partition(pg, dst(edge)))
+  )
+end
+
+function partition_edges(pg::PartitionedGraph, partition_edge::PartitionEdge)
+  psrc_vs, pdst_vs = vertices(pg, PartitionVertex(src(partition_edge))),
+  vertices(pg, PartitionVertex(dst(partition_edge)))
+  psrc_subgraph, pdst_subgraph, full_subgraph = subgraph(graph(pg), psrc_vs),
+  subgraph(pg, pdst_vs),
+  subgraph(pg, vcat(psrc_vs, pdst_vs))
+
+  return setdiff(
+    NamedGraphs.edges(full_subgraph),
+    vcat(NamedGraphs.edges(psrc_subgraph), NamedGraphs.edges(pdst_subgraph)),
+  )
+end
+
+#Copy on dictionaries is dodgy?!
+function copy(pg::PartitionedGraph)
+  return PartitionedGraph(
+    copy(graph(pg)),
+    copy(partitioned_graph(pg)),
+    copy_keys_values(partitioned_vertices(pg)),
+    copy_keys_values(which_partition(pg)),
+  )
+end
+
+function insert_to_vertex_map!(
+  pg::PartitionedGraph, vertex, partition_vertex::PartitionVertex
+)
+  pv = parent(partition_vertex)
+  if pv ∉ keys(partitioned_vertices(pg))
+    insert!(partitioned_vertices(pg), pv, [vertex])
+  else
+    pg.partitioned_vertices[pv] = unique(vcat(vertices(pg, partition_vertex), [vertex]))
+  end
+
+  return insert!(NamedGraphs.which_partition(pg), vertex, pv)
+end
+
+function delete_from_vertex_map!(pg::PartitionedGraph, vertex)
+  pv = which_partition(pg, vertex)
+  vs = vertices(pg, pv)
+  delete!(partitioned_vertices(pg), parent(pv))
+  if length(vs) != 1
+    insert!(partitioned_vertices(pg), parent(pv), setdiff(vs, [vertex]))
+  end
+  return delete!(pg.which_partition, vertex)
+end
+
+### PartitionedGraph Specific Functions
+function induced_subgraph(pg::PartitionedGraph, vertices::Vector)
+  sub_pg_graph, _ = induced_subgraph(graph(pg), vertices)
+  sub_partitioned_vertices = copy_keys_values(partitioned_vertices(pg))
+  for pv in NamedGraphs.vertices(partitioned_graph(pg))
+    vs = intersect(vertices, sub_partitioned_vertices[pv])
+    if !isempty(vs)
+      sub_partitioned_vertices[pv] = vs
+    else
+      delete!(sub_partitioned_vertices, pv)
+    end
+  end
+
+  return PartitionedGraph(sub_pg_graph, sub_partitioned_vertices), nothing
+end
+
+### PartitionedGraph Specific Functions
+function induced_subgraph(
+  pg::PartitionedGraph, partition_verts::Vector{V}
+) where {V<:PartitionVertex}
+  return induced_subgraph(pg, vertices(pg, partition_verts))
+end