openAI-math-dataset / lean /OAI /Probability /CriticalPercolation /Entropy /BinaryReversePrices.lean
| import Mathlib | |
| import OAI.Probability.CriticalPercolation.Entropy.BinaryStages | |
| import OAI.Probability.CriticalPercolation.Entropy.BinaryReverseKernels | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| namespace CriticalPercolation.ExactExposure | |
| open scoped Classical | |
| open FiniteProduct SearchTree MarkedBits | |
| variable {V E : Type*} [Fintype V] [Fintype E] | |
| lemma reverseGuess_mark (G : BondGraph V E) (order : List (LazyDFS.Dart V E)) | |
| (B : Set V) (a b : V) (hb : b ∈ B) (p : ℝ) (hp : p ≠ 0) (w : E → Prop → ℝ) | |
| (ω : E → Bool) (e : E) (ha : Admissible G B a b ω e) : | |
| (LazyDFS.search G order a B).reverseGuess p | |
| (fun σ => ∃ t ∈ B, (G.openGraph σ).Reachable a t) w | |
| (Function.update (configuration ω) e True) 0 e = | |
| ((1-p)/p) * markWeight G order B a b p w ω e / | |
| (1+markCost G order B a b p w ω e)^2 := by | |
| obtain ⟨hn,u,v,hev,hu,hv⟩ := ha | |
| have hc := admissible_closed G B a b hb ω e ⟨hn,u,v,hev,hu,hv⟩ | |
| have hpi := G.contact_exit_pivot (configuration ω) B a u v e hev hc hn hu ⟨b,hb,hv.symm⟩ | |
| have ha : Admissible G B a b ω e := ⟨hn,u,v,hev,hu,hv⟩ | |
| simp only [reverseGuess,ite_eq_left hpi,add_zero,markWeight,markCost,ite_eq_left ha, | |
| queryDelta_update] | |
| field_simp | |
| end CriticalPercolation.ExactExposure | |
| namespace CriticalPercolation.BinaryLaw | |
| open scoped Classical | |
| open FiniteProduct BondGraph BinaryInterpolation InterpolationForest ExactExposure FiniteEntropy MarkedBits SearchTree | |
| variable {V E : Type*} [Fintype V] [Fintype E] | |
| local instance pricesFinDec (n : ℕ) : DecidableEq (Fin n) := Classical.decEq _ | |
| variable (G : BondGraph V E) (order : List (LazyDFS.Dart V E)) (d : ℕ) (x : ℕ → V) | |
| variable (p : ℝ) (w : E → Prop → ℝ) (s n : ℕ) (D : FixedDescriptor n) | |
| lemma supported_guess_price (hp : p ≠ 0) (ω : E → Bool) (m : Fin n → Option E) | |
| (hz : conditionedMass G order d x p w s n D (ω,m) ≠ 0) (i : Fin n) | |
| (hi : i ∈ activeSteps n D) (e : E) (he : m i = some e) : | |
| pivotGuess G order d x p w n D i (stage n D ω m (i.val+1)) e = | |
| ((1-p)/p) * selectedWeight G order d x p w n D i ω (m i) / | |
| (1+selectedCost G order d x p w n D i ω (m i))^2 := by | |
| obtain ⟨hD,hr⟩ := conditionedMass_support G order d x p w s n D (ω,m) hz | |
| let h := fromWords (E := E) n (fun j => (D j).1) m | |
| have hin : i.val+2 ∈ activeNodes G d x n h (configuration ω) := by | |
| rw [activeNodes_eq_descriptor G d x n h _ D hD] | |
| exact Finset.mem_image.mpr ⟨i,hi,rfl⟩ | |
| have hc := active_canonical G order d x p w _ n h _ hr _ hin | |
| have hm : nodeMark n h (i.val+2) = some e := by rw [← marks_nodeMark,marks_fromWords,he] | |
| have ht : targets d x n h (i.val+2) = stepTargets (E := E) d x n D i := by | |
| change _ = scheduledTargets (E := E) d x n (fun j => (D j).1) i.val | |
| rw [targets_prefix d x n h _ i.isLt.le,scheduledTargets_eq d x n _ m _ i.isLt.le] | |
| have hl : (node d x n h (i.val+2)).1 = stepLeft (E := E) d x n D i := | |
| congrArg Prod.fst (node_eq_descriptor G d x n h _ D hD _) | |
| have hS : ∀ j ∈ (stageIndices n D i.val).image (fun i => i.val+2), 2 ≤ j ∧ j < i.val+2 := by | |
| intro j hj | |
| obtain ⟨k,hk,rfl⟩ := Finset.mem_image.mp hj | |
| have hklt := (Finset.mem_filter.mp hk).2 | |
| omega | |
| have hh := (switched_contact_reconstruction G order d x p w _ n h (configuration ω) hr | |
| (i.val+2) (by omega) (by have := i.isLt; omega) hc e hm _ hS 0).2.2 | |
| rw [hl,ht] at hh | |
| unfold pivotGuess | |
| rw [stage,configuration_opened,stageIndices_succ_active n D i hi,Finset.image_insert] | |
| rw [← hh] | |
| obtain ⟨f,hf,ha⟩ := supported_active_admissible G order d x p w s n D ω m hz | |
| ⟨i,(Finset.mem_filter.mp hi).2⟩ | |
| have hfe : f=e := Option.some.inj (hf.symm.trans he) | |
| subst f | |
| have hpr := reverseGuess_mark G order (stepTargets (E := E) d x n D i) | |
| (stepLeft (E := E) d x n D i) (stepRight (E := E) d x n D i) | |
| (scheduled_parent_mem d x n D i) p hp w ω e ha | |
| simpa only [selectedWeight,selectedCost,ite_eq_left (Finset.mem_filter.mp hi).2,he] using hpr | |
| lemma supported_inverse_update (ω : E → Bool) (m : Fin n → Option E) | |
| (hz : conditionedMass G order d x p w s n D (ω,m) ≠ 0) (i : Fin n) : | |
| inverseUpdate (E := E) n D i.val (stage n D ω m (i.val+1)) (masked (activeSteps n D) m i) = | |
| stage n D ω m i.val := by | |
| unfold inverseUpdate | |
| rw [dite_eq_left i.isLt] | |
| by_cases hi : i ∈ activeSteps n D | |
| · obtain ⟨e,he,_⟩ := supported_active_admissible G order d x p w s n D ω m hz | |
| ⟨i,(Finset.mem_filter.mp hi).2⟩ | |
| simp only [ite_eq_left hi,masked,he] | |
| exact supported_stage_close G order d x p w s n D ω m hz i hi e he | |
| · simp only [ite_eq_right hi,stage,stageIndices_succ_inactive n D i hi] | |
| lemma supported_recover (ω : E → Bool) (m : Fin n → Option E) | |
| (hz : conditionedMass G order d x p w s n D (ω,m) ≠ 0) : | |
| ReverseReference.recover (inverseUpdate (E := E) n D) n (stage n D ω m n) | |
| (masked (activeSteps n D) m) = ω := by | |
| let m' : ℕ → Option E := fun j => if hj : j<n then masked (activeSteps n D) m ⟨j,hj⟩ else none | |
| have hm : (fun i : Fin n => m' i.val) = masked (activeSteps n D) m := by | |
| funext i | |
| simp only [m',dite_eq_left i.isLt] | |
| have hh := ReverseReference.recover_trajectory (inverseUpdate (E := E) n D) | |
| (stage n D ω m) m' n (fun j hj => by | |
| simpa only [m',dite_eq_left hj] using supported_inverse_update G order d x p w s n D ω m hz ⟨j,hj⟩) | |
| rw [hm,stage_zero] at hh | |
| exact hh | |
| end CriticalPercolation.BinaryLaw | |
| end | |
| end | |
| end | |
| end OAI | |