| import OAI.Combinatorics.MatchingPSD.SimultaneousSmoothing |
|
|
| namespace OAI |
|
|
| universe u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8 u_9 u_10 |
|
|
| namespace MatchingSmoothing |
| namespace Pairing |
| variable {A : Type u_1} {B : Type u_2} {C : Type u_3} |
|
|
| def transport (e : A ≃ B) (M : Pairing A) : Pairing B := |
| ⟨e.symm.trans (M.1.trans e), by |
| constructor |
| · intro b |
| simp |
| · intro b hb |
| apply M.partner_ne (e.symm b) |
| simpa using congrArg e.symm hb⟩ |
|
|
| @[simp] lemma transport_apply (e : A ≃ B) (M : Pairing A) (b : B) : |
| (transport e M).1 b = e (M.1 (e.symm b)) := rfl |
|
|
| @[simp] lemma transport_refl (M : Pairing A) : transport (Equiv.refl A) M = M := by |
| ext a |
| rfl |
|
|
| @[simp] lemma transport_trans (e : A ≃ B) (f : B ≃ C) (M : Pairing A) : |
| transport (e.trans f) M = transport f (transport e M) := by |
| ext c |
| rfl |
|
|
| @[simp] lemma transport_symm (e : A ≃ B) (M : Pairing A) : |
| transport e.symm (transport e M) = M := by |
| ext a |
| simp |
|
|
| def transportEquiv (e : A ≃ B) : Pairing A ≃ Pairing B where |
| toFun := transport e |
| invFun := transport e.symm |
| left_inv := transport_symm e |
| right_inv := transport_symm e.symm |
|
|
| lemma transport_perm (p : Equiv.Perm A) (M : Pairing A) : transport p M = relabel p M := rfl |
|
|
| def sum (M : Pairing A) (N : Pairing B) : Pairing (A ⊕ B) := |
| ⟨Equiv.sumCongr M.1 N.1, by |
| constructor |
| · intro v |
| cases v <;> simp |
| · intro v hv |
| cases v with |
| | inl a => exact M.partner_ne a (Sum.inl.inj hv) |
| | inr b => exact N.partner_ne b (Sum.inr.inj hv)⟩ |
|
|
| @[simp] lemma sum_inl (M : Pairing A) (N : Pairing B) (a : A) : |
| (sum M N).1 (.inl a) = .inl (M.1 a) := rfl |
| @[simp] lemma sum_inr (M : Pairing A) (N : Pairing B) (b : B) : |
| (sum M N).1 (.inr b) = .inr (N.1 b) := rfl |
|
|
| lemma sum_relabel_left (p : Equiv.Perm A) (M : Pairing A) (N : Pairing B) : |
| sum (relabel p M) N = relabel (Equiv.sumCongr p (Equiv.refl B)) (sum M N) := by |
| ext v |
| cases v <;> rfl |
|
|
| lemma transport_relabel (e : A ≃ B) (p : Equiv.Perm A) (M : Pairing A) : |
| transport e (relabel p M) = relabel (e.symm.trans (p.trans e)) (transport e M) := by |
| ext b |
| simp only [transport_apply, relabel_apply, Equiv.Perm.inv_def, |
| Equiv.symm_trans_apply, Equiv.trans_apply, Equiv.symm_symm, |
| Equiv.symm_apply_apply] |
|
|
| def cellwise {I : Type u_4} (M : I → Pairing A) : Pairing (I × A) := |
| ⟨{ toFun := fun v => (v.1,(M v.1).1 v.2) |
| invFun := fun v => (v.1,(M v.1).1 v.2) |
| left_inv := by intro v; simp |
| right_inv := by intro v; simp }, by |
| constructor |
| · intro v; simp |
| · intro v hv |
| exact (M v.1).partner_ne v.2 (congrArg Prod.snd hv)⟩ |
|
|
| @[simp] lemma cellwise_apply {I : Type u_5} (M : I → Pairing A) (i : I) (a : A) : |
| (cellwise M).1 (i,a) = (i,(M i).1 a) := rfl |
|
|
| end Pairing |
|
|
| section Coordinates |
| variable {A : Type u_6} {B : Type u_7} {C : Type u_8} [Fintype A] [Fintype B] |
| attribute [local instance] Classical.propDecidable |
|
|
| lemma tableCoordinate_transport (e : A ≃ B) (z : B → C) (c : C × C) (M : Pairing A) : |
| tableCoordinate z c (Pairing.transport e M) = tableCoordinate (z ∘ e) c M := by |
| unfold tableCoordinate |
| rw [← e.sum_comp (fun b => if z b = c.1 ∧ z ((Pairing.transport e M).1 b) = c.2 then (1:ℝ) else 0)] |
| simp only [Pairing.transport_apply, Equiv.symm_apply_apply, Function.comp_apply] |
|
|
| lemma tableCoordinate_sum (z : A → C) (w : B → C) (c : C × C) |
| (M : Pairing A) (N : Pairing B) : |
| tableCoordinate (Sum.elim z w) c (Pairing.sum M N) = |
| tableCoordinate z c M + tableCoordinate w c N := by |
| simp only [tableCoordinate, Fintype.sum_sum_type, Pairing.sum_inl, Pairing.sum_inr, |
| Sum.elim_inl, Sum.elim_inr] |
| rfl |
|
|
| lemma tableCoordinate_nonneg (z : A → C) (c : C × C) (M : Pairing A) : |
| 0 ≤ tableCoordinate z c M := by |
| unfold tableCoordinate |
| exact Finset.sum_nonneg (fun _ _ => by split_ifs <;> norm_num) |
|
|
| lemma tableCoordinate_eq_zero_iff (z : A → C) (c : C × C) (M : Pairing A) : |
| tableCoordinate z c M = 0 ↔ ∀ a, ¬ (z a = c.1 ∧ z (M.1 a) = c.2) := by |
| unfold tableCoordinate |
| rw [Finset.sum_eq_zero_iff_of_nonneg (fun _ _ => by split_ifs <;> norm_num)] |
| simp |
|
|
| lemma tableCoordinate_constant (z : C) (c : C × C) (M : Pairing A) : |
| tableCoordinate (fun _ : A => z) c M = |
| if z=c.1 ∧ z=c.2 then (Fintype.card A : ℝ) else 0 := by |
| simp only [tableCoordinate] |
| split_ifs <;> simp_all |
|
|
| end Coordinates |
| end MatchingSmoothing |
|
|
| namespace MatchingSmoothing.Pairing |
| variable {A : Type u_9} {B : Type u_10} |
|
|
| lemma sum_injective : Function.Injective (fun p : Pairing A × Pairing B => sum p.1 p.2) := by |
| intro p q hpq |
| apply Prod.ext |
| · ext a |
| exact Sum.inl.inj (congrArg (fun M : Pairing (A ⊕ B) => M.1 (.inl a)) hpq) |
| · ext b |
| exact Sum.inr.inj (congrArg (fun M : Pairing (A ⊕ B) => M.1 (.inr b)) hpq) |
|
|
| lemma exists_sum (M : Pairing (A ⊕ B)) |
| (hl : ∀ a : A, ∃ a' : A, M.1 (.inl a) = .inl a') : |
| ∃ L : Pairing A, ∃ R : Pairing B, M = sum L R := by |
| classical |
| have hr (b : B) : ∃ b' : B, M.1 (.inr b) = .inr b' := by |
| cases he : M.1 (.inr b) with |
| | inl a => |
| obtain ⟨a',ha⟩ := hl a |
| have hh := M.partner_partner (.inr b) |
| rw [he, ha] at hh |
| cases hh |
| | inr b' => exact ⟨b',rfl⟩ |
| choose f hf using hl |
| choose g hg using hr |
| have hff : Function.Involutive f := by |
| intro a |
| apply Sum.inl_injective (β := B) |
| rw [← hf, ← hf, M.partner_partner] |
| have hgg : Function.Involutive g := by |
| intro b |
| apply Sum.inr_injective (α := A) |
| rw [← hg, ← hg, M.partner_partner] |
| let L : Pairing A := ⟨⟨f,f,hff,hff⟩,hff,fun a ha => |
| M.partner_ne (.inl a) ((hf a).trans (congrArg Sum.inl ha))⟩ |
| let R : Pairing B := ⟨⟨g,g,hgg,hgg⟩,hgg,fun b hb => |
| M.partner_ne (.inr b) ((hg b).trans (congrArg Sum.inr hb))⟩ |
| refine ⟨L,R,?_⟩ |
| ext v |
| cases v with |
| | inl a => exact hf a |
| | inr b => exact hg b |
|
|
| noncomputable def sumFiberEquiv (P : Pairing (A ⊕ B) → Prop) (Q : Pairing A → Prop) |
| (hs : ∀ L R, P (sum L R) ↔ Q L) |
| (hc : ∀ M, P M → ∀ a : A, ∃ a' : A, M.1 (.inl a) = .inl a') : |
| {L : Pairing A // Q L} × Pairing B ≃ {M : Pairing (A ⊕ B) // P M} := |
| Equiv.ofBijective (fun p => ⟨sum p.1.1 p.2, (hs _ _).mpr p.1.2⟩) (by |
| constructor |
| · intro p q he |
| have hh : (p.1.1,p.2) = (q.1.1,q.2) := |
| sum_injective (congrArg Subtype.val he) |
| apply Prod.ext |
| · exact Subtype.ext (congrArg (fun x : Pairing A × Pairing B => x.1) hh) |
| · exact congrArg (fun x : Pairing A × Pairing B => x.2) hh |
| · intro M |
| obtain ⟨L,R,hM⟩ := exists_sum M.1 (hc M.1 M.2) |
| refine ⟨(⟨L,(hs L R).mp (hM ▸ M.2)⟩,R),?_⟩ |
| exact Subtype.ext hM.symm) |
|
|
| end MatchingSmoothing.Pairing |
|
|
| end OAI |
|
|
