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

tactic: apply strictConvexOn_of_slope_strict_mono_adjacent convex_univ
state_before: ⊢ StrictConvexOn ℝ univ rexp
state_after: ⊢ ∀ {x y z : ℝ}, x ∈ univ → z ∈ univ → x < y → y < z → (rexp y - rexp x) / (y - x) < (rexp z - rexp y) / (z - y)

tactic: rintro x y z - - hxy hyz
state_before: ⊢ ∀ {x y z : ℝ}, x ∈ univ → z ∈ univ → x < y → y < z → (rexp y - rexp x) / (y - x) < (rexp z - rexp y) / (z - y)
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
⊢ (rexp y - rexp x) / (y - x) < (rexp z - rexp y) / (z - y)

tactic: trans exp y
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
⊢ (rexp y - rexp x) / (y - x) < (rexp z - rexp y) / (z - y)
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
⊢ (rexp y - rexp x) / (y - x) < rexp y

x y z : ℝ
hxy : x < y
hyz : y < z
⊢ rexp y < (rexp z - rexp y) / (z - y)

tactic: have h1 : 0 < y - x := by linarith
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
⊢ (rexp y - rexp x) / (y - x) < rexp y
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
⊢ (rexp y - rexp x) / (y - x) < rexp y

tactic: have h2 : x - y < 0 := by linarith
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
⊢ (rexp y - rexp x) / (y - x) < rexp y
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ (rexp y - rexp x) / (y - x) < rexp y

tactic: rw [div_lt_iff h1]
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ (rexp y - rexp x) / (y - x) < rexp y
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ rexp y - rexp x < rexp y * (y - x)

tactic: calc
  exp y - exp x = exp y - exp y * exp (x - y) := by rw [← exp_add]; ring_nf
  _ = exp y * (1 - exp (x - y)) := by ring
  _ < exp y * -(x - y) := by gcongr; linarith [add_one_lt_exp h2.ne]
  _ = exp y * (y - x) := by ring
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ rexp y - rexp x < rexp y * (y - x)
state_after: no goals

tactic: linarith
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
⊢ 0 < y - x
state_after: no goals

tactic: linarith
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
⊢ x - y < 0
state_after: no goals

tactic: rw [← exp_add]
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ rexp y - rexp x = rexp y - rexp y * rexp (x - y)
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ rexp y - rexp x = rexp y - rexp (y + (x - y))

tactic: ring_nf
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ rexp y - rexp x = rexp y - rexp (y + (x - y))
state_after: no goals

tactic: ring
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ rexp y - rexp y * rexp (x - y) = rexp y * (1 - rexp (x - y))
state_after: no goals

tactic: gcongr
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ rexp y * (1 - rexp (x - y)) < rexp y * -(x - y)
state_after: case bc
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ 1 - rexp (x - y) < -(x - y)

tactic: linarith [add_one_lt_exp h2.ne]
state_before: case bc
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ 1 - rexp (x - y) < -(x - y)
state_after: no goals

tactic: ring
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ rexp y * -(x - y) = rexp y * (y - x)
state_after: no goals

tactic: have h1 : 0 < z - y := by linarith
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
⊢ rexp y < (rexp z - rexp y) / (z - y)
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp y < (rexp z - rexp y) / (z - y)

tactic: rw [lt_div_iff h1]
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp y < (rexp z - rexp y) / (z - y)
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp y * (z - y) < rexp z - rexp y

tactic: calc
  exp y * (z - y) < exp y * (exp (z - y) - 1) := by
    gcongr _ * ?_
    linarith [add_one_lt_exp h1.ne']
  _ = exp (z - y) * exp y - exp y := by ring
  _ ≤ exp z - exp y := by rw [← exp_add]; ring_nf; rfl
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp y * (z - y) < rexp z - rexp y
state_after: no goals

tactic: linarith
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
⊢ 0 < z - y
state_after: no goals

tactic: gcongr _ * ?_
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp y * (z - y) < rexp y * (rexp (z - y) - 1)
state_after: case bc
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ z - y < rexp (z - y) - 1

tactic: linarith [add_one_lt_exp h1.ne']
state_before: case bc
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ z - y < rexp (z - y) - 1
state_after: no goals

tactic: ring
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp y * (rexp (z - y) - 1) = rexp (z - y) * rexp y - rexp y
state_after: no goals

tactic: rw [← exp_add]
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp (z - y) * rexp y - rexp y ≤ rexp z - rexp y
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp (z - y + y) - rexp y ≤ rexp z - rexp y

tactic: ring_nf
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp (z - y + y) - rexp y ≤ rexp z - rexp y
state_after: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp z - rexp y ≤ rexp z - rexp y

tactic: rfl
state_before: x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ rexp z - rexp y ≤ rexp z - rexp y
state_after: no goals