introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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