Download data/lean/OAI/Dynamics/ConditionalShuffle/Instrument.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.85 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/ConditionalShuffle/Instrument.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/ConditionalShuffle/Instrument.lean
-
curl -L -o Instrument.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/ConditionalShuffle/Instrument.lean
7.85 kB
| import OAI.Dynamics.ConditionalShuffle.Disintegration | |
| namespace OAI | |
| noncomputable section | |
| namespace Revealed.Instrument | |
| open scoped Classical | |
| open Thorp Thorp.Conditional Thorp.Fourier Revealed.Disintegration | |
| lemma fairMass_bind {Ξ© Ξ©' X Y : Type*} [Fintype Ξ©] [Fintype Ξ©'] [Fintype X] | |
| (f : Ξ© β X) (k : X β Ξ©' β Y) (y : Y) : | |
| fairMass (fun z : Ξ© Γ Ξ©' => k (f z.1) z.2) y = | |
| β x, fairMass f x * fairMass (k x) y := by | |
| rw [fairMass_test] | |
| rw [fairMass_eq_mean, mean_prod] | |
| rfl | |
| lemma fairMass_snoc {Ξ© X : Type*} [Fintype Ξ©] {n : β} (f : (Fin (n + 1) β Ξ©) β X) (x : X) : | |
| fairMass f x = fairMass (fun z : (Fin n β Ξ©) Γ Ξ© => f (Fin.snoc z.1 z.2)) x := by | |
| rw [fairMass_eq_mean, fairMass_eq_mean] | |
| exact (mean_equiv ((Equiv.prodComm (Fin n β Ξ©) Ξ©).trans (Fin.snocEquiv (fun _ : Fin (n + 1) => Ξ©))) _).symm | |
| structure Data (E S G Ξ© : Type) where | |
| obs : E β Ξ© β S | |
| inc : E β Ξ© β G | |
| next : E β S β E | |
| variable {E S G Ξ© : Type} [fintype_S : Fintype S] [fintype_G : Fintype G] [group_G : Group G] [Fintype Ξ©] [nonempty_Ξ© : Nonempty Ξ©] | |
| variable (I : Data E S G Ξ©) | |
| def joint (e : E) : S Γ G β β := fairMass (fun Ο => (I.obs e Ο, I.inc e Ο)) | |
| def probability (e : E) : S β β := marginal (joint I e) | |
| def kernel (e : E) : S β G β β := conditional (joint I e) | |
| lemma joint_nonneg (e : E) (x) : 0 β€ joint I e x := by | |
| let retained_fintype_S := fintype_S | |
| let retained_fintype_G := fintype_G | |
| let retained_group_G := group_G | |
| let retained_nonempty_Ξ© := nonempty_Ξ© | |
| exact fairMass_nonneg _ _ | |
| lemma probability_nonneg (e : E) (s) : 0 β€ probability I e s := marginal_nonneg _ (joint_nonneg I e) s | |
| lemma probability_sum (e : E) : β s, probability I e s = 1 := by | |
| rw [probability, marginal_sum] | |
| exact fairMass_sum _ | |
| lemma kernel_nonneg (e : E) (s g) : 0 β€ kernel I e s g := conditional_nonneg _ (joint_nonneg I e) s g | |
| lemma kernel_sum (e : E) (s) : β g, kernel I e s g = 1 := by | |
| let retained_nonempty_Ξ© := nonempty_Ξ© | |
| exact conditional_sum _ s | |
| lemma probability_mul_kernel (e : E) (s g) : probability I e s * kernel I e s g = joint I e (s,g) := | |
| marginal_mul_conditional _ (joint_nonneg I e) s g | |
| def base (e : E) : (n : β) β (Fin n β S) β E | |
| | 0, _ => e | |
| | n + 1, p => I.next (base e n (Fin.init p)) (p (Fin.last n)) | |
| def weights (e : E) : (n : β) β (Fin n β S) β β | |
| | 0, _ => 1 | |
| | n + 1, p => weights e n (Fin.init p) * probability I (base I e n (Fin.init p)) (p (Fin.last n)) | |
| def kernels (e : E) : (n : β) β (Fin n β S) β (Fin n β G β β) | |
| | 0, _ => Fin.elim0 | |
| | n + 1, p => Fin.snoc (kernels e n (Fin.init p)) | |
| (kernel I (base I e n (Fin.init p)) (p (Fin.last n))) | |
| def observed (e : E) : (n : β) β (Fin n β Ξ©) β (Fin n β S) | |
| | 0, _ => Fin.elim0 | |
| | n + 1, Ο => let p := observed e n (Fin.init Ο) | |
| Fin.snoc p (I.obs (base I e n p) (Ο (Fin.last n))) | |
| def groupRun (e : E) : (n : β) β (Fin n β Ξ©) β G | |
| | 0, _ => 1 | |
| | n + 1, Ο => I.inc (base I e n (observed I e n (Fin.init Ο))) (Ο (Fin.last n)) * | |
| groupRun e n (Fin.init Ο) | |
| def pathJoint (e : E) (n : β) : (Fin n β S) Γ G β β := | |
| fairMass (fun Ο : Fin n β Ξ© => (observed I e n Ο, groupRun I e n Ο)) | |
| lemma kernels_nonneg (e : E) (n : β) (p : Fin n β S) : β i g, 0 β€ kernels I e n p i g := by | |
| induction n with | |
| | zero => intro i; exact Fin.elim0 i | |
| | succ n ih => | |
| intro i g | |
| refine Fin.lastCases ?_ (fun j => ?_) i | |
| Β· simpa only [kernels, Fin.snoc_last] using kernel_nonneg I _ _ g | |
| Β· simpa only [kernels, Fin.snoc_castSucc] using ih (Fin.init p) j g | |
| lemma kernels_sum (e : E) (n : β) (p : Fin n β S) : β i, β g, kernels I e n p i g = 1 := by | |
| induction n with | |
| | zero => intro i; exact Fin.elim0 i | |
| | succ n ih => | |
| intro i | |
| refine Fin.lastCases ?_ (fun j => ?_) i | |
| Β· simpa only [kernels, Fin.snoc_last] using kernel_sum I _ _ | |
| Β· simpa only [kernels, Fin.snoc_castSucc] using ih (Fin.init p) j | |
| lemma weights_nonneg (e : E) (n : β) (p : Fin n β S) : 0 β€ weights I e n p := by | |
| induction n with | |
| | zero => exact zero_le_one | |
| | succ n ih => exact mul_nonneg (ih _) (probability_nonneg I _ _) | |
| lemma sum_snoc {M : Type*} [AddCommMonoid M] (n : β) (f : (Fin (n + 1) β S) β M) : | |
| (β p, f p) = β p : Fin n β S, β s : S, f (Fin.snoc p s) := by | |
| have h := (Equiv.sum_comp ((Equiv.prodComm (Fin n β S) S).trans | |
| (Fin.snocEquiv (fun _ : Fin (n + 1) => S))) f).symm | |
| change (β p, f p) = β z : (Fin n β S) Γ S, f (Fin.snoc z.1 z.2) at h | |
| rw [Fintype.sum_prod_type] at h | |
| exact h | |
| lemma weights_sum (e : E) (n : β) : β p, weights I e n p = 1 := by | |
| induction n with | |
| | zero => simp [weights] | |
| | succ n ih => | |
| rw [sum_snoc] | |
| simp only [weights, Fin.init_snoc, Fin.snoc_last, β Finset.mul_sum, probability_sum, mul_one] | |
| exact ih | |
| lemma snoc_eq_iff {A : Type*} {n : β} (p q : Fin n β A) (s t : A) : | |
| (Fin.snoc p s : Fin (n + 1) β A) = Fin.snoc q t β p = q β§ s = t := by | |
| constructor | |
| Β· intro h | |
| exact β¨by simpa using congrArg Fin.init h, by simpa using congrFun h (Fin.last n)β© | |
| Β· rintro β¨rfl, rflβ© | |
| rfl | |
| lemma realConv_right (ΞΌ Ξ½ : G β β) (z : G) : realConv ΞΌ Ξ½ z = β h, ΞΌ (z * hβ»ΒΉ) * Ξ½ h := by | |
| have h := Equiv.sum_comp ((Equiv.inv G).trans (Equiv.mulLeft z)) | |
| (fun a => ΞΌ a * Ξ½ (aβ»ΒΉ * z)) | |
| change (β a, ΞΌ (z * aβ»ΒΉ) * Ξ½ ((z * aβ»ΒΉ)β»ΒΉ * z)) = β a, ΞΌ a * Ξ½ (aβ»ΒΉ * z) at h | |
| simpa only [mul_inv_rev, inv_inv, mul_assoc, inv_mul_cancel, mul_one, realConv] using h.symm | |
| lemma transition_mass (e : E) (n : β) (p q : Fin n β S) (h z : G) (s : S) : | |
| fairMass (fun c : Ξ© => (Fin.snoc p (I.obs (base I e n p) c), I.inc (base I e n p) c * h)) | |
| ((Fin.snoc q s : Fin (n + 1) β S), z) = | |
| if p = q then joint I (base I e n q) (s, z * hβ»ΒΉ) else 0 := by | |
| let retained_fintype_S := fintype_S | |
| let retained_fintype_G := fintype_G | |
| let retained_nonempty_Ξ© := nonempty_Ξ© | |
| by_cases hp : p = q | |
| Β· subst p | |
| simp [joint, fairMass, Prod.mk.injEq, eq_mul_inv_iff_mul_eq] | |
| Β· simp only [fairMass, Prod.mk.injEq, snoc_eq_iff, hp, false_and, | |
| ite_false, Finset.sum_const_zero, zero_div] | |
| lemma pathJoint_succ (e : E) (n : β) (p : Fin n β S) (s : S) (g : G) : | |
| pathJoint I e (n + 1) (Fin.snoc p s, g) = | |
| realConv (fun h => joint I (base I e n p) (s,h)) (fun h => pathJoint I e n (p,h)) g := by | |
| rw [pathJoint, fairMass_snoc] | |
| simp only [observed, groupRun, Fin.init_snoc, Fin.snoc_last] | |
| have h := fairMass_bind | |
| (fun Ο : Fin n β Ξ© => (observed I e n Ο, groupRun I e n Ο)) | |
| (fun x c => (Fin.snoc x.1 (I.obs (base I e n x.1) c), I.inc (base I e n x.1) c * x.2)) | |
| ((Fin.snoc p s : Fin (n + 1) β S), g) | |
| rw [h, Fintype.sum_prod_type] | |
| simp only [transition_mass, mul_ite, mul_zero] | |
| rw [Finset.sum_comm] | |
| simp only [Finset.sum_ite_eq', Finset.mem_univ, ite_true] | |
| rw [realConv_right] | |
| apply Finset.sum_congr rfl | |
| intro h _ | |
| rw [mul_comm] | |
| rfl | |
| theorem pathJoint_factor (e : E) (n : β) (p : Fin n β S) (g : G) : | |
| pathJoint I e n (p,g) = weights I e n p * realProduct n (kernels I e n p) g := by | |
| induction n generalizing g with | |
| | zero => | |
| have hp : p = Fin.elim0 := Subsingleton.elim _ _ | |
| subst p | |
| simp [pathJoint, observed, groupRun, weights, realProduct, fairMass, eq_comm] | |
| | succ n ih => | |
| have hp : p = Fin.snoc (Fin.init p) (p (Fin.last n)) := (Fin.snoc_init_self p).symm | |
| conv_lhs => rw [hp] | |
| rw [pathJoint_succ, realConv_right] | |
| simp only [weights, kernels, realProduct, Fin.snoc_last, Fin.init_snoc, realConv_right] | |
| simp_rw [ih] | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro h _ | |
| rw [β probability_mul_kernel] | |
| ring | |
| end Revealed.Instrument | |
| end | |
| end OAI | |