Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | rank int64 0 2.4k |
|---|---|---|---|---|---|---|
import Mathlib.Analysis.Convex.Slope
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Tactic.LinearCombination
#align_import analysis.convex.specific_functions.basic from "leanprover-community/mathlib"@"8f9fea08977f7e450770933ee6abb20733b47c92"
open Real Set NNReal
theorem strictConvexOn_exp : StrictConvexOn β univ exp := by
apply strictConvexOn_of_slope_strict_mono_adjacent convex_univ
rintro x y z - - hxy hyz
trans exp y
Β· have h1 : 0 < y - x := by linarith
have h2 : x - y < 0 := by linarith
rw [div_lt_iff h1]
calc
exp y - exp x = exp y - exp y * exp (x - y) := by rw [β exp_add]; ring_nf
_ = exp y * (1 - exp (x - y)) := by ring
_ < exp y * -(x - y) := by gcongr; linarith [add_one_lt_exp h2.ne]
_ = exp y * (y - x) := by ring
Β· have h1 : 0 < z - y := by linarith
rw [lt_div_iff h1]
calc
exp y * (z - y) < exp y * (exp (z - y) - 1) := by
gcongr _ * ?_
linarith [add_one_lt_exp h1.ne']
_ = exp (z - y) * exp y - exp y := by ring
_ β€ exp z - exp y := by rw [β exp_add]; ring_nf; rfl
#align strict_convex_on_exp strictConvexOn_exp
theorem convexOn_exp : ConvexOn β univ exp :=
strictConvexOn_exp.convexOn
#align convex_on_exp convexOn_exp
| Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean | 67 | 94 | theorem strictConcaveOn_log_Ioi : StrictConcaveOn β (Ioi 0) log := by |
apply strictConcaveOn_of_slope_strict_anti_adjacent (convex_Ioi (0 : β))
intro x y z (hx : 0 < x) (hz : 0 < z) hxy hyz
have hy : 0 < y := hx.trans hxy
trans yβ»ΒΉ
Β· have h : 0 < z - y := by linarith
rw [div_lt_iff h]
have hyz' : 0 < z / y := by positivity
have hyz'' : z / y β 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
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
Β· have h : 0 < y - x := by linarith
rw [lt_div_iff h]
have hxy' : 0 < x / y := by positivity
have hxy'' : x / y β 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
calc
yβ»ΒΉ * (y - x) = 1 - x / y := by field_simp
_ < -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
| 1,571 |
import Mathlib.Analysis.Convex.Slope
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Tactic.LinearCombination
#align_import analysis.convex.specific_functions.basic from "leanprover-community/mathlib"@"8f9fea08977f7e450770933ee6abb20733b47c92"
open Real Set NNReal
theorem strictConvexOn_exp : StrictConvexOn β univ exp := by
apply strictConvexOn_of_slope_strict_mono_adjacent convex_univ
rintro x y z - - hxy hyz
trans exp y
Β· have h1 : 0 < y - x := by linarith
have h2 : x - y < 0 := by linarith
rw [div_lt_iff h1]
calc
exp y - exp x = exp y - exp y * exp (x - y) := by rw [β exp_add]; ring_nf
_ = exp y * (1 - exp (x - y)) := by ring
_ < exp y * -(x - y) := by gcongr; linarith [add_one_lt_exp h2.ne]
_ = exp y * (y - x) := by ring
Β· have h1 : 0 < z - y := by linarith
rw [lt_div_iff h1]
calc
exp y * (z - y) < exp y * (exp (z - y) - 1) := by
gcongr _ * ?_
linarith [add_one_lt_exp h1.ne']
_ = exp (z - y) * exp y - exp y := by ring
_ β€ exp z - exp y := by rw [β exp_add]; ring_nf; rfl
#align strict_convex_on_exp strictConvexOn_exp
theorem convexOn_exp : ConvexOn β univ exp :=
strictConvexOn_exp.convexOn
#align convex_on_exp convexOn_exp
theorem strictConcaveOn_log_Ioi : StrictConcaveOn β (Ioi 0) log := by
apply strictConcaveOn_of_slope_strict_anti_adjacent (convex_Ioi (0 : β))
intro x y z (hx : 0 < x) (hz : 0 < z) hxy hyz
have hy : 0 < y := hx.trans hxy
trans yβ»ΒΉ
Β· have h : 0 < z - y := by linarith
rw [div_lt_iff h]
have hyz' : 0 < z / y := by positivity
have hyz'' : z / y β 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
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
Β· have h : 0 < y - x := by linarith
rw [lt_div_iff h]
have hxy' : 0 < x / y := by positivity
have hxy'' : x / y β 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
calc
yβ»ΒΉ * (y - x) = 1 - x / y := by field_simp
_ < -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
#align strict_concave_on_log_Ioi strictConcaveOn_log_Ioi
| Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean | 99 | 122 | theorem one_add_mul_self_lt_rpow_one_add {s : β} (hs : -1 β€ s) (hs' : s β 0) {p : β} (hp : 1 < p) :
1 + p * s < (1 + s) ^ p := by |
have hp' : 0 < p := zero_lt_one.trans hp
rcases eq_or_lt_of_le hs with rfl | hs
Β· rwa [add_right_neg, zero_rpow hp'.ne', mul_neg_one, add_neg_lt_iff_lt_add, zero_add]
have hs1 : 0 < 1 + s := neg_lt_iff_pos_add'.mp hs
rcases le_or_lt (1 + p * s) 0 with hs2 | hs2
Β· exact hs2.trans_lt (rpow_pos_of_pos hs1 _)
have hs3 : 1 + s β 1 := hs' β add_right_eq_self.mp
have hs4 : 1 + p * s β 1 := by
contrapose! hs'; rwa [add_right_eq_self, mul_eq_zero, eq_false_intro hp'.ne', false_or] at hs'
rw [rpow_def_of_pos hs1, β exp_log hs2]
apply exp_strictMono
cases' lt_or_gt_of_ne hs' with hs' hs'
Β· rw [β div_lt_iff hp', β div_lt_div_right_of_neg hs']
convert strictConcaveOn_log_Ioi.secant_strict_mono (zero_lt_one' β) hs2 hs1 hs4 hs3 _ using 1
Β· rw [add_sub_cancel_left, log_one, sub_zero]
Β· rw [add_sub_cancel_left, div_div, log_one, sub_zero]
Β· apply add_lt_add_left (mul_lt_of_one_lt_left hs' hp)
Β· rw [β div_lt_iff hp', β div_lt_div_right hs']
convert strictConcaveOn_log_Ioi.secant_strict_mono (zero_lt_one' β) hs1 hs2 hs3 hs4 _ using 1
Β· rw [add_sub_cancel_left, div_div, log_one, sub_zero]
Β· rw [add_sub_cancel_left, log_one, sub_zero]
Β· apply add_lt_add_left (lt_mul_of_one_lt_left hs' hp)
| 1,571 |
import Mathlib.Analysis.Convex.Slope
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Tactic.LinearCombination
#align_import analysis.convex.specific_functions.basic from "leanprover-community/mathlib"@"8f9fea08977f7e450770933ee6abb20733b47c92"
open Real Set NNReal
theorem strictConvexOn_exp : StrictConvexOn β univ exp := by
apply strictConvexOn_of_slope_strict_mono_adjacent convex_univ
rintro x y z - - hxy hyz
trans exp y
Β· have h1 : 0 < y - x := by linarith
have h2 : x - y < 0 := by linarith
rw [div_lt_iff h1]
calc
exp y - exp x = exp y - exp y * exp (x - y) := by rw [β exp_add]; ring_nf
_ = exp y * (1 - exp (x - y)) := by ring
_ < exp y * -(x - y) := by gcongr; linarith [add_one_lt_exp h2.ne]
_ = exp y * (y - x) := by ring
Β· have h1 : 0 < z - y := by linarith
rw [lt_div_iff h1]
calc
exp y * (z - y) < exp y * (exp (z - y) - 1) := by
gcongr _ * ?_
linarith [add_one_lt_exp h1.ne']
_ = exp (z - y) * exp y - exp y := by ring
_ β€ exp z - exp y := by rw [β exp_add]; ring_nf; rfl
#align strict_convex_on_exp strictConvexOn_exp
theorem convexOn_exp : ConvexOn β univ exp :=
strictConvexOn_exp.convexOn
#align convex_on_exp convexOn_exp
theorem strictConcaveOn_log_Ioi : StrictConcaveOn β (Ioi 0) log := by
apply strictConcaveOn_of_slope_strict_anti_adjacent (convex_Ioi (0 : β))
intro x y z (hx : 0 < x) (hz : 0 < z) hxy hyz
have hy : 0 < y := hx.trans hxy
trans yβ»ΒΉ
Β· have h : 0 < z - y := by linarith
rw [div_lt_iff h]
have hyz' : 0 < z / y := by positivity
have hyz'' : z / y β 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
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
Β· have h : 0 < y - x := by linarith
rw [lt_div_iff h]
have hxy' : 0 < x / y := by positivity
have hxy'' : x / y β 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
calc
yβ»ΒΉ * (y - x) = 1 - x / y := by field_simp
_ < -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
#align strict_concave_on_log_Ioi strictConcaveOn_log_Ioi
theorem one_add_mul_self_lt_rpow_one_add {s : β} (hs : -1 β€ s) (hs' : s β 0) {p : β} (hp : 1 < p) :
1 + p * s < (1 + s) ^ p := by
have hp' : 0 < p := zero_lt_one.trans hp
rcases eq_or_lt_of_le hs with rfl | hs
Β· rwa [add_right_neg, zero_rpow hp'.ne', mul_neg_one, add_neg_lt_iff_lt_add, zero_add]
have hs1 : 0 < 1 + s := neg_lt_iff_pos_add'.mp hs
rcases le_or_lt (1 + p * s) 0 with hs2 | hs2
Β· exact hs2.trans_lt (rpow_pos_of_pos hs1 _)
have hs3 : 1 + s β 1 := hs' β add_right_eq_self.mp
have hs4 : 1 + p * s β 1 := by
contrapose! hs'; rwa [add_right_eq_self, mul_eq_zero, eq_false_intro hp'.ne', false_or] at hs'
rw [rpow_def_of_pos hs1, β exp_log hs2]
apply exp_strictMono
cases' lt_or_gt_of_ne hs' with hs' hs'
Β· rw [β div_lt_iff hp', β div_lt_div_right_of_neg hs']
convert strictConcaveOn_log_Ioi.secant_strict_mono (zero_lt_one' β) hs2 hs1 hs4 hs3 _ using 1
Β· rw [add_sub_cancel_left, log_one, sub_zero]
Β· rw [add_sub_cancel_left, div_div, log_one, sub_zero]
Β· apply add_lt_add_left (mul_lt_of_one_lt_left hs' hp)
Β· rw [β div_lt_iff hp', β div_lt_div_right hs']
convert strictConcaveOn_log_Ioi.secant_strict_mono (zero_lt_one' β) hs1 hs2 hs3 hs4 _ using 1
Β· rw [add_sub_cancel_left, div_div, log_one, sub_zero]
Β· rw [add_sub_cancel_left, log_one, sub_zero]
Β· apply add_lt_add_left (lt_mul_of_one_lt_left hs' hp)
#align one_add_mul_self_lt_rpow_one_add one_add_mul_self_lt_rpow_one_add
| Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean | 127 | 133 | theorem one_add_mul_self_le_rpow_one_add {s : β} (hs : -1 β€ s) {p : β} (hp : 1 β€ p) :
1 + p * s β€ (1 + s) ^ p := by |
rcases eq_or_lt_of_le hp with (rfl | hp)
Β· simp
by_cases hs' : s = 0
Β· simp [hs']
exact (one_add_mul_self_lt_rpow_one_add hs hs' hp).le
| 1,571 |
import Mathlib.Analysis.Convex.Slope
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Tactic.LinearCombination
#align_import analysis.convex.specific_functions.basic from "leanprover-community/mathlib"@"8f9fea08977f7e450770933ee6abb20733b47c92"
open Real Set NNReal
theorem strictConvexOn_exp : StrictConvexOn β univ exp := by
apply strictConvexOn_of_slope_strict_mono_adjacent convex_univ
rintro x y z - - hxy hyz
trans exp y
Β· have h1 : 0 < y - x := by linarith
have h2 : x - y < 0 := by linarith
rw [div_lt_iff h1]
calc
exp y - exp x = exp y - exp y * exp (x - y) := by rw [β exp_add]; ring_nf
_ = exp y * (1 - exp (x - y)) := by ring
_ < exp y * -(x - y) := by gcongr; linarith [add_one_lt_exp h2.ne]
_ = exp y * (y - x) := by ring
Β· have h1 : 0 < z - y := by linarith
rw [lt_div_iff h1]
calc
exp y * (z - y) < exp y * (exp (z - y) - 1) := by
gcongr _ * ?_
linarith [add_one_lt_exp h1.ne']
_ = exp (z - y) * exp y - exp y := by ring
_ β€ exp z - exp y := by rw [β exp_add]; ring_nf; rfl
#align strict_convex_on_exp strictConvexOn_exp
theorem convexOn_exp : ConvexOn β univ exp :=
strictConvexOn_exp.convexOn
#align convex_on_exp convexOn_exp
theorem strictConcaveOn_log_Ioi : StrictConcaveOn β (Ioi 0) log := by
apply strictConcaveOn_of_slope_strict_anti_adjacent (convex_Ioi (0 : β))
intro x y z (hx : 0 < x) (hz : 0 < z) hxy hyz
have hy : 0 < y := hx.trans hxy
trans yβ»ΒΉ
Β· have h : 0 < z - y := by linarith
rw [div_lt_iff h]
have hyz' : 0 < z / y := by positivity
have hyz'' : z / y β 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
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
Β· have h : 0 < y - x := by linarith
rw [lt_div_iff h]
have hxy' : 0 < x / y := by positivity
have hxy'' : x / y β 1 := by
contrapose! h
rw [div_eq_one_iff_eq hy.ne'] at h
simp [h]
calc
yβ»ΒΉ * (y - x) = 1 - x / y := by field_simp
_ < -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
#align strict_concave_on_log_Ioi strictConcaveOn_log_Ioi
theorem one_add_mul_self_lt_rpow_one_add {s : β} (hs : -1 β€ s) (hs' : s β 0) {p : β} (hp : 1 < p) :
1 + p * s < (1 + s) ^ p := by
have hp' : 0 < p := zero_lt_one.trans hp
rcases eq_or_lt_of_le hs with rfl | hs
Β· rwa [add_right_neg, zero_rpow hp'.ne', mul_neg_one, add_neg_lt_iff_lt_add, zero_add]
have hs1 : 0 < 1 + s := neg_lt_iff_pos_add'.mp hs
rcases le_or_lt (1 + p * s) 0 with hs2 | hs2
Β· exact hs2.trans_lt (rpow_pos_of_pos hs1 _)
have hs3 : 1 + s β 1 := hs' β add_right_eq_self.mp
have hs4 : 1 + p * s β 1 := by
contrapose! hs'; rwa [add_right_eq_self, mul_eq_zero, eq_false_intro hp'.ne', false_or] at hs'
rw [rpow_def_of_pos hs1, β exp_log hs2]
apply exp_strictMono
cases' lt_or_gt_of_ne hs' with hs' hs'
Β· rw [β div_lt_iff hp', β div_lt_div_right_of_neg hs']
convert strictConcaveOn_log_Ioi.secant_strict_mono (zero_lt_one' β) hs2 hs1 hs4 hs3 _ using 1
Β· rw [add_sub_cancel_left, log_one, sub_zero]
Β· rw [add_sub_cancel_left, div_div, log_one, sub_zero]
Β· apply add_lt_add_left (mul_lt_of_one_lt_left hs' hp)
Β· rw [β div_lt_iff hp', β div_lt_div_right hs']
convert strictConcaveOn_log_Ioi.secant_strict_mono (zero_lt_one' β) hs1 hs2 hs3 hs4 _ using 1
Β· rw [add_sub_cancel_left, div_div, log_one, sub_zero]
Β· rw [add_sub_cancel_left, log_one, sub_zero]
Β· apply add_lt_add_left (lt_mul_of_one_lt_left hs' hp)
#align one_add_mul_self_lt_rpow_one_add one_add_mul_self_lt_rpow_one_add
theorem one_add_mul_self_le_rpow_one_add {s : β} (hs : -1 β€ s) {p : β} (hp : 1 β€ p) :
1 + p * s β€ (1 + s) ^ p := by
rcases eq_or_lt_of_le hp with (rfl | hp)
Β· simp
by_cases hs' : s = 0
Β· simp [hs']
exact (one_add_mul_self_lt_rpow_one_add hs hs' hp).le
#align one_add_mul_self_le_rpow_one_add one_add_mul_self_le_rpow_one_add
| Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean | 138 | 163 | theorem rpow_one_add_lt_one_add_mul_self {s : β} (hs : -1 β€ s) (hs' : s β 0) {p : β} (hp1 : 0 < p)
(hp2 : p < 1) : (1 + s) ^ p < 1 + p * s := by |
rcases eq_or_lt_of_le hs with rfl | hs
Β· rwa [add_right_neg, zero_rpow hp1.ne', mul_neg_one, lt_add_neg_iff_add_lt, zero_add]
have hs1 : 0 < 1 + s := neg_lt_iff_pos_add'.mp hs
have hs2 : 0 < 1 + p * s := by
rw [β neg_lt_iff_pos_add']
rcases lt_or_gt_of_ne hs' with h | h
Β· exact hs.trans (lt_mul_of_lt_one_left h hp2)
Β· exact neg_one_lt_zero.trans (mul_pos hp1 h)
have hs3 : 1 + s β 1 := hs' β add_right_eq_self.mp
have hs4 : 1 + p * s β 1 := by
contrapose! hs'; rwa [add_right_eq_self, mul_eq_zero, eq_false_intro hp1.ne', false_or] at hs'
rw [rpow_def_of_pos hs1, β exp_log hs2]
apply exp_strictMono
cases' lt_or_gt_of_ne hs' with hs' hs'
Β· rw [β lt_div_iff hp1, β div_lt_div_right_of_neg hs']
convert strictConcaveOn_log_Ioi.secant_strict_mono (zero_lt_one' β) hs1 hs2 hs3 hs4 _ using 1
Β· rw [add_sub_cancel_left, div_div, log_one, sub_zero]
Β· rw [add_sub_cancel_left, log_one, sub_zero]
Β· apply add_lt_add_left (lt_mul_of_lt_one_left hs' hp2)
Β· rw [β lt_div_iff hp1, β div_lt_div_right hs']
convert strictConcaveOn_log_Ioi.secant_strict_mono (zero_lt_one' β) hs2 hs1 hs4 hs3 _ using 1
Β· rw [add_sub_cancel_left, log_one, sub_zero]
Β· rw [add_sub_cancel_left, div_div, log_one, sub_zero]
Β· apply add_lt_add_left (mul_lt_of_lt_one_left hs' hp2)
| 1,571 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 49 | 49 | theorem logb_zero : logb b 0 = 0 := by | simp [logb]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 53 | 53 | theorem logb_one : logb b 1 = 0 := by | simp [logb]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 64 | 64 | theorem logb_abs (x : β) : logb b |x| = logb b x := by | rw [logb, logb, log_abs]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 68 | 69 | theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by |
rw [β logb_abs x, β logb_abs (-x), abs_neg]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 72 | 73 | theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by |
simp_rw [logb, log_mul hx hy, add_div]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 76 | 77 | theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by |
simp_rw [logb, log_div hx hy, sub_div]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 81 | 81 | theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by | simp [logb, neg_div]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 84 | 84 | theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by | simp_rw [logb, inv_div]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 87 | 89 | theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by |
simp_rw [inv_logb]; exact logb_mul hβ hβ
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 92 | 94 | theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by |
simp_rw [inv_logb]; exact logb_div hβ hβ
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 97 | 98 | theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by | rw [β inv_logb_mul_base hβ hβ c, inv_inv]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 101 | 102 | theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by | rw [β inv_logb_div_base hβ hβ c, inv_inv]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_div_base hβ hβ c, inv_inv]
#align real.logb_div_base Real.logb_div_base
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 105 | 108 | theorem mul_logb {a b c : β} (hβ : b β 0) (hβ : b β 1) (hβ : b β -1) :
logb a b * logb b c = logb a c := by |
unfold logb
rw [mul_comm, div_mul_div_cancel _ (log_ne_zero.mpr β¨hβ, hβ, hββ©)]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_div_base hβ hβ c, inv_inv]
#align real.logb_div_base Real.logb_div_base
theorem mul_logb {a b c : β} (hβ : b β 0) (hβ : b β 1) (hβ : b β -1) :
logb a b * logb b c = logb a c := by
unfold logb
rw [mul_comm, div_mul_div_cancel _ (log_ne_zero.mpr β¨hβ, hβ, hββ©)]
#align real.mul_logb Real.mul_logb
theorem div_logb {a b c : β} (hβ : c β 0) (hβ : c β 1) (hβ : c β -1) :
logb a c / logb b c = logb a b :=
div_div_div_cancel_left' _ _ <| log_ne_zero.mpr β¨hβ, hβ, hββ©
#align real.div_logb Real.div_logb
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 116 | 117 | theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x := by |
rw [logb, log_rpow hx, logb, mul_div_assoc]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_div_base hβ hβ c, inv_inv]
#align real.logb_div_base Real.logb_div_base
theorem mul_logb {a b c : β} (hβ : b β 0) (hβ : b β 1) (hβ : b β -1) :
logb a b * logb b c = logb a c := by
unfold logb
rw [mul_comm, div_mul_div_cancel _ (log_ne_zero.mpr β¨hβ, hβ, hββ©)]
#align real.mul_logb Real.mul_logb
theorem div_logb {a b c : β} (hβ : c β 0) (hβ : c β 1) (hβ : c β -1) :
logb a c / logb b c = logb a b :=
div_div_div_cancel_left' _ _ <| log_ne_zero.mpr β¨hβ, hβ, hββ©
#align real.div_logb Real.div_logb
theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x := by
rw [logb, log_rpow hx, logb, mul_div_assoc]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 119 | 120 | theorem logb_pow {k : β} (hx : 0 < x) : logb b (x ^ k) = k * logb b x := by |
rw [β rpow_natCast, logb_rpow_eq_mul_logb_of_pos hx]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_div_base hβ hβ c, inv_inv]
#align real.logb_div_base Real.logb_div_base
theorem mul_logb {a b c : β} (hβ : b β 0) (hβ : b β 1) (hβ : b β -1) :
logb a b * logb b c = logb a c := by
unfold logb
rw [mul_comm, div_mul_div_cancel _ (log_ne_zero.mpr β¨hβ, hβ, hββ©)]
#align real.mul_logb Real.mul_logb
theorem div_logb {a b c : β} (hβ : c β 0) (hβ : c β 1) (hβ : c β -1) :
logb a c / logb b c = logb a b :=
div_div_div_cancel_left' _ _ <| log_ne_zero.mpr β¨hβ, hβ, hββ©
#align real.div_logb Real.div_logb
theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x := by
rw [logb, log_rpow hx, logb, mul_div_assoc]
theorem logb_pow {k : β} (hx : 0 < x) : logb b (x ^ k) = k * logb b x := by
rw [β rpow_natCast, logb_rpow_eq_mul_logb_of_pos hx]
section BPosAndNeOne
variable (b_pos : 0 < b) (b_ne_one : b β 1)
private theorem log_b_ne_zero : log b β 0 := by
have b_ne_zero : b β 0 := by linarith
have b_ne_minus_one : b β -1 := by linarith
simp [b_ne_one, b_ne_zero, b_ne_minus_one]
@[simp]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 132 | 134 | theorem logb_rpow : logb b (b ^ x) = x := by |
rw [logb, div_eq_iff, log_rpow b_pos]
exact log_b_ne_zero b_pos b_ne_one
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_div_base hβ hβ c, inv_inv]
#align real.logb_div_base Real.logb_div_base
theorem mul_logb {a b c : β} (hβ : b β 0) (hβ : b β 1) (hβ : b β -1) :
logb a b * logb b c = logb a c := by
unfold logb
rw [mul_comm, div_mul_div_cancel _ (log_ne_zero.mpr β¨hβ, hβ, hββ©)]
#align real.mul_logb Real.mul_logb
theorem div_logb {a b c : β} (hβ : c β 0) (hβ : c β 1) (hβ : c β -1) :
logb a c / logb b c = logb a b :=
div_div_div_cancel_left' _ _ <| log_ne_zero.mpr β¨hβ, hβ, hββ©
#align real.div_logb Real.div_logb
theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x := by
rw [logb, log_rpow hx, logb, mul_div_assoc]
theorem logb_pow {k : β} (hx : 0 < x) : logb b (x ^ k) = k * logb b x := by
rw [β rpow_natCast, logb_rpow_eq_mul_logb_of_pos hx]
section BPosAndNeOne
variable (b_pos : 0 < b) (b_ne_one : b β 1)
private theorem log_b_ne_zero : log b β 0 := by
have b_ne_zero : b β 0 := by linarith
have b_ne_minus_one : b β -1 := by linarith
simp [b_ne_one, b_ne_zero, b_ne_minus_one]
@[simp]
theorem logb_rpow : logb b (b ^ x) = x := by
rw [logb, div_eq_iff, log_rpow b_pos]
exact log_b_ne_zero b_pos b_ne_one
#align real.logb_rpow Real.logb_rpow
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 137 | 143 | theorem rpow_logb_eq_abs (hx : x β 0) : b ^ logb b x = |x| := by |
apply log_injOn_pos
Β· simp only [Set.mem_Ioi]
apply rpow_pos_of_pos b_pos
Β· simp only [abs_pos, mem_Ioi, Ne, hx, not_false_iff]
rw [log_rpow b_pos, logb, log_abs]
field_simp [log_b_ne_zero b_pos b_ne_one]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_div_base hβ hβ c, inv_inv]
#align real.logb_div_base Real.logb_div_base
theorem mul_logb {a b c : β} (hβ : b β 0) (hβ : b β 1) (hβ : b β -1) :
logb a b * logb b c = logb a c := by
unfold logb
rw [mul_comm, div_mul_div_cancel _ (log_ne_zero.mpr β¨hβ, hβ, hββ©)]
#align real.mul_logb Real.mul_logb
theorem div_logb {a b c : β} (hβ : c β 0) (hβ : c β 1) (hβ : c β -1) :
logb a c / logb b c = logb a b :=
div_div_div_cancel_left' _ _ <| log_ne_zero.mpr β¨hβ, hβ, hββ©
#align real.div_logb Real.div_logb
theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x := by
rw [logb, log_rpow hx, logb, mul_div_assoc]
theorem logb_pow {k : β} (hx : 0 < x) : logb b (x ^ k) = k * logb b x := by
rw [β rpow_natCast, logb_rpow_eq_mul_logb_of_pos hx]
section OneLtB
variable (hb : 1 < b)
private theorem b_pos : 0 < b := by linarith
-- Porting note: prime added to avoid clashing with `b_ne_one` further down the file
private theorem b_ne_one' : b β 1 := by linarith
@[simp]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 195 | 196 | theorem logb_le_logb (h : 0 < x) (hβ : 0 < y) : logb b x β€ logb b y β x β€ y := by |
rw [logb, logb, div_le_div_right (log_pos hb), log_le_log_iff h hβ]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_div_base hβ hβ c, inv_inv]
#align real.logb_div_base Real.logb_div_base
theorem mul_logb {a b c : β} (hβ : b β 0) (hβ : b β 1) (hβ : b β -1) :
logb a b * logb b c = logb a c := by
unfold logb
rw [mul_comm, div_mul_div_cancel _ (log_ne_zero.mpr β¨hβ, hβ, hββ©)]
#align real.mul_logb Real.mul_logb
theorem div_logb {a b c : β} (hβ : c β 0) (hβ : c β 1) (hβ : c β -1) :
logb a c / logb b c = logb a b :=
div_div_div_cancel_left' _ _ <| log_ne_zero.mpr β¨hβ, hβ, hββ©
#align real.div_logb Real.div_logb
theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x := by
rw [logb, log_rpow hx, logb, mul_div_assoc]
theorem logb_pow {k : β} (hx : 0 < x) : logb b (x ^ k) = k * logb b x := by
rw [β rpow_natCast, logb_rpow_eq_mul_logb_of_pos hx]
section BPosAndBLtOne
variable (b_pos : 0 < b) (b_lt_one : b < 1)
private theorem b_ne_one : b β 1 := by linarith
@[simp]
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 308 | 309 | theorem logb_le_logb_of_base_lt_one (h : 0 < x) (hβ : 0 < y) : logb b x β€ logb b y β y β€ x := by |
rw [logb, logb, div_le_div_right_of_neg (log_neg b_pos b_lt_one), log_le_log_iff hβ h]
| 1,572 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : β}
-- @[pp_nodot] -- Porting note: removed
noncomputable def logb (b x : β) : β :=
log x / log b
#align real.logb Real.logb
theorem log_div_log : log x / log b = logb b x :=
rfl
#align real.log_div_log Real.log_div_log
@[simp]
theorem logb_zero : logb b 0 = 0 := by simp [logb]
#align real.logb_zero Real.logb_zero
@[simp]
theorem logb_one : logb b 1 = 0 := by simp [logb]
#align real.logb_one Real.logb_one
@[simp]
lemma logb_self_eq_one (hb : 1 < b) : logb b b = 1 :=
div_self (log_pos hb).ne'
lemma logb_self_eq_one_iff : logb b b = 1 β b β 0 β§ b β 1 β§ b β -1 :=
Iff.trans β¨fun h h' => by simp [logb, h'] at h, div_selfβ© log_ne_zero
@[simp]
theorem logb_abs (x : β) : logb b |x| = logb b x := by rw [logb, logb, log_abs]
#align real.logb_abs Real.logb_abs
@[simp]
theorem logb_neg_eq_logb (x : β) : logb b (-x) = logb b x := by
rw [β logb_abs x, β logb_abs (-x), abs_neg]
#align real.logb_neg_eq_logb Real.logb_neg_eq_logb
theorem logb_mul (hx : x β 0) (hy : y β 0) : logb b (x * y) = logb b x + logb b y := by
simp_rw [logb, log_mul hx hy, add_div]
#align real.logb_mul Real.logb_mul
theorem logb_div (hx : x β 0) (hy : y β 0) : logb b (x / y) = logb b x - logb b y := by
simp_rw [logb, log_div hx hy, sub_div]
#align real.logb_div Real.logb_div
@[simp]
theorem logb_inv (x : β) : logb b xβ»ΒΉ = -logb b x := by simp [logb, neg_div]
#align real.logb_inv Real.logb_inv
theorem inv_logb (a b : β) : (logb a b)β»ΒΉ = logb b a := by simp_rw [logb, inv_div]
#align real.inv_logb Real.inv_logb
theorem inv_logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a * b) c)β»ΒΉ = (logb a c)β»ΒΉ + (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_mul hβ hβ
#align real.inv_logb_mul_base Real.inv_logb_mul_base
theorem inv_logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
(logb (a / b) c)β»ΒΉ = (logb a c)β»ΒΉ - (logb b c)β»ΒΉ := by
simp_rw [inv_logb]; exact logb_div hβ hβ
#align real.inv_logb_div_base Real.inv_logb_div_base
theorem logb_mul_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a * b) c = ((logb a c)β»ΒΉ + (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_mul_base hβ hβ c, inv_inv]
#align real.logb_mul_base Real.logb_mul_base
theorem logb_div_base {a b : β} (hβ : a β 0) (hβ : b β 0) (c : β) :
logb (a / b) c = ((logb a c)β»ΒΉ - (logb b c)β»ΒΉ)β»ΒΉ := by rw [β inv_logb_div_base hβ hβ c, inv_inv]
#align real.logb_div_base Real.logb_div_base
theorem mul_logb {a b c : β} (hβ : b β 0) (hβ : b β 1) (hβ : b β -1) :
logb a b * logb b c = logb a c := by
unfold logb
rw [mul_comm, div_mul_div_cancel _ (log_ne_zero.mpr β¨hβ, hβ, hββ©)]
#align real.mul_logb Real.mul_logb
theorem div_logb {a b c : β} (hβ : c β 0) (hβ : c β 1) (hβ : c β -1) :
logb a c / logb b c = logb a b :=
div_div_div_cancel_left' _ _ <| log_ne_zero.mpr β¨hβ, hβ, hββ©
#align real.div_logb Real.div_logb
theorem logb_rpow_eq_mul_logb_of_pos (hx : 0 < x) : logb b (x ^ y) = y * logb b x := by
rw [logb, log_rpow hx, logb, mul_div_assoc]
theorem logb_pow {k : β} (hx : 0 < x) : logb b (x ^ k) = k * logb b x := by
rw [β rpow_natCast, logb_rpow_eq_mul_logb_of_pos hx]
section BPosAndBLtOne
variable (b_pos : 0 < b) (b_lt_one : b < 1)
private theorem b_ne_one : b β 1 := by linarith
@[simp]
theorem logb_le_logb_of_base_lt_one (h : 0 < x) (hβ : 0 < y) : logb b x β€ logb b y β y β€ x := by
rw [logb, logb, div_le_div_right_of_neg (log_neg b_pos b_lt_one), log_le_log_iff hβ h]
#align real.logb_le_logb_of_base_lt_one Real.logb_le_logb_of_base_lt_one
| Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 312 | 314 | theorem logb_lt_logb_of_base_lt_one (hx : 0 < x) (hxy : x < y) : logb b y < logb b x := by |
rw [logb, logb, div_lt_div_right_of_neg (log_neg b_pos b_lt_one)]
exact log_lt_log hx hxy
| 1,572 |
import Mathlib.Algebra.Order.Hom.Ring
import Mathlib.Algebra.Order.Pointwise
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import algebra.order.complete_field from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
variable {F Ξ± Ξ² Ξ³ : Type*}
noncomputable section
open Function Rat Real Set
open scoped Classical Pointwise
-- @[protect_proj] -- Porting note: does not exist anymore
class ConditionallyCompleteLinearOrderedField (Ξ± : Type*) extends
LinearOrderedField Ξ±, ConditionallyCompleteLinearOrder Ξ±
#align conditionally_complete_linear_ordered_field ConditionallyCompleteLinearOrderedField
-- see Note [lower instance priority]
instance (priority := 100) ConditionallyCompleteLinearOrderedField.to_archimedean
[ConditionallyCompleteLinearOrderedField Ξ±] : Archimedean Ξ± :=
archimedean_iff_nat_lt.2
(by
by_contra! h
obtain β¨x, hβ© := h
have := csSup_le _ _ (range_nonempty Nat.cast)
(forall_mem_range.2 fun m =>
le_sub_iff_add_le.2 <| le_csSup _ _ β¨x, forall_mem_range.2 hβ© β¨m+1, Nat.cast_succ mβ©)
linarith)
#align conditionally_complete_linear_ordered_field.to_archimedean ConditionallyCompleteLinearOrderedField.to_archimedean
instance : ConditionallyCompleteLinearOrderedField β :=
{ (inferInstance : LinearOrderedField β),
(inferInstance : ConditionallyCompleteLinearOrder β) with }
namespace LinearOrderedField
section CutMap
variable [LinearOrderedField Ξ±]
section DivisionRing
variable (Ξ²) [DivisionRing Ξ²] {a aβ aβ : Ξ±} {b : Ξ²} {q : β}
def cutMap (a : Ξ±) : Set Ξ² :=
(Rat.cast : β β Ξ²) '' {t | βt < a}
#align linear_ordered_field.cut_map LinearOrderedField.cutMap
theorem cutMap_mono (h : aβ β€ aβ) : cutMap Ξ² aβ β cutMap Ξ² aβ := image_subset _ fun _ => h.trans_lt'
#align linear_ordered_field.cut_map_mono LinearOrderedField.cutMap_mono
variable {Ξ²}
@[simp]
theorem mem_cutMap_iff : b β cutMap Ξ² a β β q : β, (q : Ξ±) < a β§ (q : Ξ²) = b := Iff.rfl
#align linear_ordered_field.mem_cut_map_iff LinearOrderedField.mem_cutMap_iff
-- @[simp] -- Porting note: not in simpNF
theorem coe_mem_cutMap_iff [CharZero Ξ²] : (q : Ξ²) β cutMap Ξ² a β (q : Ξ±) < a :=
Rat.cast_injective.mem_set_image
#align linear_ordered_field.coe_mem_cut_map_iff LinearOrderedField.coe_mem_cutMap_iff
| Mathlib/Algebra/Order/CompleteField.lean | 121 | 127 | theorem cutMap_self (a : Ξ±) : cutMap Ξ± a = Iio a β© range (Rat.cast : β β Ξ±) := by |
ext
constructor
Β· rintro β¨q, h, rflβ©
exact β¨h, q, rflβ©
Β· rintro β¨h, q, rflβ©
exact β¨q, h, rflβ©
| 1,573 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.special_functions.pow.nnreal from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real NNReal ENNReal ComplexConjugate
open Finset Function Set
namespace NNReal
variable {w x y z : β}
noncomputable def rpow (x : ββ₯0) (y : β) : ββ₯0 :=
β¨(x : β) ^ y, Real.rpow_nonneg x.2 yβ©
#align nnreal.rpow NNReal.rpow
noncomputable instance : Pow ββ₯0 β :=
β¨rpowβ©
@[simp]
theorem rpow_eq_pow (x : ββ₯0) (y : β) : rpow x y = x ^ y :=
rfl
#align nnreal.rpow_eq_pow NNReal.rpow_eq_pow
@[simp, norm_cast]
theorem coe_rpow (x : ββ₯0) (y : β) : ((x ^ y : ββ₯0) : β) = (x : β) ^ y :=
rfl
#align nnreal.coe_rpow NNReal.coe_rpow
@[simp]
theorem rpow_zero (x : ββ₯0) : x ^ (0 : β) = 1 :=
NNReal.eq <| Real.rpow_zero _
#align nnreal.rpow_zero NNReal.rpow_zero
@[simp]
| Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean | 57 | 59 | theorem rpow_eq_zero_iff {x : ββ₯0} {y : β} : x ^ y = 0 β x = 0 β§ y β 0 := by |
rw [β NNReal.coe_inj, coe_rpow, β NNReal.coe_eq_zero]
exact Real.rpow_eq_zero_iff_of_nonneg x.2
| 1,574 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.special_functions.pow.nnreal from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real NNReal ENNReal ComplexConjugate
open Finset Function Set
namespace NNReal
variable {w x y z : β}
noncomputable def rpow (x : ββ₯0) (y : β) : ββ₯0 :=
β¨(x : β) ^ y, Real.rpow_nonneg x.2 yβ©
#align nnreal.rpow NNReal.rpow
noncomputable instance : Pow ββ₯0 β :=
β¨rpowβ©
@[simp]
theorem rpow_eq_pow (x : ββ₯0) (y : β) : rpow x y = x ^ y :=
rfl
#align nnreal.rpow_eq_pow NNReal.rpow_eq_pow
@[simp, norm_cast]
theorem coe_rpow (x : ββ₯0) (y : β) : ((x ^ y : ββ₯0) : β) = (x : β) ^ y :=
rfl
#align nnreal.coe_rpow NNReal.coe_rpow
@[simp]
theorem rpow_zero (x : ββ₯0) : x ^ (0 : β) = 1 :=
NNReal.eq <| Real.rpow_zero _
#align nnreal.rpow_zero NNReal.rpow_zero
@[simp]
theorem rpow_eq_zero_iff {x : ββ₯0} {y : β} : x ^ y = 0 β x = 0 β§ y β 0 := by
rw [β NNReal.coe_inj, coe_rpow, β NNReal.coe_eq_zero]
exact Real.rpow_eq_zero_iff_of_nonneg x.2
#align nnreal.rpow_eq_zero_iff NNReal.rpow_eq_zero_iff
@[simp]
theorem zero_rpow {x : β} (h : x β 0) : (0 : ββ₯0) ^ x = 0 :=
NNReal.eq <| Real.zero_rpow h
#align nnreal.zero_rpow NNReal.zero_rpow
@[simp]
theorem rpow_one (x : ββ₯0) : x ^ (1 : β) = x :=
NNReal.eq <| Real.rpow_one _
#align nnreal.rpow_one NNReal.rpow_one
@[simp]
theorem one_rpow (x : β) : (1 : ββ₯0) ^ x = 1 :=
NNReal.eq <| Real.one_rpow _
#align nnreal.one_rpow NNReal.one_rpow
theorem rpow_add {x : ββ₯0} (hx : x β 0) (y z : β) : x ^ (y + z) = x ^ y * x ^ z :=
NNReal.eq <| Real.rpow_add (pos_iff_ne_zero.2 hx) _ _
#align nnreal.rpow_add NNReal.rpow_add
theorem rpow_add' (x : ββ₯0) {y z : β} (h : y + z β 0) : x ^ (y + z) = x ^ y * x ^ z :=
NNReal.eq <| Real.rpow_add' x.2 h
#align nnreal.rpow_add' NNReal.rpow_add'
lemma rpow_of_add_eq (x : ββ₯0) (hw : w β 0) (h : y + z = w) : x ^ w = x ^ y * x ^ z := by
rw [β h, rpow_add']; rwa [h]
theorem rpow_mul (x : ββ₯0) (y z : β) : x ^ (y * z) = (x ^ y) ^ z :=
NNReal.eq <| Real.rpow_mul x.2 y z
#align nnreal.rpow_mul NNReal.rpow_mul
theorem rpow_neg (x : ββ₯0) (y : β) : x ^ (-y) = (x ^ y)β»ΒΉ :=
NNReal.eq <| Real.rpow_neg x.2 _
#align nnreal.rpow_neg NNReal.rpow_neg
| Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean | 97 | 97 | theorem rpow_neg_one (x : ββ₯0) : x ^ (-1 : β) = xβ»ΒΉ := by | simp [rpow_neg]
| 1,574 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.special_functions.pow.nnreal from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real NNReal ENNReal ComplexConjugate
open Finset Function Set
namespace NNReal
variable {w x y z : β}
noncomputable def rpow (x : ββ₯0) (y : β) : ββ₯0 :=
β¨(x : β) ^ y, Real.rpow_nonneg x.2 yβ©
#align nnreal.rpow NNReal.rpow
noncomputable instance : Pow ββ₯0 β :=
β¨rpowβ©
@[simp]
theorem rpow_eq_pow (x : ββ₯0) (y : β) : rpow x y = x ^ y :=
rfl
#align nnreal.rpow_eq_pow NNReal.rpow_eq_pow
@[simp, norm_cast]
theorem coe_rpow (x : ββ₯0) (y : β) : ((x ^ y : ββ₯0) : β) = (x : β) ^ y :=
rfl
#align nnreal.coe_rpow NNReal.coe_rpow
@[simp]
theorem rpow_zero (x : ββ₯0) : x ^ (0 : β) = 1 :=
NNReal.eq <| Real.rpow_zero _
#align nnreal.rpow_zero NNReal.rpow_zero
@[simp]
theorem rpow_eq_zero_iff {x : ββ₯0} {y : β} : x ^ y = 0 β x = 0 β§ y β 0 := by
rw [β NNReal.coe_inj, coe_rpow, β NNReal.coe_eq_zero]
exact Real.rpow_eq_zero_iff_of_nonneg x.2
#align nnreal.rpow_eq_zero_iff NNReal.rpow_eq_zero_iff
@[simp]
theorem zero_rpow {x : β} (h : x β 0) : (0 : ββ₯0) ^ x = 0 :=
NNReal.eq <| Real.zero_rpow h
#align nnreal.zero_rpow NNReal.zero_rpow
@[simp]
theorem rpow_one (x : ββ₯0) : x ^ (1 : β) = x :=
NNReal.eq <| Real.rpow_one _
#align nnreal.rpow_one NNReal.rpow_one
@[simp]
theorem one_rpow (x : β) : (1 : ββ₯0) ^ x = 1 :=
NNReal.eq <| Real.one_rpow _
#align nnreal.one_rpow NNReal.one_rpow
theorem rpow_add {x : ββ₯0} (hx : x β 0) (y z : β) : x ^ (y + z) = x ^ y * x ^ z :=
NNReal.eq <| Real.rpow_add (pos_iff_ne_zero.2 hx) _ _
#align nnreal.rpow_add NNReal.rpow_add
theorem rpow_add' (x : ββ₯0) {y z : β} (h : y + z β 0) : x ^ (y + z) = x ^ y * x ^ z :=
NNReal.eq <| Real.rpow_add' x.2 h
#align nnreal.rpow_add' NNReal.rpow_add'
lemma rpow_of_add_eq (x : ββ₯0) (hw : w β 0) (h : y + z = w) : x ^ w = x ^ y * x ^ z := by
rw [β h, rpow_add']; rwa [h]
theorem rpow_mul (x : ββ₯0) (y z : β) : x ^ (y * z) = (x ^ y) ^ z :=
NNReal.eq <| Real.rpow_mul x.2 y z
#align nnreal.rpow_mul NNReal.rpow_mul
theorem rpow_neg (x : ββ₯0) (y : β) : x ^ (-y) = (x ^ y)β»ΒΉ :=
NNReal.eq <| Real.rpow_neg x.2 _
#align nnreal.rpow_neg NNReal.rpow_neg
theorem rpow_neg_one (x : ββ₯0) : x ^ (-1 : β) = xβ»ΒΉ := by simp [rpow_neg]
#align nnreal.rpow_neg_one NNReal.rpow_neg_one
theorem rpow_sub {x : ββ₯0} (hx : x β 0) (y z : β) : x ^ (y - z) = x ^ y / x ^ z :=
NNReal.eq <| Real.rpow_sub (pos_iff_ne_zero.2 hx) y z
#align nnreal.rpow_sub NNReal.rpow_sub
theorem rpow_sub' (x : ββ₯0) {y z : β} (h : y - z β 0) : x ^ (y - z) = x ^ y / x ^ z :=
NNReal.eq <| Real.rpow_sub' x.2 h
#align nnreal.rpow_sub' NNReal.rpow_sub'
| Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean | 108 | 109 | theorem rpow_inv_rpow_self {y : β} (hy : y β 0) (x : ββ₯0) : (x ^ y) ^ (1 / y) = x := by |
field_simp [β rpow_mul]
| 1,574 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.special_functions.pow.nnreal from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real NNReal ENNReal ComplexConjugate
open Finset Function Set
namespace NNReal
variable {w x y z : β}
noncomputable def rpow (x : ββ₯0) (y : β) : ββ₯0 :=
β¨(x : β) ^ y, Real.rpow_nonneg x.2 yβ©
#align nnreal.rpow NNReal.rpow
noncomputable instance : Pow ββ₯0 β :=
β¨rpowβ©
@[simp]
theorem rpow_eq_pow (x : ββ₯0) (y : β) : rpow x y = x ^ y :=
rfl
#align nnreal.rpow_eq_pow NNReal.rpow_eq_pow
@[simp, norm_cast]
theorem coe_rpow (x : ββ₯0) (y : β) : ((x ^ y : ββ₯0) : β) = (x : β) ^ y :=
rfl
#align nnreal.coe_rpow NNReal.coe_rpow
@[simp]
theorem rpow_zero (x : ββ₯0) : x ^ (0 : β) = 1 :=
NNReal.eq <| Real.rpow_zero _
#align nnreal.rpow_zero NNReal.rpow_zero
@[simp]
theorem rpow_eq_zero_iff {x : ββ₯0} {y : β} : x ^ y = 0 β x = 0 β§ y β 0 := by
rw [β NNReal.coe_inj, coe_rpow, β NNReal.coe_eq_zero]
exact Real.rpow_eq_zero_iff_of_nonneg x.2
#align nnreal.rpow_eq_zero_iff NNReal.rpow_eq_zero_iff
@[simp]
theorem zero_rpow {x : β} (h : x β 0) : (0 : ββ₯0) ^ x = 0 :=
NNReal.eq <| Real.zero_rpow h
#align nnreal.zero_rpow NNReal.zero_rpow
@[simp]
theorem rpow_one (x : ββ₯0) : x ^ (1 : β) = x :=
NNReal.eq <| Real.rpow_one _
#align nnreal.rpow_one NNReal.rpow_one
@[simp]
theorem one_rpow (x : β) : (1 : ββ₯0) ^ x = 1 :=
NNReal.eq <| Real.one_rpow _
#align nnreal.one_rpow NNReal.one_rpow
theorem rpow_add {x : ββ₯0} (hx : x β 0) (y z : β) : x ^ (y + z) = x ^ y * x ^ z :=
NNReal.eq <| Real.rpow_add (pos_iff_ne_zero.2 hx) _ _
#align nnreal.rpow_add NNReal.rpow_add
theorem rpow_add' (x : ββ₯0) {y z : β} (h : y + z β 0) : x ^ (y + z) = x ^ y * x ^ z :=
NNReal.eq <| Real.rpow_add' x.2 h
#align nnreal.rpow_add' NNReal.rpow_add'
lemma rpow_of_add_eq (x : ββ₯0) (hw : w β 0) (h : y + z = w) : x ^ w = x ^ y * x ^ z := by
rw [β h, rpow_add']; rwa [h]
theorem rpow_mul (x : ββ₯0) (y z : β) : x ^ (y * z) = (x ^ y) ^ z :=
NNReal.eq <| Real.rpow_mul x.2 y z
#align nnreal.rpow_mul NNReal.rpow_mul
theorem rpow_neg (x : ββ₯0) (y : β) : x ^ (-y) = (x ^ y)β»ΒΉ :=
NNReal.eq <| Real.rpow_neg x.2 _
#align nnreal.rpow_neg NNReal.rpow_neg
theorem rpow_neg_one (x : ββ₯0) : x ^ (-1 : β) = xβ»ΒΉ := by simp [rpow_neg]
#align nnreal.rpow_neg_one NNReal.rpow_neg_one
theorem rpow_sub {x : ββ₯0} (hx : x β 0) (y z : β) : x ^ (y - z) = x ^ y / x ^ z :=
NNReal.eq <| Real.rpow_sub (pos_iff_ne_zero.2 hx) y z
#align nnreal.rpow_sub NNReal.rpow_sub
theorem rpow_sub' (x : ββ₯0) {y z : β} (h : y - z β 0) : x ^ (y - z) = x ^ y / x ^ z :=
NNReal.eq <| Real.rpow_sub' x.2 h
#align nnreal.rpow_sub' NNReal.rpow_sub'
theorem rpow_inv_rpow_self {y : β} (hy : y β 0) (x : ββ₯0) : (x ^ y) ^ (1 / y) = x := by
field_simp [β rpow_mul]
#align nnreal.rpow_inv_rpow_self NNReal.rpow_inv_rpow_self
| Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean | 112 | 113 | theorem rpow_self_rpow_inv {y : β} (hy : y β 0) (x : ββ₯0) : (x ^ (1 / y)) ^ y = x := by |
field_simp [β rpow_mul]
| 1,574 |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.special_functions.pow.nnreal from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real NNReal ENNReal ComplexConjugate
open Finset Function Set
namespace NNReal
variable {w x y z : β}
noncomputable def rpow (x : ββ₯0) (y : β) : ββ₯0 :=
β¨(x : β) ^ y, Real.rpow_nonneg x.2 yβ©
#align nnreal.rpow NNReal.rpow
noncomputable instance : Pow ββ₯0 β :=
β¨rpowβ©
@[simp]
theorem rpow_eq_pow (x : ββ₯0) (y : β) : rpow x y = x ^ y :=
rfl
#align nnreal.rpow_eq_pow NNReal.rpow_eq_pow
@[simp, norm_cast]
theorem coe_rpow (x : ββ₯0) (y : β) : ((x ^ y : ββ₯0) : β) = (x : β) ^ y :=
rfl
#align nnreal.coe_rpow NNReal.coe_rpow
@[simp]
theorem rpow_zero (x : ββ₯0) : x ^ (0 : β) = 1 :=
NNReal.eq <| Real.rpow_zero _
#align nnreal.rpow_zero NNReal.rpow_zero
@[simp]
theorem rpow_eq_zero_iff {x : ββ₯0} {y : β} : x ^ y = 0 β x = 0 β§ y β 0 := by
rw [β NNReal.coe_inj, coe_rpow, β NNReal.coe_eq_zero]
exact Real.rpow_eq_zero_iff_of_nonneg x.2
#align nnreal.rpow_eq_zero_iff NNReal.rpow_eq_zero_iff
@[simp]
theorem zero_rpow {x : β} (h : x β 0) : (0 : ββ₯0) ^ x = 0 :=
NNReal.eq <| Real.zero_rpow h
#align nnreal.zero_rpow NNReal.zero_rpow
@[simp]
theorem rpow_one (x : ββ₯0) : x ^ (1 : β) = x :=
NNReal.eq <| Real.rpow_one _
#align nnreal.rpow_one NNReal.rpow_one
@[simp]
theorem one_rpow (x : β) : (1 : ββ₯0) ^ x = 1 :=
NNReal.eq <| Real.one_rpow _
#align nnreal.one_rpow NNReal.one_rpow
theorem rpow_add {x : ββ₯0} (hx : x β 0) (y z : β) : x ^ (y + z) = x ^ y * x ^ z :=
NNReal.eq <| Real.rpow_add (pos_iff_ne_zero.2 hx) _ _
#align nnreal.rpow_add NNReal.rpow_add
theorem rpow_add' (x : ββ₯0) {y z : β} (h : y + z β 0) : x ^ (y + z) = x ^ y * x ^ z :=
NNReal.eq <| Real.rpow_add' x.2 h
#align nnreal.rpow_add' NNReal.rpow_add'
lemma rpow_of_add_eq (x : ββ₯0) (hw : w β 0) (h : y + z = w) : x ^ w = x ^ y * x ^ z := by
rw [β h, rpow_add']; rwa [h]
theorem rpow_mul (x : ββ₯0) (y z : β) : x ^ (y * z) = (x ^ y) ^ z :=
NNReal.eq <| Real.rpow_mul x.2 y z
#align nnreal.rpow_mul NNReal.rpow_mul
theorem rpow_neg (x : ββ₯0) (y : β) : x ^ (-y) = (x ^ y)β»ΒΉ :=
NNReal.eq <| Real.rpow_neg x.2 _
#align nnreal.rpow_neg NNReal.rpow_neg
theorem rpow_neg_one (x : ββ₯0) : x ^ (-1 : β) = xβ»ΒΉ := by simp [rpow_neg]
#align nnreal.rpow_neg_one NNReal.rpow_neg_one
theorem rpow_sub {x : ββ₯0} (hx : x β 0) (y z : β) : x ^ (y - z) = x ^ y / x ^ z :=
NNReal.eq <| Real.rpow_sub (pos_iff_ne_zero.2 hx) y z
#align nnreal.rpow_sub NNReal.rpow_sub
theorem rpow_sub' (x : ββ₯0) {y z : β} (h : y - z β 0) : x ^ (y - z) = x ^ y / x ^ z :=
NNReal.eq <| Real.rpow_sub' x.2 h
#align nnreal.rpow_sub' NNReal.rpow_sub'
theorem rpow_inv_rpow_self {y : β} (hy : y β 0) (x : ββ₯0) : (x ^ y) ^ (1 / y) = x := by
field_simp [β rpow_mul]
#align nnreal.rpow_inv_rpow_self NNReal.rpow_inv_rpow_self
theorem rpow_self_rpow_inv {y : β} (hy : y β 0) (x : ββ₯0) : (x ^ (1 / y)) ^ y = x := by
field_simp [β rpow_mul]
#align nnreal.rpow_self_rpow_inv NNReal.rpow_self_rpow_inv
theorem inv_rpow (x : ββ₯0) (y : β) : xβ»ΒΉ ^ y = (x ^ y)β»ΒΉ :=
NNReal.eq <| Real.inv_rpow x.2 y
#align nnreal.inv_rpow NNReal.inv_rpow
theorem div_rpow (x y : ββ₯0) (z : β) : (x / y) ^ z = x ^ z / y ^ z :=
NNReal.eq <| Real.div_rpow x.2 y.2 z
#align nnreal.div_rpow NNReal.div_rpow
| Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean | 124 | 127 | theorem sqrt_eq_rpow (x : ββ₯0) : sqrt x = x ^ (1 / (2 : β)) := by |
refine NNReal.eq ?_
push_cast
exact Real.sqrt_eq_rpow x.1
| 1,574 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
section Limits
open Real Filter
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 36 | 46 | theorem tendsto_rpow_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ y) atTop atTop := by |
rw [tendsto_atTop_atTop]
intro b
use max b 0 ^ (1 / y)
intro x hx
exact
le_of_max_le_left
(by
convert rpow_le_rpow (rpow_nonneg (le_max_right b 0) (1 / y)) hx (le_of_lt hy)
using 1
rw [β rpow_mul (le_max_right b 0), (eq_div_iff (ne_of_gt hy)).mp rfl, Real.rpow_one])
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
section Limits
open Real Filter
theorem tendsto_rpow_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ y) atTop atTop := by
rw [tendsto_atTop_atTop]
intro b
use max b 0 ^ (1 / y)
intro x hx
exact
le_of_max_le_left
(by
convert rpow_le_rpow (rpow_nonneg (le_max_right b 0) (1 / y)) hx (le_of_lt hy)
using 1
rw [β rpow_mul (le_max_right b 0), (eq_div_iff (ne_of_gt hy)).mp rfl, Real.rpow_one])
#align tendsto_rpow_at_top tendsto_rpow_atTop
theorem tendsto_rpow_neg_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ (-y)) atTop (π 0) :=
Tendsto.congr' (eventuallyEq_of_mem (Ioi_mem_atTop 0) fun _ hx => (rpow_neg (le_of_lt hx) y).symm)
(tendsto_rpow_atTop hy).inv_tendsto_atTop
#align tendsto_rpow_neg_at_top tendsto_rpow_neg_atTop
open Asymptotics in
lemma tendsto_rpow_atTop_of_base_lt_one (b : β) (hbβ : -1 < b) (hbβ : b < 1) :
Tendsto (b ^ Β· : β β β) atTop (π (0:β)) := by
rcases lt_trichotomy b 0 with hb|rfl|hb
case inl => -- b < 0
simp_rw [Real.rpow_def_of_nonpos hb.le, hb.ne, ite_false]
rw [β isLittleO_const_iff (c := (1:β)) one_ne_zero, (one_mul (1 : β)).symm]
refine IsLittleO.mul_isBigO ?exp ?cos
case exp =>
rw [isLittleO_const_iff one_ne_zero]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_neg ?_).mpr tendsto_id
rw [β log_neg_eq_log, log_neg_iff (by linarith)]
linarith
case cos =>
rw [isBigO_iff]
exact β¨1, eventually_of_forall fun x => by simp [Real.abs_cos_le_one]β©
case inr.inl => -- b = 0
refine Tendsto.mono_right ?_ (Iff.mpr pure_le_nhds_iff rfl)
rw [tendsto_pure]
filter_upwards [eventually_ne_atTop 0] with _ hx
simp [hx]
case inr.inr => -- b > 0
simp_rw [Real.rpow_def_of_pos hb]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_neg ?_).mpr tendsto_id
exact (log_neg_iff hb).mpr hbβ
lemma tendsto_rpow_atTop_of_base_gt_one (b : β) (hb : 1 < b) :
Tendsto (b ^ Β· : β β β) atBot (π (0:β)) := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_pos ?_).mpr tendsto_id
exact (log_pos_iff (by positivity)).mpr <| by aesop
lemma tendsto_rpow_atBot_of_base_lt_one (b : β) (hbβ : 0 < b) (hbβ : b < 1) :
Tendsto (b ^ Β· : β β β) atBot atTop := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atTop.comp <| (tendsto_const_mul_atTop_iff_neg <| tendsto_id (Ξ± := β)).mpr ?_
exact (log_neg_iff hbβ).mpr hbβ
lemma tendsto_rpow_atBot_of_base_gt_one (b : β) (hb : 1 < b) :
Tendsto (b ^ Β· : β β β) atBot (π 0) := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_iff_pos <| tendsto_id (Ξ± := β)).mpr ?_
exact (log_pos_iff (by positivity)).mpr <| by aesop
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 102 | 116 | theorem tendsto_rpow_div_mul_add (a b c : β) (hb : 0 β b) :
Tendsto (fun x => x ^ (a / (b * x + c))) atTop (π 1) := by |
refine
Tendsto.congr' ?_
((tendsto_exp_nhds_zero_nhds_one.comp
(by
simpa only [mul_zero, pow_one] using
(tendsto_const_nhds (x := a)).mul
(tendsto_div_pow_mul_exp_add_atTop b c 1 hb))).comp
tendsto_log_atTop)
apply eventuallyEq_of_mem (Ioi_mem_atTop (0 : β))
intro x hx
simp only [Set.mem_Ioi, Function.comp_apply] at hx β’
rw [exp_log hx, β exp_log (rpow_pos_of_pos hx (a / (b * x + c))), log_rpow hx (a / (b * x + c))]
field_simp
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
section Limits
open Real Filter
theorem tendsto_rpow_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ y) atTop atTop := by
rw [tendsto_atTop_atTop]
intro b
use max b 0 ^ (1 / y)
intro x hx
exact
le_of_max_le_left
(by
convert rpow_le_rpow (rpow_nonneg (le_max_right b 0) (1 / y)) hx (le_of_lt hy)
using 1
rw [β rpow_mul (le_max_right b 0), (eq_div_iff (ne_of_gt hy)).mp rfl, Real.rpow_one])
#align tendsto_rpow_at_top tendsto_rpow_atTop
theorem tendsto_rpow_neg_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ (-y)) atTop (π 0) :=
Tendsto.congr' (eventuallyEq_of_mem (Ioi_mem_atTop 0) fun _ hx => (rpow_neg (le_of_lt hx) y).symm)
(tendsto_rpow_atTop hy).inv_tendsto_atTop
#align tendsto_rpow_neg_at_top tendsto_rpow_neg_atTop
open Asymptotics in
lemma tendsto_rpow_atTop_of_base_lt_one (b : β) (hbβ : -1 < b) (hbβ : b < 1) :
Tendsto (b ^ Β· : β β β) atTop (π (0:β)) := by
rcases lt_trichotomy b 0 with hb|rfl|hb
case inl => -- b < 0
simp_rw [Real.rpow_def_of_nonpos hb.le, hb.ne, ite_false]
rw [β isLittleO_const_iff (c := (1:β)) one_ne_zero, (one_mul (1 : β)).symm]
refine IsLittleO.mul_isBigO ?exp ?cos
case exp =>
rw [isLittleO_const_iff one_ne_zero]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_neg ?_).mpr tendsto_id
rw [β log_neg_eq_log, log_neg_iff (by linarith)]
linarith
case cos =>
rw [isBigO_iff]
exact β¨1, eventually_of_forall fun x => by simp [Real.abs_cos_le_one]β©
case inr.inl => -- b = 0
refine Tendsto.mono_right ?_ (Iff.mpr pure_le_nhds_iff rfl)
rw [tendsto_pure]
filter_upwards [eventually_ne_atTop 0] with _ hx
simp [hx]
case inr.inr => -- b > 0
simp_rw [Real.rpow_def_of_pos hb]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_neg ?_).mpr tendsto_id
exact (log_neg_iff hb).mpr hbβ
lemma tendsto_rpow_atTop_of_base_gt_one (b : β) (hb : 1 < b) :
Tendsto (b ^ Β· : β β β) atBot (π (0:β)) := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_pos ?_).mpr tendsto_id
exact (log_pos_iff (by positivity)).mpr <| by aesop
lemma tendsto_rpow_atBot_of_base_lt_one (b : β) (hbβ : 0 < b) (hbβ : b < 1) :
Tendsto (b ^ Β· : β β β) atBot atTop := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atTop.comp <| (tendsto_const_mul_atTop_iff_neg <| tendsto_id (Ξ± := β)).mpr ?_
exact (log_neg_iff hbβ).mpr hbβ
lemma tendsto_rpow_atBot_of_base_gt_one (b : β) (hb : 1 < b) :
Tendsto (b ^ Β· : β β β) atBot (π 0) := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_iff_pos <| tendsto_id (Ξ± := β)).mpr ?_
exact (log_pos_iff (by positivity)).mpr <| by aesop
theorem tendsto_rpow_div_mul_add (a b c : β) (hb : 0 β b) :
Tendsto (fun x => x ^ (a / (b * x + c))) atTop (π 1) := by
refine
Tendsto.congr' ?_
((tendsto_exp_nhds_zero_nhds_one.comp
(by
simpa only [mul_zero, pow_one] using
(tendsto_const_nhds (x := a)).mul
(tendsto_div_pow_mul_exp_add_atTop b c 1 hb))).comp
tendsto_log_atTop)
apply eventuallyEq_of_mem (Ioi_mem_atTop (0 : β))
intro x hx
simp only [Set.mem_Ioi, Function.comp_apply] at hx β’
rw [exp_log hx, β exp_log (rpow_pos_of_pos hx (a / (b * x + c))), log_rpow hx (a / (b * x + c))]
field_simp
#align tendsto_rpow_div_mul_add tendsto_rpow_div_mul_add
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 120 | 122 | theorem tendsto_rpow_div : Tendsto (fun x => x ^ ((1 : β) / x)) atTop (π 1) := by |
convert tendsto_rpow_div_mul_add (1 : β) _ (0 : β) zero_ne_one
ring
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
section Limits
open Real Filter
theorem tendsto_rpow_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ y) atTop atTop := by
rw [tendsto_atTop_atTop]
intro b
use max b 0 ^ (1 / y)
intro x hx
exact
le_of_max_le_left
(by
convert rpow_le_rpow (rpow_nonneg (le_max_right b 0) (1 / y)) hx (le_of_lt hy)
using 1
rw [β rpow_mul (le_max_right b 0), (eq_div_iff (ne_of_gt hy)).mp rfl, Real.rpow_one])
#align tendsto_rpow_at_top tendsto_rpow_atTop
theorem tendsto_rpow_neg_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ (-y)) atTop (π 0) :=
Tendsto.congr' (eventuallyEq_of_mem (Ioi_mem_atTop 0) fun _ hx => (rpow_neg (le_of_lt hx) y).symm)
(tendsto_rpow_atTop hy).inv_tendsto_atTop
#align tendsto_rpow_neg_at_top tendsto_rpow_neg_atTop
open Asymptotics in
lemma tendsto_rpow_atTop_of_base_lt_one (b : β) (hbβ : -1 < b) (hbβ : b < 1) :
Tendsto (b ^ Β· : β β β) atTop (π (0:β)) := by
rcases lt_trichotomy b 0 with hb|rfl|hb
case inl => -- b < 0
simp_rw [Real.rpow_def_of_nonpos hb.le, hb.ne, ite_false]
rw [β isLittleO_const_iff (c := (1:β)) one_ne_zero, (one_mul (1 : β)).symm]
refine IsLittleO.mul_isBigO ?exp ?cos
case exp =>
rw [isLittleO_const_iff one_ne_zero]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_neg ?_).mpr tendsto_id
rw [β log_neg_eq_log, log_neg_iff (by linarith)]
linarith
case cos =>
rw [isBigO_iff]
exact β¨1, eventually_of_forall fun x => by simp [Real.abs_cos_le_one]β©
case inr.inl => -- b = 0
refine Tendsto.mono_right ?_ (Iff.mpr pure_le_nhds_iff rfl)
rw [tendsto_pure]
filter_upwards [eventually_ne_atTop 0] with _ hx
simp [hx]
case inr.inr => -- b > 0
simp_rw [Real.rpow_def_of_pos hb]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_neg ?_).mpr tendsto_id
exact (log_neg_iff hb).mpr hbβ
lemma tendsto_rpow_atTop_of_base_gt_one (b : β) (hb : 1 < b) :
Tendsto (b ^ Β· : β β β) atBot (π (0:β)) := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_pos ?_).mpr tendsto_id
exact (log_pos_iff (by positivity)).mpr <| by aesop
lemma tendsto_rpow_atBot_of_base_lt_one (b : β) (hbβ : 0 < b) (hbβ : b < 1) :
Tendsto (b ^ Β· : β β β) atBot atTop := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atTop.comp <| (tendsto_const_mul_atTop_iff_neg <| tendsto_id (Ξ± := β)).mpr ?_
exact (log_neg_iff hbβ).mpr hbβ
lemma tendsto_rpow_atBot_of_base_gt_one (b : β) (hb : 1 < b) :
Tendsto (b ^ Β· : β β β) atBot (π 0) := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_iff_pos <| tendsto_id (Ξ± := β)).mpr ?_
exact (log_pos_iff (by positivity)).mpr <| by aesop
theorem tendsto_rpow_div_mul_add (a b c : β) (hb : 0 β b) :
Tendsto (fun x => x ^ (a / (b * x + c))) atTop (π 1) := by
refine
Tendsto.congr' ?_
((tendsto_exp_nhds_zero_nhds_one.comp
(by
simpa only [mul_zero, pow_one] using
(tendsto_const_nhds (x := a)).mul
(tendsto_div_pow_mul_exp_add_atTop b c 1 hb))).comp
tendsto_log_atTop)
apply eventuallyEq_of_mem (Ioi_mem_atTop (0 : β))
intro x hx
simp only [Set.mem_Ioi, Function.comp_apply] at hx β’
rw [exp_log hx, β exp_log (rpow_pos_of_pos hx (a / (b * x + c))), log_rpow hx (a / (b * x + c))]
field_simp
#align tendsto_rpow_div_mul_add tendsto_rpow_div_mul_add
theorem tendsto_rpow_div : Tendsto (fun x => x ^ ((1 : β) / x)) atTop (π 1) := by
convert tendsto_rpow_div_mul_add (1 : β) _ (0 : β) zero_ne_one
ring
#align tendsto_rpow_div tendsto_rpow_div
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 126 | 128 | theorem tendsto_rpow_neg_div : Tendsto (fun x => x ^ (-(1 : β) / x)) atTop (π 1) := by |
convert tendsto_rpow_div_mul_add (-(1 : β)) _ (0 : β) zero_ne_one
ring
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
section Limits
open Real Filter
theorem tendsto_rpow_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ y) atTop atTop := by
rw [tendsto_atTop_atTop]
intro b
use max b 0 ^ (1 / y)
intro x hx
exact
le_of_max_le_left
(by
convert rpow_le_rpow (rpow_nonneg (le_max_right b 0) (1 / y)) hx (le_of_lt hy)
using 1
rw [β rpow_mul (le_max_right b 0), (eq_div_iff (ne_of_gt hy)).mp rfl, Real.rpow_one])
#align tendsto_rpow_at_top tendsto_rpow_atTop
theorem tendsto_rpow_neg_atTop {y : β} (hy : 0 < y) : Tendsto (fun x : β => x ^ (-y)) atTop (π 0) :=
Tendsto.congr' (eventuallyEq_of_mem (Ioi_mem_atTop 0) fun _ hx => (rpow_neg (le_of_lt hx) y).symm)
(tendsto_rpow_atTop hy).inv_tendsto_atTop
#align tendsto_rpow_neg_at_top tendsto_rpow_neg_atTop
open Asymptotics in
lemma tendsto_rpow_atTop_of_base_lt_one (b : β) (hbβ : -1 < b) (hbβ : b < 1) :
Tendsto (b ^ Β· : β β β) atTop (π (0:β)) := by
rcases lt_trichotomy b 0 with hb|rfl|hb
case inl => -- b < 0
simp_rw [Real.rpow_def_of_nonpos hb.le, hb.ne, ite_false]
rw [β isLittleO_const_iff (c := (1:β)) one_ne_zero, (one_mul (1 : β)).symm]
refine IsLittleO.mul_isBigO ?exp ?cos
case exp =>
rw [isLittleO_const_iff one_ne_zero]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_neg ?_).mpr tendsto_id
rw [β log_neg_eq_log, log_neg_iff (by linarith)]
linarith
case cos =>
rw [isBigO_iff]
exact β¨1, eventually_of_forall fun x => by simp [Real.abs_cos_le_one]β©
case inr.inl => -- b = 0
refine Tendsto.mono_right ?_ (Iff.mpr pure_le_nhds_iff rfl)
rw [tendsto_pure]
filter_upwards [eventually_ne_atTop 0] with _ hx
simp [hx]
case inr.inr => -- b > 0
simp_rw [Real.rpow_def_of_pos hb]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_neg ?_).mpr tendsto_id
exact (log_neg_iff hb).mpr hbβ
lemma tendsto_rpow_atTop_of_base_gt_one (b : β) (hb : 1 < b) :
Tendsto (b ^ Β· : β β β) atBot (π (0:β)) := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_of_pos ?_).mpr tendsto_id
exact (log_pos_iff (by positivity)).mpr <| by aesop
lemma tendsto_rpow_atBot_of_base_lt_one (b : β) (hbβ : 0 < b) (hbβ : b < 1) :
Tendsto (b ^ Β· : β β β) atBot atTop := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atTop.comp <| (tendsto_const_mul_atTop_iff_neg <| tendsto_id (Ξ± := β)).mpr ?_
exact (log_neg_iff hbβ).mpr hbβ
lemma tendsto_rpow_atBot_of_base_gt_one (b : β) (hb : 1 < b) :
Tendsto (b ^ Β· : β β β) atBot (π 0) := by
simp_rw [Real.rpow_def_of_pos (by positivity : 0 < b)]
refine tendsto_exp_atBot.comp <| (tendsto_const_mul_atBot_iff_pos <| tendsto_id (Ξ± := β)).mpr ?_
exact (log_pos_iff (by positivity)).mpr <| by aesop
theorem tendsto_rpow_div_mul_add (a b c : β) (hb : 0 β b) :
Tendsto (fun x => x ^ (a / (b * x + c))) atTop (π 1) := by
refine
Tendsto.congr' ?_
((tendsto_exp_nhds_zero_nhds_one.comp
(by
simpa only [mul_zero, pow_one] using
(tendsto_const_nhds (x := a)).mul
(tendsto_div_pow_mul_exp_add_atTop b c 1 hb))).comp
tendsto_log_atTop)
apply eventuallyEq_of_mem (Ioi_mem_atTop (0 : β))
intro x hx
simp only [Set.mem_Ioi, Function.comp_apply] at hx β’
rw [exp_log hx, β exp_log (rpow_pos_of_pos hx (a / (b * x + c))), log_rpow hx (a / (b * x + c))]
field_simp
#align tendsto_rpow_div_mul_add tendsto_rpow_div_mul_add
theorem tendsto_rpow_div : Tendsto (fun x => x ^ ((1 : β) / x)) atTop (π 1) := by
convert tendsto_rpow_div_mul_add (1 : β) _ (0 : β) zero_ne_one
ring
#align tendsto_rpow_div tendsto_rpow_div
theorem tendsto_rpow_neg_div : Tendsto (fun x => x ^ (-(1 : β) / x)) atTop (π 1) := by
convert tendsto_rpow_div_mul_add (-(1 : β)) _ (0 : β) zero_ne_one
ring
#align tendsto_rpow_neg_div tendsto_rpow_neg_div
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 132 | 137 | theorem tendsto_exp_div_rpow_atTop (s : β) : Tendsto (fun x : β => exp x / x ^ s) atTop atTop := by |
cases' archimedean_iff_nat_lt.1 Real.instArchimedean s with n hn
refine tendsto_atTop_mono' _ ?_ (tendsto_exp_div_pow_atTop n)
filter_upwards [eventually_gt_atTop (0 : β), eventually_ge_atTop (1 : β)] with x hxβ hxβ
rw [div_le_div_left (exp_pos _) (pow_pos hxβ _) (rpow_pos_of_pos hxβ _), β Real.rpow_natCast]
exact rpow_le_rpow_of_exponent_le hxβ hn.le
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
namespace Complex
section
variable {Ξ± : Type*} {l : Filter Ξ±} {f g : Ξ± β β}
open Asymptotics
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 200 | 207 | theorem isTheta_exp_arg_mul_im (hl : IsBoundedUnder (Β· β€ Β·) l fun x => |(g x).im|) :
(fun x => Real.exp (arg (f x) * im (g x))) =Ξ[l] fun _ => (1 : β) := by |
rcases hl with β¨b, hbβ©
refine Real.isTheta_exp_comp_one.2 β¨Ο * b, ?_β©
rw [eventually_map] at hb β’
refine hb.mono fun x hx => ?_
erw [abs_mul]
exact mul_le_mul (abs_arg_le_pi _) hx (abs_nonneg _) Real.pi_pos.le
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
namespace Complex
section
variable {Ξ± : Type*} {l : Filter Ξ±} {f g : Ξ± β β}
open Asymptotics
theorem isTheta_exp_arg_mul_im (hl : IsBoundedUnder (Β· β€ Β·) l fun x => |(g x).im|) :
(fun x => Real.exp (arg (f x) * im (g x))) =Ξ[l] fun _ => (1 : β) := by
rcases hl with β¨b, hbβ©
refine Real.isTheta_exp_comp_one.2 β¨Ο * b, ?_β©
rw [eventually_map] at hb β’
refine hb.mono fun x hx => ?_
erw [abs_mul]
exact mul_le_mul (abs_arg_le_pi _) hx (abs_nonneg _) Real.pi_pos.le
#align complex.is_Theta_exp_arg_mul_im Complex.isTheta_exp_arg_mul_im
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 210 | 220 | theorem isBigO_cpow_rpow (hl : IsBoundedUnder (Β· β€ Β·) l fun x => |(g x).im|) :
(fun x => f x ^ g x) =O[l] fun x => abs (f x) ^ (g x).re :=
calc
(fun x => f x ^ g x) =O[l]
(show Ξ± β β from fun x => abs (f x) ^ (g x).re / Real.exp (arg (f x) * im (g x))) :=
isBigO_of_le _ fun x => (abs_cpow_le _ _).trans (le_abs_self _)
_ =Ξ[l] (show Ξ± β β from fun x => abs (f x) ^ (g x).re / (1 : β)) :=
((isTheta_refl _ _).div (isTheta_exp_arg_mul_im hl))
_ =αΆ [l] (show Ξ± β β from fun x => abs (f x) ^ (g x).re) := by |
simp only [ofReal_one, div_one]
rfl
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
namespace Complex
section
variable {Ξ± : Type*} {l : Filter Ξ±} {f g : Ξ± β β}
open Asymptotics
theorem isTheta_exp_arg_mul_im (hl : IsBoundedUnder (Β· β€ Β·) l fun x => |(g x).im|) :
(fun x => Real.exp (arg (f x) * im (g x))) =Ξ[l] fun _ => (1 : β) := by
rcases hl with β¨b, hbβ©
refine Real.isTheta_exp_comp_one.2 β¨Ο * b, ?_β©
rw [eventually_map] at hb β’
refine hb.mono fun x hx => ?_
erw [abs_mul]
exact mul_le_mul (abs_arg_le_pi _) hx (abs_nonneg _) Real.pi_pos.le
#align complex.is_Theta_exp_arg_mul_im Complex.isTheta_exp_arg_mul_im
theorem isBigO_cpow_rpow (hl : IsBoundedUnder (Β· β€ Β·) l fun x => |(g x).im|) :
(fun x => f x ^ g x) =O[l] fun x => abs (f x) ^ (g x).re :=
calc
(fun x => f x ^ g x) =O[l]
(show Ξ± β β from fun x => abs (f x) ^ (g x).re / Real.exp (arg (f x) * im (g x))) :=
isBigO_of_le _ fun x => (abs_cpow_le _ _).trans (le_abs_self _)
_ =Ξ[l] (show Ξ± β β from fun x => abs (f x) ^ (g x).re / (1 : β)) :=
((isTheta_refl _ _).div (isTheta_exp_arg_mul_im hl))
_ =αΆ [l] (show Ξ± β β from fun x => abs (f x) ^ (g x).re) := by
simp only [ofReal_one, div_one]
rfl
#align complex.is_O_cpow_rpow Complex.isBigO_cpow_rpow
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 223 | 234 | theorem isTheta_cpow_rpow (hl_im : IsBoundedUnder (Β· β€ Β·) l fun x => |(g x).im|)
(hl : βαΆ x in l, f x = 0 β re (g x) = 0 β g x = 0) :
(fun x => f x ^ g x) =Ξ[l] fun x => abs (f x) ^ (g x).re :=
calc
(fun x => f x ^ g x) =Ξ[l]
(show Ξ± β β from fun x => abs (f x) ^ (g x).re / Real.exp (arg (f x) * im (g x))) :=
isTheta_of_norm_eventuallyEq' <| hl.mono fun x => abs_cpow_of_imp
_ =Ξ[l] (show Ξ± β β from fun x => abs (f x) ^ (g x).re / (1 : β)) :=
((isTheta_refl _ _).div (isTheta_exp_arg_mul_im hl_im))
_ =αΆ [l] (show Ξ± β β from fun x => abs (f x) ^ (g x).re) := by |
simp only [ofReal_one, div_one]
rfl
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
open Real
namespace Asymptotics
variable {Ξ± : Type*} {r c : β} {l : Filter Ξ±} {f g : Ξ± β β}
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 259 | 266 | theorem IsBigOWith.rpow (h : IsBigOWith c l f g) (hc : 0 β€ c) (hr : 0 β€ r) (hg : 0 β€αΆ [l] g) :
IsBigOWith (c ^ r) l (fun x => f x ^ r) fun x => g x ^ r := by |
apply IsBigOWith.of_bound
filter_upwards [hg, h.bound] with x hgx hx
calc
|f x ^ r| β€ |f x| ^ r := abs_rpow_le_abs_rpow _ _
_ β€ (c * |g x|) ^ r := rpow_le_rpow (abs_nonneg _) hx hr
_ = c ^ r * |g x ^ r| := by rw [mul_rpow hc (abs_nonneg _), abs_rpow_of_nonneg hgx]
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
open Real
namespace Asymptotics
variable {Ξ± : Type*} {r c : β} {l : Filter Ξ±} {f g : Ξ± β β}
theorem IsBigOWith.rpow (h : IsBigOWith c l f g) (hc : 0 β€ c) (hr : 0 β€ r) (hg : 0 β€αΆ [l] g) :
IsBigOWith (c ^ r) l (fun x => f x ^ r) fun x => g x ^ r := by
apply IsBigOWith.of_bound
filter_upwards [hg, h.bound] with x hgx hx
calc
|f x ^ r| β€ |f x| ^ r := abs_rpow_le_abs_rpow _ _
_ β€ (c * |g x|) ^ r := rpow_le_rpow (abs_nonneg _) hx hr
_ = c ^ r * |g x ^ r| := by rw [mul_rpow hc (abs_nonneg _), abs_rpow_of_nonneg hgx]
#align asymptotics.is_O_with.rpow Asymptotics.IsBigOWith.rpow
theorem IsBigO.rpow (hr : 0 β€ r) (hg : 0 β€αΆ [l] g) (h : f =O[l] g) :
(fun x => f x ^ r) =O[l] fun x => g x ^ r :=
let β¨_, hc, h'β© := h.exists_nonneg
(h'.rpow hc hr hg).isBigO
#align asymptotics.is_O.rpow Asymptotics.IsBigO.rpow
theorem IsTheta.rpow (hr : 0 β€ r) (hf : 0 β€αΆ [l] f) (hg : 0 β€αΆ [l] g) (h : f =Ξ[l] g) :
(fun x => f x ^ r) =Ξ[l] fun x => g x ^ r :=
β¨h.1.rpow hr hg, h.2.rpow hr hfβ©
| Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 279 | 283 | theorem IsLittleO.rpow (hr : 0 < r) (hg : 0 β€αΆ [l] g) (h : f =o[l] g) :
(fun x => f x ^ r) =o[l] fun x => g x ^ r := by |
refine .of_isBigOWith fun c hc β¦ ?_
rw [β rpow_inv_rpow hc.le hr.ne']
refine (h.forall_isBigOWith ?_).rpow ?_ ?_ hg <;> positivity
| 1,575 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Asymptotics.SpecificAsymptotics
#align_import analysis.special_functions.compare_exp from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
open Asymptotics Filter Function
open scoped Topology
namespace Complex
structure IsExpCmpFilter (l : Filter β) : Prop where
tendsto_re : Tendsto re l atTop
isBigO_im_pow_re : β n : β, (fun z : β => z.im ^ n) =O[l] fun z => Real.exp z.re
#align complex.is_exp_cmp_filter Complex.IsExpCmpFilter
namespace IsExpCmpFilter
variable {l : Filter β}
theorem of_isBigO_im_re_rpow (hre : Tendsto re l atTop) (r : β) (hr : im =O[l] fun z => z.re ^ r) :
IsExpCmpFilter l :=
β¨hre, fun n =>
IsLittleO.isBigO <|
calc
(fun z : β => z.im ^ n) =O[l] fun z => (z.re ^ r) ^ n := hr.pow n
_ =αΆ [l] fun z => z.re ^ (r * n) :=
((hre.eventually_ge_atTop 0).mono fun z hz => by
simp only [Real.rpow_mul hz r n, Real.rpow_natCast])
_ =o[l] fun z => Real.exp z.re := (isLittleO_rpow_exp_atTop _).comp_tendsto hre β©
set_option linter.uppercaseLean3 false in
#align complex.is_exp_cmp_filter.of_is_O_im_re_rpow Complex.IsExpCmpFilter.of_isBigO_im_re_rpow
theorem of_isBigO_im_re_pow (hre : Tendsto re l atTop) (n : β) (hr : im =O[l] fun z => z.re ^ n) :
IsExpCmpFilter l :=
of_isBigO_im_re_rpow hre n <| mod_cast hr
set_option linter.uppercaseLean3 false in
#align complex.is_exp_cmp_filter.of_is_O_im_re_pow Complex.IsExpCmpFilter.of_isBigO_im_re_pow
theorem of_boundedUnder_abs_im (hre : Tendsto re l atTop)
(him : IsBoundedUnder (Β· β€ Β·) l fun z => |z.im|) : IsExpCmpFilter l :=
of_isBigO_im_re_pow hre 0 <| by
simpa only [pow_zero] using him.isBigO_const (f := im) one_ne_zero
#align complex.is_exp_cmp_filter.of_bounded_under_abs_im Complex.IsExpCmpFilter.of_boundedUnder_abs_im
theorem of_boundedUnder_im (hre : Tendsto re l atTop) (him_le : IsBoundedUnder (Β· β€ Β·) l im)
(him_ge : IsBoundedUnder (Β· β₯ Β·) l im) : IsExpCmpFilter l :=
of_boundedUnder_abs_im hre <| isBoundedUnder_le_abs.2 β¨him_le, him_geβ©
#align complex.is_exp_cmp_filter.of_bounded_under_im Complex.IsExpCmpFilter.of_boundedUnder_im
theorem eventually_ne (hl : IsExpCmpFilter l) : βαΆ w : β in l, w β 0 :=
hl.tendsto_re.eventually_ne_atTop' _
#align complex.is_exp_cmp_filter.eventually_ne Complex.IsExpCmpFilter.eventually_ne
theorem tendsto_abs_re (hl : IsExpCmpFilter l) : Tendsto (fun z : β => |z.re|) l atTop :=
tendsto_abs_atTop_atTop.comp hl.tendsto_re
#align complex.is_exp_cmp_filter.tendsto_abs_re Complex.IsExpCmpFilter.tendsto_abs_re
theorem tendsto_abs (hl : IsExpCmpFilter l) : Tendsto abs l atTop :=
tendsto_atTop_mono abs_re_le_abs hl.tendsto_abs_re
#align complex.is_exp_cmp_filter.tendsto_abs Complex.IsExpCmpFilter.tendsto_abs
theorem isLittleO_log_re_re (hl : IsExpCmpFilter l) : (fun z => Real.log z.re) =o[l] re :=
Real.isLittleO_log_id_atTop.comp_tendsto hl.tendsto_re
#align complex.is_exp_cmp_filter.is_o_log_re_re Complex.IsExpCmpFilter.isLittleO_log_re_re
| Mathlib/Analysis/SpecialFunctions/CompareExp.lean | 107 | 116 | theorem isLittleO_im_pow_exp_re (hl : IsExpCmpFilter l) (n : β) :
(fun z : β => z.im ^ n) =o[l] fun z => Real.exp z.re :=
flip IsLittleO.of_pow two_ne_zero <|
calc
(fun z : β β¦ (z.im ^ n) ^ 2) = (fun z β¦ z.im ^ (2 * n)) := by | simp only [pow_mul']
_ =O[l] fun z β¦ Real.exp z.re := hl.isBigO_im_pow_re _
_ = fun z β¦ (Real.exp z.re) ^ 1 := by simp only [pow_one]
_ =o[l] fun z β¦ (Real.exp z.re) ^ 2 :=
(isLittleO_pow_pow_atTop_of_lt one_lt_two).comp_tendsto <|
Real.tendsto_exp_atTop.comp hl.tendsto_re
| 1,576 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Asymptotics.SpecificAsymptotics
#align_import analysis.special_functions.compare_exp from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
open Asymptotics Filter Function
open scoped Topology
namespace Complex
structure IsExpCmpFilter (l : Filter β) : Prop where
tendsto_re : Tendsto re l atTop
isBigO_im_pow_re : β n : β, (fun z : β => z.im ^ n) =O[l] fun z => Real.exp z.re
#align complex.is_exp_cmp_filter Complex.IsExpCmpFilter
namespace IsExpCmpFilter
variable {l : Filter β}
theorem of_isBigO_im_re_rpow (hre : Tendsto re l atTop) (r : β) (hr : im =O[l] fun z => z.re ^ r) :
IsExpCmpFilter l :=
β¨hre, fun n =>
IsLittleO.isBigO <|
calc
(fun z : β => z.im ^ n) =O[l] fun z => (z.re ^ r) ^ n := hr.pow n
_ =αΆ [l] fun z => z.re ^ (r * n) :=
((hre.eventually_ge_atTop 0).mono fun z hz => by
simp only [Real.rpow_mul hz r n, Real.rpow_natCast])
_ =o[l] fun z => Real.exp z.re := (isLittleO_rpow_exp_atTop _).comp_tendsto hre β©
set_option linter.uppercaseLean3 false in
#align complex.is_exp_cmp_filter.of_is_O_im_re_rpow Complex.IsExpCmpFilter.of_isBigO_im_re_rpow
theorem of_isBigO_im_re_pow (hre : Tendsto re l atTop) (n : β) (hr : im =O[l] fun z => z.re ^ n) :
IsExpCmpFilter l :=
of_isBigO_im_re_rpow hre n <| mod_cast hr
set_option linter.uppercaseLean3 false in
#align complex.is_exp_cmp_filter.of_is_O_im_re_pow Complex.IsExpCmpFilter.of_isBigO_im_re_pow
theorem of_boundedUnder_abs_im (hre : Tendsto re l atTop)
(him : IsBoundedUnder (Β· β€ Β·) l fun z => |z.im|) : IsExpCmpFilter l :=
of_isBigO_im_re_pow hre 0 <| by
simpa only [pow_zero] using him.isBigO_const (f := im) one_ne_zero
#align complex.is_exp_cmp_filter.of_bounded_under_abs_im Complex.IsExpCmpFilter.of_boundedUnder_abs_im
theorem of_boundedUnder_im (hre : Tendsto re l atTop) (him_le : IsBoundedUnder (Β· β€ Β·) l im)
(him_ge : IsBoundedUnder (Β· β₯ Β·) l im) : IsExpCmpFilter l :=
of_boundedUnder_abs_im hre <| isBoundedUnder_le_abs.2 β¨him_le, him_geβ©
#align complex.is_exp_cmp_filter.of_bounded_under_im Complex.IsExpCmpFilter.of_boundedUnder_im
theorem eventually_ne (hl : IsExpCmpFilter l) : βαΆ w : β in l, w β 0 :=
hl.tendsto_re.eventually_ne_atTop' _
#align complex.is_exp_cmp_filter.eventually_ne Complex.IsExpCmpFilter.eventually_ne
theorem tendsto_abs_re (hl : IsExpCmpFilter l) : Tendsto (fun z : β => |z.re|) l atTop :=
tendsto_abs_atTop_atTop.comp hl.tendsto_re
#align complex.is_exp_cmp_filter.tendsto_abs_re Complex.IsExpCmpFilter.tendsto_abs_re
theorem tendsto_abs (hl : IsExpCmpFilter l) : Tendsto abs l atTop :=
tendsto_atTop_mono abs_re_le_abs hl.tendsto_abs_re
#align complex.is_exp_cmp_filter.tendsto_abs Complex.IsExpCmpFilter.tendsto_abs
theorem isLittleO_log_re_re (hl : IsExpCmpFilter l) : (fun z => Real.log z.re) =o[l] re :=
Real.isLittleO_log_id_atTop.comp_tendsto hl.tendsto_re
#align complex.is_exp_cmp_filter.is_o_log_re_re Complex.IsExpCmpFilter.isLittleO_log_re_re
theorem isLittleO_im_pow_exp_re (hl : IsExpCmpFilter l) (n : β) :
(fun z : β => z.im ^ n) =o[l] fun z => Real.exp z.re :=
flip IsLittleO.of_pow two_ne_zero <|
calc
(fun z : β β¦ (z.im ^ n) ^ 2) = (fun z β¦ z.im ^ (2 * n)) := by simp only [pow_mul']
_ =O[l] fun z β¦ Real.exp z.re := hl.isBigO_im_pow_re _
_ = fun z β¦ (Real.exp z.re) ^ 1 := by simp only [pow_one]
_ =o[l] fun z β¦ (Real.exp z.re) ^ 2 :=
(isLittleO_pow_pow_atTop_of_lt one_lt_two).comp_tendsto <|
Real.tendsto_exp_atTop.comp hl.tendsto_re
#align complex.is_exp_cmp_filter.is_o_im_pow_exp_re Complex.IsExpCmpFilter.isLittleO_im_pow_exp_re
| Mathlib/Analysis/SpecialFunctions/CompareExp.lean | 119 | 121 | theorem abs_im_pow_eventuallyLE_exp_re (hl : IsExpCmpFilter l) (n : β) :
(fun z : β => |z.im| ^ n) β€αΆ [l] fun z => Real.exp z.re := by |
simpa using (hl.isLittleO_im_pow_exp_re n).bound zero_lt_one
| 1,576 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Asymptotics.SpecificAsymptotics
#align_import analysis.special_functions.compare_exp from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
open Asymptotics Filter Function
open scoped Topology
namespace Complex
structure IsExpCmpFilter (l : Filter β) : Prop where
tendsto_re : Tendsto re l atTop
isBigO_im_pow_re : β n : β, (fun z : β => z.im ^ n) =O[l] fun z => Real.exp z.re
#align complex.is_exp_cmp_filter Complex.IsExpCmpFilter
namespace IsExpCmpFilter
variable {l : Filter β}
theorem of_isBigO_im_re_rpow (hre : Tendsto re l atTop) (r : β) (hr : im =O[l] fun z => z.re ^ r) :
IsExpCmpFilter l :=
β¨hre, fun n =>
IsLittleO.isBigO <|
calc
(fun z : β => z.im ^ n) =O[l] fun z => (z.re ^ r) ^ n := hr.pow n
_ =αΆ [l] fun z => z.re ^ (r * n) :=
((hre.eventually_ge_atTop 0).mono fun z hz => by
simp only [Real.rpow_mul hz r n, Real.rpow_natCast])
_ =o[l] fun z => Real.exp z.re := (isLittleO_rpow_exp_atTop _).comp_tendsto hre β©
set_option linter.uppercaseLean3 false in
#align complex.is_exp_cmp_filter.of_is_O_im_re_rpow Complex.IsExpCmpFilter.of_isBigO_im_re_rpow
theorem of_isBigO_im_re_pow (hre : Tendsto re l atTop) (n : β) (hr : im =O[l] fun z => z.re ^ n) :
IsExpCmpFilter l :=
of_isBigO_im_re_rpow hre n <| mod_cast hr
set_option linter.uppercaseLean3 false in
#align complex.is_exp_cmp_filter.of_is_O_im_re_pow Complex.IsExpCmpFilter.of_isBigO_im_re_pow
theorem of_boundedUnder_abs_im (hre : Tendsto re l atTop)
(him : IsBoundedUnder (Β· β€ Β·) l fun z => |z.im|) : IsExpCmpFilter l :=
of_isBigO_im_re_pow hre 0 <| by
simpa only [pow_zero] using him.isBigO_const (f := im) one_ne_zero
#align complex.is_exp_cmp_filter.of_bounded_under_abs_im Complex.IsExpCmpFilter.of_boundedUnder_abs_im
theorem of_boundedUnder_im (hre : Tendsto re l atTop) (him_le : IsBoundedUnder (Β· β€ Β·) l im)
(him_ge : IsBoundedUnder (Β· β₯ Β·) l im) : IsExpCmpFilter l :=
of_boundedUnder_abs_im hre <| isBoundedUnder_le_abs.2 β¨him_le, him_geβ©
#align complex.is_exp_cmp_filter.of_bounded_under_im Complex.IsExpCmpFilter.of_boundedUnder_im
theorem eventually_ne (hl : IsExpCmpFilter l) : βαΆ w : β in l, w β 0 :=
hl.tendsto_re.eventually_ne_atTop' _
#align complex.is_exp_cmp_filter.eventually_ne Complex.IsExpCmpFilter.eventually_ne
theorem tendsto_abs_re (hl : IsExpCmpFilter l) : Tendsto (fun z : β => |z.re|) l atTop :=
tendsto_abs_atTop_atTop.comp hl.tendsto_re
#align complex.is_exp_cmp_filter.tendsto_abs_re Complex.IsExpCmpFilter.tendsto_abs_re
theorem tendsto_abs (hl : IsExpCmpFilter l) : Tendsto abs l atTop :=
tendsto_atTop_mono abs_re_le_abs hl.tendsto_abs_re
#align complex.is_exp_cmp_filter.tendsto_abs Complex.IsExpCmpFilter.tendsto_abs
theorem isLittleO_log_re_re (hl : IsExpCmpFilter l) : (fun z => Real.log z.re) =o[l] re :=
Real.isLittleO_log_id_atTop.comp_tendsto hl.tendsto_re
#align complex.is_exp_cmp_filter.is_o_log_re_re Complex.IsExpCmpFilter.isLittleO_log_re_re
theorem isLittleO_im_pow_exp_re (hl : IsExpCmpFilter l) (n : β) :
(fun z : β => z.im ^ n) =o[l] fun z => Real.exp z.re :=
flip IsLittleO.of_pow two_ne_zero <|
calc
(fun z : β β¦ (z.im ^ n) ^ 2) = (fun z β¦ z.im ^ (2 * n)) := by simp only [pow_mul']
_ =O[l] fun z β¦ Real.exp z.re := hl.isBigO_im_pow_re _
_ = fun z β¦ (Real.exp z.re) ^ 1 := by simp only [pow_one]
_ =o[l] fun z β¦ (Real.exp z.re) ^ 2 :=
(isLittleO_pow_pow_atTop_of_lt one_lt_two).comp_tendsto <|
Real.tendsto_exp_atTop.comp hl.tendsto_re
#align complex.is_exp_cmp_filter.is_o_im_pow_exp_re Complex.IsExpCmpFilter.isLittleO_im_pow_exp_re
theorem abs_im_pow_eventuallyLE_exp_re (hl : IsExpCmpFilter l) (n : β) :
(fun z : β => |z.im| ^ n) β€αΆ [l] fun z => Real.exp z.re := by
simpa using (hl.isLittleO_im_pow_exp_re n).bound zero_lt_one
#align complex.is_exp_cmp_filter.abs_im_pow_eventually_le_exp_re Complex.IsExpCmpFilter.abs_im_pow_eventuallyLE_exp_re
| Mathlib/Analysis/SpecialFunctions/CompareExp.lean | 127 | 151 | theorem isLittleO_log_abs_re (hl : IsExpCmpFilter l) : (fun z => Real.log (abs z)) =o[l] re :=
calc
(fun z => Real.log (abs z)) =O[l] fun z => Real.log (β2) + Real.log (max z.re |z.im|) :=
IsBigO.of_bound 1 <|
(hl.tendsto_re.eventually_ge_atTop 1).mono fun z hz => by
have h2 : 0 < β2 := by | simp
have hz' : 1 β€ abs z := hz.trans (re_le_abs z)
have hmβ : 0 < max z.re |z.im| := lt_max_iff.2 (Or.inl <| one_pos.trans_le hz)
rw [one_mul, Real.norm_eq_abs, _root_.abs_of_nonneg (Real.log_nonneg hz')]
refine le_trans ?_ (le_abs_self _)
rw [β Real.log_mul, Real.log_le_log_iff, β _root_.abs_of_nonneg (le_trans zero_le_one hz)]
exacts [abs_le_sqrt_two_mul_max z, one_pos.trans_le hz', mul_pos h2 hmβ, h2.ne', hmβ.ne']
_ =o[l] re :=
IsLittleO.add (isLittleO_const_left.2 <| Or.inr <| hl.tendsto_abs_re) <|
isLittleO_iff_nat_mul_le.2 fun n => by
filter_upwards [isLittleO_iff_nat_mul_le'.1 hl.isLittleO_log_re_re n,
hl.abs_im_pow_eventuallyLE_exp_re n,
hl.tendsto_re.eventually_gt_atTop 1] with z hre him hβ
rcases le_total |z.im| z.re with hle | hle
Β· rwa [max_eq_left hle]
Β· have H : 1 < |z.im| := hβ.trans_le hle
norm_cast at *
rwa [max_eq_right hle, Real.norm_eq_abs, Real.norm_eq_abs, abs_of_pos (Real.log_pos H),
β Real.log_pow, Real.log_le_iff_le_exp (pow_pos (one_pos.trans H) _),
abs_of_pos (one_pos.trans hβ)]
| 1,576 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
#align_import analysis.special_functions.pow.continuity from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate
open Filter Finset Set
section CpowLimits
open Complex
variable {Ξ± : Type*}
| Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean | 36 | 41 | theorem zero_cpow_eq_nhds {b : β} (hb : b β 0) : (fun x : β => (0 : β) ^ x) =αΆ [π b] 0 := by |
suffices βαΆ x : β in π b, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [zero_cpow hx, Pi.zero_apply]
exact IsOpen.eventually_mem isOpen_ne hb
| 1,577 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
#align_import analysis.special_functions.pow.continuity from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate
open Filter Finset Set
section CpowLimits
open Complex
variable {Ξ± : Type*}
theorem zero_cpow_eq_nhds {b : β} (hb : b β 0) : (fun x : β => (0 : β) ^ x) =αΆ [π b] 0 := by
suffices βαΆ x : β in π b, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [zero_cpow hx, Pi.zero_apply]
exact IsOpen.eventually_mem isOpen_ne hb
#align zero_cpow_eq_nhds zero_cpow_eq_nhds
| Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean | 44 | 50 | theorem cpow_eq_nhds {a b : β} (ha : a β 0) :
(fun x => x ^ b) =αΆ [π a] fun x => exp (log x * b) := by |
suffices βαΆ x : β in π a, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
exact IsOpen.eventually_mem isOpen_ne ha
| 1,577 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
#align_import analysis.special_functions.pow.continuity from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate
open Filter Finset Set
section CpowLimits
open Complex
variable {Ξ± : Type*}
theorem zero_cpow_eq_nhds {b : β} (hb : b β 0) : (fun x : β => (0 : β) ^ x) =αΆ [π b] 0 := by
suffices βαΆ x : β in π b, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [zero_cpow hx, Pi.zero_apply]
exact IsOpen.eventually_mem isOpen_ne hb
#align zero_cpow_eq_nhds zero_cpow_eq_nhds
theorem cpow_eq_nhds {a b : β} (ha : a β 0) :
(fun x => x ^ b) =αΆ [π a] fun x => exp (log x * b) := by
suffices βαΆ x : β in π a, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
exact IsOpen.eventually_mem isOpen_ne ha
#align cpow_eq_nhds cpow_eq_nhds
| Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean | 53 | 62 | theorem cpow_eq_nhds' {p : β Γ β} (hp_fst : p.fst β 0) :
(fun x => x.1 ^ x.2) =αΆ [π p] fun x => exp (log x.1 * x.2) := by |
suffices βαΆ x : β Γ β in π p, x.1 β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
refine IsOpen.eventually_mem ?_ hp_fst
change IsOpen { x : β Γ β | x.1 = 0 }αΆ
rw [isOpen_compl_iff]
exact isClosed_eq continuous_fst continuous_const
| 1,577 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
#align_import analysis.special_functions.pow.continuity from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate
open Filter Finset Set
section CpowLimits
open Complex
variable {Ξ± : Type*}
theorem zero_cpow_eq_nhds {b : β} (hb : b β 0) : (fun x : β => (0 : β) ^ x) =αΆ [π b] 0 := by
suffices βαΆ x : β in π b, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [zero_cpow hx, Pi.zero_apply]
exact IsOpen.eventually_mem isOpen_ne hb
#align zero_cpow_eq_nhds zero_cpow_eq_nhds
theorem cpow_eq_nhds {a b : β} (ha : a β 0) :
(fun x => x ^ b) =αΆ [π a] fun x => exp (log x * b) := by
suffices βαΆ x : β in π a, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
exact IsOpen.eventually_mem isOpen_ne ha
#align cpow_eq_nhds cpow_eq_nhds
theorem cpow_eq_nhds' {p : β Γ β} (hp_fst : p.fst β 0) :
(fun x => x.1 ^ x.2) =αΆ [π p] fun x => exp (log x.1 * x.2) := by
suffices βαΆ x : β Γ β in π p, x.1 β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
refine IsOpen.eventually_mem ?_ hp_fst
change IsOpen { x : β Γ β | x.1 = 0 }αΆ
rw [isOpen_compl_iff]
exact isClosed_eq continuous_fst continuous_const
#align cpow_eq_nhds' cpow_eq_nhds'
-- Continuity of `fun x => a ^ x`: union of these two lemmas is optimal.
| Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean | 66 | 71 | theorem continuousAt_const_cpow {a b : β} (ha : a β 0) : ContinuousAt (fun x : β => a ^ x) b := by |
have cpow_eq : (fun x : β => a ^ x) = fun x => exp (log a * x) := by
ext1 b
rw [cpow_def_of_ne_zero ha]
rw [cpow_eq]
exact continuous_exp.continuousAt.comp (ContinuousAt.mul continuousAt_const continuousAt_id)
| 1,577 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
#align_import analysis.special_functions.pow.continuity from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate
open Filter Finset Set
section CpowLimits
open Complex
variable {Ξ± : Type*}
theorem zero_cpow_eq_nhds {b : β} (hb : b β 0) : (fun x : β => (0 : β) ^ x) =αΆ [π b] 0 := by
suffices βαΆ x : β in π b, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [zero_cpow hx, Pi.zero_apply]
exact IsOpen.eventually_mem isOpen_ne hb
#align zero_cpow_eq_nhds zero_cpow_eq_nhds
theorem cpow_eq_nhds {a b : β} (ha : a β 0) :
(fun x => x ^ b) =αΆ [π a] fun x => exp (log x * b) := by
suffices βαΆ x : β in π a, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
exact IsOpen.eventually_mem isOpen_ne ha
#align cpow_eq_nhds cpow_eq_nhds
theorem cpow_eq_nhds' {p : β Γ β} (hp_fst : p.fst β 0) :
(fun x => x.1 ^ x.2) =αΆ [π p] fun x => exp (log x.1 * x.2) := by
suffices βαΆ x : β Γ β in π p, x.1 β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
refine IsOpen.eventually_mem ?_ hp_fst
change IsOpen { x : β Γ β | x.1 = 0 }αΆ
rw [isOpen_compl_iff]
exact isClosed_eq continuous_fst continuous_const
#align cpow_eq_nhds' cpow_eq_nhds'
-- Continuity of `fun x => a ^ x`: union of these two lemmas is optimal.
theorem continuousAt_const_cpow {a b : β} (ha : a β 0) : ContinuousAt (fun x : β => a ^ x) b := by
have cpow_eq : (fun x : β => a ^ x) = fun x => exp (log a * x) := by
ext1 b
rw [cpow_def_of_ne_zero ha]
rw [cpow_eq]
exact continuous_exp.continuousAt.comp (ContinuousAt.mul continuousAt_const continuousAt_id)
#align continuous_at_const_cpow continuousAt_const_cpow
| Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean | 74 | 78 | theorem continuousAt_const_cpow' {a b : β} (h : b β 0) : ContinuousAt (fun x : β => a ^ x) b := by |
by_cases ha : a = 0
Β· rw [ha, continuousAt_congr (zero_cpow_eq_nhds h)]
exact continuousAt_const
Β· exact continuousAt_const_cpow ha
| 1,577 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
#align_import analysis.special_functions.pow.continuity from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate
open Filter Finset Set
section CpowLimits
open Complex
variable {Ξ± : Type*}
theorem zero_cpow_eq_nhds {b : β} (hb : b β 0) : (fun x : β => (0 : β) ^ x) =αΆ [π b] 0 := by
suffices βαΆ x : β in π b, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [zero_cpow hx, Pi.zero_apply]
exact IsOpen.eventually_mem isOpen_ne hb
#align zero_cpow_eq_nhds zero_cpow_eq_nhds
theorem cpow_eq_nhds {a b : β} (ha : a β 0) :
(fun x => x ^ b) =αΆ [π a] fun x => exp (log x * b) := by
suffices βαΆ x : β in π a, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
exact IsOpen.eventually_mem isOpen_ne ha
#align cpow_eq_nhds cpow_eq_nhds
theorem cpow_eq_nhds' {p : β Γ β} (hp_fst : p.fst β 0) :
(fun x => x.1 ^ x.2) =αΆ [π p] fun x => exp (log x.1 * x.2) := by
suffices βαΆ x : β Γ β in π p, x.1 β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
refine IsOpen.eventually_mem ?_ hp_fst
change IsOpen { x : β Γ β | x.1 = 0 }αΆ
rw [isOpen_compl_iff]
exact isClosed_eq continuous_fst continuous_const
#align cpow_eq_nhds' cpow_eq_nhds'
-- Continuity of `fun x => a ^ x`: union of these two lemmas is optimal.
theorem continuousAt_const_cpow {a b : β} (ha : a β 0) : ContinuousAt (fun x : β => a ^ x) b := by
have cpow_eq : (fun x : β => a ^ x) = fun x => exp (log a * x) := by
ext1 b
rw [cpow_def_of_ne_zero ha]
rw [cpow_eq]
exact continuous_exp.continuousAt.comp (ContinuousAt.mul continuousAt_const continuousAt_id)
#align continuous_at_const_cpow continuousAt_const_cpow
theorem continuousAt_const_cpow' {a b : β} (h : b β 0) : ContinuousAt (fun x : β => a ^ x) b := by
by_cases ha : a = 0
Β· rw [ha, continuousAt_congr (zero_cpow_eq_nhds h)]
exact continuousAt_const
Β· exact continuousAt_const_cpow ha
#align continuous_at_const_cpow' continuousAt_const_cpow'
| Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean | 84 | 91 | theorem continuousAt_cpow {p : β Γ β} (hp_fst : p.fst β slitPlane) :
ContinuousAt (fun x : β Γ β => x.1 ^ x.2) p := by |
rw [continuousAt_congr (cpow_eq_nhds' <| slitPlane_ne_zero hp_fst)]
refine continuous_exp.continuousAt.comp ?_
exact
ContinuousAt.mul
(ContinuousAt.comp (continuousAt_clog hp_fst) continuous_fst.continuousAt)
continuous_snd.continuousAt
| 1,577 |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
#align_import analysis.special_functions.pow.continuity from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate
open Filter Finset Set
section CpowLimits
open Complex
variable {Ξ± : Type*}
theorem zero_cpow_eq_nhds {b : β} (hb : b β 0) : (fun x : β => (0 : β) ^ x) =αΆ [π b] 0 := by
suffices βαΆ x : β in π b, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [zero_cpow hx, Pi.zero_apply]
exact IsOpen.eventually_mem isOpen_ne hb
#align zero_cpow_eq_nhds zero_cpow_eq_nhds
theorem cpow_eq_nhds {a b : β} (ha : a β 0) :
(fun x => x ^ b) =αΆ [π a] fun x => exp (log x * b) := by
suffices βαΆ x : β in π a, x β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
exact IsOpen.eventually_mem isOpen_ne ha
#align cpow_eq_nhds cpow_eq_nhds
theorem cpow_eq_nhds' {p : β Γ β} (hp_fst : p.fst β 0) :
(fun x => x.1 ^ x.2) =αΆ [π p] fun x => exp (log x.1 * x.2) := by
suffices βαΆ x : β Γ β in π p, x.1 β 0 from
this.mono fun x hx β¦ by
dsimp only
rw [cpow_def_of_ne_zero hx]
refine IsOpen.eventually_mem ?_ hp_fst
change IsOpen { x : β Γ β | x.1 = 0 }αΆ
rw [isOpen_compl_iff]
exact isClosed_eq continuous_fst continuous_const
#align cpow_eq_nhds' cpow_eq_nhds'
-- Continuity of `fun x => a ^ x`: union of these two lemmas is optimal.
theorem continuousAt_const_cpow {a b : β} (ha : a β 0) : ContinuousAt (fun x : β => a ^ x) b := by
have cpow_eq : (fun x : β => a ^ x) = fun x => exp (log a * x) := by
ext1 b
rw [cpow_def_of_ne_zero ha]
rw [cpow_eq]
exact continuous_exp.continuousAt.comp (ContinuousAt.mul continuousAt_const continuousAt_id)
#align continuous_at_const_cpow continuousAt_const_cpow
theorem continuousAt_const_cpow' {a b : β} (h : b β 0) : ContinuousAt (fun x : β => a ^ x) b := by
by_cases ha : a = 0
Β· rw [ha, continuousAt_congr (zero_cpow_eq_nhds h)]
exact continuousAt_const
Β· exact continuousAt_const_cpow ha
#align continuous_at_const_cpow' continuousAt_const_cpow'
theorem continuousAt_cpow {p : β Γ β} (hp_fst : p.fst β slitPlane) :
ContinuousAt (fun x : β Γ β => x.1 ^ x.2) p := by
rw [continuousAt_congr (cpow_eq_nhds' <| slitPlane_ne_zero hp_fst)]
refine continuous_exp.continuousAt.comp ?_
exact
ContinuousAt.mul
(ContinuousAt.comp (continuousAt_clog hp_fst) continuous_fst.continuousAt)
continuous_snd.continuousAt
#align continuous_at_cpow continuousAt_cpow
theorem continuousAt_cpow_const {a b : β} (ha : a β slitPlane) :
ContinuousAt (Β· ^ b) a :=
Tendsto.comp (@continuousAt_cpow (a, b) ha) (continuousAt_id.prod continuousAt_const)
#align continuous_at_cpow_const continuousAt_cpow_const
theorem Filter.Tendsto.cpow {l : Filter Ξ±} {f g : Ξ± β β} {a b : β} (hf : Tendsto f l (π a))
(hg : Tendsto g l (π b)) (ha : a β slitPlane) :
Tendsto (fun x => f x ^ g x) l (π (a ^ b)) :=
(@continuousAt_cpow (a, b) ha).tendsto.comp (hf.prod_mk_nhds hg)
#align filter.tendsto.cpow Filter.Tendsto.cpow
| Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean | 105 | 109 | theorem Filter.Tendsto.const_cpow {l : Filter Ξ±} {f : Ξ± β β} {a b : β} (hf : Tendsto f l (π b))
(h : a β 0 β¨ b β 0) : Tendsto (fun x => a ^ f x) l (π (a ^ b)) := by |
cases h with
| inl h => exact (continuousAt_const_cpow h).tendsto.comp hf
| inr h => exact (continuousAt_const_cpow' h).tendsto.comp hf
| 1,577 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SumOverResidueClass
#align_import analysis.p_series from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
def SuccDiffBounded (C : β) (u : β β β) : Prop :=
β n : β, u (n + 2) - u (n + 1) β€ C β’ (u (n + 1) - u n)
namespace Finset
variable {M : Type*} [OrderedAddCommMonoid M] {f : β β M} {u : β β β}
| Mathlib/Analysis/PSeries.lean | 50 | 62 | theorem le_sum_schlomilch' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β Ico (u 0) (u n), f k) β€ β k β range n, (u (k + 1) - u k) β’ f (u k) := by |
induction' n with n ihn
Β· simp
suffices (β k β Ico (u n) (u (n + 1)), f k) β€ (u (n + 1) - u n) β’ f (u n) by
rw [sum_range_succ, β sum_Ico_consecutive]
Β· exact add_le_add ihn this
exacts [hu n.zero_le, hu n.le_succ]
have : β k β Ico (u n) (u (n + 1)), f k β€ f (u n) := fun k hk =>
hf (Nat.succ_le_of_lt (h_pos n)) (mem_Ico.mp hk).1
convert sum_le_sum this
simp [pow_succ, mul_two]
| 1,578 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SumOverResidueClass
#align_import analysis.p_series from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
def SuccDiffBounded (C : β) (u : β β β) : Prop :=
β n : β, u (n + 2) - u (n + 1) β€ C β’ (u (n + 1) - u n)
namespace Finset
variable {M : Type*} [OrderedAddCommMonoid M] {f : β β M} {u : β β β}
theorem le_sum_schlomilch' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β Ico (u 0) (u n), f k) β€ β k β range n, (u (k + 1) - u k) β’ f (u k) := by
induction' n with n ihn
Β· simp
suffices (β k β Ico (u n) (u (n + 1)), f k) β€ (u (n + 1) - u n) β’ f (u n) by
rw [sum_range_succ, β sum_Ico_consecutive]
Β· exact add_le_add ihn this
exacts [hu n.zero_le, hu n.le_succ]
have : β k β Ico (u n) (u (n + 1)), f k β€ f (u n) := fun k hk =>
hf (Nat.succ_le_of_lt (h_pos n)) (mem_Ico.mp hk).1
convert sum_le_sum this
simp [pow_succ, mul_two]
| Mathlib/Analysis/PSeries.lean | 64 | 68 | theorem le_sum_condensed' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (n : β) :
(β k β Ico 1 (2 ^ n), f k) β€ β k β range n, 2 ^ k β’ f (2 ^ k) := by |
convert le_sum_schlomilch' hf (fun n => pow_pos zero_lt_two n)
(fun m n hm => pow_le_pow_right one_le_two hm) n using 2
simp [pow_succ, mul_two, two_mul]
| 1,578 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SumOverResidueClass
#align_import analysis.p_series from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
def SuccDiffBounded (C : β) (u : β β β) : Prop :=
β n : β, u (n + 2) - u (n + 1) β€ C β’ (u (n + 1) - u n)
namespace Finset
variable {M : Type*} [OrderedAddCommMonoid M] {f : β β M} {u : β β β}
theorem le_sum_schlomilch' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β Ico (u 0) (u n), f k) β€ β k β range n, (u (k + 1) - u k) β’ f (u k) := by
induction' n with n ihn
Β· simp
suffices (β k β Ico (u n) (u (n + 1)), f k) β€ (u (n + 1) - u n) β’ f (u n) by
rw [sum_range_succ, β sum_Ico_consecutive]
Β· exact add_le_add ihn this
exacts [hu n.zero_le, hu n.le_succ]
have : β k β Ico (u n) (u (n + 1)), f k β€ f (u n) := fun k hk =>
hf (Nat.succ_le_of_lt (h_pos n)) (mem_Ico.mp hk).1
convert sum_le_sum this
simp [pow_succ, mul_two]
theorem le_sum_condensed' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (n : β) :
(β k β Ico 1 (2 ^ n), f k) β€ β k β range n, 2 ^ k β’ f (2 ^ k) := by
convert le_sum_schlomilch' hf (fun n => pow_pos zero_lt_two n)
(fun m n hm => pow_le_pow_right one_le_two hm) n using 2
simp [pow_succ, mul_two, two_mul]
#align finset.le_sum_condensed' Finset.le_sum_condensed'
| Mathlib/Analysis/PSeries.lean | 71 | 76 | theorem le_sum_schlomilch (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β range (u n), f k) β€
β k β range (u 0), f k + β k β range n, (u (k + 1) - u k) β’ f (u k) := by |
convert add_le_add_left (le_sum_schlomilch' hf h_pos hu n) (β k β range (u 0), f k)
rw [β sum_range_add_sum_Ico _ (hu n.zero_le)]
| 1,578 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SumOverResidueClass
#align_import analysis.p_series from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
def SuccDiffBounded (C : β) (u : β β β) : Prop :=
β n : β, u (n + 2) - u (n + 1) β€ C β’ (u (n + 1) - u n)
namespace Finset
variable {M : Type*} [OrderedAddCommMonoid M] {f : β β M} {u : β β β}
theorem le_sum_schlomilch' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β Ico (u 0) (u n), f k) β€ β k β range n, (u (k + 1) - u k) β’ f (u k) := by
induction' n with n ihn
Β· simp
suffices (β k β Ico (u n) (u (n + 1)), f k) β€ (u (n + 1) - u n) β’ f (u n) by
rw [sum_range_succ, β sum_Ico_consecutive]
Β· exact add_le_add ihn this
exacts [hu n.zero_le, hu n.le_succ]
have : β k β Ico (u n) (u (n + 1)), f k β€ f (u n) := fun k hk =>
hf (Nat.succ_le_of_lt (h_pos n)) (mem_Ico.mp hk).1
convert sum_le_sum this
simp [pow_succ, mul_two]
theorem le_sum_condensed' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (n : β) :
(β k β Ico 1 (2 ^ n), f k) β€ β k β range n, 2 ^ k β’ f (2 ^ k) := by
convert le_sum_schlomilch' hf (fun n => pow_pos zero_lt_two n)
(fun m n hm => pow_le_pow_right one_le_two hm) n using 2
simp [pow_succ, mul_two, two_mul]
#align finset.le_sum_condensed' Finset.le_sum_condensed'
theorem le_sum_schlomilch (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β range (u n), f k) β€
β k β range (u 0), f k + β k β range n, (u (k + 1) - u k) β’ f (u k) := by
convert add_le_add_left (le_sum_schlomilch' hf h_pos hu n) (β k β range (u 0), f k)
rw [β sum_range_add_sum_Ico _ (hu n.zero_le)]
| Mathlib/Analysis/PSeries.lean | 78 | 81 | theorem le_sum_condensed (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (n : β) :
(β k β range (2 ^ n), f k) β€ f 0 + β k β range n, 2 ^ k β’ f (2 ^ k) := by |
convert add_le_add_left (le_sum_condensed' hf n) (f 0)
rw [β sum_range_add_sum_Ico _ n.one_le_two_pow, sum_range_succ, sum_range_zero, zero_add]
| 1,578 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SumOverResidueClass
#align_import analysis.p_series from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
def SuccDiffBounded (C : β) (u : β β β) : Prop :=
β n : β, u (n + 2) - u (n + 1) β€ C β’ (u (n + 1) - u n)
namespace Finset
variable {M : Type*} [OrderedAddCommMonoid M] {f : β β M} {u : β β β}
theorem le_sum_schlomilch' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β Ico (u 0) (u n), f k) β€ β k β range n, (u (k + 1) - u k) β’ f (u k) := by
induction' n with n ihn
Β· simp
suffices (β k β Ico (u n) (u (n + 1)), f k) β€ (u (n + 1) - u n) β’ f (u n) by
rw [sum_range_succ, β sum_Ico_consecutive]
Β· exact add_le_add ihn this
exacts [hu n.zero_le, hu n.le_succ]
have : β k β Ico (u n) (u (n + 1)), f k β€ f (u n) := fun k hk =>
hf (Nat.succ_le_of_lt (h_pos n)) (mem_Ico.mp hk).1
convert sum_le_sum this
simp [pow_succ, mul_two]
theorem le_sum_condensed' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (n : β) :
(β k β Ico 1 (2 ^ n), f k) β€ β k β range n, 2 ^ k β’ f (2 ^ k) := by
convert le_sum_schlomilch' hf (fun n => pow_pos zero_lt_two n)
(fun m n hm => pow_le_pow_right one_le_two hm) n using 2
simp [pow_succ, mul_two, two_mul]
#align finset.le_sum_condensed' Finset.le_sum_condensed'
theorem le_sum_schlomilch (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β range (u n), f k) β€
β k β range (u 0), f k + β k β range n, (u (k + 1) - u k) β’ f (u k) := by
convert add_le_add_left (le_sum_schlomilch' hf h_pos hu n) (β k β range (u 0), f k)
rw [β sum_range_add_sum_Ico _ (hu n.zero_le)]
theorem le_sum_condensed (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (n : β) :
(β k β range (2 ^ n), f k) β€ f 0 + β k β range n, 2 ^ k β’ f (2 ^ k) := by
convert add_le_add_left (le_sum_condensed' hf n) (f 0)
rw [β sum_range_add_sum_Ico _ n.one_le_two_pow, sum_range_succ, sum_range_zero, zero_add]
#align finset.le_sum_condensed Finset.le_sum_condensed
| Mathlib/Analysis/PSeries.lean | 84 | 98 | theorem sum_schlomilch_le' (hf : β β¦m nβ¦, 1 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β range n, (u (k + 1) - u k) β’ f (u (k + 1))) β€ β k β Ico (u 0 + 1) (u n + 1), f k := by |
induction' n with n ihn
Β· simp
suffices (u (n + 1) - u n) β’ f (u (n + 1)) β€ β k β Ico (u n + 1) (u (n + 1) + 1), f k by
rw [sum_range_succ, β sum_Ico_consecutive]
exacts [add_le_add ihn this,
(add_le_add_right (hu n.zero_le) _ : u 0 + 1 β€ u n + 1),
add_le_add_right (hu n.le_succ) _]
have : β k β Ico (u n + 1) (u (n + 1) + 1), f (u (n + 1)) β€ f k := fun k hk =>
hf (Nat.lt_of_le_of_lt (Nat.succ_le_of_lt (h_pos n)) <| (Nat.lt_succ_of_le le_rfl).trans_le
(mem_Ico.mp hk).1) (Nat.le_of_lt_succ <| (mem_Ico.mp hk).2)
convert sum_le_sum this
simp [pow_succ, mul_two]
| 1,578 |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SumOverResidueClass
#align_import analysis.p_series from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
def SuccDiffBounded (C : β) (u : β β β) : Prop :=
β n : β, u (n + 2) - u (n + 1) β€ C β’ (u (n + 1) - u n)
namespace Finset
variable {M : Type*} [OrderedAddCommMonoid M] {f : β β M} {u : β β β}
theorem le_sum_schlomilch' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β Ico (u 0) (u n), f k) β€ β k β range n, (u (k + 1) - u k) β’ f (u k) := by
induction' n with n ihn
Β· simp
suffices (β k β Ico (u n) (u (n + 1)), f k) β€ (u (n + 1) - u n) β’ f (u n) by
rw [sum_range_succ, β sum_Ico_consecutive]
Β· exact add_le_add ihn this
exacts [hu n.zero_le, hu n.le_succ]
have : β k β Ico (u n) (u (n + 1)), f k β€ f (u n) := fun k hk =>
hf (Nat.succ_le_of_lt (h_pos n)) (mem_Ico.mp hk).1
convert sum_le_sum this
simp [pow_succ, mul_two]
theorem le_sum_condensed' (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (n : β) :
(β k β Ico 1 (2 ^ n), f k) β€ β k β range n, 2 ^ k β’ f (2 ^ k) := by
convert le_sum_schlomilch' hf (fun n => pow_pos zero_lt_two n)
(fun m n hm => pow_le_pow_right one_le_two hm) n using 2
simp [pow_succ, mul_two, two_mul]
#align finset.le_sum_condensed' Finset.le_sum_condensed'
theorem le_sum_schlomilch (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β range (u n), f k) β€
β k β range (u 0), f k + β k β range n, (u (k + 1) - u k) β’ f (u k) := by
convert add_le_add_left (le_sum_schlomilch' hf h_pos hu n) (β k β range (u 0), f k)
rw [β sum_range_add_sum_Ico _ (hu n.zero_le)]
theorem le_sum_condensed (hf : β β¦m nβ¦, 0 < m β m β€ n β f n β€ f m) (n : β) :
(β k β range (2 ^ n), f k) β€ f 0 + β k β range n, 2 ^ k β’ f (2 ^ k) := by
convert add_le_add_left (le_sum_condensed' hf n) (f 0)
rw [β sum_range_add_sum_Ico _ n.one_le_two_pow, sum_range_succ, sum_range_zero, zero_add]
#align finset.le_sum_condensed Finset.le_sum_condensed
theorem sum_schlomilch_le' (hf : β β¦m nβ¦, 1 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(hu : Monotone u) (n : β) :
(β k β range n, (u (k + 1) - u k) β’ f (u (k + 1))) β€ β k β Ico (u 0 + 1) (u n + 1), f k := by
induction' n with n ihn
Β· simp
suffices (u (n + 1) - u n) β’ f (u (n + 1)) β€ β k β Ico (u n + 1) (u (n + 1) + 1), f k by
rw [sum_range_succ, β sum_Ico_consecutive]
exacts [add_le_add ihn this,
(add_le_add_right (hu n.zero_le) _ : u 0 + 1 β€ u n + 1),
add_le_add_right (hu n.le_succ) _]
have : β k β Ico (u n + 1) (u (n + 1) + 1), f (u (n + 1)) β€ f k := fun k hk =>
hf (Nat.lt_of_le_of_lt (Nat.succ_le_of_lt (h_pos n)) <| (Nat.lt_succ_of_le le_rfl).trans_le
(mem_Ico.mp hk).1) (Nat.le_of_lt_succ <| (mem_Ico.mp hk).2)
convert sum_le_sum this
simp [pow_succ, mul_two]
| Mathlib/Analysis/PSeries.lean | 100 | 104 | theorem sum_condensed_le' (hf : β β¦m nβ¦, 1 < m β m β€ n β f n β€ f m) (n : β) :
(β k β range n, 2 ^ k β’ f (2 ^ (k + 1))) β€ β k β Ico 2 (2 ^ n + 1), f k := by |
convert sum_schlomilch_le' hf (fun n => pow_pos zero_lt_two n)
(fun m n hm => pow_le_pow_right one_le_two hm) n using 2
simp [pow_succ, mul_two, two_mul]
| 1,578 |
import Mathlib.NumberTheory.SmoothNumbers
import Mathlib.Analysis.PSeries
open Set Nat
open scoped Topology
-- This needs `Mathlib.Analysis.RCLike.Basic`, so we put it here
-- instead of in `Mathlib.NumberTheory.SmoothNumbers`.
lemma Nat.roughNumbersUpTo_card_le' (N k : β) :
(roughNumbersUpTo N k).card β€
N * (N.succ.primesBelow \ k.primesBelow).sum (fun p β¦ (1 : β) / p) := by
simp_rw [Finset.mul_sum, mul_one_div]
exact (Nat.cast_le.mpr <| roughNumbersUpTo_card_le N k).trans <|
(cast_sum (Ξ² := β) ..) βΈ Finset.sum_le_sum fun n _ β¦ cast_div_le
lemma one_half_le_sum_primes_ge_one_div (k : β) :
1 / 2 β€ β p β (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow,
(1 / p : β) := by
set m : β := 2 ^ k.primesBelow.card
set Nβ : β := 2 * m ^ 2 with hNβ
let S : β := ((2 * Nβ).succ.primesBelow \ k.primesBelow).sum (fun p β¦ (1 / p : β))
suffices 1 / 2 β€ S by
convert this using 5
rw [show 4 = 2 ^ 2 by norm_num, pow_right_comm]
ring
suffices 2 * Nβ β€ m * (2 * Nβ).sqrt + 2 * Nβ * S by
rwa [hNβ, β mul_assoc, β pow_two 2, β mul_pow, sqrt_eq', β sub_le_iff_le_add',
cast_mul, cast_mul, cast_pow, cast_two,
show (2 * (2 * m ^ 2) - m * (2 * m) : β) = 2 * (2 * m ^ 2) * (1 / 2) by ring,
_root_.mul_le_mul_left <| by positivity] at this
calc (2 * Nβ : β)
_ = ((2 * Nβ).smoothNumbersUpTo k).card + ((2 * Nβ).roughNumbersUpTo k).card := by
exact_mod_cast ((2 * Nβ).smoothNumbersUpTo_card_add_roughNumbersUpTo_card k).symm
_ β€ m * (2 * Nβ).sqrt + ((2 * Nβ).roughNumbersUpTo k).card := by
exact_mod_cast Nat.add_le_add_right ((2 * Nβ).smoothNumbersUpTo_card_le k) _
_ β€ m * (2 * Nβ).sqrt + 2 * Nβ * S := add_le_add_left ?_ _
exact_mod_cast roughNumbersUpTo_card_le' (2 * Nβ) k
| Mathlib/NumberTheory/SumPrimeReciprocals.lean | 64 | 79 | theorem not_summable_one_div_on_primes :
Β¬ Summable (indicator {p | p.Prime} (fun n : β β¦ (1 : β) / n)) := by |
intro h
obtain β¨k, hkβ© := h.nat_tsum_vanishing (Iio_mem_nhds one_half_pos : Iio (1 / 2 : β) β π 0)
specialize hk ({p | Nat.Prime p} β© {p | k β€ p}) inter_subset_right
rw [tsum_subtype, indicator_indicator, inter_eq_left.mpr fun n hn β¦ hn.1, mem_Iio] at hk
have h' : Summable (indicator ({p | Nat.Prime p} β© {p | k β€ p}) fun n β¦ (1 : β) / n) := by
convert h.indicator {n : β | k β€ n} using 1
simp only [indicator_indicator, inter_comm]
refine ((one_half_le_sum_primes_ge_one_div k).trans_lt <| LE.le.trans_lt ?_ hk).false
convert sum_le_tsum (primesBelow ((4 ^ (k.primesBelow.card + 1)).succ) \ primesBelow k)
(fun n _ β¦ indicator_nonneg (fun p _ β¦ by positivity) _) h' using 2 with p hp
obtain β¨hpβ, hpββ© := mem_setOf_eq βΈ Finset.mem_sdiff.mp hp
have hpp := prime_of_mem_primesBelow hpβ
refine (indicator_of_mem (mem_def.mpr β¨hpp, ?_β©) fun n : β β¦ (1 / n : β)).symm
exact not_lt.mp <| (not_and_or.mp <| (not_congr mem_primesBelow).mp hpβ).neg_resolve_right hpp
| 1,579 |
import Mathlib.NumberTheory.SmoothNumbers
import Mathlib.Analysis.PSeries
open Set Nat
open scoped Topology
-- This needs `Mathlib.Analysis.RCLike.Basic`, so we put it here
-- instead of in `Mathlib.NumberTheory.SmoothNumbers`.
lemma Nat.roughNumbersUpTo_card_le' (N k : β) :
(roughNumbersUpTo N k).card β€
N * (N.succ.primesBelow \ k.primesBelow).sum (fun p β¦ (1 : β) / p) := by
simp_rw [Finset.mul_sum, mul_one_div]
exact (Nat.cast_le.mpr <| roughNumbersUpTo_card_le N k).trans <|
(cast_sum (Ξ² := β) ..) βΈ Finset.sum_le_sum fun n _ β¦ cast_div_le
lemma one_half_le_sum_primes_ge_one_div (k : β) :
1 / 2 β€ β p β (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow,
(1 / p : β) := by
set m : β := 2 ^ k.primesBelow.card
set Nβ : β := 2 * m ^ 2 with hNβ
let S : β := ((2 * Nβ).succ.primesBelow \ k.primesBelow).sum (fun p β¦ (1 / p : β))
suffices 1 / 2 β€ S by
convert this using 5
rw [show 4 = 2 ^ 2 by norm_num, pow_right_comm]
ring
suffices 2 * Nβ β€ m * (2 * Nβ).sqrt + 2 * Nβ * S by
rwa [hNβ, β mul_assoc, β pow_two 2, β mul_pow, sqrt_eq', β sub_le_iff_le_add',
cast_mul, cast_mul, cast_pow, cast_two,
show (2 * (2 * m ^ 2) - m * (2 * m) : β) = 2 * (2 * m ^ 2) * (1 / 2) by ring,
_root_.mul_le_mul_left <| by positivity] at this
calc (2 * Nβ : β)
_ = ((2 * Nβ).smoothNumbersUpTo k).card + ((2 * Nβ).roughNumbersUpTo k).card := by
exact_mod_cast ((2 * Nβ).smoothNumbersUpTo_card_add_roughNumbersUpTo_card k).symm
_ β€ m * (2 * Nβ).sqrt + ((2 * Nβ).roughNumbersUpTo k).card := by
exact_mod_cast Nat.add_le_add_right ((2 * Nβ).smoothNumbersUpTo_card_le k) _
_ β€ m * (2 * Nβ).sqrt + 2 * Nβ * S := add_le_add_left ?_ _
exact_mod_cast roughNumbersUpTo_card_le' (2 * Nβ) k
theorem not_summable_one_div_on_primes :
Β¬ Summable (indicator {p | p.Prime} (fun n : β β¦ (1 : β) / n)) := by
intro h
obtain β¨k, hkβ© := h.nat_tsum_vanishing (Iio_mem_nhds one_half_pos : Iio (1 / 2 : β) β π 0)
specialize hk ({p | Nat.Prime p} β© {p | k β€ p}) inter_subset_right
rw [tsum_subtype, indicator_indicator, inter_eq_left.mpr fun n hn β¦ hn.1, mem_Iio] at hk
have h' : Summable (indicator ({p | Nat.Prime p} β© {p | k β€ p}) fun n β¦ (1 : β) / n) := by
convert h.indicator {n : β | k β€ n} using 1
simp only [indicator_indicator, inter_comm]
refine ((one_half_le_sum_primes_ge_one_div k).trans_lt <| LE.le.trans_lt ?_ hk).false
convert sum_le_tsum (primesBelow ((4 ^ (k.primesBelow.card + 1)).succ) \ primesBelow k)
(fun n _ β¦ indicator_nonneg (fun p _ β¦ by positivity) _) h' using 2 with p hp
obtain β¨hpβ, hpββ© := mem_setOf_eq βΈ Finset.mem_sdiff.mp hp
have hpp := prime_of_mem_primesBelow hpβ
refine (indicator_of_mem (mem_def.mpr β¨hpp, ?_β©) fun n : β β¦ (1 / n : β)).symm
exact not_lt.mp <| (not_and_or.mp <| (not_congr mem_primesBelow).mp hpβ).neg_resolve_right hpp
| Mathlib/NumberTheory/SumPrimeReciprocals.lean | 82 | 83 | theorem Nat.Primes.not_summable_one_div : Β¬ Summable (fun p : Nat.Primes β¦ (1 / p : β)) := by |
convert summable_subtype_iff_indicator.mp.mt not_summable_one_div_on_primes
| 1,579 |
import Mathlib.NumberTheory.SmoothNumbers
import Mathlib.Analysis.PSeries
open Set Nat
open scoped Topology
-- This needs `Mathlib.Analysis.RCLike.Basic`, so we put it here
-- instead of in `Mathlib.NumberTheory.SmoothNumbers`.
lemma Nat.roughNumbersUpTo_card_le' (N k : β) :
(roughNumbersUpTo N k).card β€
N * (N.succ.primesBelow \ k.primesBelow).sum (fun p β¦ (1 : β) / p) := by
simp_rw [Finset.mul_sum, mul_one_div]
exact (Nat.cast_le.mpr <| roughNumbersUpTo_card_le N k).trans <|
(cast_sum (Ξ² := β) ..) βΈ Finset.sum_le_sum fun n _ β¦ cast_div_le
lemma one_half_le_sum_primes_ge_one_div (k : β) :
1 / 2 β€ β p β (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow,
(1 / p : β) := by
set m : β := 2 ^ k.primesBelow.card
set Nβ : β := 2 * m ^ 2 with hNβ
let S : β := ((2 * Nβ).succ.primesBelow \ k.primesBelow).sum (fun p β¦ (1 / p : β))
suffices 1 / 2 β€ S by
convert this using 5
rw [show 4 = 2 ^ 2 by norm_num, pow_right_comm]
ring
suffices 2 * Nβ β€ m * (2 * Nβ).sqrt + 2 * Nβ * S by
rwa [hNβ, β mul_assoc, β pow_two 2, β mul_pow, sqrt_eq', β sub_le_iff_le_add',
cast_mul, cast_mul, cast_pow, cast_two,
show (2 * (2 * m ^ 2) - m * (2 * m) : β) = 2 * (2 * m ^ 2) * (1 / 2) by ring,
_root_.mul_le_mul_left <| by positivity] at this
calc (2 * Nβ : β)
_ = ((2 * Nβ).smoothNumbersUpTo k).card + ((2 * Nβ).roughNumbersUpTo k).card := by
exact_mod_cast ((2 * Nβ).smoothNumbersUpTo_card_add_roughNumbersUpTo_card k).symm
_ β€ m * (2 * Nβ).sqrt + ((2 * Nβ).roughNumbersUpTo k).card := by
exact_mod_cast Nat.add_le_add_right ((2 * Nβ).smoothNumbersUpTo_card_le k) _
_ β€ m * (2 * Nβ).sqrt + 2 * Nβ * S := add_le_add_left ?_ _
exact_mod_cast roughNumbersUpTo_card_le' (2 * Nβ) k
theorem not_summable_one_div_on_primes :
Β¬ Summable (indicator {p | p.Prime} (fun n : β β¦ (1 : β) / n)) := by
intro h
obtain β¨k, hkβ© := h.nat_tsum_vanishing (Iio_mem_nhds one_half_pos : Iio (1 / 2 : β) β π 0)
specialize hk ({p | Nat.Prime p} β© {p | k β€ p}) inter_subset_right
rw [tsum_subtype, indicator_indicator, inter_eq_left.mpr fun n hn β¦ hn.1, mem_Iio] at hk
have h' : Summable (indicator ({p | Nat.Prime p} β© {p | k β€ p}) fun n β¦ (1 : β) / n) := by
convert h.indicator {n : β | k β€ n} using 1
simp only [indicator_indicator, inter_comm]
refine ((one_half_le_sum_primes_ge_one_div k).trans_lt <| LE.le.trans_lt ?_ hk).false
convert sum_le_tsum (primesBelow ((4 ^ (k.primesBelow.card + 1)).succ) \ primesBelow k)
(fun n _ β¦ indicator_nonneg (fun p _ β¦ by positivity) _) h' using 2 with p hp
obtain β¨hpβ, hpββ© := mem_setOf_eq βΈ Finset.mem_sdiff.mp hp
have hpp := prime_of_mem_primesBelow hpβ
refine (indicator_of_mem (mem_def.mpr β¨hpp, ?_β©) fun n : β β¦ (1 / n : β)).symm
exact not_lt.mp <| (not_and_or.mp <| (not_congr mem_primesBelow).mp hpβ).neg_resolve_right hpp
theorem Nat.Primes.not_summable_one_div : Β¬ Summable (fun p : Nat.Primes β¦ (1 / p : β)) := by
convert summable_subtype_iff_indicator.mp.mt not_summable_one_div_on_primes
| Mathlib/NumberTheory/SumPrimeReciprocals.lean | 86 | 97 | theorem Nat.Primes.summable_rpow {r : β} :
Summable (fun p : Nat.Primes β¦ (p : β) ^ r) β r < -1 := by |
by_cases h : r < -1
Β· -- case `r < -1`
simp only [h, iff_true]
exact (Real.summable_nat_rpow.mpr h).subtype _
Β· -- case `-1 β€ r`
simp only [h, iff_false]
refine fun H β¦ Nat.Primes.not_summable_one_div <| H.of_nonneg_of_le (fun _ β¦ by positivity) ?_
intro p
rw [one_div, β Real.rpow_neg_one]
exact Real.rpow_le_rpow_of_exponent_le (by exact_mod_cast p.prop.one_lt.le) <| not_lt.mp h
| 1,579 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
| Mathlib/Data/Nat/Choose/Multinomial.lean | 80 | 85 | theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by |
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
| 1,580 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
#align nat.multinomial_insert_one Nat.multinomial_insert_one
| Mathlib/Data/Nat/Choose/Multinomial.lean | 88 | 92 | theorem multinomial_congr {f g : Ξ± β β} (h : β a β s, f a = g a) :
multinomial s f = multinomial s g := by |
simp only [multinomial]; congr 1
Β· rw [Finset.sum_congr rfl h]
Β· exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
| 1,580 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
#align nat.multinomial_insert_one Nat.multinomial_insert_one
theorem multinomial_congr {f g : Ξ± β β} (h : β a β s, f a = g a) :
multinomial s f = multinomial s g := by
simp only [multinomial]; congr 1
Β· rw [Finset.sum_congr rfl h]
Β· exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
#align nat.multinomial_congr Nat.multinomial_congr
| Mathlib/Data/Nat/Choose/Multinomial.lean | 102 | 104 | theorem binomial_eq [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!) := by |
simp [multinomial, Finset.sum_pair h, Finset.prod_pair h]
| 1,580 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
#align nat.multinomial_insert_one Nat.multinomial_insert_one
theorem multinomial_congr {f g : Ξ± β β} (h : β a β s, f a = g a) :
multinomial s f = multinomial s g := by
simp only [multinomial]; congr 1
Β· rw [Finset.sum_congr rfl h]
Β· exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
#align nat.multinomial_congr Nat.multinomial_congr
theorem binomial_eq [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!) := by
simp [multinomial, Finset.sum_pair h, Finset.prod_pair h]
#align nat.binomial_eq Nat.binomial_eq
| Mathlib/Data/Nat/Choose/Multinomial.lean | 107 | 109 | theorem binomial_eq_choose [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b).choose (f a) := by |
simp [binomial_eq h, choose_eq_factorial_div_factorial (Nat.le_add_right _ _)]
| 1,580 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
#align nat.multinomial_insert_one Nat.multinomial_insert_one
theorem multinomial_congr {f g : Ξ± β β} (h : β a β s, f a = g a) :
multinomial s f = multinomial s g := by
simp only [multinomial]; congr 1
Β· rw [Finset.sum_congr rfl h]
Β· exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
#align nat.multinomial_congr Nat.multinomial_congr
theorem binomial_eq [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!) := by
simp [multinomial, Finset.sum_pair h, Finset.prod_pair h]
#align nat.binomial_eq Nat.binomial_eq
theorem binomial_eq_choose [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b).choose (f a) := by
simp [binomial_eq h, choose_eq_factorial_div_factorial (Nat.le_add_right _ _)]
#align nat.binomial_eq_choose Nat.binomial_eq_choose
| Mathlib/Data/Nat/Choose/Multinomial.lean | 112 | 114 | theorem binomial_spec [DecidableEq Ξ±] (hab : a β b) :
(f a)! * (f b)! * multinomial {a, b} f = (f a + f b)! := by |
simpa [Finset.sum_pair hab, Finset.prod_pair hab] using multinomial_spec {a, b} f
| 1,580 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
#align nat.multinomial_insert_one Nat.multinomial_insert_one
theorem multinomial_congr {f g : Ξ± β β} (h : β a β s, f a = g a) :
multinomial s f = multinomial s g := by
simp only [multinomial]; congr 1
Β· rw [Finset.sum_congr rfl h]
Β· exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
#align nat.multinomial_congr Nat.multinomial_congr
theorem binomial_eq [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!) := by
simp [multinomial, Finset.sum_pair h, Finset.prod_pair h]
#align nat.binomial_eq Nat.binomial_eq
theorem binomial_eq_choose [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b).choose (f a) := by
simp [binomial_eq h, choose_eq_factorial_div_factorial (Nat.le_add_right _ _)]
#align nat.binomial_eq_choose Nat.binomial_eq_choose
theorem binomial_spec [DecidableEq Ξ±] (hab : a β b) :
(f a)! * (f b)! * multinomial {a, b} f = (f a + f b)! := by
simpa [Finset.sum_pair hab, Finset.prod_pair hab] using multinomial_spec {a, b} f
#align nat.binomial_spec Nat.binomial_spec
@[simp]
| Mathlib/Data/Nat/Choose/Multinomial.lean | 118 | 120 | theorem binomial_one [DecidableEq Ξ±] (h : a β b) (hβ : f a = 1) :
multinomial {a, b} f = (f b).succ := by |
simp [multinomial_insert_one (Finset.not_mem_singleton.mpr h) hβ]
| 1,580 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
#align nat.multinomial_insert_one Nat.multinomial_insert_one
theorem multinomial_congr {f g : Ξ± β β} (h : β a β s, f a = g a) :
multinomial s f = multinomial s g := by
simp only [multinomial]; congr 1
Β· rw [Finset.sum_congr rfl h]
Β· exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
#align nat.multinomial_congr Nat.multinomial_congr
theorem binomial_eq [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!) := by
simp [multinomial, Finset.sum_pair h, Finset.prod_pair h]
#align nat.binomial_eq Nat.binomial_eq
theorem binomial_eq_choose [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b).choose (f a) := by
simp [binomial_eq h, choose_eq_factorial_div_factorial (Nat.le_add_right _ _)]
#align nat.binomial_eq_choose Nat.binomial_eq_choose
theorem binomial_spec [DecidableEq Ξ±] (hab : a β b) :
(f a)! * (f b)! * multinomial {a, b} f = (f a + f b)! := by
simpa [Finset.sum_pair hab, Finset.prod_pair hab] using multinomial_spec {a, b} f
#align nat.binomial_spec Nat.binomial_spec
@[simp]
theorem binomial_one [DecidableEq Ξ±] (h : a β b) (hβ : f a = 1) :
multinomial {a, b} f = (f b).succ := by
simp [multinomial_insert_one (Finset.not_mem_singleton.mpr h) hβ]
#align nat.binomial_one Nat.binomial_one
| Mathlib/Data/Nat/Choose/Multinomial.lean | 123 | 131 | theorem binomial_succ_succ [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} (Function.update (Function.update f a (f a).succ) b (f b).succ) =
multinomial {a, b} (Function.update f a (f a).succ) +
multinomial {a, b} (Function.update f b (f b).succ) := by |
simp only [binomial_eq_choose, Function.update_apply,
h, Ne, ite_true, ite_false, not_false_eq_true]
rw [if_neg h.symm]
rw [add_succ, choose_succ_succ, succ_add_eq_add_succ]
ring
| 1,580 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
#align nat.multinomial_insert_one Nat.multinomial_insert_one
theorem multinomial_congr {f g : Ξ± β β} (h : β a β s, f a = g a) :
multinomial s f = multinomial s g := by
simp only [multinomial]; congr 1
Β· rw [Finset.sum_congr rfl h]
Β· exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
#align nat.multinomial_congr Nat.multinomial_congr
theorem binomial_eq [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!) := by
simp [multinomial, Finset.sum_pair h, Finset.prod_pair h]
#align nat.binomial_eq Nat.binomial_eq
theorem binomial_eq_choose [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b).choose (f a) := by
simp [binomial_eq h, choose_eq_factorial_div_factorial (Nat.le_add_right _ _)]
#align nat.binomial_eq_choose Nat.binomial_eq_choose
theorem binomial_spec [DecidableEq Ξ±] (hab : a β b) :
(f a)! * (f b)! * multinomial {a, b} f = (f a + f b)! := by
simpa [Finset.sum_pair hab, Finset.prod_pair hab] using multinomial_spec {a, b} f
#align nat.binomial_spec Nat.binomial_spec
@[simp]
theorem binomial_one [DecidableEq Ξ±] (h : a β b) (hβ : f a = 1) :
multinomial {a, b} f = (f b).succ := by
simp [multinomial_insert_one (Finset.not_mem_singleton.mpr h) hβ]
#align nat.binomial_one Nat.binomial_one
theorem binomial_succ_succ [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} (Function.update (Function.update f a (f a).succ) b (f b).succ) =
multinomial {a, b} (Function.update f a (f a).succ) +
multinomial {a, b} (Function.update f b (f b).succ) := by
simp only [binomial_eq_choose, Function.update_apply,
h, Ne, ite_true, ite_false, not_false_eq_true]
rw [if_neg h.symm]
rw [add_succ, choose_succ_succ, succ_add_eq_add_succ]
ring
#align nat.binomial_succ_succ Nat.binomial_succ_succ
| Mathlib/Data/Nat/Choose/Multinomial.lean | 134 | 139 | theorem succ_mul_binomial [DecidableEq Ξ±] (h : a β b) :
(f a + f b).succ * multinomial {a, b} f =
(f a).succ * multinomial {a, b} (Function.update f a (f a).succ) := by |
rw [binomial_eq_choose h, binomial_eq_choose h, mul_comm (f a).succ, Function.update_same,
Function.update_noteq (ne_comm.mp h)]
rw [succ_mul_choose_eq (f a + f b) (f a), succ_add (f a) (f b)]
| 1,580 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.Data.Nat.Factorial.BigOperators
import Mathlib.Data.Fin.VecNotation
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Finsupp.Multiset
#align_import data.nat.choose.multinomial from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
open Finset
open scoped Nat
namespace Nat
variable {Ξ± : Type*} (s : Finset Ξ±) (f : Ξ± β β) {a b : Ξ±} (n : β)
def multinomial : β :=
(β i β s, f i)! / β i β s, (f i)!
#align nat.multinomial Nat.multinomial
theorem multinomial_pos : 0 < multinomial s f :=
Nat.div_pos (le_of_dvd (factorial_pos _) (prod_factorial_dvd_factorial_sum s f))
(prod_factorial_pos s f)
#align nat.multinomial_pos Nat.multinomial_pos
theorem multinomial_spec : (β i β s, (f i)!) * multinomial s f = (β i β s, f i)! :=
Nat.mul_div_cancel' (prod_factorial_dvd_factorial_sum s f)
#align nat.multinomial_spec Nat.multinomial_spec
@[simp] lemma multinomial_empty : multinomial β
f = 1 := by simp [multinomial]
#align nat.multinomial_nil Nat.multinomial_empty
@[deprecated (since := "2024-06-01")] alias multinomial_nil := multinomial_empty
variable {s f}
lemma multinomial_cons (ha : a β s) (f : Ξ± β β) :
multinomial (s.cons a ha) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
multinomial, mul_assoc, mul_left_comm _ (f a)!,
Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), β mul_assoc, Nat.choose_symm_add,
Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
positivity
lemma multinomial_insert [DecidableEq Ξ±] (ha : a β s) (f : Ξ± β β) :
multinomial (insert a s) f = (f a + β i β s, f i).choose (f a) * multinomial s f := by
rw [β cons_eq_insert _ _ ha, multinomial_cons]
#align nat.multinomial_insert Nat.multinomial_insert
@[simp] lemma multinomial_singleton (a : Ξ±) (f : Ξ± β β) : multinomial {a} f = 1 := by
rw [β cons_empty, multinomial_cons]; simp
#align nat.multinomial_singleton Nat.multinomial_singleton
@[simp]
theorem multinomial_insert_one [DecidableEq Ξ±] (h : a β s) (hβ : f a = 1) :
multinomial (insert a s) f = (s.sum f).succ * multinomial s f := by
simp only [multinomial, one_mul, factorial]
rw [Finset.sum_insert h, Finset.prod_insert h, hβ, add_comm, β succ_eq_add_one, factorial_succ]
simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, β one_eq_succ_zero]
rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
#align nat.multinomial_insert_one Nat.multinomial_insert_one
theorem multinomial_congr {f g : Ξ± β β} (h : β a β s, f a = g a) :
multinomial s f = multinomial s g := by
simp only [multinomial]; congr 1
Β· rw [Finset.sum_congr rfl h]
Β· exact Finset.prod_congr rfl fun a ha => by rw [h a ha]
#align nat.multinomial_congr Nat.multinomial_congr
theorem binomial_eq [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!) := by
simp [multinomial, Finset.sum_pair h, Finset.prod_pair h]
#align nat.binomial_eq Nat.binomial_eq
theorem binomial_eq_choose [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} f = (f a + f b).choose (f a) := by
simp [binomial_eq h, choose_eq_factorial_div_factorial (Nat.le_add_right _ _)]
#align nat.binomial_eq_choose Nat.binomial_eq_choose
theorem binomial_spec [DecidableEq Ξ±] (hab : a β b) :
(f a)! * (f b)! * multinomial {a, b} f = (f a + f b)! := by
simpa [Finset.sum_pair hab, Finset.prod_pair hab] using multinomial_spec {a, b} f
#align nat.binomial_spec Nat.binomial_spec
@[simp]
theorem binomial_one [DecidableEq Ξ±] (h : a β b) (hβ : f a = 1) :
multinomial {a, b} f = (f b).succ := by
simp [multinomial_insert_one (Finset.not_mem_singleton.mpr h) hβ]
#align nat.binomial_one Nat.binomial_one
theorem binomial_succ_succ [DecidableEq Ξ±] (h : a β b) :
multinomial {a, b} (Function.update (Function.update f a (f a).succ) b (f b).succ) =
multinomial {a, b} (Function.update f a (f a).succ) +
multinomial {a, b} (Function.update f b (f b).succ) := by
simp only [binomial_eq_choose, Function.update_apply,
h, Ne, ite_true, ite_false, not_false_eq_true]
rw [if_neg h.symm]
rw [add_succ, choose_succ_succ, succ_add_eq_add_succ]
ring
#align nat.binomial_succ_succ Nat.binomial_succ_succ
theorem succ_mul_binomial [DecidableEq Ξ±] (h : a β b) :
(f a + f b).succ * multinomial {a, b} f =
(f a).succ * multinomial {a, b} (Function.update f a (f a).succ) := by
rw [binomial_eq_choose h, binomial_eq_choose h, mul_comm (f a).succ, Function.update_same,
Function.update_noteq (ne_comm.mp h)]
rw [succ_mul_choose_eq (f a + f b) (f a), succ_add (f a) (f b)]
#align nat.succ_mul_binomial Nat.succ_mul_binomial
| Mathlib/Data/Nat/Choose/Multinomial.lean | 145 | 148 | theorem multinomial_univ_two (a b : β) :
multinomial Finset.univ ![a, b] = (a + b)! / (a ! * b !) := by |
rw [multinomial, Fin.sum_univ_two, Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one,
Matrix.head_cons]
| 1,580 |
import Mathlib.Data.Finsupp.Lex
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.GameAdd
#align_import logic.hydra from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
namespace Relation
open Multiset Prod
variable {Ξ± : Type*}
def CutExpand (r : Ξ± β Ξ± β Prop) (s' s : Multiset Ξ±) : Prop :=
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ s' + {a} = s + t
#align relation.cut_expand Relation.CutExpand
variable {r : Ξ± β Ξ± β Prop}
| Mathlib/Logic/Hydra.lean | 62 | 74 | theorem cutExpand_le_invImage_lex [DecidableEq Ξ±] [IsIrrefl Ξ± r] :
CutExpand r β€ InvImage (Finsupp.Lex (rαΆ β (Β· β Β·)) (Β· < Β·)) toFinsupp := by |
rintro s t β¨u, a, hr, heβ©
replace hr := fun a' β¦ mt (hr a')
classical
refine β¨a, fun b h β¦ ?_, ?_β© <;> simp_rw [toFinsupp_apply]
Β· apply_fun count b at he
simpa only [count_add, count_singleton, if_neg h.2, add_zero, count_eq_zero.2 (hr b h.1)]
using he
Β· apply_fun count a at he
simp only [count_add, count_singleton_self, count_eq_zero.2 (hr _ (irrefl_of r a)),
add_zero] at he
exact he βΈ Nat.lt_succ_self _
| 1,581 |
import Mathlib.Data.Finsupp.Lex
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.GameAdd
#align_import logic.hydra from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
namespace Relation
open Multiset Prod
variable {Ξ± : Type*}
def CutExpand (r : Ξ± β Ξ± β Prop) (s' s : Multiset Ξ±) : Prop :=
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ s' + {a} = s + t
#align relation.cut_expand Relation.CutExpand
variable {r : Ξ± β Ξ± β Prop}
theorem cutExpand_le_invImage_lex [DecidableEq Ξ±] [IsIrrefl Ξ± r] :
CutExpand r β€ InvImage (Finsupp.Lex (rαΆ β (Β· β Β·)) (Β· < Β·)) toFinsupp := by
rintro s t β¨u, a, hr, heβ©
replace hr := fun a' β¦ mt (hr a')
classical
refine β¨a, fun b h β¦ ?_, ?_β© <;> simp_rw [toFinsupp_apply]
Β· apply_fun count b at he
simpa only [count_add, count_singleton, if_neg h.2, add_zero, count_eq_zero.2 (hr b h.1)]
using he
Β· apply_fun count a at he
simp only [count_add, count_singleton_self, count_eq_zero.2 (hr _ (irrefl_of r a)),
add_zero] at he
exact he βΈ Nat.lt_succ_self _
#align relation.cut_expand_le_inv_image_lex Relation.cutExpand_le_invImage_lex
theorem cutExpand_singleton {s x} (h : β x' β s, r x' x) : CutExpand r s {x} :=
β¨s, x, h, add_comm s _β©
#align relation.cut_expand_singleton Relation.cutExpand_singleton
theorem cutExpand_singleton_singleton {x' x} (h : r x' x) : CutExpand r {x'} {x} :=
cutExpand_singleton fun a h β¦ by rwa [mem_singleton.1 h]
#align relation.cut_expand_singleton_singleton Relation.cutExpand_singleton_singleton
theorem cutExpand_add_left {t u} (s) : CutExpand r (s + t) (s + u) β CutExpand r t u :=
existsβ_congr fun _ _ β¦ and_congr Iff.rfl <| by rw [add_assoc, add_assoc, add_left_cancel_iff]
#align relation.cut_expand_add_left Relation.cutExpand_add_left
| Mathlib/Logic/Hydra.lean | 89 | 98 | theorem cutExpand_iff [DecidableEq Ξ±] [IsIrrefl Ξ± r] {s' s : Multiset Ξ±} :
CutExpand r s' s β
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ a β s β§ s' = s.erase a + t := by |
simp_rw [CutExpand, add_singleton_eq_iff]
refine existsβ_congr fun t a β¦ β¨?_, ?_β©
Β· rintro β¨ht, ha, rflβ©
obtain h | h := mem_add.1 ha
exacts [β¨ht, h, erase_add_left_pos t hβ©, (@irrefl Ξ± r _ a (ht a h)).elim]
Β· rintro β¨ht, h, rflβ©
exact β¨ht, mem_add.2 (Or.inl h), (erase_add_left_pos t h).symmβ©
| 1,581 |
import Mathlib.Data.Finsupp.Lex
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.GameAdd
#align_import logic.hydra from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
namespace Relation
open Multiset Prod
variable {Ξ± : Type*}
def CutExpand (r : Ξ± β Ξ± β Prop) (s' s : Multiset Ξ±) : Prop :=
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ s' + {a} = s + t
#align relation.cut_expand Relation.CutExpand
variable {r : Ξ± β Ξ± β Prop}
theorem cutExpand_le_invImage_lex [DecidableEq Ξ±] [IsIrrefl Ξ± r] :
CutExpand r β€ InvImage (Finsupp.Lex (rαΆ β (Β· β Β·)) (Β· < Β·)) toFinsupp := by
rintro s t β¨u, a, hr, heβ©
replace hr := fun a' β¦ mt (hr a')
classical
refine β¨a, fun b h β¦ ?_, ?_β© <;> simp_rw [toFinsupp_apply]
Β· apply_fun count b at he
simpa only [count_add, count_singleton, if_neg h.2, add_zero, count_eq_zero.2 (hr b h.1)]
using he
Β· apply_fun count a at he
simp only [count_add, count_singleton_self, count_eq_zero.2 (hr _ (irrefl_of r a)),
add_zero] at he
exact he βΈ Nat.lt_succ_self _
#align relation.cut_expand_le_inv_image_lex Relation.cutExpand_le_invImage_lex
theorem cutExpand_singleton {s x} (h : β x' β s, r x' x) : CutExpand r s {x} :=
β¨s, x, h, add_comm s _β©
#align relation.cut_expand_singleton Relation.cutExpand_singleton
theorem cutExpand_singleton_singleton {x' x} (h : r x' x) : CutExpand r {x'} {x} :=
cutExpand_singleton fun a h β¦ by rwa [mem_singleton.1 h]
#align relation.cut_expand_singleton_singleton Relation.cutExpand_singleton_singleton
theorem cutExpand_add_left {t u} (s) : CutExpand r (s + t) (s + u) β CutExpand r t u :=
existsβ_congr fun _ _ β¦ and_congr Iff.rfl <| by rw [add_assoc, add_assoc, add_left_cancel_iff]
#align relation.cut_expand_add_left Relation.cutExpand_add_left
theorem cutExpand_iff [DecidableEq Ξ±] [IsIrrefl Ξ± r] {s' s : Multiset Ξ±} :
CutExpand r s' s β
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ a β s β§ s' = s.erase a + t := by
simp_rw [CutExpand, add_singleton_eq_iff]
refine existsβ_congr fun t a β¦ β¨?_, ?_β©
Β· rintro β¨ht, ha, rflβ©
obtain h | h := mem_add.1 ha
exacts [β¨ht, h, erase_add_left_pos t hβ©, (@irrefl Ξ± r _ a (ht a h)).elim]
Β· rintro β¨ht, h, rflβ©
exact β¨ht, mem_add.2 (Or.inl h), (erase_add_left_pos t h).symmβ©
#align relation.cut_expand_iff Relation.cutExpand_iff
| Mathlib/Logic/Hydra.lean | 101 | 104 | theorem not_cutExpand_zero [IsIrrefl Ξ± r] (s) : Β¬CutExpand r s 0 := by |
classical
rw [cutExpand_iff]
rintro β¨_, _, _, β¨β©, _β©
| 1,581 |
import Mathlib.Data.Finsupp.Lex
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.GameAdd
#align_import logic.hydra from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
namespace Relation
open Multiset Prod
variable {Ξ± : Type*}
def CutExpand (r : Ξ± β Ξ± β Prop) (s' s : Multiset Ξ±) : Prop :=
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ s' + {a} = s + t
#align relation.cut_expand Relation.CutExpand
variable {r : Ξ± β Ξ± β Prop}
theorem cutExpand_le_invImage_lex [DecidableEq Ξ±] [IsIrrefl Ξ± r] :
CutExpand r β€ InvImage (Finsupp.Lex (rαΆ β (Β· β Β·)) (Β· < Β·)) toFinsupp := by
rintro s t β¨u, a, hr, heβ©
replace hr := fun a' β¦ mt (hr a')
classical
refine β¨a, fun b h β¦ ?_, ?_β© <;> simp_rw [toFinsupp_apply]
Β· apply_fun count b at he
simpa only [count_add, count_singleton, if_neg h.2, add_zero, count_eq_zero.2 (hr b h.1)]
using he
Β· apply_fun count a at he
simp only [count_add, count_singleton_self, count_eq_zero.2 (hr _ (irrefl_of r a)),
add_zero] at he
exact he βΈ Nat.lt_succ_self _
#align relation.cut_expand_le_inv_image_lex Relation.cutExpand_le_invImage_lex
theorem cutExpand_singleton {s x} (h : β x' β s, r x' x) : CutExpand r s {x} :=
β¨s, x, h, add_comm s _β©
#align relation.cut_expand_singleton Relation.cutExpand_singleton
theorem cutExpand_singleton_singleton {x' x} (h : r x' x) : CutExpand r {x'} {x} :=
cutExpand_singleton fun a h β¦ by rwa [mem_singleton.1 h]
#align relation.cut_expand_singleton_singleton Relation.cutExpand_singleton_singleton
theorem cutExpand_add_left {t u} (s) : CutExpand r (s + t) (s + u) β CutExpand r t u :=
existsβ_congr fun _ _ β¦ and_congr Iff.rfl <| by rw [add_assoc, add_assoc, add_left_cancel_iff]
#align relation.cut_expand_add_left Relation.cutExpand_add_left
theorem cutExpand_iff [DecidableEq Ξ±] [IsIrrefl Ξ± r] {s' s : Multiset Ξ±} :
CutExpand r s' s β
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ a β s β§ s' = s.erase a + t := by
simp_rw [CutExpand, add_singleton_eq_iff]
refine existsβ_congr fun t a β¦ β¨?_, ?_β©
Β· rintro β¨ht, ha, rflβ©
obtain h | h := mem_add.1 ha
exacts [β¨ht, h, erase_add_left_pos t hβ©, (@irrefl Ξ± r _ a (ht a h)).elim]
Β· rintro β¨ht, h, rflβ©
exact β¨ht, mem_add.2 (Or.inl h), (erase_add_left_pos t h).symmβ©
#align relation.cut_expand_iff Relation.cutExpand_iff
theorem not_cutExpand_zero [IsIrrefl Ξ± r] (s) : Β¬CutExpand r s 0 := by
classical
rw [cutExpand_iff]
rintro β¨_, _, _, β¨β©, _β©
#align relation.not_cut_expand_zero Relation.not_cutExpand_zero
| Mathlib/Logic/Hydra.lean | 109 | 121 | theorem cutExpand_fibration (r : Ξ± β Ξ± β Prop) :
Fibration (GameAdd (CutExpand r) (CutExpand r)) (CutExpand r) fun s β¦ s.1 + s.2 := by |
rintro β¨sβ, sββ© s β¨t, a, hr, heβ©; dsimp at he β’
classical
obtain β¨ha, rflβ© := add_singleton_eq_iff.1 he
rw [add_assoc, mem_add] at ha
obtain h | h := ha
Β· refine β¨(sβ.erase a + t, sβ), GameAdd.fst β¨t, a, hr, ?_β©, ?_β©
Β· rw [add_comm, β add_assoc, singleton_add, cons_erase h]
Β· rw [add_assoc sβ, erase_add_left_pos _ h, add_right_comm, add_assoc]
Β· refine β¨(sβ, (sβ + t).erase a), GameAdd.snd β¨t, a, hr, ?_β©, ?_β©
Β· rw [add_comm, singleton_add, cons_erase h]
Β· rw [add_assoc, erase_add_right_pos _ h]
| 1,581 |
import Mathlib.Data.Finsupp.Lex
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.GameAdd
#align_import logic.hydra from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
namespace Relation
open Multiset Prod
variable {Ξ± : Type*}
def CutExpand (r : Ξ± β Ξ± β Prop) (s' s : Multiset Ξ±) : Prop :=
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ s' + {a} = s + t
#align relation.cut_expand Relation.CutExpand
variable {r : Ξ± β Ξ± β Prop}
theorem cutExpand_le_invImage_lex [DecidableEq Ξ±] [IsIrrefl Ξ± r] :
CutExpand r β€ InvImage (Finsupp.Lex (rαΆ β (Β· β Β·)) (Β· < Β·)) toFinsupp := by
rintro s t β¨u, a, hr, heβ©
replace hr := fun a' β¦ mt (hr a')
classical
refine β¨a, fun b h β¦ ?_, ?_β© <;> simp_rw [toFinsupp_apply]
Β· apply_fun count b at he
simpa only [count_add, count_singleton, if_neg h.2, add_zero, count_eq_zero.2 (hr b h.1)]
using he
Β· apply_fun count a at he
simp only [count_add, count_singleton_self, count_eq_zero.2 (hr _ (irrefl_of r a)),
add_zero] at he
exact he βΈ Nat.lt_succ_self _
#align relation.cut_expand_le_inv_image_lex Relation.cutExpand_le_invImage_lex
theorem cutExpand_singleton {s x} (h : β x' β s, r x' x) : CutExpand r s {x} :=
β¨s, x, h, add_comm s _β©
#align relation.cut_expand_singleton Relation.cutExpand_singleton
theorem cutExpand_singleton_singleton {x' x} (h : r x' x) : CutExpand r {x'} {x} :=
cutExpand_singleton fun a h β¦ by rwa [mem_singleton.1 h]
#align relation.cut_expand_singleton_singleton Relation.cutExpand_singleton_singleton
theorem cutExpand_add_left {t u} (s) : CutExpand r (s + t) (s + u) β CutExpand r t u :=
existsβ_congr fun _ _ β¦ and_congr Iff.rfl <| by rw [add_assoc, add_assoc, add_left_cancel_iff]
#align relation.cut_expand_add_left Relation.cutExpand_add_left
theorem cutExpand_iff [DecidableEq Ξ±] [IsIrrefl Ξ± r] {s' s : Multiset Ξ±} :
CutExpand r s' s β
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ a β s β§ s' = s.erase a + t := by
simp_rw [CutExpand, add_singleton_eq_iff]
refine existsβ_congr fun t a β¦ β¨?_, ?_β©
Β· rintro β¨ht, ha, rflβ©
obtain h | h := mem_add.1 ha
exacts [β¨ht, h, erase_add_left_pos t hβ©, (@irrefl Ξ± r _ a (ht a h)).elim]
Β· rintro β¨ht, h, rflβ©
exact β¨ht, mem_add.2 (Or.inl h), (erase_add_left_pos t h).symmβ©
#align relation.cut_expand_iff Relation.cutExpand_iff
theorem not_cutExpand_zero [IsIrrefl Ξ± r] (s) : Β¬CutExpand r s 0 := by
classical
rw [cutExpand_iff]
rintro β¨_, _, _, β¨β©, _β©
#align relation.not_cut_expand_zero Relation.not_cutExpand_zero
theorem cutExpand_fibration (r : Ξ± β Ξ± β Prop) :
Fibration (GameAdd (CutExpand r) (CutExpand r)) (CutExpand r) fun s β¦ s.1 + s.2 := by
rintro β¨sβ, sββ© s β¨t, a, hr, heβ©; dsimp at he β’
classical
obtain β¨ha, rflβ© := add_singleton_eq_iff.1 he
rw [add_assoc, mem_add] at ha
obtain h | h := ha
Β· refine β¨(sβ.erase a + t, sβ), GameAdd.fst β¨t, a, hr, ?_β©, ?_β©
Β· rw [add_comm, β add_assoc, singleton_add, cons_erase h]
Β· rw [add_assoc sβ, erase_add_left_pos _ h, add_right_comm, add_assoc]
Β· refine β¨(sβ, (sβ + t).erase a), GameAdd.snd β¨t, a, hr, ?_β©, ?_β©
Β· rw [add_comm, singleton_add, cons_erase h]
Β· rw [add_assoc, erase_add_right_pos _ h]
#align relation.cut_expand_fibration Relation.cutExpand_fibration
| Mathlib/Logic/Hydra.lean | 126 | 133 | theorem acc_of_singleton [IsIrrefl Ξ± r] {s : Multiset Ξ±} (hs : β a β s, Acc (CutExpand r) {a}) :
Acc (CutExpand r) s := by |
induction s using Multiset.induction with
| empty => exact Acc.intro 0 fun s h β¦ (not_cutExpand_zero s h).elim
| cons a s ihs =>
rw [β s.singleton_add a]
rw [forall_mem_cons] at hs
exact (hs.1.prod_gameAdd <| ihs fun a ha β¦ hs.2 a ha).of_fibration _ (cutExpand_fibration r)
| 1,581 |
import Mathlib.Data.Finsupp.Lex
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.GameAdd
#align_import logic.hydra from "leanprover-community/mathlib"@"48085f140e684306f9e7da907cd5932056d1aded"
namespace Relation
open Multiset Prod
variable {Ξ± : Type*}
def CutExpand (r : Ξ± β Ξ± β Prop) (s' s : Multiset Ξ±) : Prop :=
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ s' + {a} = s + t
#align relation.cut_expand Relation.CutExpand
variable {r : Ξ± β Ξ± β Prop}
theorem cutExpand_le_invImage_lex [DecidableEq Ξ±] [IsIrrefl Ξ± r] :
CutExpand r β€ InvImage (Finsupp.Lex (rαΆ β (Β· β Β·)) (Β· < Β·)) toFinsupp := by
rintro s t β¨u, a, hr, heβ©
replace hr := fun a' β¦ mt (hr a')
classical
refine β¨a, fun b h β¦ ?_, ?_β© <;> simp_rw [toFinsupp_apply]
Β· apply_fun count b at he
simpa only [count_add, count_singleton, if_neg h.2, add_zero, count_eq_zero.2 (hr b h.1)]
using he
Β· apply_fun count a at he
simp only [count_add, count_singleton_self, count_eq_zero.2 (hr _ (irrefl_of r a)),
add_zero] at he
exact he βΈ Nat.lt_succ_self _
#align relation.cut_expand_le_inv_image_lex Relation.cutExpand_le_invImage_lex
theorem cutExpand_singleton {s x} (h : β x' β s, r x' x) : CutExpand r s {x} :=
β¨s, x, h, add_comm s _β©
#align relation.cut_expand_singleton Relation.cutExpand_singleton
theorem cutExpand_singleton_singleton {x' x} (h : r x' x) : CutExpand r {x'} {x} :=
cutExpand_singleton fun a h β¦ by rwa [mem_singleton.1 h]
#align relation.cut_expand_singleton_singleton Relation.cutExpand_singleton_singleton
theorem cutExpand_add_left {t u} (s) : CutExpand r (s + t) (s + u) β CutExpand r t u :=
existsβ_congr fun _ _ β¦ and_congr Iff.rfl <| by rw [add_assoc, add_assoc, add_left_cancel_iff]
#align relation.cut_expand_add_left Relation.cutExpand_add_left
theorem cutExpand_iff [DecidableEq Ξ±] [IsIrrefl Ξ± r] {s' s : Multiset Ξ±} :
CutExpand r s' s β
β (t : Multiset Ξ±) (a : Ξ±), (β a' β t, r a' a) β§ a β s β§ s' = s.erase a + t := by
simp_rw [CutExpand, add_singleton_eq_iff]
refine existsβ_congr fun t a β¦ β¨?_, ?_β©
Β· rintro β¨ht, ha, rflβ©
obtain h | h := mem_add.1 ha
exacts [β¨ht, h, erase_add_left_pos t hβ©, (@irrefl Ξ± r _ a (ht a h)).elim]
Β· rintro β¨ht, h, rflβ©
exact β¨ht, mem_add.2 (Or.inl h), (erase_add_left_pos t h).symmβ©
#align relation.cut_expand_iff Relation.cutExpand_iff
theorem not_cutExpand_zero [IsIrrefl Ξ± r] (s) : Β¬CutExpand r s 0 := by
classical
rw [cutExpand_iff]
rintro β¨_, _, _, β¨β©, _β©
#align relation.not_cut_expand_zero Relation.not_cutExpand_zero
theorem cutExpand_fibration (r : Ξ± β Ξ± β Prop) :
Fibration (GameAdd (CutExpand r) (CutExpand r)) (CutExpand r) fun s β¦ s.1 + s.2 := by
rintro β¨sβ, sββ© s β¨t, a, hr, heβ©; dsimp at he β’
classical
obtain β¨ha, rflβ© := add_singleton_eq_iff.1 he
rw [add_assoc, mem_add] at ha
obtain h | h := ha
Β· refine β¨(sβ.erase a + t, sβ), GameAdd.fst β¨t, a, hr, ?_β©, ?_β©
Β· rw [add_comm, β add_assoc, singleton_add, cons_erase h]
Β· rw [add_assoc sβ, erase_add_left_pos _ h, add_right_comm, add_assoc]
Β· refine β¨(sβ, (sβ + t).erase a), GameAdd.snd β¨t, a, hr, ?_β©, ?_β©
Β· rw [add_comm, singleton_add, cons_erase h]
Β· rw [add_assoc, erase_add_right_pos _ h]
#align relation.cut_expand_fibration Relation.cutExpand_fibration
theorem acc_of_singleton [IsIrrefl Ξ± r] {s : Multiset Ξ±} (hs : β a β s, Acc (CutExpand r) {a}) :
Acc (CutExpand r) s := by
induction s using Multiset.induction with
| empty => exact Acc.intro 0 fun s h β¦ (not_cutExpand_zero s h).elim
| cons a s ihs =>
rw [β s.singleton_add a]
rw [forall_mem_cons] at hs
exact (hs.1.prod_gameAdd <| ihs fun a ha β¦ hs.2 a ha).of_fibration _ (cutExpand_fibration r)
#align relation.acc_of_singleton Relation.acc_of_singleton
| Mathlib/Logic/Hydra.lean | 138 | 146 | theorem _root_.Acc.cutExpand [IsIrrefl Ξ± r] {a : Ξ±} (hacc : Acc r a) : Acc (CutExpand r) {a} := by |
induction' hacc with a h ih
refine Acc.intro _ fun s β¦ ?_
classical
simp only [cutExpand_iff, mem_singleton]
rintro β¨t, a, hr, rfl, rflβ©
refine acc_of_singleton fun a' β¦ ?_
rw [erase_singleton, zero_add]
exact ih a' β hr a'
| 1,581 |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Set Cardinal Equiv Order Ordinal
open scoped Classical
universe u v w
namespace Cardinal
section UsingOrdinals
| Mathlib/SetTheory/Cardinal/Ordinal.lean | 61 | 70 | theorem ord_isLimit {c} (co : β΅β β€ c) : (ord c).IsLimit := by |
refine β¨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_β©
Β· rw [β Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
Β· rw [ord_le] at h β’
rwa [β @add_one_of_aleph0_le (card a), β card_succ]
rw [β ord_le, β le_succ_of_isLimit, ord_le]
Β· exact co.trans h
Β· rw [ord_aleph0]
exact omega_isLimit
| 1,582 |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Set Cardinal Equiv Order Ordinal
open scoped Classical
universe u v w
namespace Cardinal
section UsingOrdinals
theorem ord_isLimit {c} (co : β΅β β€ c) : (ord c).IsLimit := by
refine β¨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_β©
Β· rw [β Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
Β· rw [ord_le] at h β’
rwa [β @add_one_of_aleph0_le (card a), β card_succ]
rw [β ord_le, β le_succ_of_isLimit, ord_le]
Β· exact co.trans h
Β· rw [ord_aleph0]
exact omega_isLimit
#align cardinal.ord_is_limit Cardinal.ord_isLimit
theorem noMaxOrder {c} (h : β΅β β€ c) : NoMaxOrder c.ord.out.Ξ± :=
Ordinal.out_no_max_of_succ_lt (ord_isLimit h).2
section aleph
def alephIdx.initialSeg : @InitialSeg Cardinal Ordinal (Β· < Β·) (Β· < Β·) :=
@RelEmbedding.collapse Cardinal Ordinal (Β· < Β·) (Β· < Β·) _ Cardinal.ord.orderEmbedding.ltEmbedding
#align cardinal.aleph_idx.initial_seg Cardinal.alephIdx.initialSeg
def alephIdx : Cardinal β Ordinal :=
alephIdx.initialSeg
#align cardinal.aleph_idx Cardinal.alephIdx
@[simp]
theorem alephIdx.initialSeg_coe : (alephIdx.initialSeg : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.initial_seg_coe Cardinal.alephIdx.initialSeg_coe
@[simp]
theorem alephIdx_lt {a b} : alephIdx a < alephIdx b β a < b :=
alephIdx.initialSeg.toRelEmbedding.map_rel_iff
#align cardinal.aleph_idx_lt Cardinal.alephIdx_lt
@[simp]
| Mathlib/SetTheory/Cardinal/Ordinal.lean | 111 | 112 | theorem alephIdx_le {a b} : alephIdx a β€ alephIdx b β a β€ b := by |
rw [β not_lt, β not_lt, alephIdx_lt]
| 1,582 |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Set Cardinal Equiv Order Ordinal
open scoped Classical
universe u v w
namespace Cardinal
section UsingOrdinals
theorem ord_isLimit {c} (co : β΅β β€ c) : (ord c).IsLimit := by
refine β¨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_β©
Β· rw [β Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
Β· rw [ord_le] at h β’
rwa [β @add_one_of_aleph0_le (card a), β card_succ]
rw [β ord_le, β le_succ_of_isLimit, ord_le]
Β· exact co.trans h
Β· rw [ord_aleph0]
exact omega_isLimit
#align cardinal.ord_is_limit Cardinal.ord_isLimit
theorem noMaxOrder {c} (h : β΅β β€ c) : NoMaxOrder c.ord.out.Ξ± :=
Ordinal.out_no_max_of_succ_lt (ord_isLimit h).2
section aleph
def alephIdx.initialSeg : @InitialSeg Cardinal Ordinal (Β· < Β·) (Β· < Β·) :=
@RelEmbedding.collapse Cardinal Ordinal (Β· < Β·) (Β· < Β·) _ Cardinal.ord.orderEmbedding.ltEmbedding
#align cardinal.aleph_idx.initial_seg Cardinal.alephIdx.initialSeg
def alephIdx : Cardinal β Ordinal :=
alephIdx.initialSeg
#align cardinal.aleph_idx Cardinal.alephIdx
@[simp]
theorem alephIdx.initialSeg_coe : (alephIdx.initialSeg : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.initial_seg_coe Cardinal.alephIdx.initialSeg_coe
@[simp]
theorem alephIdx_lt {a b} : alephIdx a < alephIdx b β a < b :=
alephIdx.initialSeg.toRelEmbedding.map_rel_iff
#align cardinal.aleph_idx_lt Cardinal.alephIdx_lt
@[simp]
theorem alephIdx_le {a b} : alephIdx a β€ alephIdx b β a β€ b := by
rw [β not_lt, β not_lt, alephIdx_lt]
#align cardinal.aleph_idx_le Cardinal.alephIdx_le
theorem alephIdx.init {a b} : b < alephIdx a β β c, alephIdx c = b :=
alephIdx.initialSeg.init
#align cardinal.aleph_idx.init Cardinal.alephIdx.init
def alephIdx.relIso : @RelIso Cardinal.{u} Ordinal.{u} (Β· < Β·) (Β· < Β·) :=
@RelIso.ofSurjective Cardinal.{u} Ordinal.{u} (Β· < Β·) (Β· < Β·) alephIdx.initialSeg.{u} <|
(InitialSeg.eq_or_principal alephIdx.initialSeg.{u}).resolve_right fun β¨o, eβ© => by
have : β c, alephIdx c < o := fun c => (e _).2 β¨_, rflβ©
refine Ordinal.inductionOn o ?_ this; intro Ξ± r _ h
let s := β¨ a, invFun alephIdx (Ordinal.typein r a)
apply (lt_succ s).not_le
have I : Injective.{u+2, u+2} alephIdx := alephIdx.initialSeg.toEmbedding.injective
simpa only [typein_enum, leftInverse_invFun I (succ s)] using
le_ciSup
(Cardinal.bddAbove_range.{u, u} fun a : Ξ± => invFun alephIdx (Ordinal.typein r a))
(Ordinal.enum r _ (h (succ s)))
#align cardinal.aleph_idx.rel_iso Cardinal.alephIdx.relIso
@[simp]
theorem alephIdx.relIso_coe : (alephIdx.relIso : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.rel_iso_coe Cardinal.alephIdx.relIso_coe
@[simp]
| Mathlib/SetTheory/Cardinal/Ordinal.lean | 146 | 147 | theorem type_cardinal : @type Cardinal (Β· < Β·) _ = Ordinal.univ.{u, u + 1} := by |
rw [Ordinal.univ_id]; exact Quotient.sound β¨alephIdx.relIsoβ©
| 1,582 |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Set Cardinal Equiv Order Ordinal
open scoped Classical
universe u v w
namespace Cardinal
section UsingOrdinals
theorem ord_isLimit {c} (co : β΅β β€ c) : (ord c).IsLimit := by
refine β¨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_β©
Β· rw [β Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
Β· rw [ord_le] at h β’
rwa [β @add_one_of_aleph0_le (card a), β card_succ]
rw [β ord_le, β le_succ_of_isLimit, ord_le]
Β· exact co.trans h
Β· rw [ord_aleph0]
exact omega_isLimit
#align cardinal.ord_is_limit Cardinal.ord_isLimit
theorem noMaxOrder {c} (h : β΅β β€ c) : NoMaxOrder c.ord.out.Ξ± :=
Ordinal.out_no_max_of_succ_lt (ord_isLimit h).2
section aleph
def alephIdx.initialSeg : @InitialSeg Cardinal Ordinal (Β· < Β·) (Β· < Β·) :=
@RelEmbedding.collapse Cardinal Ordinal (Β· < Β·) (Β· < Β·) _ Cardinal.ord.orderEmbedding.ltEmbedding
#align cardinal.aleph_idx.initial_seg Cardinal.alephIdx.initialSeg
def alephIdx : Cardinal β Ordinal :=
alephIdx.initialSeg
#align cardinal.aleph_idx Cardinal.alephIdx
@[simp]
theorem alephIdx.initialSeg_coe : (alephIdx.initialSeg : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.initial_seg_coe Cardinal.alephIdx.initialSeg_coe
@[simp]
theorem alephIdx_lt {a b} : alephIdx a < alephIdx b β a < b :=
alephIdx.initialSeg.toRelEmbedding.map_rel_iff
#align cardinal.aleph_idx_lt Cardinal.alephIdx_lt
@[simp]
theorem alephIdx_le {a b} : alephIdx a β€ alephIdx b β a β€ b := by
rw [β not_lt, β not_lt, alephIdx_lt]
#align cardinal.aleph_idx_le Cardinal.alephIdx_le
theorem alephIdx.init {a b} : b < alephIdx a β β c, alephIdx c = b :=
alephIdx.initialSeg.init
#align cardinal.aleph_idx.init Cardinal.alephIdx.init
def alephIdx.relIso : @RelIso Cardinal.{u} Ordinal.{u} (Β· < Β·) (Β· < Β·) :=
@RelIso.ofSurjective Cardinal.{u} Ordinal.{u} (Β· < Β·) (Β· < Β·) alephIdx.initialSeg.{u} <|
(InitialSeg.eq_or_principal alephIdx.initialSeg.{u}).resolve_right fun β¨o, eβ© => by
have : β c, alephIdx c < o := fun c => (e _).2 β¨_, rflβ©
refine Ordinal.inductionOn o ?_ this; intro Ξ± r _ h
let s := β¨ a, invFun alephIdx (Ordinal.typein r a)
apply (lt_succ s).not_le
have I : Injective.{u+2, u+2} alephIdx := alephIdx.initialSeg.toEmbedding.injective
simpa only [typein_enum, leftInverse_invFun I (succ s)] using
le_ciSup
(Cardinal.bddAbove_range.{u, u} fun a : Ξ± => invFun alephIdx (Ordinal.typein r a))
(Ordinal.enum r _ (h (succ s)))
#align cardinal.aleph_idx.rel_iso Cardinal.alephIdx.relIso
@[simp]
theorem alephIdx.relIso_coe : (alephIdx.relIso : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.rel_iso_coe Cardinal.alephIdx.relIso_coe
@[simp]
theorem type_cardinal : @type Cardinal (Β· < Β·) _ = Ordinal.univ.{u, u + 1} := by
rw [Ordinal.univ_id]; exact Quotient.sound β¨alephIdx.relIsoβ©
#align cardinal.type_cardinal Cardinal.type_cardinal
@[simp]
| Mathlib/SetTheory/Cardinal/Ordinal.lean | 151 | 152 | theorem mk_cardinal : #Cardinal = univ.{u, u + 1} := by |
simpa only [card_type, card_univ] using congr_arg card type_cardinal
| 1,582 |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Set Cardinal Equiv Order Ordinal
open scoped Classical
universe u v w
namespace Cardinal
section UsingOrdinals
theorem ord_isLimit {c} (co : β΅β β€ c) : (ord c).IsLimit := by
refine β¨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_β©
Β· rw [β Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
Β· rw [ord_le] at h β’
rwa [β @add_one_of_aleph0_le (card a), β card_succ]
rw [β ord_le, β le_succ_of_isLimit, ord_le]
Β· exact co.trans h
Β· rw [ord_aleph0]
exact omega_isLimit
#align cardinal.ord_is_limit Cardinal.ord_isLimit
theorem noMaxOrder {c} (h : β΅β β€ c) : NoMaxOrder c.ord.out.Ξ± :=
Ordinal.out_no_max_of_succ_lt (ord_isLimit h).2
section aleph
def alephIdx.initialSeg : @InitialSeg Cardinal Ordinal (Β· < Β·) (Β· < Β·) :=
@RelEmbedding.collapse Cardinal Ordinal (Β· < Β·) (Β· < Β·) _ Cardinal.ord.orderEmbedding.ltEmbedding
#align cardinal.aleph_idx.initial_seg Cardinal.alephIdx.initialSeg
def alephIdx : Cardinal β Ordinal :=
alephIdx.initialSeg
#align cardinal.aleph_idx Cardinal.alephIdx
@[simp]
theorem alephIdx.initialSeg_coe : (alephIdx.initialSeg : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.initial_seg_coe Cardinal.alephIdx.initialSeg_coe
@[simp]
theorem alephIdx_lt {a b} : alephIdx a < alephIdx b β a < b :=
alephIdx.initialSeg.toRelEmbedding.map_rel_iff
#align cardinal.aleph_idx_lt Cardinal.alephIdx_lt
@[simp]
theorem alephIdx_le {a b} : alephIdx a β€ alephIdx b β a β€ b := by
rw [β not_lt, β not_lt, alephIdx_lt]
#align cardinal.aleph_idx_le Cardinal.alephIdx_le
theorem alephIdx.init {a b} : b < alephIdx a β β c, alephIdx c = b :=
alephIdx.initialSeg.init
#align cardinal.aleph_idx.init Cardinal.alephIdx.init
def alephIdx.relIso : @RelIso Cardinal.{u} Ordinal.{u} (Β· < Β·) (Β· < Β·) :=
@RelIso.ofSurjective Cardinal.{u} Ordinal.{u} (Β· < Β·) (Β· < Β·) alephIdx.initialSeg.{u} <|
(InitialSeg.eq_or_principal alephIdx.initialSeg.{u}).resolve_right fun β¨o, eβ© => by
have : β c, alephIdx c < o := fun c => (e _).2 β¨_, rflβ©
refine Ordinal.inductionOn o ?_ this; intro Ξ± r _ h
let s := β¨ a, invFun alephIdx (Ordinal.typein r a)
apply (lt_succ s).not_le
have I : Injective.{u+2, u+2} alephIdx := alephIdx.initialSeg.toEmbedding.injective
simpa only [typein_enum, leftInverse_invFun I (succ s)] using
le_ciSup
(Cardinal.bddAbove_range.{u, u} fun a : Ξ± => invFun alephIdx (Ordinal.typein r a))
(Ordinal.enum r _ (h (succ s)))
#align cardinal.aleph_idx.rel_iso Cardinal.alephIdx.relIso
@[simp]
theorem alephIdx.relIso_coe : (alephIdx.relIso : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.rel_iso_coe Cardinal.alephIdx.relIso_coe
@[simp]
theorem type_cardinal : @type Cardinal (Β· < Β·) _ = Ordinal.univ.{u, u + 1} := by
rw [Ordinal.univ_id]; exact Quotient.sound β¨alephIdx.relIsoβ©
#align cardinal.type_cardinal Cardinal.type_cardinal
@[simp]
theorem mk_cardinal : #Cardinal = univ.{u, u + 1} := by
simpa only [card_type, card_univ] using congr_arg card type_cardinal
#align cardinal.mk_cardinal Cardinal.mk_cardinal
def Aleph'.relIso :=
Cardinal.alephIdx.relIso.symm
#align cardinal.aleph'.rel_iso Cardinal.Aleph'.relIso
def aleph' : Ordinal β Cardinal :=
Aleph'.relIso
#align cardinal.aleph' Cardinal.aleph'
@[simp]
theorem aleph'.relIso_coe : (Aleph'.relIso : Ordinal β Cardinal) = aleph' :=
rfl
#align cardinal.aleph'.rel_iso_coe Cardinal.aleph'.relIso_coe
@[simp]
theorem aleph'_lt {oβ oβ : Ordinal} : aleph' oβ < aleph' oβ β oβ < oβ :=
Aleph'.relIso.map_rel_iff
#align cardinal.aleph'_lt Cardinal.aleph'_lt
@[simp]
theorem aleph'_le {oβ oβ : Ordinal} : aleph' oβ β€ aleph' oβ β oβ β€ oβ :=
le_iff_le_iff_lt_iff_lt.2 aleph'_lt
#align cardinal.aleph'_le Cardinal.aleph'_le
@[simp]
theorem aleph'_alephIdx (c : Cardinal) : aleph' c.alephIdx = c :=
Cardinal.alephIdx.relIso.toEquiv.symm_apply_apply c
#align cardinal.aleph'_aleph_idx Cardinal.aleph'_alephIdx
@[simp]
theorem alephIdx_aleph' (o : Ordinal) : (aleph' o).alephIdx = o :=
Cardinal.alephIdx.relIso.toEquiv.apply_symm_apply o
#align cardinal.aleph_idx_aleph' Cardinal.alephIdx_aleph'
@[simp]
| Mathlib/SetTheory/Cardinal/Ordinal.lean | 198 | 200 | theorem aleph'_zero : aleph' 0 = 0 := by |
rw [β nonpos_iff_eq_zero, β aleph'_alephIdx 0, aleph'_le]
apply Ordinal.zero_le
| 1,582 |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Set Cardinal Equiv Order Ordinal
open scoped Classical
universe u v w
namespace Cardinal
section UsingOrdinals
theorem ord_isLimit {c} (co : β΅β β€ c) : (ord c).IsLimit := by
refine β¨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_β©
Β· rw [β Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
Β· rw [ord_le] at h β’
rwa [β @add_one_of_aleph0_le (card a), β card_succ]
rw [β ord_le, β le_succ_of_isLimit, ord_le]
Β· exact co.trans h
Β· rw [ord_aleph0]
exact omega_isLimit
#align cardinal.ord_is_limit Cardinal.ord_isLimit
theorem noMaxOrder {c} (h : β΅β β€ c) : NoMaxOrder c.ord.out.Ξ± :=
Ordinal.out_no_max_of_succ_lt (ord_isLimit h).2
section aleph
def alephIdx.initialSeg : @InitialSeg Cardinal Ordinal (Β· < Β·) (Β· < Β·) :=
@RelEmbedding.collapse Cardinal Ordinal (Β· < Β·) (Β· < Β·) _ Cardinal.ord.orderEmbedding.ltEmbedding
#align cardinal.aleph_idx.initial_seg Cardinal.alephIdx.initialSeg
def alephIdx : Cardinal β Ordinal :=
alephIdx.initialSeg
#align cardinal.aleph_idx Cardinal.alephIdx
@[simp]
theorem alephIdx.initialSeg_coe : (alephIdx.initialSeg : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.initial_seg_coe Cardinal.alephIdx.initialSeg_coe
@[simp]
theorem alephIdx_lt {a b} : alephIdx a < alephIdx b β a < b :=
alephIdx.initialSeg.toRelEmbedding.map_rel_iff
#align cardinal.aleph_idx_lt Cardinal.alephIdx_lt
@[simp]
theorem alephIdx_le {a b} : alephIdx a β€ alephIdx b β a β€ b := by
rw [β not_lt, β not_lt, alephIdx_lt]
#align cardinal.aleph_idx_le Cardinal.alephIdx_le
theorem alephIdx.init {a b} : b < alephIdx a β β c, alephIdx c = b :=
alephIdx.initialSeg.init
#align cardinal.aleph_idx.init Cardinal.alephIdx.init
def alephIdx.relIso : @RelIso Cardinal.{u} Ordinal.{u} (Β· < Β·) (Β· < Β·) :=
@RelIso.ofSurjective Cardinal.{u} Ordinal.{u} (Β· < Β·) (Β· < Β·) alephIdx.initialSeg.{u} <|
(InitialSeg.eq_or_principal alephIdx.initialSeg.{u}).resolve_right fun β¨o, eβ© => by
have : β c, alephIdx c < o := fun c => (e _).2 β¨_, rflβ©
refine Ordinal.inductionOn o ?_ this; intro Ξ± r _ h
let s := β¨ a, invFun alephIdx (Ordinal.typein r a)
apply (lt_succ s).not_le
have I : Injective.{u+2, u+2} alephIdx := alephIdx.initialSeg.toEmbedding.injective
simpa only [typein_enum, leftInverse_invFun I (succ s)] using
le_ciSup
(Cardinal.bddAbove_range.{u, u} fun a : Ξ± => invFun alephIdx (Ordinal.typein r a))
(Ordinal.enum r _ (h (succ s)))
#align cardinal.aleph_idx.rel_iso Cardinal.alephIdx.relIso
@[simp]
theorem alephIdx.relIso_coe : (alephIdx.relIso : Cardinal β Ordinal) = alephIdx :=
rfl
#align cardinal.aleph_idx.rel_iso_coe Cardinal.alephIdx.relIso_coe
@[simp]
theorem type_cardinal : @type Cardinal (Β· < Β·) _ = Ordinal.univ.{u, u + 1} := by
rw [Ordinal.univ_id]; exact Quotient.sound β¨alephIdx.relIsoβ©
#align cardinal.type_cardinal Cardinal.type_cardinal
@[simp]
theorem mk_cardinal : #Cardinal = univ.{u, u + 1} := by
simpa only [card_type, card_univ] using congr_arg card type_cardinal
#align cardinal.mk_cardinal Cardinal.mk_cardinal
def Aleph'.relIso :=
Cardinal.alephIdx.relIso.symm
#align cardinal.aleph'.rel_iso Cardinal.Aleph'.relIso
def aleph' : Ordinal β Cardinal :=
Aleph'.relIso
#align cardinal.aleph' Cardinal.aleph'
@[simp]
theorem aleph'.relIso_coe : (Aleph'.relIso : Ordinal β Cardinal) = aleph' :=
rfl
#align cardinal.aleph'.rel_iso_coe Cardinal.aleph'.relIso_coe
@[simp]
theorem aleph'_lt {oβ oβ : Ordinal} : aleph' oβ < aleph' oβ β oβ < oβ :=
Aleph'.relIso.map_rel_iff
#align cardinal.aleph'_lt Cardinal.aleph'_lt
@[simp]
theorem aleph'_le {oβ oβ : Ordinal} : aleph' oβ β€ aleph' oβ β oβ β€ oβ :=
le_iff_le_iff_lt_iff_lt.2 aleph'_lt
#align cardinal.aleph'_le Cardinal.aleph'_le
@[simp]
theorem aleph'_alephIdx (c : Cardinal) : aleph' c.alephIdx = c :=
Cardinal.alephIdx.relIso.toEquiv.symm_apply_apply c
#align cardinal.aleph'_aleph_idx Cardinal.aleph'_alephIdx
@[simp]
theorem alephIdx_aleph' (o : Ordinal) : (aleph' o).alephIdx = o :=
Cardinal.alephIdx.relIso.toEquiv.apply_symm_apply o
#align cardinal.aleph_idx_aleph' Cardinal.alephIdx_aleph'
@[simp]
theorem aleph'_zero : aleph' 0 = 0 := by
rw [β nonpos_iff_eq_zero, β aleph'_alephIdx 0, aleph'_le]
apply Ordinal.zero_le
#align cardinal.aleph'_zero Cardinal.aleph'_zero
@[simp]
| Mathlib/SetTheory/Cardinal/Ordinal.lean | 204 | 207 | theorem aleph'_succ {o : Ordinal} : aleph' (succ o) = succ (aleph' o) := by |
apply (succ_le_of_lt <| aleph'_lt.2 <| lt_succ o).antisymm' (Cardinal.alephIdx_le.1 <| _)
rw [alephIdx_aleph', succ_le_iff, β aleph'_lt, aleph'_alephIdx]
apply lt_succ
| 1,582 |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Set Cardinal Equiv Order Ordinal
open scoped Classical
universe u v w
namespace Cardinal
section UsingOrdinals
theorem ord_isLimit {c} (co : β΅β β€ c) : (ord c).IsLimit := by
refine β¨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_β©
Β· rw [β Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
Β· rw [ord_le] at h β’
rwa [β @add_one_of_aleph0_le (card a), β card_succ]
rw [β ord_le, β le_succ_of_isLimit, ord_le]
Β· exact co.trans h
Β· rw [ord_aleph0]
exact omega_isLimit
#align cardinal.ord_is_limit Cardinal.ord_isLimit
theorem noMaxOrder {c} (h : β΅β β€ c) : NoMaxOrder c.ord.out.Ξ± :=
Ordinal.out_no_max_of_succ_lt (ord_isLimit h).2
section beth
def beth (o : Ordinal.{u}) : Cardinal.{u} :=
limitRecOn o aleph0 (fun _ x => (2 : Cardinal) ^ x) fun a _ IH => β¨ b : Iio a, IH b.1 b.2
#align cardinal.beth Cardinal.beth
@[simp]
theorem beth_zero : beth 0 = aleph0 :=
limitRecOn_zero _ _ _
#align cardinal.beth_zero Cardinal.beth_zero
@[simp]
theorem beth_succ (o : Ordinal) : beth (succ o) = 2 ^ beth o :=
limitRecOn_succ _ _ _ _
#align cardinal.beth_succ Cardinal.beth_succ
theorem beth_limit {o : Ordinal} : o.IsLimit β beth o = β¨ a : Iio o, beth a :=
limitRecOn_limit _ _ _ _
#align cardinal.beth_limit Cardinal.beth_limit
| Mathlib/SetTheory/Cardinal/Ordinal.lean | 433 | 447 | theorem beth_strictMono : StrictMono beth := by |
intro a b
induction' b using Ordinal.induction with b IH generalizing a
intro h
rcases zero_or_succ_or_limit b with (rfl | β¨c, rflβ© | hb)
Β· exact (Ordinal.not_lt_zero a h).elim
Β· rw [lt_succ_iff] at h
rw [beth_succ]
apply lt_of_le_of_lt _ (cantor _)
rcases eq_or_lt_of_le h with (rfl | h)
Β· rfl
exact (IH c (lt_succ c) h).le
Β· apply (cantor _).trans_le
rw [beth_limit hb, β beth_succ]
exact le_ciSup (bddAbove_of_small _) (β¨_, hb.succ_lt hβ© : Iio b)
| 1,582 |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Set Cardinal Equiv Order Ordinal
open scoped Classical
universe u v w
namespace Cardinal
section UsingOrdinals
theorem ord_isLimit {c} (co : β΅β β€ c) : (ord c).IsLimit := by
refine β¨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_β©
Β· rw [β Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
Β· rw [ord_le] at h β’
rwa [β @add_one_of_aleph0_le (card a), β card_succ]
rw [β ord_le, β le_succ_of_isLimit, ord_le]
Β· exact co.trans h
Β· rw [ord_aleph0]
exact omega_isLimit
#align cardinal.ord_is_limit Cardinal.ord_isLimit
theorem noMaxOrder {c} (h : β΅β β€ c) : NoMaxOrder c.ord.out.Ξ± :=
Ordinal.out_no_max_of_succ_lt (ord_isLimit h).2
section mulOrdinals
| Mathlib/SetTheory/Cardinal/Ordinal.lean | 500 | 543 | theorem mul_eq_self {c : Cardinal} (h : β΅β β€ c) : c * c = c := by |
refine le_antisymm ?_ (by simpa only [mul_one] using mul_le_mul_left' (one_le_aleph0.trans h) c)
-- the only nontrivial part is `c * c β€ c`. We prove it inductively.
refine Acc.recOn (Cardinal.lt_wf.apply c) (fun c _ => Quotient.inductionOn c fun Ξ± IH ol => ?_) h
-- consider the minimal well-order `r` on `Ξ±` (a type with cardinality `c`).
rcases ord_eq Ξ± with β¨r, wo, eβ©
letI := linearOrderOfSTO r
haveI : IsWellOrder Ξ± (Β· < Β·) := wo
-- Define an order `s` on `Ξ± Γ Ξ±` by writing `(a, b) < (c, d)` if `max a b < max c d`, or
-- the max are equal and `a < c`, or the max are equal and `a = c` and `b < d`.
let g : Ξ± Γ Ξ± β Ξ± := fun p => max p.1 p.2
let f : Ξ± Γ Ξ± βͺ Ordinal Γ Ξ± Γ Ξ± :=
β¨fun p : Ξ± Γ Ξ± => (typein (Β· < Β·) (g p), p), fun p q => congr_arg Prod.sndβ©
let s := f β»ΒΉ'o Prod.Lex (Β· < Β·) (Prod.Lex (Β· < Β·) (Β· < Β·))
-- this is a well order on `Ξ± Γ Ξ±`.
haveI : IsWellOrder _ s := (RelEmbedding.preimage _ _).isWellOrder
/- it suffices to show that this well order is smaller than `r`
if it were larger, then `r` would be a strict prefix of `s`. It would be contained in
`Ξ² Γ Ξ²` for some `Ξ²` of cardinality `< c`. By the inductive assumption, this set has the
same cardinality as `Ξ²` (or it is finite if `Ξ²` is finite), so it is `< c`, which is a
contradiction. -/
suffices type s β€ type r by exact card_le_card this
refine le_of_forall_lt fun o h => ?_
rcases typein_surj s h with β¨p, rflβ©
rw [β e, lt_ord]
refine lt_of_le_of_lt
(?_ : _ β€ card (succ (typein (Β· < Β·) (g p))) * card (succ (typein (Β· < Β·) (g p)))) ?_
Β· have : { q | s q p } β insert (g p) { x | x < g p } ΓΛ’ insert (g p) { x | x < g p } := by
intro q h
simp only [s, f, Preimage, ge_iff_le, Embedding.coeFn_mk, Prod.lex_def, typein_lt_typein,
typein_inj, mem_setOf_eq] at h
exact max_le_iff.1 (le_iff_lt_or_eq.2 <| h.imp_right And.left)
suffices H : (insert (g p) { x | r x (g p) } : Set Ξ±) β Sum { x | r x (g p) } PUnit from
β¨(Set.embeddingOfSubset _ _ this).trans
((Equiv.Set.prod _ _).trans (H.prodCongr H)).toEmbeddingβ©
refine (Equiv.Set.insert ?_).trans ((Equiv.refl _).sumCongr punitEquivPUnit)
apply @irrefl _ r
cases' lt_or_le (card (succ (typein (Β· < Β·) (g p)))) β΅β with qo qo
Β· exact (mul_lt_aleph0 qo qo).trans_le ol
Β· suffices (succ (typein LT.lt (g p))).card < β¦Ξ±β§ from (IH _ this qo).trans_lt this
rw [β lt_ord]
apply (ord_isLimit ol).2
rw [mk'_def, e]
apply typein_lt_type
| 1,582 |
import Mathlib.Data.W.Basic
import Mathlib.SetTheory.Cardinal.Ordinal
#align_import data.W.cardinal from "leanprover-community/mathlib"@"6eeb941cf39066417a09b1bbc6e74761cadfcb1a"
universe u v
variable {Ξ± : Type u} {Ξ² : Ξ± β Type v}
noncomputable section
namespace WType
open Cardinal
-- Porting note: `W` is a special name, exceptionally in upper case in Lean3
set_option linter.uppercaseLean3 false
theorem cardinal_mk_eq_sum' : #(WType Ξ²) = sum (fun a : Ξ± => #(WType Ξ²) ^ lift.{u} #(Ξ² a)) :=
(mk_congr <| equivSigma Ξ²).trans <| by
simp_rw [mk_sigma, mk_arrow]; rw [lift_id'.{v, u}, lift_umax.{v, u}]
| Mathlib/Data/W/Cardinal.lean | 46 | 54 | theorem cardinal_mk_le_of_le' {ΞΊ : Cardinal.{max u v}}
(hΞΊ : (sum fun a : Ξ± => ΞΊ ^ lift.{u} #(Ξ² a)) β€ ΞΊ) :
#(WType Ξ²) β€ ΞΊ := by |
induction' ΞΊ using Cardinal.inductionOn with Ξ³
simp_rw [β lift_umax.{v, u}] at hΞΊ
nth_rewrite 1 [β lift_id'.{v, u} #Ξ³] at hΞΊ
simp_rw [β mk_arrow, β mk_sigma, le_def] at hΞΊ
cases' hΞΊ with hΞΊ
exact Cardinal.mk_le_of_injective (elim_injective _ hΞΊ.1 hΞΊ.2)
| 1,583 |
import Mathlib.SetTheory.Cardinal.Ordinal
import Mathlib.SetTheory.Ordinal.FixedPoint
#align_import set_theory.cardinal.cofinality from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Cardinal Set Order
open scoped Classical
open Cardinal Ordinal
universe u v w
variable {Ξ± : Type*} {r : Ξ± β Ξ± β Prop}
namespace Order
def cof (r : Ξ± β Ξ± β Prop) : Cardinal :=
sInf { c | β S : Set Ξ±, (β a, β b β S, r a b) β§ #S = c }
#align order.cof Order.cof
theorem cof_nonempty (r : Ξ± β Ξ± β Prop) [IsRefl Ξ± r] :
{ c | β S : Set Ξ±, (β a, β b β S, r a b) β§ #S = c }.Nonempty :=
β¨_, Set.univ, fun a => β¨a, β¨β©, refl _β©, rflβ©
#align order.cof_nonempty Order.cof_nonempty
theorem cof_le (r : Ξ± β Ξ± β Prop) {S : Set Ξ±} (h : β a, β b β S, r a b) : cof r β€ #S :=
csInf_le' β¨S, h, rflβ©
#align order.cof_le Order.cof_le
| Mathlib/SetTheory/Cardinal/Cofinality.lean | 80 | 85 | theorem le_cof {r : Ξ± β Ξ± β Prop} [IsRefl Ξ± r] (c : Cardinal) :
c β€ cof r β β {S : Set Ξ±}, (β a, β b β S, r a b) β c β€ #S := by |
rw [cof, le_csInf_iff'' (cof_nonempty r)]
use fun H S h => H _ β¨S, h, rflβ©
rintro H d β¨S, h, rflβ©
exact H h
| 1,584 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section repr
theorem repr_injective : Injective (repr : Basis ΞΉ R M β M ββ[R] ΞΉ ββ R) := fun f g h => by
cases f; cases g; congr
#align basis.repr_injective Basis.repr_injective
instance instFunLike : FunLike (Basis ΞΉ R M) ΞΉ M where
coe b i := b.repr.symm (Finsupp.single i 1)
coe_injective' f g h := repr_injective <| LinearEquiv.symm_bijective.injective <|
LinearEquiv.toLinearMap_injective <| by ext; exact congr_fun h _
#align basis.fun_like Basis.instFunLike
@[simp]
theorem coe_ofRepr (e : M ββ[R] ΞΉ ββ R) : β(ofRepr e) = fun i => e.symm (Finsupp.single i 1) :=
rfl
#align basis.coe_of_repr Basis.coe_ofRepr
protected theorem injective [Nontrivial R] : Injective b :=
b.repr.symm.injective.comp fun _ _ => (Finsupp.single_left_inj (one_ne_zero : (1 : R) β 0)).mp
#align basis.injective Basis.injective
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
rfl
#align basis.repr_symm_single_one Basis.repr_symm_single_one
| Mathlib/LinearAlgebra/Basis.lean | 137 | 141 | theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c β’ b i :=
calc
b.repr.symm (Finsupp.single i c) = b.repr.symm (c β’ Finsupp.single i (1 : R)) := by |
{ rw [Finsupp.smul_single', mul_one] }
_ = c β’ b i := by rw [LinearEquiv.map_smul, repr_symm_single_one]
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section repr
theorem repr_injective : Injective (repr : Basis ΞΉ R M β M ββ[R] ΞΉ ββ R) := fun f g h => by
cases f; cases g; congr
#align basis.repr_injective Basis.repr_injective
instance instFunLike : FunLike (Basis ΞΉ R M) ΞΉ M where
coe b i := b.repr.symm (Finsupp.single i 1)
coe_injective' f g h := repr_injective <| LinearEquiv.symm_bijective.injective <|
LinearEquiv.toLinearMap_injective <| by ext; exact congr_fun h _
#align basis.fun_like Basis.instFunLike
@[simp]
theorem coe_ofRepr (e : M ββ[R] ΞΉ ββ R) : β(ofRepr e) = fun i => e.symm (Finsupp.single i 1) :=
rfl
#align basis.coe_of_repr Basis.coe_ofRepr
protected theorem injective [Nontrivial R] : Injective b :=
b.repr.symm.injective.comp fun _ _ => (Finsupp.single_left_inj (one_ne_zero : (1 : R) β 0)).mp
#align basis.injective Basis.injective
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
rfl
#align basis.repr_symm_single_one Basis.repr_symm_single_one
theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c β’ b i :=
calc
b.repr.symm (Finsupp.single i c) = b.repr.symm (c β’ Finsupp.single i (1 : R)) := by
{ rw [Finsupp.smul_single', mul_one] }
_ = c β’ b i := by rw [LinearEquiv.map_smul, repr_symm_single_one]
#align basis.repr_symm_single Basis.repr_symm_single
@[simp]
theorem repr_self : b.repr (b i) = Finsupp.single i 1 :=
LinearEquiv.apply_symm_apply _ _
#align basis.repr_self Basis.repr_self
| Mathlib/LinearAlgebra/Basis.lean | 149 | 150 | theorem repr_self_apply (j) [Decidable (i = j)] : b.repr (b i) j = if i = j then 1 else 0 := by |
rw [repr_self, Finsupp.single_apply]
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section repr
theorem repr_injective : Injective (repr : Basis ΞΉ R M β M ββ[R] ΞΉ ββ R) := fun f g h => by
cases f; cases g; congr
#align basis.repr_injective Basis.repr_injective
instance instFunLike : FunLike (Basis ΞΉ R M) ΞΉ M where
coe b i := b.repr.symm (Finsupp.single i 1)
coe_injective' f g h := repr_injective <| LinearEquiv.symm_bijective.injective <|
LinearEquiv.toLinearMap_injective <| by ext; exact congr_fun h _
#align basis.fun_like Basis.instFunLike
@[simp]
theorem coe_ofRepr (e : M ββ[R] ΞΉ ββ R) : β(ofRepr e) = fun i => e.symm (Finsupp.single i 1) :=
rfl
#align basis.coe_of_repr Basis.coe_ofRepr
protected theorem injective [Nontrivial R] : Injective b :=
b.repr.symm.injective.comp fun _ _ => (Finsupp.single_left_inj (one_ne_zero : (1 : R) β 0)).mp
#align basis.injective Basis.injective
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
rfl
#align basis.repr_symm_single_one Basis.repr_symm_single_one
theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c β’ b i :=
calc
b.repr.symm (Finsupp.single i c) = b.repr.symm (c β’ Finsupp.single i (1 : R)) := by
{ rw [Finsupp.smul_single', mul_one] }
_ = c β’ b i := by rw [LinearEquiv.map_smul, repr_symm_single_one]
#align basis.repr_symm_single Basis.repr_symm_single
@[simp]
theorem repr_self : b.repr (b i) = Finsupp.single i 1 :=
LinearEquiv.apply_symm_apply _ _
#align basis.repr_self Basis.repr_self
theorem repr_self_apply (j) [Decidable (i = j)] : b.repr (b i) j = if i = j then 1 else 0 := by
rw [repr_self, Finsupp.single_apply]
#align basis.repr_self_apply Basis.repr_self_apply
@[simp]
| Mathlib/LinearAlgebra/Basis.lean | 154 | 158 | theorem repr_symm_apply (v) : b.repr.symm v = Finsupp.total ΞΉ M R b v :=
calc
b.repr.symm v = b.repr.symm (v.sum Finsupp.single) := by | simp
_ = v.sum fun i vi => b.repr.symm (Finsupp.single i vi) := map_finsupp_sum ..
_ = Finsupp.total ΞΉ M R b v := by simp only [repr_symm_single, Finsupp.total_apply]
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section repr
theorem repr_injective : Injective (repr : Basis ΞΉ R M β M ββ[R] ΞΉ ββ R) := fun f g h => by
cases f; cases g; congr
#align basis.repr_injective Basis.repr_injective
instance instFunLike : FunLike (Basis ΞΉ R M) ΞΉ M where
coe b i := b.repr.symm (Finsupp.single i 1)
coe_injective' f g h := repr_injective <| LinearEquiv.symm_bijective.injective <|
LinearEquiv.toLinearMap_injective <| by ext; exact congr_fun h _
#align basis.fun_like Basis.instFunLike
@[simp]
theorem coe_ofRepr (e : M ββ[R] ΞΉ ββ R) : β(ofRepr e) = fun i => e.symm (Finsupp.single i 1) :=
rfl
#align basis.coe_of_repr Basis.coe_ofRepr
protected theorem injective [Nontrivial R] : Injective b :=
b.repr.symm.injective.comp fun _ _ => (Finsupp.single_left_inj (one_ne_zero : (1 : R) β 0)).mp
#align basis.injective Basis.injective
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
rfl
#align basis.repr_symm_single_one Basis.repr_symm_single_one
theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c β’ b i :=
calc
b.repr.symm (Finsupp.single i c) = b.repr.symm (c β’ Finsupp.single i (1 : R)) := by
{ rw [Finsupp.smul_single', mul_one] }
_ = c β’ b i := by rw [LinearEquiv.map_smul, repr_symm_single_one]
#align basis.repr_symm_single Basis.repr_symm_single
@[simp]
theorem repr_self : b.repr (b i) = Finsupp.single i 1 :=
LinearEquiv.apply_symm_apply _ _
#align basis.repr_self Basis.repr_self
theorem repr_self_apply (j) [Decidable (i = j)] : b.repr (b i) j = if i = j then 1 else 0 := by
rw [repr_self, Finsupp.single_apply]
#align basis.repr_self_apply Basis.repr_self_apply
@[simp]
theorem repr_symm_apply (v) : b.repr.symm v = Finsupp.total ΞΉ M R b v :=
calc
b.repr.symm v = b.repr.symm (v.sum Finsupp.single) := by simp
_ = v.sum fun i vi => b.repr.symm (Finsupp.single i vi) := map_finsupp_sum ..
_ = Finsupp.total ΞΉ M R b v := by simp only [repr_symm_single, Finsupp.total_apply]
#align basis.repr_symm_apply Basis.repr_symm_apply
@[simp]
theorem coe_repr_symm : βb.repr.symm = Finsupp.total ΞΉ M R b :=
LinearMap.ext fun v => b.repr_symm_apply v
#align basis.coe_repr_symm Basis.coe_repr_symm
@[simp]
| Mathlib/LinearAlgebra/Basis.lean | 167 | 169 | theorem repr_total (v) : b.repr (Finsupp.total _ _ _ b v) = v := by |
rw [β b.coe_repr_symm]
exact b.repr.apply_symm_apply v
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section repr
theorem repr_injective : Injective (repr : Basis ΞΉ R M β M ββ[R] ΞΉ ββ R) := fun f g h => by
cases f; cases g; congr
#align basis.repr_injective Basis.repr_injective
instance instFunLike : FunLike (Basis ΞΉ R M) ΞΉ M where
coe b i := b.repr.symm (Finsupp.single i 1)
coe_injective' f g h := repr_injective <| LinearEquiv.symm_bijective.injective <|
LinearEquiv.toLinearMap_injective <| by ext; exact congr_fun h _
#align basis.fun_like Basis.instFunLike
@[simp]
theorem coe_ofRepr (e : M ββ[R] ΞΉ ββ R) : β(ofRepr e) = fun i => e.symm (Finsupp.single i 1) :=
rfl
#align basis.coe_of_repr Basis.coe_ofRepr
protected theorem injective [Nontrivial R] : Injective b :=
b.repr.symm.injective.comp fun _ _ => (Finsupp.single_left_inj (one_ne_zero : (1 : R) β 0)).mp
#align basis.injective Basis.injective
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
rfl
#align basis.repr_symm_single_one Basis.repr_symm_single_one
theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c β’ b i :=
calc
b.repr.symm (Finsupp.single i c) = b.repr.symm (c β’ Finsupp.single i (1 : R)) := by
{ rw [Finsupp.smul_single', mul_one] }
_ = c β’ b i := by rw [LinearEquiv.map_smul, repr_symm_single_one]
#align basis.repr_symm_single Basis.repr_symm_single
@[simp]
theorem repr_self : b.repr (b i) = Finsupp.single i 1 :=
LinearEquiv.apply_symm_apply _ _
#align basis.repr_self Basis.repr_self
theorem repr_self_apply (j) [Decidable (i = j)] : b.repr (b i) j = if i = j then 1 else 0 := by
rw [repr_self, Finsupp.single_apply]
#align basis.repr_self_apply Basis.repr_self_apply
@[simp]
theorem repr_symm_apply (v) : b.repr.symm v = Finsupp.total ΞΉ M R b v :=
calc
b.repr.symm v = b.repr.symm (v.sum Finsupp.single) := by simp
_ = v.sum fun i vi => b.repr.symm (Finsupp.single i vi) := map_finsupp_sum ..
_ = Finsupp.total ΞΉ M R b v := by simp only [repr_symm_single, Finsupp.total_apply]
#align basis.repr_symm_apply Basis.repr_symm_apply
@[simp]
theorem coe_repr_symm : βb.repr.symm = Finsupp.total ΞΉ M R b :=
LinearMap.ext fun v => b.repr_symm_apply v
#align basis.coe_repr_symm Basis.coe_repr_symm
@[simp]
theorem repr_total (v) : b.repr (Finsupp.total _ _ _ b v) = v := by
rw [β b.coe_repr_symm]
exact b.repr.apply_symm_apply v
#align basis.repr_total Basis.repr_total
@[simp]
| Mathlib/LinearAlgebra/Basis.lean | 173 | 175 | theorem total_repr : Finsupp.total _ _ _ b (b.repr x) = x := by |
rw [β b.coe_repr_symm]
exact b.repr.symm_apply_apply x
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section repr
theorem repr_injective : Injective (repr : Basis ΞΉ R M β M ββ[R] ΞΉ ββ R) := fun f g h => by
cases f; cases g; congr
#align basis.repr_injective Basis.repr_injective
instance instFunLike : FunLike (Basis ΞΉ R M) ΞΉ M where
coe b i := b.repr.symm (Finsupp.single i 1)
coe_injective' f g h := repr_injective <| LinearEquiv.symm_bijective.injective <|
LinearEquiv.toLinearMap_injective <| by ext; exact congr_fun h _
#align basis.fun_like Basis.instFunLike
@[simp]
theorem coe_ofRepr (e : M ββ[R] ΞΉ ββ R) : β(ofRepr e) = fun i => e.symm (Finsupp.single i 1) :=
rfl
#align basis.coe_of_repr Basis.coe_ofRepr
protected theorem injective [Nontrivial R] : Injective b :=
b.repr.symm.injective.comp fun _ _ => (Finsupp.single_left_inj (one_ne_zero : (1 : R) β 0)).mp
#align basis.injective Basis.injective
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
rfl
#align basis.repr_symm_single_one Basis.repr_symm_single_one
theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c β’ b i :=
calc
b.repr.symm (Finsupp.single i c) = b.repr.symm (c β’ Finsupp.single i (1 : R)) := by
{ rw [Finsupp.smul_single', mul_one] }
_ = c β’ b i := by rw [LinearEquiv.map_smul, repr_symm_single_one]
#align basis.repr_symm_single Basis.repr_symm_single
@[simp]
theorem repr_self : b.repr (b i) = Finsupp.single i 1 :=
LinearEquiv.apply_symm_apply _ _
#align basis.repr_self Basis.repr_self
theorem repr_self_apply (j) [Decidable (i = j)] : b.repr (b i) j = if i = j then 1 else 0 := by
rw [repr_self, Finsupp.single_apply]
#align basis.repr_self_apply Basis.repr_self_apply
@[simp]
theorem repr_symm_apply (v) : b.repr.symm v = Finsupp.total ΞΉ M R b v :=
calc
b.repr.symm v = b.repr.symm (v.sum Finsupp.single) := by simp
_ = v.sum fun i vi => b.repr.symm (Finsupp.single i vi) := map_finsupp_sum ..
_ = Finsupp.total ΞΉ M R b v := by simp only [repr_symm_single, Finsupp.total_apply]
#align basis.repr_symm_apply Basis.repr_symm_apply
@[simp]
theorem coe_repr_symm : βb.repr.symm = Finsupp.total ΞΉ M R b :=
LinearMap.ext fun v => b.repr_symm_apply v
#align basis.coe_repr_symm Basis.coe_repr_symm
@[simp]
theorem repr_total (v) : b.repr (Finsupp.total _ _ _ b v) = v := by
rw [β b.coe_repr_symm]
exact b.repr.apply_symm_apply v
#align basis.repr_total Basis.repr_total
@[simp]
theorem total_repr : Finsupp.total _ _ _ b (b.repr x) = x := by
rw [β b.coe_repr_symm]
exact b.repr.symm_apply_apply x
#align basis.total_repr Basis.total_repr
| Mathlib/LinearAlgebra/Basis.lean | 178 | 179 | theorem repr_range : LinearMap.range (b.repr : M ββ[R] ΞΉ ββ R) = Finsupp.supported R R univ := by |
rw [LinearEquiv.range, Finsupp.supported_univ]
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section repr
theorem repr_injective : Injective (repr : Basis ΞΉ R M β M ββ[R] ΞΉ ββ R) := fun f g h => by
cases f; cases g; congr
#align basis.repr_injective Basis.repr_injective
instance instFunLike : FunLike (Basis ΞΉ R M) ΞΉ M where
coe b i := b.repr.symm (Finsupp.single i 1)
coe_injective' f g h := repr_injective <| LinearEquiv.symm_bijective.injective <|
LinearEquiv.toLinearMap_injective <| by ext; exact congr_fun h _
#align basis.fun_like Basis.instFunLike
@[simp]
theorem coe_ofRepr (e : M ββ[R] ΞΉ ββ R) : β(ofRepr e) = fun i => e.symm (Finsupp.single i 1) :=
rfl
#align basis.coe_of_repr Basis.coe_ofRepr
protected theorem injective [Nontrivial R] : Injective b :=
b.repr.symm.injective.comp fun _ _ => (Finsupp.single_left_inj (one_ne_zero : (1 : R) β 0)).mp
#align basis.injective Basis.injective
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
rfl
#align basis.repr_symm_single_one Basis.repr_symm_single_one
theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c β’ b i :=
calc
b.repr.symm (Finsupp.single i c) = b.repr.symm (c β’ Finsupp.single i (1 : R)) := by
{ rw [Finsupp.smul_single', mul_one] }
_ = c β’ b i := by rw [LinearEquiv.map_smul, repr_symm_single_one]
#align basis.repr_symm_single Basis.repr_symm_single
@[simp]
theorem repr_self : b.repr (b i) = Finsupp.single i 1 :=
LinearEquiv.apply_symm_apply _ _
#align basis.repr_self Basis.repr_self
theorem repr_self_apply (j) [Decidable (i = j)] : b.repr (b i) j = if i = j then 1 else 0 := by
rw [repr_self, Finsupp.single_apply]
#align basis.repr_self_apply Basis.repr_self_apply
@[simp]
theorem repr_symm_apply (v) : b.repr.symm v = Finsupp.total ΞΉ M R b v :=
calc
b.repr.symm v = b.repr.symm (v.sum Finsupp.single) := by simp
_ = v.sum fun i vi => b.repr.symm (Finsupp.single i vi) := map_finsupp_sum ..
_ = Finsupp.total ΞΉ M R b v := by simp only [repr_symm_single, Finsupp.total_apply]
#align basis.repr_symm_apply Basis.repr_symm_apply
@[simp]
theorem coe_repr_symm : βb.repr.symm = Finsupp.total ΞΉ M R b :=
LinearMap.ext fun v => b.repr_symm_apply v
#align basis.coe_repr_symm Basis.coe_repr_symm
@[simp]
theorem repr_total (v) : b.repr (Finsupp.total _ _ _ b v) = v := by
rw [β b.coe_repr_symm]
exact b.repr.apply_symm_apply v
#align basis.repr_total Basis.repr_total
@[simp]
theorem total_repr : Finsupp.total _ _ _ b (b.repr x) = x := by
rw [β b.coe_repr_symm]
exact b.repr.symm_apply_apply x
#align basis.total_repr Basis.total_repr
theorem repr_range : LinearMap.range (b.repr : M ββ[R] ΞΉ ββ R) = Finsupp.supported R R univ := by
rw [LinearEquiv.range, Finsupp.supported_univ]
#align basis.repr_range Basis.repr_range
theorem mem_span_repr_support (m : M) : m β span R (b '' (b.repr m).support) :=
(Finsupp.mem_span_image_iff_total _).2 β¨b.repr m, by simp [Finsupp.mem_supported_support]β©
#align basis.mem_span_repr_support Basis.mem_span_repr_support
| Mathlib/LinearAlgebra/Basis.lean | 186 | 189 | theorem repr_support_subset_of_mem_span (s : Set ΞΉ) {m : M}
(hm : m β span R (b '' s)) : β(b.repr m).support β s := by |
rcases (Finsupp.mem_span_image_iff_total _).1 hm with β¨l, hl, rflβ©
rwa [repr_total, β Finsupp.mem_supported R l]
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section repr
theorem repr_injective : Injective (repr : Basis ΞΉ R M β M ββ[R] ΞΉ ββ R) := fun f g h => by
cases f; cases g; congr
#align basis.repr_injective Basis.repr_injective
instance instFunLike : FunLike (Basis ΞΉ R M) ΞΉ M where
coe b i := b.repr.symm (Finsupp.single i 1)
coe_injective' f g h := repr_injective <| LinearEquiv.symm_bijective.injective <|
LinearEquiv.toLinearMap_injective <| by ext; exact congr_fun h _
#align basis.fun_like Basis.instFunLike
@[simp]
theorem coe_ofRepr (e : M ββ[R] ΞΉ ββ R) : β(ofRepr e) = fun i => e.symm (Finsupp.single i 1) :=
rfl
#align basis.coe_of_repr Basis.coe_ofRepr
protected theorem injective [Nontrivial R] : Injective b :=
b.repr.symm.injective.comp fun _ _ => (Finsupp.single_left_inj (one_ne_zero : (1 : R) β 0)).mp
#align basis.injective Basis.injective
theorem repr_symm_single_one : b.repr.symm (Finsupp.single i 1) = b i :=
rfl
#align basis.repr_symm_single_one Basis.repr_symm_single_one
theorem repr_symm_single : b.repr.symm (Finsupp.single i c) = c β’ b i :=
calc
b.repr.symm (Finsupp.single i c) = b.repr.symm (c β’ Finsupp.single i (1 : R)) := by
{ rw [Finsupp.smul_single', mul_one] }
_ = c β’ b i := by rw [LinearEquiv.map_smul, repr_symm_single_one]
#align basis.repr_symm_single Basis.repr_symm_single
@[simp]
theorem repr_self : b.repr (b i) = Finsupp.single i 1 :=
LinearEquiv.apply_symm_apply _ _
#align basis.repr_self Basis.repr_self
theorem repr_self_apply (j) [Decidable (i = j)] : b.repr (b i) j = if i = j then 1 else 0 := by
rw [repr_self, Finsupp.single_apply]
#align basis.repr_self_apply Basis.repr_self_apply
@[simp]
theorem repr_symm_apply (v) : b.repr.symm v = Finsupp.total ΞΉ M R b v :=
calc
b.repr.symm v = b.repr.symm (v.sum Finsupp.single) := by simp
_ = v.sum fun i vi => b.repr.symm (Finsupp.single i vi) := map_finsupp_sum ..
_ = Finsupp.total ΞΉ M R b v := by simp only [repr_symm_single, Finsupp.total_apply]
#align basis.repr_symm_apply Basis.repr_symm_apply
@[simp]
theorem coe_repr_symm : βb.repr.symm = Finsupp.total ΞΉ M R b :=
LinearMap.ext fun v => b.repr_symm_apply v
#align basis.coe_repr_symm Basis.coe_repr_symm
@[simp]
theorem repr_total (v) : b.repr (Finsupp.total _ _ _ b v) = v := by
rw [β b.coe_repr_symm]
exact b.repr.apply_symm_apply v
#align basis.repr_total Basis.repr_total
@[simp]
theorem total_repr : Finsupp.total _ _ _ b (b.repr x) = x := by
rw [β b.coe_repr_symm]
exact b.repr.symm_apply_apply x
#align basis.total_repr Basis.total_repr
theorem repr_range : LinearMap.range (b.repr : M ββ[R] ΞΉ ββ R) = Finsupp.supported R R univ := by
rw [LinearEquiv.range, Finsupp.supported_univ]
#align basis.repr_range Basis.repr_range
theorem mem_span_repr_support (m : M) : m β span R (b '' (b.repr m).support) :=
(Finsupp.mem_span_image_iff_total _).2 β¨b.repr m, by simp [Finsupp.mem_supported_support]β©
#align basis.mem_span_repr_support Basis.mem_span_repr_support
theorem repr_support_subset_of_mem_span (s : Set ΞΉ) {m : M}
(hm : m β span R (b '' s)) : β(b.repr m).support β s := by
rcases (Finsupp.mem_span_image_iff_total _).1 hm with β¨l, hl, rflβ©
rwa [repr_total, β Finsupp.mem_supported R l]
#align basis.repr_support_subset_of_mem_span Basis.repr_support_subset_of_mem_span
theorem mem_span_image {m : M} {s : Set ΞΉ} : m β span R (b '' s) β β(b.repr m).support β s :=
β¨repr_support_subset_of_mem_span _ _, fun h β¦
span_mono (image_subset _ h) (mem_span_repr_support b _)β©
@[simp]
| Mathlib/LinearAlgebra/Basis.lean | 197 | 199 | theorem self_mem_span_image [Nontrivial R] {i : ΞΉ} {s : Set ΞΉ} :
b i β span R (b '' s) β i β s := by |
simp [mem_span_image, Finsupp.support_single_ne_zero]
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section Coord
@[simps!]
def coord : M ββ[R] R :=
Finsupp.lapply i ββ βb.repr
#align basis.coord Basis.coord
theorem forall_coord_eq_zero_iff {x : M} : (β i, b.coord i x = 0) β x = 0 :=
Iff.trans (by simp only [b.coord_apply, DFunLike.ext_iff, Finsupp.zero_apply])
b.repr.map_eq_zero_iff
#align basis.forall_coord_eq_zero_iff Basis.forall_coord_eq_zero_iff
noncomputable def sumCoords : M ββ[R] R :=
(Finsupp.lsum β fun _ => LinearMap.id) ββ (b.repr : M ββ[R] ΞΉ ββ R)
#align basis.sum_coords Basis.sumCoords
@[simp]
theorem coe_sumCoords : (b.sumCoords : M β R) = fun m => (b.repr m).sum fun _ => id :=
rfl
#align basis.coe_sum_coords Basis.coe_sumCoords
| Mathlib/LinearAlgebra/Basis.lean | 231 | 236 | theorem coe_sumCoords_eq_finsum : (b.sumCoords : M β R) = fun m => βαΆ i, b.coord i m := by |
ext m
simp only [Basis.sumCoords, Basis.coord, Finsupp.lapply_apply, LinearMap.id_coe,
LinearEquiv.coe_coe, Function.comp_apply, Finsupp.coe_lsum, LinearMap.coe_comp,
finsum_eq_sum _ (b.repr m).finite_support, Finsupp.sum, Finset.finite_toSet_toFinset, id,
Finsupp.fun_support_eq]
| 1,585 |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
noncomputable section
universe u
open Function Set Submodule
variable {ΞΉ : Type*} {ΞΉ' : Type*} {R : Type*} {Rβ : Type*} {K : Type*}
variable {M : Type*} {M' M'' : Type*} {V : Type u} {V' : Type*}
section Module
variable [Semiring R]
variable [AddCommMonoid M] [Module R M] [AddCommMonoid M'] [Module R M']
section
variable (ΞΉ R M)
structure Basis where
ofRepr ::
repr : M ββ[R] ΞΉ ββ R
#align basis Basis
#align basis.repr Basis.repr
#align basis.of_repr Basis.ofRepr
end
instance uniqueBasis [Subsingleton R] : Unique (Basis ΞΉ R M) :=
β¨β¨β¨defaultβ©β©, fun β¨bβ© => by rw [Subsingleton.elim b]β©
#align unique_basis uniqueBasis
namespace Basis
instance : Inhabited (Basis ΞΉ R (ΞΉ ββ R)) :=
β¨.ofRepr (LinearEquiv.refl _ _)β©
variable (b bβ : Basis ΞΉ R M) (i : ΞΉ) (c : R) (x : M)
section Coord
@[simps!]
def coord : M ββ[R] R :=
Finsupp.lapply i ββ βb.repr
#align basis.coord Basis.coord
theorem forall_coord_eq_zero_iff {x : M} : (β i, b.coord i x = 0) β x = 0 :=
Iff.trans (by simp only [b.coord_apply, DFunLike.ext_iff, Finsupp.zero_apply])
b.repr.map_eq_zero_iff
#align basis.forall_coord_eq_zero_iff Basis.forall_coord_eq_zero_iff
noncomputable def sumCoords : M ββ[R] R :=
(Finsupp.lsum β fun _ => LinearMap.id) ββ (b.repr : M ββ[R] ΞΉ ββ R)
#align basis.sum_coords Basis.sumCoords
@[simp]
theorem coe_sumCoords : (b.sumCoords : M β R) = fun m => (b.repr m).sum fun _ => id :=
rfl
#align basis.coe_sum_coords Basis.coe_sumCoords
theorem coe_sumCoords_eq_finsum : (b.sumCoords : M β R) = fun m => βαΆ i, b.coord i m := by
ext m
simp only [Basis.sumCoords, Basis.coord, Finsupp.lapply_apply, LinearMap.id_coe,
LinearEquiv.coe_coe, Function.comp_apply, Finsupp.coe_lsum, LinearMap.coe_comp,
finsum_eq_sum _ (b.repr m).finite_support, Finsupp.sum, Finset.finite_toSet_toFinset, id,
Finsupp.fun_support_eq]
#align basis.coe_sum_coords_eq_finsum Basis.coe_sumCoords_eq_finsum
@[simp high]
| Mathlib/LinearAlgebra/Basis.lean | 240 | 246 | theorem coe_sumCoords_of_fintype [Fintype ΞΉ] : (b.sumCoords : M β R) = β i, b.coord i := by |
ext m
-- Porting note: - `eq_self_iff_true`
-- + `comp_apply` `LinearMap.coeFn_sum`
simp only [sumCoords, Finsupp.sum_fintype, LinearMap.id_coe, LinearEquiv.coe_coe, coord_apply,
id, Fintype.sum_apply, imp_true_iff, Finsupp.coe_lsum, LinearMap.coe_comp, comp_apply,
LinearMap.coeFn_sum]
| 1,585 |
import Mathlib.LinearAlgebra.Basis
import Mathlib.Algebra.Module.LocalizedModule
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Localization.Integer
#align_import ring_theory.localization.module from "leanprover-community/mathlib"@"2e59a6de168f95d16b16d217b808a36290398c0a"
open nonZeroDivisors
section Localization
variable {R : Type*} (Rβ : Type*) [CommSemiring R] (S : Submonoid R)
section IsLocalizedModule
section AddCommMonoid
open Submodule
variable [CommSemiring Rβ] [Algebra R Rβ] [hT : IsLocalization S Rβ]
variable {M M' : Type*} [AddCommMonoid M] [Module R M] [Module Rβ M] [IsScalarTower R Rβ M]
[AddCommMonoid M'] [Module R M'] [Module Rβ M'] [IsScalarTower R Rβ M'] (f : M ββ[R] M')
[IsLocalizedModule S f]
theorem span_eq_top_of_isLocalizedModule {v : Set M} (hv : span R v = β€) :
span Rβ (f '' v) = β€ := top_unique fun x _ β¦ by
obtain β¨β¨m, sβ©, hβ© := IsLocalizedModule.surj S f x
rw [Submonoid.smul_def, β algebraMap_smul Rβ, β Units.smul_isUnit (IsLocalization.map_units Rβ s),
eq_comm, β inv_smul_eq_iff] at h
refine h βΈ smul_mem _ _ (span_subset_span R Rβ _ ?_)
rw [β LinearMap.coe_restrictScalars R, β LinearMap.map_span, hv]
exact mem_map_of_mem mem_top
| Mathlib/RingTheory/Localization/Module.lean | 56 | 71 | theorem LinearIndependent.of_isLocalizedModule {ΞΉ : Type*} {v : ΞΉ β M}
(hv : LinearIndependent R v) : LinearIndependent Rβ (f β v) := by |
rw [linearIndependent_iff'] at hv β’
intro t g hg i hi
choose! a g' hg' using IsLocalization.exist_integer_multiples S t g
have h0 : f (β i β t, g' i β’ v i) = 0 := by
apply_fun ((a : R) β’ Β·) at hg
rw [smul_zero, Finset.smul_sum] at hg
rw [map_sum, β hg]
refine Finset.sum_congr rfl fun i hi => ?_
rw [β smul_assoc, β hg' i hi, map_smul, Function.comp_apply, algebraMap_smul]
obtain β¨s, hsβ© := (IsLocalizedModule.eq_zero_iff S f).mp h0
simp_rw [Finset.smul_sum, Submonoid.smul_def, smul_smul] at hs
specialize hv t _ hs i hi
rw [β (IsLocalization.map_units Rβ a).mul_right_eq_zero, β Algebra.smul_def, β hg' i hi]
exact (IsLocalization.map_eq_zero_iff S _ _).2 β¨s, hvβ©
| 1,586 |
import Mathlib.LinearAlgebra.Basis
import Mathlib.Algebra.Module.LocalizedModule
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Localization.Integer
#align_import ring_theory.localization.module from "leanprover-community/mathlib"@"2e59a6de168f95d16b16d217b808a36290398c0a"
open nonZeroDivisors
section Localization
variable {R : Type*} (Rβ : Type*) [CommSemiring R] (S : Submonoid R)
section IsLocalizedModule
section AddCommMonoid
open Submodule
variable [CommSemiring Rβ] [Algebra R Rβ] [hT : IsLocalization S Rβ]
variable {M M' : Type*} [AddCommMonoid M] [Module R M] [Module Rβ M] [IsScalarTower R Rβ M]
[AddCommMonoid M'] [Module R M'] [Module Rβ M'] [IsScalarTower R Rβ M'] (f : M ββ[R] M')
[IsLocalizedModule S f]
theorem span_eq_top_of_isLocalizedModule {v : Set M} (hv : span R v = β€) :
span Rβ (f '' v) = β€ := top_unique fun x _ β¦ by
obtain β¨β¨m, sβ©, hβ© := IsLocalizedModule.surj S f x
rw [Submonoid.smul_def, β algebraMap_smul Rβ, β Units.smul_isUnit (IsLocalization.map_units Rβ s),
eq_comm, β inv_smul_eq_iff] at h
refine h βΈ smul_mem _ _ (span_subset_span R Rβ _ ?_)
rw [β LinearMap.coe_restrictScalars R, β LinearMap.map_span, hv]
exact mem_map_of_mem mem_top
theorem LinearIndependent.of_isLocalizedModule {ΞΉ : Type*} {v : ΞΉ β M}
(hv : LinearIndependent R v) : LinearIndependent Rβ (f β v) := by
rw [linearIndependent_iff'] at hv β’
intro t g hg i hi
choose! a g' hg' using IsLocalization.exist_integer_multiples S t g
have h0 : f (β i β t, g' i β’ v i) = 0 := by
apply_fun ((a : R) β’ Β·) at hg
rw [smul_zero, Finset.smul_sum] at hg
rw [map_sum, β hg]
refine Finset.sum_congr rfl fun i hi => ?_
rw [β smul_assoc, β hg' i hi, map_smul, Function.comp_apply, algebraMap_smul]
obtain β¨s, hsβ© := (IsLocalizedModule.eq_zero_iff S f).mp h0
simp_rw [Finset.smul_sum, Submonoid.smul_def, smul_smul] at hs
specialize hv t _ hs i hi
rw [β (IsLocalization.map_units Rβ a).mul_right_eq_zero, β Algebra.smul_def, β hg' i hi]
exact (IsLocalization.map_eq_zero_iff S _ _).2 β¨s, hvβ©
| Mathlib/RingTheory/Localization/Module.lean | 73 | 76 | theorem LinearIndependent.localization {ΞΉ : Type*} {b : ΞΉ β M} (hli : LinearIndependent R b) :
LinearIndependent Rβ b := by |
have := isLocalizedModule_id S M Rβ
exact hli.of_isLocalizedModule Rβ S .id
| 1,586 |
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.BilinearMap
#align_import linear_algebra.basis.bilinear from "leanprover-community/mathlib"@"87c54600fe3cdc7d32ff5b50873ac724d86aef8d"
namespace LinearMap
variable {ΞΉβ ΞΉβ : Type*}
variable {R Rβ S Sβ M N P Rβ : Type*}
variable {Mβ Nβ Pβ : Type*}
-- Could weaken [CommSemiring Rβ] to [SMulCommClass Rβ Rβ Pβ], but might impact performance
variable [Semiring R] [Semiring S] [Semiring Rβ] [Semiring Sβ] [CommSemiring Rβ]
section AddCommMonoid
variable [AddCommMonoid M] [AddCommMonoid N] [AddCommMonoid P]
variable [AddCommMonoid Mβ] [AddCommMonoid Nβ] [AddCommMonoid Pβ]
variable [Module R M] [Module S N] [Module Rβ P] [Module Sβ P]
variable [Module Rβ Mβ] [Module Rβ Nβ] [Module Rβ Pβ]
variable [SMulCommClass Sβ Rβ P]
variable {Οββ : R β+* Rβ} {Οββ : S β+* Sβ}
variable (bβ : Basis ΞΉβ R M) (bβ : Basis ΞΉβ S N) (bβ' : Basis ΞΉβ Rβ Mβ) (bβ' : Basis ΞΉβ Rβ Nβ)
theorem ext_basis {B B' : M βββ[Οββ] N βββ[Οββ] P} (h : β i j, B (bβ i) (bβ j) = B' (bβ i) (bβ j)) :
B = B' :=
bβ.ext fun i => bβ.ext fun j => h i j
#align linear_map.ext_basis LinearMap.ext_basis
| Mathlib/LinearAlgebra/Basis/Bilinear.lean | 44 | 49 | theorem sum_repr_mul_repr_mulββ {B : M βββ[Οββ] N βββ[Οββ] P} (x y) :
((bβ.repr x).sum fun i xi => (bβ.repr y).sum fun j yj => Οββ xi β’ Οββ yj β’ B (bβ i) (bβ j)) =
B x y := by |
conv_rhs => rw [β bβ.total_repr x, β bβ.total_repr y]
simp_rw [Finsupp.total_apply, Finsupp.sum, map_sumβ, map_sum, LinearMap.map_smulβββ,
LinearMap.map_smulββ]
| 1,587 |
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.BilinearMap
#align_import linear_algebra.basis.bilinear from "leanprover-community/mathlib"@"87c54600fe3cdc7d32ff5b50873ac724d86aef8d"
namespace LinearMap
variable {ΞΉβ ΞΉβ : Type*}
variable {R Rβ S Sβ M N P Rβ : Type*}
variable {Mβ Nβ Pβ : Type*}
-- Could weaken [CommSemiring Rβ] to [SMulCommClass Rβ Rβ Pβ], but might impact performance
variable [Semiring R] [Semiring S] [Semiring Rβ] [Semiring Sβ] [CommSemiring Rβ]
section AddCommMonoid
variable [AddCommMonoid M] [AddCommMonoid N] [AddCommMonoid P]
variable [AddCommMonoid Mβ] [AddCommMonoid Nβ] [AddCommMonoid Pβ]
variable [Module R M] [Module S N] [Module Rβ P] [Module Sβ P]
variable [Module Rβ Mβ] [Module Rβ Nβ] [Module Rβ Pβ]
variable [SMulCommClass Sβ Rβ P]
variable {Οββ : R β+* Rβ} {Οββ : S β+* Sβ}
variable (bβ : Basis ΞΉβ R M) (bβ : Basis ΞΉβ S N) (bβ' : Basis ΞΉβ Rβ Mβ) (bβ' : Basis ΞΉβ Rβ Nβ)
theorem ext_basis {B B' : M βββ[Οββ] N βββ[Οββ] P} (h : β i j, B (bβ i) (bβ j) = B' (bβ i) (bβ j)) :
B = B' :=
bβ.ext fun i => bβ.ext fun j => h i j
#align linear_map.ext_basis LinearMap.ext_basis
theorem sum_repr_mul_repr_mulββ {B : M βββ[Οββ] N βββ[Οββ] P} (x y) :
((bβ.repr x).sum fun i xi => (bβ.repr y).sum fun j yj => Οββ xi β’ Οββ yj β’ B (bβ i) (bβ j)) =
B x y := by
conv_rhs => rw [β bβ.total_repr x, β bβ.total_repr y]
simp_rw [Finsupp.total_apply, Finsupp.sum, map_sumβ, map_sum, LinearMap.map_smulβββ,
LinearMap.map_smulββ]
#align linear_map.sum_repr_mul_repr_mulββ LinearMap.sum_repr_mul_repr_mulββ
| Mathlib/LinearAlgebra/Basis/Bilinear.lean | 55 | 60 | theorem sum_repr_mul_repr_mul {B : Mβ ββ[Rβ] Nβ ββ[Rβ] Pβ} (x y) :
((bβ'.repr x).sum fun i xi => (bβ'.repr y).sum fun j yj => xi β’ yj β’ B (bβ' i) (bβ' j)) =
B x y := by |
conv_rhs => rw [β bβ'.total_repr x, β bβ'.total_repr y]
simp_rw [Finsupp.total_apply, Finsupp.sum, map_sumβ, map_sum, LinearMap.map_smulβ,
LinearMap.map_smul]
| 1,587 |
import Mathlib.Analysis.Normed.Group.Basic
import Mathlib.Topology.Algebra.Module.Basic
import Mathlib.LinearAlgebra.Basis
#align_import analysis.normed_space.linear_isometry from "leanprover-community/mathlib"@"4601791ea62fea875b488dafc4e6dede19e8363f"
open Function Set
variable {R Rβ Rβ Rβ E Eβ Eβ Eβ F π : Type*} [Semiring R] [Semiring Rβ] [Semiring Rβ] [Semiring Rβ]
{Οββ : R β+* Rβ} {Οββ : Rβ β+* R} {Οββ : R β+* Rβ} {Οββ : Rβ β+* R} {Οββ : R β+* Rβ}
{Οββ : Rβ β+* R} {Οββ : Rβ β+* Rβ} {Οββ : Rβ β+* Rβ} {Οββ : Rβ β+* Rβ} {Οββ : Rβ β+* Rβ}
{Οββ : Rβ β+* Rβ} {Οββ : Rβ β+* Rβ} [RingHomInvPair Οββ Οββ] [RingHomInvPair Οββ Οββ]
[RingHomInvPair Οββ Οββ] [RingHomInvPair Οββ Οββ] [RingHomInvPair Οββ Οββ]
[RingHomInvPair Οββ Οββ] [RingHomInvPair Οββ Οββ] [RingHomInvPair Οββ Οββ]
[RingHomInvPair Οββ Οββ] [RingHomInvPair Οββ Οββ] [RingHomInvPair Οββ Οββ]
[RingHomInvPair Οββ Οββ] [RingHomCompTriple Οββ Οββ Οββ] [RingHomCompTriple Οββ Οββ Οββ]
[RingHomCompTriple Οββ Οββ Οββ] [RingHomCompTriple Οββ Οββ Οββ] [RingHomCompTriple Οββ Οββ Οββ]
[RingHomCompTriple Οββ Οββ Οββ] [RingHomCompTriple Οββ Οββ Οββ] [RingHomCompTriple Οββ Οββ Οββ]
[SeminormedAddCommGroup E] [SeminormedAddCommGroup Eβ] [SeminormedAddCommGroup Eβ]
[SeminormedAddCommGroup Eβ] [Module R E] [Module Rβ Eβ] [Module Rβ Eβ] [Module Rβ Eβ]
[NormedAddCommGroup F] [Module R F]
structure LinearIsometry (Οββ : R β+* Rβ) (E Eβ : Type*) [SeminormedAddCommGroup E]
[SeminormedAddCommGroup Eβ] [Module R E] [Module Rβ Eβ] extends E βββ[Οββ] Eβ where
norm_map' : β x, βtoLinearMap xβ = βxβ
#align linear_isometry LinearIsometry
@[inherit_doc]
notation:25 E " βββα΅’[" Οββ:25 "] " Eβ:0 => LinearIsometry Οββ E Eβ
notation:25 E " ββα΅’[" R:25 "] " Eβ:0 => LinearIsometry (RingHom.id R) E Eβ
notation:25 E " ββα΅’β[" R:25 "] " Eβ:0 => LinearIsometry (starRingEnd R) E Eβ
class SemilinearIsometryClass (π : Type*) {R Rβ : outParam Type*} [Semiring R] [Semiring Rβ]
(Οββ : outParam <| R β+* Rβ) (E Eβ : outParam Type*) [SeminormedAddCommGroup E]
[SeminormedAddCommGroup Eβ] [Module R E] [Module Rβ Eβ] [FunLike π E Eβ] extends
SemilinearMapClass π Οββ E Eβ : Prop where
norm_map : β (f : π) (x : E), βf xβ = βxβ
#align semilinear_isometry_class SemilinearIsometryClass
abbrev LinearIsometryClass (π : Type*) (R E Eβ : outParam Type*) [Semiring R]
[SeminormedAddCommGroup E] [SeminormedAddCommGroup Eβ] [Module R E] [Module R Eβ]
[FunLike π E Eβ] :=
SemilinearIsometryClass π (RingHom.id R) E Eβ
#align linear_isometry_class LinearIsometryClass
namespace LinearIsometry
variable (f : E βββα΅’[Οββ] Eβ) (fβ : F βββα΅’[Οββ] Eβ)
theorem toLinearMap_injective : Injective (toLinearMap : (E βββα΅’[Οββ] Eβ) β E βββ[Οββ] Eβ)
| β¨_, _β©, β¨_, _β©, rfl => rfl
#align linear_isometry.to_linear_map_injective LinearIsometry.toLinearMap_injective
@[simp]
theorem toLinearMap_inj {f g : E βββα΅’[Οββ] Eβ} : f.toLinearMap = g.toLinearMap β f = g :=
toLinearMap_injective.eq_iff
#align linear_isometry.to_linear_map_inj LinearIsometry.toLinearMap_inj
instance instFunLike : FunLike (E βββα΅’[Οββ] Eβ) E Eβ where
coe f := f.toFun
coe_injective' _ _ h := toLinearMap_injective (DFunLike.coe_injective h)
instance instSemilinearIsometryClass : SemilinearIsometryClass (E βββα΅’[Οββ] Eβ) Οββ E Eβ where
map_add f := map_add f.toLinearMap
map_smulββ f := map_smulββ f.toLinearMap
norm_map f := f.norm_map'
@[simp]
theorem coe_toLinearMap : βf.toLinearMap = f :=
rfl
#align linear_isometry.coe_to_linear_map LinearIsometry.coe_toLinearMap
@[simp]
theorem coe_mk (f : E βββ[Οββ] Eβ) (hf) : β(mk f hf) = f :=
rfl
#align linear_isometry.coe_mk LinearIsometry.coe_mk
| Mathlib/Analysis/NormedSpace/LinearIsometry.lean | 170 | 172 | theorem coe_injective : @Injective (E βββα΅’[Οββ] Eβ) (E β Eβ) (fun f => f) := by |
rintro β¨_β© β¨_β©
simp
| 1,588 |
import Mathlib.Algebra.Algebra.Tower
import Mathlib.Analysis.LocallyConvex.WithSeminorms
import Mathlib.Topology.Algebra.Module.StrongTopology
import Mathlib.Analysis.NormedSpace.LinearIsometry
import Mathlib.Analysis.NormedSpace.ContinuousLinearMap
import Mathlib.Tactic.SuppressCompilation
#align_import analysis.normed_space.operator_norm from "leanprover-community/mathlib"@"f7ebde7ee0d1505dfccac8644ae12371aa3c1c9f"
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special cases about linear (as opposed to semilinear) maps
variable {π πβ πβ E Eβ F Fβ G Gβ π : Type*}
section SemiNormed
open Metric ContinuousLinearMap
variable [SeminormedAddCommGroup E] [SeminormedAddCommGroup Eβ] [SeminormedAddCommGroup F]
[SeminormedAddCommGroup Fβ] [SeminormedAddCommGroup G] [SeminormedAddCommGroup Gβ]
variable [NontriviallyNormedField π] [NontriviallyNormedField πβ] [NontriviallyNormedField πβ]
[NormedSpace π E] [NormedSpace π Eβ] [NormedSpace πβ F] [NormedSpace π Fβ] [NormedSpace πβ G]
{Οββ : π β+* πβ} {Οββ : πβ β+* πβ} {Οββ : π β+* πβ} [RingHomCompTriple Οββ Οββ Οββ]
variable [FunLike π E F]
| Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean | 54 | 57 | theorem norm_image_of_norm_zero [SemilinearMapClass π Οββ E F] (f : π) (hf : Continuous f) {x : E}
(hx : βxβ = 0) : βf xβ = 0 := by |
rw [β mem_closure_zero_iff_norm, β specializes_iff_mem_closure, β map_zero f] at *
exact hx.map hf
| 1,589 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.