Fix bipartite update

Author: Keno

src/bipartite_graph.jl

@@ -516,117 +516,4 @@ end
 Graphs.has_edge(g::DiCMOBiGraph{true}, a, b) = a in inneighbors(g, b)
 Graphs.has_edge(g::DiCMOBiGraph{false}, a, b) = b in outneighbors(g, a)
 
-"""
-    struct ResidualCMOGraph
-
-For a bipartite graph and matching on the graph's destination vertices, this
-wrapper exposes the induced graph on the destination vertices formed by those
-destination and source vertices that are left unmatched. In particular, two
-(destination) vertices a and b are neighbors if they are both unassigned and
-there is some unassigned source vertex `s` such that `s` is a neighbor (in the
-bipartite graph) of both `a` and `b`.
-
-# Hypergraph interpreation
-
-Refer to the hypergraph interpretation of the DiCMOBiGraph. Now consider the
-hypergraph left over after removing all edges that are oriented by the mapping.
-This graph is the undirected graph obtained by replacing all hyper edges by the
-maximal undirected graph on the vertices that are members of the original hyper
-edge.
-
-# Nota Bene
-
-1. For technical reasons, the `vertices` function includes even those vertices
-   vertices that are assigned in the original hypergraph, even though they
-   are conceptually not part of the graph.
-2. This graph is not strict. In particular, multi edges between vertices are
-   allowed and common.
-"""
-struct ResidualCMOGraph{I, G<:BipartiteGraph{I}, M <: Matching} <: Graphs.AbstractGraph{I}
-    graph::G
-    matching::M
-    function ResidualCMOGraph{I, G, M}(g::G, m::M) where {I, G<:BipartiteGraph{I}, M}
-        require_complete(g)
-        require_complete(m)
-        new{I, G, M}(g, m)
-    end
-end
-ResidualCMOGraph(g::G, m::M) where {I, G<:BipartiteGraph{I}, M} = ResidualCMOGraph{I, G, M}(g, m)
-
-invview(rcg::ResidualCMOGraph) = ResidualCMOGraph(invview(rcg.graph), invview(rcg.matching))
-
-Graphs.is_directed(::Type{<:ResidualCMOGraph}) = false
-Graphs.nv(rcg::ResidualCMOGraph) = ndsts(rcg.graph)
-Graphs.vertices(rcg::ResidualCMOGraph) = 𝑑vertices(rcg.graph)
-function Graphs.neighbors(rcg::ResidualCMOGraph, v::Integer)
-    rcg.matching[v] !== unassigned && return ()
-    Iterators.filter(
-        vdst->rcg.matching[vdst] === unassigned,
-        Iterators.flatten(rcg.graph.fadjlist[vsrc] for
-            vsrc in rcg.graph.badjlist[v] if
-            invview(rcg.matching)[vsrc] === unassigned))
-end
-
-# TODO: Fix the function in Graphs to do this instead
-function Graphs.neighborhood(rcg::ResidualCMOGraph, v::Integer)
-    worklist = Int[v]
-    ns = BitSet()
-    while !isempty(worklist)
-        v′ = popfirst!(worklist)
-        for n in neighbors(rcg, v′)
-            if !(n in ns)
-                push!(ns, n)
-                push!(worklist, n)
-            end
-        end
-    end
-    return ns
-end
-
-"""
-    struct InducedCondensationGraph
-
-For some bipartite-graph and an orientation induced on its destination contraction,
-records the condensation DAG of the digraph formed by the orientation. I.e. this
-is a DAG of connected components formed by the destination vertices of some
-underlying bipartite graph.
-
-N.B.: This graph does not store explicit neighbor relations of the sccs.
-Therefor, the edge multiplicity is derived from the underlying bipartite graph,
-i.e. this graph is not strict.
-"""
-struct InducedCondensationGraph{G <: BipartiteGraph} <: AbstractGraph{Vector{Union{Int, Vector{Int}}}}
-    graph::G
-    # Records the members of a strongly connected component. For efficiency,
-    # trivial sccs (with one vertex member) are stored inline. Note: the sccs
-    # here are stored in topological order.
-    sccs::Vector{Union{Int, Vector{Int}}}
-    # Maps the vertices back to the scc of which they are a part
-    scc_assignment::Vector{Int}
-end
-
-function InducedCondensationGraph(g::BipartiteGraph, sccs::Vector{Union{Int, Vector{Int}}})
-    scc_assignment = Vector{Int}(undef, ndsts(g))
-    for (i, c) in enumerate(sccs)
-        for v in c
-            scc_assignment[v] = i
-        end
-    end
-    InducedCondensationGraph(g, sccs, scc_assignment)
-end
-
-Graphs.is_directed(::Type{<:InducedCondensationGraph}) = true
-Graphs.nv(icg::InducedCondensationGraph) = length(icg.sccs)
-Graphs.vertices(icg::InducedCondensationGraph) = icg.sccs
-
-_neighbors(icg::InducedCondensationGraph, cc::Integer) =
-    Iterators.flatten(Iterators.flatten(rcg.graph.fadjlist[vsrc] for vsrc in rcg.graph.badjlist[v]) for v in icg.sccs[cc])
-
-Graphs.outneighbors(rcg::InducedCondensationGraph, v::Integer) =
-    (scc_assignment[n] for n in _neighbors(rcg, v) if scc_assignment[n] > v)
-
-Graphs.inneighbors(rcg::InducedCondensationGraph, v::Integer) =
-    (scc_assignment[n] for n in _neighbors(rcg, v) if scc_assignment[n] < v)
-
-
 end # module

src/structural_transformation/tearing.jl

@@ -31,21 +31,11 @@ function contract_variables(graph::BipartiteGraph, var_eq_matching::Matching, el
     masked_cumsum!(var_rename)
     masked_cumsum!(eq_rename)
 
-    rg = ResidualCMOGraph(graph, var_eq_matching)
+    dig = DiCMOBiGraph{true}(graph, var_eq_matching)
 
     # Update bipartite graph
-    var_deps = Union{Vector{Int}, Nothing}[nothing for v in eliminated_variables]
-    var_idxs = Dict(v => i for (i,v) in enumerate(eliminated_variables))
-    for (i, v) in enumerate(eliminated_variables)
-        isa(var_deps[i], Vector{Int}) && continue
-        var_deps[i] = deps = Vector{Int}()
-        for v′ in neighborhood(rg, v)
-            if var_rename[v′] != 0
-                push!(deps, var_rename[v′])
-            else
-                var_deps[var_idxs[v′]] = deps
-            end
-        end
+    var_deps = map(1:ndsts(graph)) do v
+        [var_rename[v′] for v′ in neighborhood(dig, v, Inf; dir=:in) if var_rename[v′] != 0]
     end
 
     new_fadjlist = Vector{Int}[
@@ -54,7 +44,7 @@ function contract_variables(graph::BipartiteGraph, var_eq_matching::Matching, el
                 if var_rename[v] != 0
                     push!(new_list, var_rename[v])
                 else
-                    append!(new_list, var_deps[var_idxs[v]])
+                    append!(new_list, var_deps[v])
                 end
             end
             new_list