Documentation

TauCeti.Combinatorics.Network.VertexSplitting

Vertex splitting #

Splitting the vertices of a directed network turns constraints on vertices into constraints on arrows. Every vertex v is replaced by an entrance v⁻ = (v, false) and an exit v⁺ = (v, true) on the vertex type V × Bool. Every original arrow e from v to w is retained, with its identity, as an arrow from v⁺ to w⁻, and every vertex v, including an isolated vertex or one carrying loops, receives one split arrow from v⁻ to v⁺. There are no other arrows; in particular an original loop at v becomes an arrow from v⁺ to v⁻.

Since the only arrow leaving an entrance is its split arrow and every arrow entering an exit is a split arrow, a walk in the split network starting at an entrance alternates between split arrows and original arrows. Such walks are therefore exactly the lifts of walks in the original network: a walk from s to t lifts to a walk from s⁻ to t⁻, or to t⁺ when the split arrow of t is appended, and projection, which forgets the split arrows, inverts lifting. The lift of a path is a path, and conversely. A walk starting at an exit s⁺ is a lift with the split arrow of s removed from the front.

An assignment on the split network consists of an assignment on the original arrows together with a value on each split arrow. Its excess at v⁻ is the value entering v along original arrows minus the value on the split arrow of v, and its excess at v⁺ is the value on the split arrow minus the value leaving v along original arrows. Conservation at both copies of v therefore says that the value entering v, the value on its split arrow and the value leaving v all agree, and it implies conservation of the original assignment at v. Since original conservation alone does not determine the value on the split arrow, both copies are needed. Under a capacity c v on the split arrow of v, conservation at v⁻ bounds the total traffic through v by c v; this is how vertex capacities and vertex separators are reduced to arrow capacities and arrow cuts.

Main definitions #

Main results #

References #

@[reducible, inline]
abbrev TauCeti.SplitHom {V : Type u} (Q : V → V → Type v) :
V × Bool → V × Bool → Type v

The arrow family of the network obtained from Q by splitting every vertex v into an entrance (v, false) and an exit (v, true). The arrows from (v, true) to (w, false) are the original arrows of Q v w; there is exactly one arrow from (v, false) to (v, true), the split arrow of v; and there are no other arrows.

