| import OAI.RingTheory.DirectFiniteness.BalanceDetachment |
|
|
| namespace OAI |
|
|
| universe u_1 u_2 u_3 u_4 u_5 |
|
|
| noncomputable section |
| open scoped Classical |
| open scoped BigOperators |
| open Equiv Equiv.Perm |
| namespace KaplanskyCounterexample.Planar |
| open Equiv Equiv.Perm |
| variable {α : Type u_1} {V : Type u_2} {F : Type u_3} {A : Type u_4} {B : Type u_5} [Fintype α] [AddCommGroup A] [AddCommGroup B] |
|
|
| /-- The inclusion of the cycles of an invariant subset. -/ |
| def cycleSubtypeMap (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x) : |
| Cycles (p.subtypePerm hP) → Cycles p := |
| Quotient.map Subtype.val (fun _ _ h => (sameCycle_subtypePerm (h := hP)).mp h) |
|
|
| omit [Fintype α] in |
| lemma cycleSubtypeMap_injective (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x) : |
| Function.Injective (cycleSubtypeMap p P hP) := by |
| intro c d |
| induction c using Quotient.inductionOn with |
| | h x => |
| induction d using Quotient.inductionOn with |
| | h y => |
| intro h |
| exact Quotient.sound ((sameCycle_subtypePerm (h := hP)).mpr (Quotient.exact h)) |
|
|
| lemma sum_cycle_subtype (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x) |
| (c : Cycles (p.subtypePerm hP)) (f : α → A) : |
| ∑ a ∈ cycleSet (p.subtypePerm hP) c, f a.val = |
| ∑ a ∈ cycleSet p (cycleSubtypeMap p P hP c), f a := by |
| classical |
| induction c using Quotient.inductionOn with |
| | h x => |
| apply Finset.sum_bij (fun y _ => y.val) |
| · intro y hy |
| apply (mem_cycleSet _ _ _).mpr |
| exact Quotient.sound ((sameCycle_subtypePerm (h := hP)).mp |
| (Quotient.exact ((mem_cycleSet _ _ _).mp hy))) |
| · intro y _ z _ h |
| exact Subtype.ext h |
| · intro y hy |
| have hcycle : p.SameCycle y x.val := (cycleClass_eq _ _ _).mp ((mem_cycleSet _ _ _).mp hy) |
| have hPy : P y := (perm_invariant_cycle p P hP hcycle).mpr x.property |
| refine ⟨⟨y, hPy⟩, ?_, rfl⟩ |
| apply (mem_cycleSet _ _ _).mpr |
| exact Quotient.sound ((sameCycle_subtypePerm (h := hP)).mpr hcycle) |
| · intro _ _ |
| rfl |
|
|
| variable {R : Ribbon α} {Inc : V → F → Prop} {ι : V → F → (A →+ B)} |
|
|
| /-- Discard components not containing the exception. -/ |
| def WeakBalanced.restrict (D : WeakBalanced R Inc ι) (P : α → Prop) |
| (hb : ∀ x, P (R.black x) ↔ P x) (hw : ∀ x, P (R.white x) ↔ P x) |
| (e : α) (he : cycleClass R.white e = D.exception) (hPe : P e) : |
| WeakBalanced (R.restrict P hb hw) Inc ι where |
| blackLabel a := D.blackLabel a.val |
| whiteLabel a := D.whiteLabel a.val |
| blackLabel_rot a := D.blackLabel_rot a.val |
| whiteLabel_rot a := D.whiteLabel_rot a.val |
| incident a := D.incident a.val |
| weight a := D.weight a.val |
| exception := cycleClass (R.white.subtypePerm hw) ⟨e, hPe⟩ |
| black_sum c := by |
| dsimp only [Ribbon.restrict] at c ⊢ |
| rw [sum_cycle_subtype R.black P hb c |
| (fun x => ι (D.blackLabel x) (D.whiteLabel x) (D.weight x))] |
| exact D.black_sum _ |
| white_sum c hc := by |
| dsimp only [Ribbon.restrict] at c hc ⊢ |
| rw [sum_cycle_subtype] |
| apply D.white_sum |
| intro h |
| apply hc |
| apply cycleSubtypeMap_injective R.white P hw |
| exact h.trans he.symm |
| exceptional_sum := by |
| change (∑ a ∈ cycleSet (R.white.subtypePerm hw) |
| (cycleClass (R.white.subtypePerm hw) ⟨e, hPe⟩), D.weight a.val) ≠ 0 |
| rw [sum_cycle_subtype] |
| change (∑ a ∈ cycleSet R.white (cycleClass R.white e), D.weight a) ≠ 0 |
| rw [he] |
| exact D.exceptional_sum |
|
|
| end KaplanskyCounterexample.Planar |
| end |
|
|
| end OAI |
|
|
