| import OAI.RingTheory.DirectFiniteness.BalanceCoarsening |
|
|
| namespace OAI |
|
|
| universe u_1 u_2 u_3 u_4 u_5 u_6 |
|
|
| noncomputable section |
| open scoped Classical |
| open scoped BigOperators |
| open Equiv Equiv.Perm |
| namespace KaplanskyCounterexample.Planar |
| open Equiv Equiv.Perm |
| variable {α : Type u_1} {β : Type u_2} {V : Type u_3} {F : Type u_4} {A : Type u_5} {B : Type u_6} [Fintype α] [AddCommGroup A] [AddCommGroup B] |
|
|
| lemma label_sameCycle (p : Perm α) (f : α → β) (hf : ∀ a, f (p a) = f a) |
| {x y : α} (hxy : p.SameCycle x y) : f x = f y := |
| setoid_sameCycle_of_step (Setoid.ker f) p (fun x => (hf x).symm) hxy |
|
|
| lemma label_unplug (p : Perm α) (f : α → β) (hf : ∀ a, f (p a) = f a) (a x : α) : |
| f (unplug p a x) = f x := |
| (label_sameCycle p f hf (unplug_sameCycle p a ((SameCycle.refl _ x).apply_right))).symm |
|
|
| lemma sameCycle_unplug_iff_of_ne (p : Perm α) (a : α) {x y : α} |
| (hx : x ≠ a) (hy : y ≠ a) : (unplug p a).SameCycle x y ↔ p.SameCycle x y := by |
| by_cases ha : p a = a |
| · simp only [unplug, ha, swap_self] |
| rfl |
| · exact unplug_sameCycle_iff p a ha hx hy |
|
|
| lemma cycleSet_unplug (p : Perm α) (a x : α) (hx : x ≠ a) : |
| cycleSet (unplug p a) (cycleClass (unplug p a) x) = |
| (cycleSet p (cycleClass p x)).erase a := by |
| classical |
| ext y |
| rw [mem_cycleSet, cycleClass_eq, Finset.mem_erase, mem_cycleSet, cycleClass_eq] |
| constructor |
| · intro hy |
| refine ⟨?_, unplug_sameCycle p a hy⟩ |
| intro hya |
| subst y |
| exact hx (hy.symm.eq_of_right (unplug_fixed p a)) |
| · rintro ⟨hya, hy⟩ |
| exact (sameCycle_unplug_iff_of_ne p a hya hx).mpr hy |
|
|
| omit [Fintype α] in |
| lemma sum_erase_of_zero (s : Finset α) (a : α) (f : α → A) (ha : f a = 0) : |
| ∑ x ∈ s.erase a, f x = ∑ x ∈ s, f x := by |
| classical |
| apply Finset.sum_subset (Finset.erase_subset _ _) |
| intro x hx hxa |
| have : x = a := by simpa [hx] using hxa |
| simpa [this] using ha |
|
|
| lemma sum_cycle_unplug (p : Perm α) (a x : α) (hx : x ≠ a) |
| (f : α → A) (ha : f a = 0) : |
| ∑ y ∈ cycleSet (unplug p a) (cycleClass (unplug p a) x), f y = |
| ∑ y ∈ cycleSet p (cycleClass p x), f y := by |
| rw [cycleSet_unplug p a x hx] |
| exact sum_erase_of_zero _ a f ha |
|
|
| variable {R : Ribbon α} {Inc : V → F → Prop} {ι : V → F → (A →+ B)} |
|
|
| lemma WeakBalanced.exists_exception_nonzero (D : WeakBalanced R Inc ι) : |
| ∃ e ∈ cycleSet R.white D.exception, D.weight e ≠ 0 := by |
| classical |
| by_contra! h |
| exact D.exceptional_sum (Finset.sum_eq_zero h) |
|
|
| / |
| def WeakBalanced.detach (D : WeakBalanced R Inc ι) (a : α) (ha : D.weight a = 0) : |
| WeakBalanced (R.detach a) Inc ι := by |
| classical |
| let e := D.exists_exception_nonzero.choose |
| have he := D.exists_exception_nonzero.choose_spec.1 |
| have hwe := D.exists_exception_nonzero.choose_spec.2 |
| have hea : e ≠ a := by rintro rfl; exact hwe ha |
| have hec := (mem_cycleSet R.white D.exception e).mp he |
| refine { |
| blackLabel := D.blackLabel |
| whiteLabel := D.whiteLabel |
| blackLabel_rot := label_unplug R.black D.blackLabel D.blackLabel_rot a |
| whiteLabel_rot := label_unplug R.white D.whiteLabel D.whiteLabel_rot a |
| incident := D.incident |
| weight := D.weight |
| exception := cycleClass (unplug R.white a) e |
| black_sum := ?_ |
| white_sum := ?_ |
| exceptional_sum := ?_ } |
| · dsimp only [Ribbon.detach] |
| intro c |
| induction c using Quotient.inductionOn with |
| | h x => |
| change (∑ y ∈ cycleSet (unplug R.black a) (cycleClass (unplug R.black a) x), |
| ι (D.blackLabel y) (D.whiteLabel y) (D.weight y)) = 0 |
| by_cases hx : x = a |
| · subst x |
| rw [cycleSet_singleton_of_fixed _ _ (unplug_fixed R.black a)] |
| simp [ha] |
| · rw [sum_cycle_unplug R.black a x hx |
| (fun y => ι (D.blackLabel y) (D.whiteLabel y) (D.weight y)) (by simp [ha])] |
| exact D.black_sum _ |
| · dsimp only [Ribbon.detach] |
| intro c hc |
| induction c using Quotient.inductionOn with |
| | h x => |
| change (∑ y ∈ cycleSet (unplug R.white a) (cycleClass (unplug R.white a) x), |
| D.weight y) = 0 |
| by_cases hx : x = a |
| · subst x |
| rw [cycleSet_singleton_of_fixed _ _ (unplug_fixed R.white a)] |
| simpa using ha |
| · rw [sum_cycle_unplug R.white a x hx _ ha] |
| apply D.white_sum |
| intro hxc |
| apply hc |
| apply (cycleClass_eq _ _ _).mpr |
| apply (sameCycle_unplug_iff_of_ne R.white a hx hea).mpr |
| exact (cycleClass_eq _ _ _).mp (hxc.trans hec.symm) |
| · dsimp only [Ribbon.detach] |
| rw [sum_cycle_unplug R.white a e hea _ ha, hec] |
| exact D.exceptional_sum |
|
|
| end KaplanskyCounterexample.Planar |
| end |
|
|
| end OAI |
|
|