Instances For
    @[instance_reducible]
    instance TauCeti.SplitHom.instFintype {V : Type u} (Q : V → V → Type v) [DecidableEq V] [(v w : V) → Fintype (Q v w)] (x y : V × Bool) :
    def TauCeti.SplitHom.original {V : Type u} {Q : V → V → Type v} {v w : V} (e : Q v w) :

    An original arrow e : Q v w, as an arrow from the exit of v to the entrance of w.

    Instances For
      def TauCeti.SplitHom.split {V : Type u} {Q : V → V → Type v} (v : V) :

      The split arrow of v, from its entrance to its exit.

      Instances For
        theorem TauCeti.SplitHom.eq_split {V : Type u} {Q : V → V → Type v} {v : V} (e : SplitHom Q (v, false) (v, true)) :
        e = split v

        The only arrow from the entrance of v to its exit is the split arrow of v.

        theorem TauCeti.SplitHom.exists_original {V : Type u} {Q : V → V → Type v} {v w : V} (e : SplitHom Q (v, true) (w, false)) :
        ∃ (e' : Q v w), original e' = e

        Every arrow from the exit of v to the entrance of w is an original arrow.

        def TauCeti.SplitHom.toWalk {V : Type u} {Q : V → V → Type v} {x y : V × Bool} :
        SplitHom Q x y → ArrowWalk Q x.1 y.1

        The walk in Q traced by an arrow of the split network: an original arrow traces itself and a split arrow traces the walk of length zero.

        Instances For
          @[simp]
          theorem TauCeti.SplitHom.toWalk_original {V : Type u} {Q : V → V → Type v} {v w : V} (e : Q v w) :
          @[simp]
          theorem TauCeti.SplitHom.toWalk_split {V : Type u} {Q : V → V → Type v} (v : V) :
          def TauCeti.ArrowWalk.splitLift {V : Type u} {Q : V → V → Type v} {s t : V} (b : Bool) :

          The lift of a walk from s to t to the split network: it starts at the entrance of s, crosses the split arrow of every vertex it leaves, and ends at the entrance of t for b = false and, after crossing the split arrow of t, at the exit of t for b = true.

          Instances For
            @[simp]
            theorem TauCeti.ArrowWalk.splitLift_false_nil {V : Type u} {Q : V → V → Type v} (s : V) :
            @[simp]
            theorem TauCeti.ArrowWalk.splitLift_false_cons {V : Type u} {Q : V → V → Type v} {s t x : V} (p : ArrowWalk Q s t) (e : Q t x) :
            @[simp]
            theorem TauCeti.ArrowWalk.splitLift_true_nil {V : Type u} {Q : V → V → Type v} (s : V) :
            @[simp]
            theorem TauCeti.ArrowWalk.splitLift_true_cons {V : Type u} {Q : V → V → Type v} {s t x : V} (p : ArrowWalk Q s t) (e : Q t x) :
            theorem TauCeti.ArrowWalk.splitLift_true {V : Type u} {Q : V → V → Type v} {s t : V} (p : ArrowWalk Q s t) :

            The lift ending at the exit of t is the lift ending at its entrance followed by the split arrow of t.

            def TauCeti.ArrowWalk.splitProj {V : Type u} {Q : V → V → Type v} {x y : V × Bool} :
            ArrowWalk (SplitHom Q) x y → ArrowWalk Q x.1 y.1

            The projection of a walk in the split network to Q, which forgets its split arrows and keeps its original arrows.

            Instances For
              @[simp]
              theorem TauCeti.ArrowWalk.splitProj_nil {V : Type u} {Q : V → V → Type v} (x : V × Bool) :
              (nil x).splitProj = nil x.1
              @[simp]
              theorem TauCeti.ArrowWalk.splitProj_cons {V : Type u} {Q : V → V → Type v} {x y z : V × Bool} (p : ArrowWalk (SplitHom Q) x y) (e : SplitHom Q y z) :
              @[simp]
              theorem TauCeti.ArrowWalk.splitProj_splitLift {V : Type u} {Q : V → V → Type v} {s t : V} (b : Bool) (p : ArrowWalk Q s t) :

              Projection inverts lifting.

              @[simp]
              theorem TauCeti.ArrowWalk.splitLift_splitProj {V : Type u} {Q : V → V → Type v} {s : V} {y : V × Bool} (q : ArrowWalk (SplitHom Q) (s, false) y) :

              Every walk in the split network starting at an entrance is the lift of its projection.

              @[simp]
              theorem TauCeti.ArrowWalk.splitProj_comp {V : Type u} {Q : V → V → Type v} {x y z : V × Bool} (p : ArrowWalk (SplitHom Q) x y) (q : ArrowWalk (SplitHom Q) y z) :

              Projection takes composition of walks to composition.

              @[simp]
              theorem TauCeti.ArrowWalk.splitLift_comp {V : Type u} {Q : V → V → Type v} {s t x : V} (b : Bool) (p : ArrowWalk Q s t) (q : ArrowWalk Q t x) :

              The lift of a composite walk is the lift of the first walk, ending at an entrance, followed by the lift of the second.

              theorem TauCeti.ArrowWalk.splitLift_splitProj_of_exit {V : Type u} {Q : V → V → Type v} {s : V} {y : V × Bool} (q : ArrowWalk (SplitHom Q) (s, true) y) :

              A walk in the split network starting at the exit of s is the lift of its projection with the split arrow of s removed from the front.

              def TauCeti.ArrowWalk.splitEquiv {V : Type u} (Q : V → V → Type v) (s t : V) (b : Bool) :

              Lifting identifies the walks from s to t with the walks in the split network from the entrance of s to the entrance (b = false) or exit (b = true) of t; the inverse is projection.

              Instances For
                @[simp]
                theorem TauCeti.ArrowWalk.splitEquiv_apply {V : Type u} {Q : V → V → Type v} {s t : V} (b : Bool) (p : ArrowWalk Q s t) :
                (splitEquiv Q s t b) p = splitLift b p
                @[simp]
                theorem TauCeti.ArrowWalk.splitEquiv_symm_apply {V : Type u} {Q : V → V → Type v} {s t : V} (b : Bool) (q : ArrowWalk (SplitHom Q) (s, false) (t, b)) :
                (splitEquiv Q s t b).symm q = q.splitProj
                @[simp]
                theorem TauCeti.ArrowWalk.length_splitLift {V : Type u} {Q : V → V → Type v} {s t : V} (b : Bool) (p : ArrowWalk Q s t) :

                A walk with k arrows lifts to a walk with 2 * k arrows ending at an entrance, or 2 * k + 1 arrows ending at an exit.

                theorem TauCeti.ArrowWalk.vertices_splitLift_true {V : Type u} {Q : V → V → Type v} {s t : V} (p : ArrowWalk Q s t) :

                The vertices of the lift ending at an exit: each vertex v of the walk is replaced by its entrance and its exit.

                theorem TauCeti.ArrowWalk.vertices_splitLift_false_cons {V : Type u} {Q : V → V → Type v} {s t x : V} (p : ArrowWalk Q s t) (e : Q t x) :

                The vertices of the lift of a nonempty walk ending at an entrance: the vertices of the lift of its prefix ending at an exit, followed by the entrance of its last vertex.

                @[simp]
                theorem TauCeti.ArrowWalk.mem_vertices_splitLift_true {V : Type u} {Q : V → V → Type v} {s t : V} {p : ArrowWalk Q s t} {x : V × Bool} :

                A vertex of the split network lies on the lift of a walk ending at an exit exactly when its underlying vertex lies on the walk.

                @[simp]
                theorem TauCeti.ArrowWalk.isPath_splitLift {V : Type u} {Q : V → V → Type v} {s t : V} (b : Bool) (p : ArrowWalk Q s t) :

                Lifting preserves and reflects paths.

                @[simp]
                theorem TauCeti.ArrowWalk.isPath_splitProj {V : Type u} {Q : V → V → Type v} {s : V} {y : V × Bool} {q : ArrowWalk (SplitHom Q) (s, false) y} :

                A walk in the split network from the entrance of s is a path exactly when its projection is.

                theorem TauCeti.ArrowWalk.length_splitProj {V : Type u} {Q : V → V → Type v} {s : V} {y : V × Bool} (q : ArrowWalk (SplitHom Q) (s, false) y) :

                The length of a walk in the split network from the entrance of s is twice the length of its projection, plus one when it ends at an exit.

                The arrows traversed by the lift ending at an exit: the split arrow of s, followed, for each arrow of the walk, by that arrow and the split arrow of its target.

                theorem TauCeti.ArrowWalk.arrows_splitLift_false {V : Type u} {Q : V → V → Type v} {s t : V} (p : ArrowWalk Q s t) :

                The arrows traversed by the lift ending at an entrance: for each arrow of the walk, the split arrow of its source followed by that arrow.

                @[simp]
                theorem TauCeti.ArrowWalk.original_mem_arrows_splitLift {V : Type u} {Q : V → V → Type v} {s t v w : V} {b : Bool} {p : ArrowWalk Q s t} {e : Q v w} :

                The lift of a walk traverses an original arrow exactly when the walk traverses it.

                @[simp]

                The lift of a walk ending at an exit traverses the split arrow of v exactly when the walk visits v.

                @[simp]

                The lift of a walk ending at an entrance traverses the split arrow of v exactly when the walk visits v before its last vertex.

                Walks starting at an exit #

                def TauCeti.ArrowWalk.splitLiftExit {V : Type u} {Q : V → V → Type v} {s t x : V} (b : Bool) :
                ArrowWalk Q s t → Q t x → ArrowWalk (SplitHom Q) (s, true) (x, b)

                The lift of the nonempty walk p.cons e from s to x to a walk in the split network starting at the exit of s: the lift of p.cons e with the split arrow of s removed from the front. It ends at the entrance of x for b = false and at the exit of x for b = true.

                Instances For
                  @[simp]
                  theorem TauCeti.ArrowWalk.splitLiftExit_false_nil {V : Type u} {Q : V → V → Type v} {s x : V} (e : Q s x) :
                  @[simp]
                  theorem TauCeti.ArrowWalk.splitLiftExit_true_nil {V : Type u} {Q : V → V → Type v} {s x : V} (e : Q s x) :
                  @[simp]
                  theorem TauCeti.ArrowWalk.splitLiftExit_false_cons {V : Type u} {Q : V → V → Type v} {s t x y : V} (p : ArrowWalk Q s t) (e' : Q t x) (e : Q x y) :
                  @[simp]
                  theorem TauCeti.ArrowWalk.splitLiftExit_true_cons {V : Type u} {Q : V → V → Type v} {s t x y : V} (p : ArrowWalk Q s t) (e' : Q t x) (e : Q x y) :
                  theorem TauCeti.ArrowWalk.splitLift_cons_eq_comp_splitLiftExit {V : Type u} {Q : V → V → Type v} {s t x : V} (b : Bool) (p : ArrowWalk Q s t) (e : Q t x) :

                  The lift of a nonempty walk from the entrance of s is the split arrow of s followed by its lift from the exit of s.

                  @[simp]
                  theorem TauCeti.ArrowWalk.splitProj_splitLiftExit {V : Type u} {Q : V → V → Type v} {s t x : V} (b : Bool) (p : ArrowWalk Q s t) (e : Q t x) :

                  Projection inverts lifting from the exit.

                  theorem TauCeti.ArrowWalk.eq_splitLiftExit_of_splitProj_eq {V : Type u} {Q : V → V → Type v} {s t x : V} {b : Bool} {q : ArrowWalk (SplitHom Q) (s, true) (x, b)} {p : ArrowWalk Q s t} {e : Q t x} (h : q.splitProj = p.cons e) :

                  A walk in the split network from the exit of s whose projection is the nonempty walk p.cons e is the lift of p.cons e from the exit.

                  theorem TauCeti.ArrowWalk.isPath_splitProj_of_exit {V : Type u} {Q : V → V → Type v} {s : V} {y : V × Bool} {q : ArrowWalk (SplitHom Q) (s, true) y} :

                  A walk in the split network from the exit of s projects to a path exactly when it is a path that avoids the entrance of s.

                  theorem TauCeti.ArrowWalk.IsPath.splitLiftExit {V : Type u} {Q : V → V → Type v} {s t x : V} {p : ArrowWalk Q s t} {e : Q t x} (b : Bool) (h : (p.cons e).IsPath) :

                  The lift of a path from the exit is a path.

                  @[simp]
                  theorem TauCeti.ArrowWalk.length_splitLiftExit {V : Type u} {Q : V → V → Type v} {s t x : V} (b : Bool) (p : ArrowWalk Q s t) (e : Q t x) :
                  (splitLiftExit b p e).length = 2 * p.length + 1 + b.toNat

                  The lift from the exit of a walk p.cons e has 2 * p.length + 1 arrows when it ends at an entrance and 2 * p.length + 2 arrows when it ends at an exit.

                  theorem TauCeti.ArrowWalk.length_splitProj_of_exit {V : Type u} {Q : V → V → Type v} {s : V} {y : V × Bool} (q : ArrowWalk (SplitHom Q) (s, true) y) :

                  One more than the length of a walk in the split network from the exit of s is twice the length of its projection, plus one when the walk ends at an exit.

                  The arrows traversed by a walk in the split network from the exit of s to an exit: for each arrow of its projection, that arrow and the split arrow of its target.

                  The arrows traversed by a walk in the split network from the exit of s to an entrance, preceded by the split arrow of s: for each arrow of its projection, the split arrow of its source followed by that arrow.

                  @[simp]
                  theorem TauCeti.ArrowWalk.original_mem_arrows_of_exit {V : Type u} {Q : V → V → Type v} {s v w : V} {y : V × Bool} {q : ArrowWalk (SplitHom Q) (s, true) y} {e : Q v w} :

                  A walk in the split network from the exit of s traverses an original arrow exactly when its projection traverses it.

                  @[simp]

                  A walk in the split network from the exit of s to an exit traverses the split arrow of v exactly when its projection visits v after its first vertex.

                  @[simp]

                  A walk in the split network from the exit of s to an entrance traverses the split arrow of v exactly when its projection visits v strictly between its first and last vertices.

                  Assignments on the split network #

                  def TauCeti.SplitHom.assignment {V : Type u} {Q : V → V → Type v} {K : Type w} (f : Assignment Q K) (φ : V → K) :

                  The assignment on the split network with the value f e on each original arrow e and the value φ v on the split arrow of each vertex v. With capacities cap on the original arrows and c v on the split arrow of v, the split capacities are assignment cap c.

                  Instances For
                    @[simp]
                    theorem TauCeti.SplitHom.assignment_original {V : Type u} {Q : V → V → Type v} {K : Type w} (f : Assignment Q K) (φ : V → K) {v w : V} (e : Q v w) :
                    assignment f φ (original e) = f e
                    @[simp]
                    theorem TauCeti.SplitHom.assignment_split {V : Type u} {Q : V → V → Type v} {K : Type w} (f : Assignment Q K) (φ : V → K) (v : V) :
                    assignment f φ (split v) = φ v
                    def TauCeti.SplitHom.originalAssignment {V : Type u} {Q : V → V → Type v} {K : Type w} (g : Assignment (SplitHom Q) K) :

                    The values of an assignment on the split network on the original arrows.

                    Instances For
                      @[simp]
                      theorem TauCeti.SplitHom.originalAssignment_apply {V : Type u} {Q : V → V → Type v} {K : Type w} (g : Assignment (SplitHom Q) K) {v w : V} (e : Q v w) :
                      @[simp]
                      theorem TauCeti.SplitHom.originalAssignment_assignment {V : Type u} {Q : V → V → Type v} {K : Type w} (f : Assignment Q K) (φ : V → K) :
                      theorem TauCeti.SplitHom.assignment_originalAssignment {V : Type u} {Q : V → V → Type v} {K : Type w} (g : Assignment (SplitHom Q) K) :
                      (assignment (originalAssignment g) fun (v : V) => g (split v)) = g

                      Every assignment on the split network is determined by its values on the original arrows and on the split arrows.

                      theorem TauCeti.SplitHom.assignment_ext {V : Type u} {Q : V → V → Type v} {K : Type w} {g g' : Assignment (SplitHom Q) K} (h : originalAssignment g = originalAssignment g') (h' : ∀ (v : V), g (split v) = g' (split v)) :
                      g = g'

                      Two assignments on the split network are equal when they agree on the original arrows and on the split arrows.

                      @[simp]
                      theorem TauCeti.SplitHom.assignment_zero {V : Type u} {Q : V → V → Type v} {K : Type w} [Zero K] :
                      @[simp]
                      theorem TauCeti.SplitHom.assignment_add {V : Type u} {Q : V → V → Type v} {K : Type w} [Add K] (f f' : Assignment Q K) (φ φ' : V → K) :
                      assignment (f + f') (φ + φ') = assignment f φ + assignment f' φ'
                      @[simp]
                      theorem TauCeti.SplitHom.assignment_neg {V : Type u} {Q : V → V → Type v} {K : Type w} [Neg K] (f : Assignment Q K) (φ : V → K) :
                      assignment (-f) (-φ) = -assignment f φ
                      @[simp]
                      theorem TauCeti.SplitHom.assignment_sub {V : Type u} {Q : V → V → Type v} {K : Type w} [Sub K] (f f' : Assignment Q K) (φ φ' : V → K) :
                      assignment (f - f') (φ - φ') = assignment f φ - assignment f' φ'
                      @[simp]
                      theorem TauCeti.SplitHom.originalAssignment_zero {V : Type u} {Q : V → V → Type v} {K : Type w} [Zero K] :
                      @[simp]
                      theorem TauCeti.SplitHom.originalAssignment_add {V : Type u} {Q : V → V → Type v} {K : Type w} [Add K] (g g' : Assignment (SplitHom Q) K) :
                      @[simp]
                      theorem TauCeti.SplitHom.originalAssignment_neg {V : Type u} {Q : V → V → Type v} {K : Type w} [Neg K] (g : Assignment (SplitHom Q) K) :
                      @[simp]
                      theorem TauCeti.SplitHom.originalAssignment_sub {V : Type u} {Q : V → V → Type v} {K : Type w} [Sub K] (g g' : Assignment (SplitHom Q) K) :
                      @[simp]
                      theorem TauCeti.SplitHom.assignment_le_assignment_iff {V : Type u} {Q : V → V → Type v} {K : Type w} [LE K] {f f' : Assignment Q K} {φ φ' : V → K} :
                      assignment f φ ≤ assignment f' φ' ↔ f ≤ f' ∧ φ ≤ φ'

                      Split assignments are compared arrowwise on original arrows and vertexwise on split arrows.

                      def TauCeti.SplitHom.network {V : Type u} {Q : V → V → Type v} {K : Type w} [Zero K] [LE K] (cap : Assignment Q K) (hcap : ∀ {v w : V} (e : Q v w), 0 ≤ cap e) (c : V → K) (hc : ∀ (v : V), 0 ≤ c v) :

                      The split network: zero lower bounds, the capacity cap e on each original arrow e and the capacity c v on the split arrow of each vertex v. The body is exposed because the dependent arrow family occurs in the types of the projection lemmas below.

                      Instances For
                        @[simp]
                        theorem TauCeti.SplitHom.network_Hom {V : Type u} {Q : V → V → Type v} {K : Type w} [Zero K] [LE K] (cap : Assignment Q K) (hcap : ∀ {v w : V} (e : Q v w), 0 ≤ cap e) (c : V → K) (hc : ∀ (v : V), 0 ≤ c v) :
                        (network cap ⋯ c hc).Hom = SplitHom Q
                        @[simp]
                        theorem TauCeti.SplitHom.network_lower {V : Type u} {Q : V → V → Type v} {K : Type w} [Zero K] [LE K] (cap : Assignment Q K) (hcap : ∀ {v w : V} (e : Q v w), 0 ≤ cap e) (c : V → K) (hc : ∀ (v : V), 0 ≤ c v) {x y : V × Bool} (e : SplitHom Q x y) :
                        (network cap ⋯ c hc).lower e = 0
                        @[simp]
                        theorem TauCeti.SplitHom.network_upper {V : Type u} {Q : V → V → Type v} {K : Type w} [Zero K] [LE K] (cap : Assignment Q K) (hcap : ∀ {v w : V} (e : Q v w), 0 ≤ cap e) (c : V → K) (hc : ∀ (v : V), 0 ≤ c v) {x y : V × Bool} (e : SplitHom Q x y) :
                        (network cap ⋯ c hc).upper e = assignment cap c e
                        theorem TauCeti.SplitHom.excessAt_entrance {V : Type u} {Q : V → V → Type v} {K : Type w} [AddCommGroup K] [Fintype V] [DecidableEq V] (g : Assignment (SplitHom Q) K) (v : V) [(v w : V) → Fintype (Q v w)] :

                        The excess of a split assignment at the entrance (v, false) is the value entering v along original arrows minus the value on the split arrow of v.

                        theorem TauCeti.SplitHom.excessAt_exit {V : Type u} {Q : V → V → Type v} {K : Type w} [AddCommGroup K] [Fintype V] [DecidableEq V] (g : Assignment (SplitHom Q) K) (v : V) [(v w : V) → Fintype (Q v w)] :

                        The excess of a split assignment at the exit (v, true) is the value on the split arrow of v minus the value leaving v along original arrows.

                        theorem TauCeti.SplitHom.excessAt_originalAssignment {V : Type u} {Q : V → V → Type v} {K : Type w} [AddCommGroup K] [Fintype V] [DecidableEq V] (g : Assignment (SplitHom Q) K) (v : V) [(v w : V) → Fintype (Q v w)] :

                        The excess of the original part of a split assignment at v is the sum of its excesses at the entrance and at the exit of v.

                        A split assignment is conserved at both copies of v exactly when the value entering v along original arrows, the value on the split arrow of v and the value leaving v along original arrows agree.

                        theorem TauCeti.SplitHom.excessAt_originalAssignment_eq_zero {V : Type u} {Q : V → V → Type v} {K : Type w} [AddCommGroup K] [Fintype V] [DecidableEq V] [(v w : V) → Fintype (Q v w)] {g : Assignment (SplitHom Q) K} {v : V} (h₀ : excessAt g (v, false) = 0) (h₁ : excessAt g (v, true) = 0) :

                        Conservation of a split assignment at both copies of v implies conservation of its original part at v.

                        theorem TauCeti.SplitHom.arrowSum_originalAssignment_univ_singleton_le {V : Type u} {Q : V → V → Type v} {K : Type w} [AddCommGroup K] [Fintype V] [DecidableEq V] {g : Assignment (SplitHom Q) K} (v : V) [(v w : V) → Fintype (Q v w)] [LE K] {c : K} (hg : g (split v) ≤ c) (h : excessAt g (v, false) = 0) :

                        Vertex capacities. If a split assignment has value at most c on the split arrow of v and is conserved at the entrance of v, then the total value entering v along original arrows is at most c.

                        theorem TauCeti.SplitHom.arrowSum_originalAssignment_singleton_univ_le {V : Type u} {Q : V → V → Type v} {K : Type w} [AddCommGroup K] [Fintype V] [DecidableEq V] {g : Assignment (SplitHom Q) K} (v : V) [(v w : V) → Fintype (Q v w)] [LE K] {c : K} (hg : g (split v) ≤ c) (h : excessAt g (v, true) = 0) :

                        If a split assignment has value at most c on the split arrow of v and is conserved at the exit of v, then the total value leaving v along original arrows is at most c.

                        The vertices whose split arrows leave the vertex set S of the split network: those whose entrance lies in S and whose exit does not.

                        Instances For
                          @[simp]
                          theorem TauCeti.SplitHom.mem_cutVertices {V : Type u} [Fintype V] [DecidableEq V] (S : Finset (V × Bool)) {v : V} :
                          def TauCeti.SplitHom.cutArrows {V : Type u} (Q : V → V → Type v) [Fintype V] [DecidableEq V] (S : Finset (V × Bool)) [(v w : V) → Fintype (Q v w)] :
                          Finset ((v : V) × (w : V) × Q v w)

                          The original arrows leaving the vertex set S of the split network, each recorded with its endpoints: the arrows from a vertex whose exit lies in S to a vertex whose entrance does not.

                          Instances For
                            @[simp]
                            theorem TauCeti.SplitHom.mem_cutArrows {V : Type u} (Q : V → V → Type v) [Fintype V] [DecidableEq V] (S : Finset (V × Bool)) [(v w : V) → Fintype (Q v w)] {a : (v : V) × (w : V) × Q v w} :
                            theorem TauCeti.SplitHom.arrowSum_assignment_compl {V : Type u} {Q : V → V → Type v} {K : Type w} [Fintype V] [DecidableEq V] (S : Finset (V × Bool)) [(v w : V) → Fintype (Q v w)] [AddCommMonoid K] (f : Assignment Q K) (φ : V → K) :
                            arrowSum (assignment f φ) S Sᶜ = ∑ v ∈ cutVertices S, φ v + ∑ a ∈ cutArrows Q S, f a.snd.snd

                            Cuts of the split network. The total value of a split assignment on the arrows leaving a vertex set S is its value on the split arrows leaving S plus its value on the original arrows leaving S.