l3lab/ntp-mathlib huggingface dataset:
theorem condCdfRat_le_one (ρ : Measure (α × ℝ)) (a : α) (r : ℚ) : condCdfRat ρ a r ≤ 1 := by
  unfold condCdfRat
  split_ifs with h
  · refine' ENNReal.toReal_le_of_le_ofReal zero_le_one _
    rw [ENNReal.ofReal_one]
    exact (hasCondCdf_of_mem_condCdfSet h).le_one r
  -- Porting note: added
  dsimp only; 

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
r : ℚ
h : a ∉ condCdfSet ρ
⊢ (if r < 0 then 0 else 1) ≤ 1

Next tactic:
split_ifs
theorem condCdfRat_le_one (ρ : Measure (α × ℝ)) (a : α) (r : ℚ) : condCdfRat ρ a r ≤ 1 := by
  unfold condCdfRat
  split_ifs with h
  · refine' ENNReal.toReal_le_of_le_ofReal zero_le_one _
    rw [ENNReal.ofReal_one]
    exact (hasCondCdf_of_mem_condCdfSet h).le_one r
  -- Porting note: added
  dsimp only; split_ifs
  

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
r : ℚ
h : a ∉ condCdfSet ρ
h✝ : r < 0
⊢ 0 ≤ 1
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
r : ℚ
h : a ∉ condCdfSet ρ
h✝ : ¬r < 0
⊢ 1 ≤ 1

Next tactic:
exacts [zero_le_one, le_rfl]
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
⊢ Tendsto (condCdfRat ρ a) atBot (𝓝 0)

Next tactic:
unfold condCdfRat
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
⊢ Tendsto (if a ∈ condCdfSet ρ then fun r => ENNReal.toReal (preCdf ρ r a) else fun r => if r < 0 then 0 else 1) atBot
    (𝓝 0)

Next tactic:
split_ifs with h
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
⊢ Tendsto (fun r => ENNReal.toReal (preCdf ρ r a)) atBot (𝓝 0)

Next tactic:
rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
    · 

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
⊢ Tendsto (fun r => preCdf ρ r a) atBot (𝓝 0)

Next tactic:
exact (hasCondCdf_of_mem_condCdfSet h).tendsto_atBot_zero
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
    · exact (hasCondCdf_of_mem_condCdfSet h).tendsto_atBot_zero
    · 

Proof state:
case pos.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
⊢ ∀ (i : ℚ), preCdf ρ i a ≠ ⊤

Next tactic:
have h' := hasCondCdf_of_mem_condCdfSet h
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
    · exact (hasCondCdf_of_mem_condCdfSet h).tendsto_atBot_zero
    · have h' := hasCondCdf_of_mem_condCdfSet h
      

Proof state:
case pos.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
h' : HasCondCdf ρ a
⊢ ∀ (i : ℚ), preCdf ρ i a ≠ ⊤

Next tactic:
exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
    · exact (hasCondCdf_of_mem_condCdfSet h).tendsto_atBot_zero
    · have h' := hasCondCdf_of_mem_condCdfSet h
      exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · 

Proof state:
case pos.hx
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
⊢ 0 ≠ ⊤

Next tactic:
exact ENNReal.zero_ne_top
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
    · exact (hasCondCdf_of_mem_condCdfSet h).tendsto_atBot_zero
    · have h' := hasCondCdf_of_mem_condCdfSet h
      exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · exact ENNReal.zero_ne_top
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∉ condCdfSet ρ
⊢ Tendsto (fun r => if r < 0 then 0 else 1) atBot (𝓝 0)

Next tactic:
refine' (tendsto_congr' _).mp tendsto_const_nhds
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
    · exact (hasCondCdf_of_mem_condCdfSet h).tendsto_atBot_zero
    · have h' := hasCondCdf_of_mem_condCdfSet h
      exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · exact ENNReal.zero_ne_top
  · refine' (tendsto_congr' _).mp tendsto_const_nhds
    

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∉ condCdfSet ρ
⊢ (fun x => 0) =ᶠ[atBot] fun r => if r < 0 then 0 else 1

Next tactic:
rw [EventuallyEq, eventually_atBot]
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
    · exact (hasCondCdf_of_mem_condCdfSet h).tendsto_atBot_zero
    · have h' := hasCondCdf_of_mem_condCdfSet h
      exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · exact ENNReal.zero_ne_top
  · refine' (tendsto_congr' _).mp tendsto_const_nhds
    rw [EventuallyEq, eventually_atBot]
    

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∉ condCdfSet ρ
⊢ ∃ a, ∀ b ≤ a, 0 = if b < 0 then 0 else 1

