name
stringlengths 3
112
| file
stringlengths 21
116
| statement
stringlengths 17
8.64k
| state
stringlengths 7
205k
| tactic
stringlengths 3
4.55k
| result
stringlengths 7
205k
| id
stringlengths 16
16
|
|---|---|---|---|---|---|---|
tendsto_tsum_div_pow_atTop_integral
|
Mathlib/Analysis/BoxIntegral/UnitPartition.lean
|
theorem _root_.tendsto_tsum_div_pow_atTop_integral (hF : Continuous F) (hs₁ : IsBounded s)
(hs₂ : MeasurableSet s) (hs₃ : volume (frontier s) = 0) :
Tendsto (fun n : ℕ ↦ (∑' x : ↑(s ∩ (n : ℝ)⁻¹ • L), F x) / n ^ card ι)
atTop (nhds (∫ x in s, F x))
|
case intro.intro.intro.intro
ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
F : (ι → ℝ) → ℝ
hF : Continuous F
hs₁ : Bornology.IsBounded s
hs₂ : MeasurableSet s
hs₃ : volume (frontier s) = 0
B : Box ι
hB : hasIntegralVertices B
hs₀ : s ≤ ↑B
ε : ℝ
hε : ε > 0
h₁ : ∃ C, ∀ x ∈ Box.Icc B, ‖s.indicator F x‖ ≤ C
h₂ : ∀ᵐ (x : ι → ℝ), ContinuousAt (s.indicator F) x
r : NNReal → (ι → ℝ) → ↑(Set.Ioi 0)
hr₁ : ∀ (c : NNReal), IntegrationParams.Riemann.RCond (r c)
hr₂ :
∀ (c : NNReal) (π : TaggedPrepartition B),
IntegrationParams.Riemann.MemBaseSet B c (r c) π →
π.IsPartition →
dist (integralSum (s.indicator F) volume.toBoxAdditive.toSMul π)
(∫ (x : ι → ℝ) in ↑B, s.indicator F x ∂volume) ≤
ε / 2
⊢ ∃ N,
∀ n ≥ N,
dist ((∑' (x : ↑(s ∩ (↑n)⁻¹ • ↑(span ℤ (Set.range ⇑(Pi.basisFun ℝ ι))))), F ↑x) / ↑n ^ card ι)
(∫ (x : ι → ℝ) in s, F x) <
ε
|
refine ⟨⌈(r 0 0 : ℝ)⁻¹⌉₊, fun n hn ↦ lt_of_le_of_lt ?_ (half_lt_self_iff.mpr hε)⟩
|
case intro.intro.intro.intro
ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
F : (ι → ℝ) → ℝ
hF : Continuous F
hs₁ : Bornology.IsBounded s
hs₂ : MeasurableSet s
hs₃ : volume (frontier s) = 0
B : Box ι
hB : hasIntegralVertices B
hs₀ : s ≤ ↑B
ε : ℝ
hε : ε > 0
h₁ : ∃ C, ∀ x ∈ Box.Icc B, ‖s.indicator F x‖ ≤ C
h₂ : ∀ᵐ (x : ι → ℝ), ContinuousAt (s.indicator F) x
r : NNReal → (ι → ℝ) → ↑(Set.Ioi 0)
hr₁ : ∀ (c : NNReal), IntegrationParams.Riemann.RCond (r c)
hr₂ :
∀ (c : NNReal) (π : TaggedPrepartition B),
IntegrationParams.Riemann.MemBaseSet B c (r c) π →
π.IsPartition →
dist (integralSum (s.indicator F) volume.toBoxAdditive.toSMul π)
(∫ (x : ι → ℝ) in ↑B, s.indicator F x ∂volume) ≤
ε / 2
n : ℕ
hn : n ≥ ⌈(↑(r 0 0))⁻¹⌉₊
⊢ dist ((∑' (x : ↑(s ∩ (↑n)⁻¹ • ↑(span ℤ (Set.range ⇑(Pi.basisFun ℝ ι))))), F ↑x) / ↑n ^ card ι)
(∫ (x : ι → ℝ) in s, F x) ≤
ε / 2
|
e99fafdae745475e
|
List.partition_eq_filter_filter
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
|
theorem partition_eq_filter_filter (p : α → Bool) (l : List α) :
partition p l = (filter p l, filter (not ∘ p) l)
|
α : Type u_1
p : α → Bool
l : List α
⊢ partition p l = (filter p l, filter (not ∘ p) l)
|
simp [partition, aux]
|
no goals
|
1b206b7b210bcfe8
|
Num.ofNat'_eq
|
Mathlib/Data/Num/Lemmas.lean
|
theorem ofNat'_eq : ∀ n, Num.ofNat' n = n :=
Nat.binaryRec (by simp) fun b n IH => by tauto
|
⊢ ofNat' 0 = ↑0
|
simp
|
no goals
|
a8dda501c3f53f4e
|
Nat.primeFactors_pow_succ
|
Mathlib/Data/Nat/PrimeFin.lean
|
lemma primeFactors_pow_succ (n k : ℕ) : (n ^ (k + 1)).primeFactors = n.primeFactors
|
n k : ℕ
⊢ (n ^ (k + 1)).primeFactors = n.primeFactors
|
rcases eq_or_ne n 0 with (rfl | hn)
|
case inl
k : ℕ
⊢ (0 ^ (k + 1)).primeFactors = primeFactors 0
case inr
n k : ℕ
hn : n ≠ 0
⊢ (n ^ (k + 1)).primeFactors = n.primeFactors
|
1853618c5cac81f8
|
WeierstrassCurve.ΨSq_four
|
Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
|
@[simp]
lemma ΨSq_four : W.ΨSq 4 = W.preΨ₄ ^ 2 * W.Ψ₂Sq
|
R : Type r
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ Even 4
|
decide
|
no goals
|
7ca1b640087f381b
|
Finset.Colex.trans_aux
|
Mathlib/Combinatorics/Colex.lean
|
private lemma trans_aux (hst : toColex s ≤ toColex t) (htu : toColex t ≤ toColex u)
(has : a ∈ s) (hat : a ∉ t) : ∃ b, b ∈ u ∧ b ∉ s ∧ a ≤ b
|
α : Type u_1
inst✝ : PartialOrder α
s t u : Finset α
a : α
hst : { ofColex := s } ≤ { ofColex := t }
htu : { ofColex := t } ≤ { ofColex := u }
has : a ∈ s
hat : a ∉ t
s' : Finset α := filter (fun b => b ∉ t ∧ a ≤ b) s
b : α
hb : b ∈ s ∧ b ∉ t ∧ a ≤ b
hbmax : ∀ x ∈ s, x ∉ t → a ≤ x → ¬b < x
⊢ ∃ b ∈ u, b ∉ s ∧ a ≤ b
|
have ⟨c, hct, hcs, hbc⟩ := hst hb.1 hb.2.1
|
α : Type u_1
inst✝ : PartialOrder α
s t u : Finset α
a : α
hst : { ofColex := s } ≤ { ofColex := t }
htu : { ofColex := t } ≤ { ofColex := u }
has : a ∈ s
hat : a ∉ t
s' : Finset α := filter (fun b => b ∉ t ∧ a ≤ b) s
b : α
hb : b ∈ s ∧ b ∉ t ∧ a ≤ b
hbmax : ∀ x ∈ s, x ∉ t → a ≤ x → ¬b < x
c : α
hct : c ∈ { ofColex := t }.ofColex
hcs : c ∉ { ofColex := s }.ofColex
hbc : b ≤ c
⊢ ∃ b ∈ u, b ∉ s ∧ a ≤ b
|
d44eef7b38eb8d38
|
Rat.uniformSpace_eq
|
Mathlib/Topology/UniformSpace/CompareReals.lean
|
theorem Rat.uniformSpace_eq :
(AbsoluteValue.abs : AbsoluteValue ℚ ℚ).uniformSpace = PseudoMetricSpace.toUniformSpace
|
⊢ AbsoluteValue.abs.uniformSpace = PseudoMetricSpace.toUniformSpace
|
ext s
|
case h.h
s : Set (ℚ × ℚ)
⊢ s ∈ uniformity ℚ ↔ s ∈ uniformity ℚ
|
860aee39be103d1d
|
MeasureTheory.analyticSet_empty
|
Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
|
theorem analyticSet_empty : AnalyticSet (∅ : Set α)
|
α : Type u_1
inst✝ : TopologicalSpace α
⊢ AnalyticSet ∅
|
rw [AnalyticSet]
|
α : Type u_1
inst✝ : TopologicalSpace α
⊢ ∅ = ∅ ∨ ∃ f, Continuous f ∧ range f = ∅
|
96d6590387ca3fc0
|
TopologicalSpace.IsOpenCover.isOpenMap_iff_restrictPreimage
|
Mathlib/Topology/LocalAtTarget.lean
|
theorem isOpenMap_iff_restrictPreimage :
IsOpenMap f ↔ ∀ i, IsOpenMap ((U i).1.restrictPreimage f)
|
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
ι : Type u_3
U : ι → Opens β
hU : IsOpenCover U
⊢ IsOpenMap f ↔ ∀ (i : ι), IsOpenMap ((U i).carrier.restrictPreimage f)
|
refine ⟨fun h i ↦ h.restrictPreimage _, fun H s hs ↦ ?_⟩
|
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
ι : Type u_3
U : ι → Opens β
hU : IsOpenCover U
H : ∀ (i : ι), IsOpenMap ((U i).carrier.restrictPreimage f)
s : Set α
hs : IsOpen s
⊢ IsOpen (f '' s)
|
344d9e2126901f20
|
uniformCauchySeqOn_ball_of_fderiv
|
Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
|
theorem uniformCauchySeqOn_ball_of_fderiv {r : ℝ} (hf' : UniformCauchySeqOn f' l (Metric.ball x r))
(hf : ∀ n : ι, ∀ y : E, y ∈ Metric.ball x r → HasFDerivAt (f n) (f' n y) y)
(hfg : Cauchy (map (fun n => f n x) l)) : UniformCauchySeqOn f l (Metric.ball x r)
|
case inr
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : IsRCLikeNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : ι → E → G
f' : ι → E → E →L[𝕜] G
x : E
r : ℝ
hf : ∀ (n : ι), ∀ y ∈ Metric.ball x r, HasFDerivAt (f n) (f' n y) y
hfg : Cauchy (map (fun n => f n x) l)
this✝¹ : RCLike 𝕜 := IsRCLikeNormedField.rclike 𝕜
hf' : TendstoUniformlyOn (fun n z => f' n.1 z - f' n.2 z) 0 (l ×ˢ l) (Metric.ball x r)
this✝ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
this : l.NeBot
hr : 0 < r
⊢ TendstoUniformlyOn (fun n z => f n.1 z - f n.2 z - (f n.1 x - f n.2 x)) 0 (l ×ˢ l) (Metric.ball x r) ∧
TendstoUniformlyOn (fun n x_1 => f n.1 x - f n.2 x) 0 (l ×ˢ l) (Metric.ball x r)
|
constructor
|
case inr.left
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : IsRCLikeNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : ι → E → G
f' : ι → E → E →L[𝕜] G
x : E
r : ℝ
hf : ∀ (n : ι), ∀ y ∈ Metric.ball x r, HasFDerivAt (f n) (f' n y) y
hfg : Cauchy (map (fun n => f n x) l)
this✝¹ : RCLike 𝕜 := IsRCLikeNormedField.rclike 𝕜
hf' : TendstoUniformlyOn (fun n z => f' n.1 z - f' n.2 z) 0 (l ×ˢ l) (Metric.ball x r)
this✝ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
this : l.NeBot
hr : 0 < r
⊢ TendstoUniformlyOn (fun n z => f n.1 z - f n.2 z - (f n.1 x - f n.2 x)) 0 (l ×ˢ l) (Metric.ball x r)
case inr.right
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : IsRCLikeNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : ι → E → G
f' : ι → E → E →L[𝕜] G
x : E
r : ℝ
hf : ∀ (n : ι), ∀ y ∈ Metric.ball x r, HasFDerivAt (f n) (f' n y) y
hfg : Cauchy (map (fun n => f n x) l)
this✝¹ : RCLike 𝕜 := IsRCLikeNormedField.rclike 𝕜
hf' : TendstoUniformlyOn (fun n z => f' n.1 z - f' n.2 z) 0 (l ×ˢ l) (Metric.ball x r)
this✝ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
this : l.NeBot
hr : 0 < r
⊢ TendstoUniformlyOn (fun n x_1 => f n.1 x - f n.2 x) 0 (l ×ˢ l) (Metric.ball x r)
|
982ef3c3832b9fcd
|
MultilinearMap.norm_image_sub_le_of_bound
|
Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
|
theorem norm_image_sub_le_of_bound (f : MultilinearMap 𝕜 E G)
{C : ℝ} (hC : 0 ≤ C) (H : ∀ m, ‖f m‖ ≤ C * ∏ i, ‖m i‖) (m₁ m₂ : ∀ i, E i) :
‖f m₁ - f m₂‖ ≤ C * Fintype.card ι * max ‖m₁‖ ‖m₂‖ ^ (Fintype.card ι - 1) * ‖m₁ - m₂‖
|
case h.h
𝕜 : Type u
ι : Type v
E : ι → Type wE
G : Type wG
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝³ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝² : SeminormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : Fintype ι
f : MultilinearMap 𝕜 E G
C : ℝ
hC : 0 ≤ C
H : ∀ (m : (i : ι) → E i), ‖f m‖ ≤ C * ∏ i : ι, ‖m i‖
m₁ m₂ : (i : ι) → E i
A :
∀ (i : ι),
(∏ j : ι, if j = i then ‖m₁ i - m₂ i‖ else ‖m₁ j‖ ⊔ ‖m₂ j‖) ≤ ‖m₁ - m₂‖ * (‖m₁‖ ⊔ ‖m₂‖) ^ (Fintype.card ι - 1)
i✝ : ι
a✝ : i✝ ∈ univ
⊢ (∏ j : ι, if j = i✝ then ‖m₁ i✝ - m₂ i✝‖ else ‖m₁ j‖ ⊔ ‖m₂ j‖) ≤ ‖m₁ - m₂‖ * (‖m₁‖ ⊔ ‖m₂‖) ^ (Fintype.card ι - 1)
|
apply A
|
no goals
|
f3950b21519cddc8
|
rexp_neg_quadratic_isLittleO_rpow_atTop
|
Mathlib/Analysis/SpecialFunctions/Gaussian/PoissonSummation.lean
|
lemma rexp_neg_quadratic_isLittleO_rpow_atTop {a : ℝ} (ha : a < 0) (b s : ℝ) :
(fun x ↦ rexp (a * x ^ 2 + b * x)) =o[atTop] (· ^ s)
|
a : ℝ
ha : a < 0
b s : ℝ
⊢ Tendsto (fun x => -x - (a * x ^ 2 + b * x)) atTop atTop
|
have : (fun x ↦ -x - (a * x ^ 2 + b * x)) = fun x ↦ x * (-a * x - (b + 1)) := by
ext1 x; ring_nf
|
a : ℝ
ha : a < 0
b s : ℝ
this : (fun x => -x - (a * x ^ 2 + b * x)) = fun x => x * (-a * x - (b + 1))
⊢ Tendsto (fun x => -x - (a * x ^ 2 + b * x)) atTop atTop
|
729446a2306c563c
|
ZetaAsymptotics.term_one
|
Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean
|
lemma term_one {n : ℕ} (hn : 0 < n) :
term n 1 = (log (n + 1) - log n) - 1 / (n + 1)
|
case e_a.e_a
n : ℕ
hn : 0 < n
hv : ∀ x ∈ uIcc (↑n) (↑n + 1), 0 < x
x : ℝ
hx : x ∈ uIcc (↑n) (↑n + 1)
⊢ 1 / x ^ 2 = x ^ (-2)
|
rw [rpow_neg, one_div, ← Nat.cast_two (R := ℝ), rpow_natCast]
|
case e_a.e_a.hx
n : ℕ
hn : 0 < n
hv : ∀ x ∈ uIcc (↑n) (↑n + 1), 0 < x
x : ℝ
hx : x ∈ uIcc (↑n) (↑n + 1)
⊢ 0 ≤ x
|
b352dfbb4af79ad9
|
BitVec.mul_eq_and
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem mul_eq_and {a b : BitVec 1} : a * b = a &&& b
|
a b : BitVec 1
ha : a = 0 ∨ a = 1
hb : b = 0 ∨ b = 1
⊢ a * b = a &&& b
|
rcases ha with h | h <;> (rcases hb with h' | h' <;> (simp [h, h']))
|
no goals
|
65f931d1a2379105
|
Set.chainHeight_image
|
Mathlib/Order/Height.lean
|
theorem chainHeight_image (f : α → β) (hf : ∀ {x y}, x < y ↔ f x < f y) (s : Set α) :
(f '' s).chainHeight = s.chainHeight
|
case a.cons
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
f : α → β
hf : ∀ {x y : α}, x < y ↔ f x < f y
s : Set α
x : β
xs : List β
hx : xs ∈ (f '' s).subchain → ∃ l' ∈ s.subchain, map f l' = xs
h : x ∈ f '' s ∧ xs ∈ (f '' s).subchain ∧ ∀ b ∈ xs.head?, x < b
⊢ ∃ l' ∈ s.subchain, map f l' = x :: xs
|
obtain ⟨⟨x, hx', rfl⟩, h₁, h₂⟩ := h
|
case a.cons.intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
f : α → β
hf : ∀ {x y : α}, x < y ↔ f x < f y
s : Set α
xs : List β
hx : xs ∈ (f '' s).subchain → ∃ l' ∈ s.subchain, map f l' = xs
x : α
hx' : x ∈ s
h₁ : xs ∈ (f '' s).subchain
h₂ : ∀ b ∈ xs.head?, f x < b
⊢ ∃ l' ∈ s.subchain, map f l' = f x :: xs
|
0c10e60540ca25b5
|
Real.ceil_logb_natCast
|
Mathlib/Analysis/SpecialFunctions/Log/Base.lean
|
theorem ceil_logb_natCast {b : ℕ} {r : ℝ} (hr : 0 ≤ r) :
⌈logb b r⌉ = Int.clog b r
|
case pos.a
b : ℕ
r : ℝ
hr✝ : 0 ≤ r
hr : 0 < r
hb : 1 < b
hb1' : 1 < ↑b
⊢ ↑b ^ logb (↑b) r ≤ ↑b ^ ↑⌈logb (↑b) r⌉
|
exact rpow_le_rpow_of_exponent_le hb1'.le (Int.le_ceil _)
|
no goals
|
f353f45d6f6f2c29
|
LieAlgebra.lie_mem_genWeightSpace_of_mem_genWeightSpace
|
Mathlib/Algebra/Lie/Weights/Cartan.lean
|
theorem lie_mem_genWeightSpace_of_mem_genWeightSpace {χ₁ χ₂ : H → R} {x : L} {m : M}
(hx : x ∈ rootSpace H χ₁) (hm : m ∈ genWeightSpace M χ₂) :
⁅x, m⁆ ∈ genWeightSpace M (χ₁ + χ₂)
|
R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieRing.IsNilpotent ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : ↥H → R
x : L
m : M
y : ↥H
hx : x ∈ genWeightSpaceOf L (χ₁ y) y
hm : m ∈ genWeightSpaceOf M (χ₂ y) y
⊢ ⁅x, m⁆ ∈ genWeightSpaceOf M ((χ₁ + χ₂) y) y
|
exact lie_mem_maxGenEigenspace_toEnd hx hm
|
no goals
|
4c37ae78eab20823
|
CoalgebraCat.MonoidalCategoryAux.counit_tensorObj_tensorObj_right
|
Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean
|
theorem counit_tensorObj_tensorObj_right :
Coalgebra.counit (R := R)
(A := (CoalgebraCat.of R M ⊗ (CoalgebraCat.of R N ⊗ CoalgebraCat.of R P) : CoalgebraCat R))
= Coalgebra.counit (A := M ⊗[R] (N ⊗[R] P))
|
R : Type u
inst✝⁹ : CommRing R
M N P : Type u
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup N
inst✝⁶ : AddCommGroup P
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Coalgebra R M
inst✝¹ : Coalgebra R N
inst✝ : Coalgebra R P
⊢ CoalgebraStruct.counit = CoalgebraStruct.counit
|
ext
|
case h
R : Type u
inst✝⁹ : CommRing R
M N P : Type u
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup N
inst✝⁶ : AddCommGroup P
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Coalgebra R M
inst✝¹ : Coalgebra R N
inst✝ : Coalgebra R P
x✝ : ↑(of R M ⊗ of R N ⊗ of R P).toModuleCat
⊢ CoalgebraStruct.counit x✝ = CoalgebraStruct.counit x✝
|
0c920a2c3480b08c
|
Polynomial.derivative_mul
|
Mathlib/Algebra/Polynomial/Derivative.lean
|
theorem derivative_mul {f g : R[X]} : derivative (f * g) = derivative f * g + f * derivative g
|
case h_monomial.h_monomial.succ.succ
R : Type u
inst✝ : Semiring R
a b : R
m n : ℕ
⊢ (monomial (m + 1 + n)) (a * (b * ↑(m + 1))) + (monomial (m + 1 + n)) (a * (b * ↑(n + 1))) =
(monomial (m + (n + 1))) (a * (b * ↑(m + 1))) + (monomial (m + 1 + n)) (a * (b * ↑(n + 1)))
|
rw [add_assoc, add_comm n 1]
|
no goals
|
a66065c70ef80a14
|
controlled_prod_of_mem_closure
|
Mathlib/Analysis/Normed/Group/Continuity.lean
|
theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s : Set E)) {b : ℕ → ℝ}
(b_pos : ∀ n, 0 < b n) :
∃ v : ℕ → E,
Tendsto (fun n => ∏ i ∈ range (n + 1), v i) atTop (𝓝 a) ∧
(∀ n, v n ∈ s) ∧ ‖v 0 / a‖ < b 0 ∧ ∀ n, 0 < n → ‖v n‖ < b n
|
case intro.intro.intro
E : Type u_5
inst✝ : SeminormedCommGroup E
a : E
s : Subgroup E
hg : a ∈ closure ↑s
b : ℕ → ℝ
b_pos : ∀ (n : ℕ), 0 < b n
u : ℕ → E
u_in : ∀ (n : ℕ), u n ∈ s
lim_u : Tendsto u atTop (𝓝 a)
n₀ : ℕ
hn₀ : ∀ n ≥ n₀, ‖u n / a‖ < b 0
z : ℕ → E := fun n => u (n + n₀)
⊢ ∃ v,
Tendsto (fun n => ∏ i ∈ range (n + 1), v i) atTop (𝓝 a) ∧
(∀ (n : ℕ), v n ∈ s) ∧ ‖v 0 / a‖ < b 0 ∧ ∀ (n : ℕ), 0 < n → ‖v n‖ < b n
|
have lim_z : Tendsto z atTop (𝓝 a) := lim_u.comp (tendsto_add_atTop_nat n₀)
|
case intro.intro.intro
E : Type u_5
inst✝ : SeminormedCommGroup E
a : E
s : Subgroup E
hg : a ∈ closure ↑s
b : ℕ → ℝ
b_pos : ∀ (n : ℕ), 0 < b n
u : ℕ → E
u_in : ∀ (n : ℕ), u n ∈ s
lim_u : Tendsto u atTop (𝓝 a)
n₀ : ℕ
hn₀ : ∀ n ≥ n₀, ‖u n / a‖ < b 0
z : ℕ → E := fun n => u (n + n₀)
lim_z : Tendsto z atTop (𝓝 a)
⊢ ∃ v,
Tendsto (fun n => ∏ i ∈ range (n + 1), v i) atTop (𝓝 a) ∧
(∀ (n : ℕ), v n ∈ s) ∧ ‖v 0 / a‖ < b 0 ∧ ∀ (n : ℕ), 0 < n → ‖v n‖ < b n
|
647a783958e68b9a
|
List.eraseIdx_modify_of_eq
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Nat/Modify.lean
|
theorem eraseIdx_modify_of_eq (f : α → α) (n) (l : List α) :
(modify f n l).eraseIdx n = l.eraseIdx n
|
case h
α : Type u_1
f : α → α
n : Nat
l : List α
⊢ ∀ (i : Nat) (h₁ : i < ((modify f n l).eraseIdx n).length) (h₂ : i < (l.eraseIdx n).length),
((modify f n l).eraseIdx n)[i] = (l.eraseIdx n)[i]
|
intro m h₁ h₂
|
case h
α : Type u_1
f : α → α
n : Nat
l : List α
m : Nat
h₁ : m < ((modify f n l).eraseIdx n).length
h₂ : m < (l.eraseIdx n).length
⊢ ((modify f n l).eraseIdx n)[m] = (l.eraseIdx n)[m]
|
0e1ed36136351a9f
|
MeasureTheory.ae_nonneg_of_forall_setIntegral_nonneg
|
Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
|
theorem ae_nonneg_of_forall_setIntegral_nonneg (hf : Integrable f μ)
(hf_zero : ∀ s, MeasurableSet s → μ s < ∞ → 0 ≤ ∫ x in s, f x ∂μ) : 0 ≤ᵐ[μ] f
|
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable f μ
hf_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
⊢ 0 ≤ᶠ[ae μ] f
|
simp_rw [EventuallyLE, Pi.zero_apply]
|
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable f μ
hf_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
⊢ ∀ᵐ (x : α) ∂μ, 0 ≤ f x
|
d52a385303ec1354
|
ProbabilityTheory.lintegral_mul_eq_lintegral_mul_lintegral_of_independent_measurableSpace
|
Mathlib/Probability/Integration.lean
|
theorem lintegral_mul_eq_lintegral_mul_lintegral_of_independent_measurableSpace
{Mf Mg mΩ : MeasurableSpace Ω} {μ : Measure Ω} (hMf : Mf ≤ mΩ) (hMg : Mg ≤ mΩ)
(h_ind : Indep Mf Mg μ) (h_meas_f : Measurable[Mf] f) (h_meas_g : Measurable[Mg] g) :
∫⁻ ω, f ω * g ω ∂μ = (∫⁻ ω, f ω ∂μ) * ∫⁻ ω, g ω ∂μ
|
case h_add
Ω : Type u_1
f : Ω → ℝ≥0∞
Mf Mg mΩ : MeasurableSpace Ω
μ : Measure Ω
hMf : Mf ≤ mΩ
hMg : Mg ≤ mΩ
h_ind : Indep Mf Mg μ
h_meas_f : Measurable f
h_measM_f : Measurable f
f' g : Ω → ℝ≥0∞
a✝¹ : Disjoint (Function.support f') (Function.support g)
h_measMg_f' : Measurable f'
a✝ : Measurable g
h_ind_f' : ∫⁻ (ω : Ω), f ω * f' ω ∂μ = (∫⁻ (ω : Ω), f ω ∂μ) * ∫⁻ (ω : Ω), f' ω ∂μ
h_ind_g' : ∫⁻ (ω : Ω), f ω * g ω ∂μ = (∫⁻ (ω : Ω), f ω ∂μ) * ∫⁻ (ω : Ω), g ω ∂μ
h_measM_f' : Measurable f'
⊢ ∫⁻ (ω : Ω), f ω * f' ω + f ω * g ω ∂μ = (∫⁻ (ω : Ω), f ω ∂μ) * ∫⁻ (ω : Ω), f' ω + g ω ∂μ
|
rw [lintegral_add_left h_measM_f', lintegral_add_left (h_measM_f.mul h_measM_f'), left_distrib,
h_ind_f', h_ind_g']
|
no goals
|
bad3bf0b684e4cf2
|
PNat.factorMultiset_le_iff'
|
Mathlib/Data/PNat/Factors.lean
|
theorem factorMultiset_le_iff' {m : ℕ+} {v : PrimeMultiset} :
factorMultiset m ≤ v ↔ m ∣ v.prod
|
m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v.prod.factorMultiset ↔ m ∣ v.prod := factorMultiset_le_iff
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
|
rw [v.factorMultiset_prod] at h
|
m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v ↔ m ∣ v.prod
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
|
38271c385288e7e9
|
Polynomial.Gal.splits_in_splittingField_of_comp
|
Mathlib/FieldTheory/PolynomialGaloisGroup.lean
|
theorem splits_in_splittingField_of_comp (hq : q.natDegree ≠ 0) :
p.Splits (algebraMap F (p.comp q).SplittingField)
|
case neg.intro
F : Type u_1
inst✝ : Field F
p q : F[X]
hq : q.natDegree ≠ 0
P : F[X] → Prop := fun r => Splits (algebraMap F (r.comp q).SplittingField) r
r : F[X]
hr : Irreducible r
hr' : ¬r.natDegree = 0
x : (r.comp q).SplittingField
hx : eval₂ (algebraMap F (r.comp q).SplittingField) x (r.comp q) = 0
⊢ P r
|
rw [← aeval_def, aeval_comp] at hx
|
case neg.intro
F : Type u_1
inst✝ : Field F
p q : F[X]
hq : q.natDegree ≠ 0
P : F[X] → Prop := fun r => Splits (algebraMap F (r.comp q).SplittingField) r
r : F[X]
hr : Irreducible r
hr' : ¬r.natDegree = 0
x : (r.comp q).SplittingField
hx : (aeval ((aeval x) q)) r = 0
⊢ P r
|
781c423315763045
|
Ordering.isGT_swap
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Ord.lean
|
theorem isGT_swap {o : Ordering} : o.swap.isGT = o.isLT
|
o : Ordering
⊢ o.swap.isGT = o.isLT
|
cases o <;> simp
|
no goals
|
46ace378b3355311
|
List.chain'_of_mem_splitByLoop
|
Mathlib/Data/List/SplitBy.lean
|
theorem chain'_of_mem_splitByLoop {r : α → α → Bool} {l : List α} {a : α} {g : List α}
(hga : ∀ b ∈ g.head?, r b a) (hg : g.Chain' fun y x ↦ r x y)
(h : m ∈ splitBy.loop r l a g []) : m.Chain' fun x y ↦ r x y
|
case cons.h_2.inl
α : Type u_1
r : α → α → Bool
b : α
l : List α
a : α
g : List α
hga : ∀ (b : α), b ∈ g.head? → r b a = true
hg : Chain' (fun y x => r x y = true) g
x✝ : Bool
heq✝ : r a b = false
IH :
∀ {a_1 : α} {g_1 : List α},
(∀ (b : α), b ∈ g_1.head? → r b a_1 = true) →
Chain' (fun y x => r x y = true) g_1 →
g.reverse ++ [a] ∈ splitBy.loop r l a_1 g_1 [] → Chain' (fun x y => r x y = true) (g.reverse ++ [a])
⊢ Chain' (fun y x => r x y = true) ([a] ++ g)
|
exact chain'_cons'.2 ⟨hga, hg⟩
|
no goals
|
f1b83979d934bdc8
|
iteratedFDeriv_comp
|
Mathlib/Analysis/Calculus/ContDiff/Basic.lean
|
theorem iteratedFDeriv_comp (hg : ContDiffAt 𝕜 n g (f x)) (hf : ContDiffAt 𝕜 n f x)
{i : ℕ} (hi : i ≤ n) :
iteratedFDeriv 𝕜 i (g ∘ f) x =
(ftaylorSeries 𝕜 g (f x)).taylorComp (ftaylorSeries 𝕜 f x) i
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type uF
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type uG
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E → F
g : F → G
x : E
n : WithTop ℕ∞
hg : ContDiffAt 𝕜 n g (f x)
hf : ContDiffAt 𝕜 n f x
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDeriv 𝕜 i (g ∘ f) x = (ftaylorSeries 𝕜 g (f x)).taylorComp (ftaylorSeries 𝕜 f x) i
|
simp only [← iteratedFDerivWithin_univ, ← ftaylorSeriesWithin_univ]
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type uF
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type uG
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E → F
g : F → G
x : E
n : WithTop ℕ∞
hg : ContDiffAt 𝕜 n g (f x)
hf : ContDiffAt 𝕜 n f x
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDerivWithin 𝕜 i (g ∘ f) univ x =
(ftaylorSeriesWithin 𝕜 g univ (f x)).taylorComp (ftaylorSeriesWithin 𝕜 f univ x) i
|
ec1777b9bb089ded
|
not_summable_of_antitone_of_neg
|
Mathlib/Analysis/SumOverResidueClass.lean
|
/-- If `f : ℕ → ℝ` is decreasing and has a negative term, then `f` is not summable. -/
lemma not_summable_of_antitone_of_neg {f : ℕ → ℝ} (hf : Antitone f) {n : ℕ} (hn : f n < 0) :
¬ Summable f
|
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
⊢ ¬Summable f
|
intro hs
|
f : ℕ → ℝ
hf : Antitone f
n : ℕ
hn : f n < 0
hs : Summable f
⊢ False
|
bd42ef63684ae4ee
|
Real.Icc_mem_vitaliFamily_at_right
|
Mathlib/MeasureTheory/Covering/OneDim.lean
|
theorem Icc_mem_vitaliFamily_at_right {x y : ℝ} (hxy : x < y) :
Icc x y ∈ (vitaliFamily (volume : Measure ℝ) 1).setsAt x
|
x y : ℝ
hxy : x < y
⊢ dist x ((x + y) / 2) ≤ 1 * ((y - x) / 2)
|
rw [dist_comm, Real.dist_eq, abs_of_nonneg] <;> linarith
|
no goals
|
f44bb90059fd7aa2
|
Polynomial.monomial_pow
|
Mathlib/Algebra/Polynomial/Basic.lean
|
theorem monomial_pow (n : ℕ) (r : R) (k : ℕ) : monomial n r ^ k = monomial (n * k) (r ^ k)
|
case zero
R : Type u
inst✝ : Semiring R
n : ℕ
r : R
⊢ (monomial n) r ^ 0 = (monomial (n * 0)) (r ^ 0)
|
simp [pow_zero, monomial_zero_one]
|
no goals
|
bbe2b6146920ba11
|
LawfulFunctor.map_inj_right_of_nonempty
|
Mathlib/.lake/packages/batteries/Batteries/Control/Monad.lean
|
theorem _root_.LawfulFunctor.map_inj_right_of_nonempty [Functor f] [LawfulFunctor f] [Nonempty α]
{g : α → β} (h : ∀ {x y : α}, g x = g y → x = y) {x y : f α} :
g <$> x = g <$> y ↔ x = y
|
case mpr
f : Type u_1 → Type u_2
α β : Type u_1
inst✝² : Functor f
inst✝¹ : LawfulFunctor f
inst✝ : Nonempty α
g : α → β
h : ∀ {x y : α}, g x = g y → x = y
x y : f α
⊢ x = y → g <$> x = g <$> y
|
intro h'
|
case mpr
f : Type u_1 → Type u_2
α β : Type u_1
inst✝² : Functor f
inst✝¹ : LawfulFunctor f
inst✝ : Nonempty α
g : α → β
h : ∀ {x y : α}, g x = g y → x = y
x y : f α
h' : x = y
⊢ g <$> x = g <$> y
|
9ff9346398dc10b4
|
List.idxOf_mem_indexesOf
|
Mathlib/.lake/packages/batteries/Batteries/Data/List/Lemmas.lean
|
theorem idxOf_mem_indexesOf [BEq α] [LawfulBEq α] {xs : List α} (m : x ∈ xs) :
xs.idxOf x ∈ xs.indexesOf x
|
case cons
α : Type u_1
x : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
h : α
t : List α
ih : x ∈ t → idxOf x t ∈ indexesOf x t
m : x ∈ h :: t
⊢ idxOf x (h :: t) ∈ indexesOf x (h :: t)
|
simp [idxOf_cons, indexesOf_cons, cond_eq_if]
|
case cons
α : Type u_1
x : α
inst✝¹ : BEq α
inst✝ : LawfulBEq α
h : α
t : List α
ih : x ∈ t → idxOf x t ∈ indexesOf x t
m : x ∈ h :: t
⊢ (if (h == x) = true then 0 else idxOf x t + 1) ∈
if (h == x) = true then 0 :: map (fun x => x + 1) (indexesOf x t) else map (fun x => x + 1) (indexesOf x t)
|
e8cb18c97ac0bdad
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.reduce_postcondition
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.lean
|
theorem reduce_postcondition {n : Nat} (c : DefaultClause n) (assignment : Array Assignment) :
(reduce c assignment = reducedToEmpty → Incompatible (PosFin n) c assignment) ∧
(∀ l : Literal (PosFin n), reduce c assignment = reducedToUnit l → ∀ (p : (PosFin n) → Bool), p ⊨ assignment → p ⊨ c → p ⊨ l)
|
case intro.right.intro.inr.intro
n : Nat
c : DefaultClause n
assignment : Array Assignment
c_arr : Array (Literal (PosFin n)) := List.toArray c.clause
c_clause_rw : c.clause = c_arr.toList
motive : Nat → ReduceResult (PosFin n) → Prop := ReducePostconditionInductionMotive c_arr assignment
h_base : motive 0 reducedToEmpty
h_inductive :
∀ (idx : Fin c_arr.size) (res : ReduceResult (PosFin n)),
motive (↑idx) res → motive (↑idx + 1) (reduce_fold_fn assignment res c_arr[idx])
h1 :
Array.foldl (reduce_fold_fn assignment) reducedToEmpty c_arr = reducedToEmpty →
∀ (p : PosFin n → Bool), (∀ (i : Fin c_arr.size), ↑i < c_arr.size → ¬(p ⊨ c_arr[i])) ∨ ¬(p ⊨ assignment)
h2 :
∀ (l : Literal (PosFin n)),
Array.foldl (reduce_fold_fn assignment) reducedToEmpty c_arr = reducedToUnit l →
∀ (p : PosFin n → Bool), p ⊨ assignment → (∃ i, ↑i < c_arr.size ∧ (p ⊨ c_arr[i])) → p ⊨ l
l : Literal (PosFin n)
hl : Array.foldl (reduce_fold_fn assignment) reducedToEmpty c_arr = reducedToUnit l
p : PosFin n → Bool
hp : p ⊨ assignment
i : PosFin n
pc1 : (i, true) ∈ c.clause
pc2 : decide (p i = true) = true
⊢ ∃ i, ↑i < c_arr.size ∧ (p ⊨ c_arr[i])
|
rw [c_clause_rw] at pc1
|
case intro.right.intro.inr.intro
n : Nat
c : DefaultClause n
assignment : Array Assignment
c_arr : Array (Literal (PosFin n)) := List.toArray c.clause
c_clause_rw : c.clause = c_arr.toList
motive : Nat → ReduceResult (PosFin n) → Prop := ReducePostconditionInductionMotive c_arr assignment
h_base : motive 0 reducedToEmpty
h_inductive :
∀ (idx : Fin c_arr.size) (res : ReduceResult (PosFin n)),
motive (↑idx) res → motive (↑idx + 1) (reduce_fold_fn assignment res c_arr[idx])
h1 :
Array.foldl (reduce_fold_fn assignment) reducedToEmpty c_arr = reducedToEmpty →
∀ (p : PosFin n → Bool), (∀ (i : Fin c_arr.size), ↑i < c_arr.size → ¬(p ⊨ c_arr[i])) ∨ ¬(p ⊨ assignment)
h2 :
∀ (l : Literal (PosFin n)),
Array.foldl (reduce_fold_fn assignment) reducedToEmpty c_arr = reducedToUnit l →
∀ (p : PosFin n → Bool), p ⊨ assignment → (∃ i, ↑i < c_arr.size ∧ (p ⊨ c_arr[i])) → p ⊨ l
l : Literal (PosFin n)
hl : Array.foldl (reduce_fold_fn assignment) reducedToEmpty c_arr = reducedToUnit l
p : PosFin n → Bool
hp : p ⊨ assignment
i : PosFin n
pc1 : (i, true) ∈ c_arr.toList
pc2 : decide (p i = true) = true
⊢ ∃ i, ↑i < c_arr.size ∧ (p ⊨ c_arr[i])
|
bc01533c0ab5cdb8
|
CategoryTheory.Functor.IsCocartesian.map_self
|
Mathlib/CategoryTheory/FiberedCategory/Cocartesian.lean
|
@[simp]
lemma map_self : IsCocartesian.map p f φ φ = 𝟙 b
|
case map
𝒮 : Type u₁
𝒳 : Type u₂
inst✝² : Category.{v₁, u₁} 𝒮
inst✝¹ : Category.{v₂, u₂} 𝒳
p : 𝒳 ⥤ 𝒮
a✝ b✝ : 𝒳
φ : a✝ ⟶ b✝
R S : 𝒮
a b : 𝒳
inst✝ : p.IsCocartesian (p.map φ) φ
⊢ 𝟙 b✝ = IsCocartesian.map p (p.map φ) φ φ
|
apply map_uniq
|
case map.hψ
𝒮 : Type u₁
𝒳 : Type u₂
inst✝² : Category.{v₁, u₁} 𝒮
inst✝¹ : Category.{v₂, u₂} 𝒳
p : 𝒳 ⥤ 𝒮
a✝ b✝ : 𝒳
φ : a✝ ⟶ b✝
R S : 𝒮
a b : 𝒳
inst✝ : p.IsCocartesian (p.map φ) φ
⊢ φ ≫ 𝟙 b✝ = φ
|
833ab7024cb503ea
|
SimpleGraph.chromaticNumber_le_of_forall_imp
|
Mathlib/Combinatorics/SimpleGraph/Coloring.lean
|
theorem chromaticNumber_le_of_forall_imp {V' : Type*} {G' : SimpleGraph V'}
(h : ∀ n, G'.Colorable n → G.Colorable n) :
G.chromaticNumber ≤ G'.chromaticNumber
|
V : Type u
G : SimpleGraph V
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
m : ℕ
hc : G'.Colorable m
this : G.Colorable m
⊢ ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑m
|
rw [← chromaticNumber_le_iff_colorable] at this
|
V : Type u
G : SimpleGraph V
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
m : ℕ
hc : G'.Colorable m
this : G.chromaticNumber ≤ ↑m
⊢ ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑m
|
5f4f3f6887a3f266
|
CategoryTheory.Abelian.Ext.add_hom
|
Mathlib/Algebra/Homology/DerivedCategory/Ext/Basic.lean
|
@[simp]
lemma add_hom (α β : Ext X Y n) : (α + β).hom = α.hom + β.hom
|
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasExt C
X Y : C
n : ℕ
inst✝ : HasDerivedCategory C
α β : Ext X Y n
α' : Ext (X ⊞ X) Y n := (mk₀ biprod.fst).comp α ⋯
β' : Ext (X ⊞ X) Y n := (mk₀ biprod.snd).comp β ⋯
eq₁ : α + β = (mk₀ (biprod.lift (𝟙 X) (𝟙 X))).comp (α' + β') ⋯
⊢ α' + β' = homEquiv.symm (α'.hom + β'.hom)
|
apply biprod_ext
|
case h₁
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasExt C
X Y : C
n : ℕ
inst✝ : HasDerivedCategory C
α β : Ext X Y n
α' : Ext (X ⊞ X) Y n := (mk₀ biprod.fst).comp α ⋯
β' : Ext (X ⊞ X) Y n := (mk₀ biprod.snd).comp β ⋯
eq₁ : α + β = (mk₀ (biprod.lift (𝟙 X) (𝟙 X))).comp (α' + β') ⋯
⊢ (mk₀ biprod.inl).comp (α' + β') ⋯ = (mk₀ biprod.inl).comp (homEquiv.symm (α'.hom + β'.hom)) ⋯
case h₂
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasExt C
X Y : C
n : ℕ
inst✝ : HasDerivedCategory C
α β : Ext X Y n
α' : Ext (X ⊞ X) Y n := (mk₀ biprod.fst).comp α ⋯
β' : Ext (X ⊞ X) Y n := (mk₀ biprod.snd).comp β ⋯
eq₁ : α + β = (mk₀ (biprod.lift (𝟙 X) (𝟙 X))).comp (α' + β') ⋯
⊢ (mk₀ biprod.inr).comp (α' + β') ⋯ = (mk₀ biprod.inr).comp (homEquiv.symm (α'.hom + β'.hom)) ⋯
|
df159b910b840aef
|
List.Vector.get_ofFn
|
Mathlib/Data/Vector/Basic.lean
|
theorem get_ofFn {n} (f : Fin n → α) (i) : get (ofFn f) i = f i
|
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).toList.get (Fin.cast ⋯ i) = (List.ofFn f).get ⟨↑i, ⋯⟩
|
congr <;> simp [Fin.heq_ext_iff]
|
no goals
|
0313928d8f9dd4c8
|
MeasureTheory.tendsto_of_lintegral_tendsto_of_antitone
|
Mathlib/MeasureTheory/Integral/Lebesgue.lean
|
/-- If an antitone sequence of functions has a lower bound and the sequence of integrals of these
functions tends to the integral of the lower bound, then the sequence of functions converges
almost everywhere to the lower bound. -/
lemma tendsto_of_lintegral_tendsto_of_antitone {α : Type*} {mα : MeasurableSpace α}
{f : ℕ → α → ℝ≥0∞} {F : α → ℝ≥0∞} {μ : Measure α}
(hf_meas : ∀ n, AEMeasurable (f n) μ)
(hf_tendsto : Tendsto (fun i ↦ ∫⁻ a, f i a ∂μ) atTop (𝓝 (∫⁻ a, F a ∂μ)))
(hf_mono : ∀ᵐ a ∂μ, Antitone (fun i ↦ f i a))
(h_bound : ∀ᵐ a ∂μ, ∀ i, F a ≤ f i a) (h0 : ∫⁻ a, f 0 a ∂μ ≠ ∞) :
∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (F a))
|
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Antitone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), F a ≤ f i a
h0 : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F a))
|
suffices F' =ᵐ[μ] F by
filter_upwards [this, hF'_tendsto] with a h_eq h_tendsto using h_eq ▸ h_tendsto
|
α : Type u_5
mα : MeasurableSpace α
f : ℕ → α → ℝ≥0∞
F : α → ℝ≥0∞
μ : Measure α
hf_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
hf_tendsto : Tendsto (fun i => ∫⁻ (a : α), f i a ∂μ) atTop (𝓝 (∫⁻ (a : α), F a ∂μ))
hf_mono : ∀ᵐ (a : α) ∂μ, Antitone fun i => f i a
h_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), F a ≤ f i a
h0 : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
h_int_finite : ∫⁻ (a : α), F a ∂μ ≠ ⊤
h_exists : ∀ᵐ (a : α) ∂μ, ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l)
F' : α → ℝ≥0∞ := fun a => if h : ∃ l, Tendsto (fun i => f i a) atTop (𝓝 l) then h.choose else ⊤
hF'_tendsto : ∀ᵐ (a : α) ∂μ, Tendsto (fun i => f i a) atTop (𝓝 (F' a))
⊢ F' =ᶠ[ae μ] F
|
4ccce525cdd179a4
|
Set.chainHeight_insert_of_forall_gt
|
Mathlib/Order/Height.lean
|
theorem chainHeight_insert_of_forall_gt (a : α) (hx : ∀ b ∈ s, a < b) :
(insert a s).chainHeight = s.chainHeight + 1
|
case a.refine_1
α : Type u_1
s : Set α
inst✝ : Preorder α
a : α
hx : ∀ b ∈ s, a < b
l : List α
hl : l ∈ s.subchain
⊢ Chain' (fun x1 x2 => x1 < x2) (a :: l)
|
rw [chain'_cons']
|
case a.refine_1
α : Type u_1
s : Set α
inst✝ : Preorder α
a : α
hx : ∀ b ∈ s, a < b
l : List α
hl : l ∈ s.subchain
⊢ (∀ y ∈ l.head?, a < y) ∧ Chain' (fun x1 x2 => x1 < x2) l
|
abd1373dde588775
|
ModularGroup.det_coe
|
Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
|
theorem det_coe {g : SL(2, ℤ)} : det (Units.val <| Subtype.val <| coe g) = 1
|
g : SL(2, ℤ)
⊢ (↑↑↑g).det = 1
|
simp only [SpecialLinearGroup.coe_GLPos_coe_GL_coe_matrix, SpecialLinearGroup.det_coe, coe]
|
no goals
|
c80b6f191a45697d
|
WeierstrassCurve.exists_variableChange_of_char_two_of_j_ne_zero
|
Mathlib/AlgebraicGeometry/EllipticCurve/IsomOfJ.lean
|
private lemma exists_variableChange_of_char_two_of_j_ne_zero
[E.IsCharTwoJNeZeroNF] [E'.IsCharTwoJNeZeroNF] (heq : E.a₆ = E'.a₆) :
∃ C : VariableChange F, E.variableChange C = E'
|
F : Type u_1
inst✝⁴ : Field F
inst✝³ : IsSepClosed F
E E' : WeierstrassCurve F
inst✝² : CharP F 2
inst✝¹ : E.IsCharTwoJNeZeroNF
inst✝ : E'.IsCharTwoJNeZeroNF
heq : E.a₆ = E'.a₆
⊢ 2 ∣ 2
|
norm_num
|
no goals
|
515774c34fadda64
|
HilbertBasis.hasSum_repr_symm
|
Mathlib/Analysis/InnerProductSpace/l2Space.lean
|
theorem hasSum_repr_symm (b : HilbertBasis ι 𝕜 E) (f : ℓ²(ι, 𝕜)) :
HasSum (fun i => f i • b i) (b.repr.symm f)
|
case h.a
ι : Type u_1
𝕜 : Type u_2
inst✝² : RCLike 𝕜
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
b : HilbertBasis ι 𝕜 E
f : ↥(lp (fun i => 𝕜) 2)
i : ι
this✝ : NormedSpace 𝕜 ↥(lp (fun _i => 𝕜) 2) := inferInstance
this : lp.single 2 i (↑f i) = ↑f i • lp.single 2 i 1
⊢ lp.single 2 i (↑f i) = b.repr (b.repr.symm ((fun i => lp.single 2 i (↑f i)) i))
|
exact (b.repr.apply_symm_apply (lp.single 2 i (f i))).symm
|
no goals
|
611317bc4a18ea4f
|
Nat.testBit_mod_two_pow
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
|
theorem testBit_mod_two_pow (x j i : Nat) :
testBit (x % 2^j) i = (decide (i < j) && testBit x i)
|
case ind
x : Nat
hyp : ∀ (m : Nat), m < x → ∀ (j i : Nat), (m % 2 ^ j).testBit i = (decide (i < j) && m.testBit i)
j i : Nat
⊢ (x % 2 ^ j).testBit i = (decide (i < j) && x.testBit i)
|
rw [mod_eq]
|
case ind
x : Nat
hyp : ∀ (m : Nat), m < x → ∀ (j i : Nat), (m % 2 ^ j).testBit i = (decide (i < j) && m.testBit i)
j i : Nat
⊢ (if 0 < 2 ^ j ∧ 2 ^ j ≤ x then (x - 2 ^ j) % 2 ^ j else x).testBit i = (decide (i < j) && x.testBit i)
|
f8ba27e4751df3a5
|
AlgebraicGeometry.Scheme.IdealSheafData.zeroLocus_inter_subset_support
|
Mathlib/AlgebraicGeometry/IdealSheaf.lean
|
lemma zeroLocus_inter_subset_support (I : IdealSheafData X) (U : X.affineOpens) :
X.zeroLocus (U := U.1) (I.ideal U) ∩ U ⊆ I.support
|
case intro.intro.intro.intro.intro
X : Scheme
I : X.IdealSheafData
U V : ↑X.affineOpens
x : ↑↑X.toPresheafedSpace
hxV : x ∈ ↑↑V
hxU : x ∈ ↑↑U
hx : ∀ f ∈ I.ideal U, x ∉ X.basicOpen f
s : ↑Γ(X, ↑V)
hfU : s ∈ I.ideal V
hxs : x ∈ X.basicOpen s
f : ↑Γ(X, ↑U)
g : ↑Γ(X, ↑V)
hfg : X.basicOpen f = X.basicOpen g
hxf : x ∈ X.basicOpen f
⊢ False
|
have inst := U.2.isLocalization_basicOpen f
|
case intro.intro.intro.intro.intro
X : Scheme
I : X.IdealSheafData
U V : ↑X.affineOpens
x : ↑↑X.toPresheafedSpace
hxV : x ∈ ↑↑V
hxU : x ∈ ↑↑U
hx : ∀ f ∈ I.ideal U, x ∉ X.basicOpen f
s : ↑Γ(X, ↑V)
hfU : s ∈ I.ideal V
hxs : x ∈ X.basicOpen s
f : ↑Γ(X, ↑U)
g : ↑Γ(X, ↑V)
hfg : X.basicOpen f = X.basicOpen g
hxf : x ∈ X.basicOpen f
inst : IsLocalization.Away f ↑Γ(X, X.basicOpen f)
⊢ False
|
ac346fd7f1a4fa9f
|
NormedField.continuousAt_zpow
|
Mathlib/Analysis/Normed/Field/Lemmas.lean
|
@[simp]
protected lemma continuousAt_zpow : ContinuousAt (fun x ↦ x ^ n) x ↔ x ≠ 0 ∨ 0 ≤ n
|
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
n : ℤ
x : 𝕜
⊢ ContinuousAt (fun x => x ^ n) x ↔ x ≠ 0 ∨ 0 ≤ n
|
refine ⟨?_, continuousAt_zpow₀ _ _⟩
|
𝕜 : Type u_4
inst✝ : NontriviallyNormedField 𝕜
n : ℤ
x : 𝕜
⊢ ContinuousAt (fun x => x ^ n) x → x ≠ 0 ∨ 0 ≤ n
|
25b0e3752eb9042c
|
LieAlgebra.IsKilling.isSemisimple_ad_of_mem_isCartanSubalgebra
|
Mathlib/Algebra/Lie/Weights/Killing.lean
|
lemma isSemisimple_ad_of_mem_isCartanSubalgebra {x : L} (hx : x ∈ H) :
(ad K L x).IsSemisimple
|
case hN
K : Type u_2
L : Type u_3
inst✝⁷ : LieRing L
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : FiniteDimensional K L
H : LieSubalgebra K L
inst✝³ : H.IsCartanSubalgebra
inst✝² : IsKilling K L
inst✝¹ : IsTriangularizable K (↥H) L
inst✝ : PerfectField K
x : L
hx : x ∈ H
N S : End K L
hN : _root_.IsNilpotent ((ad K L) x - S)
hS : S.IsSemisimple
hSN : (ad K L) x = N + S
hS₀ : Commute ((ad K L) x) S
x' : ↥H := ⟨x, hx⟩
aux : ∀ {α : ↥H → K} {y : L}, y ∈ rootSpace H α → S y = α x' • y
h_der : ∀ (y z : L) (α β : ↥H → K), y ∈ rootSpace H α → z ∈ rootSpace H β → S ⁅y, z⁆ = ⁅S y, z⁆ + ⁅y, S z⁆
y✝ z : L
hz : z ∈ ⨆ α, rootSpace H α
α : ↥H → K
y : L
hy : y ∈ rootSpace H α
⊢ S ⁅y, z⁆ = ⁅S y, z⁆ + ⁅y, S z⁆
|
induction hz using LieSubmodule.iSup_induction' with
| hN β z hz => exact h_der y z α β hy hz
| h0 => simp
| hadd _ _ _ _ h h' => simp only [lie_add, map_add, h, h']; abel
|
no goals
|
b080016ae19cad5d
|
MeasureTheory.Measure.haveLebesgueDecomposition_of_finiteMeasure
|
Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
|
theorem haveLebesgueDecomposition_of_finiteMeasure [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
HaveLebesgueDecomposition μ ν where
lebesgue_decomposition
|
α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
g : ℕ → ℝ≥0∞
h✝ : Monotone g
hg₂ : Filter.Tendsto g Filter.atTop (nhds (sSup (measurableLEEval ν μ)))
f : ℕ → α → ℝ≥0∞
hf₁ : ∀ (n : ℕ), f n ∈ measurableLE ν μ
hf₂ : ∀ (n : ℕ), (fun f => ∫⁻ (x : α), f x ∂ν) (f n) = g n
ξ : α → ℝ≥0∞ := ⨆ n, ⨆ k, ⨆ (_ : k ≤ n), f k
hξ : ξ = ⨆ n, ⨆ k, ⨆ (_ : k ≤ n), f k
hξ₁ : sSup (measurableLEEval ν μ) = ∫⁻ (a : α), ξ a ∂ν
hξm : Measurable ξ
hξle : ∀ (A : Set α), MeasurableSet A → ∫⁻ (a : α) in A, ξ a ∂ν ≤ μ A
hle : ν.withDensity ξ ≤ μ
⊢ IsFiniteMeasure (ν.withDensity ξ)
|
refine isFiniteMeasure_withDensity ?_
|
α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
g : ℕ → ℝ≥0∞
h✝ : Monotone g
hg₂ : Filter.Tendsto g Filter.atTop (nhds (sSup (measurableLEEval ν μ)))
f : ℕ → α → ℝ≥0∞
hf₁ : ∀ (n : ℕ), f n ∈ measurableLE ν μ
hf₂ : ∀ (n : ℕ), (fun f => ∫⁻ (x : α), f x ∂ν) (f n) = g n
ξ : α → ℝ≥0∞ := ⨆ n, ⨆ k, ⨆ (_ : k ≤ n), f k
hξ : ξ = ⨆ n, ⨆ k, ⨆ (_ : k ≤ n), f k
hξ₁ : sSup (measurableLEEval ν μ) = ∫⁻ (a : α), ξ a ∂ν
hξm : Measurable ξ
hξle : ∀ (A : Set α), MeasurableSet A → ∫⁻ (a : α) in A, ξ a ∂ν ≤ μ A
hle : ν.withDensity ξ ≤ μ
⊢ ∫⁻ (a : α), ξ a ∂ν ≠ ⊤
|
0e340e69a0abebdf
|
bernsteinApproximation_uniform
|
Mathlib/Analysis/SpecialFunctions/Bernstein.lean
|
theorem bernsteinApproximation_uniform (f : C(I, ℝ)) :
Tendsto (fun n : ℕ => bernsteinApproximation n f) atTop (𝓝 f)
|
case h.calc_2
f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
δ : ℝ := bernsteinApproximation.δ f ε h
nhds_zero : Tendsto (fun n => 2 * ‖f‖ * δ ^ (-2) / ↑n) atTop (𝓝 0)
n : ℕ
nh : 2 * ‖f‖ * δ ^ (-2) / ↑n < ε / 2
npos' : 0 < n
npos : 0 < ↑n
x : ↑I
S : Finset (Fin (n + 1)) := bernsteinApproximation.S f ε h n x
⊢ ∑ k ∈ Sᶜ, |f k/ₙ - f x| * (bernstein n ↑k) x < ε / 2
|
calc
∑ k ∈ Sᶜ, |f k/ₙ - f x| * bernstein n k x ≤ ∑ k ∈ Sᶜ, 2 * ‖f‖ * bernstein n k x := by
gcongr
apply f.dist_le_two_norm
_ = 2 * ‖f‖ * ∑ k ∈ Sᶜ, bernstein n k x := by rw [Finset.mul_sum]
_ ≤ 2 * ‖f‖ * ∑ k ∈ Sᶜ, δ ^ (-2 : ℤ) * ((x : ℝ) - k/ₙ) ^ 2 * bernstein n k x := by
gcongr with _ m
conv_lhs => rw [← one_mul (bernstein _ _ _)]
gcongr
exact le_of_mem_S_compl m
_ ≤ 2 * ‖f‖ * ∑ k : Fin (n + 1), δ ^ (-2 : ℤ) * ((x : ℝ) - k/ₙ) ^ 2 * bernstein n k x := by
gcongr; exact Sᶜ.subset_univ
_ = 2 * ‖f‖ * δ ^ (-2 : ℤ) * ∑ k : Fin (n + 1), ((x : ℝ) - k/ₙ) ^ 2 * bernstein n k x := by
conv_rhs =>
rw [mul_assoc, Finset.mul_sum]
simp only [← mul_assoc]
_ = 2 * ‖f‖ * δ ^ (-2 : ℤ) * x * (1 - x) / n := by rw [variance npos]; ring
_ ≤ 2 * ‖f‖ * δ ^ (-2 : ℤ) * 1 * 1 / n := by gcongr <;> unit_interval
_ < ε / 2 := by simp only [mul_one]; exact nh
|
no goals
|
404c705b844529e4
|
LinearMap.re_inner_adjoint_mul_self_nonneg
|
Mathlib/Analysis/InnerProductSpace/Adjoint.lean
|
theorem re_inner_adjoint_mul_self_nonneg (T : E →ₗ[𝕜] E) (x : E) :
0 ≤ re ⟪x, (LinearMap.adjoint T * T) x⟫
|
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : FiniteDimensional 𝕜 E
T : E →ₗ[𝕜] E
x : E
⊢ 0 ≤ re ⟪x, (adjoint T * T) x⟫_𝕜
|
simp only [mul_apply, adjoint_inner_right, inner_self_eq_norm_sq_to_K]
|
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : FiniteDimensional 𝕜 E
T : E →ₗ[𝕜] E
x : E
⊢ 0 ≤ re (↑‖T x‖ ^ 2)
|
59c20261fe17c950
|
ProbabilityTheory.Kernel.indepSets_piiUnionInter_of_disjoint
|
Mathlib/Probability/Independence/Kernel.lean
|
theorem indepSets_piiUnionInter_of_disjoint {s : ι → Set (Set Ω)}
{S T : Set ι} (h_indep : iIndepSets s κ μ) (hST : Disjoint S T) :
IndepSets (piiUnionInter s S) (piiUnionInter s T) κ μ
|
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
s : ι → Set (Set Ω)
S T : Set ι
h_indep : iIndepSets s κ μ
hST : Disjoint S T
t1 t2 : Set Ω
p1 : Finset ι
hp1 : ↑p1 ⊆ S
f1 : ι → Set Ω
ht1_m : ∀ x ∈ p1, f1 x ∈ s x
ht1_eq : t1 = ⋂ x ∈ p1, f1 x
p2 : Finset ι
hp2 : ↑p2 ⊆ T
f2 : ι → Set Ω
ht2_m : ∀ x ∈ p2, f2 x ∈ s x
ht2_eq : t2 = ⋂ x ∈ p2, f2 x
g : ι → Set Ω := fun i => (if i ∈ p1 then f1 i else univ) ∩ if i ∈ p2 then f2 i else univ
⊢ ∀ i ∈ p1 ∪ p2, g i ∈ s i
|
intro i hi_mem_union
|
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
s : ι → Set (Set Ω)
S T : Set ι
h_indep : iIndepSets s κ μ
hST : Disjoint S T
t1 t2 : Set Ω
p1 : Finset ι
hp1 : ↑p1 ⊆ S
f1 : ι → Set Ω
ht1_m : ∀ x ∈ p1, f1 x ∈ s x
ht1_eq : t1 = ⋂ x ∈ p1, f1 x
p2 : Finset ι
hp2 : ↑p2 ⊆ T
f2 : ι → Set Ω
ht2_m : ∀ x ∈ p2, f2 x ∈ s x
ht2_eq : t2 = ⋂ x ∈ p2, f2 x
g : ι → Set Ω := fun i => (if i ∈ p1 then f1 i else univ) ∩ if i ∈ p2 then f2 i else univ
i : ι
hi_mem_union : i ∈ p1 ∪ p2
⊢ g i ∈ s i
|
139cefbe3a1213c8
|
LocalizedModule.subsingleton_iff_support_subset
|
Mathlib/RingTheory/Support.lean
|
lemma LocalizedModule.subsingleton_iff_support_subset {f : R} :
Subsingleton (LocalizedModule (.powers f) M) ↔
Module.support R M ⊆ PrimeSpectrum.zeroLocus {f}
|
case mpr
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : R
H : Module.support R M ⊆ PrimeSpectrum.zeroLocus {f}
m : M
⊢ ∃ r ∈ Submonoid.powers f, r • m = 0
|
by_cases h : (Submodule.span R {m}).annihilator = ⊤
|
case pos
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : R
H : Module.support R M ⊆ PrimeSpectrum.zeroLocus {f}
m : M
h : (Submodule.span R {m}).annihilator = ⊤
⊢ ∃ r ∈ Submonoid.powers f, r • m = 0
case neg
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : R
H : Module.support R M ⊆ PrimeSpectrum.zeroLocus {f}
m : M
h : ¬(Submodule.span R {m}).annihilator = ⊤
⊢ ∃ r ∈ Submonoid.powers f, r • m = 0
|
75188a38276e1985
|
CategoryTheory.compatiblePreservingOfFlat
|
Mathlib/CategoryTheory/Sites/CoverPreserving.lean
|
theorem compatiblePreservingOfFlat {C : Type u₁} [Category.{v₁} C] {D : Type u₁} [Category.{v₁} D]
(K : GrothendieckTopology D) (G : C ⥤ D) [RepresentablyFlat G] : CompatiblePreserving K G
|
case compatible
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₁
inst✝¹ : Category.{v₁, u₁} D
K : GrothendieckTopology D
G : C ⥤ D
inst✝ : RepresentablyFlat G
ℱ : Sheaf K (Type u_1)
Z : C
T : Presieve Z
x : FamilyOfElements (G.op ⋙ ℱ.val) T
hx : x.Compatible
Y₁ Y₂ : C
X : D
f₁ : X ⟶ G.obj Y₁
f₂ : X ⟶ G.obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
e : f₁ ≫ G.map g₁ = f₂ ≫ G.map g₂
c : Cone (cospan g₁ g₂ ⋙ G) :=
(Cones.postcompose (diagramIsoCospan (cospan g₁ g₂ ⋙ G)).inv).obj (PullbackCone.mk f₁ f₂ e)
c' : Cone (c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G) :=
IsCofiltered.cone (c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G)
eq₁ : f₁ = (c'.pt.hom ≫ G.map (c'.π.app left).right) ≫ eqToHom ⋯
eq₂ : f₂ = (c'.pt.hom ≫ G.map (c'.π.app right).right) ≫ eqToHom ⋯
⊢ ℱ.val.map c'.pt.hom.op (ℱ.val.map (G.map (c'.π.app left).right).op (eqToHom ⋯ (x g₁ hg₁))) =
ℱ.val.map c'.pt.hom.op (ℱ.val.map (G.map (c'.π.app right).right).op (eqToHom ⋯ (x g₂ hg₂)))
|
apply congr_arg
|
case compatible.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₁
inst✝¹ : Category.{v₁, u₁} D
K : GrothendieckTopology D
G : C ⥤ D
inst✝ : RepresentablyFlat G
ℱ : Sheaf K (Type u_1)
Z : C
T : Presieve Z
x : FamilyOfElements (G.op ⋙ ℱ.val) T
hx : x.Compatible
Y₁ Y₂ : C
X : D
f₁ : X ⟶ G.obj Y₁
f₂ : X ⟶ G.obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
e : f₁ ≫ G.map g₁ = f₂ ≫ G.map g₂
c : Cone (cospan g₁ g₂ ⋙ G) :=
(Cones.postcompose (diagramIsoCospan (cospan g₁ g₂ ⋙ G)).inv).obj (PullbackCone.mk f₁ f₂ e)
c' : Cone (c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G) :=
IsCofiltered.cone (c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G)
eq₁ : f₁ = (c'.pt.hom ≫ G.map (c'.π.app left).right) ≫ eqToHom ⋯
eq₂ : f₂ = (c'.pt.hom ≫ G.map (c'.π.app right).right) ≫ eqToHom ⋯
⊢ ℱ.val.map (G.map (c'.π.app left).right).op (eqToHom ⋯ (x g₁ hg₁)) =
ℱ.val.map (G.map (c'.π.app right).right).op (eqToHom ⋯ (x g₂ hg₂))
|
8ad53d89c26ce87e
|
ModuleCat.FreeMonoidal.εIso_inv_freeMk
|
Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
|
@[simp]
lemma εIso_inv_freeMk (x : PUnit) : (εIso R).inv (freeMk x) = 1
|
R : Type u
inst✝ : CommRing R
x : PUnit.{u + 1}
⊢ (Finsupp.single x 1) PUnit.unit = 1
|
rw [Finsupp.single_eq_same]
|
no goals
|
930ba52caeff00d7
|
LieAlgebra.derivedSeriesOfIdeal_add_le_add
|
Mathlib/Algebra/Lie/Solvable.lean
|
theorem derivedSeriesOfIdeal_add_le_add (J : LieIdeal R L) (k l : ℕ) :
D (k + l) (I + J) ≤ D k I + D l J
|
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
I J : LieIdeal R L
k l : ℕ
D₁ : LieIdeal R L →o LieIdeal R L := { toFun := fun I => ⁅I, I⁆, monotone' := ⋯ }
⊢ D (k + l) (I + J) ≤ D k I + D l J
|
have h₁ : ∀ I J : LieIdeal R L, D₁ (I ⊔ J) ≤ D₁ I ⊔ J := by
simp [D₁, LieSubmodule.lie_le_right, LieSubmodule.lie_le_left, le_sup_of_le_right]
|
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
I J : LieIdeal R L
k l : ℕ
D₁ : LieIdeal R L →o LieIdeal R L := { toFun := fun I => ⁅I, I⁆, monotone' := ⋯ }
h₁ : ∀ (I J : LieIdeal R L), D₁ (I ⊔ J) ≤ D₁ I ⊔ J
⊢ D (k + l) (I + J) ≤ D k I + D l J
|
c99f5499945f2a44
|
Submodule.apply_mem_map₂
|
Mathlib/Algebra/Module/Submodule/Bilinear.lean
|
theorem apply_mem_map₂ (f : M →ₗ[R] N →ₗ[R] P) {m : M} {n : N} {p : Submodule R M}
{q : Submodule R N} (hm : m ∈ p) (hn : n ∈ q) : f m n ∈ map₂ f p q :=
(le_iSup _ ⟨m, hm⟩ : _ ≤ map₂ f p q) ⟨n, hn, by rfl⟩
|
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
m : M
n : N
p : Submodule R M
q : Submodule R N
hm : m ∈ p
hn : n ∈ q
⊢ (f ↑⟨m, hm⟩) n = (f m) n
|
rfl
|
no goals
|
6f9e3c11fa4bc728
|
MeasureTheory.tendsto_measure_symmDiff_preimage_nhds_zero
|
Mathlib/MeasureTheory/Measure/ContinuousPreimage.lean
|
theorem tendsto_measure_symmDiff_preimage_nhds_zero
{l : Filter α} {f : α → C(X, Y)} {g : C(X, Y)} {s : Set Y} (hfg : Tendsto f l (𝓝 g))
(hf : ∀ᶠ a in l, MeasurePreserving (f a) μ ν) (hg : MeasurePreserving g μ ν)
(hs : NullMeasurableSet s ν) (hνs : ν s ≠ ∞) :
Tendsto (fun a ↦ μ ((f a ⁻¹' s) ∆ (g ⁻¹' s))) l (𝓝 0)
|
α : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace X
inst✝⁷ : BorelSpace X
inst✝⁶ : R1Space X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : MeasurableSpace Y
inst✝³ : BorelSpace Y
inst✝² : R1Space Y
μ : Measure X
ν : Measure Y
inst✝¹ : μ.InnerRegularCompactLTTop
inst✝ : IsLocallyFiniteMeasure ν
l : Filter α
f : α → C(X, Y)
g : C(X, Y)
s : Set Y
hfg : Tendsto f l (𝓝 g)
hf : ∀ᶠ (a : α) in l, MeasurePreserving (⇑(f a)) μ ν
hg : MeasurePreserving (⇑g) μ ν
hs : NullMeasurableSet s ν
hνs : ν s ≠ ⊤
this✝ : ν.InnerRegularCompactLTTop
ε : ℝ≥0∞
hε : ε > 0
this :
∀ {s : Set Y},
NullMeasurableSet s ν → ν s ≠ ⊤ → ∀ ε > 0, IsOpen s → ∀ᶠ (x : α) in l, μ ((⇑(f x) ⁻¹' s) ∆ (⇑g ⁻¹' s)) ≤ ε
hso : ¬IsOpen s
H : 0 < ε / 3
U : Set Y
hUo : IsOpen U
hU : ν U < ⊤
hmU : NullMeasurableSet U ν
hUs : ν (U ∆ s) ≤ ε / 3
a : α
hfa : MeasurePreserving (⇑(f a)) μ ν
ha : μ ((⇑(f a) ⁻¹' U) ∆ (⇑g ⁻¹' U)) ≤ ε / 3
⊢ μ ((⇑(f a) ⁻¹' s) ∆ (⇑g ⁻¹' s)) ≤
μ ((⇑(f a) ⁻¹' s) ∆ (⇑(f a) ⁻¹' U)) + μ ((⇑(f a) ⁻¹' U) ∆ (⇑g ⁻¹' U)) + μ ((⇑g ⁻¹' U) ∆ (⇑g ⁻¹' s))
|
refine (measure_symmDiff_le _ (g ⁻¹' U) _).trans ?_
|
α : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace X
inst✝⁷ : BorelSpace X
inst✝⁶ : R1Space X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : MeasurableSpace Y
inst✝³ : BorelSpace Y
inst✝² : R1Space Y
μ : Measure X
ν : Measure Y
inst✝¹ : μ.InnerRegularCompactLTTop
inst✝ : IsLocallyFiniteMeasure ν
l : Filter α
f : α → C(X, Y)
g : C(X, Y)
s : Set Y
hfg : Tendsto f l (𝓝 g)
hf : ∀ᶠ (a : α) in l, MeasurePreserving (⇑(f a)) μ ν
hg : MeasurePreserving (⇑g) μ ν
hs : NullMeasurableSet s ν
hνs : ν s ≠ ⊤
this✝ : ν.InnerRegularCompactLTTop
ε : ℝ≥0∞
hε : ε > 0
this :
∀ {s : Set Y},
NullMeasurableSet s ν → ν s ≠ ⊤ → ∀ ε > 0, IsOpen s → ∀ᶠ (x : α) in l, μ ((⇑(f x) ⁻¹' s) ∆ (⇑g ⁻¹' s)) ≤ ε
hso : ¬IsOpen s
H : 0 < ε / 3
U : Set Y
hUo : IsOpen U
hU : ν U < ⊤
hmU : NullMeasurableSet U ν
hUs : ν (U ∆ s) ≤ ε / 3
a : α
hfa : MeasurePreserving (⇑(f a)) μ ν
ha : μ ((⇑(f a) ⁻¹' U) ∆ (⇑g ⁻¹' U)) ≤ ε / 3
⊢ μ ((⇑(f a) ⁻¹' s) ∆ (⇑g ⁻¹' U)) + μ ((⇑g ⁻¹' U) ∆ (⇑g ⁻¹' s)) ≤
μ ((⇑(f a) ⁻¹' s) ∆ (⇑(f a) ⁻¹' U)) + μ ((⇑(f a) ⁻¹' U) ∆ (⇑g ⁻¹' U)) + μ ((⇑g ⁻¹' U) ∆ (⇑g ⁻¹' s))
|
050b449bb51827ad
|
exists_mul_right_lt₀
|
Mathlib/Algebra/Order/Field/Basic.lean
|
private lemma exists_mul_right_lt₀ {a b c : α} (hc : a * b < c) : ∃ b' > b, a * b' < c
|
α : Type u_2
inst✝ : LinearOrderedField α
a b c : α
hc : a * b < c
⊢ ∃ b' > b, a * b' < c
|
simp_rw [mul_comm a] at hc ⊢
|
α : Type u_2
inst✝ : LinearOrderedField α
a b c : α
hc : b * a < c
⊢ ∃ b' > b, b' * a < c
|
65fa0f9f99da1238
|
CategoryTheory.LaxMonoidalFunctor.hom_ext
|
Mathlib/CategoryTheory/Monoidal/NaturalTransformation.lean
|
@[ext]
lemma hom_ext {F G : LaxMonoidalFunctor C D} {α β : F ⟶ G} (h : α.hom = β.hom) : α = β
|
case mk.mk
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F G : LaxMonoidalFunctor C D
hom✝ : F.toFunctor ⟶ G.toFunctor
isMonoidal✝¹ : NatTrans.IsMonoidal hom✝
isMonoidal✝ : NatTrans.IsMonoidal { hom := hom✝, isMonoidal := isMonoidal✝¹ }.hom
⊢ { hom := hom✝, isMonoidal := isMonoidal✝¹ } =
{ hom := { hom := hom✝, isMonoidal := isMonoidal✝¹ }.hom, isMonoidal := isMonoidal✝ }
|
rfl
|
no goals
|
8848a8c64a10a477
|
MeasureTheory.integral_eq_zero_iff_of_nonneg_ae
|
Mathlib/MeasureTheory/Integral/Bochner.lean
|
theorem integral_eq_zero_iff_of_nonneg_ae {f : α → ℝ} (hf : 0 ≤ᵐ[μ] f) (hfi : Integrable f μ) :
∫ x, f x ∂μ = 0 ↔ f =ᵐ[μ] 0
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : 0 ≤ᶠ[ae μ] f
hfi : Integrable f μ
⊢ AEMeasurable (fun a => ENNReal.ofReal (f a)) μ
|
exact (ENNReal.measurable_ofReal.comp_aemeasurable hfi.1.aemeasurable)
|
no goals
|
3f575e9bc56637ff
|
Num.succ_ofInt'
|
Mathlib/Data/Num/Lemmas.lean
|
theorem succ_ofInt' : ∀ n, ZNum.ofInt' (n + 1) = ZNum.ofInt' n + 1
| (n : ℕ) => by
change ZNum.ofInt' (n + 1 : ℕ) = ZNum.ofInt' (n : ℕ) + 1
dsimp only [ZNum.ofInt', ZNum.ofInt']
rw [Num.ofNat'_succ, Num.add_one, toZNum_succ, ZNum.add_one]
| -[0+1] => by
change ZNum.ofInt' 0 = ZNum.ofInt' (-[0+1]) + 1
dsimp only [ZNum.ofInt', ZNum.ofInt']
rw [ofNat'_succ, ofNat'_zero]; rfl
| -[(n + 1)+1] => by
change ZNum.ofInt' -[n+1] = ZNum.ofInt' -[(n + 1)+1] + 1
dsimp only [ZNum.ofInt', ZNum.ofInt']
rw [@Num.ofNat'_succ (n + 1), Num.add_one, toZNumNeg_succ,
@ofNat'_succ n, Num.add_one, ZNum.add_one, pred_succ]
|
n : ℕ
⊢ ZNum.ofInt' ↑(n + 1) = ZNum.ofInt' ↑n + 1
|
dsimp only [ZNum.ofInt', ZNum.ofInt']
|
n : ℕ
⊢ (ofNat' (n + 1)).toZNum = (ofNat' n).toZNum + 1
|
ca426ea9d61f4551
|
Complex.volume_ball
|
Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean
|
theorem Complex.volume_ball (a : ℂ) (r : ℝ) :
volume (Metric.ball a r) = .ofReal r ^ 2 * NNReal.pi
|
a : ℂ
r : ℝ
⊢ volume (Metric.ball a r) = ENNReal.ofReal r ^ 2 * ↑NNReal.pi
|
simp [InnerProductSpace.volume_ball_of_dim_even (k := 1) (by simp) a,
← NNReal.coe_real_pi, ofReal_coe_nnreal]
|
no goals
|
08ef1cfdd4ddfd5b
|
emultiplicity_le_emultiplicity_iff
|
Mathlib/RingTheory/Multiplicity.lean
|
theorem emultiplicity_le_emultiplicity_iff {c d : β} :
emultiplicity a b ≤ emultiplicity c d ↔ ∀ n : ℕ, a ^ n ∣ b → c ^ n ∣ d
|
case mpr
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : α
c d : β
h : ∀ (n : ℕ), a ^ n ∣ b → c ^ n ∣ d
⊢ emultiplicity a b ≤ emultiplicity c d
|
unfold emultiplicity
|
case mpr
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : Monoid β
a b : α
c d : β
h : ∀ (n : ℕ), a ^ n ∣ b → c ^ n ∣ d
⊢ (if h : FiniteMultiplicity a b then ↑(Nat.find h) else ⊤) ≤ if h : FiniteMultiplicity c d then ↑(Nat.find h) else ⊤
|
bab270aee1ba305d
|
spectrum.isUnit_one_sub_smul_of_lt_inv_radius
|
Mathlib/Analysis/Normed/Algebra/Spectrum.lean
|
theorem isUnit_one_sub_smul_of_lt_inv_radius {a : A} {z : 𝕜} (h : ↑‖z‖₊ < (spectralRadius 𝕜 a)⁻¹) :
IsUnit (1 - z • a)
|
case neg
𝕜 : Type u_1
A : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedRing A
inst✝ : NormedAlgebra 𝕜 A
a : A
z : 𝕜
h : ↑‖z‖₊ < (spectralRadius 𝕜 a)⁻¹
hz : ¬z = 0
u : 𝕜ˣ := Units.mk0 z hz
⊢ IsUnit (1 - z • a)
|
suffices hu : IsUnit (u⁻¹ • (1 : A) - a) by
rwa [IsUnit.smul_sub_iff_sub_inv_smul, inv_inv u] at hu
|
case neg
𝕜 : Type u_1
A : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedRing A
inst✝ : NormedAlgebra 𝕜 A
a : A
z : 𝕜
h : ↑‖z‖₊ < (spectralRadius 𝕜 a)⁻¹
hz : ¬z = 0
u : 𝕜ˣ := Units.mk0 z hz
⊢ IsUnit (u⁻¹ • 1 - a)
|
7c24ad5e48f2ddf5
|
LieModule.iterate_toEnd_mem_lowerCentralSeries₂
|
Mathlib/Algebra/Lie/Nilpotent.lean
|
theorem iterate_toEnd_mem_lowerCentralSeries₂ (x y : L) (m : M) (k : ℕ) :
(toEnd R L M x ∘ₗ toEnd R L M y)^[k] m ∈
lowerCentralSeries R L M (2 * k)
|
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
m : M
k : ℕ
⊢ (⇑((toEnd R L M) x ∘ₗ (toEnd R L M) y))^[k] m ∈ lowerCentralSeries R L M (2 * k)
|
induction k with
| zero => simp
| succ k ih =>
have hk : 2 * k.succ = (2 * k + 1) + 1 := rfl
simp only [lowerCentralSeries_succ, Function.comp_apply, Function.iterate_succ', hk,
toEnd_apply_apply, LinearMap.coe_comp, toEnd_apply_apply]
refine LieSubmodule.lie_mem_lie (LieSubmodule.mem_top x) ?_
exact LieSubmodule.lie_mem_lie (LieSubmodule.mem_top y) ih
|
no goals
|
a700d4de77919e57
|
Real.log_lt_sub_one_of_pos
|
Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
|
theorem log_lt_sub_one_of_pos (hx1 : 0 < x) (hx2 : x ≠ 1) : log x < x - 1
|
x : ℝ
hx1 : 0 < x
hx2 : x ≠ 1
⊢ log x ≠ 0
|
rwa [← log_one, log_injOn_pos.ne_iff hx1]
|
x : ℝ
hx1 : 0 < x
hx2 : x ≠ 1
⊢ 1 ∈ Ioi 0
|
9e3a3fb6c52026a5
|
CategoryTheory.IsDetecting.isIso_iff_of_mono
|
Mathlib/CategoryTheory/Generator/Basic.lean
|
lemma IsDetecting.isIso_iff_of_mono {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢)
{X Y : C} (f : X ⟶ Y) [Mono f] :
IsIso f ↔ ∀ s ∈ 𝒢, Function.Surjective ((coyoneda.obj (op s)).map f)
|
case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
𝒢 : Set C
h𝒢 : IsDetecting 𝒢
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : IsIso f
⊢ ∀ s ∈ 𝒢, Function.Surjective ((coyoneda.obj (op s)).map f)
|
rw [isIso_iff_yoneda_map_bijective] at h
|
case mp
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
𝒢 : Set C
h𝒢 : IsDetecting 𝒢
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ∀ (T : C), Function.Bijective fun x => x ≫ f
⊢ ∀ s ∈ 𝒢, Function.Surjective ((coyoneda.obj (op s)).map f)
|
f84bf19dd3722ac1
|
Finsupp.linearCombination_linear_comp
|
Mathlib/LinearAlgebra/Finsupp/LinearCombination.lean
|
theorem linearCombination_linear_comp (f : M →ₗ[R] M') :
linearCombination R (f ∘ v) = f ∘ₗ linearCombination R v
|
α : Type u_1
M : Type u_2
R : Type u_5
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
f : M →ₗ[R] M'
⊢ linearCombination R (⇑f ∘ v) = f ∘ₗ linearCombination R v
|
ext
|
case h.h
α : Type u_1
M : Type u_2
R : Type u_5
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
f : M →ₗ[R] M'
a✝ : α
⊢ (linearCombination R (⇑f ∘ v) ∘ₗ lsingle a✝) 1 = ((f ∘ₗ linearCombination R v) ∘ₗ lsingle a✝) 1
|
9c925f59b92133d8
|
ContMDiffOn.contMDiffOn_tangentMapWithin
|
Mathlib/Geometry/Manifold/ContMDiffMFDeriv.lean
|
theorem ContMDiffOn.contMDiffOn_tangentMapWithin
(hf : ContMDiffOn I I' n f s) (hmn : m + 1 ≤ n)
(hs : UniqueMDiffOn I s) :
haveI : IsManifold I 1 M := .of_le (le_trans le_add_self hmn)
haveI : IsManifold I' 1 M' := .of_le (le_trans le_add_self hmn)
ContMDiffOn I.tangent I'.tangent m (tangentMapWithin I I' f s)
(π E (TangentSpace I) ⁻¹' s)
|
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
m n : WithTop ℕ∞
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁷ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝² : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
f : M → M'
s : Set M
Is : IsManifold I n M
I's : IsManifold I' n M'
hf : ContMDiffOn I I' n f s
hmn : m + 1 ≤ n
hs : UniqueMDiffOn I s
this✝ : IsManifold I 1 M
this : IsManifold I' 1 M'
x₀ : TangentBundle I M
hx₀ : x₀ ∈ TotalSpace.proj ⁻¹' s
s' : Set (TangentBundle I M) := TotalSpace.proj ⁻¹' s
b₁ : TangentBundle I M → M := fun p => p.proj
v : (y : TangentBundle I M) → TangentSpace I (b₁ y) := fun y => y.snd
hv : ContMDiffWithinAt I.tangent I.tangent m (fun y => { proj := b₁ y, snd := v y }) s' x₀
b₂ : TangentBundle I M → M' := f ∘ b₁
hb₂ : ContMDiffWithinAt I.tangent I' m b₂ s' x₀
ϕ : (y : TangentBundle I M) → TangentSpace I (b₁ y) →L[𝕜] TangentSpace I' (b₂ y) :=
fun y => mfderivWithin I I' f s (b₁ y)
hϕ :
ContMDiffWithinAt I.tangent 𝓘(𝕜, E →L[𝕜] E') m
(fun y =>
ContinuousLinearMap.inCoordinates E (TangentSpace I) E' (TangentSpace I') (b₁ x₀) (b₁ y) (b₂ x₀) (b₂ y) (ϕ y))
s' x₀
⊢ ContMDiffWithinAt I.tangent I'.tangent m (tangentMapWithin I I' f s) (TotalSpace.proj ⁻¹' s) x₀
|
exact ContMDiffWithinAt.clm_apply_of_inCoordinates hϕ hv hb₂
|
no goals
|
cff72fb4de8037fe
|
IsRelPrime.prod_left
|
Mathlib/RingTheory/Coprime/Lemmas.lean
|
theorem IsRelPrime.prod_left : (∀ i ∈ t, IsRelPrime (s i) x) → IsRelPrime (∏ i ∈ t, s i) x
|
α : Type u_2
I : Type u_1
inst✝¹ : CommMonoid α
inst✝ : DecompositionMonoid α
x : α
s : I → α
t : Finset I
⊢ (∀ i ∈ t, IsRelPrime (s i) x) → IsRelPrime (∏ i ∈ t, s i) x
|
classical
refine Finset.induction_on t (fun _ ↦ isRelPrime_one_left) fun b t hbt ih H ↦ ?_
rw [Finset.prod_insert hbt]
rw [Finset.forall_mem_insert] at H
exact H.1.mul_left (ih H.2)
|
no goals
|
21cdedf24c1fa426
|
mem_tangentCone_of_openSegment_subset
|
Mathlib/Analysis/Calculus/TangentCone.lean
|
theorem mem_tangentCone_of_openSegment_subset {s : Set G} {x y : G} (h : openSegment ℝ x y ⊆ s) :
y - x ∈ tangentConeAt ℝ s x
|
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
s : Set G
x y : G
h : openSegment ℝ x y ⊆ s
n : ℕ
hn : n ≠ 0
⊢ x + (1 / 2) ^ n • (y - x) ∈ openSegment ℝ x y
|
rw [openSegment_eq_image]
|
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
s : Set G
x y : G
h : openSegment ℝ x y ⊆ s
n : ℕ
hn : n ≠ 0
⊢ x + (1 / 2) ^ n • (y - x) ∈ (fun θ => (1 - θ) • x + θ • y) '' Ioo 0 1
|
6e94cb4690e67383
|
LieAlgebra.IsKilling.rootSpace_neg_nsmul_add_chainTop_of_le
|
Mathlib/Algebra/Lie/Weights/RootSystem.lean
|
lemma rootSpace_neg_nsmul_add_chainTop_of_le {n : ℕ} (hn : n ≤ chainLength α β) :
rootSpace H (- (n • α) + chainTop α β) ≠ ⊥
|
case neg.intro.intro
K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
n : ℕ
hn : n ≤ chainLength α β
hα : ¬α.IsZero
x : L
hx : x ∈ genWeightSpace L ⇑(chainTop (⇑α) β)
x_ne0 : x ≠ 0
⊢ rootSpace H (-(n • ⇑α) + ⇑(chainTop (⇑α) β)) ≠ ⊥
|
obtain ⟨h, e, f, isSl2, he, hf⟩ := exists_isSl2Triple_of_weight_isNonZero hα
|
case neg.intro.intro.intro.intro.intro.intro.intro
K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
n : ℕ
hn : n ≤ chainLength α β
hα : ¬α.IsZero
x : L
hx : x ∈ genWeightSpace L ⇑(chainTop (⇑α) β)
x_ne0 : x ≠ 0
h e f : L
isSl2 : IsSl2Triple h e f
he : e ∈ rootSpace H ⇑α
hf : f ∈ rootSpace H (-⇑α)
⊢ rootSpace H (-(n • ⇑α) + ⇑(chainTop (⇑α) β)) ≠ ⊥
|
bc20a037735ef6ac
|
Submonoid.LocalizationWithZeroMap.leftCancelMulZero_of_le_isLeftRegular
|
Mathlib/GroupTheory/MonoidLocalization/MonoidWithZero.lean
|
theorem leftCancelMulZero_of_le_isLeftRegular
(f : LocalizationWithZeroMap S N) [IsLeftCancelMulZero M]
(h : ∀ ⦃x⦄, x ∈ S → IsLeftRegular x) : IsLeftCancelMulZero N
|
M : Type u_1
inst✝² : CommMonoidWithZero M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoidWithZero N
f : S.LocalizationWithZeroMap N
inst✝ : IsLeftCancelMulZero M
h : ∀ ⦃x : M⦄, x ∈ S → IsLeftRegular x
fl : S.LocalizationMap N := f.toLocalizationMap
g : M →* N := f.toMap
a z w : N
ha : a ≠ 0
hazw : a * z = a * w
b : M × ↥S
hb : a * fl.toMap ↑b.2 = fl.toMap b.1
x : M × ↥S
hx : z * fl.toMap ↑x.2 = fl.toMap x.1
y : M × ↥S
hy : w * fl.toMap ↑y.2 = fl.toMap y.1
b1ne0 : b.1 ≠ 0
⊢ g b.1 * g (↑y.2 * x.1) = g (b.1 * (↑y.2 * x.1))
|
rw [← map_mul g]
|
no goals
|
395e8d90995bfe86
|
PartitionOfUnity.finsupport_subset_fintsupport
|
Mathlib/Topology/PartitionOfUnity.lean
|
theorem finsupport_subset_fintsupport : ρ.finsupport x₀ ⊆ ρ.fintsupport x₀ := fun i hi ↦ by
rw [ρ.mem_fintsupport_iff]
apply subset_closure
exact (ρ.mem_finsupport x₀).mp hi
|
case a
ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
ρ : PartitionOfUnity ι X s
x₀ : X
i : ι
hi : i ∈ ρ.finsupport x₀
⊢ x₀ ∈ support ⇑(ρ i)
|
exact (ρ.mem_finsupport x₀).mp hi
|
no goals
|
9ecb2bf735262740
|
Complex.norm_log_one_add_half_le_self
|
Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean
|
/-- For `‖z‖ ≤ 1/2`, the complex logarithm is bounded by `(3/2) * ‖z‖`. -/
lemma norm_log_one_add_half_le_self {z : ℂ} (hz : ‖z‖ ≤ 1/2) : ‖(log (1 + z))‖ ≤ (3/2) * ‖z‖
|
case hab.c0
z : ℂ
hz : ‖z‖ ≤ 1 / 2
hz3 : (1 - ‖z‖)⁻¹ ≤ 2
⊢ 0 ≤ 1 - ‖z‖
|
linarith
|
no goals
|
f3a688a3bed721f7
|
Ordinal.natCast_add_omega0
|
Mathlib/SetTheory/Ordinal/Arithmetic.lean
|
theorem natCast_add_omega0 (n : ℕ) : n + ω = ω
|
case intro.intro.intro
n : ℕ
a : Ordinal.{u_1}
ha : a < ↑n + ω
m : ℕ
hb' : ↑m < ω
hb : a ≤ ↑n + ↑m
⊢ ↑n + ↑m < ω
|
exact_mod_cast nat_lt_omega0 (n + m)
|
no goals
|
f552f4cf7a04b7d2
|
Valued.continuous_extension
|
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
theorem continuous_extension : Continuous (Valued.extension : hat K → Γ₀)
|
case inr.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ⇑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑x ∈ V → v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : 0 ∉ V'
hV' : ∀ x ∈ V', ∀ y ∈ V', x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
⊢ ∃ c, Tendsto (⇑v) (Filter.comap Completion.coe' (𝓝 x₀)) (𝓝 c)
|
have : ∃ z₀ : K, ∃ y₀ ∈ V', ↑z₀ = y₀ * x₀ ∧ z₀ ≠ 0 := by
rcases Completion.denseRange_coe.mem_nhds nhds_right with ⟨z₀, y₀, y₀_in, H : y₀ * x₀ = z₀⟩
refine ⟨z₀, y₀, y₀_in, ⟨H.symm, ?_⟩⟩
rintro rfl
exact mul_ne_zero (ne_of_mem_of_not_mem y₀_in zeroV') h H
|
case inr.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ⇑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑x ∈ V → v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : 0 ∉ V'
hV' : ∀ x ∈ V', ∀ y ∈ V', x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
this : ∃ z₀, ∃ y₀ ∈ V', ↑z₀ = y₀ * x₀ ∧ z₀ ≠ 0
⊢ ∃ c, Tendsto (⇑v) (Filter.comap Completion.coe' (𝓝 x₀)) (𝓝 c)
|
af62a79ad478b7b6
|
PMF.apply_eq_one_iff
|
Mathlib/Probability/ProbabilityMassFunction/Basic.lean
|
theorem apply_eq_one_iff (p : PMF α) (a : α) : p a = 1 ↔ p.support = {a}
|
α : Type u_1
p : PMF α
a : α
h : p a = 1
a' : α
ha' : a' ∈ p.support
ha : a' ∉ {a}
this : 0 < ∑' (b : α), if b = a then 0 else p b
⊢ (p a + ∑' (b : α), if b = a then 0 else p b) = (if a = a then p a else 0) + ∑' (b : α), if b = a then 0 else p b
|
rw [eq_self_iff_true, if_true]
|
no goals
|
ccbc613819a4be0f
|
Real.smul_map_diagonal_volume_pi
|
Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
|
theorem smul_map_diagonal_volume_pi [DecidableEq ι] {D : ι → ℝ} (h : det (diagonal D) ≠ 0) :
ENNReal.ofReal (abs (det (diagonal D))) • Measure.map (toLin' (diagonal D)) volume =
volume
|
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
D : ι → ℝ
h : (Matrix.diagonal D).det ≠ 0
s : ι → Set ℝ
hs : ∀ (i : ι), MeasurableSet (s i)
this : (⇑(toLin' (Matrix.diagonal D)) ⁻¹' univ.pi fun i => s i) = univ.pi fun i => (fun x => D i * x) ⁻¹' s i
⊢ ∀ (i : ι), ofReal |D i| * volume ((fun x => D i * x) ⁻¹' s i) = volume (s i)
|
intro i
|
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
D : ι → ℝ
h : (Matrix.diagonal D).det ≠ 0
s : ι → Set ℝ
hs : ∀ (i : ι), MeasurableSet (s i)
this : (⇑(toLin' (Matrix.diagonal D)) ⁻¹' univ.pi fun i => s i) = univ.pi fun i => (fun x => D i * x) ⁻¹' s i
i : ι
⊢ ofReal |D i| * volume ((fun x => D i * x) ⁻¹' s i) = volume (s i)
|
f356868f3a872858
|
Zsqrtd.nonneg_smul
|
Mathlib/NumberTheory/Zsqrtd/Basic.lean
|
theorem nonneg_smul {a : ℤ√d} {n : ℕ} (ha : Nonneg a) : Nonneg ((n : ℤ√d) * a)
|
d : ℕ
a : ℤ√↑d
n : ℕ
ha✝ : a.Nonneg
x y : ℕ
ha : { re := -↑x, im := ↑y }.Nonneg
⊢ { re := ↑n * -↑x, im := ↑n * ↑y }.Nonneg
|
simpa using nonnegg_neg_pos.2 (sqLe_smul n <| nonnegg_neg_pos.1 ha)
|
no goals
|
ed3c83933b42a1bd
|
LieModule.Weight.hasEigenvalueAt
|
Mathlib/Algebra/Lie/Weights/Basic.lean
|
lemma hasEigenvalueAt (χ : Weight R L M) (x : L) :
(toEnd R L M x).HasEigenvalue (χ x)
|
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieRing.IsNilpotent L
χ : Weight R L M
x : L
⊢ ?m.173842
|
simpa [genWeightSpaceOf, ← Module.End.iSup_genEigenspace_eq] using χ.genWeightSpaceOf_ne_bot x
|
no goals
|
e7ad90acf37962a9
|
Std.Sat.AIG.RefVec.ite.go_decl_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Sat/AIG/If.lean
|
theorem go_decl_eq (aig : AIG α) (curr : Nat) (hcurr : curr ≤ w) (discr : Ref aig)
(lhs rhs : RefVec aig w) (s : RefVec aig curr) :
∀ (idx : Nat) (h1) (h2),
(go aig curr hcurr discr lhs rhs s).aig.decls[idx]'h2 = aig.decls[idx]'h1
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
curr : Nat
hcurr : curr ≤ w
discr : aig.Ref
lhs rhs : aig.RefVec w
s : aig.RefVec curr
res : RefVecEntry α w
hgo :
(if hcurr : curr < w then
let input := { discr := discr, lhs := lhs.get curr hcurr, rhs := rhs.get curr hcurr };
let res := aig.mkIfCached input;
let aig_1 := res.aig;
let ref := res.ref;
let_fun this := ⋯;
let discr_1 := discr.cast this;
let lhs_1 := lhs.cast this;
let rhs_1 := rhs.cast this;
let s := s.cast this;
let s := s.push ref;
go aig_1 (curr + 1) ⋯ discr_1 lhs_1 rhs_1 s
else
let_fun this := ⋯;
{ aig := aig, vec := this ▸ s }) =
res
⊢ ∀ (idx : Nat) (h1 : idx < aig.decls.size) (h2 : idx < res.aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
|
dsimp only at hgo
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
curr : Nat
hcurr : curr ≤ w
discr : aig.Ref
lhs rhs : aig.RefVec w
s : aig.RefVec curr
res : RefVecEntry α w
hgo :
(if hcurr : curr < w then
go (aig.mkIfCached { discr := discr, lhs := lhs.get curr hcurr, rhs := rhs.get curr hcurr }).aig (curr + 1) ⋯
(discr.cast ⋯) (lhs.cast ⋯) (rhs.cast ⋯)
((s.cast ⋯).push (aig.mkIfCached { discr := discr, lhs := lhs.get curr hcurr, rhs := rhs.get curr hcurr }).ref)
else { aig := aig, vec := ⋯ ▸ s }) =
res
⊢ ∀ (idx : Nat) (h1 : idx < aig.decls.size) (h2 : idx < res.aig.decls.size), res.aig.decls[idx] = aig.decls[idx]
|
adac79f2da711b55
|
MeasureTheory.Measure.dirac_apply
|
Mathlib/MeasureTheory/Measure/Dirac.lean
|
theorem dirac_apply [MeasurableSingletonClass α] (a : α) (s : Set α) :
dirac a s = s.indicator 1 a
|
α : Type u_1
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : a ∉ s
⊢ (dirac a) {a}ᶜ = 0
|
simp [dirac_apply' _ (measurableSet_singleton _).compl]
|
no goals
|
ffeb750d32ef2676
|
Finset.pow_ssubset_pow_succ_of_pow_ne_closure
|
Mathlib/Geometry/Group/Growth/LinearLowerBound.lean
|
@[to_additive]
lemma pow_ssubset_pow_succ_of_pow_ne_closure (hX₁ : (1 : G) ∈ X) (hX : X.Nontrivial)
(hXclosure : (X ^ n : Set G) ≠ closure (X : Set G)) : X ^ n ⊂ X ^ (n + 1)
|
G : Type u_1
inst✝¹ : Group G
inst✝ : DecidableEq G
X : Finset G
n : ℕ
hX₁ : 1 ∈ X
hX : X.Nontrivial
hXclosure : ↑X ^ n ≠ ↑(closure ↑X)
⊢ X ^ n ⊂ X ^ (n + 1)
|
obtain rfl | hn := eq_or_ne n 0
|
case inl
G : Type u_1
inst✝¹ : Group G
inst✝ : DecidableEq G
X : Finset G
hX₁ : 1 ∈ X
hX : X.Nontrivial
hXclosure : ↑X ^ 0 ≠ ↑(closure ↑X)
⊢ X ^ 0 ⊂ X ^ (0 + 1)
case inr
G : Type u_1
inst✝¹ : Group G
inst✝ : DecidableEq G
X : Finset G
n : ℕ
hX₁ : 1 ∈ X
hX : X.Nontrivial
hXclosure : ↑X ^ n ≠ ↑(closure ↑X)
hn : n ≠ 0
⊢ X ^ n ⊂ X ^ (n + 1)
|
baf8f0ea21c560bf
|
WeierstrassCurve.Jacobian.nonsingular_iff_of_Z_ne_zero
|
Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
|
lemma nonsingular_iff_of_Z_ne_zero {P : Fin 3 → F} (hPz : P z ≠ 0) :
W.Nonsingular P ↔ W.Equation P ∧ (eval P W.polynomialX ≠ 0 ∨ eval P W.polynomialY ≠ 0)
|
F : Type u
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.Nonsingular P ↔ W.Equation P ∧ ((eval P) W.polynomialX ≠ 0 ∨ (eval P) W.polynomialY ≠ 0)
|
rw [nonsingular_of_Z_ne_zero hPz, Affine.Nonsingular, ← equation_of_Z_ne_zero hPz,
← eval_polynomialX_of_Z_ne_zero hPz, div_ne_zero_iff, and_iff_left <| pow_ne_zero 4 hPz,
← eval_polynomialY_of_Z_ne_zero hPz, div_ne_zero_iff, and_iff_left <| pow_ne_zero 3 hPz]
|
no goals
|
36d824e29353fb1b
|
CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.exists_epi
|
Mathlib/CategoryTheory/Abelian/GrothendieckCategory/ModuleEmbedding/Opposite.lean
|
theorem exists_epi (X : D) : ∃ f : generator F ⟶ F.obj X, Epi f
|
C : Type u
inst✝³ : Category.{v, u} C
D : Type v
inst✝² : SmallCategory D
F : D ⥤ Cᵒᵖ
inst✝¹ : Abelian C
inst✝ : IsGrothendieckAbelian.{v, v, u} C
X : D
⊢ ∃ f, Epi f
|
refine ⟨Sigma.desc (Pi.single X (𝟙 _)) ≫ Sigma.desc (fun f => f), ?_⟩
|
C : Type u
inst✝³ : Category.{v, u} C
D : Type v
inst✝² : SmallCategory D
F : D ⥤ Cᵒᵖ
inst✝¹ : Abelian C
inst✝ : IsGrothendieckAbelian.{v, v, u} C
X : D
⊢ Epi
(Sigma.desc
(Pi.single X
(𝟙 (∐ fun x => CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.projectiveSeparator C))) ≫
Sigma.desc fun f => f)
|
ba1692fa24a3cffa
|
Euclidean.closedBall_eq_image
|
Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean
|
theorem closedBall_eq_image (x : E) (r : ℝ) :
closedBall x r = toEuclidean.symm '' Metric.closedBall (toEuclidean x) r
|
E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : IsTopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ closedBall x r = ⇑toEuclidean.symm '' Metric.closedBall (toEuclidean x) r
|
rw [toEuclidean.image_symm_eq_preimage, closedBall_eq_preimage]
|
no goals
|
0001a621089f0d20
|
rotation_ne_conjLIE
|
Mathlib/Analysis/Complex/Isometry.lean
|
theorem rotation_ne_conjLIE (a : Circle) : rotation a ≠ conjLIE
|
a : Circle
⊢ rotation a ≠ conjLIE
|
intro h
|
a : Circle
h : rotation a = conjLIE
⊢ False
|
a62cbc42ea7f34f8
|
Nat.Linear.Certificate.of_combineHyps
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
|
theorem Certificate.of_combineHyps (ctx : Context) (c : PolyCnstr) (cs : Certificate) (h : (combineHyps c cs).denote ctx → False) : c.denote ctx → cs.denote ctx
|
ctx : Context
c : PolyCnstr
cs✝ : Certificate
k : Nat
c' : ExprCnstr
cs : List (Nat × ExprCnstr)
h : PolyCnstr.denote ctx (combineHyps c ((k, c') :: cs)) → False
⊢ PolyCnstr.denote ctx c → denote ctx ((k, c') :: cs)
|
intro h₁ h₂
|
ctx : Context
c : PolyCnstr
cs✝ : Certificate
k : Nat
c' : ExprCnstr
cs : List (Nat × ExprCnstr)
h : PolyCnstr.denote ctx (combineHyps c ((k, c') :: cs)) → False
h₁ : PolyCnstr.denote ctx c
h₂ : ExprCnstr.denote ctx c'
⊢ denote ctx cs
|
31feb49d52d674e6
|
DirichletCharacter.LSeriesSummable_iff
|
Mathlib/NumberTheory/LSeries/Dirichlet.lean
|
/-- The L-series of a Dirichlet character mod `N > 0` converges absolutely at `s` if and only if
`re s > 1`. -/
lemma LSeriesSummable_iff {N : ℕ} (hN : N ≠ 0) (χ : DirichletCharacter ℂ N) {s : ℂ} :
LSeriesSummable ↗χ s ↔ 1 < s.re
|
N : ℕ
hN : N ≠ 0
χ : DirichletCharacter ℂ N
s : ℂ
⊢ LSeriesSummable (fun n => χ ↑n) s ↔ 1 < s.re
|
refine ⟨fun H ↦ ?_, LSeriesSummable_of_one_lt_re χ⟩
|
N : ℕ
hN : N ≠ 0
χ : DirichletCharacter ℂ N
s : ℂ
H : LSeriesSummable (fun n => χ ↑n) s
⊢ 1 < s.re
|
def54cbe0d797bc5
|
Set.inter_indicator_mul
|
Mathlib/Algebra/GroupWithZero/Indicator.lean
|
lemma inter_indicator_mul (f g : ι → M₀) (i : ι) :
(s ∩ t).indicator (fun j ↦ f j * g j) i = s.indicator f i * t.indicator g i
|
ι : Type u_1
M₀ : Type u_4
inst✝ : MulZeroClass M₀
s t : Set ι
f g : ι → M₀
i : ι
⊢ (s ∩ t).indicator (fun j => f j * g j) i = s.indicator f i * t.indicator g i
|
rw [← Set.indicator_indicator]
|
ι : Type u_1
M₀ : Type u_4
inst✝ : MulZeroClass M₀
s t : Set ι
f g : ι → M₀
i : ι
⊢ s.indicator (t.indicator fun j => f j * g j) i = s.indicator f i * t.indicator g i
|
f1bcb382e3797e03
|
Multiset.sum_map_mul_right
|
Mathlib/Algebra/BigOperators/Ring/Multiset.lean
|
lemma sum_map_mul_right : sum (s.map fun i ↦ f i * a) = sum (s.map f) * a :=
Multiset.induction_on s (by simp) fun a s ih => by simp [ih, add_mul]
|
ι : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
a✝ : α
s✝ : Multiset ι
f : ι → α
a : ι
s : Multiset ι
ih : (map (fun i => f i * a✝) s).sum = (map f s).sum * a✝
⊢ (map (fun i => f i * a✝) (a ::ₘ s)).sum = (map f (a ::ₘ s)).sum * a✝
|
simp [ih, add_mul]
|
no goals
|
025acb62f462b207
|
SimpleGraph.IsTuranMaximal.nonempty_iso_turanGraph
|
Mathlib/Combinatorics/SimpleGraph/Turan.lean
|
theorem nonempty_iso_turanGraph :
Nonempty (G ≃g turanGraph (Fintype.card V) r)
|
case intro
V : Type u_1
inst✝¹ : Fintype V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
r : ℕ
h : G.IsTuranMaximal r
zm : { x // x ∈ univ } ≃ Fin #univ
zp :
∀ (a b : { x // x ∈ univ }),
h.finpartition.part ↑a = h.finpartition.part ↑b ↔ ↑(zm a) % #h.finpartition.parts = ↑(zm b) % #h.finpartition.parts
⊢ Nonempty (G ≃g turanGraph (Fintype.card V) r)
|
use (Equiv.subtypeUnivEquiv mem_univ).symm.trans zm
|
case map_rel_iff'
V : Type u_1
inst✝¹ : Fintype V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
r : ℕ
h : G.IsTuranMaximal r
zm : { x // x ∈ univ } ≃ Fin #univ
zp :
∀ (a b : { x // x ∈ univ }),
h.finpartition.part ↑a = h.finpartition.part ↑b ↔ ↑(zm a) % #h.finpartition.parts = ↑(zm b) % #h.finpartition.parts
⊢ ∀ {a b : V},
(turanGraph (Fintype.card V) r).Adj (((Equiv.subtypeUnivEquiv ⋯).symm.trans zm) a)
(((Equiv.subtypeUnivEquiv ⋯).symm.trans zm) b) ↔
G.Adj a b
|
a368d21921cbec7c
|
MeasureTheory.StronglyMeasurable.mono
|
Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
|
theorem mono {m m' : MeasurableSpace α} [TopologicalSpace β]
(hf : StronglyMeasurable[m'] f) (h_mono : m' ≤ m) : StronglyMeasurable[m] f
|
α : Type u_1
β : Type u_2
f : α → β
m m' : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
h_mono : m' ≤ m
⊢ StronglyMeasurable f
|
let f_approx : ℕ → @SimpleFunc α m β := fun n =>
@SimpleFunc.mk α m β
(hf.approx n)
(fun x => h_mono _ (SimpleFunc.measurableSet_fiber' _ x))
(SimpleFunc.finite_range (hf.approx n))
|
α : Type u_1
β : Type u_2
f : α → β
m m' : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
h_mono : m' ≤ m
f_approx : ℕ → α →ₛ β := fun n => { toFun := ⇑(hf.approx n), measurableSet_fiber' := ⋯, finite_range' := ⋯ }
⊢ StronglyMeasurable f
|
9ffa2b32d9636e7e
|
Ordinal.mul_add_div_mul
|
Mathlib/SetTheory/Ordinal/Arithmetic.lean
|
theorem mul_add_div_mul {a c : Ordinal} (hc : c < a) (b d : Ordinal) :
(a * b + c) / (a * d) = b / d
|
case inr
a c : Ordinal.{u_4}
hc : c < a
b d : Ordinal.{u_4}
ha : a ≠ 0
hd : d ≠ 0
H : a * d ≠ 0
⊢ (a * b + c) / (a * d) = b / d
|
apply le_antisymm
|
case inr.a
a c : Ordinal.{u_4}
hc : c < a
b d : Ordinal.{u_4}
ha : a ≠ 0
hd : d ≠ 0
H : a * d ≠ 0
⊢ (a * b + c) / (a * d) ≤ b / d
case inr.a
a c : Ordinal.{u_4}
hc : c < a
b d : Ordinal.{u_4}
ha : a ≠ 0
hd : d ≠ 0
H : a * d ≠ 0
⊢ b / d ≤ (a * b + c) / (a * d)
|
a58e67332447199e
|
Sym2.GameAdd.fix_eq
|
Mathlib/Order/GameAdd.lean
|
theorem GameAdd.fix_eq {C : α → α → Sort*} (hr : WellFounded rα)
(IH : ∀ a₁ b₁, (∀ a₂ b₂, Sym2.GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁) (a b : α) :
GameAdd.fix hr IH a b = IH a b fun a' b' _ => GameAdd.fix hr IH a' b'
|
α : Type u_1
rα : α → α → Prop
C : α → α → Sort u_3
hr : WellFounded rα
IH : (a₁ b₁ : α) → ((a₂ b₂ : α) → GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁
a b : α
⊢ fix hr IH a b = IH a b fun a' b' x => fix hr IH a' b'
|
dsimp [GameAdd.fix]
|
α : Type u_1
rα : α → α → Prop
C : α → α → Sort u_3
hr : WellFounded rα
IH : (a₁ b₁ : α) → ((a₂ b₂ : α) → GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁
a b : α
⊢ ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a, b) =
IH a b fun a' b' x => ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a', b')
|
0a1156822e7dedaa
|
hasCardinalLT_option_iff
|
Mathlib/SetTheory/Cardinal/HasCardinalLT.lean
|
lemma hasCardinalLT_option_iff (X : Type u) (κ : Cardinal.{w})
(hκ : Cardinal.aleph0 ≤ κ) :
HasCardinalLT (Option X) κ ↔ HasCardinalLT X κ
|
X : Type u
κ : Cardinal.{w}
hκ : Cardinal.aleph0 ≤ κ
x✝ : HasCardinalLT X κ
⊢ HasCardinalLT PUnit.{1} Cardinal.aleph0
|
rw [hasCardinalLT_aleph0_iff]
|
X : Type u
κ : Cardinal.{w}
hκ : Cardinal.aleph0 ≤ κ
x✝ : HasCardinalLT X κ
⊢ Finite PUnit.{1}
|
db42753f48328993
|
Int.add_assoc
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
|
theorem add_assoc : ∀ a b c : Int, a + b + c = a + (b + c)
| (m:Nat), (n:Nat), _ => aux1 ..
| Nat.cast m, b, Nat.cast k => by
rw [Int.add_comm, ← aux1, Int.add_comm k, aux1, Int.add_comm b]
| a, (n:Nat), (k:Nat) => by
rw [Int.add_comm, Int.add_comm a, ← aux1, Int.add_comm a, Int.add_comm k]
| -[_+1], -[_+1], (k:Nat) => aux2 ..
| -[m+1], (n:Nat), -[k+1] => by
rw [Int.add_comm, ← aux2, Int.add_comm n, ← aux2, Int.add_comm -[m+1]]
| (m:Nat), -[n+1], -[k+1] => by
rw [Int.add_comm, Int.add_comm m, Int.add_comm m, ← aux2, Int.add_comm -[k+1]]
| -[m+1], -[n+1], -[k+1] => by
simp [Nat.add_comm, Nat.add_left_comm, Nat.add_assoc]
where
aux1 (m n : Nat) : ∀ c : Int, m + n + c = m + (n + c)
| (k:Nat) => by simp [Nat.add_assoc]
| -[k+1] => by simp [subNatNat_add]
aux2 (m n k : Nat) : -[m+1] + -[n+1] + k = -[m+1] + (-[n+1] + k)
|
m n k : Nat
⊢ -[m+1] + -[n+1] + -[k+1] = -[m+1] + (-[n+1] + -[k+1])
|
simp [Nat.add_comm, Nat.add_left_comm, Nat.add_assoc]
|
no goals
|
3685d74f433bd852
|
fermatLastTheoremWith'_polynomial
|
Mathlib/NumberTheory/FLT/Polynomial.lean
|
theorem fermatLastTheoremWith'_polynomial {n : ℕ} (hn : 3 ≤ n) (chn : (n : k) ≠ 0) :
FermatLastTheoremWith' k[X] n
|
case intro.intro.intro
k : Type u_1
inst✝ : Field k
n : ℕ
hn : 3 ≤ n
chn : ↑n ≠ 0
a b c a' b' : k[X]
d : k[X] := gcd a b
hb : d ≠ 0 ∧ b' ≠ 0
ha : d ≠ 0 ∧ a' ≠ 0
eq_a : a = a' * d
eq_b : b = b' * d
hd : d ≠ 0
c' : k[X]
heq : a' ^ n + b' ^ n = c' ^ n
hc : d ≠ 0 ∧ c' ≠ 0
eq_c : c = c' * d
⊢ IsUnit a' ∧ IsUnit b' ∧ IsUnit c'
|
suffices goal : a'.natDegree = 0 ∧ b'.natDegree = 0 ∧ c'.natDegree = 0 by
simp [natDegree_eq_zero] at goal
obtain ⟨⟨ca', ha'⟩, ⟨cb', hb'⟩, ⟨cc', hc'⟩⟩ := goal
rw [← ha', ← hb', ← hc']
rw [← ha', C_ne_zero] at ha
rw [← hb', C_ne_zero] at hb
rw [← hc', C_ne_zero] at hc
exact ⟨ha.right.isUnit_C, hb.right.isUnit_C, hc.right.isUnit_C⟩
|
case intro.intro.intro
k : Type u_1
inst✝ : Field k
n : ℕ
hn : 3 ≤ n
chn : ↑n ≠ 0
a b c a' b' : k[X]
d : k[X] := gcd a b
hb : d ≠ 0 ∧ b' ≠ 0
ha : d ≠ 0 ∧ a' ≠ 0
eq_a : a = a' * d
eq_b : b = b' * d
hd : d ≠ 0
c' : k[X]
heq : a' ^ n + b' ^ n = c' ^ n
hc : d ≠ 0 ∧ c' ≠ 0
eq_c : c = c' * d
⊢ a'.natDegree = 0 ∧ b'.natDegree = 0 ∧ c'.natDegree = 0
|
0b2f8f9d4d152b49
|
CategoryTheory.PreGaloisCategory.exists_hom_from_galois_of_fiber_nonempty
|
Mathlib/CategoryTheory/Galois/Decomposition.lean
|
/-- Any object with non-empty fiber admits a hom from a Galois object. -/
lemma exists_hom_from_galois_of_fiber_nonempty (X : C) (h : Nonempty (F.obj X)) :
∃ (A : C) (_ : A ⟶ X), IsGalois A
|
case intro
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
x : (F.obj X).carrier
⊢ ∃ A x, IsGalois A
|
obtain ⟨A, f, a, h1, _⟩ := exists_hom_from_galois_of_fiber F X x
|
case intro.intro.intro.intro.intro
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
x : (F.obj X).carrier
A : C
f : A ⟶ X
a : (F.obj A).carrier
h1 : IsGalois A
right✝ : F.map f a = x
⊢ ∃ A x, IsGalois A
|
c1e1ad914efa42c5
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.