[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : Module.rank K V = ↑n
⊢ finrank K V = n
[PROOFSTEP]
apply_fun toNat at h
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : ↑toNat (Module.rank K V) = ↑toNat ↑n
⊢ finrank K V = n
[PROOFSTEP]
rw [toNat_cast] at h
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : ↑toNat (Module.rank K V) = n
⊢ finrank K V = n
[PROOFSTEP]
exact_mod_cast h
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : Module.rank K V ≤ ↑n
⊢ finrank K V ≤ n
[PROOFSTEP]
rwa [← Cardinal.toNat_le_iff_le_of_lt_aleph0, toNat_cast] at h
[GOAL]
case hc
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : Module.rank K V ≤ ↑n
⊢ Module.rank K V < ℵ₀
[PROOFSTEP]
exact h.trans_lt (nat_lt_aleph0 n)
[GOAL]
case hd
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : Module.rank K V ≤ ↑n
⊢ ↑n < ℵ₀
[PROOFSTEP]
exact nat_lt_aleph0 n
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : Module.rank K V < ↑n
⊢ finrank K V < n
[PROOFSTEP]
rwa [← Cardinal.toNat_lt_iff_lt_of_lt_aleph0, toNat_cast] at h
[GOAL]
case hc
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : Module.rank K V < ↑n
⊢ Module.rank K V < ℵ₀
[PROOFSTEP]
exact h.trans (nat_lt_aleph0 n)
[GOAL]
case hd
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : Module.rank K V < ↑n
⊢ ↑n < ℵ₀
[PROOFSTEP]
exact nat_lt_aleph0 n
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : n < finrank K V
⊢ ↑n < Module.rank K V
[PROOFSTEP]
rwa [← Cardinal.toNat_lt_iff_lt_of_lt_aleph0, toNat_cast]
[GOAL]
case hc
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : n < finrank K V
⊢ ↑n < ℵ₀
[PROOFSTEP]
exact nat_lt_aleph0 n
[GOAL]
case hd
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : n < finrank K V
⊢ Module.rank K V < ℵ₀
[PROOFSTEP]
contrapose! h
[GOAL]
case hd
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : ℵ₀ ≤ Module.rank K V
⊢ finrank K V ≤ n
[PROOFSTEP]
rw [finrank, Cardinal.toNat_apply_of_aleph0_le h]
[GOAL]
case hd
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
h : ℵ₀ ≤ Module.rank K V
⊢ 0 ≤ n
[PROOFSTEP]
exact n.zero_le
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
h : 1 < finrank K V
⊢ 1 < Module.rank K V
[PROOFSTEP]
simpa using lt_rank_of_lt_finrank h
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
h : lift (Module.rank K V) ≤ lift (Module.rank K V₂)
h' : Module.rank K V₂ < ℵ₀
⊢ finrank K V ≤ finrank K V₂
[PROOFSTEP]
simpa only [toNat_lift] using toNat_le_of_le_of_lt_aleph0 (lift_lt_aleph0.mpr h') h
[GOAL]
K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : Nontrivial K
inst✝ : NoZeroSMulDivisors K V
n : ℕ
hn : finrank K V = Nat.succ n
⊢ 0 < finrank (?m.108424 hn) V
[PROOFSTEP]
rw [hn]
[GOAL]
K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : Nontrivial K
inst✝ : NoZeroSMulDivisors K V
n : ℕ
hn : finrank K V = Nat.succ n
⊢ 0 < Nat.succ n
[PROOFSTEP]
exact n.succ_pos
[GOAL]
K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : Nontrivial K
inst✝ : NoZeroSMulDivisors K V
h : Subsingleton V
⊢ finrank K V = 0
[PROOFSTEP]
by_contra h0
[GOAL]
K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : Nontrivial K
inst✝ : NoZeroSMulDivisors K V
h : Subsingleton V
h0 : ¬finrank K V = 0
⊢ False
[PROOFSTEP]
obtain ⟨x, y, hxy⟩ := nontrivial_of_finrank_pos (Nat.pos_of_ne_zero h0)
[GOAL]
case mk.intro.intro
K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : Nontrivial K
inst✝ : NoZeroSMulDivisors K V
h : Subsingleton V
h0 : ¬finrank K V = 0
x y : V
hxy : x ≠ y
⊢ False
[PROOFSTEP]
exact hxy (Subsingleton.elim _ _)
[GOAL]
K : Type u
V : Type v
inst✝⁵ : Ring K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : StrongRankCondition K
ι : Type w
b : Finset ι
h : Basis { x // x ∈ b } K V
⊢ finrank K V = Finset.card b
[PROOFSTEP]
rw [finrank_eq_card_basis h, Fintype.card_coe]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : Ring K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : StrongRankCondition K
⊢ Module.rank K K = ↑1
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝⁵ : Ring K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : StrongRankCondition K
n : ℕ
⊢ finrank K (Fin n → K) = n
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : ∀ (s : Set V), Basis (↑s) K V → ¬Set.Finite s
⊢ finrank K V = 0
[PROOFSTEP]
obtain ⟨_, ⟨b⟩⟩ := (Module.free_iff_set K V).mp ‹_›
[GOAL]
case intro.intro
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : ∀ (s : Set V), Basis (↑s) K V → ¬Set.Finite s
w✝ : Set V
b : Basis (↑w✝) K V
⊢ finrank K V = 0
[PROOFSTEP]
exact dif_neg fun rank_lt => h _ b (b.finite_index_of_rank_lt_aleph0 rank_lt)
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : ∀ (s : Finset V), Basis (↑↑s) K V → False
s : Set V
b : Basis (↑s) K V
hs : Set.Finite s
⊢ Basis (↑↑(Set.Finite.toFinset hs)) K V
[PROOFSTEP]
convert b
[GOAL]
case h.e'_1.h.e'_2
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : ∀ (s : Finset V), Basis (↑↑s) K V → False
s : Set V
b : Basis (↑s) K V
hs : Set.Finite s
⊢ ↑(Set.Finite.toFinset hs) = s
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
V₂ : Type v'
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module K V₂
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
f : M ≃ₗ[R] M₂
⊢ finrank R M = finrank R M₂
[PROOFSTEP]
unfold finrank
[GOAL]
K : Type u
V : Type v
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
V₂ : Type v'
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module K V₂
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
f : M ≃ₗ[R] M₂
⊢ ↑toNat (Module.rank R M) = ↑toNat (Module.rank R M₂)
[PROOFSTEP]
rw [← Cardinal.toNat_lift, f.lift_rank_eq, Cardinal.toNat_lift]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
hf : Injective ↑f
⊢ finrank K { x // x ∈ range f } = finrank K V
[PROOFSTEP]
rw [(LinearEquiv.ofInjective f hf).finrank_eq]
[GOAL]
K : Type u
V : Type v
inst✝² : Ring K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ finrank K { x // x ∈ ⊤ } = finrank K V
[PROOFSTEP]
unfold finrank
[GOAL]
K : Type u
V : Type v
inst✝² : Ring K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ ↑toNat (Module.rank K { x // x ∈ ⊤ }) = ↑toNat (Module.rank K V)
[PROOFSTEP]
simp [rank_top]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
s t : Submodule K V
le : s ≤ t
lt : finrank K { x // x ∈ s } < finrank K { x // x ∈ t }
h : s = t
⊢ finrank K { x // x ∈ s } = finrank K { x // x ∈ t }
[PROOFSTEP]
rw [h]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
s : Submodule K V
lt : finrank K { x // x ∈ s } < finrank K V
⊢ s < ⊤
[PROOFSTEP]
rw [← finrank_top K V] at lt
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
s : Submodule K V
lt : finrank K { x // x ∈ s } < finrank K { x // x ∈ ⊤ }
⊢ s < ⊤
[PROOFSTEP]
exact lt_of_le_of_finrank_lt_finrank le_top lt
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Set V
inst✝ : Fintype ↑s
⊢ Module.rank K { x // x ∈ span K s } ≤ ↑(Finset.card (Set.toFinset s))
[PROOFSTEP]
simpa using rank_span_le (K := K) s
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
⊢ Finset.card (Set.toFinset ↑s) = Finset.card s
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ Set.finrank K (Set.range b) ≤ Fintype.card ι
[PROOFSTEP]
classical
refine (finrank_span_le_card _).trans ?_
rw [Set.toFinset_range]
exact Finset.card_image_le
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ Set.finrank K (Set.range b) ≤ Fintype.card ι
[PROOFSTEP]
refine (finrank_span_le_card _).trans ?_
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ Finset.card (Set.toFinset (Set.range b)) ≤ Fintype.card ι
[PROOFSTEP]
rw [Set.toFinset_range]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ Finset.card (Finset.image b Finset.univ) ≤ Fintype.card ι
[PROOFSTEP]
exact Finset.card_image_le
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hb : LinearIndependent K b
⊢ Module.rank K { x // x ∈ span K (Set.range b) } = ↑(Fintype.card ι)
[PROOFSTEP]
have : Module.rank K (span K (Set.range b)) = #(Set.range b) := rank_span hb
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hb : LinearIndependent K b
this : Module.rank K { x // x ∈ span K (Set.range b) } = #↑(Set.range b)
⊢ Module.rank K { x // x ∈ span K (Set.range b) } = ↑(Fintype.card ι)
[PROOFSTEP]
rwa [← lift_inj, mk_range_eq_of_injective hb.injective, Cardinal.mk_fintype, lift_natCast, lift_eq_nat_iff] at this
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Set V
inst✝ : Fintype ↑s
hs : LinearIndependent K Subtype.val
⊢ Module.rank K { x // x ∈ span K s } = ↑(Finset.card (Set.toFinset s))
[PROOFSTEP]
have : Module.rank K (span K s) = #s := rank_span_set hs
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Set V
inst✝ : Fintype ↑s
hs : LinearIndependent K Subtype.val
this : Module.rank K { x // x ∈ span K s } = #↑s
⊢ Module.rank K { x // x ∈ span K s } = ↑(Finset.card (Set.toFinset s))
[PROOFSTEP]
rwa [Cardinal.mk_fintype, ← Set.toFinset_card] at this
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : LinearIndependent K Subtype.val
⊢ finrank K { x // x ∈ span K ↑s } = Finset.card s
[PROOFSTEP]
convert finrank_span_set_eq_card (s : Set V) hs
[GOAL]
case h.e'_3.h.e'_2
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : LinearIndependent K Subtype.val
⊢ s = Set.toFinset ↑s
[PROOFSTEP]
ext
[GOAL]
case h.e'_3.h.e'_2.a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : LinearIndependent K Subtype.val
a✝ : V
⊢ a✝ ∈ s ↔ a✝ ∈ Set.toFinset ↑s
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
⊢ g i = 0
[PROOFSTEP]
classical
by_contra gx_ne_zero
refine'
  not_le_of_gt (span_lt_top_of_card_lt_finrank (show (b '' (Set.univ \ { i })).toFinset.card < finrank K V from _)) _
·
  calc
    (b '' (Set.univ \ { i })).toFinset.card = ((Set.univ \ { i }).toFinset.image b).card := by
      rw [Set.toFinset_card, Fintype.card_ofFinset]
    _ ≤ (Set.univ \ { i }).toFinset.card := Finset.card_image_le
    _ = (Finset.univ.erase i).card := (congr_arg Finset.card (Finset.ext (by simp [and_comm])))
    _ < Finset.univ.card := (Finset.card_erase_lt_of_mem (Finset.mem_univ i))
    _ = finrank K V := card_eq
refine' spans.trans (span_le.mpr _)
rintro _
  ⟨j, rfl, rfl⟩
      -- The case that `j ≠ i` is easy because `b j ∈ b '' (univ \ {i})`.
by_cases j_eq : j = i
swap
· refine' subset_span ⟨j, (Set.mem_diff _).mpr ⟨Set.mem_univ _, _⟩, rfl⟩
  exact mt Set.mem_singleton_iff.mp j_eq
rw [j_eq, SetLike.mem_coe, show b i = -((g i)⁻¹ • (s.erase i).sum fun j => g j • b j) from _]
· refine' neg_mem (smul_mem _ _ (sum_mem fun k hk => _))
  obtain ⟨k_ne_i, _⟩ := Finset.mem_erase.mp hk
  refine' smul_mem _ _ (subset_span ⟨k, _, rfl⟩)
  simp_all only [Set.mem_univ, Set.mem_diff, Set.mem_singleton_iff]
    -- To show `b i` is a weighted sum of the other `b j`s, we'll rewrite this sum
        -- to have the form of the assumption `dependent`.
apply eq_neg_of_add_eq_zero_left
calc
  (b i + (g i)⁻¹ • (s.erase i).sum fun j => g j • b j) = (g i)⁻¹ • (g i • b i + (s.erase i).sum fun j => g j • b j) :=
    by rw [smul_add, ← mul_smul, inv_mul_cancel gx_ne_zero, one_smul]
  _ = (g i)⁻¹ • (0 : V) := (congr_arg _ ?_)
  _ = 0 :=
    smul_zero
      _
        -- And then it's just a bit of manipulation with finite sums.
rwa [← Finset.insert_erase i_mem_s, Finset.sum_insert (Finset.not_mem_erase _ _)] at dependent
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
⊢ g i = 0
[PROOFSTEP]
by_contra gx_ne_zero
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
⊢ False
[PROOFSTEP]
refine'
  not_le_of_gt (span_lt_top_of_card_lt_finrank (show (b '' (Set.univ \ { i })).toFinset.card < finrank K V from _)) _
[GOAL]
case refine'_1
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
⊢ Finset.card (Set.toFinset (b '' (Set.univ \ {i}))) < finrank K V
[PROOFSTEP]
calc
  (b '' (Set.univ \ { i })).toFinset.card = ((Set.univ \ { i }).toFinset.image b).card := by
    rw [Set.toFinset_card, Fintype.card_ofFinset]
  _ ≤ (Set.univ \ { i }).toFinset.card := Finset.card_image_le
  _ = (Finset.univ.erase i).card := (congr_arg Finset.card (Finset.ext (by simp [and_comm])))
  _ < Finset.univ.card := (Finset.card_erase_lt_of_mem (Finset.mem_univ i))
  _ = finrank K V := card_eq
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
⊢ Finset.card (Set.toFinset (b '' (Set.univ \ {i}))) = Finset.card (Finset.image b (Set.toFinset (Set.univ \ {i})))
[PROOFSTEP]
rw [Set.toFinset_card, Fintype.card_ofFinset]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
⊢ ∀ (a : ι), a ∈ Set.toFinset (Set.univ \ {i}) ↔ a ∈ Finset.erase Finset.univ i
[PROOFSTEP]
simp [and_comm]
[GOAL]
case refine'_2
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
⊢ ⊤ ≤ span K (b '' (Set.univ \ {i}))
[PROOFSTEP]
refine' spans.trans (span_le.mpr _)
[GOAL]
case refine'_2
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
⊢ Set.range b ⊆ ↑(span K (b '' (Set.univ \ {i})))
[PROOFSTEP]
rintro _
  ⟨j, rfl, rfl⟩
      -- The case that `j ≠ i` is easy because `b j ∈ b '' (univ \ {i})`.
[GOAL]
case refine'_2.intro.refl
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
⊢ b j ∈ ↑(span K (b '' (Set.univ \ {i})))
[PROOFSTEP]
by_cases j_eq : j = i
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
⊢ b j ∈ ↑(span K (b '' (Set.univ \ {i})))
case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : ¬j = i
⊢ b j ∈ ↑(span K (b '' (Set.univ \ {i})))
[PROOFSTEP]
swap
[GOAL]
case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : ¬j = i
⊢ b j ∈ ↑(span K (b '' (Set.univ \ {i})))
[PROOFSTEP]
refine' subset_span ⟨j, (Set.mem_diff _).mpr ⟨Set.mem_univ _, _⟩, rfl⟩
[GOAL]
case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : ¬j = i
⊢ ¬j ∈ {i}
[PROOFSTEP]
exact mt Set.mem_singleton_iff.mp j_eq
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
⊢ b j ∈ ↑(span K (b '' (Set.univ \ {i})))
[PROOFSTEP]
rw [j_eq, SetLike.mem_coe, show b i = -((g i)⁻¹ • (s.erase i).sum fun j => g j • b j) from _]
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
⊢ -((g i)⁻¹ • Finset.sum (Finset.erase s i) fun j => g j • b j) ∈ span K (b '' (Set.univ \ {i}))
[PROOFSTEP]
refine' neg_mem (smul_mem _ _ (sum_mem fun k hk => _))
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
k : ι
hk : k ∈ Finset.erase s i
⊢ g k • b k ∈ span K (b '' (Set.univ \ {i}))
[PROOFSTEP]
obtain ⟨k_ne_i, _⟩ := Finset.mem_erase.mp hk
[GOAL]
case pos.intro
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
k : ι
hk : k ∈ Finset.erase s i
k_ne_i : k ≠ i
right✝ : k ∈ s
⊢ g k • b k ∈ span K (b '' (Set.univ \ {i}))
[PROOFSTEP]
refine' smul_mem _ _ (subset_span ⟨k, _, rfl⟩)
[GOAL]
case pos.intro
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
k : ι
hk : k ∈ Finset.erase s i
k_ne_i : k ≠ i
right✝ : k ∈ s
⊢ k ∈ Set.univ \ {i}
[PROOFSTEP]
simp_all only [Set.mem_univ, Set.mem_diff, Set.mem_singleton_iff]
  -- To show `b i` is a weighted sum of the other `b j`s, we'll rewrite this sum
      -- to have the form of the assumption `dependent`.
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
⊢ b i = -((g i)⁻¹ • Finset.sum (Finset.erase s i) fun j => g j • b j)
[PROOFSTEP]
apply eq_neg_of_add_eq_zero_left
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
⊢ (b i + (g i)⁻¹ • Finset.sum (Finset.erase s i) fun j => g j • b j) = 0
[PROOFSTEP]
calc
  (b i + (g i)⁻¹ • (s.erase i).sum fun j => g j • b j) = (g i)⁻¹ • (g i • b i + (s.erase i).sum fun j => g j • b j) :=
    by rw [smul_add, ← mul_smul, inv_mul_cancel gx_ne_zero, one_smul]
  _ = (g i)⁻¹ • (0 : V) := (congr_arg _ ?_)
  _ = 0 :=
    smul_zero
      _
        -- And then it's just a bit of manipulation with finite sums.
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
⊢ (b i + (g i)⁻¹ • Finset.sum (Finset.erase s i) fun j => g j • b j) =
    (g i)⁻¹ • (g i • b i + Finset.sum (Finset.erase s i) fun j => g j • b j)
[PROOFSTEP]
rw [smul_add, ← mul_smul, inv_mul_cancel gx_ne_zero, one_smul]
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
spans : ⊤ ≤ span K (Set.range b)
card_eq : Fintype.card ι = finrank K V
s : Finset ι
g : ι → K
dependent : (Finset.sum s fun i => g i • b i) = 0
i : ι
i_mem_s : i ∈ s
gx_ne_zero : ¬g i = 0
j : ι
j_eq : j = i
⊢ (g i • b i + Finset.sum (Finset.erase s i) fun j => g j • b j) = 0
[PROOFSTEP]
rwa [← Finset.insert_erase i_mem_s, Finset.sum_insert (Finset.not_mem_erase _ _)] at dependent
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ LinearIndependent K b ↔ Fintype.card ι = Set.finrank K (Set.range b)
[PROOFSTEP]
constructor
[GOAL]
case mp
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ LinearIndependent K b → Fintype.card ι = Set.finrank K (Set.range b)
[PROOFSTEP]
intro h
[GOAL]
case mp
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
h : LinearIndependent K b
⊢ Fintype.card ι = Set.finrank K (Set.range b)
[PROOFSTEP]
exact (finrank_span_eq_card h).symm
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ Fintype.card ι = Set.finrank K (Set.range b) → LinearIndependent K b
[PROOFSTEP]
intro hc
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
⊢ LinearIndependent K b
[PROOFSTEP]
let f := Submodule.subtype (span K (Set.range b))
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
⊢ LinearIndependent K b
[PROOFSTEP]
let b' : ι → span K (Set.range b) := fun i => ⟨b i, mem_span.2 fun p hp => hp (Set.mem_range_self _)⟩
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
⊢ LinearIndependent K b
[PROOFSTEP]
have hs : ⊤ ≤ span K (Set.range b') := by
  intro x
  have h : span K (f '' Set.range b') = map f (span K (Set.range b')) := span_image f
  have hf : f '' Set.range b' = Set.range b := by
    ext x
    simp [Set.mem_image, Set.mem_range]
  rw [hf] at h
  have hx : (x : V) ∈ span K (Set.range b) := x.property
  conv at hx =>
    arg 2
    rw [h]
  simpa [mem_map] using hx
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
⊢ ⊤ ≤ span K (Set.range b')
[PROOFSTEP]
intro x
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
⊢ x ∈ ⊤ → x ∈ span K (Set.range b')
[PROOFSTEP]
have h : span K (f '' Set.range b') = map f (span K (Set.range b')) := span_image f
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (↑f '' Set.range b') = Submodule.map f (span K (Set.range b'))
⊢ x ∈ ⊤ → x ∈ span K (Set.range b')
[PROOFSTEP]
have hf : f '' Set.range b' = Set.range b := by
  ext x
  simp [Set.mem_image, Set.mem_range]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (↑f '' Set.range b') = Submodule.map f (span K (Set.range b'))
⊢ ↑f '' Set.range b' = Set.range b
[PROOFSTEP]
ext x
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x✝ : { x // x ∈ span K (Set.range b) }
h : span K (↑f '' Set.range b') = Submodule.map f (span K (Set.range b'))
x : V
⊢ x ∈ ↑f '' Set.range b' ↔ x ∈ Set.range b
[PROOFSTEP]
simp [Set.mem_image, Set.mem_range]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (↑f '' Set.range b') = Submodule.map f (span K (Set.range b'))
hf : ↑f '' Set.range b' = Set.range b
⊢ x ∈ ⊤ → x ∈ span K (Set.range b')
[PROOFSTEP]
rw [hf] at h
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (Set.range b) = Submodule.map f (span K (Set.range b'))
hf : ↑f '' Set.range b' = Set.range b
⊢ x ∈ ⊤ → x ∈ span K (Set.range b')
[PROOFSTEP]
have hx : (x : V) ∈ span K (Set.range b) := x.property
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (Set.range b) = Submodule.map f (span K (Set.range b'))
hf : ↑f '' Set.range b' = Set.range b
hx : ↑x ∈ span K (Set.range b)
⊢ x ∈ ⊤ → x ∈ span K (Set.range b')
[PROOFSTEP]
conv at hx =>
  arg 2
  rw [h]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (Set.range b) = Submodule.map f (span K (Set.range b'))
hf : ↑f '' Set.range b' = Set.range b
hx : ↑x ∈ span K (Set.range b)
| ↑x ∈ span K (Set.range b)
[PROOFSTEP]
  arg 2
  rw [h]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (Set.range b) = Submodule.map f (span K (Set.range b'))
hf : ↑f '' Set.range b' = Set.range b
hx : ↑x ∈ span K (Set.range b)
| ↑x ∈ span K (Set.range b)
[PROOFSTEP]
  arg 2
  rw [h]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (Set.range b) = Submodule.map f (span K (Set.range b'))
hf : ↑f '' Set.range b' = Set.range b
hx : ↑x ∈ span K (Set.range b)
| ↑x ∈ span K (Set.range b)
[PROOFSTEP]
arg 2
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (Set.range b) = Submodule.map f (span K (Set.range b'))
hf : ↑f '' Set.range b' = Set.range b
hx : ↑x ∈ span K (Set.range b)
| span K (Set.range b)
[PROOFSTEP]
rw [h]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
x : { x // x ∈ span K (Set.range b) }
h : span K (Set.range b) = Submodule.map f (span K (Set.range b'))
hf : ↑f '' Set.range b' = Set.range b
hx : ↑x ∈ Submodule.map f (span K (Set.range b'))
⊢ x ∈ ⊤ → x ∈ span K (Set.range b')
[PROOFSTEP]
simpa [mem_map] using hx
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
hs : ⊤ ≤ span K (Set.range b')
⊢ LinearIndependent K b
[PROOFSTEP]
have hi : LinearMap.ker f = ⊥ := ker_subtype _
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
hc : Fintype.card ι = Set.finrank K (Set.range b)
f : { x // x ∈ span K (Set.range b) } →ₗ[K] V := Submodule.subtype (span K (Set.range b))
b' : ι → { x // x ∈ span K (Set.range b) } := fun i => { val := b i, property := (_ : b i ∈ span K (Set.range b)) }
hs : ⊤ ≤ span K (Set.range b')
hi : LinearMap.ker f = ⊥
⊢ LinearIndependent K b
[PROOFSTEP]
convert (linearIndependent_of_top_le_span_of_card_eq_finrank hs hc).map' _ hi
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ LinearIndependent K b ↔ Fintype.card ι ≤ Set.finrank K (Set.range b)
[PROOFSTEP]
rw [linearIndependent_iff_card_eq_finrank_span, finrank_range_le_card.le_iff_eq]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
v : V
n : v ≠ 0
h : ∀ (w : V), ∃ c, c • v = w
⊢ finrank K V = 1
[PROOFSTEP]
haveI := nontrivial_of_invariantBasisNumber K
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
v : V
n : v ≠ 0
h : ∀ (w : V), ∃ c, c • v = w
this : Nontrivial K
⊢ finrank K V = 1
[PROOFSTEP]
obtain ⟨b⟩ := (Basis.basis_singleton_iff.{u} PUnit).mpr ⟨v, n, h⟩
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
v : V
n : v ≠ 0
h : ∀ (w : V), ∃ c, c • v = w
this : Nontrivial K
b : Basis PUnit K V
⊢ finrank K V = 1
[PROOFSTEP]
rw [finrank_eq_card_basis b, Fintype.card_punit]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
v : V
h : ∀ (w : V), ∃ c, c • v = w
⊢ finrank K V ≤ 1
[PROOFSTEP]
haveI := nontrivial_of_invariantBasisNumber K
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
v : V
h : ∀ (w : V), ∃ c, c • v = w
this : Nontrivial K
⊢ finrank K V ≤ 1
[PROOFSTEP]
rcases eq_or_ne v 0 with (rfl | hn)
[GOAL]
case inl
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
this : Nontrivial K
h : ∀ (w : V), ∃ c, c • 0 = w
⊢ finrank K V ≤ 1
[PROOFSTEP]
haveI :=
  subsingleton_of_forall_eq (0 : V) fun w => by
    obtain ⟨c, rfl⟩ := h w
    simp
[GOAL]
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
this : Nontrivial K
h : ∀ (w : V), ∃ c, c • 0 = w
w : V
⊢ w = 0
[PROOFSTEP]
obtain ⟨c, rfl⟩ := h w
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
this : Nontrivial K
h : ∀ (w : V), ∃ c, c • 0 = w
c : K
⊢ c • 0 = 0
[PROOFSTEP]
simp
[GOAL]
case inl
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
this✝ : Nontrivial K
h : ∀ (w : V), ∃ c, c • 0 = w
this : Subsingleton V
⊢ finrank K V ≤ 1
[PROOFSTEP]
rw [finrank_zero_of_subsingleton]
[GOAL]
case inl
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
this✝ : Nontrivial K
h : ∀ (w : V), ∃ c, c • 0 = w
this : Subsingleton V
⊢ 0 ≤ 1
[PROOFSTEP]
exact zero_le_one
[GOAL]
case inr
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : NoZeroSMulDivisors K V
inst✝ : StrongRankCondition K
v : V
h : ∀ (w : V), ∃ c, c • v = w
this : Nontrivial K
hn : v ≠ 0
⊢ finrank K V ≤ 1
[PROOFSTEP]
exact (finrank_eq_one v hn h).le
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ Module.rank F { x // x ∈ ⊤ } = Module.rank F { x // x ∈ ⊤ }
[PROOFSTEP]
rw [← Algebra.top_toSubmodule]
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ Module.rank F { x // x ∈ ⊤ } = Module.rank F { x // x ∈ ↑Subalgebra.toSubmodule ⊤ }
[PROOFSTEP]
rfl
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ finrank F { x // x ∈ ⊤ } = finrank F { x // x ∈ ⊤ }
[PROOFSTEP]
rw [← Algebra.top_toSubmodule]
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ finrank F { x // x ∈ ⊤ } = finrank F { x // x ∈ ↑Subalgebra.toSubmodule ⊤ }
[PROOFSTEP]
rfl
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ Module.rank F { x // x ∈ ⊤ } = Module.rank F E
[PROOFSTEP]
rw [subalgebra_top_rank_eq_submodule_top_rank]
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ Module.rank F { x // x ∈ ⊤ } = Module.rank F E
[PROOFSTEP]
exact _root_.rank_top F E
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : Ring E
inst✝³ : Algebra F E
inst✝² : StrongRankCondition F
inst✝¹ : NoZeroSMulDivisors F E
inst✝ : Nontrivial E
⊢ Module.rank F { x // x ∈ span F {1} } = 1
[PROOFSTEP]
letI := Module.nontrivial F E
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : Ring E
inst✝³ : Algebra F E
inst✝² : StrongRankCondition F
inst✝¹ : NoZeroSMulDivisors F E
inst✝ : Nontrivial E
this : Nontrivial F := Module.nontrivial F E
⊢ Module.rank F { x // x ∈ span F {1} } = 1
[PROOFSTEP]
rw [rank_span_set]
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : Ring E
inst✝³ : Algebra F E
inst✝² : StrongRankCondition F
inst✝¹ : NoZeroSMulDivisors F E
inst✝ : Nontrivial E
this : Nontrivial F := Module.nontrivial F E
⊢ #↑{1} = 1
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : Ring E
inst✝³ : Algebra F E
inst✝² : StrongRankCondition F
inst✝¹ : NoZeroSMulDivisors F E
inst✝ : Nontrivial E
this : Nontrivial F := Module.nontrivial F E
⊢ LinearIndependent F fun x => ↑x
[PROOFSTEP]
exacts [mk_singleton _, linearIndependent_singleton one_ne_zero]
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : Ring E
inst✝³ : Algebra F E
inst✝² : StrongRankCondition F
inst✝¹ : NoZeroSMulDivisors F E
inst✝ : Nontrivial E
⊢ Module.rank F { x // x ∈ ⊥ } = ↑1
[PROOFSTEP]
simp


[GOAL]
⊢ StrictConvexOn ℝ univ exp
[PROOFSTEP]
apply strictConvexOn_of_slope_strict_mono_adjacent convex_univ
[GOAL]
⊢ ∀ {x y z : ℝ}, x ∈ univ → z ∈ univ → x < y → y < z → (exp y - exp x) / (y - x) < (exp z - exp y) / (z - y)
[PROOFSTEP]
rintro x y z - - hxy hyz
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ (exp y - exp x) / (y - x) < (exp z - exp y) / (z - y)
[PROOFSTEP]
trans exp y
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ (exp y - exp x) / (y - x) < exp y
[PROOFSTEP]
have h1 : 0 < y - x := by linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ 0 < y - x
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
⊢ (exp y - exp x) / (y - x) < exp y
[PROOFSTEP]
have h2 : x - y < 0 := by linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
⊢ x - y < 0
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ (exp y - exp x) / (y - x) < exp y
[PROOFSTEP]
rw [div_lt_iff h1]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y - exp x < exp y * (y - x)
[PROOFSTEP]
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_of_nonzero h2.ne]
  _ = exp y * (y - x) := by ring
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y - exp x = exp y - exp y * exp (x - y)
[PROOFSTEP]
rw [← exp_add]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y - exp x = exp y - exp (y + (x - y))
[PROOFSTEP]
ring_nf
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y - exp y * exp (x - y) = exp y * (1 - exp (x - y))
[PROOFSTEP]
ring
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y * (1 - exp (x - y)) < exp y * -(x - y)
[PROOFSTEP]
gcongr
[GOAL]
case bc
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ 1 - exp (x - y) < -(x - y)
[PROOFSTEP]
linarith [add_one_lt_exp_of_nonzero h2.ne]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < y - x
h2 : x - y < 0
⊢ exp y * -(x - y) = exp y * (y - x)
[PROOFSTEP]
ring
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ exp y < (exp z - exp y) / (z - y)
[PROOFSTEP]
have h1 : 0 < z - y := by linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
⊢ 0 < z - y
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp y < (exp z - exp y) / (z - y)
[PROOFSTEP]
rw [lt_div_iff h1]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp y * (z - y) < exp z - exp y
[PROOFSTEP]
calc
  exp y * (z - y) < exp y * (exp (z - y) - 1) := by
    gcongr _ * ?_
    linarith [add_one_lt_exp_of_nonzero h1.ne']
  _ = exp (z - y) * exp y - exp y := by ring
  _ ≤ exp z - exp y := by rw [← exp_add]; ring_nf; rfl
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp y * (z - y) < exp y * (exp (z - y) - 1)
[PROOFSTEP]
gcongr _ * ?_
[GOAL]
case bc
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ z - y < exp (z - y) - 1
[PROOFSTEP]
linarith [add_one_lt_exp_of_nonzero h1.ne']
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp y * (exp (z - y) - 1) = exp (z - y) * exp y - exp y
[PROOFSTEP]
ring
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp (z - y) * exp y - exp y ≤ exp z - exp y
[PROOFSTEP]
rw [← exp_add]
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp (z - y + y) - exp y ≤ exp z - exp y
[PROOFSTEP]
ring_nf
[GOAL]
x y z : ℝ
hxy : x < y
hyz : y < z
h1 : 0 < z - y
⊢ exp z - exp y ≤ exp z - exp y
[PROOFSTEP]
rfl
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ n
[PROOFSTEP]
induction' n with k IH
[GOAL]
case zero
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ Nat.zero
[PROOFSTEP]
exact convexOn_const (1 : ℝ) (convex_Ici _)
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ Nat.succ k
[PROOFSTEP]
refine' ⟨convex_Ici _, _⟩
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
⊢ ∀ ⦃x : ℝ⦄,
    x ∈ Ici 0 →
      ∀ ⦃y : ℝ⦄,
        y ∈ Ici 0 →
          ∀ ⦃a b : ℝ⦄,
            0 ≤ a →
              0 ≤ b →
                a + b = 1 →
                  (fun x => x ^ Nat.succ k) (a • x + b • y) ≤
                    a • (fun x => x ^ Nat.succ k) x + b • (fun x => x ^ Nat.succ k) y
[PROOFSTEP]
rintro a (ha : 0 ≤ a) b (hb : 0 ≤ b) μ ν hμ hν h
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (fun x => x ^ Nat.succ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ Nat.succ k) a + ν • (fun x => x ^ Nat.succ k) b
[PROOFSTEP]
have H := IH.2 ha hb hμ hν h
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
⊢ (fun x => x ^ Nat.succ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ Nat.succ k) a + ν • (fun x => x ^ Nat.succ k) b
[PROOFSTEP]
have : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν :=
  by
  cases' le_or_lt a b with hab hab
  · have : a ^ k ≤ b ^ k := by gcongr
    have : 0 ≤ (b ^ k - a ^ k) * (b - a) := by nlinarith
    positivity
  · have : b ^ k ≤ a ^ k := by gcongr
    have : 0 ≤ (b ^ k - a ^ k) * (b - a) := by nlinarith
    positivity
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
cases' le_or_lt a b with hab hab
[GOAL]
case inl
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
have : a ^ k ≤ b ^ k := by gcongr
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
⊢ a ^ k ≤ b ^ k
[PROOFSTEP]
gcongr
[GOAL]
case inl
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
this : a ^ k ≤ b ^ k
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
have : 0 ≤ (b ^ k - a ^ k) * (b - a) := by nlinarith
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
this : a ^ k ≤ b ^ k
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a)
[PROOFSTEP]
nlinarith
[GOAL]
case inl
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : a ≤ b
this✝ : a ^ k ≤ b ^ k
this : 0 ≤ (b ^ k - a ^ k) * (b - a)
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
positivity
[GOAL]
case inr
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
have : b ^ k ≤ a ^ k := by gcongr
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
⊢ b ^ k ≤ a ^ k
[PROOFSTEP]
gcongr
[GOAL]
case inr
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
this : b ^ k ≤ a ^ k
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
have : 0 ≤ (b ^ k - a ^ k) * (b - a) := by nlinarith
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
this : b ^ k ≤ a ^ k
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a)
[PROOFSTEP]
nlinarith
[GOAL]
case inr
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
hab : b < a
this✝ : b ^ k ≤ a ^ k
this : 0 ≤ (b ^ k - a ^ k) * (b - a)
⊢ 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
positivity
[GOAL]
case succ
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (fun x => x ^ Nat.succ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ Nat.succ k) a + ν • (fun x => x ^ Nat.succ k) b
[PROOFSTEP]
calc
  (μ * a + ν * b) ^ k.succ = (μ * a + ν * b) * (μ * a + ν * b) ^ k := pow_succ _ _
  _ ≤ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) := by gcongr; exact H
  _ ≤ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) + (b ^ k - a ^ k) * (b - a) * μ * ν := by linarith
  _ = (μ + ν) * (μ * a ^ k.succ + ν * b ^ k.succ) := by rw [Nat.succ_eq_add_one]; ring
  _ = μ * a ^ k.succ + ν * b ^ k.succ := by rw [h]; ring
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) * (μ * a + ν * b) ^ k ≤ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k)
[PROOFSTEP]
gcongr
[GOAL]
case h
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) ^ k ≤ μ * a ^ k + ν * b ^ k
[PROOFSTEP]
exact H
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) ≤
    (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) + (b ^ k - a ^ k) * (b - a) * μ * ν
[PROOFSTEP]
linarith
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) + (b ^ k - a ^ k) * (b - a) * μ * ν =
    (μ + ν) * (μ * a ^ Nat.succ k + ν * b ^ Nat.succ k)
[PROOFSTEP]
rw [Nat.succ_eq_add_one]
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ * a + ν * b) * (μ * a ^ k + ν * b ^ k) + (b ^ k - a ^ k) * (b - a) * μ * ν =
    (μ + ν) * (μ * a ^ (k + 1) + ν * b ^ (k + 1))
[PROOFSTEP]
ring
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ (μ + ν) * (μ * a ^ Nat.succ k + ν * b ^ Nat.succ k) = μ * a ^ Nat.succ k + ν * b ^ Nat.succ k
[PROOFSTEP]
rw [h]
[GOAL]
k : ℕ
IH : ConvexOn ℝ (Ici 0) fun x => x ^ k
a : ℝ
ha : 0 ≤ a
b : ℝ
hb : 0 ≤ b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
H : (fun x => x ^ k) (μ • a + ν • b) ≤ μ • (fun x => x ^ k) a + ν • (fun x => x ^ k) b
this : 0 ≤ (b ^ k - a ^ k) * (b - a) * μ * ν
⊢ 1 * (μ * a ^ Nat.succ k + ν * b ^ Nat.succ k) = μ * a ^ Nat.succ k + ν * b ^ Nat.succ k
[PROOFSTEP]
ring
[GOAL]
n : ℕ
hn : Even n
⊢ ConvexOn ℝ univ fun x => x ^ n
[PROOFSTEP]
refine' ⟨convex_univ, _⟩
[GOAL]
n : ℕ
hn : Even n
⊢ ∀ ⦃x : ℝ⦄,
    x ∈ univ →
      ∀ ⦃y : ℝ⦄,
        y ∈ univ →
          ∀ ⦃a b : ℝ⦄,
            0 ≤ a →
              0 ≤ b → a + b = 1 → (fun x => x ^ n) (a • x + b • y) ≤ a • (fun x => x ^ n) x + b • (fun x => x ^ n) y
[PROOFSTEP]
rintro a - b - μ ν hμ hν h
[GOAL]
n : ℕ
hn : Even n
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (fun x => x ^ n) (μ • a + ν • b) ≤ μ • (fun x => x ^ n) a + ν • (fun x => x ^ n) b
[PROOFSTEP]
obtain ⟨k, rfl⟩ :=
  hn.exists_two_nsmul
    _
      -- Porting note: added type ascription to LHS
[GOAL]
case intro
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
⊢ (fun x => x ^ (2 • k)) (μ • a + ν • b) ≤ μ • (fun x => x ^ (2 • k)) a + ν • (fun x => x ^ (2 • k)) b
[PROOFSTEP]
have : (0 : ℝ) ≤ (a - b) ^ 2 * μ * ν := by positivity
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
⊢ 0 ≤ (a - b) ^ 2 * μ * ν
[PROOFSTEP]
positivity
[GOAL]
case intro
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (fun x => x ^ (2 • k)) (μ • a + ν • b) ≤ μ • (fun x => x ^ (2 • k)) a + ν • (fun x => x ^ (2 • k)) b
[PROOFSTEP]
calc
  (μ * a + ν * b) ^ (2 * k) = ((μ * a + ν * b) ^ 2) ^ k := by rw [pow_mul]
  _ ≤ ((μ + ν) * (μ * a ^ 2 + ν * b ^ 2)) ^ k := by gcongr; linarith
  _ = (μ * a ^ 2 + ν * b ^ 2) ^ k := by rw [h]; ring
  _ ≤ μ * (a ^ 2) ^ k + ν * (b ^ 2) ^ k := ?_
  _ ≤ μ * a ^ (2 * k) + ν * b ^ (2 * k) := by ring_nf;
    rfl
      -- Porting note: `rw [mem_Ici]` was `dsimp`
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (μ * a + ν * b) ^ (2 * k) = ((μ * a + ν * b) ^ 2) ^ k
[PROOFSTEP]
rw [pow_mul]
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ ((μ * a + ν * b) ^ 2) ^ k ≤ ((μ + ν) * (μ * a ^ 2 + ν * b ^ 2)) ^ k
[PROOFSTEP]
gcongr
[GOAL]
case hab
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (μ * a + ν * b) ^ 2 ≤ (μ + ν) * (μ * a ^ 2 + ν * b ^ 2)
[PROOFSTEP]
linarith
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ ((μ + ν) * (μ * a ^ 2 + ν * b ^ 2)) ^ k = (μ * a ^ 2 + ν * b ^ 2) ^ k
[PROOFSTEP]
rw [h]
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (1 * (μ * a ^ 2 + ν * b ^ 2)) ^ k = (μ * a ^ 2 + ν * b ^ 2) ^ k
[PROOFSTEP]
ring
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ μ * (a ^ 2) ^ k + ν * (b ^ 2) ^ k ≤ μ * a ^ (2 * k) + ν * b ^ (2 * k)
[PROOFSTEP]
ring_nf
[GOAL]
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ μ * a ^ (k * 2) + ν * b ^ (k * 2) ≤ μ * a ^ (k * 2) + ν * b ^ (k * 2)
[PROOFSTEP]
rfl
  -- Porting note: `rw [mem_Ici]` was `dsimp`
[GOAL]
case intro
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ (μ * a ^ 2 + ν * b ^ 2) ^ k ≤ μ * (a ^ 2) ^ k + ν * (b ^ 2) ^ k
[PROOFSTEP]
refine' (convexOn_pow k).2 _ _ hμ hν h
[GOAL]
case intro.refine'_1
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ a ^ 2 ∈ Ici 0
[PROOFSTEP]
rw [mem_Ici]
[GOAL]
case intro.refine'_2
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ b ^ 2 ∈ Ici 0
[PROOFSTEP]
rw [mem_Ici]
[GOAL]
case intro.refine'_1
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ 0 ≤ a ^ 2
[PROOFSTEP]
positivity
[GOAL]
case intro.refine'_2
a b μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
k : ℕ
hn : Even (2 • k)
this : 0 ≤ (a - b) ^ 2 * μ * ν
⊢ 0 ≤ b ^ 2
[PROOFSTEP]
positivity
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ioi 0) fun x => x ^ ↑n
[PROOFSTEP]
simp_rw [zpow_ofNat]
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ioi 0) fun x => x ^ n
[PROOFSTEP]
exact (convexOn_pow n).subset Ioi_subset_Ici_self (convex_Ioi _)
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ioi 0) fun x => x ^ -[n+1]
[PROOFSTEP]
simp_rw [zpow_negSucc]
[GOAL]
n : ℕ
⊢ ConvexOn ℝ (Ioi 0) fun x => (x ^ (n + 1))⁻¹
[PROOFSTEP]
refine' ⟨convex_Ioi _, _⟩
[GOAL]
n : ℕ
⊢ ∀ ⦃x : ℝ⦄,
    x ∈ Ioi 0 →
      ∀ ⦃y : ℝ⦄,
        y ∈ Ioi 0 →
          ∀ ⦃a b : ℝ⦄,
            0 ≤ a →
              0 ≤ b →
                a + b = 1 →
                  (fun x => (x ^ (n + 1))⁻¹) (a • x + b • y) ≤
                    a • (fun x => (x ^ (n + 1))⁻¹) x + b • (fun x => (x ^ (n + 1))⁻¹) y
[PROOFSTEP]
rintro a (ha : 0 < a) b (hb : 0 < b) μ ν hμ hν h
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (fun x => (x ^ (n + 1))⁻¹) (μ • a + ν • b) ≤ μ • (fun x => (x ^ (n + 1))⁻¹) a + ν • (fun x => (x ^ (n + 1))⁻¹) b
[PROOFSTEP]
field_simp [ha.ne', hb.ne']
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 1 / (μ * a + ν * b) ^ (n + 1) ≤ (μ * b ^ (n + 1) + ν * a ^ (n + 1)) / (a ^ (n + 1) * b ^ (n + 1))
[PROOFSTEP]
rw [div_le_div_iff]
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 1 * (a ^ (n + 1) * b ^ (n + 1)) ≤ (μ * b ^ (n + 1) + ν * a ^ (n + 1)) * (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
calc
  (1 : ℝ) * (a ^ (n + 1) * b ^ (n + 1)) = ((μ + ν) ^ 2 * (a * b)) ^ (n + 1) := by rw [h]; ring
  _ ≤ ((μ * b + ν * a) * (μ * a + ν * b)) ^ (n + 1) := ?_
  _ = (μ * b + ν * a) ^ (n + 1) * (μ * a + ν * b) ^ (n + 1) := by rw [mul_pow]
  _ ≤ (μ * b ^ (n + 1) + ν * a ^ (n + 1)) * (μ * a + ν * b) ^ (n + 1) := ?_
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 1 * (a ^ (n + 1) * b ^ (n + 1)) = ((μ + ν) ^ 2 * (a * b)) ^ (n + 1)
[PROOFSTEP]
rw [h]
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 1 * (a ^ (n + 1) * b ^ (n + 1)) = (1 ^ 2 * (a * b)) ^ (n + 1)
[PROOFSTEP]
ring
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ ((μ * b + ν * a) * (μ * a + ν * b)) ^ (n + 1) = (μ * b + ν * a) ^ (n + 1) * (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
rw [mul_pow]
[GOAL]
case calc_1
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ ((μ + ν) ^ 2 * (a * b)) ^ (n + 1) ≤ ((μ * b + ν * a) * (μ * a + ν * b)) ^ (n + 1)
[PROOFSTEP]
gcongr(?_ : ℝ) ^ _
[GOAL]
case calc_1.hab
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (μ + ν) ^ 2 * (a * b) ≤ (μ * b + ν * a) * (μ * a + ν * b)
[PROOFSTEP]
have : (0 : ℝ) ≤ μ * ν * (a - b) ^ 2 := by positivity
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 0 ≤ μ * ν * (a - b) ^ 2
[PROOFSTEP]
positivity
[GOAL]
case calc_1.hab
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
this : 0 ≤ μ * ν * (a - b) ^ 2
⊢ (μ + ν) ^ 2 * (a * b) ≤ (μ * b + ν * a) * (μ * a + ν * b)
[PROOFSTEP]
linarith
[GOAL]
case calc_2
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (μ * b + ν * a) ^ (n + 1) * (μ * a + ν * b) ^ (n + 1) ≤
    (μ * b ^ (n + 1) + ν * a ^ (n + 1)) * (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
gcongr
[GOAL]
case calc_2.h
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ (μ * b + ν * a) ^ (n + 1) ≤ μ * b ^ (n + 1) + ν * a ^ (n + 1)
[PROOFSTEP]
apply (convexOn_pow (n + 1)).2 hb.le ha.le hμ hν h
[GOAL]
case b0
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 0 < (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
have : 0 < μ * a + ν * b := by cases le_or_lt a b <;> nlinarith
[GOAL]
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 0 < μ * a + ν * b
[PROOFSTEP]
cases le_or_lt a b
[GOAL]
case inl
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
h✝ : a ≤ b
⊢ 0 < μ * a + ν * b
[PROOFSTEP]
nlinarith
[GOAL]
case inr
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
h✝ : b < a
⊢ 0 < μ * a + ν * b
[PROOFSTEP]
nlinarith
[GOAL]
case b0
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
this : 0 < μ * a + ν * b
⊢ 0 < (μ * a + ν * b) ^ (n + 1)
[PROOFSTEP]
positivity
[GOAL]
case d0
n : ℕ
a : ℝ
ha : 0 < a
b : ℝ
hb : 0 < b
μ ν : ℝ
hμ : 0 ≤ μ
hν : 0 ≤ ν
h : μ + ν = 1
⊢ 0 < a ^ (n + 1) * b ^ (n + 1)
[PROOFSTEP]
positivity
[GOAL]
⊢ StrictConcaveOn ℝ (Ioi 0) log
[PROOFSTEP]
apply strictConcaveOn_of_slope_strict_anti_adjacent (convex_Ioi (0 : ℝ))
[GOAL]
⊢ ∀ {x y z : ℝ}, x ∈ Ioi 0 → z ∈ Ioi 0 → x < y → y < z → (log z - log y) / (z - y) < (log y - log x) / (y - x)
[PROOFSTEP]
rintro x y z (hx : 0 < x) (hz : 0 < z) hxy hyz
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
⊢ (log z - log y) / (z - y) < (log y - log x) / (y - x)
[PROOFSTEP]
have hy : 0 < y := hx.trans hxy
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ (log z - log y) / (z - y) < (log y - log x) / (y - x)
[PROOFSTEP]
trans y⁻¹
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ (log z - log y) / (z - y) < y⁻¹
[PROOFSTEP]
have h : 0 < z - y := by linarith
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ 0 < z - y
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
⊢ (log z - log y) / (z - y) < y⁻¹
[PROOFSTEP]
rw [div_lt_iff h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
⊢ log z - log y < y⁻¹ * (z - y)
[PROOFSTEP]
have hyz' : 0 < z / y := by positivity
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
⊢ 0 < z / y
[PROOFSTEP]
positivity
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
⊢ log z - log y < y⁻¹ * (z - y)
[PROOFSTEP]
have hyz'' : z / y ≠ 1 := by
  contrapose! h
  rw [div_eq_one_iff_eq hy.ne'] at h
  simp [h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
⊢ z / y ≠ 1
[PROOFSTEP]
contrapose! h
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
hyz' : 0 < z / y
h : z / y = 1
⊢ z - y ≤ 0
[PROOFSTEP]
rw [div_eq_one_iff_eq hy.ne'] at h
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
hyz' : 0 < z / y
h : z = y
⊢ z - y ≤ 0
[PROOFSTEP]
simp [h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
hyz'' : z / y ≠ 1
⊢ log z - log y < y⁻¹ * (z - y)
[PROOFSTEP]
calc
  log z - log y = log (z / y) := by rw [← log_div hz.ne' hy.ne']
  _ < z / y - 1 := (log_lt_sub_one_of_pos hyz' hyz'')
  _ = y⁻¹ * (z - y) := by field_simp [hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
hyz'' : z / y ≠ 1
⊢ log z - log y = log (z / y)
[PROOFSTEP]
rw [← log_div hz.ne' hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < z - y
hyz' : 0 < z / y
hyz'' : z / y ≠ 1
⊢ z / y - 1 = y⁻¹ * (z - y)
[PROOFSTEP]
field_simp [hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ y⁻¹ < (log y - log x) / (y - x)
[PROOFSTEP]
have h : 0 < y - x := by linarith
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ 0 < y - x
[PROOFSTEP]
linarith
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
⊢ y⁻¹ < (log y - log x) / (y - x)
[PROOFSTEP]
rw [lt_div_iff h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
⊢ y⁻¹ * (y - x) < log y - log x
[PROOFSTEP]
have hxy' : 0 < x / y := by positivity
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
⊢ 0 < x / y
[PROOFSTEP]
positivity
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
⊢ y⁻¹ * (y - x) < log y - log x
[PROOFSTEP]
have hxy'' : x / y ≠ 1 := by
  contrapose! h
  rw [div_eq_one_iff_eq hy.ne'] at h
  simp [h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
⊢ x / y ≠ 1
[PROOFSTEP]
contrapose! h
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
hxy' : 0 < x / y
h : x / y = 1
⊢ y - x ≤ 0
[PROOFSTEP]
rw [div_eq_one_iff_eq hy.ne'] at h
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
hxy' : 0 < x / y
h : x = y
⊢ y - x ≤ 0
[PROOFSTEP]
simp [h]
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ y⁻¹ * (y - x) < log y - log x
[PROOFSTEP]
calc
  y⁻¹ * (y - x) = 1 - x / y := by field_simp [hy.ne']
  _ < -log (x / y) := by linarith [log_lt_sub_one_of_pos hxy' hxy'']
  _ = -(log x - log y) := by rw [log_div hx.ne' hy.ne']
  _ = log y - log x := by ring
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ y⁻¹ * (y - x) = 1 - x / y
[PROOFSTEP]
field_simp [hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ 1 - x / y < -log (x / y)
[PROOFSTEP]
linarith [log_lt_sub_one_of_pos hxy' hxy'']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ -log (x / y) = -(log x - log y)
[PROOFSTEP]
rw [log_div hx.ne' hy.ne']
[GOAL]
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
hxy' : 0 < x / y
hxy'' : x / y ≠ 1
⊢ -(log x - log y) = log y - log x
[PROOFSTEP]
ring
[GOAL]
s : ℝ
hs : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
⊢ 1 + p * s < (1 + s) ^ p
[PROOFSTEP]
rcases eq_or_lt_of_le hs with (rfl | hs)
[GOAL]
case inl
p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
⊢ 1 + p * -1 < (1 + -1) ^ p
[PROOFSTEP]
have : p ≠ 0 := by positivity
[GOAL]
p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
⊢ p ≠ 0
[PROOFSTEP]
positivity
[GOAL]
case inl
p : ℝ
hp : 1 < p
hs : -1 ≤ -1
hs' : -1 ≠ 0
this : p ≠ 0
⊢ 1 + p * -1 < (1 + -1) ^ p
[PROOFSTEP]
simpa [zero_rpow this]
[GOAL]
case inr
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
⊢ 1 + p * s < (1 + s) ^ p
[PROOFSTEP]
have hs1 : 0 < 1 + s := by linarith
[GOAL]
s : ℝ
hs✝ : -1 ≤ s
hs' : s ≠ 0
p : ℝ
hp : 1 < p
hs : -1 < s
⊢ 0 < 1 + s
[PROOFSTEP]
linarith
[GOAL]
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
[PROOFSTEP]
cases' le_or_lt (1 + p * s) 0 with hs2 hs2
[GOAL]
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
[PROOFSTEP]
exact hs2.trans_lt (rpow_pos_of_pos hs1 _)
[GOAL]
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
[PROOFSTEP]
rw [rpow_def_of_pos hs1, ← exp_log hs2]
[GOAL]
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)
[PROOFSTEP]
apply exp_strictMono
[GOAL]
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
[PROOFSTEP]
have hp : 0 < p := by positivity
[GOAL]
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
[PROOFSTEP]
positivity
[GOAL]
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
[PROOFSTEP]
have hs3 : 1 + s ≠ 1 := by contrapose! hs'; linarith
[GOAL]
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
[PROOFSTEP]
contrapose! hs'
[GOAL]
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
[PROOFSTEP]
linarith
[GOAL]
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
[PROOFSTEP]
have hs4 : 1 + p * s ≠ 1 := by contrapose! hs'; nlinarith
[GOAL]
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
[PROOFSTEP]
contrapose! hs'
[GOAL]
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
[PROOFSTEP]
nlinarith
[GOAL]
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
[PROOFSTEP]
cases' lt_or_gt_of_ne hs' with hs' hs'
[GOAL]
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
[PROOFSTEP]
rw [← div_lt_iff hp, ← div_lt_div_right_of_neg hs']
  -- Porting note: previously we could write `zero_lt_one` inline,
      -- but now Lean doesn't guess we are talking about `1` fast enough.
[GOAL]
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
[PROOFSTEP]
haveI : (1 : ℝ) ∈ Ioi 0 := zero_lt_one
[GOAL]
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
[PROOFSTEP]
convert strictConcaveOn_log_Ioi.secant_strict_mono this hs2 hs1 hs4 hs3 _ using 1
[GOAL]
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)
[PROOFSTEP]
field_simp [log_one]
[GOAL]
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)
[PROOFSTEP]
field_simp [log_one]
[GOAL]
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
[PROOFSTEP]
nlinarith
[GOAL]
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
[PROOFSTEP]
rw [← div_lt_iff hp, ← div_lt_div_right hs']
  -- Porting note: previously we could write `zero_lt_one` inline,
      -- but now Lean doesn't guess we are talking about `1` fast enough.
[GOAL]
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
[PROOFSTEP]
haveI : (1 : ℝ) ∈ Ioi 0 := zero_lt_one
[GOAL]
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
[PROOFSTEP]
convert strictConcaveOn_log_Ioi.secant_strict_mono this hs1 hs2 hs3 hs4 _ using 1
[GOAL]
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)
[PROOFSTEP]
field_simp [log_one, hp.ne']
[GOAL]
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)
[PROOFSTEP]
field_simp [log_one]
[GOAL]
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
[PROOFSTEP]
nlinarith
[GOAL]
s : ℝ
hs : -1 ≤ s
p : ℝ
hp : 1 ≤ p
⊢ 1 + p * s ≤ (1 + s) ^ p
[PROOFSTEP]
rcases eq_or_lt_of_le hp with (rfl | hp)
[GOAL]
case inl
s : ℝ
hs : -1 ≤ s
hp : 1 ≤ 1
⊢ 1 + 1 * s ≤ (1 + s) ^ 1
[PROOFSTEP]
simp
[GOAL]
case inr
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ 1 + p * s ≤ (1 + s) ^ p
[PROOFSTEP]
by_cases hs' : s = 0
[GOAL]
case pos
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p
[PROOFSTEP]
simp [hs']
[GOAL]
case neg
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : ¬s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p
[PROOFSTEP]
exact (one_add_mul_self_lt_rpow_one_add hs hs' hp).le
[GOAL]
p : ℝ
hp : 1 < p
⊢ StrictConvexOn ℝ (Ici 0) fun x => x ^ p
[PROOFSTEP]
apply strictConvexOn_of_slope_strict_mono_adjacent (convex_Ici (0 : ℝ))
[GOAL]
p : ℝ
hp : 1 < p
⊢ ∀ {x y z : ℝ}, x ∈ Ici 0 → z ∈ Ici 0 → x < y → y < z → (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
rintro x y z (hx : 0 ≤ x) (hz : 0 ≤ z) hxy hyz
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hy : 0 < y := by linarith
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
⊢ 0 < y
[PROOFSTEP]
linarith
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hy' : 0 < y ^ p := rpow_pos_of_pos hy _
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have H1 : y ^ (p - 1 + 1) = y ^ (p - 1) * y := rpow_add_one hy.ne' _
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ (p - 1 + 1) = y ^ (p - 1) * y
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
ring_nf at H1
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ (y ^ p - x ^ p) / (y - x) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
trans p * y ^ (p - 1)
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have h3 : 0 < y - x := by linarith only [hxy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ 0 < y - x
[PROOFSTEP]
linarith only [hxy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have hyx'' : x / y < 1 := by rwa [div_lt_one hy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
⊢ x / y < 1
[PROOFSTEP]
rwa [div_lt_one hy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have hyx''' : x / y - 1 < 0 := by linarith only [hyx'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
⊢ x / y - 1 < 0
[PROOFSTEP]
linarith only [hyx'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have hyx'''' : 0 ≤ x / y := by positivity
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
⊢ 0 ≤ x / y
[PROOFSTEP]
positivity
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have hyx''''' : -1 ≤ x / y - 1 := by linarith only [hyx'''']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
⊢ -1 ≤ x / y - 1
[PROOFSTEP]
linarith only [hyx'''']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
have : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1) := by
  linarith [one_add_mul_self_lt_rpow_one_add hyx''''' hyx'''.ne hp]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
⊢ 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
[PROOFSTEP]
linarith [one_add_mul_self_lt_rpow_one_add hyx''''' hyx'''.ne hp]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1)
[PROOFSTEP]
rw [div_lt_iff h3, ← div_lt_div_right hy']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ (y ^ p - x ^ p) / y ^ p < p * y ^ (p - 1) * (y - x) / y ^ p
[PROOFSTEP]
convert this using 1
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ (y ^ p - x ^ p) / y ^ p = 1 - (1 + (x / y - 1)) ^ p
[PROOFSTEP]
have H : (x / y) ^ p = x ^ p / y ^ p := div_rpow hx hy.le _
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
H : (x / y) ^ p = x ^ p / y ^ p
⊢ (y ^ p - x ^ p) / y ^ p = 1 - (1 + (x / y - 1)) ^ p
[PROOFSTEP]
ring_nf at H ⊢
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
H : (x * y⁻¹) ^ p = x ^ p * (y ^ p)⁻¹
⊢ -(x ^ p * (y ^ p)⁻¹) + y ^ p * (y ^ p)⁻¹ = 1 - (x * y⁻¹) ^ p
[PROOFSTEP]
field_simp [hy.ne', hy'.ne'] at H ⊢
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
H : (x / y) ^ p * y ^ p = x ^ p
⊢ -x ^ p + y ^ p = (1 - (x / y) ^ p) * y ^ p
[PROOFSTEP]
linear_combination H
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ p * y ^ (p - 1) * (y - x) / y ^ p = -p * (x / y - 1)
[PROOFSTEP]
ring_nf at H1 ⊢
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ p * y ^ (-1 + p) * y * (y ^ p)⁻¹ - p * y ^ (-1 + p) * x * (y ^ p)⁻¹ = p - p * x * y⁻¹
[PROOFSTEP]
field_simp [hy.ne', hy'.ne']
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
h3 : 0 < y - x
hyx'' : x / y < 1
hyx''' : x / y - 1 < 0
hyx'''' : 0 ≤ x / y
hyx''''' : -1 ≤ x / y - 1
this : 1 - (1 + (x / y - 1)) ^ p < -p * (x / y - 1)
⊢ (p * y ^ (-1 + p) * y - p * y ^ (-1 + p) * x) * y = (p * y - p * x) * y ^ p
[PROOFSTEP]
linear_combination p * (-y + x) * H1
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hyz' : 0 < z - y := by linarith only [hyz]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
⊢ 0 < z - y
[PROOFSTEP]
linarith only [hyz]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hyz'' : 1 < z / y := by rwa [one_lt_div hy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
⊢ 1 < z / y
[PROOFSTEP]
rwa [one_lt_div hy]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hyz''' : 0 < z / y - 1 := by linarith only [hyz'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
⊢ 0 < z / y - 1
[PROOFSTEP]
linarith only [hyz'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have hyz'''' : -1 ≤ z / y - 1 := by linarith only [hyz'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
⊢ -1 ≤ z / y - 1
[PROOFSTEP]
linarith only [hyz'']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
have : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1 := by
  linarith [one_add_mul_self_lt_rpow_one_add hyz'''' hyz'''.ne' hp]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
⊢ p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
[PROOFSTEP]
linarith [one_add_mul_self_lt_rpow_one_add hyz'''' hyz'''.ne' hp]
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ p * y ^ (p - 1) < (z ^ p - y ^ p) / (z - y)
[PROOFSTEP]
rw [lt_div_iff hyz', ← div_lt_div_right hy']
[GOAL]
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ p * y ^ (p - 1) * (z - y) / y ^ p < (z ^ p - y ^ p) / y ^ p
[PROOFSTEP]
convert this using 1
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ p * y ^ (p - 1) * (z - y) / y ^ p = p * (z / y - 1)
[PROOFSTEP]
ring_nf at H1 ⊢
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ -(p * y ^ (-1 + p) * y * (y ^ p)⁻¹) + p * y ^ (-1 + p) * z * (y ^ p)⁻¹ = -p + p * z * y⁻¹
[PROOFSTEP]
field_simp [hy.ne', hy'.ne'] at H1 ⊢
[GOAL]
case h.e'_3
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ (-(p * y ^ (-1 + p) * y * y ^ p) + p * y ^ (-1 + p) * z * y ^ p) * y = (-(p * y) + p * z) * (y ^ p * y ^ p)
[PROOFSTEP]
linear_combination p * (y - z) * y ^ p * H1
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
⊢ (z ^ p - y ^ p) / y ^ p = (1 + (z / y - 1)) ^ p - 1
[PROOFSTEP]
have H : (z / y) ^ p = z ^ p / y ^ p := div_rpow hz hy.le _
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
H : (z / y) ^ p = z ^ p / y ^ p
⊢ (z ^ p - y ^ p) / y ^ p = (1 + (z / y - 1)) ^ p - 1
[PROOFSTEP]
ring_nf at H ⊢
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
H : (z * y⁻¹) ^ p = z ^ p * (y ^ p)⁻¹
⊢ z ^ p * (y ^ p)⁻¹ - y ^ p * (y ^ p)⁻¹ = -1 + (z * y⁻¹) ^ p
[PROOFSTEP]
field_simp [hy.ne', hy'.ne'] at H ⊢
[GOAL]
case h.e'_4
p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
H1 : y ^ p = y ^ (-1 + p) * y
hyz' : 0 < z - y
hyz'' : 1 < z / y
hyz''' : 0 < z / y - 1
hyz'''' : -1 ≤ z / y - 1
this : p * (z / y - 1) < (1 + (z / y - 1)) ^ p - 1
H : (z / y) ^ p * y ^ p = z ^ p
⊢ z ^ p - y ^ p = (-1 + (z / y) ^ p) * y ^ p
[PROOFSTEP]
linear_combination -H
[GOAL]
p : ℝ
hp : 1 ≤ p
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ p
[PROOFSTEP]
rcases eq_or_lt_of_le hp with (rfl | hp)
[GOAL]
case inl
hp : 1 ≤ 1
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ 1
[PROOFSTEP]
simpa using convexOn_id (convex_Ici _)
[GOAL]
case inr
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ ConvexOn ℝ (Ici 0) fun x => x ^ p
[PROOFSTEP]
exact (strictConvexOn_rpow hp).convexOn
[GOAL]
⊢ StrictConcaveOn ℝ (Iio 0) log
[PROOFSTEP]
refine' ⟨convex_Iio _, _⟩
[GOAL]
⊢ ∀ ⦃x : ℝ⦄,
    x ∈ Iio 0 →
      ∀ ⦃y : ℝ⦄,
        y ∈ Iio 0 → x ≠ y → ∀ ⦃a b : ℝ⦄, 0 < a → 0 < b → a + b = 1 → a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
rintro x (hx : x < 0) y (hy : y < 0) hxy a b ha hb hab
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
have hx' : 0 < -x := by linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < -x
[PROOFSTEP]
linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
⊢ a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
have hy' : 0 < -y := by linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
⊢ 0 < -y
[PROOFSTEP]
linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
⊢ a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
have hxy' : -x ≠ -y := by contrapose! hxy; linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
⊢ -x ≠ -y
[PROOFSTEP]
contrapose! hxy
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy : -x = -y
⊢ x = y
[PROOFSTEP]
linarith
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ a • log x + b • log y < log (a • x + b • y)
[PROOFSTEP]
calc
  a • log x + b • log y = a • log (-x) + b • log (-y) := by simp_rw [log_neg_eq_log]
  _ < log (a • -x + b • -y) := (strictConcaveOn_log_Ioi.2 hx' hy' hxy' ha hb hab)
  _ = log (-(a • x + b • y)) := by congr 1; simp only [Algebra.id.smul_eq_mul]; ring
  _ = _ := by rw [log_neg_eq_log]
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ a • log x + b • log y = a • log (-x) + b • log (-y)
[PROOFSTEP]
simp_rw [log_neg_eq_log]
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ log (a • -x + b • -y) = log (-(a • x + b • y))
[PROOFSTEP]
congr 1
[GOAL]
case e_x
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ a • -x + b • -y = -(a • x + b • y)
[PROOFSTEP]
simp only [Algebra.id.smul_eq_mul]
[GOAL]
case e_x
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ a * -x + b * -y = -(a * x + b * y)
[PROOFSTEP]
ring
[GOAL]
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx' : 0 < -x
hy' : 0 < -y
hxy' : -x ≠ -y
⊢ log (-(a • x + b • y)) = log (a • x + b • y)
[PROOFSTEP]
rw [log_neg_eq_log]


[GOAL]
⊢ MeasurablePow ℝ≥0∞ ℝ
[PROOFSTEP]
refine' ⟨ENNReal.measurable_of_measurable_nnreal_prod _ _⟩
[GOAL]
case refine'_1
⊢ Measurable fun p => (↑p.fst, p.snd).fst ^ (↑p.fst, p.snd).snd
[PROOFSTEP]
simp_rw [ENNReal.coe_rpow_def]
[GOAL]
case refine'_1
⊢ Measurable fun p => if p.fst = 0 ∧ p.snd < 0 then ⊤ else ↑(p.fst ^ p.snd)
[PROOFSTEP]
refine' Measurable.ite _ measurable_const (measurable_fst.pow measurable_snd).coe_nnreal_ennreal
[GOAL]
case refine'_1
⊢ MeasurableSet {a | a.fst = 0 ∧ a.snd < 0}
[PROOFSTEP]
exact MeasurableSet.inter (measurable_fst (measurableSet_singleton 0)) (measurable_snd measurableSet_Iio)
[GOAL]
case refine'_2
⊢ Measurable fun x => (⊤, x).fst ^ (⊤, x).snd
[PROOFSTEP]
simp_rw [ENNReal.top_rpow_def]
[GOAL]
case refine'_2
⊢ Measurable fun x => if 0 < x then ⊤ else if x = 0 then 1 else 0
[PROOFSTEP]
refine' Measurable.ite measurableSet_Ioi measurable_const _
[GOAL]
case refine'_2
⊢ Measurable fun x => if x = 0 then 1 else 0
[PROOFSTEP]
exact Measurable.ite (measurableSet_singleton 0) measurable_const measurable_const