Next tactic:
refine' ⟨-1, fun q hq => (if_pos (hq.trans_lt _)).symm⟩
theorem tendsto_condCdfRat_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atBot (𝓝 0) := by
  unfold condCdfRat
  split_ifs with h
  · rw [← ENNReal.zero_toReal, ENNReal.tendsto_toReal_iff]
    · exact (hasCondCdf_of_mem_condCdfSet h).tendsto_atBot_zero
    · have h' := hasCondCdf_of_mem_condCdfSet h
      exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · exact ENNReal.zero_ne_top
  · refine' (tendsto_congr' _).mp tendsto_const_nhds
    rw [EventuallyEq, eventually_atBot]
    refine' ⟨-1, fun q hq => (if_pos (hq.trans_lt _)).symm⟩
    

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∉ condCdfSet ρ
q : ℚ
hq : q ≤ -1
⊢ -1 < 0

Next tactic:
linarith
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
⊢ Tendsto (condCdfRat ρ a) atTop (𝓝 1)

Next tactic:
unfold condCdfRat
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
⊢ Tendsto (if a ∈ condCdfSet ρ then fun r => ENNReal.toReal (preCdf ρ r a) else fun r => if r < 0 then 0 else 1) atTop
    (𝓝 1)

Next tactic:
split_ifs with h
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  split_ifs with h
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
⊢ Tendsto (fun r => ENNReal.toReal (preCdf ρ r a)) atTop (𝓝 1)

Next tactic:
have h' := hasCondCdf_of_mem_condCdfSet h
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  split_ifs with h
  · have h' := hasCondCdf_of_mem_condCdfSet h
    

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
h' : HasCondCdf ρ a
⊢ Tendsto (fun r => ENNReal.toReal (preCdf ρ r a)) atTop (𝓝 1)

Next tactic:
rw [← ENNReal.one_toReal, ENNReal.tendsto_toReal_iff]
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  split_ifs with h
  · have h' := hasCondCdf_of_mem_condCdfSet h
    rw [← ENNReal.one_toReal, ENNReal.tendsto_toReal_iff]
    · 

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
h' : HasCondCdf ρ a
⊢ Tendsto (fun r => preCdf ρ r a) atTop (𝓝 1)

Next tactic:
exact h'.tendsto_atTop_one
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  split_ifs with h
  · have h' := hasCondCdf_of_mem_condCdfSet h
    rw [← ENNReal.one_toReal, ENNReal.tendsto_toReal_iff]
    · exact h'.tendsto_atTop_one
    · 

Proof state:
case pos.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
h' : HasCondCdf ρ a
⊢ ∀ (i : ℚ), preCdf ρ i a ≠ ⊤

Next tactic:
exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  split_ifs with h
  · have h' := hasCondCdf_of_mem_condCdfSet h
    rw [← ENNReal.one_toReal, ENNReal.tendsto_toReal_iff]
    · exact h'.tendsto_atTop_one
    · exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · 

Proof state:
case pos.hx
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∈ condCdfSet ρ
h' : HasCondCdf ρ a
⊢ 1 ≠ ⊤

Next tactic:
exact ENNReal.one_ne_top
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  split_ifs with h
  · have h' := hasCondCdf_of_mem_condCdfSet h
    rw [← ENNReal.one_toReal, ENNReal.tendsto_toReal_iff]
    · exact h'.tendsto_atTop_one
    · exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · exact ENNReal.one_ne_top
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∉ condCdfSet ρ
⊢ Tendsto (fun r => if r < 0 then 0 else 1) atTop (𝓝 1)

Next tactic:
refine' (tendsto_congr' _).mp tendsto_const_nhds
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  split_ifs with h
  · have h' := hasCondCdf_of_mem_condCdfSet h
    rw [← ENNReal.one_toReal, ENNReal.tendsto_toReal_iff]
    · exact h'.tendsto_atTop_one
    · exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · exact ENNReal.one_ne_top
  · refine' (tendsto_congr' _).mp tendsto_const_nhds
    

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∉ condCdfSet ρ
⊢ (fun x => 1) =ᶠ[atTop] fun r => if r < 0 then 0 else 1

