| 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 |
|
|
