| import OAI.Probability.FKMaps.LadderCuts |
| import OAI.Probability.FKMaps.StationaryCuts |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.Inventory |
| |
| instance : MeasurableSpace Order := ⊤ |
| instance : MeasurableSingletonClass Order := ⟨fun _ => trivial⟩ |
| instance : MeasurableSpace (List Order) := ⊤ |
| instance : MeasurableSingletonClass (List Order) := ⟨fun _ => trivial⟩ |
| |
| / |
| def intervalWord (x : ℤ → List Letter) (a : ℤ) (n : ℕ) : List Letter := |
| piecesPrefix (fun j => x (a+j)) n |
| lemma intervalWord_zero (x : ℤ → List Letter) (a : ℤ) : intervalWord x a 0=[] := rfl |
| lemma intervalWord_succ (x : ℤ → List Letter) (a : ℤ) (n : ℕ) : |
| intervalWord x a (n+1)=intervalWord x a n++x (a+n) := rfl |
| lemma intervalWord_add (x : ℤ → List Letter) (a : ℤ) (m n : ℕ) : |
| intervalWord x a (m+n)=intervalWord x a m++intervalWord x (a+m) n := by |
| rw [intervalWord,piecesPrefix_add] |
| congr 2 |
| funext j |
| dsimp only [piecesTail] |
| congr 1 |
| push_cast |
| ring |
| lemma intervalWord_measurable (a : ℤ) (n : ℕ) : Measurable (fun x : ℤ → List Letter => intervalWord x a n) := |
| (piecesPrefix_measurable n).comp (Measurable.of_eval (fun j => measurable_pi_apply (a+j))) |
| lemma intervalWord_shift (x : ℤ → List Letter) (a b : ℤ) (n : ℕ) : |
| intervalWord (Stationary.shift b x) a n=intervalWord x (a+b) n := by |
| unfold intervalWord |
| congr 1 |
| funext j |
| simp only [Stationary.shift] |
| congr 1 |
| omega |
| lemma intervalWord_net (x : ℤ → List Letter) (a : ℤ) (n : ℕ) (d : ℤ) |
| (hd : ∀ j,((x j).map Letter.increment).sum=d) : |
| ((intervalWord x a n).map Letter.increment).sum=(n:ℤ)*d := by |
| induction n with |
| | zero => simp [intervalWord_zero] |
| | succ n ih => rw [intervalWord_succ,List.map_append,List.sum_append,ih,hd]; push_cast; ring |
| |
| lemma reduce_append_no_burgers (u v : List Letter) (hu : (reduce u).burgers=[]) : |
| reduce (u++v)=⟨(reduce u).orders++(reduce v).orders,(reduce v).burgers⟩ := by |
| unfold reduce |
| rw [run_append] |
| have he : run u ⟨[],[]⟩=⟨(reduce u).orders,[]⟩ := by cases h : reduce u; simp_all [reduce] |
| rw [he] |
| simpa only [List.append_nil] using run_orders_prefix v (reduce u).orders (⟨[],[]⟩ : Evaluation) |
| lemma reduce_append_no_orders (u v : List Letter) (hv : (reduce v).orders=[]) : |
| reduce (u++v)=⟨(reduce u).orders,(reduce v).burgers++(reduce u).burgers⟩ := by |
| have h := run_orders_prefix v (reduce u).orders (⟨[],(reduce u).burgers⟩ : Evaluation) |
| simp only [List.append_nil] at h |
| rw [reduce,run_append] |
| rw [show run u ⟨[],[]⟩=⟨(reduce u).orders,(reduce u).burgers⟩ by rfl,h,run_older_supply,hv,evalOrders_nil] |
| simp only [List.append_nil] |
| |
| def leftCutAt (x : ℤ → List Letter) (a : ℤ) : Prop := ∀ n,(reduce (intervalWord x a n)).orders=[] |
| def rightCutAt (x : ℤ → List Letter) (b : ℤ) : Prop := ∀ n : ℕ,(reduce (intervalWord x (b-n) n)).burgers=[] |
| lemma leftCutAt_measurable (a : ℤ) : MeasurableSet {x | leftCutAt x a} := by |
| simp only [leftCutAt,Set.ofPred_forall] |
| exact MeasurableSet.iInter (fun n => (intervalWord_measurable a n) ((Set.to_countable {w : List Letter | (reduce w).orders=[]}).measurableSet)) |
| lemma rightCutAt_measurable (b : ℤ) : MeasurableSet {x | rightCutAt x b} := by |
| simp only [rightCutAt,Set.ofPred_forall] |
| exact MeasurableSet.iInter (fun n => (intervalWord_measurable (b-n) n) ((Set.to_countable {w : List Letter | (reduce w).burgers=[]}).measurableSet)) |
| lemma leftCutAt_shift (x : ℤ → List Letter) (a b : ℤ) : |
| leftCutAt (Stationary.shift b x) a ↔ leftCutAt x (a+b) := by |
| simp only [leftCutAt,intervalWord_shift] |
| lemma rightCutAt_shift (x : ℤ → List Letter) (a b : ℤ) : |
| rightCutAt (Stationary.shift b x) a ↔ rightCutAt x (a+b) := by |
| simp only [rightCutAt,intervalWord_shift] |
| have he (n : ℕ) : a-(n:ℤ)+b=a+b-n := by omega |
| simp only [he] |
| lemma no_burgers_interval {x : ℤ → List Letter} {a : ℤ} {n : ℕ} (h : rightCutAt x (a+n)) : |
| (reduce (intervalWord x a n)).burgers=[] := by simpa using h n |
| |
| def rightOrders (x : ℤ → List Letter) (a : ℤ) (n : ℕ) : List Order := (reduce (intervalWord x a n)).orders |
| lemma rightOrders_length {x : ℤ → List Letter} (hd : ∀ j,((x j).map Letter.increment).sum= -1) |
| (a : ℤ) (n : ℕ) (hb : rightCutAt x (a+n)) : (rightOrders x a n).length=n := by |
| have he := reduce_imbalance (intervalWord x a n) |
| rw [imbalance,no_burgers_interval hb,intervalWord_net x a n (-1) hd] at he |
| simp only [List.length_nil,Nat.cast_zero,zero_sub,mul_neg_one] at he |
| dsimp [rightOrders] |
| omega |
| lemma rightOrders_append {x : ℤ → List Letter} (a : ℤ) (m n : ℕ) |
| (hm : rightCutAt x (a+m)) : rightOrders x a (m+n)=rightOrders x a m++rightOrders x (a+m) n := by |
| simp only [rightOrders,intervalWord_add,reduce_append_no_burgers _ _ (no_burgers_interval hm)] |
| def rightOutput (x : ℤ → List Letter) (i : ℤ) : Order := CutOutput.output (rightCutAt x) (rightOrders x) none i |
| lemma rightOutput_measurable (i : ℤ) : Measurable (fun x => rightOutput x i) := by |
| apply CutOutput.output_measurable _ _ none i rightCutAt_measurable |
| intro a n |
| exact (measurable_of_countable (fun w : List Letter => (reduce w).orders)).comp (intervalWord_measurable a n) |
| lemma rightOutput_shift (x : ℤ → List Letter) (a i : ℤ) : |
| rightOutput (Stationary.shift a x) i=rightOutput x (i+a) := by |
| have hc : rightCutAt (Stationary.shift a x)=fun j => rightCutAt x (j+a) := by |
| funext j; exact propext (rightCutAt_shift x j a) |
| have hw : rightOrders (Stationary.shift a x)=fun j n => rightOrders x (j+a) n := by |
| funext j n; simp only [rightOrders,intervalWord_shift] |
| exact (show CutOutput.output (rightCutAt (Stationary.shift a x)) (rightOrders (Stationary.shift a x)) none i=_ by |
| rw [hc,hw,CutOutput.output_translate]; rfl) |
| def rightOutputData (x : ℤ → List Letter) (hd : ∀ j,((x j).map Letter.increment).sum= -1) : CutOutput.Data Order where |
| cut := rightCutAt x |
| word := rightOrders x |
| length a n _ hb := rightOrders_length hd a n hb |
| append a m n _ hm _ := rightOrders_append a m n hm |
| lemma rightOutput_segment {x : ℤ → List Letter} (hd : ∀ j,((x j).map Letter.increment).sum= -1) |
| (a : ℤ) (n : ℕ) (ha : rightCutAt x a) (hb : rightCutAt x (a+n)) : |
| List.ofFn (fun j : Fin n => rightOutput x (a+j))=rightOrders x a n := |
| (rightOutputData x hd).output_segment none a n ha hb |
|
|
| end FKCRT.Inventory |
| end |
|
|
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.Inventory |
|
|
| def rightWord (x : ℕ → Letter) : List Letter := (reverseRightWord x).reverse |
| def rightLaw (P : Parameters) : Measure (List Letter) := (reverseRightLaw P).map List.reverse |
| lemma rightWord_measurable : Measurable rightWord := (measurable_of_countable List.reverse).comp reverseRightWord_measurable |
| lemma rightLaw_eq (P : Parameters) : rightLaw P=(streamLaw P ℕ).map rightWord := by |
| rw [rightLaw,reverseRightLaw,Measure.map_map (measurable_of_countable List.reverse) reverseRightWord_measurable] |
| rfl |
| instance rightLaw_probability (P : Parameters) : IsProbabilityMeasure (rightLaw P) := |
| inferInstanceAs (IsProbabilityMeasure ((reverseRightLaw P).map List.reverse)) |
| lemma rightLaw_reverse (P : Parameters) : (rightLaw P).map List.reverse=reverseRightLaw P := by |
| rw [rightLaw,Measure.map_map (measurable_of_countable List.reverse) (measurable_of_countable List.reverse)] |
| simp only [Function.comp_def,List.reverse_reverse] |
| exact Measure.map_id |
| lemma rightLaw_net (P : Parameters) : ∀ᵐ w ∂rightLaw P,(w.map Letter.increment).sum= -1 := by |
| rw [rightLaw_eq,ae_map_iff rightWord_measurable.aemeasurable ((Set.to_countable _).measurableSet)] |
| simpa only [rightWord,List.map_reverse,List.sum_reverse] using reverseRightWord_net P |
| lemma rightSeq_net (P : Parameters) : ∀ᵐ x ∂Stationary.seqLaw (rightLaw P),∀ j,((x j).map Letter.increment).sum= -1 := by |
| apply ae_all_iff.mpr |
| intro j |
| exact (measurePreserving_eval_infinitePi (fun _ : ℤ => rightLaw P) j).quasiMeasurePreserving.ae (rightLaw_net P) |
| |
| def reversedPast (x : ℤ → List Letter) : ℕ → List Letter := fun j => (x (-1-j)).reverse |
| lemma reversedPast_measurable : Measurable reversedPast := |
| Measurable.of_eval (fun j => (measurable_of_countable List.reverse).comp (measurable_pi_apply (-1-(j:ℤ)))) |
| lemma reversedPast_preserving (P : Parameters) : |
| MeasurePreserving reversedPast (Stationary.seqLaw (rightLaw P)) (naturalPiecesLaw (reverseRightLaw P)) := by |
| let f : (ℤ → List Letter) → (ℕ → List Letter) := fun x j => x (-1-j) |
| have hf : MeasurePreserving f (Stationary.seqLaw (rightLaw P)) (naturalPiecesLaw (rightLaw P)) := by |
| refine ⟨Measurable.of_eval (fun j => measurable_pi_apply (-1-(j:ℤ))),?_⟩ |
| exact Measure.map_infinitePi_infinitePi_of_inj (fun i j h => by omega) |
| have hg : MeasurePreserving (fun x : ℕ → List Letter => fun j => (x j).reverse) |
| (naturalPiecesLaw (rightLaw P)) (naturalPiecesLaw (reverseRightLaw P)) := by |
| refine ⟨Measurable.of_eval (fun j => (measurable_of_countable List.reverse).comp (measurable_pi_apply j)),?_⟩ |
| change (Measure.infinitePi _).map _=Measure.infinitePi _ |
| rw [Measure.infinitePi_map_pi (fun _ : ℕ => rightLaw P) (fun _ => measurable_of_countable List.reverse)] |
| simp only [rightLaw_reverse] |
| exact hg.comp hf |
| lemma intervalWord_first (x : ℤ → List Letter) (a : ℤ) (n : ℕ) : |
| intervalWord x a (n+1)=x a++intervalWord x (a+1) n := by |
| rw [show n+1=1+n by omega,intervalWord_add] |
| simp only [intervalWord_succ,intervalWord_zero,List.nil_append,Nat.cast_zero,add_zero,Nat.cast_one] |
| lemma reversedPast_prefix (x : ℤ → List Letter) (n : ℕ) : |
| (piecesPrefix (reversedPast x) n).reverse=intervalWord x (-(n:ℤ)) n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| rw [piecesPrefix,List.reverse_append,ih,intervalWord_first] |
| simp only [reversedPast,List.reverse_reverse,Nat.cast_add,Nat.cast_one] |
| rw [show -((n:ℤ)+1)= -1-n by omega, |
| show -1-(n:ℤ)+1= -n by omega] |
| lemma rightCutAt_zero_iff (x : ℤ → List Letter) : rightCutAt x 0 ↔ RightCut (reversedPast x) := by |
| simp only [rightCutAt,RightCut,reversedPast_prefix,zero_sub] |
| lemma rightCutAt_positive (P : Parameters) : 0<Stationary.seqLaw (rightLaw P) {x | rightCutAt x 0} := by |
| have he := (reversedPast_preserving P).measure_preimage measurableSet_rightCut.nullMeasurableSet |
| have hs : {x | rightCutAt x 0}=reversedPast ⁻¹' {x | RightCut x} := by ext x; exact rightCutAt_zero_iff x |
| rw [hs,he] |
| exact positive_rightCut P |
| |
| lemma rightWord_of_order {x : ℕ → Letter} {o : Order} (hx : x 0=Letter.order o) : |
| rightWord x=[Letter.order o] := by |
| have hh : firstDown 1 x=WithTop.some 0 := by |
| rw [firstDown_of_hit_iff] |
| constructor |
| · simp [signSum,hx,Letter.increment] |
| · intro j hj; omega |
| simp [rightWord,reverseRightWord,stoppedWord_of_hit hh,revealed,hx] |
| lemma rightLaw_order_positive (P : Parameters) (o : Order) : 0<rightLaw P {[Letter.order o]} := by |
| rw [rightLaw_eq,Measure.map_apply rightWord_measurable (measurableSet_singleton _)] |
| have hle : streamLaw P ℕ {x | x 0=Letter.order o} ≤ streamLaw P ℕ (rightWord ⁻¹' {[Letter.order o]}) := |
| measure_mono (fun x hx => rightWord_of_order hx) |
| have he : streamLaw P ℕ {x | x 0=Letter.order o}=(law P).toMeasure {Letter.order o} := |
| (measurePreserving_eval_infinitePi (fun _ : ℕ => (law P).toMeasure) 0).measure_preimage |
| (measurableSet_singleton (Letter.order o)).nullMeasurableSet |
| rw [he,law_singleton] at hle |
| exact (ENNReal.ofReal_pos.mpr (mass_pos P _)).trans_le hle |
| |
| lemma increment_flip (a : Letter) : a.flip.increment=a.increment := by cases a <;> rfl |
| lemma signSum_flip (x : ℕ → Letter) (n : ℕ) : signSum (flipStream x) n=signSum x n := by |
| simp only [signSum,flipStream,increment_flip] |
| lemma firstDown_flip (h : ℕ) (x : ℕ → Letter) : firstDown h (flipStream x)=firstDown h x := by |
| apply eq_of_forall_ge_iff |
| intro n |
| cases n with |
| | top => simp |
| | coe n => simp only [firstDown,TreeCoding.firstZero_le_iff,downPath,signSum_flip] |
| lemma rightWord_flip (x : ℕ → Letter) : rightWord (flipStream x)=(rightWord x).map Letter.flip := by |
| simp only [rightWord,reverseRightWord,stoppedWord,firstDown_flip,revealed_flip,List.map_reverse] |
| lemma rightLaw_flip_preserving (P : Parameters) : |
| MeasurePreserving (List.map Letter.flip) (rightLaw P) (rightLaw P) := by |
| refine ⟨measurable_of_countable _,?_⟩ |
| rw [rightLaw_eq,Measure.map_map (measurable_of_countable _) rightWord_measurable] |
| have he : List.map Letter.flip ∘ rightWord=rightWord ∘ flipStream := by funext x; exact (rightWord_flip x).symm |
| rw [he,← Measure.map_map rightWord_measurable measurable_flipStream,(flipStream_preserving P).map_eq] |
| |
| end FKCRT.Inventory |
| end |
| |
| |
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.Inventory |
| |
| def flipPieceSeq (x : ℤ → List Letter) : ℤ → List Letter := fun j => (x j).map Letter.flip |
| lemma flipPieceSeq_measurable : Measurable flipPieceSeq := |
| Measurable.of_eval (fun j => (measurable_of_countable _).comp (measurable_pi_apply j)) |
| lemma flipPieceSeq_preserving (P : Parameters) : |
| MeasurePreserving flipPieceSeq (Stationary.seqLaw (rightLaw P)) (Stationary.seqLaw (rightLaw P)) := by |
| refine ⟨flipPieceSeq_measurable,?_⟩ |
| change (Measure.infinitePi _).map (fun x : ℤ → List Letter => fun j => (x j).map Letter.flip)=Measure.infinitePi _ |
| rw [Measure.infinitePi_map_pi (fun _ : ℤ => rightLaw P) (fun _ => measurable_of_countable (List.map Letter.flip))] |
| simp only [(rightLaw_flip_preserving P).map_eq] |
| lemma intervalWord_flip (x : ℤ → List Letter) (a : ℤ) (n : ℕ) : |
| intervalWord (flipPieceSeq x) a n=(intervalWord x a n).map Letter.flip := by |
| induction n with |
| | zero => rfl |
| | succ n ih => simp only [intervalWord_succ,ih,flipPieceSeq,List.map_append] |
| lemma rightCutAt_flip (x : ℤ → List Letter) (a : ℤ) : rightCutAt (flipPieceSeq x) a ↔ rightCutAt x a := by |
| simp only [rightCutAt,intervalWord_flip,burgers_flip_empty_iff] |
| lemma rightOrders_flip (x : ℤ → List Letter) (a : ℤ) (n : ℕ) : |
| rightOrders (flipPieceSeq x) a n=(rightOrders x a n).map (Option.map Bool.not) := by |
| simp only [rightOrders,intervalWord_flip,reduce_flip,Evaluation.flip] |
| lemma rightOutput_flip (x : ℤ → List Letter) (i : ℤ) : |
| rightOutput (flipPieceSeq x) i=(rightOutput x i).map Bool.not := by |
| have hc : rightCutAt (flipPieceSeq x)=rightCutAt x := by funext j; exact propext (rightCutAt_flip x j) |
| unfold rightOutput CutOutput.output |
| rw [hc,rightOrders_flip,List.getElem?_map] |
| exact Option.getD_map (Option.map Bool.not) none _ |
| |
| lemma rightCutAt_zero_past_measurable : |
| MeasurableSet[Stationary.coords (α := List Letter) {j | j<0}] {x | rightCutAt x 0} := by |
| have hm : Measurable[Stationary.coords (α := List Letter) {j | j<0}] reversedPast := by |
| let : MeasurableSpace (ℤ → List Letter) := Stationary.coords {j | j<0} |
| apply Measurable.of_eval |
| intro j |
| apply (measurable_of_countable List.reverse).comp |
| apply measurable_iff_comap_le.mpr |
| exact le_iSup_of_le (-1-(j:ℤ)) (le_iSup_of_le (show -1-(j:ℤ)<0 by omega) le_rfl) |
| have hs : {x | rightCutAt x 0}=reversedPast ⁻¹' {x | RightCut x} := by ext x; exact rightCutAt_zero_iff x |
| rw [hs] |
| exact hm measurableSet_rightCut |
| lemma rightCutAt_one_of_order {x : ℤ → List Letter} (hc : rightCutAt x 0) {o : Order} |
| (hx : x 0=[Letter.order o]) : rightCutAt x 1 := by |
| intro n |
| cases n with |
| | zero => simp [intervalWord_zero,reduce,run] |
| | succ n => |
| rw [intervalWord_succ] |
| have ha : (1:ℤ)-(n+1)= -(n:ℤ) := by omega |
| have hb : (1:ℤ)-(n+1)+n=0 := by omega |
| simp only [Nat.cast_add,Nat.cast_one] |
| rw [hb,hx,ha] |
| have hh : (reduce (intervalWord x (-(n:ℤ)) n)).burgers=[] := by simpa using hc n |
| exact append_order_no_burgers hh o |
| lemma rightOutput_of_cut_order {x : ℤ → List Letter} (hc : rightCutAt x 0) {o : Order} |
| (hx : x 0=[Letter.order o]) : rightOutput x 0=o := by |
| have hd := rightCutAt_one_of_order hc hx |
| have hl : CutOutput.left (rightCutAt x) 0=0 := by |
| apply Nat.eq_zero_of_le_zero |
| exact CutOutput.firstIndex_le (p := fun k => rightCutAt x (0-k)) (k := 0) (by simpa using hc) |
| have hr : CutOutput.right (rightCutAt x) 0=0 := by |
| apply Nat.eq_zero_of_le_zero |
| exact CutOutput.firstIndex_le (p := fun k => rightCutAt x (0+1+k)) (k := 0) (by simpa using hd) |
| simp [rightOutput,CutOutput.output,hl,hr,rightOrders,intervalWord_succ,intervalWord_zero,hx,reduce,run,step,pop] |
| lemma rightOutput_flexible_positive (P : Parameters) : |
| 0<Stationary.seqLaw (rightLaw P) {x | rightOutput x 0=none} := by |
| let A : Set (ℤ → List Letter) := {x | rightCutAt x 0} |
| let B : Set (ℤ → List Letter) := {x | x 0=[Letter.order none]} |
| have hB : MeasurableSet[Stationary.coords (α := List Letter) {j | 0 ≤ j}] B := by |
| have hm : Measurable[Stationary.coords (α := List Letter) {j | 0 ≤ j}] (fun x : ℤ → List Letter => x 0) := by |
| apply measurable_iff_comap_le.mpr |
| exact le_iSup_of_le 0 (le_iSup_of_le (show (0:ℤ) ≤ 0 by omega) le_rfl) |
| exact hm (measurableSet_singleton _) |
| have hi := Stationary.indep_coords (rightLaw P) (S := {j | j<0}) (R := {j | 0 ≤ j}) |
| (Set.disjoint_left.mpr (fun j hj hj' => by change j<0 at hj; change 0 ≤ j at hj'; omega)) |
| have he := (indep_iff_forall_indepSet _).mp hi A B rightCutAt_zero_past_measurable hB |>.measure_inter_eq_mul |
| have hBp : 0<Stationary.seqLaw (rightLaw P) B := by |
| have hh := (measurePreserving_eval_infinitePi (fun _ : ℤ => rightLaw P) 0).measure_preimage |
| (measurableSet_singleton [Letter.order none]).nullMeasurableSet |
| change Stationary.seqLaw (rightLaw P) B=rightLaw P {[Letter.order none]} at hh |
| rw [hh] |
| exact rightLaw_order_positive P none |
| have hpos : 0<Stationary.seqLaw (rightLaw P) (A∩B) := by rw [he]; exact ENNReal.mul_pos_iff.mpr ⟨rightCutAt_positive P,hBp⟩ |
| exact hpos.trans_le (measure_mono (fun x hx => rightOutput_of_cut_order hx.1 hx.2)) |
| |
| def outputIndicator (o : Order) (x : ℤ → List Letter) : ℝ := if rightOutput x 0=o then 1 else 0 |
| lemma outputIndicator_measurable (o : Order) : Measurable (outputIndicator o) := by |
| apply Measurable.ite (measurableSet_eq_fun (rightOutput_measurable 0) measurable_const) measurable_const measurable_const |
| lemma outputIndicator_integrable (P : Parameters) (o : Order) : Integrable (outputIndicator o) (Stationary.seqLaw (rightLaw P)) := by |
| apply (integrable_const (1:ℝ)).mono' (outputIndicator_measurable o).aestronglyMeasurable |
| filter_upwards [] with x |
| simp only [outputIndicator] |
| split_ifs <;> norm_num |
| |
| def outputMass (P : Parameters) (o : Order) : ℝ := ∫ x,outputIndicator o x ∂Stationary.seqLaw (rightLaw P) |
| lemma outputMass_eq_measure (P : Parameters) (o : Order) : |
| outputMass P o=(Stationary.seqLaw (rightLaw P) {x | rightOutput x 0=o}).toReal := by |
| simpa only [outputMass,outputIndicator,Set.indicator,Pi.one_apply,Measure.real,Set.mem_ofPred_eq] using |
| integral_indicator_one (μ := Stationary.seqLaw (rightLaw P)) (s := {x | rightOutput x 0=o}) |
| (measurableSet_eq_fun (rightOutput_measurable 0) measurable_const) |
| lemma outputMass_flexible_pos (P : Parameters) : 0<outputMass P none := by |
| rw [outputMass_eq_measure] |
| exact ENNReal.toReal_pos (ne_of_gt (rightOutput_flexible_positive P)) (measure_ne_top _ _) |
| lemma outputMass_fixed_eq (P : Parameters) : outputMass P (some false)=outputMass P (some true) := by |
| have hh := (flipPieceSeq_preserving P).hasLaw.integral_comp (outputIndicator_measurable (some false)).aestronglyMeasurable |
| have hf (x : ℤ → List Letter) : outputIndicator (some false) (flipPieceSeq x)=outputIndicator (some true) x := by |
| simp only [outputIndicator,rightOutput_flip] |
| cases h : rightOutput x 0 with |
| | none => simp |
| | some b => cases b <;> simp |
| simpa only [Function.comp_apply,hf,outputMass] using hh.symm |
| lemma outputMass_sum (P : Parameters) : outputMass P none+outputMass P (some false)+outputMass P (some true)=1 := by |
| have hp (x : ℤ → List Letter) : outputIndicator none x+outputIndicator (some false) x+outputIndicator (some true) x=1 := by |
| simp only [outputIndicator] |
| cases h : rightOutput x 0 with |
| | none => |
| have h₀ : (none : Order) ≠ some false := by intro h; cases h |
| have h₁ : (none : Order) ≠ some true := by intro h; cases h |
| simp only [h₀,h₁,ite_true,ite_false,add_zero] |
| | some b => cases b <;> simp only [Option.some_ne_none,Option.some.injEq,Bool.false_eq_true,Bool.true_eq_false,ite_false,ite_true,zero_add,add_zero] |
| have hi := integral_congr_ae (μ := Stationary.seqLaw (rightLaw P)) (Filter.Eventually.of_forall hp) |
| have ha := integral_add ((outputIndicator_integrable P none).add (outputIndicator_integrable P (some false))) |
| (outputIndicator_integrable P (some true)) |
| simp only [Pi.add_apply] at ha |
| rw [ha,integral_add (outputIndicator_integrable P none) (outputIndicator_integrable P (some false))] at hi |
| simpa [outputMass] using hi |
| lemma outputMass_fixed (P : Parameters) (b : Bool) : outputMass P (some b)=(1-outputMass P none)/2 := by |
| have h₁ := outputMass_fixed_eq P |
| have h₂ := outputMass_sum P |
| cases b <;> linarith |
| |
| theorem rightOutput_frequencies (P : Parameters) (o : Order) : |
| ∀ᵐ x ∂Stationary.seqLaw (rightLaw P), |
| Tendsto (fun n => (∑ j∈Finset.range n,if rightOutput x (j:ℤ)=o then (1:ℝ) else 0)/(n:ℝ)) atTop (𝓝 (outputMass P o)) := by |
| have hh := Stationary.iid_shift_strong_law (rightLaw P) (outputIndicator_measurable o) (outputIndicator_integrable P o) |
| filter_upwards [hh] with x hx |
| simpa only [Stationary.average,Stationary.shift_iterate,outputIndicator,rightOutput_shift,zero_add,outputMass] using hx |
| |
| end FKCRT.Inventory |
| end |
| |
| |
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.CutOutput |
| open Classical |
| |
| / |
| def count (C : ℕ → Prop) (n : ℕ) : ℕ := by |
| classical |
| exact ∑ i∈Finset.range n,if C i then 1 else 0 |
| def last (C : ℕ → Prop) (n : ℕ) : ℕ := by |
| classical |
| exact Nat.findGreatest C n |
| lemma last_le (C : ℕ → Prop) (n : ℕ) : last C n ≤ n := Nat.findGreatest_le _ |
| lemma last_spec {C : ℕ → Prop} (hC : C 0) (n : ℕ) : C (last C n) := Nat.findGreatest_spec (Nat.zero_le n) hC |
| lemma count_le (C : ℕ → Prop) (n : ℕ) : count C n ≤ n := by |
| classical |
| calc |
| _ ≤ ∑ _ ∈ Finset.range n,1 := Finset.sum_le_sum (fun j _ => by split_ifs <;> omega) |
| _ = n := by simp |
| lemma count_at_last (C : ℕ → Prop) (n : ℕ) : count C (last C n+1)=count C (n+1) := by |
| classical |
| apply Finset.sum_subset (Finset.range_mono (by have := last_le C n; omega)) |
| intro j hj hj' |
| have hjle : j ≤ n := by have := Finset.mem_range.mp hj; omega |
| have hjgt : last C n<j := by have := Finset.mem_range.not.mp hj'; omega |
| have hn : ¬C j := Nat.findGreatest_is_greatest hjgt hjle |
| simp [hn] |
| lemma countReal (C : ℕ → Prop) (n : ℕ) : |
| (count C n:ℝ)=∑ i∈Finset.range n,if C i then (1:ℝ) else 0 := by |
| classical |
| simp only [count,Nat.cast_sum] |
| apply Finset.sum_congr rfl |
| intro i hi |
| split_ifs <;> norm_num |
| |
| / |
| lemma last_tendsto (C : ℕ → Prop) {δ : ℝ} (hδ : 0<δ) |
| (hd : Tendsto (fun n => (count C n:ℝ)/(n:ℝ)) atTop (𝓝 δ)) : |
| Tendsto (fun n => last C n+1) atTop atTop := by |
| have hshift : Tendsto (fun n : ℕ => n+1) atTop atTop := tendsto_add_atTop_nat 1 |
| have hc : Tendsto (fun n => (count C (n+1):ℝ)) atTop atTop := by |
| have hm := (hd.comp hshift).pos_mul_atTop hδ (tendsto_natCast_atTop_atTop.comp hshift) |
| convert hm using 1 |
| funext n |
| exact (div_mul_cancel₀ _ (by positivity : ((n+1:ℕ):ℝ)≠0)).symm |
| rw [← tendsto_natCast_atTop_iff (R := ℝ)] |
| apply tendsto_atTop_mono (fun n => ?_) hc |
| rw [← count_at_last C n] |
| exact_mod_cast count_le C (last C n+1) |
| |
| lemma last_ratio (C : ℕ → Prop) {δ : ℝ} (hδ : 0<δ) |
| (hd : Tendsto (fun n => (count C n:ℝ)/(n:ℝ)) atTop (𝓝 δ)) : |
| Tendsto (fun n => ((last C n+1:ℕ):ℝ)/((n+1:ℕ):ℝ)) atTop (𝓝 1) := by |
| have hshift : Tendsto (fun n : ℕ => n+1) atTop atTop := tendsto_add_atTop_nat 1 |
| have ha := hd.comp hshift |
| have hb := hd.comp (last_tendsto C hδ hd) |
| have hdiv := ha.div hb (ne_of_gt hδ) |
| rw [div_self (ne_of_gt hδ)] at hdiv |
| apply hdiv.congr' |
| have hp := (tendsto_order.mp ha).1 0 hδ |
| filter_upwards [hp] with n hn |
| dsimp only [Function.comp_def,Pi.div_apply] at hn ⊢ |
| have hc : (count C (n+1):ℝ)≠0 := by intro hz; rw [hz,zero_div] at hn; exact lt_irrefl _ hn |
| rw [count_at_last] |
| field_simp |
| |
| lemma last_gap_ratio (C : ℕ → Prop) {δ : ℝ} (hδ : 0<δ) |
| (hd : Tendsto (fun n => (count C n:ℝ)/(n:ℝ)) atTop (𝓝 δ)) : |
| Tendsto (fun n => ((n-last C n:ℕ):ℝ)/((n+1:ℕ):ℝ)) atTop (𝓝 0) := by |
| have hh := (tendsto_const_nhds (x := (1:ℝ)) (f := (atTop : Filter ℕ))).sub (last_ratio C hδ hd) |
| rw [sub_self (1:ℝ)] at hh |
| convert hh using 1 |
| funext n |
| rw [Nat.cast_sub (last_le C n)] |
| push_cast |
| field_simp |
| ring |
| |
| lemma last_gap_div (C : ℕ → Prop) {δ : ℝ} (hδ : 0<δ) |
| (hd : Tendsto (fun n => (count C n:ℝ)/(n:ℝ)) atTop (𝓝 δ)) : |
| Tendsto (fun n => ((n-last C n:ℕ):ℝ)/(n:ℝ)) atTop (𝓝 0) := by |
| have hh := (last_gap_ratio C hδ hd).div (tendsto_natCast_div_add_atTop (1:ℝ)) (by norm_num : (1:ℝ)≠0) |
| simp only [zero_div] at hh |
| apply hh.congr' |
| filter_upwards [eventually_ne_atTop (0:ℕ)] with n hn |
| dsimp only [Pi.div_apply] |
| push_cast |
| field_simp |
| |
| lemma last_div (C : ℕ → Prop) {δ : ℝ} (hδ : 0<δ) |
| (hd : Tendsto (fun n => (count C n:ℝ)/(n:ℝ)) atTop (𝓝 δ)) : |
| Tendsto (fun n => (last C n:ℝ)/(n:ℝ)) atTop (𝓝 1) := by |
| have hh := (tendsto_const_nhds (x := (1:ℝ)) (f := (atTop : Filter ℕ))).sub (last_gap_div C hδ hd) |
| simp only [sub_zero] at hh |
| apply hh.congr' |
| filter_upwards [eventually_ne_atTop (0:ℕ)] with n hn |
| rw [Nat.cast_sub (last_le C n)] |
| have hne : (n:ℝ)≠0 := Nat.cast_ne_zero.mpr hn |
| field_simp |
| ring |
| |
| end FKCRT.CutOutput |
| end |
| |
| |
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT |
| namespace Stationary |
| variable {α : Type*} |
| lemma shift_neg_iterate (n : ℕ) (x : ℤ → α) : (shift (-1))^[n] x=shift (-(n:ℤ)) x := by |
| induction n with |
| | zero => ext k; simp [shift] |
| | succ n ih => |
| rw [Function.iterate_succ_apply',ih] |
| ext k |
| simp only [shift,Nat.cast_add,Nat.cast_one] |
| congr 1 |
| omega |
| end Stationary |
| namespace Inventory |
| open Classical |
| lemma rightOutput_reverse_frequencies (P : Parameters) (o : Order) : |
| ∀ᵐ x ∂Stationary.seqLaw (rightLaw P), |
| Tendsto (fun n => (∑ j∈Finset.range n,if rightOutput x (-1-j)=o then (1:ℝ) else 0)/(n:ℝ)) atTop (𝓝 (outputMass P o)) := by |
| have hh := Stationary.iid_reverse_shift_strong_law (rightLaw P) (outputIndicator_measurable o) (outputIndicator_integrable P o) |
| have ht := (Stationary.shift_preserving (rightLaw P) (-1)).quasiMeasurePreserving.ae hh |
| filter_upwards [ht] with x hx |
| have he (j : ℕ) : rightOutput (Stationary.shift (-(j:ℤ)) (Stationary.shift (-1) x)) 0=rightOutput x (-1-j) := by |
| rw [rightOutput_shift,rightOutput_shift] |
| congr 1 |
| omega |
| simpa only [Stationary.average,Stationary.shift_neg_iterate,outputIndicator,he,outputMass] using hx |
| |
| def rightCutDensity (P : Parameters) : ℝ := (Stationary.seqLaw (rightLaw P) {x | rightCutAt x 0}).toReal |
| lemma rightCutDensity_pos (P : Parameters) : 0<rightCutDensity P := |
| ENNReal.toReal_pos (ne_of_gt (rightCutAt_positive P)) (measure_ne_top _ _) |
| lemma rightCut_reverse_density (P : Parameters) : |
| ∀ᵐ x ∂Stationary.seqLaw (rightLaw P), |
| Tendsto (fun n => (CutOutput.count (fun k => rightCutAt x (-(k:ℤ))) n:ℝ)/(n:ℝ)) atTop (𝓝 (rightCutDensity P)) := by |
| let f : (ℤ → List Letter) → ℝ := fun x => if rightCutAt x 0 then 1 else 0 |
| have hf : Measurable f := Measurable.ite (rightCutAt_measurable 0) measurable_const measurable_const |
| have hi : Integrable f (Stationary.seqLaw (rightLaw P)) := by |
| apply (integrable_const (1:ℝ)).mono' hf.aestronglyMeasurable |
| filter_upwards [] with x |
| dsimp [f] |
| split_ifs <;> norm_num |
| have he : (∫ x,f x ∂Stationary.seqLaw (rightLaw P))=rightCutDensity P := by |
| simpa only [f,Set.indicator,Pi.one_apply,Measure.real,Set.mem_ofPred_eq,rightCutDensity] using |
| integral_indicator_one (μ := Stationary.seqLaw (rightLaw P)) (s := {x | rightCutAt x 0}) (rightCutAt_measurable 0) |
| have hh := Stationary.iid_reverse_shift_strong_law (rightLaw P) hf hi |
| filter_upwards [hh] with x hx |
| simpa only [CutOutput.countReal,Stationary.average,Stationary.shift_neg_iterate,f,rightCutAt_shift,zero_add,he] using hx |
| lemma rightCut_last_gap (P : Parameters) : |
| ∀ᵐ x ∂Stationary.seqLaw (rightLaw P), |
| Tendsto (fun n => ((n-CutOutput.last (fun k => rightCutAt x (-(k:ℤ))) n:ℕ):ℝ)/((n+1:ℕ):ℝ)) atTop (𝓝 0) := by |
| filter_upwards [rightCut_reverse_density P] with x hx |
| exact CutOutput.last_gap_ratio _ (rightCutDensity_pos P) hx |
| end Inventory |
| end FKCRT |
| end |
| |
| |
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.Inventory |
| open Classical |
| variable {α : Type*} |
| lemma bottom_append {u v : List α} {k : ℕ} (hk : v.length ≤ k) : |
| bottom (u++v) k=bottom u (k-v.length)++v := by |
| unfold bottom |
| rw [List.length_append,List.drop_append_of_le_length (by omega)] |
| congr 2 |
| omega |
| lemma bottom_append_bounds [BEq α] [LawfulBEq α] (a : α) {u v : List α} {k : ℕ} |
| (h₁ : v.length ≤ k) (h₂ : k ≤ u.length+v.length) : |
| v.count a ≤ (bottom (u++v) k).count a ∧ |
| (bottom (u++v) k).count a ≤ v.count a+(k-v.length) := by |
| rw [bottom_append h₁,List.count_append] |
| have hh : (bottom u (k-v.length)).length=k-v.length := by |
| rw [bottom,List.length_drop] |
| omega |
| have hc := List.count_le_length (a := a) (l := bottom u (k-v.length)) |
| rw [hh] at hc |
| omega |
| lemma count_real_sum [BEq α] [LawfulBEq α] (a : α) (l : List α) : |
| (l.count a:ℝ)=(l.map (fun b => if b=a then (1:ℝ) else 0)).sum := by |
| classical |
| induction l with |
| | nil => simp |
| | cons b l ih => |
| by_cases h : b=a |
| · subst b; simp [ih,add_comm] |
| · simp [h,ih] |
| lemma count_ofFn_real [BEq α] [LawfulBEq α] (a : α) {n : ℕ} (f : Fin n → α) : |
| ((List.ofFn f).count a:ℝ)=∑ j : Fin n,if f j=a then (1:ℝ) else 0 := by |
| rw [count_real_sum,List.map_ofFn,List.sum_ofFn] |
| rfl |
| end FKCRT.Inventory |
| end |
| |
| |
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.Inventory |
| open Classical |
| |
| def typeBalance (b : Bool) (e : Evaluation) : ℤ := (e.burgers.count b:ℤ)-(e.orders.count (some b):ℤ) |
| lemma typeBalance_step (b : Bool) (e : Evaluation) {a : Letter} (ha : a≠Letter.order none) : |
| typeBalance b (step e a)=typeBalance b e+Letter.typeNet b a := by |
| cases a with |
| | burger c => |
| by_cases h : c=b |
| · subst c; simp only [typeBalance,step,List.count_cons_self,Nat.cast_add,Nat.cast_one,Letter.typeNet,ite_true]; ring |
| · simp only [typeBalance,step,List.count_cons_of_ne h,Letter.typeNet,ite_eq_right h,add_zero] |
| | order o => |
| cases o with |
| | none => exact (ha rfl).elim |
| | some c => |
| cases hp : pop (some c) e.burgers with |
| | none => |
| by_cases h : c=b |
| · subst c |
| simp only [typeBalance,step,hp,List.count_append,List.count_singleton,Nat.cast_add,beq_self_eq_true,ite_true,Nat.cast_one,Letter.typeNet,ite_true] |
| ring |
| · have he : (some c:Order)≠some b := by simpa using h |
| simp only [typeBalance,step,hp,List.count_append,List.count_singleton,beq_eq_false_iff_ne.mpr he,Bool.false_eq_true,ite_false,Letter.typeNet,ite_eq_right h,add_zero] |
| | some s => |
| have hc := pop_fixed_count (a := b) hp |
| by_cases h : b=c |
| · subst c |
| simp only [ite_true] at hc |
| simp only [typeBalance,step,hp,Letter.typeNet,ite_true] |
| omega |
| · simp only [ite_eq_right h,Nat.add_zero] at hc |
| simp only [typeBalance,step,hp,Letter.typeNet,ite_eq_right (Ne.symm h),add_zero,hc] |
| lemma typeBalance_run (b : Bool) (e : Evaluation) (w : List Letter) (hw : FixedWord w) : |
| typeBalance b (run w e)=typeBalance b e+typeNet b w := by |
| induction w generalizing e with |
| | nil => simp [run,typeNet] |
| | cons a w ih => |
| have ha : a≠Letter.order none := by intro h; exact hw (by simp [h]) |
| have ht : FixedWord w := fun h => hw (List.mem_cons_of_mem a h) |
| rw [run,ih _ ht,typeBalance_step b e ha] |
| change _=(typeBalance b e)+(Letter.typeNet b a+typeNet b w) |
| ring |
| lemma burger_count_eq_typeNet {w : List Letter} (hw : FixedWord w) (ho : (reduce w).orders=[]) (b : Bool) : |
| ((reduce w).burgers.count b:ℤ)=typeNet b w := by |
| have hh := typeBalance_run b ⟨[],[]⟩ w hw |
| change typeBalance b (reduce w)=typeBalance b ⟨[],[]⟩+typeNet b w at hh |
| simpa only [typeBalance,ho,List.count_nil,Nat.cast_zero,sub_zero,sub_self,zero_add] using hh |
| lemma intervalWord_fixed {x : ℤ → List Letter} (hx : ∀ j,FixedWord (x j)) (a : ℤ) (n : ℕ) : FixedWord (intervalWord x a n) := by |
| induction n with |
| | zero => simp [intervalWord_zero,FixedWord] |
| | succ n ih => |
| rw [intervalWord_succ] |
| exact fun h => (List.mem_append.mp h).elim ih (hx _) |
| lemma typeNet_intervalWord (x : ℤ → List Letter) (b : Bool) (a : ℤ) (n : ℕ) : |
| typeNet b (intervalWord x a n)=∑ j∈Finset.range n,typeNet b (x (a+j)) := by |
| induction n with |
| | zero => simp [intervalWord_zero,typeNet] |
| | succ n ih => |
| rw [intervalWord_succ,Finset.sum_range_succ] |
| simpa only [typeNet,List.map_append,List.sum_append] using congrArg (·+typeNet b (x (a+n))) ih |
| |
| lemma shortLeftLaw_net (P : Parameters) : ∀ᵐ w ∂shortLeftLaw P,(w.map Letter.increment).sum=1 := by |
| rw [shortLeftLaw,ae_map_iff measurable_shortLeftWord.aemeasurable ((Set.to_countable _).measurableSet)] |
| filter_upwards [ae_left_first_hit P] with x hx |
| rw [shortLeftWord_sign,hx.1] |
| lemma leftSeq_net (P : Parameters) : ∀ᵐ x ∂Stationary.seqLaw (shortLeftLaw P),∀ j,((x j).map Letter.increment).sum=1 := by |
| apply ae_all_iff.mpr |
| intro j |
| exact (measurePreserving_eval_infinitePi (fun _ : ℤ => shortLeftLaw P) j).quasiMeasurePreserving.ae (shortLeftLaw_net P) |
| lemma leftSeq_fixed (P : Parameters) : ∀ᵐ x ∂Stationary.seqLaw (shortLeftLaw P),∀ j,FixedWord (x j) := by |
| apply ae_all_iff.mpr |
| intro j |
| exact (measurePreserving_eval_infinitePi (fun _ : ℤ => shortLeftLaw P) j).quasiMeasurePreserving.ae (shortLeftLaw_fixed P) |
| |
| def futurePieces (x : ℤ → List Letter) : ℕ → List Letter := fun j => x j |
| lemma futurePieces_preserving (ν : Measure (List Letter)) [IsProbabilityMeasure ν] : |
| MeasurePreserving futurePieces (Stationary.seqLaw ν) (naturalPiecesLaw ν) := by |
| refine ⟨Measurable.of_eval (fun j => measurable_pi_apply (j:ℤ)),?_⟩ |
| exact Measure.map_infinitePi_infinitePi_of_inj (fun a b h => Int.ofNat_inj.mp h) |
| lemma futurePieces_prefix (x : ℤ → List Letter) (n : ℕ) : piecesPrefix (futurePieces x) n=intervalWord x 0 n := by |
| simp only [intervalWord,zero_add] |
| rfl |
| lemma leftCutAt_zero_iff (x : ℤ → List Letter) : leftCutAt x 0 ↔ LeftCut (futurePieces x) := by |
| simp only [leftCutAt,LeftCut,futurePieces_prefix] |
| lemma leftCutAt_positive (P : Parameters) : 0<Stationary.seqLaw (shortLeftLaw P) {x | leftCutAt x 0} := by |
| have hh := (futurePieces_preserving (shortLeftLaw P)).measure_preimage measurableSet_leftCut.nullMeasurableSet |
| have he : {x | leftCutAt x 0}=futurePieces ⁻¹' {x | LeftCut x} := Set.ext (fun x => leftCutAt_zero_iff x) |
| rw [he,hh] |
| exact shortLeft_positive_cut P |
| end FKCRT.Inventory |
| end |
| |
| end OAI |
| |
