Dev.MonadicDependence.Subdivision
Definition
Let \(H\) be a (simple) graph and \(r \in \mathbb{N}\). The \(r\)-subdivision of \(H\), denoted \(H^{(r)}\), is the graph obtained from \(H\) by replacing every edge \(uv \in E(H)\) with a path \(u, x^{uv}_1, x^{uv}_2, \ldots, x^{uv}_r, v\), where the internal vertices \(x^{uv}_1, \ldots, x^{uv}_r\) are fresh and pairwise disjoint across edges. Equivalently, \(H^{(r)}\) has vertex set \(V(H) \,\cup\, \{x^e_i : e \in E(H), i \in [r]\}\) and edges forming the \(r+1\)-edge path along each original edge of \(H\). For \(r = 0\) we have \(H^{(0)} = H\).
The \(r\)-subdivided clique of order \(n\) is \((K_n)^{(r)}\). The \(r\)-subdivided biclique of order \(n\) is \((K_{n,n})^{(r)}\), where \(K_{n,n}\) denotes the biclique of order \(n\) (Definition Biclique). The vertices of \(V(H) \subseteq V(H^{(r)})\) are called the principal vertices of the subdivision; the fresh \(x^e_i\) are the subdivision vertices.
Let \(G\) be a graph. We say \(G\) contains \(H^{(r)}\) as a subgraph if there is an injection \(\iota\) from \(V(H^{(r)})\) to \(V(G)\) such that every edge of \(H^{(r)}\) maps to an edge of \(G\). We say \(G\) contains \(H^{(r)}\) as an induced subgraph if \(\iota\) can be chosen so that \(uv \in E(H^{(r)})\) if and only if \(\iota(u)\iota(v) \in E(G)\), for every pair of distinct \(u, v \in V(H^{(r)})\).
Review notes
The thesis uses \(r\)-subdivisions without explicit preliminaries. We fix the standard convention: subdividing an edge \(r\) times means inserting \(r\) fresh internal vertices, so the resulting path has length \(r+1\). In particular, \(H^{(0)} = H\) and \(H^{(1)}\) subdivides each edge once (a two-edge path per original edge). This matches Mählmann’s usage on p. 14, where a “star \(r\)-crossing of order \(n\)” is built from \(r\)-vertex paths between the bipartite roots — i.e. paths of length \(r + 1\).
We define “contains as subgraph” via an injection preserving edges (no constraint on non-edges), and “contains as induced subgraph” via an injection that preserves both edges and non-edges on its image. This is standard and matches the distinction Mählmann draws in the proof of Lemma 13.8 (p. 167), where he moves between “as a subgraph” and “as an induced subgraph”.
Open notational point. The thesis does not consistently name the principal vertices of a subdivision. We use “principal vertices” for the image of \(V(H) \subseteq V(H^{(r)})\) and “subdivision vertices” for the \(x^e_i\); this matches the star-\(r\)-crossing convention of “roots” vs. “path vertices” on p. 14 and the use of “principal vertices” in the proofs on pp. 167–168.
Lean scope cut: no abstract subdivide H r. In Lean,
we do not formalize the general \(r\)-subdivision of an arbitrary graph
\(H : \mathrm{SimpleGraph}\ V\). Only the two concrete instances
subdividedClique n r and subdividedBiclique n r are
provided. Reason: Mathlib’s SimpleGraph uses unordered edges
(Sym2 V), so defining \(H^{(r)}\) generically requires
orienting each edge before placing its \(r\) fresh path vertices —
doable but requires Classical.choice or a
LinearOrder V assumption, and contributes nothing to the
target scope (Mählmann uses \(H^{(r)}\) only for \(H = K_n\) and \(H =
K_{n,n}\)). The two concrete definitions side-step the orientation
question by hard-coding the Fin n-based ordering in the
vertex type.
Vertex-type shape. We use sum types rather than a discriminated dependent record:
SubdividedCliqueVert n r := Fin n ⊕ ({p : Fin n × Fin n // p.1 < p.2} × Fin r)SubdividedBicliqueVert n r := (Fin n ⊕ Fin n) ⊕ ((Fin n × Fin n) × Fin r)
Sum types compose cleanly with Lean’s pattern-matcher and give
decidable equality for free. The clique version uses the subtype
{p : Fin n × Fin n // p.1 < p.2} to index unordered edges
of \(K_n\); the biclique version indexes by Fin n × Fin n
directly (ordered pair of left/right sides), which matches \(K_{n, n}\)
having no diagonal.
Edge relation via SimpleGraph.fromRel.
SimpleGraph.fromRel takes a relation \(R : V \to V \to Prop\)
and builds the symmetric, irreflexive closure: adjacency is
\(x \neq y \land (R\ x\ y \lor R\ y\ x)\). We only populate the “forward”
direction of each edge pattern; the “backward” direction is
handled by fromRel’s symmetrization. The catch-all
| _, _ => False branch in the match handles all pairs
whose reverse is already covered by an earlier clause (e.g. (.inr, .inl) reverses to (.inl, .inr)).
Dev/MonadicDependence/Subdivision/Contract.lean (full)
| 1 | import Mathlib.Combinatorics.SimpleGraph.Basic |
| 2 | |
| 3 | namespace Dev.MonadicDependence.Subdivision |
| 4 | |
| 5 | /-- Vertex type of the `r`-subdivision of the complete graph `K_n`. |
| 6 | Either a principal vertex `.inl i` (with `i : Fin n`) or a subdivision |
| 7 | vertex `.inr (e, k)`, where `e : {p : Fin n × Fin n // p.1 < p.2}` |
| 8 | represents the edge `{e.1, e.2}` of `K_n` oriented by `<`, and |
| 9 | `k : Fin r` is its position along the path `e.1 ↝ e.2` (0-indexed). -/ |
| 10 | abbrev SubdividedCliqueVert (n r : ℕ) : Type := |
| 11 | Fin n ⊕ ({p : Fin n × Fin n // p.1 < p.2} × Fin r) |
| 12 | |
| 13 | /-- Vertex type of the `r`-subdivision of the biclique `K_{n,n}`. |
| 14 | Either a root (`.inl (.inl i)` = `aᵢ` or `.inl (.inr j)` = `bⱼ`) or a |
| 15 | subdivision vertex `.inr ((i, j), k)` = `π_{i,j,k+1}`, the `(k+1)`-st |
| 16 | interior vertex on the `a_i ↝ b_j` path (`k : Fin r`). -/ |
| 17 | abbrev SubdividedBicliqueVert (n r : ℕ) : Type := |
| 18 | (Fin n ⊕ Fin n) ⊕ ((Fin n × Fin n) × Fin r) |
| 19 | |
| 20 | /-- The `r`-subdivision of the complete graph on `Fin n`. Each edge |
| 21 | `{i, j}` of `K_n` (represented as the ordered pair `(i, j)` with `i < j`) |
| 22 | is replaced by a path of length `r + 1`: |
| 23 | `i — π₀ — π₁ — ⋯ — π_{r-1} — j`. For `r = 0` the graph equals `K_n` |
| 24 | (the subdivision-vertex component is indexed by `Fin 0 = ∅`, so it is |
| 25 | empty, and the principal-principal clause `r = 0` kicks in). |
| 26 | |
| 27 | `SimpleGraph.fromRel` adds the `x ≠ y` guard and symmetrizes by |
| 28 | disjunction, so the catch-all `False` branch accounts for pattern pairs |
| 29 | whose reverse is handled by an earlier clause. -/ |
| 30 | def subdividedClique (n r : ℕ) : SimpleGraph (SubdividedCliqueVert n r) := |
| 31 | SimpleGraph.fromRel fun x y => |
| 32 | match x, y with |
| 33 | | .inl _, .inl _ => r = 0 |
| 34 | | .inl i, .inr ⟨e, k⟩ => |
| 35 | (i = e.val.1 ∧ k.val = 0) ∨ (i = e.val.2 ∧ k.val = r - 1) |
| 36 | | .inr ⟨e, k⟩, .inr ⟨e', k'⟩ => e = e' ∧ k.val + 1 = k'.val |
| 37 | | _, _ => False |
| 38 | |
| 39 | /-- The `r`-subdivision of the biclique `K_{n,n}`. Each edge `a_i b_j` is |
| 40 | replaced by the `(r+1)`-edge path |
| 41 | `a_i — π_{i,j,1} — ⋯ — π_{i,j,r} — b_j`. For `r = 0` the graph equals |
| 42 | `K_{n,n}` (subdivision-vertex component empty; the root-root clauses |
| 43 | produce the biclique). |
| 44 | |
| 45 | Shares the vertex type with the star/clique/half-graph `r`-crossings |
| 46 | (`Dev.MonadicDependence.StarCrossing`, |
| 47 | `Dev.MonadicDependence.CliqueCrossing`, |
| 48 | `Dev.MonadicDependence.HalfGraphCrossing`), which augment this graph's |
| 49 | adjacency without changing its vertices. -/ |
| 50 | def subdividedBiclique (n r : ℕ) : SimpleGraph (SubdividedBicliqueVert n r) := |
| 51 | SimpleGraph.fromRel fun x y => |
| 52 | match x, y with |
| 53 | | .inl (.inl _), .inl (.inr _) => r = 0 |
| 54 | | .inl (.inl i), .inr ⟨⟨a, _⟩, k⟩ => i = a ∧ k.val = 0 |
| 55 | | .inl (.inr j), .inr ⟨⟨_, b⟩, k⟩ => j = b ∧ k.val = r - 1 |
| 56 | | .inr ⟨e, k⟩, .inr ⟨e', k'⟩ => e = e' ∧ k.val + 1 = k'.val |
| 57 | | _, _ => False |
| 58 | |
| 59 | end Dev.MonadicDependence.Subdivision |
| 60 |