Download data/lean/OAI/Probability/CriticalPercolation/Entropy/MarkedBits.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 5.84 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/CriticalPercolation/Entropy/MarkedBits.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/CriticalPercolation/Entropy/MarkedBits.lean
-
curl -L -o MarkedBits.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/CriticalPercolation/Entropy/MarkedBits.lean
5.84 kB
| import Mathlib | |
| import OAI.Probability.CriticalPercolation.Exploration.ClusterUsers | |
| import OAI.Probability.CriticalPercolation.Criticality.ReverseReference | |
| namespace OAI | |
| section | |
| section | |
| namespace CriticalPercolation.MarkedBits | |
| open scoped Classical | |
| open FiniteProduct ExactExposure | |
| variable {E I : Type*} | |
| noncomputable def opened (S : Finset I) (m : I β Option E) (Ο : E β Bool) : E β Bool := | |
| fun e => if β i β S, m i = some e then true else Ο e | |
| noncomputable def masked (S : Finset I) (m : I β Option E) : I β Option E := | |
| fun i => if i β S then m i else none | |
| variable [Fintype I] | |
| lemma masked_join (S : Finset I) (m : I β Option E) (i : I) : | |
| (if i β S then masked S m i else masked SαΆ m i) = m i := by | |
| simp only [masked,Finset.mem_compl] | |
| split_ifs <;> rfl | |
| lemma masked_injective (S : Finset I) (m m' : I β Option E) | |
| (h1 : masked S m = masked S m') (h2 : masked SαΆ m = masked SαΆ m') : m=m' := by | |
| funext i | |
| rw [β masked_join S m i,β masked_join S m' i,h1,h2] | |
| omit [Fintype I] in | |
| lemma opened_empty (m : I β Option E) (Ο : E β Bool) : opened β m Ο = Ο := by | |
| funext e | |
| simp [opened] | |
| omit [Fintype I] in | |
| lemma opened_insert (S : Finset I) (m : I β Option E) (Ο : E β Bool) | |
| (i : I) (e : E) (hm : m i = some e) : | |
| opened (insert i S) m Ο = Function.update (opened S m Ο) e true := by | |
| funext f | |
| by_cases hf : f=e | |
| Β· subst f | |
| simp only [Function.update_self,opened] | |
| rw [ite_eq_left β¨i,Finset.mem_insert_self _ _,hmβ©] | |
| Β· rw [Function.update_of_ne hf] | |
| have he : (β j β insert i S, m j = some f) β β j β S, m j = some f := by | |
| constructor | |
| Β· rintro β¨j,hj,hjmβ© | |
| rcases Finset.mem_insert.mp hj with rfl|hj | |
| Β· exact (hf (Option.some.inj (hjm.symm.trans hm))).elim | |
| Β· exact β¨j,hj,hjmβ© | |
| Β· rintro β¨j,hj,hjmβ© | |
| exact β¨j,Finset.mem_insert_of_mem hj,hjmβ© | |
| simp only [opened,he] | |
| omit [Fintype I] in | |
| lemma opened_unchanged (S : Finset I) (m : I β Option E) (Ο : E β Bool) | |
| (e : E) (he : β i β S, m i β some e) : opened S m Ο e = Ο e := by | |
| apply ite_eq_right | |
| rintro β¨i,hi,hieβ© | |
| exact he i hi hie | |
| omit [Fintype I] in | |
| lemma close_opened_insert (S : Finset I) (m : I β Option E) (Ο : E β Bool) | |
| (i : I) (e : E) (hm : m i = some e) (hΟ : Ο e = false) | |
| (hd : β j β S, m j β some e) : | |
| Function.update (opened (insert i S) m Ο) e false = opened S m Ο := by | |
| rw [opened_insert S m Ο i e hm,Function.update_idem] | |
| rw [β hΟ,β opened_unchanged S m Ο e hd,Function.update_eq_self] | |
| omit [Fintype I] in | |
| lemma opened_injective_closed (S : Finset I) (m : I β Option E) (Ο Ξ· : E β Bool) | |
| (hΟ : β i β S, β e, m i = some e β Ο e = false) | |
| (hΞ· : β i β S, β e, m i = some e β Ξ· e = false) | |
| (he : opened S m Ο = opened S m Ξ·) : Ο=Ξ· := by | |
| funext e | |
| by_cases hm : β i β S, m i = some e | |
| Β· obtain β¨i,hi,himβ© := hm | |
| rw [hΟ i hi e him,hΞ· i hi e him] | |
| Β· have hh := congrFun he e | |
| simpa only [opened,ite_eq_right hm] using hh | |
| omit [Fintype I] in | |
| lemma configuration_update (Ο : E β Bool) (e : E) (b : Bool) : | |
| configuration (Function.update Ο e b) = Function.update (configuration Ο) e (b=true) := by | |
| apply Set.ext | |
| intro f | |
| change (Function.update Ο e b) f = true β (Function.update (configuration Ο : E β Prop) e (b=true)) f | |
| by_cases hf : f=e | |
| Β· subst f | |
| simp [Function.update] | |
| Β· simp only [Function.update,configuration,hf] | |
| rfl | |
| omit [Fintype I] in | |
| lemma density_open_likelihood [Fintype E] (p : β) (Ο : E β Bool) (e : E) (he : Ο e = false) : | |
| FiniteProduct.density (QueryTree.bitWeight p) Ο * p = | |
| FiniteProduct.density (QueryTree.bitWeight p) (Function.update Ο e true) * (1-p) := by | |
| classical | |
| have hf (m : E β Bool) : FiniteProduct.density (QueryTree.bitWeight p) m = | |
| QueryTree.bitWeight p e (m e) * β f β Finset.univ.erase e, QueryTree.bitWeight p f (m f) := | |
| (Finset.mul_prod_erase _ _ (Finset.mem_univ e)).symm | |
| rw [hf Ο,hf (Function.update Ο e true)] | |
| have ht : (β f β Finset.univ.erase e, QueryTree.bitWeight p f ((Function.update Ο e true) f)) = | |
| β f β Finset.univ.erase e, QueryTree.bitWeight p f (Ο f) := by | |
| apply Finset.prod_congr rfl | |
| intro f hf | |
| rw [Function.update_of_ne (Finset.mem_erase.mp hf).1] | |
| rw [ht] | |
| simp only [he,Function.update_self,QueryTree.bitWeight,Bool.false_eq_true,ite_false,ite_true] | |
| ring | |
| end CriticalPercolation.MarkedBits | |
| namespace CriticalPercolation.ReverseReference | |
| open scoped Classical | |
| variable {X M : Type*} | |
| lemma recover_trajectory (u : β β X β M β X) (Ο : β β X) (m : β β M) | |
| (n : β) (hu : β i < n, u i (Ο (i+1)) (m i) = Ο i) : | |
| recover u n (Ο n) (fun i => m i.val) = Ο 0 := by | |
| induction n with | |
| | zero => rfl | |
| | succ n ih => | |
| rw [recover] | |
| dsimp only [Fin.val_last] | |
| rw [hu n (Nat.lt_succ_self n)] | |
| exact ih (fun i hi => hu i (hi.trans (Nat.lt_succ_self n))) | |
| lemma weight_trajectory (k : β β X β M β β) (u : β β X β M β X) | |
| (Ο : β β X) (m : β β M) (v : β β β) (n : β) | |
| (hu : β i < n, u i (Ο (i+1)) (m i) = Ο i) | |
| (hk : β i < n, k i (Ο (i+1)) (m i) = v i) : | |
| weight k u n (Ο n) (fun i => m i.val) = β i : Fin n, v i.val := by | |
| induction n with | |
| | zero => simp [weight] | |
| | succ n ih => | |
| rw [weight] | |
| dsimp only [Fin.val_last] | |
| rw [hk n (Nat.lt_succ_self n),hu n (Nat.lt_succ_self n)] | |
| change v n * weight k u n (Ο n) (fun i => m i.val) = _ | |
| rw [ih (fun i hi => hu i (hi.trans (Nat.lt_succ_self n))) | |
| (fun i hi => hk i (hi.trans (Nat.lt_succ_self n)))] | |
| rw [Fin.prod_univ_castSucc] | |
| simp only [Fin.val_castSucc,Fin.val_last] | |
| ring | |
| end CriticalPercolation.ReverseReference | |
| end | |
| end | |
| end OAI | |