| import OAI.Probability.FKMaps.WordLaw |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.Inventory |
|
|
| def revealed (x : ℕ → Letter) (n : ℕ) : List Letter := |
| (List.ofFn (fun i : Fin n => x i)).reverse |
|
|
| lemma revealed_zero (x : ℕ → Letter) : revealed x 0=[] := by simp [revealed] |
| lemma revealed_succ (x : ℕ → Letter) (n : ℕ) : |
| revealed x (n+1)=x n::revealed x n := by |
| unfold revealed |
| rw [List.ofFn_succ'] |
| simp only [List.concat_eq_append,List.reverse_concat,Fin.val_last,Fin.val_castSucc] |
|
|
| lemma revealed_sum (x : ℕ → Letter) (n : ℕ) : |
| ((revealed x n).map Letter.increment).sum=signSum x n := by |
| simp only [revealed,List.map_reverse,List.sum_reverse,List.map_ofFn,List.sum_ofFn] |
| exact Fin.sum_univ_eq_sum_range (fun i => (x i).increment) n |
|
|
| lemma survivor_mono (x : ℕ → Letter) {n m : ℕ} (hnm : n ≤ m) |
| (hn : (reduce (revealed x n)).burgers ≠ []) : |
| (reduce (revealed x m)).burgers ≠ [] := by |
| obtain ⟨k,rfl⟩ := Nat.exists_eq_add_of_le hnm |
| clear hnm |
| induction k with |
| | zero => simpa using hn |
| | succ k ih => |
| rw [show n+(k+1)=n+k+1 by omega,revealed_succ] |
| cases h : (reduce (revealed x (n+k))).burgers with |
| | nil => exact (ih h).elim |
| | cons b bs => |
| have hh := freshest_survivor_prepend (revealed x (n+k)) [x (n+k)] h |
| intro hz |
| simp only [List.singleton_append,hz,List.head?_nil] at hh |
| contradiction |
|
|
| def rawFiltration : Filtration ℕ (inferInstance : MeasurableSpace (ℕ → Letter)) := |
| Filtration.natural (fun n x => x n) (fun n => (measurable_pi_apply n).stronglyMeasurable) |
|
|
| lemma raw_adapted (n k : ℕ) (hk : k ≤ n) : |
| Measurable[rawFiltration n] (fun x : ℕ → Letter => x k) := by |
| exact ((Filtration.stronglyAdapted_natural |
| (fun j : ℕ => (measurable_pi_apply j).stronglyMeasurable)) k).measurable.mono |
| (rawFiltration.mono hk) le_rfl |
|
|
| lemma prefix_measurable {β : Type*} [MeasurableSpace β] (n : ℕ) |
| (f : (Fin (n+1) → Letter) → β) : |
| Measurable[rawFiltration n] (fun x => f (fun i => x i)) := by |
| let : MeasurableSpace (ℕ → Letter) := rawFiltration n |
| exact (measurable_of_countable f).comp |
| (Measurable.of_eval fun index => raw_adapted n index (by omega)) |
|
|
| lemma signSum_adapted : StronglyAdapted rawFiltration |
| (fun n x => (signSum x (n+1):ℝ)) := by |
| intro n |
| have hh := prefix_measurable n (fun y => ((∑ i:Fin (n+1),(y i).increment:ℤ):ℝ)) |
| convert hh.stronglyMeasurable using 1 |
| ext x |
| exact congrArg (fun z : ℤ => (z:ℝ)) |
| (Fin.sum_univ_eq_sum_range (fun i => (x i).increment) (n+1)).symm |
|
|
| lemma raw_sign_martingale (P : Parameters) : |
| Martingale (fun n x => (signSum x (n+1):ℝ)) rawFiltration (streamLaw P ℕ) := by |
| have hi (n : ℕ) : Integrable (fun x : ℕ → Letter => ((x n).increment:ℝ)) (streamLaw P ℕ) := by |
| exact (measurePreserving_eval_infinitePi (fun _ : ℕ => (law P).toMeasure) n).integrable_comp_of_integrable |
| (integrableOn_univ.mp (IntegrableOn.of_finite (Set.finite_univ) : |
| IntegrableOn (fun a : Letter => (a.increment:ℝ)) Set.univ (law P).toMeasure)) |
| have hint (n : ℕ) : Integrable (fun x => (signSum x (n+1):ℝ)) (streamLaw P ℕ) := by |
| simp only [signSum,Int.cast_sum] |
| exact integrable_finsetSum _ (fun k _ => hi k) |
| apply martingale_nat signSum_adapted hint |
| intro n |
| have hind : Indep (MeasurableSpace.comap (fun x : ℕ → Letter => x (n+1)) inferInstance) |
| (rawFiltration n) (streamLaw P ℕ) := by |
| have h := indep_iSup_of_disjoint |
| (fun k : ℕ => (measurable_pi_apply k : Measurable (fun x : ℕ → Letter => x k)).comap_le) |
| (iIndepFun_infinitePi (P := fun _ : ℕ => (law P).toMeasure) (X := fun _ (a : Letter) => a) (fun _ => measurable_id)) |
| (show Disjoint ({n+1} : Set ℕ) {k | k ≤ n} by simp) |
| simpa only [iSup_singleton,rawFiltration,Filtration.natural,Set.mem_ofPred_eq,streamLaw] using h |
| have hc := condExp_indep_eq |
| (measurable_pi_apply (n+1) : Measurable (fun x : ℕ → Letter => x (n+1))).comap_le |
| (rawFiltration.le n) |
| (((measurable_of_countable (fun a : Letter => (a.increment:ℝ))).comp |
| (comap_measurable (fun x : ℕ → Letter => x (n+1)))).stronglyMeasurable) hind |
| change (streamLaw P ℕ)[(fun x => ((x (n+1)).increment:ℝ)) | rawFiltration n] =ᵐ[streamLaw P ℕ] |
| (fun _ => ∫ x,((x (n+1)).increment:ℝ) ∂streamLaw P ℕ) at hc |
| have hz : ∫ x,((x (n+1)).increment:ℝ) ∂streamLaw P ℕ=0 := by |
| exact ((measurePreserving_eval_infinitePi (fun _ : ℕ => (law P).toMeasure) (n+1)).hasLaw.integral_comp |
| (f := fun a : Letter => (a.increment:ℝ)) (measurable_of_countable _).aestronglyMeasurable).trans |
| (integral_increment P) |
| have he : (fun x => (signSum x (n+1+1):ℝ))= |
| (fun x => (signSum x (n+1):ℝ))+(fun x => ((x (n+1)).increment:ℝ)) := by |
| ext x; simp only [signSum_succ,Int.cast_add,Pi.add_apply] |
| rw [he] |
| filter_upwards [condExp_add (hint n) (hi (n+1)) (rawFiltration n),hc] with x hsum hx |
| rw [condExp_of_stronglyMeasurable (rawFiltration.le n) (signSum_adapted n) (hint n), |
| Pi.add_apply,hx,hz,add_zero] at hsum |
| exact hsum.symm |
|
|
| def survivorFlag (n : ℕ) (x : ℕ → Letter) : ℤ := |
| if (reduce (revealed x (n+1))).burgers=[] then 1 else 0 |
|
|
| def firstSurvivor (x : ℕ → Letter) : WithTop ℕ := TreeCoding.firstZero survivorFlag x |
|
|
| lemma survivorFlag_adapted : StronglyAdapted rawFiltration survivorFlag := by |
| intro n |
| exact (prefix_measurable n (fun y => if (reduce (List.ofFn y).reverse).burgers=[] then (1:ℤ) else 0)).stronglyMeasurable |
|
|
| lemma firstSurvivor_stopping : IsStoppingTime rawFiltration firstSurvivor := |
| TreeCoding.firstZero_isStoppingTime survivorFlag_adapted |
|
|
| lemma firstSurvivor_le_iff (x : ℕ → Letter) (n : ℕ) : |
| firstSurvivor x ≤ (WithTop.some n) ↔ (reduce (revealed x (n+1))).burgers ≠ [] := by |
| change TreeCoding.firstZero survivorFlag x ≤ WithTop.some n ↔ _ |
| rw [TreeCoding.firstZero_le_iff] |
| constructor |
| · rintro ⟨k,hk,h⟩ |
| have hh : (reduce (revealed x (k+1))).burgers ≠ [] := by |
| simpa [survivorFlag] using h |
| exact survivor_mono x (by omega) hh |
| · intro h |
| exact ⟨n,le_rfl,by simp [survivorFlag,h]⟩ |
|
|
| lemma firstSurvivor_finite (P : Parameters) : |
| ∀ᵐ x ∂streamLaw P ℕ, firstSurvivor x ≠ ⊤ := by |
| filter_upwards [signs_hit_one P] with x hx |
| obtain ⟨n,hn⟩ := hx |
| have hb : (reduce (revealed x n)).burgers ≠ [] := |
| survivor_of_sum_pos _ (by rw [revealed_sum,hn]; norm_num) |
| have hle := (firstSurvivor_le_iff x n).mpr (survivor_mono x (by omega) hb) |
| exact ne_top_of_le_ne_top WithTop.coe_ne_top hle |
|
|
| lemma firstSurvivor_shape {x : ℕ → Letter} {n : ℕ} |
| (h : firstSurvivor x=(WithTop.some n)) : |
| ∃ b, reduce (revealed x (n+1))=⟨(reduce (revealed x n)).orders,[b]⟩ ∧ |
| ∀ o∈(reduce (revealed x n)).orders,o=some (!b) := by |
| have h₁ := (firstSurvivor_le_iff x n).mp (by rw [h]) |
| have h₀ : (reduce (revealed x n)).burgers=[] := by |
| cases n with |
| | zero => simp [revealed_zero,reduce,run] |
| | succ n => |
| by_contra hn |
| have hle := (firstSurvivor_le_iff x n).mpr hn |
| rw [h] at hle |
| have hh : n+1 ≤ n := WithTop.coe_le_coe.mp hle |
| omega |
| rw [revealed_succ] at h₁ ⊢ |
| obtain ⟨b,_,hb,ho⟩ := first_survivor_shape (x n) (revealed x n) h₀ h₁ |
| exact ⟨b,hb,ho⟩ |
|
|
| def stoppedDefect (n : ℕ) (x : ℕ → Letter) : ℝ := |
| stoppedProcess (fun k x => 1-(signSum x (k+1):ℝ)) firstSurvivor n x |
|
|
| lemma stoppedDefect_martingale (P : Parameters) : |
| Martingale stoppedDefect rawFiltration (streamLaw P ℕ) := by |
| exact TreeCoding.martingale_stoppedProcess_real |
| ((martingale_const rawFiltration (streamLaw P ℕ) (1:ℝ)).sub (raw_sign_martingale P)) |
| firstSurvivor_stopping |
|
|
| lemma stoppedDefect_nonneg (n : ℕ) (x : ℕ → Letter) : 0 ≤ stoppedDefect n x := by |
| by_cases h : firstSurvivor x ≤ (WithTop.some n) |
| · obtain ⟨k,hk⟩ := WithTop.ne_top_iff_exists.mp (ne_top_of_le_ne_top WithTop.coe_ne_top h) |
| have hk' : firstSurvivor x=(WithTop.some k) := hk.symm |
| obtain ⟨b,hb,_⟩ := firstSurvivor_shape hk' |
| have hs := reduce_imbalance (revealed x (k+1)) |
| rw [hb,imbalance,revealed_sum] at hs |
| simp only [List.length_singleton,Nat.cast_one] at hs |
| change 0 ≤ 1-(signSum x ((min (WithTop.some n) (firstSurvivor x)).untopA+1):ℝ) |
| rw [min_eq_right h,hk',WithTop.untopA_eq_untop WithTop.coe_ne_top,WithTop.untop_coe] |
| have hr : (signSum x (k+1):ℝ)=1-(((reduce (revealed x (k+1))).orders.length):ℝ) := by |
| rw [hb] |
| exact_mod_cast hs.symm |
| rw [hr] |
| linarith [Nat.cast_nonneg (α := ℝ) ((reduce (revealed x (k+1))).orders.length)] |
| · have hb : (reduce (revealed x (n+1))).burgers=[] := by |
| by_contra hn |
| exact h ((firstSurvivor_le_iff x n).mpr hn) |
| have hs := reduce_imbalance (revealed x (n+1)) |
| rw [imbalance,hb,revealed_sum] at hs |
| simp only [List.length_nil,Nat.cast_zero,zero_sub] at hs |
| change 0 ≤ 1-(signSum x ((min (WithTop.some n) (firstSurvivor x)).untopA+1):ℝ) |
| rw [min_eq_left (le_of_not_ge h),WithTop.untopA_eq_untop WithTop.coe_ne_top,WithTop.untop_coe] |
| have hr : (signSum x (n+1):ℝ) ≤ 0 := by exact_mod_cast (by omega : signSum x (n+1) ≤ 0) |
| linarith |
|
|
| lemma stoppedDefect_integral (P : Parameters) (n : ℕ) : |
| ∫ x,stoppedDefect n x ∂streamLaw P ℕ=1 := by |
| have he := (stoppedDefect_martingale P).setIntegral_eq (Nat.zero_le n) MeasurableSet.univ |
| simp only [Measure.restrict_univ] at he |
| rw [← he] |
| have he0 : stoppedDefect 0=fun x => 1-((x 0).increment:ℝ) := by |
| ext x |
| simp [stoppedDefect,stoppedProcess,signSum] |
| have hi : Integrable (fun x : ℕ → Letter => ((x 0).increment:ℝ)) (streamLaw P ℕ) := by |
| simpa [signSum] using (raw_sign_martingale P).integrable 0 |
| rw [he0,integral_sub (integrable_const _) hi] |
| have hz := ((measurePreserving_eval_infinitePi (fun _ : ℕ => (law P).toMeasure) 0).hasLaw.integral_comp |
| (f := fun a : Letter => (a.increment:ℝ)) (measurable_of_countable _).aestronglyMeasurable).trans |
| (integral_increment P) |
| change ∫ x,((x 0).increment:ℝ) ∂streamLaw P ℕ=0 at hz |
| simp only [integral_const,probReal_univ,one_smul,hz,sub_zero] |
|
|
| lemma measurableSet_firstSurvivor_eq (n : ℕ) : |
| MeasurableSet {x | firstSurvivor x=WithTop.some n} := |
| rawFiltration.le n _ (firstSurvivor_stopping.measurableSet_eq n) |
|
|
| lemma measurableSet_firstSurvivor_finite : MeasurableSet {x | firstSurvivor x ≠ ⊤} := by |
| have he : {x | firstSurvivor x ≠ ⊤}=⋃ n : ℕ,{x | firstSurvivor x=WithTop.some n} := by |
| ext x |
| simp only [Set.mem_ofPred_eq,Set.mem_iUnion] |
| exact WithTop.ne_top_iff_exists.trans (by simp only [eq_comm]) |
| rw [he] |
| exact MeasurableSet.iUnion measurableSet_firstSurvivor_eq |
|
|
| lemma measurable_firstSurvivor : Measurable firstSurvivor := by |
| apply measurable_to_countable' |
| intro n |
| obtain rfl | ⟨n,rfl⟩ := eq_or_ne n ⊤ |>.imp_right (fun h => WithTop.ne_top_iff_exists.mp h) |
| · convert measurableSet_firstSurvivor_finite.compl using 1 |
| ext x |
| simp |
| · exact measurableSet_firstSurvivor_eq n |
|
|
| def K (x : ℕ → Letter) : ℕ := |
| if firstSurvivor x=⊤ then 0 else |
| (reduce (revealed x ((firstSurvivor x).untopD 0+1))).orders.length |
|
|
| lemma K_of_hit {x : ℕ → Letter} {n : ℕ} (h : firstSurvivor x=WithTop.some n) : |
| K x=(reduce (revealed x (n+1))).orders.length := by |
| simp only [K,h,WithTop.coe_ne_top,ite_false] |
| rfl |
|
|
| lemma measurable_K : Measurable K := by |
| have hm (n : ℕ) : Measurable (fun x : ℕ → Letter => (reduce (revealed x (n+1))).orders.length) := |
| (prefix_measurable n (fun y => (reduce (List.ofFn y).reverse).orders.length)).mono |
| (rawFiltration.le n) le_rfl |
| have hp : Measurable (fun x : ℕ → Letter => |
| (reduce (revealed x ((firstSurvivor x).untopD 0+1))).orders.length) := |
| (measurable_from_prod_countable_right (f := fun z : ℕ × (ℕ → Letter) => |
| (reduce (revealed z.2 (z.1+1))).orders.length) hm).comp |
| (((measurable_of_countable (fun n : WithTop ℕ => n.untopD 0)).comp measurable_firstSurvivor).prodMk measurable_id) |
| exact measurable_const.ite (measurableSet_eq_fun measurable_firstSurvivor measurable_const) hp |
|
|
| lemma stoppedDefect_eq_K {n : ℕ} {x : ℕ → Letter} |
| (h : firstSurvivor x ≤ WithTop.some n) : stoppedDefect n x=K x := by |
| obtain ⟨k,hk⟩ := WithTop.ne_top_iff_exists.mp (ne_top_of_le_ne_top WithTop.coe_ne_top h) |
| have hk' : firstSurvivor x=WithTop.some k := hk.symm |
| obtain ⟨b,hb,_⟩ := firstSurvivor_shape hk' |
| have hs := reduce_imbalance (revealed x (k+1)) |
| rw [hb,imbalance,revealed_sum] at hs |
| simp only [List.length_singleton,Nat.cast_one] at hs |
| change 1-(signSum x ((min (WithTop.some n) (firstSurvivor x)).untopA+1):ℝ)=(K x:ℝ) |
| rw [min_eq_right h,hk',WithTop.untopA_eq_untop WithTop.coe_ne_top,WithTop.untop_coe,K_of_hit hk',hb] |
| dsimp only |
| have hr : (signSum x (k+1):ℝ)=1-(((reduce (revealed x k)).orders.length):ℝ) := by |
| exact_mod_cast hs.symm |
| rw [hr] |
| ring |
|
|
| lemma stoppedDefect_tendsto (P : Parameters) : |
| ∀ᵐ x ∂streamLaw P ℕ,Tendsto (fun n => stoppedDefect n x) atTop (𝓝 (K x:ℝ)) := by |
| filter_upwards [firstSurvivor_finite P] with x hx |
| obtain ⟨k,hk⟩ := WithTop.ne_top_iff_exists.mp hx |
| apply tendsto_const_nhds.congr' |
| filter_upwards [eventually_ge_atTop k] with n hn |
| exact (stoppedDefect_eq_K (by rw [← hk]; exact WithTop.coe_le_coe.mpr hn)).symm |
|
|
| /-- The source first optional-stopping bound, without any finite-mean |
| hypothesis on the stopping time. -/ |
| theorem K_lintegral_le_one (P : Parameters) : |
| ∫⁻ x,ENNReal.ofReal (K x:ℝ) ∂streamLaw P ℕ ≤ 1 := by |
| have hm (n : ℕ) : Measurable (fun x => ENNReal.ofReal (stoppedDefect n x)) := |
| (((stoppedDefect_martingale P).stronglyMeasurable n).measurable.mono (rawFiltration.le n) le_rfl).ennreal_ofReal |
| have hb (n : ℕ) : ∫⁻ x,ENNReal.ofReal (stoppedDefect n x) ∂streamLaw P ℕ=1 := by |
| rw [← ofReal_integral_eq_lintegral_ofReal ((stoppedDefect_martingale P).integrable n) |
| (Filter.Eventually.of_forall (stoppedDefect_nonneg n)),stoppedDefect_integral] |
| simp |
| have he : (fun x => ENNReal.ofReal (K x:ℝ)) =ᵐ[streamLaw P ℕ] |
| (fun x => liminf (fun n => ENNReal.ofReal (stoppedDefect n x)) atTop) := by |
| filter_upwards [stoppedDefect_tendsto P] with x hx |
| exact (ENNReal.continuous_ofReal.continuousAt.tendsto.comp hx).liminf_eq.symm |
| rw [lintegral_congr_ae he] |
| exact (lintegral_liminf_le hm).trans_eq (by simp only [hb,liminf_const]) |
|
|
| theorem integrable_K (P : Parameters) : Integrable (fun x => (K x:ℝ)) (streamLaw P ℕ) := by |
| apply (lintegral_ofReal_ne_top_iff_integrable |
| ((measurable_of_countable (fun k : ℕ => (k:ℝ))).comp measurable_K).aestronglyMeasurable (Filter.Eventually.of_forall (fun x => Nat.cast_nonneg (K x)))).mp |
| exact ne_top_of_le_ne_top (by norm_num) (K_lintegral_le_one P) |
|
|
| theorem integral_K_le_one (P : Parameters) : ∫ x,(K x:ℝ) ∂streamLaw P ℕ ≤ 1 := by |
| have h := K_lintegral_le_one P |
| rw [← ofReal_integral_eq_lintegral_ofReal (integrable_K P) |
| (Filter.Eventually.of_forall (fun x => Nat.cast_nonneg (K x)))] at h |
| exact (ENNReal.ofReal_le_ofReal_iff (by norm_num)).mp (by simpa using h) |
|
|
| end FKCRT.Inventory |
| end |
|
|
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.Inventory |
|
|
| def typeSign (b : Bool) : ℤ := if b then 1 else -1 |
| lemma typeSign_not (b : Bool) : typeSign (!b)= -typeSign b := by cases b <;> norm_num [typeSign] |
| lemma abs_typeSign (b : Bool) : |typeSign b|=1 := by cases b <;> norm_num [typeSign] |
| lemma typeSign_sq (b : Bool) : typeSign b^2=1 := by cases b <;> norm_num [typeSign] |
|
|
| def orderType (o : Order) (t : Bool) : Bool := o.getD t |
|
|
| def assignedSign (a : Letter × Bool) : ℤ := match a.1 with |
| | .burger b => typeSign b |
| | .order o => -typeSign (orderType o a.2) |
|
|
| lemma abs_assignedSign (a : Letter × Bool) : |assignedSign a|=1 := by |
| rcases a with ⟨a,t⟩ |
| cases a <;> simp [assignedSign,abs_typeSign] |
|
|
| structure TypedEvaluation where |
| orders : List (Order × Bool) |
| burgers : List Bool |
|
|
| def TypedEvaluation.erase (e : TypedEvaluation) : Evaluation := |
| ⟨e.orders.map Prod.fst,e.burgers⟩ |
|
|
| def typedStep (e : TypedEvaluation) (a : Letter × Bool) : TypedEvaluation := match a.1 with |
| | .burger b => ⟨e.orders,b::e.burgers⟩ |
| | .order o => match pop o e.burgers with |
| | some bs => ⟨e.orders,bs⟩ |
| | none => ⟨e.orders++[(o,a.2)],e.burgers⟩ |
|
|
| def typedRun : List (Letter × Bool) → TypedEvaluation → TypedEvaluation |
| | [],e => e |
| | a::w,e => typedRun w (typedStep e a) |
|
|
| def validStep (s : List Bool) (a : Letter × Bool) : Prop := |
| a.1=.order none → (s=[] ∨ s.head?=some a.2) |
|
|
| def ValidTyping : List (Letter × Bool) → List Bool → Prop |
| | [],_ => True |
| | a::w,s => validStep s a ∧ ValidTyping w (step ⟨[],s⟩ a.1).burgers |
|
|
| lemma erase_typedStep (e : TypedEvaluation) (a : Letter × Bool) : |
| (typedStep e a).erase=step e.erase a.1 := by |
| rcases a with ⟨a,t⟩ |
| cases a with |
| | burger b => rfl |
| | order o => |
| simp only [typedStep,step,TypedEvaluation.erase] |
| cases pop o e.burgers <;> simp |
|
|
| lemma erase_typedRun (w : List (Letter × Bool)) (e : TypedEvaluation) : |
| (typedRun w e).erase=run (w.map Prod.fst) e.erase := by |
| induction w generalizing e with |
| | nil => rfl |
| | cons a w ih => simp only [typedRun,ih,erase_typedStep,List.map_cons,run] |
|
|
| lemma typedStep_burgers (e : TypedEvaluation) (a : Letter × Bool) : |
| (typedStep e a).burgers=(step ⟨[],e.burgers⟩ a.1).burgers := by |
| rcases a with ⟨a,t⟩ |
| cases a with |
| | burger b => rfl |
| | order o => simp only [typedStep,step]; cases pop o e.burgers <;> rfl |
|
|
| lemma pop_sign_sum {o : Order} {s s' : List Bool} {t : Bool} |
| (h : pop o s=some s') (ht : o=none → s=[] ∨ s.head?=some t) : |
| (s.map typeSign).sum=(s'.map typeSign).sum+typeSign (orderType o t) := by |
| induction s generalizing s' with |
| | nil => simp [pop] at h |
| | cons b bs ih => |
| simp only [pop] at h |
| split_ifs at h with he |
| · simp only [Option.some.injEq] at h |
| subst s' |
| have hb : orderType o t=b := by |
| obtain rfl | ho := he |
| · obtain hf | hb := ht rfl |
| · simp at hf |
| · simpa [orderType] using (Option.some.inj (by simpa using hb)).symm |
| · simp [orderType,ho] |
| simp only [List.map_cons,List.sum_cons,hb] |
| omega |
| · cases hp : pop o bs with |
| | none => simp [hp] at h |
| | some cs => |
| simp only [hp,Option.map_some,Option.some.injEq] at h |
| subst s' |
| have hnone : o ≠ none := fun ho => he (Or.inl ho) |
| have hh := ih hp (fun ho => (hnone ho).elim) |
| simp only [List.map_cons,List.sum_cons] |
| omega |
|
|
| def typedImbalance (e : TypedEvaluation) : ℤ := |
| (e.burgers.map typeSign).sum-(e.orders.map (fun o => typeSign (orderType o.1 o.2))).sum |
|
|
| lemma typedStep_imbalance (e : TypedEvaluation) (a : Letter × Bool) |
| (h : validStep e.burgers a) : |
| typedImbalance (typedStep e a)=typedImbalance e+assignedSign a := by |
| rcases a with ⟨a,t⟩ |
| cases a with |
| | burger b => simp [typedStep,typedImbalance,assignedSign]; ring |
| | order o => |
| simp only [typedStep,assignedSign] |
| cases hp : pop o e.burgers with |
| | none => simp [typedImbalance]; ring |
| | some bs => |
| have hh := pop_sign_sum hp (fun ho => h (by rw [ho])) |
| simp only [typedImbalance] |
| dsimp only at * |
| omega |
|
|
| lemma typedRun_imbalance (w : List (Letter × Bool)) (e : TypedEvaluation) |
| (h : ValidTyping w e.burgers) : |
| typedImbalance (typedRun w e)=(w.map assignedSign).sum+typedImbalance e := by |
| induction w generalizing e with |
| | nil => simp [typedRun] |
| | cons a w ih => |
| rw [typedRun,ih (typedStep e a) (by simpa only [typedStep_burgers] using h.2),typedStep_imbalance e a h.1] |
| simp only [List.map_cons,List.sum_cons] |
| omega |
|
|
| lemma sum_typeSign_abs_le (l : List Bool) : |(l.map typeSign).sum| ≤ l.length := by |
| induction l with |
| | nil => simp |
| | cons b bs ih => |
| simpa only [List.map_cons,List.sum_cons,List.length_cons,Nat.cast_add,Nat.cast_one,abs_typeSign,add_comm] |
| using (abs_add_le (typeSign b) (bs.map typeSign).sum).trans (add_le_add (le_of_eq (abs_typeSign b)) ih) |
|
|
| lemma typed_orders_sum_abs_le (l : List (Order × Bool)) : |
| |(l.map (fun o => typeSign (orderType o.1 o.2))).sum| ≤ l.length := by |
| simpa only [List.map_map,List.length_map,Function.comp_def] using |
| sum_typeSign_abs_le (l.map (fun o => orderType o.1 o.2)) |
|
|
| lemma typedRun_no_survivor_bound (w : List (Letter × Bool)) (h : ValidTyping w []) |
| (h₀ : (reduce (w.map Prod.fst)).burgers=[]) : |
| |(w.map assignedSign).sum| ≤ ((reduce (w.map Prod.fst)).orders.length:ℤ) := by |
| let e := typedRun w ⟨[],[]⟩ |
| have he : e.erase=reduce (w.map Prod.fst) := erase_typedRun w ⟨[],[]⟩ |
| have hs : (w.map assignedSign).sum=typedImbalance e := by |
| simpa [typedImbalance] using (typedRun_imbalance w ⟨[],[]⟩ h).symm |
| have hb : e.burgers=[] := by |
| rw [← h₀,← he]; rfl |
| have hl : (reduce (w.map Prod.fst)).orders.length=e.orders.length := by |
| rw [← he]; simp [TypedEvaluation.erase] |
| rw [hl,hs,typedImbalance,hb] |
| simpa using typed_orders_sum_abs_le e.orders |
|
|
| lemma typed_orders_opposite_sum (l : List (Order × Bool)) (b : Bool) |
| (h : ∀ o∈l,o.1=some (!b)) : |
| (l.map (fun o => typeSign (orderType o.1 o.2))).sum= -(l.length:ℤ)*typeSign b := by |
| induction l with |
| | nil => simp |
| | cons o os ih => |
| rw [List.map_cons,List.sum_cons,ih (fun o ho => h o (by simp [ho]))] |
| rw [show orderType o.1 o.2= !b by simp [orderType,h o (by simp)],typeSign_not] |
| simp only [List.length_cons,Nat.cast_add,Nat.cast_one] |
| ring |
|
|
| lemma typedRun_first_survivor_sum (w : List (Letter × Bool)) (b : Bool) |
| (h : ValidTyping w []) (hb : (reduce (w.map Prod.fst)).burgers=[b]) |
| (ho : ∀ o∈(reduce (w.map Prod.fst)).orders,o=some (!b)) : |
| (w.map assignedSign).sum=typeSign b*(1+((reduce (w.map Prod.fst)).orders.length:ℤ)) := by |
| let e := typedRun w ⟨[],[]⟩ |
| have he : e.erase=reduce (w.map Prod.fst) := erase_typedRun w ⟨[],[]⟩ |
| have hs : (w.map assignedSign).sum=typedImbalance e := by |
| simpa [typedImbalance] using (typedRun_imbalance w ⟨[],[]⟩ h).symm |
| have hb' : e.burgers=[b] := by rw [← hb,← he]; rfl |
| have ho' : ∀ o∈e.orders,o.1=some (!b) := by |
| intro o hm |
| apply ho o.1 |
| rw [← he] |
| exact List.mem_map.mpr ⟨o,hm,rfl⟩ |
| have hl : (reduce (w.map Prod.fst)).orders.length=e.orders.length := by |
| rw [← he]; simp [TypedEvaluation.erase] |
| rw [hs,typedImbalance,hb',typed_orders_opposite_sum e.orders b ho',hl] |
| simp only [List.map_singleton,List.sum_singleton] |
| ring |
|
|
| lemma ValidTyping_append (w v : List (Letter × Bool)) (e : TypedEvaluation) : |
| ValidTyping (w++v) e.burgers ↔ ValidTyping w e.burgers ∧ ValidTyping v (typedRun w e).burgers := by |
| induction w generalizing e with |
| | nil => simp [ValidTyping,typedRun] |
| | cons a w ih => |
| simp only [List.cons_append,ValidTyping,typedRun] |
| rw [← typedStep_burgers e a,ih] |
| tauto |
|
|
| end FKCRT.Inventory |
| end |
|
|
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.Inventory |
|
|
| def Letter.flip : Letter → Letter |
| | .burger b => .burger (!b) |
| | .order o => .order (o.map Bool.not) |
|
|
| lemma Letter.flip_flip (a : Letter) : a.flip.flip=a := by |
| cases a with |
| | burger b => simp [Letter.flip] |
| | order o => cases o <;> simp [Letter.flip] |
|
|
| lemma eligible_flip (o : Order) (b : Bool) : eligible (o.map Bool.not) (!b) ↔ eligible o b := by |
| cases o with |
| | none => simp [eligible] |
| | some c => cases c <;> cases b <;> simp [eligible] |
|
|
| lemma pop_flip (o : Order) (s : List Bool) : |
| pop (o.map Bool.not) (s.map Bool.not)=(pop o s).map (List.map Bool.not) := by |
| induction s with |
| | nil => rfl |
| | cons b bs ih => |
| simp only [List.map_cons,pop,eligible_flip] |
| split_ifs <;> simp only [Option.map_some,ih,Option.map_map,Function.comp_def,List.map_cons] |
|
|
| def Evaluation.flip (e : Evaluation) : Evaluation := |
| ⟨e.orders.map (Option.map Bool.not),e.burgers.map Bool.not⟩ |
|
|
| lemma step_flip (e : Evaluation) (a : Letter) : step e.flip a.flip=(step e a).flip := by |
| cases a with |
| | burger b => rfl |
| | order o => |
| simp only [Letter.flip,Evaluation.flip,step,pop_flip] |
| cases pop o e.burgers <;> simp |
|
|
| lemma run_flip (w : List Letter) (e : Evaluation) : |
| run (w.map Letter.flip) e.flip=(run w e).flip := by |
| induction w generalizing e with |
| | nil => rfl |
| | cons a w ih => simp only [List.map_cons,run,step_flip,ih] |
|
|
| lemma reduce_flip (w : List Letter) : reduce (w.map Letter.flip)=(reduce w).flip := by |
| exact run_flip w ⟨[],[]⟩ |
|
|
| lemma burgers_flip_empty_iff (w : List Letter) : |
| (reduce (w.map Letter.flip)).burgers=[] ↔ (reduce w).burgers=[] := by |
| simp [reduce_flip,Evaluation.flip] |
|
|
| end FKCRT.Inventory |
| end |
|
|
| end OAI |
|
|
