Theorem: one_add_mul_self_lt_rpow_one_add
File: Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean

tactic: rcases eq_or_lt_of_le hs with (rfl | hs)
state_before: s : ℝ
hs : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
⊢ 1 + p * s < (1 + s) ^ p

tactic: have hs1 : 0 < 1 + s := by linarith
state_before: case inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
⊢ 1 + p * s < (1 + s) ^ p

tactic: cases' le_or_lt (1 + p * s) 0 with hs2 hs2
state_before: case inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
⊢ 1 + p * s < (1 + s) ^ p

tactic: rw [rpow_def_of_pos hs1, ← exp_log hs2]
state_before: case inr.inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
⊢ 1 + p * s < (1 + s) ^ p

tactic: apply exp_strictMono
state_before: case inr.inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
⊢ exp (log (1 + p * s)) < exp (log (1 + s) * p)

tactic: have hp : 0 < p := by positivity
state_before: case inr.inr.a
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
⊢ log (1 + p * s) < log (1 + s) * p

tactic: have hs3 : 1 + s ≠ 1 := by contrapose! hs'; linarith
state_before: case inr.inr.a
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
⊢ log (1 + p * s) < log (1 + s) * p

tactic: have hs4 : 1 + p * s ≠ 1 := by contrapose! hs'; nlinarith
state_before: case inr.inr.a
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
⊢ log (1 + p * s) < log (1 + s) * p

tactic: cases' lt_or_gt_of_ne hs' with hs' hs'
state_before: case inr.inr.a
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
⊢ log (1 + p * s) < log (1 + s) * p

tactic: have : p ≠ 0 := by positivity
state_before: case inl
p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
⊢ 1 + p * -1 < (1 + -1) ^ p

tactic: simpa [zero_rpow this]
state_before: case inl
p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
this : p ≠ 0
⊢ 1 + p * -1 < (1 + -1) ^ p

tactic: positivity
state_before: p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
⊢ p ≠ 0

tactic: linarith
state_before: s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
⊢ 0 < 1 + s

tactic: exact hs2.trans_lt (rpow_pos_of_pos hs1 _)
state_before: case inr.inl
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 1 + p * s ≤ 0
⊢ 1 + p * s < (1 + s) ^ p

tactic: positivity
state_before: s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
⊢ 0 < p

tactic: contrapose! hs'
state_before: s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
⊢ 1 + s ≠ 1

tactic: linarith
state_before: s : ℝ
hs✝ : -1 ≤ s
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs' : 1 + s = 1
⊢ s = 0

tactic: contrapose! hs'
state_before: s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
⊢ 1 + p * s ≠ 1

tactic: nlinarith
state_before: s : ℝ
hs✝ : -1 ≤ s
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs' : 1 + p * s = 1
⊢ s = 0

tactic: rw [← div_lt_iff hp, ← div_lt_div_right_of_neg hs']
state_before: case inr.inr.a.inl
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
⊢ log (1 + p * s) < log (1 + s) * p

tactic: haveI : (1 : ℝ) ∈ Ioi 0 := zero_lt_one
state_before: case inr.inr.a.inl
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
⊢ log (1 + s) / s < log (1 + p * s) / p / s

tactic: convert strictConcaveOn_log_Ioi.secant_strict_mono this hs2 hs1 hs4 hs3 _ using 1
state_before: case inr.inr.a.inl
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
this : 1 ∈ Ioi 0
⊢ log (1 + s) / s < log (1 + p * s) / p / s

tactic: field_simp [log_one]
state_before: case h.e'_3
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
this : 1 ∈ Ioi 0
⊢ log (1 + s) / s = (log (1 + s) - log 1) / (1 + s - 1)

tactic: field_simp [log_one]
state_before: case h.e'_4
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
this : 1 ∈ Ioi 0
⊢ log (1 + p * s) / p / s = (log (1 + p * s) - log 1) / (1 + p * s - 1)

tactic: nlinarith
state_before: case inr.inr.a.inl
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s < 0
this : 1 ∈ Ioi 0
⊢ 1 + p * s < 1 + s

tactic: rw [← div_lt_iff hp, ← div_lt_div_right hs']
state_before: case inr.inr.a.inr
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
⊢ log (1 + p * s) < log (1 + s) * p

tactic: haveI : (1 : ℝ) ∈ Ioi 0 := zero_lt_one
state_before: case inr.inr.a.inr
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
⊢ log (1 + p * s) / p / s < log (1 + s) / s

tactic: convert strictConcaveOn_log_Ioi.secant_strict_mono this hs1 hs2 hs3 hs4 _ using 1
state_before: case inr.inr.a.inr
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
this : 1 ∈ Ioi 0
⊢ log (1 + p * s) / p / s < log (1 + s) / s

tactic: field_simp [log_one, hp.ne']
state_before: case h.e'_3
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
this : 1 ∈ Ioi 0
⊢ log (1 + p * s) / p / s = (log (1 + p * s) - log 1) / (1 + p * s - 1)

tactic: field_simp [log_one]
state_before: case h.e'_4
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
this : 1 ∈ Ioi 0
⊢ log (1 + s) / s = (log (1 + s) - log 1) / (1 + s - 1)

tactic: nlinarith
state_before: case inr.inr.a.inr
s : ℝ
hs✝ : -1 ≤ s
hs'✝ : s ≠ 0
p : ℝ
hp✝ : 1 < p
hs : -1 < s
hs1 : 0 < 1 + s
hs2 : 0 < 1 + p * s
hp : 0 < p
hs3 : 1 + s ≠ 1
hs4 : 1 + p * s ≠ 1
hs' : s > 0
this : 1 ∈ Ioi 0
⊢ 1 + s < 1 + p * s