Next tactic:
rw [EventuallyEq, eventually_atTop]
theorem tendsto_condCdfRat_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCdfRat ρ a) atTop (𝓝 1) := by
  unfold condCdfRat
  split_ifs with h
  · have h' := hasCondCdf_of_mem_condCdfSet h
    rw [← ENNReal.one_toReal, ENNReal.tendsto_toReal_iff]
    · exact h'.tendsto_atTop_one
    · exact fun r => ((h'.le_one r).trans_lt ENNReal.one_lt_top).ne
    · exact ENNReal.one_ne_top
  · refine' (tendsto_congr' _).mp tendsto_const_nhds
    rw [EventuallyEq, eventually_atTop]
    

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
h : a ∉ condCdfSet ρ
⊢ ∃ a, ∀ b ≥ a, 1 = if b < 0 then 0 else 1

Next tactic:
exact ⟨0, fun q hq => (if_neg (not_lt.mpr hq)).symm⟩
theorem condCdfRat_ae_eq (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] (r : ℚ) :
    (fun a => condCdfRat ρ a r) =ᵐ[ρ.fst] fun a => (preCdf ρ r a).toReal := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
⊢ (fun a => condCdfRat ρ a r) =ᵐ[Measure.fst ρ] fun a => ENNReal.toReal (preCdf ρ r a)

Next tactic:
filter_upwards [mem_condCdfSet_ae ρ] with a ha using condCdfRat_of_mem ρ a ha r
theorem ofReal_condCdfRat_ae_eq (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] (r : ℚ) :
    (fun a => ENNReal.ofReal (condCdfRat ρ a r)) =ᵐ[ρ.fst] preCdf ρ r := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
⊢ (fun a => ENNReal.ofReal (condCdfRat ρ a r)) =ᵐ[Measure.fst ρ] preCdf ρ r

Next tactic:
filter_upwards [condCdfRat_ae_eq ρ r, preCdf_le_one ρ] with a ha ha_le_one
theorem ofReal_condCdfRat_ae_eq (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] (r : ℚ) :
    (fun a => ENNReal.ofReal (condCdfRat ρ a r)) =ᵐ[ρ.fst] preCdf ρ r := by
  filter_upwards [condCdfRat_ae_eq ρ r, preCdf_le_one ρ] with a ha ha_le_one
  

Proof state:
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
a : α
ha : condCdfRat ρ a r = ENNReal.toReal (preCdf ρ r a)
ha_le_one : ∀ (r : ℚ), preCdf ρ r a ≤ 1
⊢ ENNReal.ofReal (condCdfRat ρ a r) = preCdf ρ r a

Next tactic:
rw [ha, ENNReal.ofReal_toReal]
theorem ofReal_condCdfRat_ae_eq (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] (r : ℚ) :
    (fun a => ENNReal.ofReal (condCdfRat ρ a r)) =ᵐ[ρ.fst] preCdf ρ r := by
  filter_upwards [condCdfRat_ae_eq ρ r, preCdf_le_one ρ] with a ha ha_le_one
  rw [ha, ENNReal.ofReal_toReal]
  

Proof state:
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
inst✝ : IsFiniteMeasure ρ
r : ℚ
a : α
ha : condCdfRat ρ a r = ENNReal.toReal (preCdf ρ r a)
ha_le_one : ∀ (r : ℚ), preCdf ρ r a ≤ 1
⊢ preCdf ρ r a ≠ ⊤

Next tactic:
exact ((ha_le_one r).trans_lt ENNReal.one_lt_top).ne
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
⊢ ⨅ r, condCdfRat ρ a ↑r = condCdfRat ρ a t

Next tactic:
by_cases ha : a ∈ condCdfSet ρ
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∈ condCdfSet ρ
⊢ ⨅ r, condCdfRat ρ a ↑r = condCdfRat ρ a t

Next tactic:
simp_rw [condCdfRat_of_mem ρ a ha]
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∈ condCdfSet ρ
⊢ ⨅ r, ENNReal.toReal (preCdf ρ (↑r) a) = ENNReal.toReal (preCdf ρ t a)

Next tactic:
have ha' := hasCondCdf_of_mem_condCdfSet ha
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∈ condCdfSet ρ
ha' : HasCondCdf ρ a
⊢ ⨅ r, ENNReal.toReal (preCdf ρ (↑r) a) = ENNReal.toReal (preCdf ρ t a)

Next tactic:
rw [← ENNReal.toReal_iInf]
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · 

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∈ condCdfSet ρ
ha' : HasCondCdf ρ a
⊢ ENNReal.toReal (⨅ r, preCdf ρ (↑r) a) = ENNReal.toReal (preCdf ρ t a)

Next tactic:
suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by 

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∈ condCdfSet ρ
ha' : HasCondCdf ρ a
this : ⨅ i, preCdf ρ (↑i) a = preCdf ρ t a
⊢ ENNReal.toReal (⨅ r, preCdf ρ (↑r) a) = ENNReal.toReal (preCdf ρ t a)

Next tactic:
rw [this]
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
      

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∈ condCdfSet ρ
ha' : HasCondCdf ρ a
⊢ ⨅ i, preCdf ρ (↑i) a = preCdf ρ t a

Next tactic:
rw [← ha'.iInf_rat_gt_eq]
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
      rw [← ha'.iInf_rat_gt_eq]
    · 

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∈ condCdfSet ρ
ha' : HasCondCdf ρ a
⊢ ∀ (i : ↑(Ioi t)), preCdf ρ (↑i) a ≠ ⊤

Next tactic:
exact fun r => ((ha'.le_one r).trans_lt ENNReal.one_lt_top).ne
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
      rw [← ha'.iInf_rat_gt_eq]
    · exact fun r => ((ha'.le_one r).trans_lt ENNReal.one_lt_top).ne
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∉ condCdfSet ρ
⊢ ⨅ r, condCdfRat ρ a ↑r = condCdfRat ρ a t

Next tactic:
simp_rw [condCdfRat_of_not_mem ρ a ha]
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
      rw [← ha'.iInf_rat_gt_eq]
    · exact fun r => ((ha'.le_one r).trans_lt ENNReal.one_lt_top).ne
  · simp_rw [condCdfRat_of_not_mem ρ a ha]
    

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∉ condCdfSet ρ
⊢ (⨅ r, if ↑r < 0 then 0 else 1) = if t < 0 then 0 else 1

Next tactic:
have h_bdd : BddBelow (range fun r : ↥(Ioi t) => ite ((r : ℚ) < 0) (0 : ℝ) 1) := by
      refine' ⟨0, fun x hx => _⟩
      obtain ⟨y, rfl⟩ := mem_range.mpr hx
      dsimp only
      split_ifs
      exacts [le_rfl, zero_le_one]
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
      rw [← ha'.iInf_rat_gt_eq]
    · exact fun r => ((ha'.le_one r).trans_lt ENNReal.one_lt_top).ne
  · simp_rw [condCdfRat_of_not_mem ρ a ha]
    have h_bdd : BddBelow (range fun r : ↥(Ioi t) => ite ((r : ℚ) < 0) (0 : ℝ) 1) := by
      

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∉ condCdfSet ρ
⊢ BddBelow (range fun r => if ↑r < 0 then 0 else 1)

Next tactic:
refine' ⟨0, fun x hx => _⟩
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
      rw [← ha'.iInf_rat_gt_eq]
    · exact fun r => ((ha'.le_one r).trans_lt ENNReal.one_lt_top).ne
  · simp_rw [condCdfRat_of_not_mem ρ a ha]
    have h_bdd : BddBelow (range fun r : ↥(Ioi t) => ite ((r : ℚ) < 0) (0 : ℝ) 1) := by
      refine' ⟨0, fun x hx => _⟩
      

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∉ condCdfSet ρ
x : ℝ
hx : x ∈ range fun r => if ↑r < 0 then 0 else 1
⊢ 0 ≤ x

Next tactic:
obtain ⟨y, rfl⟩ := mem_range.mpr hx
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
      rw [← ha'.iInf_rat_gt_eq]
    · exact fun r => ((ha'.le_one r).trans_lt ENNReal.one_lt_top).ne
  · simp_rw [condCdfRat_of_not_mem ρ a ha]
    have h_bdd : BddBelow (range fun r : ↥(Ioi t) => ite ((r : ℚ) < 0) (0 : ℝ) 1) := by
      refine' ⟨0, fun x hx => _⟩
      obtain ⟨y, rfl⟩ := mem_range.mpr hx
      

Proof state:
case intro
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∉ condCdfSet ρ
y : ↑(Ioi t)
hx : (fun y => (fun r => if ↑r < 0 then 0 else 1) y) y ∈ range fun r => if ↑r < 0 then 0 else 1
⊢ 0 ≤ (fun y => (fun r => if ↑r < 0 then 0 else 1) y) y

Next tactic:
dsimp only
theorem inf_gt_condCdfRat (ρ : Measure (α × ℝ)) (a : α) (t : ℚ) :
    ⨅ r : Ioi t, condCdfRat ρ a r = condCdfRat ρ a t := by
  by_cases ha : a ∈ condCdfSet ρ
  · simp_rw [condCdfRat_of_mem ρ a ha]
    have ha' := hasCondCdf_of_mem_condCdfSet ha
    rw [← ENNReal.toReal_iInf]
    · suffices ⨅ i : ↥(Ioi t), preCdf ρ (↑i) a = preCdf ρ t a by rw [this]
      rw [← ha'.iInf_rat_gt_eq]
    · exact fun r => ((ha'.le_one r).trans_lt ENNReal.one_lt_top).ne
  · simp_rw [condCdfRat_of_not_mem ρ a ha]
    have h_bdd : BddBelow (range fun r : ↥(Ioi t) => ite ((r : ℚ) < 0) (0 : ℝ) 1) := by
      refine' ⟨0, fun x hx => _⟩
      obtain ⟨y, rfl⟩ := mem_range.mpr hx
      dsimp only
      

Proof state:
case intro
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
t : ℚ
ha : a ∉ condCdfSet ρ
y : ↑(Ioi t)
hx : (fun y => (fun r => if ↑r < 0 then 0 else 1) y) y ∈ range fun r => if ↑r < 0 then 0 else 1
⊢ 0 ≤ if ↑y < 0 then 0 else 1

Next tactic:
split_ifs