Download data/lean/OAI/Probability/BinarySweep/Conditional/Placement.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.92 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/BinarySweep/Conditional/Placement.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/BinarySweep/Conditional/Placement.lean
-
curl -L -o Placement.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/BinarySweep/Conditional/Placement.lean
9.92 kB
| import Mathlib | |
| import OAI.Probability.BinarySweep.Processes.LocalPathWeight | |
| import OAI.Probability.BinarySweep.FiniteLaws.CyclicHolder | |
| namespace OAI | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| namespace BinaryCoordinateSweeps | |
| attribute [local instance] Classical.propDecidable | |
| lemma independent_event_weight {J : Type*} [Fintype J] {X : J β Type*} | |
| [β j, Fintype (X j)] (w : β j, X j β β) (P : β j, X j β Prop) : | |
| (β x : β j, X j, if β j, P j (x j) then β j, w j (x j) else 0) = | |
| β j, β a : X j, if P j a then w j a else 0 := by | |
| classical | |
| calc | |
| _ = β x : β j, X j, β j, if P j (x j) then w j (x j) else 0 := by | |
| apply Finset.sum_congr rfl | |
| intro x _ | |
| exact Fintype.prod_ite_zero.symm | |
| _ = _ := (Fintype.prod_sum (fun j a => if P j a then w j a else 0)).symm | |
| lemma conditionalWeight_factor {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (z : β) (g : GridChoices bits) : | |
| (if pathEvent H g then gridWeight bits z g else 0) = | |
| β j, β y, if Assigns (lineInput H j y) (lineOutput H j y) (g j y) then | |
| lineLaw (bits j) z (g j y) else 0 := by | |
| classical | |
| rw [pathEvent_iff_assigns] | |
| simp only [Fintype.prod_ite_zero] | |
| split_ifs <;> rfl | |
| lemma sum_prod_grid {b : β} (bits : Fin b β β) | |
| (f : β j : Fin b, GridOutside bits j β Equiv.Perm (Slot (bits j)) β β) : | |
| (β g : GridChoices bits, β j, β y, f j y (g j y)) = | |
| β j, β y, β Ο, f j y Ο := by | |
| rw [β Fintype.prod_sum (fun (j : Fin b) | |
| (g : GridOutside bits j β Equiv.Perm (Slot (bits j))) => β y, f j y (g y))] | |
| apply Finset.prod_congr rfl | |
| intro j _ | |
| exact (Fintype.prod_sum (f j)).symm | |
| lemma conditionalNormalizer_eq_prod {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (z : β) : conditionalNormalizer H z = β j, β y, localPathWeight H z j y := by | |
| let f (j : Fin b) (y : GridOutside bits j) (Ο : Equiv.Perm (Slot (bits j))) : β := | |
| if Assigns (lineInput H j y) (lineOutput H j y) Ο then lineLaw (bits j) z Ο else 0 | |
| have hL : conditionalNormalizer H z = | |
| β g : GridChoices bits, β j, β y, f j y (g j y) := by | |
| unfold conditionalNormalizer | |
| apply Finset.sum_congr rfl | |
| intro g _ | |
| rw [conditionalWeight_factor] | |
| have hR : (β j, β y, localPathWeight H z j y) = | |
| β j, β y, β Ο, f j y Ο := by | |
| apply Finset.prod_congr rfl | |
| intro j _ | |
| apply Finset.prod_congr rfl | |
| intro y _ | |
| unfold localPathWeight assignmentWeight | |
| refine Finset.sum_congr ?_ ?_ | |
| Β· ext Ο | |
| simp only [Finset.mem_univ] | |
| intro Ο _ | |
| unfold f | |
| split_ifs <;> rfl | |
| rw [hL, hR] | |
| exact sum_prod_grid bits f | |
| abbrev ConditionalChoices {b h : β} {bits : Fin b β β} (H : PathFamily bits h) := | |
| {g : GridChoices bits // pathEvent H g} | |
| instance conditionalChoicesFintype {b h : β} {bits : Fin b β β} (H : PathFamily bits h) : | |
| Fintype (ConditionalChoices H) := Fintype.ofFinite _ | |
| instance conditionalChoicesNonempty {b h : β} {bits : Fin b β β} (H : PathFamily bits h) : | |
| Nonempty (ConditionalChoices H) := by | |
| obtain β¨g, hgβ© := pathEvent_nonempty H | |
| exact β¨β¨g, hgβ©β© | |
| def conditionalChoiceWeight {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (z : β) (g : ConditionalChoices H) : β := | |
| gridWeight bits z g.val / conditionalNormalizer H z | |
| lemma conditionalChoiceWeight_nonneg {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) (g : ConditionalChoices H) : | |
| 0 β€ conditionalChoiceWeight H z g := | |
| le_of_lt (div_pos (gridWeight_pos bits hz hz1 g.val) (conditionalNormalizer_pos H hz hz1)) | |
| lemma conditionalChoiceWeight_sum {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) : | |
| β g : ConditionalChoices H, conditionalChoiceWeight H z g = 1 := by | |
| classical | |
| unfold conditionalChoiceWeight | |
| rw [β Finset.sum_div] | |
| have hs : (β g : ConditionalChoices H, gridWeight bits z g.val) = | |
| conditionalNormalizer H z := by | |
| unfold conditionalNormalizer | |
| rw [β Finset.sum_filter] | |
| exact (Finset.sum_subtype _ (by simp) _).symm | |
| rw [hs, div_self (conditionalNormalizer_pos H hz hz1).ne'] | |
| abbrev Placement {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (k : β) (t : Fin (b+1)) := Fin k βͺ FreeSlot H t | |
| def placementBijection {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (k : β) (g : ConditionalChoices H) : | |
| Placement H k 0 β Placement H k (Fin.last b) := | |
| (Equiv.refl (Fin k)).embeddingCongr (remainingBijection H g.val g.property) | |
| def placementProbability {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (z : β) {k : β} (x : Placement H k 0) (y : Placement H k (Fin.last b)) : β := by | |
| classical | |
| exact β g : ConditionalChoices H, | |
| if placementBijection H k g x = y then conditionalChoiceWeight H z g else 0 | |
| section FiniteBijectionKernel | |
| variable {Ξ© A B : Type*} [Fintype Ξ©] [Fintype A] [Fintype B] | |
| def bijectionKernel (w : Ξ© β β) (e : Ξ© β A β B) (x : A) (y : B) : β := | |
| β Ο, if e Ο x = y then w Ο else 0 | |
| omit [Fintype A] [Fintype B] in | |
| lemma bijectionKernel_nonneg (w : Ξ© β β) (e : Ξ© β A β B) | |
| (hw : β Ο, 0 β€ w Ο) (x : A) (y : B) : 0 β€ bijectionKernel w e x y := by | |
| apply Finset.sum_nonneg | |
| intro Ο _ | |
| split_ifs | |
| Β· exact hw Ο | |
| Β· exact le_rfl | |
| omit [Fintype A] in | |
| lemma bijectionKernel_rowSum (w : Ξ© β β) (e : Ξ© β A β B) (x : A) : | |
| β y, bijectionKernel w e x y = β Ο, w Ο := by | |
| unfold bijectionKernel | |
| rw [Finset.sum_comm] | |
| simp | |
| lemma bijectionKernel_colSum (w : Ξ© β β) (e : Ξ© β A β B) (y : B) : | |
| β x, bijectionKernel w e x y = β Ο, w Ο := by | |
| unfold bijectionKernel | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro Ο _ | |
| rw [(e Ο).sum_comp (fun x => if x = y then w Ο else 0)] | |
| simp | |
| end FiniteBijectionKernel | |
| lemma placementProbability_eq_kernel {b h : β} {bits : Fin b β β} | |
| (H : PathFamily bits h) (z : β) {k : β} | |
| (x : Placement H k 0) (y : Placement H k (Fin.last b)) : | |
| placementProbability H z x y = | |
| bijectionKernel (conditionalChoiceWeight H z) (placementBijection H k) x y := by | |
| unfold placementProbability bijectionKernel | |
| apply Finset.sum_congr rfl | |
| intro g _ | |
| split_ifs <;> rfl | |
| lemma placementProbability_nonneg {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) {k : β} | |
| (x : Placement H k 0) (y : Placement H k (Fin.last b)) : | |
| 0 β€ placementProbability H z x y := by | |
| rw [placementProbability_eq_kernel] | |
| exact bijectionKernel_nonneg _ _ (conditionalChoiceWeight_nonneg H hz hz1) x y | |
| lemma placementProbability_rowSum {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) {k : β} (x : Placement H k 0) : | |
| β y, placementProbability H z x y = 1 := by | |
| simp_rw [placementProbability_eq_kernel] | |
| rw [bijectionKernel_rowSum, conditionalChoiceWeight_sum H hz hz1] | |
| lemma placementProbability_colSum {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) {k : β} (y : Placement H k (Fin.last b)) : | |
| β x, placementProbability H z x y = 1 := by | |
| simp_rw [placementProbability_eq_kernel] | |
| rw [bijectionKernel_colSum, conditionalChoiceWeight_sum H hz hz1] | |
| lemma card_placement {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (k : β) (t : Fin (b+1)) : | |
| Fintype.card (Placement H k t) = (gridSize bits - h).descFactorial k := by | |
| rw [Fintype.card_embedding_eq, card_freeSlot, Fintype.card_fin] | |
| def placementIdentification {b h : β} {bits : Fin b β β} (H : PathFamily bits h) (k : β) : | |
| Placement H k 0 β Placement H k (Fin.last b) := | |
| (Equiv.refl (Fin k)).embeddingCongr (freeIdentification H) | |
| def placementKernel {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (z : β) {k : β} (x y : Placement H k 0) : β := | |
| placementProbability H z x (placementIdentification H k y) | |
| lemma placementKernel_nonneg {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) {k : β} (x y : Placement H k 0) : | |
| 0 β€ placementKernel H z x y := placementProbability_nonneg H hz hz1 _ _ | |
| lemma placementKernel_rowSum {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) {k : β} (x : Placement H k 0) : | |
| β y, placementKernel H z x y = 1 := by | |
| unfold placementKernel | |
| rw [(placementIdentification H k).sum_comp] | |
| exact placementProbability_rowSum H hz hz1 x | |
| lemma placementKernel_colSum {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) {k : β} (y : Placement H k 0) : | |
| β x, placementKernel H z x y = 1 := placementProbability_colSum H hz hz1 _ | |
| def placementEdge {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| (z : β) (reverse : Bool) {k : β} (x y : Placement H k 0) : β := | |
| if reverse then placementKernel H z y x else placementKernel H z x y | |
| theorem placement_cycle_bound {b h : β} {bits : Fin b β β} (H : PathFamily bits h) | |
| {z : β} (hz : 0 β€ z) (hz1 : z < 1) (k n : β) (reverse : Fin (n+1) β Bool) : | |
| (β x : Fin (n+1) β Placement H k 0, | |
| β i, (placementEdge H z (reverse i) (x i) (x (finRotate (n+1) i))) ^ | |
| ((n : β) / (n+1 : β))) β€ ((gridSize bits - h).descFactorial k : β) := by | |
| rw [β card_placement H k 0] | |
| apply Cyclic.sum_cycle_rpow_le_card | |
| Β· intro i x y | |
| unfold placementEdge | |
| split_ifs <;> exact placementKernel_nonneg H hz hz1 _ _ | |
| Β· intro i y | |
| unfold placementEdge | |
| cases reverse i with | |
| | false => exact placementKernel_colSum H hz hz1 y | |
| | true => exact placementKernel_rowSum H hz hz1 y | |
| end BinaryCoordinateSweeps | |
| end | |
| end OAI | |