File size: 2,719 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import Mathlib
import OAI.Probability.CriticalPercolation.Entropy.MarkedBits

namespace OAI

section
section
namespace CriticalPercolation.ReverseReference
open scoped Classical

lemma trajectory_dominance (a r v : β„• β†’ ℝ) (n : β„•)
    (hr : βˆ€ i < n, 0 ≀ r i) (hv : βˆ€ i < n, 0 ≀ v i)
    (hstep : βˆ€ i < n, a i * r i ≀ a (i+1) * v i) :
    a 0 * ∏ i : Fin n, r i.val ≀ a n * ∏ i : Fin n, v i.val := by
  induction n with
  | zero => simp
  | succ n ih =>
    have hh := ih (fun i hi => hr i (hi.trans (Nat.lt_succ_self n)))
      (fun i hi => hv i (hi.trans (Nat.lt_succ_self n)))
      (fun i hi => hstep i (hi.trans (Nat.lt_succ_self n)))
    rw [Fin.prod_univ_castSucc,Fin.prod_univ_castSucc]
    simp only [Fin.val_castSucc,Fin.val_last]
    calc
      _ = (a 0 * ∏ i : Fin n, r i.val) * r n := by ring
      _ ≀ (a n * ∏ i : Fin n, v i.val) * r n := mul_le_mul_of_nonneg_right hh (hr n (Nat.lt_succ_self n))
      _ = (a n*r n)*(∏ i : Fin n, v i.val) := by ring
      _ ≀ (a (n+1)*v n)*(∏ i : Fin n, v i.val) := mul_le_mul_of_nonneg_right
        (hstep n (Nat.lt_succ_self n)) (Finset.prod_nonneg fun i _ => hv i.val (i.isLt.trans (Nat.lt_succ_self n)))
      _ = _ := by ring

lemma joint_trajectory_dominance {X M : Type*} [Fintype X] [Fintype M]
    (ΞΌ : X β†’ ℝ) (k : β„• β†’ X β†’ M β†’ ℝ) (u : β„• β†’ X β†’ M β†’ X)
    (n : β„•) (a : Fin n β†’ X β†’ M β†’ ℝ) (Οƒ : β„• β†’ X) (m : β„• β†’ M)
    (m' : Fin n β†’ M) (r v : Fin n β†’ ℝ)
    (hu : βˆ€ i < n, u i (Οƒ (i+1)) (m i) = Οƒ i)
    (hr : βˆ€ i, 0 ≀ r i)
    (hv : βˆ€ i, 0 ≀ k i.val (Οƒ (i.val+1)) (m i.val) * a i (Οƒ 0) (m' i) * v i)
    (hs : βˆ€ i : Fin n, ΞΌ (Οƒ i.val) * r i ≀
      ΞΌ (Οƒ (i.val+1)) * (k i.val (Οƒ (i.val+1)) (m i.val) * a i (Οƒ 0) (m' i) * v i)) :
    ΞΌ (Οƒ 0) * ∏ i, r i ≀
      joint ΞΌ k u a n (Οƒ n,(fun i => m i.val),m') * ∏ i, v i := by
  let r' : β„• β†’ ℝ := fun j => if hj : j<n then r ⟨j,hj⟩ else 0
  let v' : β„• β†’ ℝ := fun j => if hj : j<n then
    k j (Οƒ (j+1)) (m j) * a ⟨j,hj⟩ (Οƒ 0) (m' ⟨j,hj⟩) * v ⟨j,hj⟩ else 0
  have hh := trajectory_dominance (fun j => ΞΌ (Οƒ j)) r' v' n
    (fun j hj => by simpa only [r',dite_eq_left hj] using hr ⟨j,hj⟩)
    (fun j hj => by simpa only [v',dite_eq_left hj] using hv ⟨j,hj⟩)
    (fun j hj => by simpa only [r',v',dite_eq_left hj] using hs ⟨j,hj⟩)
  simp only [r',v',dite_eq_left (Fin.isLt _),Finset.prod_mul_distrib] at hh
  unfold joint terminalWeight
  dsimp only
  rw [recover_trajectory u Οƒ m n hu,
    weight_trajectory k u Οƒ m (fun j => k j (Οƒ (j+1)) (m j)) n hu (fun _ _ => rfl)]
  convert hh using 1
  ring

end CriticalPercolation.ReverseReference
end
end

end OAI