File size: 3,361 Bytes
a72760f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 | import Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected
import OAI.NumberTheory.Ostmann.Tree.PartitionMatching
namespace OAI
/-! # The bipartite overlap graph of an actual bulk permutation -/
namespace Ostmann
open scoped Classical
def arrangementGraph {L : Type*} (m : ℕ) (e : Equiv.Perm (L × Fin m)) :
SimpleGraph (L ⊕ L) where
Adj x y := match x, y with
| .inl a, .inr b => ∃ i j, e (a, i) = (b, j)
| .inr b, .inl a => ∃ i j, e (a, i) = (b, j)
| _, _ => False
symm := ⟨by intro x y; cases x <;> cases y <;> exact id⟩
loopless := ⟨by intro x; cases x <;> exact not_false⟩
noncomputable instance {L : Type*} [Fintype L] (m : ℕ)
(e : Equiv.Perm (L × Fin m)) : Fintype (arrangementGraph m e).ConnectedComponent :=
Fintype.ofFinite _
def arrangementLeft {L : Type*} {m : ℕ} (e : Equiv.Perm (L × Fin m))
(l : L) : (arrangementGraph m e).ConnectedComponent :=
(arrangementGraph m e).connectedComponentMk (.inl l)
def arrangementRight {L : Type*} {m : ℕ} (e : Equiv.Perm (L × Fin m))
(l : L) : (arrangementGraph m e).ConnectedComponent :=
(arrangementGraph m e).connectedComponentMk (.inr l)
theorem arrangement_components_match {L : Type*} {m : ℕ}
(e : Equiv.Perm (L × Fin m)) (x : L × Fin m) :
arrangementRight e (e x).1 = arrangementLeft e x.1 := by
apply Eq.symm
apply SimpleGraph.ConnectedComponent.connectedComponentMk_eq_of_adj
exact ⟨x.2, (e x).2, rfl⟩
def arrangementMatching {L : Type*} {m : ℕ}
(e : Equiv.Perm (L × Fin m)) :
PartitionMatching (fun x : L × Fin m => arrangementLeft e x.1)
(fun x : L × Fin m => arrangementRight e x.1) :=
⟨e, arrangement_components_match e⟩
theorem arrangementLeft_surjective {L : Type*} {m : ℕ} (hm : 0 < m)
(e : Equiv.Perm (L × Fin m)) : Function.Surjective (arrangementLeft e) := by
intro c
induction c using SimpleGraph.ConnectedComponent.ind with
| h v =>
cases v with
| inl l => exact ⟨l, rfl⟩
| inr l =>
let x := e.symm (l, ⟨0, hm⟩)
refine ⟨x.1, ?_⟩
have h := arrangement_components_match e x
simpa only [x, Equiv.apply_symm_apply, arrangementRight] using h.symm
theorem arrangementRight_surjective {L : Type*} {m : ℕ} (hm : 0 < m)
(e : Equiv.Perm (L × Fin m)) : Function.Surjective (arrangementRight e) := by
intro c
obtain ⟨l, rfl⟩ := arrangementLeft_surjective hm e c
exact ⟨(e (l, ⟨0, hm⟩)).1, arrangement_components_match e (l, ⟨0, hm⟩)⟩
/-- Counting the slots in a component from the two sides gives equal
leaf counts, because every leaf has exactly m slots. -/
theorem arrangement_component_balance {L : Type*} [Fintype L] {m : ℕ}
(hm : 0 < m) (e : Equiv.Perm (L × Fin m))
(c : (arrangementGraph m e).ConnectedComponent) :
Fintype.card {l : L // arrangementLeft e l = c} =
Fintype.card {l : L // arrangementRight e l = c} := by
have h := Fintype.card_congr ((arrangementMatching e).restrict c)
simp only [card_slotFiber] at h
exact Nat.eq_of_mul_eq_mul_right hm h
theorem arrangement_component_count_le {L : Type*} [Fintype L] {m : ℕ}
(hm : 0 < m) (e : Equiv.Perm (L × Fin m)) :
Fintype.card (arrangementGraph m e).ConnectedComponent ≤ Fintype.card L :=
Fintype.card_le_of_surjective _ (arrangementLeft_surjective hm e)
end Ostmann
end OAI
|