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
|
|---|---|---|---|---|---|---|
PrimeSpectrum.zeroLocus_eq_top_iff
|
Mathlib/RingTheory/Spectrum/Prime/Basic.lean
|
theorem zeroLocus_eq_top_iff (s : Set R) :
zeroLocus s = ⊤ ↔ s ⊆ nilradical R
|
R : Type u
inst✝ : CommSemiring R
s : Set R
⊢ zeroLocus s = ⊤ ↔ s ⊆ ↑(nilradical R)
|
constructor
|
case mp
R : Type u
inst✝ : CommSemiring R
s : Set R
⊢ zeroLocus s = ⊤ → s ⊆ ↑(nilradical R)
case mpr
R : Type u
inst✝ : CommSemiring R
s : Set R
⊢ s ⊆ ↑(nilradical R) → zeroLocus s = ⊤
|
71fbfa23dbaec95e
|
MeasureTheory.SimpleFunc.lintegral_mono_fun
|
Mathlib/MeasureTheory/Function/SimpleFunc.lean
|
theorem lintegral_mono_fun {f g : α →ₛ ℝ≥0∞} (h : f ≤ g) : f.lintegral μ ≤ g.lintegral μ
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ g✝ : α →ₛ ℝ≥0∞
h : f✝ ≤ g✝
f g : α →ₛ ℝ≥0∞
⊢ f.lintegral μ = (map Prod.fst (f.pair g)).lintegral μ
|
rw [map_fst_pair]
|
no goals
|
786bccc4e6df0904
|
List.lookupAll_nodup
|
Mathlib/Data/List/Sigma.lean
|
theorem lookupAll_nodup (a : α) {l : List (Sigma β)} (h : l.NodupKeys) : (lookupAll a l).Nodup
|
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (dlookup a l).toList.Nodup
|
apply Option.toList_nodup
|
no goals
|
dbaf0df3dc76943f
|
NNReal.inner_le_Lp_mul_Lq_tsum
|
Mathlib/Analysis/MeanInequalities.lean
|
theorem inner_le_Lp_mul_Lq_tsum {f g : ι → ℝ≥0} {p q : ℝ} (hpq : p.IsConjExponent q)
(hf : Summable fun i => f i ^ p) (hg : Summable fun i => g i ^ q) :
(Summable fun i => f i * g i) ∧
∑' i, f i * g i ≤ (∑' i, f i ^ p) ^ (1 / p) * (∑' i, g i ^ q) ^ (1 / q)
|
ι : Type u
f g : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
hf : Summable fun i => f i ^ p
hg : Summable fun i => g i ^ q
H₁ : ∀ (s : Finset ι), ∑ i ∈ s, f i * g i ≤ (∑' (i : ι), f i ^ p) ^ (1 / p) * (∑' (i : ι), g i ^ q) ^ (1 / q)
⊢ (∑' (i : ι), f i ^ p) ^ (1 / p) * (∑' (i : ι), g i ^ q) ^ (1 / q) ∈
upperBounds (Set.range fun s => ∑ i ∈ s, f i * g i)
|
rintro a ⟨s, rfl⟩
|
case intro
ι : Type u
f g : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
hf : Summable fun i => f i ^ p
hg : Summable fun i => g i ^ q
H₁ : ∀ (s : Finset ι), ∑ i ∈ s, f i * g i ≤ (∑' (i : ι), f i ^ p) ^ (1 / p) * (∑' (i : ι), g i ^ q) ^ (1 / q)
s : Finset ι
⊢ (fun s => ∑ i ∈ s, f i * g i) s ≤ (∑' (i : ι), f i ^ p) ^ (1 / p) * (∑' (i : ι), g i ^ q) ^ (1 / q)
|
a6de81c9fde72ed0
|
CategoryTheory.SingleFunctors.shiftIso_add_inv_app
|
Mathlib/CategoryTheory/Shift/SingleFunctors.lean
|
lemma shiftIso_add_inv_app (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
(F.shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha''])).inv.app X =
(F.shiftIso n a a' ha').inv.app X ≫
((F.shiftIso m a' a'' ha'').inv.app X)⟦n⟧' ≫
(shiftFunctorAdd D m n).inv.app ((F.functor a'').obj X)
|
C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁷ : Category.{?u.9398, u_1} C
inst✝⁶ : Category.{?u.9402, u_2} D
inst✝⁵ : Category.{?u.9406, u_3} E
inst✝⁴ : Category.{?u.9410, u_4} E'
A : Type u_5
inst✝³ : AddMonoid A
inst✝² : HasShift D A
inst✝¹ : HasShift E A
inst✝ : HasShift E' A
F G H : SingleFunctors C D A
n m a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ m + n + a = a''
|
rw [add_assoc, ha', ha'']
|
no goals
|
c6553c8cd9b3b20c
|
unitInterval.qRight_one_left
|
Mathlib/Topology/Homotopy/HSpaces.lean
|
theorem qRight_one_left (θ : I) : qRight (1, θ) = 1 :=
Set.projIcc_of_right_le _ <|
(le_div_iff₀ <| add_pos zero_lt_one).2 <| by
dsimp only
rw [coe_one, one_mul, mul_one, add_comm, ← one_add_one_eq_two]
simp only [add_le_add_iff_right]
exact le_one _
|
θ : ↑I
⊢ ↑θ + 1 ≤ 1 + 1
|
simp only [add_le_add_iff_right]
|
θ : ↑I
⊢ ↑θ ≤ 1
|
650383202ad70a0b
|
DirichletCharacter.not_even_and_odd
|
Mathlib/NumberTheory/DirichletCharacter/Basic.lean
|
lemma not_even_and_odd [NeZero (2 : S)] : ¬(ψ.Even ∧ ψ.Odd)
|
case intro
S : Type u_2
inst✝¹ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
inst✝ : NeZero 2
h : ψ (-1) = 1
h' : ψ (-1) = -1
⊢ False
|
simp only [h', neg_eq_iff_add_eq_zero, one_add_one_eq_two, two_ne_zero] at h
|
no goals
|
e0b452f759aa02bc
|
AkraBazziRecurrence.GrowsPolynomially.eventually_zero_of_frequently_zero
|
Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
|
lemma eventually_zero_of_frequently_zero (hf : GrowsPolynomially f) (hf' : ∃ᶠ x in atTop, f x = 0) :
∀ᶠ x in atTop, f x = 0
|
f : ℝ → ℝ
hf✝ : GrowsPolynomially f
hf' : ∀ (a : ℝ), ∃ b ≥ a, f b = 0
c₁ : ℝ
hc₁_mem : c₁ > 0
c₂ : ℝ
hc₂_mem : c₂ > 0
hf : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (1 / 2 * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)
x : ℝ
hx : ∀ (y : ℝ), x ≤ y → ∀ u ∈ Set.Icc (1 / 2 * y) y, f u ∈ Set.Icc (c₁ * f y) (c₂ * f y)
hx_pos : 0 < x
x₀ : ℝ
hx₀_ge : x₀ ≥ x ⊔ 1
hx₀ : f x₀ = 0
x₀_pos : 0 < x₀
hmain : ∀ (m : ℕ) (z : ℝ), x ≤ z → z ∈ Set.Icc (2 ^ (-↑m - 1) * x₀) (2 ^ (-↑m) * x₀) → f z = 0
⊢ 2 ^ (-↑⌊-logb 2 (x / x₀)⌋₊ - 1) ≤ x / x₀
|
refine (logb_le_logb (b := 2) (by norm_num) (zpow_pos (by norm_num) _)
(by positivity)).mp ?_
|
f : ℝ → ℝ
hf✝ : GrowsPolynomially f
hf' : ∀ (a : ℝ), ∃ b ≥ a, f b = 0
c₁ : ℝ
hc₁_mem : c₁ > 0
c₂ : ℝ
hc₂_mem : c₂ > 0
hf : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (1 / 2 * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)
x : ℝ
hx : ∀ (y : ℝ), x ≤ y → ∀ u ∈ Set.Icc (1 / 2 * y) y, f u ∈ Set.Icc (c₁ * f y) (c₂ * f y)
hx_pos : 0 < x
x₀ : ℝ
hx₀_ge : x₀ ≥ x ⊔ 1
hx₀ : f x₀ = 0
x₀_pos : 0 < x₀
hmain : ∀ (m : ℕ) (z : ℝ), x ≤ z → z ∈ Set.Icc (2 ^ (-↑m - 1) * x₀) (2 ^ (-↑m) * x₀) → f z = 0
⊢ logb 2 (2 ^ (-↑⌊-logb 2 (x / x₀)⌋₊ - 1)) ≤ logb 2 (x / x₀)
|
b2c5c4c5d5df705a
|
AkraBazziRecurrence.smoothingFn_mul_asympBound_isBigO_T
|
Mathlib/Computability/AkraBazzi/AkraBazzi.lean
|
/-- The main proof of the lower bound part of the Akra-Bazzi theorem. The factor
`1 + ε n` does not change the asymptotic order, but is needed for the induction step to go
through. -/
lemma smoothingFn_mul_asympBound_isBigO_T :
(fun (n : ℕ) => (1 + ε n) * asympBound g a b n) =O[atTop] T
|
case bc.h.h
α : Type u_1
inst✝¹ : Fintype α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
inst✝ : Nonempty α
R : AkraBazziRecurrence T g a b r
b' : ℝ := b (min_bi b) / 2
hb_pos : 0 < b'
c₁ : ℝ
hc₁ : c₁ > 0
h_sumTransform_aux : ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), sumTransform (p a b) g (r i n) n ≤ c₁ * g ↑n
n₀ : ℕ
n₀_ge_Rn₀ : R.n₀ ≤ n₀
h_b_floor : 0 < ⌊b' * ↑n₀⌋₊
h_smoothing_pos : ∀ (y : ℕ), n₀ ≤ y → 0 < 1 + ε ↑y
h_smoothing_pos' : ∀ (y : ℕ), ⌊b' * ↑n₀⌋₊ ≤ y → 0 < 1 + ε ↑y
h_asympBound_pos : ∀ (y : ℕ), n₀ ≤ y → 0 < asympBound g a b y
h_asympBound_r_pos : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), 0 < asympBound g a b (r i y)
h_asympBound_floor : ∀ (y : ℕ), ⌊b' * ↑n₀⌋₊ ≤ y → 0 < asympBound g a b y
n₀_pos : 0 < n₀
h_smoothing_r_pos : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), 0 < 1 + ε ↑(r i y)
bound2 : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), b i ^ p a b * ↑y ^ p a b * (1 + ε ↑y) ≤ ↑(r i y) ^ p a b * (1 + ε ↑(r i y))
h_smoothingFn_floor : ∀ (y : ℕ), ⌊b' * ↑n₀⌋₊ ≤ y → 0 < 1 + ε ↑y
h_sumTransform : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), sumTransform (p a b) g (r i y) y ≤ c₁ * g ↑y
h_bi_le_r : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), b (min_bi b) / 2 * ↑y ≤ ↑(r i y)
h_exp : ∀ (y : ℕ), n₀ ≤ y → ⌈rexp 1⌉₊ ≤ y
h_base_nonempty : (Ico ⌊b (min_bi b) / 2 * ↑n₀⌋₊ n₀).Nonempty
base_min : ℝ := (Ico ⌊b' * ↑n₀⌋₊ n₀).inf' h_base_nonempty fun n => T n / ((1 + ε ↑n) * asympBound g a b n)
base_min_def : base_min = (Ico ⌊b' * ↑n₀⌋₊ n₀).inf' h_base_nonempty fun n => T n / ((1 + ε ↑n) * asympBound g a b n)
C : ℝ := (2 * c₁)⁻¹ ⊓ base_min
hC_pos : 0 < C
h_base : ∀ n ∈ Ico ⌊b' * ↑n₀⌋₊ n₀, C * ((1 + ε ↑n) * asympBound g a b n) ≤ T n
n : ℕ
h_ind : ∀ m < n, m ≥ n₀ → 0 < asympBound g a b m → 0 < 1 + ε ↑m → C * ((1 + ε ↑m) * asympBound g a b m) ≤ T m
hn : n ≥ n₀
h_asympBound_pos' : 0 < asympBound g a b n
h_one_sub_smoothingFn_pos' : 0 < 1 + ε ↑n
b_mul_n₀_le_ri : ∀ (i : α), ⌊b' * ↑n₀⌋₊ ≤ r i n
g_pos : 0 ≤ g ↑n
i : α
a✝ : i ∈ univ
⊢ C * ((1 + ε ↑(r i n)) * asympBound g a b (r i n)) ≤ T (r i n)
|
cases lt_or_le (r i n) n₀ with
| inl ri_lt_n₀ => exact h_base _ <| Finset.mem_Ico.mpr ⟨b_mul_n₀_le_ri i, ri_lt_n₀⟩
| inr n₀_le_ri =>
exact h_ind (r i n) (R.r_lt_n _ _ (n₀_ge_Rn₀.trans hn)) n₀_le_ri
(h_asympBound_r_pos _ hn _) (h_smoothing_r_pos n hn i)
|
no goals
|
82bb51116c3f899e
|
MeasureTheory.QuotientMeasureEqMeasurePreimage.haarMeasure_quotient
|
Mathlib/MeasureTheory/Measure/Haar/Quotient.lean
|
theorem MeasureTheory.QuotientMeasureEqMeasurePreimage.haarMeasure_quotient [LocallyCompactSpace G]
[QuotientMeasureEqMeasurePreimage ν μ] [i : HasFundamentalDomain Γ.op G ν]
[IsFiniteMeasure μ] : IsHaarMeasure μ
|
case intro.mk.intro.ctop
G : Type u_1
inst✝¹⁴ : Group G
inst✝¹³ : MeasurableSpace G
inst✝¹² : TopologicalSpace G
inst✝¹¹ : IsTopologicalGroup G
inst✝¹⁰ : BorelSpace G
inst✝⁹ : PolishSpace G
Γ : Subgroup G
inst✝⁸ : Γ.Normal
inst✝⁷ : T2Space (G ⧸ Γ)
inst✝⁶ : SecondCountableTopology (G ⧸ Γ)
μ : Measure (G ⧸ Γ)
inst✝⁵ : Countable ↥Γ
ν : Measure G
inst✝⁴ : ν.IsHaarMeasure
inst✝³ : ν.IsMulRightInvariant
inst✝² : LocallyCompactSpace G
inst✝¹ : QuotientMeasureEqMeasurePreimage ν μ
inst✝ : IsFiniteMeasure μ
K : PositiveCompacts G
K' : PositiveCompacts (G ⧸ Γ) := PositiveCompacts.map QuotientGroup.mk ⋯ ⋯ K
this : μ.IsMulLeftInvariant
s : Set G
finiteCovol : ν s ≠ ⊤
fund_dom_s : IsFundamentalDomain (↥Γ.op) s ν
⊢ ν (Quotient.mk (MulAction.orbitRel (↥Γ.op) G) ⁻¹' ↑K' ∩ s) ≠ ⊤
|
show ν (π ⁻¹' (π '' K) ∩ s) ≠ ⊤
|
case intro.mk.intro.ctop
G : Type u_1
inst✝¹⁴ : Group G
inst✝¹³ : MeasurableSpace G
inst✝¹² : TopologicalSpace G
inst✝¹¹ : IsTopologicalGroup G
inst✝¹⁰ : BorelSpace G
inst✝⁹ : PolishSpace G
Γ : Subgroup G
inst✝⁸ : Γ.Normal
inst✝⁷ : T2Space (G ⧸ Γ)
inst✝⁶ : SecondCountableTopology (G ⧸ Γ)
μ : Measure (G ⧸ Γ)
inst✝⁵ : Countable ↥Γ
ν : Measure G
inst✝⁴ : ν.IsHaarMeasure
inst✝³ : ν.IsMulRightInvariant
inst✝² : LocallyCompactSpace G
inst✝¹ : QuotientMeasureEqMeasurePreimage ν μ
inst✝ : IsFiniteMeasure μ
K : PositiveCompacts G
K' : PositiveCompacts (G ⧸ Γ) := PositiveCompacts.map QuotientGroup.mk ⋯ ⋯ K
this : μ.IsMulLeftInvariant
s : Set G
finiteCovol : ν s ≠ ⊤
fund_dom_s : IsFundamentalDomain (↥Γ.op) s ν
⊢ ν (QuotientGroup.mk ⁻¹' (QuotientGroup.mk '' ↑K) ∩ s) ≠ ⊤
|
d4b9c01a9d05b936
|
NumberField.Embeddings.finite_of_norm_le
|
Mathlib/NumberTheory/NumberField/Embeddings.lean
|
theorem finite_of_norm_le (B : ℝ) : {x : K | IsIntegral ℤ x ∧ ∀ φ : K →+* A, ‖φ x‖ ≤ B}.Finite
|
case refine_2
K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
C : ℕ := ⌈(B ⊔ 1) ^ finrank ℚ K * ↑((finrank ℚ K).choose (finrank ℚ K / 2))⌉₊
this :
(⋃ f,
⋃ (_ : f.natDegree ≤ finrank ℚ K ∧ ∀ (i : ℕ), f.coeff i ∈ Icc (-↑C) ↑C),
↑(map (algebraMap ℤ K) f).roots.toFinset).Finite
x : K
hx : x ∈ {x | IsIntegral ℤ x ∧ ∀ (φ : K →+* A), ‖φ x‖ ≤ B}
h_map_ℚ_minpoly : minpoly ℚ x = map (algebraMap ℤ ℚ) (minpoly ℤ x)
i : ℕ
⊢ ↑|(minpoly ℤ x).coeff i| ≤ ↑↑C
|
refine (Eq.trans_le ?_ <| coeff_bdd_of_norm_le hx.2 i).trans (Nat.le_ceil _)
|
case refine_2
K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
A : Type u_2
inst✝² : NormedField A
inst✝¹ : IsAlgClosed A
inst✝ : NormedAlgebra ℚ A
B : ℝ
C : ℕ := ⌈(B ⊔ 1) ^ finrank ℚ K * ↑((finrank ℚ K).choose (finrank ℚ K / 2))⌉₊
this :
(⋃ f,
⋃ (_ : f.natDegree ≤ finrank ℚ K ∧ ∀ (i : ℕ), f.coeff i ∈ Icc (-↑C) ↑C),
↑(map (algebraMap ℤ K) f).roots.toFinset).Finite
x : K
hx : x ∈ {x | IsIntegral ℤ x ∧ ∀ (φ : K →+* A), ‖φ x‖ ≤ B}
h_map_ℚ_minpoly : minpoly ℚ x = map (algebraMap ℤ ℚ) (minpoly ℤ x)
i : ℕ
⊢ ↑|(minpoly ℤ x).coeff i| = ‖(minpoly ℚ x).coeff i‖
|
48ab9bf766b69c4b
|
Polynomial.irreducible_of_mirror
|
Mathlib/Algebra/Polynomial/Mirror.lean
|
theorem irreducible_of_mirror (h1 : ¬IsUnit f)
(h2 : ∀ k, f * f.mirror = k * k.mirror → k = f ∨ k = -f ∨ k = f.mirror ∨ k = -f.mirror)
(h3 : IsRelPrime f f.mirror) : Irreducible f
|
case isUnit_or_isUnit'.inr.inr.inl
R : Type u_1
inst✝¹ : CommRing R
inst✝ : NoZeroDivisors R
f : R[X]
h1 : ¬IsUnit f
h2 : ∀ (k : R[X]), f * f.mirror = k * k.mirror → k = f ∨ k = -f ∨ k = f.mirror ∨ k = -f.mirror
h3 : IsRelPrime f f.mirror
g h : R[X]
fgh : f = g * h
k : R[X] := g * h.mirror
key : f * f.mirror = k * k.mirror
g_dvd_f : g ∣ f
h_dvd_f : h ∣ f
g_dvd_k : g ∣ k
h_dvd_k_rev : h ∣ k.mirror
hk : k = f.mirror
⊢ IsUnit g ∨ IsUnit h
|
exact Or.inl (h3 g_dvd_f (by rwa [← hk]))
|
no goals
|
a3689552bdbf2ce5
|
spectrum.hasDerivAt_resolvent
|
Mathlib/Analysis/Normed/Algebra/Spectrum.lean
|
theorem hasDerivAt_resolvent {a : A} {k : 𝕜} (hk : k ∈ ρ a) :
HasDerivAt (resolvent a) (-resolvent a k ^ 2) k
|
𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
k : 𝕜
hk : k ∈ ρ a
H₁ :
HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 A) ↑(IsUnit.unit hk)⁻¹) ↑(IsUnit.unit hk)⁻¹)
(↑ₐ k - a)
⊢ HasDerivAt (resolvent a) (-resolvent a k ^ 2) k
|
have H₂ : HasDerivAt (fun k => ↑ₐ k - a) 1 k := by
simpa using (Algebra.linearMap 𝕜 A).hasDerivAt.sub_const a
|
𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
k : 𝕜
hk : k ∈ ρ a
H₁ :
HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 A) ↑(IsUnit.unit hk)⁻¹) ↑(IsUnit.unit hk)⁻¹)
(↑ₐ k - a)
H₂ : HasDerivAt (fun k => ↑ₐ k - a) 1 k
⊢ HasDerivAt (resolvent a) (-resolvent a k ^ 2) k
|
5377dbdfd1b8eacf
|
IsFractionRing.isFractionRing_iff_of_base_ringEquiv
|
Mathlib/RingTheory/Localization/FractionRing.lean
|
theorem isFractionRing_iff_of_base_ringEquiv (h : R ≃+* P) :
IsFractionRing R S ↔
@IsFractionRing P _ S _ ((algebraMap R S).comp h.symm.toRingHom).toAlgebra
|
case h.e'_2.h.e'_3.h.mp
R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommRing P
h : R ≃+* P
x : P
hx : x ∈ nonZeroDivisors P
z : R
hz : z * h.symm x = 0
⊢ h z = 0
|
apply hx
|
case h.e'_2.h.e'_3.h.mp.a
R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommRing P
h : R ≃+* P
x : P
hx : x ∈ nonZeroDivisors P
z : R
hz : z * h.symm x = 0
⊢ h z * x = 0
|
0e985e670472cae2
|
ProbabilityTheory.Kernel.withDensity_rnDeriv_mutuallySingularSetSlice
|
Mathlib/Probability/Kernel/RadonNikodym.lean
|
lemma withDensity_rnDeriv_mutuallySingularSetSlice (κ η : Kernel α γ) [IsFiniteKernel κ]
[IsFiniteKernel η] (a : α) :
withDensity η (rnDeriv κ η) a (mutuallySingularSetSlice κ η a) = 0
|
case hf
α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ Measurable (Function.uncurry (κ.rnDeriv η))
|
exact measurable_rnDeriv κ η
|
no goals
|
9159674b5f98d2a8
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_derivedLits
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean
|
theorem nodup_derivedLits {n : Nat} (f : DefaultFormula n)
(f_assignments_size : f.assignments.size = n) (rupHints : Array Nat)
(f'_assignments_size : (performRupCheck f rupHints).1.assignments.size = n)
(derivedLits : CNF.Clause (PosFin n))
(derivedLits_satisfies_invariant:
DerivedLitsInvariant f f_assignments_size (performRupCheck f rupHints).fst.assignments f'_assignments_size derivedLits)
(derivedLits_arr : Array (Literal (PosFin n))) (derivedLits_arr_def : derivedLits_arr = { toList := derivedLits })
(i j : Fin (Array.size derivedLits_arr)) (i_ne_j : i ≠ j) :
derivedLits_arr[i] ≠ derivedLits_arr[j]
|
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : CNF.Clause (PosFin n)
derivedLits_satisfies_invariant :
f.DerivedLitsInvariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { toList := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
⊢ ↑i < List.length derivedLits
|
have i_property := i.2
|
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : CNF.Clause (PosFin n)
derivedLits_satisfies_invariant :
f.DerivedLitsInvariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { toList := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_property : ↑i < derivedLits_arr.size
⊢ ↑i < List.length derivedLits
|
b565b2925b517fa0
|
CategoryTheory.Functor.Final.colimit_cocone_comp_aux
|
Mathlib/CategoryTheory/Limits/Final.lean
|
theorem colimit_cocone_comp_aux (s : Cocone (F ⋙ G)) (j : C) :
G.map (homToLift F (F.obj j)) ≫ s.ι.app (lift F (F.obj j)) = s.ι.app j
|
case h₁
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : F.Final
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
s : Cocone (F ⋙ G)
j j₁ j₂ : C
k₁ : F.obj j ⟶ F.obj j₁
k₂ : F.obj j ⟶ F.obj j₂
f : j₁ ⟶ j₂
w : k₁ ≫ F.map f = k₂
h : G.map k₁ ≫ (F ⋙ G).map f ≫ s.ι.app j₂ = s.ι.app j
⊢ G.map (k₁ ≫ F.map f) ≫ s.ι.app j₂ = s.ι.app j
|
simpa using h
|
no goals
|
532ac5abfe61921e
|
Vector.back_ofFn
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/OfFn.lean
|
theorem back_ofFn {n} [NeZero n](f : Fin n → α) :
(ofFn f).back = f ⟨n - 1, by have := NeZero.ne n; omega⟩
|
α : Type ?u.2100
n : Nat
inst✝ : NeZero n
f : Fin n → α
⊢ n - 1 < n
|
have := NeZero.ne n
|
α : Type ?u.2100
n : Nat
inst✝ : NeZero n
f : Fin n → α
this : n ≠ 0
⊢ n - 1 < n
|
ff20e9dfbe02ef4f
|
PFun.preimage_univ
|
Mathlib/Data/PFun.lean
|
theorem preimage_univ : f.preimage Set.univ = f.Dom
|
case h
α : Type u_1
β : Type u_2
f : α →. β
x✝ : α
⊢ x✝ ∈ f.preimage Set.univ ↔ x✝ ∈ f.Dom
|
simp [mem_preimage, mem_dom]
|
no goals
|
56e7c59c781a4d5d
|
List.pmap_eq_self
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Attach.lean
|
theorem pmap_eq_self {l : List α} {p : α → Prop} {hp : ∀ (a : α), a ∈ l → p a}
{f : (a : α) → p a → α} : l.pmap f hp = l ↔ ∀ a (h : a ∈ l), f a (hp a h) = a
|
α : Type u_1
l : List α
p : α → Prop
hp : ∀ (a : α), a ∈ l → p a
f : (a : α) → p a → α
⊢ pmap f l hp = l ↔ ∀ (a : α) (h : a ∈ l), f a ⋯ = a
|
rw [pmap_eq_map_attach]
|
α : Type u_1
l : List α
p : α → Prop
hp : ∀ (a : α), a ∈ l → p a
f : (a : α) → p a → α
⊢ map (fun x => f x.val ⋯) l.attach = l ↔ ∀ (a : α) (h : a ∈ l), f a ⋯ = a
|
01327717807452b8
|
List.reverse_zipWith
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Nat/TakeDrop.lean
|
theorem reverse_zipWith (h : l.length = l'.length) :
(zipWith f l l').reverse = zipWith f l.reverse l'.reverse
|
case cons.nil
α✝² : Type u_1
α✝¹ : Type u_2
α✝ : Type u_3
f : α✝² → α✝¹ → α✝
hd : α✝²
tl : List α✝²
hl : ∀ {l' : List α✝¹}, tl.length = l'.length → (zipWith f tl l').reverse = zipWith f tl.reverse l'.reverse
h : (hd :: tl).length = [].length
⊢ (zipWith f (hd :: tl) []).reverse = zipWith f (hd :: tl).reverse [].reverse
|
simp
|
no goals
|
b395689bbe06d7b0
|
not_integrableOn_Ioi_cpow
|
Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
|
theorem not_integrableOn_Ioi_cpow (s : ℂ) :
¬ IntegrableOn (fun x : ℝ ↦ (x : ℂ) ^ s) (Ioi (0 : ℝ))
|
case inr
s : ℂ
h : IntegrableOn (fun x => ↑x ^ s) (Ioi 0) volume
hs : -1 < s.re
⊢ False
|
have : IntegrableOn (fun x : ℝ ↦ (x : ℂ) ^ s) (Ioi 1) :=
h.mono (Ioi_subset_Ioi zero_le_one) le_rfl
|
case inr
s : ℂ
h : IntegrableOn (fun x => ↑x ^ s) (Ioi 0) volume
hs : -1 < s.re
this : IntegrableOn (fun x => ↑x ^ s) (Ioi 1) volume
⊢ False
|
443b379bbb811a88
|
Filter.HasBasis.uniformity_of_nhds_one_inv_mul_swapped
|
Mathlib/Topology/Algebra/UniformGroup/Defs.lean
|
theorem Filter.HasBasis.uniformity_of_nhds_one_inv_mul_swapped {ι} {p : ι → Prop} {U : ι → Set α}
(h : (𝓝 (1 : α)).HasBasis p U) :
(𝓤 α).HasBasis p fun i => { x : α × α | x.2⁻¹ * x.1 ∈ U i }
|
α : Type u_1
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Sort u_3
p : ι → Prop
U : ι → Set α
h : (𝓝 1).HasBasis p U
⊢ (𝓤 α).HasBasis p fun i => {x | x.2⁻¹ * x.1 ∈ U i}
|
rw [uniformity_eq_comap_inv_mul_nhds_one_swapped]
|
α : Type u_1
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Sort u_3
p : ι → Prop
U : ι → Set α
h : (𝓝 1).HasBasis p U
⊢ (Filter.comap (fun x => x.2⁻¹ * x.1) (𝓝 1)).HasBasis p fun i => {x | x.2⁻¹ * x.1 ∈ U i}
|
c8de413340aceb87
|
Fin.accumulate_rec
|
Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean
|
lemma accumulate_rec {i n m : ℕ} (hin : i < n) (him : i + 1 < m) (t : Fin n → ℕ) :
accumulate n m t ⟨i, Nat.lt_of_succ_lt him⟩ = t ⟨i, hin⟩ + accumulate n m t ⟨i + 1, him⟩
|
i n m : ℕ
hin : i < n
him : i + 1 < m
t : Fin n → ℕ
⊢ ∑ i ∈ filter (fun i_1 => i ≤ ↑i_1) univ, t i = t ⟨i, hin⟩ + ∑ i ∈ filter (fun i_1 => i + 1 ≤ ↑i_1) univ, t i
|
convert (add_sum_erase _ _ _).symm
|
case h.e'_3.h.e'_6.h
i n m : ℕ
hin : i < n
him : i + 1 < m
t : Fin n → ℕ
⊢ filter (fun i_1 => i + 1 ≤ ↑i_1) univ = (filter (fun i_1 => i ≤ ↑i_1) univ).erase ⟨i, hin⟩
case convert_3
i n m : ℕ
hin : i < n
him : i + 1 < m
t : Fin n → ℕ
⊢ DecidableEq (Fin n)
case convert_7
i n m : ℕ
hin : i < n
him : i + 1 < m
t : Fin n → ℕ
⊢ ⟨i, hin⟩ ∈ filter (fun i_1 => i ≤ ↑i_1) univ
|
3bde688e16503a13
|
Localization.existsUnique_algebraMap_eq_of_span_eq_top
|
Mathlib/RingTheory/Localization/Away/Basic.lean
|
theorem existsUnique_algebraMap_eq_of_span_eq_top (s : Set R) (span_eq : Ideal.span s = ⊤)
(f : Π a : s, Away a.1) (h : ∀ a b : s,
Away.awayToAwayRight (P := Away (a * b : R)) a.1 b (f a) = Away.awayToAwayLeft b.1 a (f b)) :
∃! r : R, ∀ a : s, algebraMap R _ r = f a
|
case inr
R : Type u_1
inst✝ : CommSemiring R
s : Set R
f : (a : ↑s) → Away ↑a
h : ∀ (a b : ↑s), (Away.awayToAwayRight ↑a ↑b) (f a) = (Away.awayToAwayLeft ↑b ↑a) (f b)
mem✝ : 1 ∈ Ideal.span s
this :
∀ (s : Set R) (f : (a : ↑s) → Away ↑a),
(∀ (a b : ↑s), (Away.awayToAwayRight ↑a ↑b) (f a) = (Away.awayToAwayLeft ↑b ↑a) (f b)) →
1 ∈ Ideal.span s → (∃ t, ↑t = s) → ∃! r, ∀ (a : ↑s), (algebraMap R (Away ↑a)) r = f a
finset_eq : ¬∃ t, ↑t = s
t : Finset R
hts : ↑t ⊆ s
mem : 1 ∈ Submodule.span R ↑t
⊢ ∃! r, ∀ (a : ↑s), (algebraMap R (Away ↑a)) r = f a
|
have ⟨r, eq, uniq⟩ := this t (fun a ↦ f ⟨a, hts a.2⟩)
(fun a b ↦ h ⟨a, hts a.2⟩ ⟨b, hts b.2⟩) mem ⟨_, rfl⟩
|
case inr
R : Type u_1
inst✝ : CommSemiring R
s : Set R
f : (a : ↑s) → Away ↑a
h : ∀ (a b : ↑s), (Away.awayToAwayRight ↑a ↑b) (f a) = (Away.awayToAwayLeft ↑b ↑a) (f b)
mem✝ : 1 ∈ Ideal.span s
this :
∀ (s : Set R) (f : (a : ↑s) → Away ↑a),
(∀ (a b : ↑s), (Away.awayToAwayRight ↑a ↑b) (f a) = (Away.awayToAwayLeft ↑b ↑a) (f b)) →
1 ∈ Ideal.span s → (∃ t, ↑t = s) → ∃! r, ∀ (a : ↑s), (algebraMap R (Away ↑a)) r = f a
finset_eq : ¬∃ t, ↑t = s
t : Finset R
hts : ↑t ⊆ s
mem : 1 ∈ Submodule.span R ↑t
r : R
eq : (fun r => ∀ (a : ↑↑t), (algebraMap R (Away ↑a)) r = f ⟨↑a, ⋯⟩) r
uniq : ∀ (y : R), (fun r => ∀ (a : ↑↑t), (algebraMap R (Away ↑a)) r = f ⟨↑a, ⋯⟩) y → y = r
⊢ ∃! r, ∀ (a : ↑s), (algebraMap R (Away ↑a)) r = f a
|
451126b322cfd0c5
|
MeasureTheory.eLpNorm'_le_eLpNorm'_mul_rpow_measure_univ
|
Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
|
theorem eLpNorm'_le_eLpNorm'_mul_rpow_measure_univ {p q : ℝ} (hp0_lt : 0 < p) (hpq : p ≤ q)
(hf : AEStronglyMeasurable f μ) :
eLpNorm' f p μ ≤ eLpNorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)
|
α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
μ : Measure α
f : α → E
p q : ℝ
hp0_lt : 0 < p
hpq : p ≤ q
hf : AEStronglyMeasurable f μ
⊢ eLpNorm' f p μ ≤ eLpNorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)
|
have hq0_lt : 0 < q := lt_of_lt_of_le hp0_lt hpq
|
α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
μ : Measure α
f : α → E
p q : ℝ
hp0_lt : 0 < p
hpq : p ≤ q
hf : AEStronglyMeasurable f μ
hq0_lt : 0 < q
⊢ eLpNorm' f p μ ≤ eLpNorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)
|
78215b1c74b9f3ae
|
Language.accepts_toDFA
|
Mathlib/Computability/MyhillNerode.lean
|
theorem accepts_toDFA : L.toDFA.accepts = L
|
α : Type u
L : Language α
⊢ L.toDFA.accepts = L
|
ext x
|
case h
α : Type u
L : Language α
x : List α
⊢ x ∈ L.toDFA.accepts ↔ x ∈ L
|
33eacd9417dfbf8c
|
Fin.cycleRange_of_le
|
Mathlib/GroupTheory/Perm/Fin.lean
|
theorem cycleRange_of_le {n : ℕ} [NeZero n] {i j : Fin n} (h : j ≤ i) :
cycleRange i j = if j = i then 0 else j + 1
|
case neg
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
i j : Fin (n✝ + 1)
h : j ≤ i
this : j = castLE ⋯ ⟨↑j, ⋯⟩
heq : ¬↑j = ↑i
⊢ ↑j + 1 = ↑(j + 1)
|
rw [Fin.val_add_one_of_lt]
|
case neg
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
i j : Fin (n✝ + 1)
h : j ≤ i
this : j = castLE ⋯ ⟨↑j, ⋯⟩
heq : ¬↑j = ↑i
⊢ j < last n✝
|
243d07b9e65f3293
|
Equiv.Perm.prod_prodExtendRight
|
Mathlib/GroupTheory/Perm/Sign.lean
|
theorem prod_prodExtendRight {α : Type*} [DecidableEq α] (σ : α → Perm β) {l : List α}
(hl : l.Nodup) (mem_l : ∀ a, a ∈ l) :
(l.map fun a => prodExtendRight a (σ a)).prod = prodCongrRight σ
|
case neg
β : Type v
α : Type u_1
inst✝ : DecidableEq α
σ : α → Perm β
a : α
b : β
a' : α
l : List α
ih :
l.Nodup →
a ∈ l ∧ (List.map (fun a => prodExtendRight a (σ a)) l).prod (a, b) = (a, (σ a) b) ∨
a ∉ l ∧ (List.map (fun a => prodExtendRight a (σ a)) l).prod (a, b) = (a, b)
hl : (a' :: l).Nodup
not_mem_l : a ∉ l
prod_eq : (List.map (fun a => prodExtendRight a (σ a)) l).prod (a, b) = (a, b)
ha' : ¬a = a'
⊢ (prodExtendRight a' (σ a')) (a, b) = (a, b)
|
rw [prodExtendRight_apply_ne _ ha']
|
no goals
|
a0e8aaef4d058ac5
|
Complex.norm_deriv_le_of_forall_mem_sphere_norm_le
|
Mathlib/Analysis/Complex/Liouville.lean
|
theorem norm_deriv_le_of_forall_mem_sphere_norm_le {c : ℂ} {R C : ℝ} {f : ℂ → F} (hR : 0 < R)
(hd : DiffContOnCl ℂ f (ball c R)) (hC : ∀ z ∈ sphere c R, ‖f z‖ ≤ C) :
‖deriv f c‖ ≤ C / R
|
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
c : ℂ
R C : ℝ
f : ℂ → F
hR : 0 < R
hd : DiffContOnCl ℂ f (ball c R)
hC : ∀ z ∈ sphere c R, ‖f z‖ ≤ C
e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
this : HasDerivAt (⇑e ∘ f) (e (deriv f c)) c
⊢ ‖deriv f c‖ ≤ C / R
|
calc
‖deriv f c‖ = ‖deriv (e ∘ f) c‖ := by
rw [this.deriv]
exact (UniformSpace.Completion.norm_coe _).symm
_ ≤ C / R :=
norm_deriv_le_aux hR (e.differentiable.comp_diffContOnCl hd) fun z hz =>
(UniformSpace.Completion.norm_coe _).trans_le (hC z hz)
|
no goals
|
e74ce06586753507
|
AList.insertRec_insert
|
Mathlib/Data/List/AList.lean
|
theorem insertRec_insert {C : AList β → Sort*} (H0 : C ∅)
(IH : ∀ (a : α) (b : β a) (l : AList β), a ∉ l → C l → C (l.insert a b)) {c : Sigma β}
{l : AList β} (h : c.1 ∉ l) :
@insertRec α β _ C H0 IH (l.insert c.1 c.2) = IH c.1 c.2 l h (@insertRec α β _ C H0 IH l)
|
α : Type u
β : α → Type v
inst✝ : DecidableEq α
C : AList β → Sort u_1
H0 : C ∅
IH : (a : α) → (b : β a) → (l : AList β) → a ∉ l → C l → C (insert a b l)
c : Sigma β
l : List (Sigma β)
hl : l.NodupKeys
h : c.fst ∉ { entries := l, nodupKeys := hl }
this :
HEq (insertRec H0 IH { entries := c :: l, nodupKeys := ⋯ })
(IH c.fst c.snd { entries := l, nodupKeys := hl } h (insertRec H0 IH { entries := l, nodupKeys := hl }))
⊢ insertRec H0 IH (insert c.fst c.snd { entries := l, nodupKeys := hl }) =
IH c.fst c.snd { entries := l, nodupKeys := hl } h (insertRec H0 IH { entries := l, nodupKeys := hl })
|
cases c
|
case mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
C : AList β → Sort u_1
H0 : C ∅
IH : (a : α) → (b : β a) → (l : AList β) → a ∉ l → C l → C (insert a b l)
l : List (Sigma β)
hl : l.NodupKeys
fst✝ : α
snd✝ : β fst✝
h : ⟨fst✝, snd✝⟩.fst ∉ { entries := l, nodupKeys := hl }
this :
HEq (insertRec H0 IH { entries := ⟨fst✝, snd✝⟩ :: l, nodupKeys := ⋯ })
(IH ⟨fst✝, snd✝⟩.fst ⟨fst✝, snd✝⟩.snd { entries := l, nodupKeys := hl } h
(insertRec H0 IH { entries := l, nodupKeys := hl }))
⊢ insertRec H0 IH (insert ⟨fst✝, snd✝⟩.fst ⟨fst✝, snd✝⟩.snd { entries := l, nodupKeys := hl }) =
IH ⟨fst✝, snd✝⟩.fst ⟨fst✝, snd✝⟩.snd { entries := l, nodupKeys := hl } h
(insertRec H0 IH { entries := l, nodupKeys := hl })
|
ac5fbba4f95f506f
|
totallyBounded_convexHull
|
Mathlib/Analysis/Convex/TotallyBounded.lean
|
theorem totallyBounded_convexHull (hs : TotallyBounded s) :
TotallyBounded (convexHull ℝ s)
|
E : Type u_1
s : Set E
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : UniformSpace E
inst✝¹ : UniformAddGroup E
lcs : LocallyConvexSpace ℝ E
inst✝ : ContinuousSMul ℝ E
hs : TotallyBounded s
U : Set E
hU : U ∈ nhds 0
W : Set E
hW₁ : W ∈ nhds 0
hW₂ : ∀ v ∈ W, ∀ w ∈ W, v + w ∈ U
V : Set E
hV₁ : V ∈ nhds 0
hV₂ : Convex ℝ V
hV₃ : V ⊆ W
t : Set E
htf : t.Finite
t' : Set E
htf' : t'.Finite
hts : s ⊆ t + V
hts' : (convexHull ℝ) t ⊆ t' + V
⊢ (convexHull ℝ) t + (convexHull ℝ) V = (convexHull ℝ) t + V
|
rw [hV₂.convexHull_eq]
|
no goals
|
64dc48938af50583
|
Multiset.bind_map_comm
|
Mathlib/Data/Multiset/Bind.lean
|
theorem bind_map_comm (m : Multiset α) (n : Multiset β) {f : α → β → γ} :
((bind m) fun a => n.map fun b => f a b) = (bind n) fun b => m.map fun a => f a b :=
Multiset.induction_on m (by simp) (by simp +contextual)
|
α : Type u_1
β : Type v
γ : Type u_2
m : Multiset α
n : Multiset β
f : α → β → γ
⊢ (bind 0 fun a => map (fun b => f a b) n) = n.bind fun b => map (fun a => f a b) 0
|
simp
|
no goals
|
211ef29718eb9be1
|
Bimod.LeftUnitorBimod.hom_inv_id
|
Mathlib/CategoryTheory/Monoidal/Bimod.lean
|
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _
|
case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
(R.one ▷ (R.X ⊗ P.X) ≫ R.X ◁ P.actLeft) ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
|
slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (R.X ◁ P.actLeft)]
|
case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
R.one ▷ (R.X ⊗ P.X) ≫
((α_ R.X R.X P.X).inv ≫ (α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
|
2c899ab3fade475b
|
ProbabilityTheory.integrable_rpow_mul_exp_of_integrable_exp_mul
|
Mathlib/Probability/Moments/IntegrableExpMul.lean
|
/-- If `exp ((v + t) * X)` and `exp ((v - t) * X)` are integrable, then for all nonnegative `p : ℝ`,
`X ^ p * exp (v * X)` is integrable. -/
lemma integrable_rpow_mul_exp_of_integrable_exp_mul (ht : t ≠ 0)
(ht_int_pos : Integrable (fun ω ↦ exp ((v + t) * X ω)) μ)
(ht_int_neg : Integrable (fun ω ↦ exp ((v - t) * X ω)) μ) {p : ℝ} (hp : 0 ≤ p) :
Integrable (fun ω ↦ X ω ^ p * exp (v * X ω)) μ
|
case refine_1
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t v : ℝ
ht : t ≠ 0
ht_int_pos : Integrable (fun ω => rexp ((v + t) * X ω)) μ
ht_int_neg : Integrable (fun ω => rexp ((v - t) * X ω)) μ
p : ℝ
hp : 0 ≤ p
⊢ v + t ≠ v - t
|
rw [← sub_ne_zero]
|
case refine_1
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t v : ℝ
ht : t ≠ 0
ht_int_pos : Integrable (fun ω => rexp ((v + t) * X ω)) μ
ht_int_neg : Integrable (fun ω => rexp ((v - t) * X ω)) μ
p : ℝ
hp : 0 ≤ p
⊢ v + t - (v - t) ≠ 0
|
40d272ffe1018378
|
monovaryOn_iff_exists_monotoneOn
|
Mathlib/Order/Monotone/MonovaryOrder.lean
|
lemma monovaryOn_iff_exists_monotoneOn :
MonovaryOn f g s ↔ ∃ (_ : LinearOrder ι), MonotoneOn f s ∧ MonotoneOn g s
|
case refine_2.inl
ι : Type u_1
α : Type u_3
β : Type u_4
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : ι → α
g : ι → β
s : Set ι
this : LinearOrder ι := linearOrderOfSTO (MonovaryOrder f g)
hfg : MonovaryOn f g s
i : ι
hi : i ∈ s
j : ι
hj : j ∈ s
hij : i < j
h : (f i, g i, i).1 < (f j, g j, j).1
⊢ g i ≤ g j
|
exact hfg.symm hi hj h
|
no goals
|
8de36b7f99549771
|
Ordering.isEq_swap
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Ord.lean
|
theorem isEq_swap {o : Ordering} : o.swap.isEq = o.isEq
|
o : Ordering
⊢ o.swap.isEq = o.isEq
|
cases o <;> simp
|
no goals
|
f7ccfb6f8f43570c
|
AlgebraicGeometry.ValuativeCriterion.Existence.specializingMap
|
Mathlib/AlgebraicGeometry/ValuativeCriterion.lean
|
@[stacks 01KE]
lemma specializingMap (H : ValuativeCriterion.Existence f) :
SpecializingMap f.base
|
X Y : Scheme
f : X ⟶ Y
H : Existence f
x' : ↑↑X.toPresheafedSpace
y : ↑↑Y.toPresheafedSpace
h : flip (fun x1 x2 => x1 ⤳ x2) y ((ConcreteCategory.hom f.base) x')
stalk_y_to_residue_x' : Y.presheaf.stalk y ⟶ X.residueField x' :=
Y.presheaf.stalkSpecializes h ≫ Scheme.Hom.stalkMap f x' ≫ X.residue x'
A : ValuationSubring ↑(X.residueField x')
hA : ∀ (x : ↑(Y.presheaf.stalk y)), (CommRingCat.Hom.hom stalk_y_to_residue_x') x ∈ A.toSubring
hA_local : IsLocalHom ((CommRingCat.Hom.hom stalk_y_to_residue_x').codRestrict A.toSubring hA)
stalk_y_to_A : Y.presheaf.stalk y ⟶ CommRingCat.of ↥A :=
CommRingCat.ofHom ((CommRingCat.Hom.hom stalk_y_to_residue_x').codRestrict A hA)
⊢ Spec.map ((Y.presheaf.stalkSpecializes h ≫ Scheme.Hom.stalkMap f x') ≫ X.residue x') ≫ Y.fromSpecStalk y =
Spec.map (stalk_y_to_A ≫ CommRingCat.ofHom (algebraMap ↥A ↑(X.residueField x'))) ≫ Y.fromSpecStalk y
|
rfl
|
no goals
|
d2b14c6180e5b843
|
eq_mul_inv_of_mul_eq
|
Mathlib/Algebra/Group/Basic.lean
|
theorem eq_mul_inv_of_mul_eq (h : a * c = b) : a = b * c⁻¹
|
G : Type u_3
inst✝ : Group G
a b c : G
h : a * c = b
⊢ a = b * c⁻¹
|
simp [h.symm]
|
no goals
|
aacf7c3bd2c6f8c3
|
Part.some_mod_some
|
Mathlib/Data/Part.lean
|
theorem some_mod_some [Mod α] (a b : α) : some a % some b = some (a % b)
|
α : Type u_1
inst✝ : Mod α
a b : α
⊢ some a % some b = some (a % b)
|
simp [mod_def]
|
no goals
|
5fc8ef77538a6ebc
|
AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.carrier.smul_mem
|
Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
|
theorem carrier.smul_mem (c x : A) (hx : x ∈ carrier f_deg q) : c • x ∈ carrier f_deg q
|
case refine_3
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
q : ↑↑(Spec A⁰_ f).toPresheafedSpace
x : A
hx : x ∈ carrier f_deg q
⊢ ∀ (m_1 m' : A), m_1 • x ∈ carrier f_deg q → m' • x ∈ carrier f_deg q → m_1 • x + m' • x ∈ carrier f_deg q
|
exact fun _ _ => carrier.add_mem f_deg q
|
no goals
|
a6e1542c5c7977fc
|
CategoryTheory.essentiallySmall_iff
|
Mathlib/CategoryTheory/EssentiallySmall.lean
|
theorem essentiallySmall_iff (C : Type u) [Category.{v} C] :
EssentiallySmall.{w} C ↔ Small.{w} (Skeleton C) ∧ LocallySmall.{w} C
|
case mp.left.mk.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
S : Type w
𝒮 : SmallCategory S
e : C ≌ S
⊢ Skeleton C ≃ Skeleton S
|
exact e.skeletonEquiv
|
no goals
|
94dd7fa13a1cc5e2
|
List.reverse_subset
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Sublist.lean
|
theorem reverse_subset {l₁ l₂ : List α} : reverse l₁ ⊆ l₂ ↔ l₁ ⊆ l₂
|
α : Type u_1
l₁ l₂ : List α
⊢ l₁.reverse ⊆ l₂ ↔ l₁ ⊆ l₂
|
simp [subset_def]
|
no goals
|
20a1f3ad673fb07c
|
Int.Cooper.resolve_left_dvd₁
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Int/Cooper.lean
|
theorem resolve_left_dvd₁ (a c d p x : Int) (h₁ : p ≤ a * x) :
a ∣ resolve_left a c d p x + p
|
a c d p x : Int
h₁ : p ≤ a * x
⊢ a ∣ ↑((add_of_le h₁).val % a.lcm (a * d / ↑((a * d).gcd c))) + p
|
obtain ⟨k', w⟩ := add_of_le h₁
|
case mk
a c d p x : Int
h₁ : p ≤ a * x
k' : Nat
w : a * x = p + ↑k'
⊢ a ∣ ↑(⟨k', w⟩.val % a.lcm (a * d / ↑((a * d).gcd c))) + p
|
4717869eaf119b13
|
SimplexCategory.eq_of_one_to_two
|
Mathlib/AlgebraicTopology/SimplexCategory/Basic.lean
|
theorem eq_of_one_to_two (f : ⦋1⦌ ⟶ ⦋2⦌) :
(∃ i, f = (δ (n := 1) i)) ∨ ∃ a, f = SimplexCategory.const _ _ a
|
f : ⦋1⦌ ⟶ ⦋2⦌
this : (Hom.toOrderHom f) 0 ≤ (Hom.toOrderHom f) 1
e0 : (Hom.toOrderHom f) 0 = 0
e1 : (Hom.toOrderHom f) 1 = 1
⊢ (∃ i, f = δ i) ∨ ∃ a, f = ⦋1⦌.const ⦋2⦌ a
|
refine .inl ⟨2, ?_⟩
|
f : ⦋1⦌ ⟶ ⦋2⦌
this : (Hom.toOrderHom f) 0 ≤ (Hom.toOrderHom f) 1
e0 : (Hom.toOrderHom f) 0 = 0
e1 : (Hom.toOrderHom f) 1 = 1
⊢ f = δ 2
|
5e795d7949346773
|
List.mem_permutationsAux_of_perm
|
Mathlib/Data/List/Permutation.lean
|
theorem mem_permutationsAux_of_perm :
∀ {ts is l : List α},
l ~ is ++ ts → (∃ (is' : _) (_ : is' ~ is), l = is' ++ ts) ∨ l ∈ permutationsAux ts is
|
α : Type u_1
⊢ ∀ (t : α) (ts is : List α),
(∀ (l : List α),
l ~ t :: is ++ ts → (∃ is', ∃ (_ : is' ~ t :: is), l = is' ++ ts) ∨ l ∈ ts.permutationsAux (t :: is)) →
(∀ (l : List α), l ~ [] ++ is → (∃ is', ∃ (_ : is' ~ []), l = is' ++ is) ∨ l ∈ is.permutationsAux []) →
∀ (l : List α),
l ~ is ++ t :: ts → (∃ is', ∃ (_ : is' ~ is), l = is' ++ t :: ts) ∨ l ∈ (t :: ts).permutationsAux is
|
intro t ts is IH1 IH2 l p
|
α : Type u_1
t : α
ts is : List α
IH1 :
∀ (l : List α), l ~ t :: is ++ ts → (∃ is', ∃ (_ : is' ~ t :: is), l = is' ++ ts) ∨ l ∈ ts.permutationsAux (t :: is)
IH2 : ∀ (l : List α), l ~ [] ++ is → (∃ is', ∃ (_ : is' ~ []), l = is' ++ is) ∨ l ∈ is.permutationsAux []
l : List α
p : l ~ is ++ t :: ts
⊢ (∃ is', ∃ (_ : is' ~ is), l = is' ++ t :: ts) ∨ l ∈ (t :: ts).permutationsAux is
|
c51a06076c0dbbc1
|
CauSeq.le_inf
|
Mathlib/Algebra/Order/CauSeq/Basic.lean
|
theorem le_inf {a b c : CauSeq α abs} (hb : a ≤ b) (hc : a ≤ c) : a ≤ b ⊓ c
|
case inl
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hc : a ≤ c
hb : a < b
⊢ a ≤ b ⊓ c
|
obtain hc | hc := hc
|
case inl.inl
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : a < b
hc : a < c
⊢ a ≤ b ⊓ c
case inl.inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : a < b
hc : a ≈ c
⊢ a ≤ b ⊓ c
|
ca14703e1c3d3eed
|
List.permutationsAux_append
|
Mathlib/Data/List/Permutation.lean
|
theorem permutationsAux_append (is is' ts : List α) :
permutationsAux (is ++ ts) is' =
(permutationsAux is is').map (· ++ ts) ++ permutationsAux ts (is.reverse ++ is')
|
α : Type u_1
is is' ts : List α
⊢ (is ++ ts).permutationsAux is' =
map (fun x => x ++ ts) (is.permutationsAux is') ++ ts.permutationsAux (is.reverse ++ is')
|
induction' is with t is ih generalizing is'
|
case nil
α : Type u_1
ts is' : List α
⊢ ([] ++ ts).permutationsAux is' =
map (fun x => x ++ ts) ([].permutationsAux is') ++ ts.permutationsAux ([].reverse ++ is')
case cons
α : Type u_1
ts : List α
t : α
is : List α
ih :
∀ (is' : List α),
(is ++ ts).permutationsAux is' =
map (fun x => x ++ ts) (is.permutationsAux is') ++ ts.permutationsAux (is.reverse ++ is')
is' : List α
⊢ (t :: is ++ ts).permutationsAux is' =
map (fun x => x ++ ts) ((t :: is).permutationsAux is') ++ ts.permutationsAux ((t :: is).reverse ++ is')
|
15800e154effb70e
|
OreLocalization.mul_smul
|
Mathlib/GroupTheory/OreLocalization/Basic.lean
|
theorem mul_smul (x y : R[S⁻¹]) (z : X[S⁻¹]) : (x * y) • z = x • y • z
|
case c.c
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
z : OreLocalization S X
r₁ : R
s₁ : ↥S
r₂ : R
s₂ : ↥S
⊢ (r₁ /ₒ s₁ * (r₂ /ₒ s₂)) • z = (r₁ /ₒ s₁) • (r₂ /ₒ s₂) • z
|
induction' z with r₃ s₃
|
case c.c.c
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r₁ : R
s₁ : ↥S
r₂ : R
s₂ : ↥S
r₃ : X
s₃ : ↥S
⊢ (r₁ /ₒ s₁ * (r₂ /ₒ s₂)) • (r₃ /ₒ s₃) = (r₁ /ₒ s₁) • (r₂ /ₒ s₂) • (r₃ /ₒ s₃)
|
13727f39039b5941
|
ENNReal.ofReal_pow
|
Mathlib/Data/ENNReal/Real.lean
|
theorem ofReal_pow {p : ℝ} (hp : 0 ≤ p) (n : ℕ) :
ENNReal.ofReal (p ^ n) = ENNReal.ofReal p ^ n
|
p : ℝ
hp : 0 ≤ p
n : ℕ
⊢ ENNReal.ofReal (p ^ n) = ENNReal.ofReal p ^ n
|
rw [ofReal_eq_coe_nnreal hp, ← coe_pow, ← ofReal_coe_nnreal, NNReal.coe_pow, NNReal.coe_mk]
|
no goals
|
1b0d0c077725c8b4
|
MeasureTheory.Measure.restrict_map_of_aemeasurable
|
Mathlib/MeasureTheory/Measure/AEMeasurable.lean
|
theorem MeasureTheory.Measure.restrict_map_of_aemeasurable {f : α → δ} (hf : AEMeasurable f μ)
{s : Set δ} (hs : MeasurableSet s) : (μ.map f).restrict s = (μ.restrict <| f ⁻¹' s).map f :=
calc
(μ.map f).restrict s = (μ.map (hf.mk f)).restrict s
|
case h.h
α : Type u_2
δ : Type u_5
m0 : MeasurableSpace α
inst✝ : MeasurableSpace δ
μ : Measure α
f : α → δ
hf : AEMeasurable f μ
s : Set δ
hs : MeasurableSet s
t : Set α
ht : MeasurableSet t
⊢ μ (t ∩ AEMeasurable.mk f hf ⁻¹' s) = μ (t ∩ f ⁻¹' s)
|
apply measure_congr
|
case h.h.H
α : Type u_2
δ : Type u_5
m0 : MeasurableSpace α
inst✝ : MeasurableSpace δ
μ : Measure α
f : α → δ
hf : AEMeasurable f μ
s : Set δ
hs : MeasurableSet s
t : Set α
ht : MeasurableSet t
⊢ t ∩ AEMeasurable.mk f hf ⁻¹' s =ᶠ[ae μ] t ∩ f ⁻¹' s
|
14bc87ba1a5d7f2e
|
Finset.expect_boole_mul
|
Mathlib/Algebra/BigOperators/Expect.lean
|
lemma expect_boole_mul [Fintype ι] [Nonempty ι] [DecidableEq ι] (f : ι → M) (i : ι) :
𝔼 j, ite (i = j) (Fintype.card ι : M) 0 * f j = f i
|
ι : Type u_1
M : Type u_3
inst✝⁴ : Semifield M
inst✝³ : CharZero M
inst✝² : Fintype ι
inst✝¹ : Nonempty ι
inst✝ : DecidableEq ι
f : ι → M
i : ι
⊢ (↑(Fintype.card ι))⁻¹ • (↑(Fintype.card ι) * f i) = f i
|
rw [← @NNRat.cast_natCast M, ← NNRat.smul_def, inv_smul_smul₀]
|
case ha
ι : Type u_1
M : Type u_3
inst✝⁴ : Semifield M
inst✝³ : CharZero M
inst✝² : Fintype ι
inst✝¹ : Nonempty ι
inst✝ : DecidableEq ι
f : ι → M
i : ι
⊢ ↑(Fintype.card ι) ≠ 0
|
4131b6636b87564d
|
dvdNotUnit_of_dvdNotUnit_associated
|
Mathlib/Algebra/GroupWithZero/Associated.lean
|
theorem dvdNotUnit_of_dvdNotUnit_associated [CommMonoidWithZero M] [Nontrivial M] {p q r : M}
(h : DvdNotUnit p q) (h' : Associated q r) : DvdNotUnit p r
|
case intro.intro.intro
M : Type u_1
inst✝¹ : CommMonoidWithZero M
inst✝ : Nontrivial M
p r : M
u : Mˣ
h' : r * ↑u ~ᵤ r
hp : p ≠ 0
x : M
hx : ¬IsUnit x ∧ r * ↑u = p * x
⊢ DvdNotUnit p r
|
refine ⟨hp, x * ↑u⁻¹, DvdNotUnit.not_unit ⟨u⁻¹.ne_zero, x, hx.left, mul_comm _ _⟩, ?_⟩
|
case intro.intro.intro
M : Type u_1
inst✝¹ : CommMonoidWithZero M
inst✝ : Nontrivial M
p r : M
u : Mˣ
h' : r * ↑u ~ᵤ r
hp : p ≠ 0
x : M
hx : ¬IsUnit x ∧ r * ↑u = p * x
⊢ r = p * (x * ↑u⁻¹)
|
64a5842690a61119
|
contentRegular_rieszContent
|
Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean
|
lemma contentRegular_rieszContent : (rieszContent Λ).ContentRegular
|
case intro.intro.intro
X : Type u_1
inst✝² : TopologicalSpace X
Λ : (X →C_c ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
inst✝¹ : T2Space X
inst✝ : LocallyCompactSpace X
K : Compacts X
b : ℝ≥0∞
hb : ∀ (i : Compacts X), b ≤ ⨅ (_ : ↑K ⊆ interior ↑i), ↑(rieszContentAux Λ i)
this : b < ⊤
ε : ℝ≥0
hε : 0 < ↑ε
f : X →C_c ℝ≥0
hfleoneonK : ∀ x ∈ K, 1 ≤ f x
hfle : ↑(Λ f) < ↑(sInf (⇑Λ '' {f | ∀ x ∈ K, 1 ≤ f x}) + ⟨↑ε, ⋯⟩)
α : ℝ≥0
hα : 1 < α
K' : Set X := ⇑f ⁻¹' Ici α⁻¹
hKK' : ↑K ⊆ interior K'
hK'cp : IsCompact K'
hb' : b ≤
⨅ (_ : ↑K ⊆ interior ↑{ carrier := K', isCompact' := hK'cp }),
↑(rieszContentAux Λ { carrier := K', isCompact' := hK'cp }) :=
hb { carrier := K', isCompact' := hK'cp }
⊢ b.toNNReal ≤ Λ (α • f)
|
simp only [Compacts.coe_mk, le_iInf_iff] at hb'
|
case intro.intro.intro
X : Type u_1
inst✝² : TopologicalSpace X
Λ : (X →C_c ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
inst✝¹ : T2Space X
inst✝ : LocallyCompactSpace X
K : Compacts X
b : ℝ≥0∞
hb : ∀ (i : Compacts X), b ≤ ⨅ (_ : ↑K ⊆ interior ↑i), ↑(rieszContentAux Λ i)
this : b < ⊤
ε : ℝ≥0
hε : 0 < ↑ε
f : X →C_c ℝ≥0
hfleoneonK : ∀ x ∈ K, 1 ≤ f x
hfle : ↑(Λ f) < ↑(sInf (⇑Λ '' {f | ∀ x ∈ K, 1 ≤ f x}) + ⟨↑ε, ⋯⟩)
α : ℝ≥0
hα : 1 < α
K' : Set X := ⇑f ⁻¹' Ici α⁻¹
hKK' : ↑K ⊆ interior K'
hK'cp : IsCompact K'
hb' : ↑K ⊆ interior K' → b ≤ ↑(rieszContentAux Λ { carrier := K', isCompact' := hK'cp })
⊢ b.toNNReal ≤ Λ (α • f)
|
ee74d0aaa3cba565
|
List.nodup_iff_getElem?_ne_getElem?
|
Mathlib/Data/List/Nodup.lean
|
theorem nodup_iff_getElem?_ne_getElem? {l : List α} :
l.Nodup ↔ ∀ i j : ℕ, i < j → j < l.length → l[i]? ≠ l[j]?
|
α : Type u
l : List α
h : ∀ (i j : ℕ) (_hi : i < l.length) (_hj : j < l.length), i < j → l[i] ≠ l[j]
i j : ℕ
hij : i < j
hj : j < l.length
⊢ i < l.length
|
omega
|
no goals
|
8e656bef319224ab
|
Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiff
|
Mathlib/GroupTheory/Perm/Cycle/Factors.lean
|
theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [DecidableEq α] [Fintype α] {f g : Perm α}
(h : f ∈ cycleFactorsFinset g) : cycleFactorsFinset (g * f⁻¹) = cycleFactorsFinset g \ {f}
|
case refine_2
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g f✝ : Perm α
⊢ ∀ (σ : Perm α),
σ.IsCycle → fun {g} =>
∀ {f : Perm α}, f ∈ g.cycleFactorsFinset → (g * f⁻¹).cycleFactorsFinset = g.cycleFactorsFinset \ {f}
|
intro σ hσ f hf
|
case refine_2
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g f✝ σ : Perm α
hσ : σ.IsCycle
f : Perm α
hf : f ∈ σ.cycleFactorsFinset
⊢ (σ * f⁻¹).cycleFactorsFinset = σ.cycleFactorsFinset \ {f}
|
3d77fd0de031f082
|
IsCompact.nhdsSet_basis_uniformity
|
Mathlib/Topology/UniformSpace/Compact.lean
|
theorem IsCompact.nhdsSet_basis_uniformity {p : ι → Prop} {V : ι → Set (α × α)}
(hbasis : (𝓤 α).HasBasis p V) (hK : IsCompact K) :
(𝓝ˢ K).HasBasis p fun i => ⋃ x ∈ K, ball x (V i) where
mem_iff' U
|
α : Type ua
ι : Sort u_1
inst✝ : UniformSpace α
K : Set α
p : ι → Prop
V : ι → Set (α × α)
hbasis : (𝓤 α).HasBasis p V
hK : IsCompact K
U : Set α
H : U ∈ 𝓝ˢ K
HKU : K ⊆ ⋃ x, interior U
⊢ ∃ i, p i ∧ ⋃ x ∈ K, ball x (V i) ⊆ interior U
|
simpa using hbasis.lebesgue_number_lemma hK (fun _ ↦ isOpen_interior) HKU
|
no goals
|
3372e9cb2aa231ed
|
Hopf_.antipode_comul
|
Mathlib/CategoryTheory/Monoidal/Hopf_.lean
|
theorem antipode_comul (A : Hopf_ C) :
A.antipode ≫ A.X.comul.hom = A.X.comul.hom ≫ (β_ _ _).hom ≫ (A.antipode ⊗ A.antipode)
|
case hba
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
A : Hopf_ C
⊢ A.X.comul.hom ≫
A.antipode ▷ A.X.X.X ≫
A.X.comul.hom ▷ A.X.X.X ≫
(α_ A.X.X.X A.X.X.X A.X.X.X).hom ≫
A.X.X.X ◁ A.X.X.X ◁ A.X.comul.hom ≫
(α_ A.X.X.X A.X.X.X (A.X.X.X ⊗ A.X.X.X)).inv ≫
tensorμ A.X.X.X A.X.X.X A.X.X.X A.X.X.X ≫ (A.X.X.mul ⊗ A.X.X.mul) =
A.X.counit.hom ≫ (λ_ (𝟙_ C)).inv ≫ (A.X.X.one ⊗ A.X.X.one)
|
simp only [tensorμ]
|
case hba
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
A : Hopf_ C
⊢ A.X.comul.hom ≫
A.antipode ▷ A.X.X.X ≫
A.X.comul.hom ▷ A.X.X.X ≫
(α_ A.X.X.X A.X.X.X A.X.X.X).hom ≫
A.X.X.X ◁ A.X.X.X ◁ A.X.comul.hom ≫
(α_ A.X.X.X A.X.X.X (A.X.X.X ⊗ A.X.X.X)).inv ≫
((α_ A.X.X.X A.X.X.X (A.X.X.X ⊗ A.X.X.X)).hom ≫
A.X.X.X ◁ (α_ A.X.X.X A.X.X.X A.X.X.X).inv ≫
A.X.X.X ◁ (β_ A.X.X.X A.X.X.X).hom ▷ A.X.X.X ≫
A.X.X.X ◁ (α_ A.X.X.X A.X.X.X A.X.X.X).hom ≫ (α_ A.X.X.X A.X.X.X (A.X.X.X ⊗ A.X.X.X)).inv) ≫
(A.X.X.mul ⊗ A.X.X.mul) =
A.X.counit.hom ≫ (λ_ (𝟙_ C)).inv ≫ (A.X.X.one ⊗ A.X.X.one)
|
95837a9afe92aa55
|
MvQPF.Cofix.dest_corec'
|
Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean
|
theorem Cofix.dest_corec' {α : TypeVec.{u} n} {β : Type u}
(g : β → F (α.append1 (Cofix F α ⊕ β))) (x : β) :
Cofix.dest (Cofix.corec' g x) =
appendFun id (Sum.elim _root_.id (Cofix.corec' g)) <$$> g x
|
case h.e'_6.h.e'_7.h.inl.intro.intro
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
β : Type u
g : β → F (α ::: (Cofix F α ⊕ β))
x✝ : β
i : Cofix F α
R : Cofix F α → Cofix F α → Prop :=
fun a b =>
∃ x,
a =
corec
(MvFunctor.map (TypeVec.id ::: fun x => x) ∘
Sum.rec (fun val => (TypeVec.id ::: Sum.inl) <$$> val.dest) fun val => g val)
(Sum.inl x) ∧
b = x
a b x : Cofix F α
Ha :
a =
corec
(MvFunctor.map (TypeVec.id ::: fun x => x) ∘
Sum.rec (fun val => (TypeVec.id ::: Sum.inl) <$$> val.dest) fun val => g val)
(Sum.inl x)
Hb : b = x
⊢ LiftR' (α.RelLast' R)
((TypeVec.id :::
corec fun x =>
(TypeVec.id ::: fun x => x) <$$>
Sum.rec (fun val => (TypeVec.id ::: Sum.inl) <$$> val.dest) (fun val => g val) x) <$$>
(TypeVec.id ::: fun x => x) <$$> (TypeVec.id ::: Sum.inl) <$$> x.dest)
x.dest
|
repeat rw [MvFunctor.map_map, ← appendFun_comp_id]
|
case h.e'_6.h.e'_7.h.inl.intro.intro
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
β : Type u
g : β → F (α ::: (Cofix F α ⊕ β))
x✝ : β
i : Cofix F α
R : Cofix F α → Cofix F α → Prop :=
fun a b =>
∃ x,
a =
corec
(MvFunctor.map (TypeVec.id ::: fun x => x) ∘
Sum.rec (fun val => (TypeVec.id ::: Sum.inl) <$$> val.dest) fun val => g val)
(Sum.inl x) ∧
b = x
a b x : Cofix F α
Ha :
a =
corec
(MvFunctor.map (TypeVec.id ::: fun x => x) ∘
Sum.rec (fun val => (TypeVec.id ::: Sum.inl) <$$> val.dest) fun val => g val)
(Sum.inl x)
Hb : b = x
⊢ LiftR' (α.RelLast' R)
((TypeVec.id :::
((corec fun x =>
(TypeVec.id ::: fun x => x) <$$>
Sum.rec (fun val => (TypeVec.id ::: Sum.inl) <$$> val.dest) (fun val => g val) x) ∘
fun x => x) ∘
Sum.inl) <$$>
x.dest)
x.dest
|
be80bc82f7ec558d
|
Polynomial.eval₂_X_pow
|
Mathlib/Algebra/Polynomial/Eval/Defs.lean
|
theorem eval₂_X_pow {n : ℕ} : (X ^ n).eval₂ f x = x ^ n
|
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
x : S
n : ℕ
⊢ eval₂ f x ((monomial n) 1) = x ^ n
|
convert eval₂_monomial f x (n := n) (r := 1)
|
case h.e'_3
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
x : S
n : ℕ
⊢ x ^ n = f 1 * x ^ n
|
bc410754bb487e9c
|
RootPairing.range_weylGroup_weightHom
|
Mathlib/LinearAlgebra/RootSystem/WeylGroup.lean
|
lemma range_weylGroup_weightHom :
MonoidHom.range ((Equiv.weightHom P).restrict P.weylGroup) =
Subgroup.closure (range P.reflection)
|
case refine_1.intro
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i : ι
⊢ P.reflection i ∈ ↑((Equiv.weightHom P).restrict P.weylGroup).range
|
simp only [MonoidHom.restrict_range, Subgroup.coe_map, Equiv.weightHom_apply, mem_image,
SetLike.mem_coe]
|
case refine_1.intro
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i : ι
⊢ ∃ x ∈ P.weylGroup, Equiv.weightEquiv P P x = P.reflection i
|
c05e89b06d1c9590
|
Sum.lex_inl_inl
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Sum/Basic.lean
|
theorem lex_inl_inl : Lex r s (inl a₁) (inl a₂) ↔ r a₁ a₂ :=
⟨fun h => by cases h; assumption, Lex.inl⟩
|
case inl
α✝ : Type u_1
r : α✝ → α✝ → Prop
β✝ : Type u_2
s : β✝ → β✝ → Prop
a₁ a₂ : α✝
h✝ : r a₁ a₂
⊢ r a₁ a₂
|
assumption
|
no goals
|
d3aae9eca3e3cd38
|
OrderedFinpartition.partSize_eq_one_of_range_emb_eq_singleton
|
Mathlib/Analysis/Calculus/ContDiff/FaaDiBruno.lean
|
lemma partSize_eq_one_of_range_emb_eq_singleton
(c : OrderedFinpartition n) {i : Fin c.length} {j : Fin n}
(hc : range (c.emb i) = {j}) :
c.partSize i = 1
|
n : ℕ
c : OrderedFinpartition n
i : Fin c.length
j : Fin n
hc : range (c.emb i) = {j}
⊢ c.partSize i = 1
|
have : Fintype.card (range (c.emb i)) = Fintype.card (Fin (c.partSize i)) :=
card_range_of_injective (c.emb_strictMono i).injective
|
n : ℕ
c : OrderedFinpartition n
i : Fin c.length
j : Fin n
hc : range (c.emb i) = {j}
this : Fintype.card ↑(range (c.emb i)) = Fintype.card (Fin (c.partSize i))
⊢ c.partSize i = 1
|
3696ccf36eca0b0e
|
MultilinearMap.map_sum_finset_aux
|
Mathlib/LinearAlgebra/Multilinear/Basic.lean
|
theorem map_sum_finset_aux [DecidableEq ι] [Fintype ι] {n : ℕ} (h : (∑ i, #(A i)) = n) :
(f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ piFinset A, f fun i => g i (r i)
|
case e_a
R : Type uR
ι : Type uι
M₁ : ι → Type v₁
M₂ : Type v₂
inst✝⁶ : Semiring R
inst✝⁵ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
f : MultilinearMap R M₁ M₂
α : ι → Type u_1
g : (i : ι) → α i → M₁ i
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
this : (i : ι) → DecidableEq (α i) := fun i => Classical.decEq (α i)
n : ℕ
IH :
∀ m < n,
∀ (A : (i : ι) → Finset (α i)),
∑ i : ι, #(A i) = m → (f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ piFinset A, f fun i => g i (r i)
A : (i : ι) → Finset (α i)
h : ∑ i : ι, #(A i) = n
Ai_empty : ∀ (i : ι), A i ≠ ∅
Ai_singleton : ∀ (i : ι), #(A i) ≤ 1
Ai_card : ∀ (i : ι), #(A i) = 1
r : (i : ι) → α i
hr : r ∈ piFinset A
i : ι
j : α i
hj : j ∈ A i
⊢ j = r i
|
apply Finset.card_le_one_iff.1 (Ai_singleton i) hj
|
case e_a
R : Type uR
ι : Type uι
M₁ : ι → Type v₁
M₂ : Type v₂
inst✝⁶ : Semiring R
inst✝⁵ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
f : MultilinearMap R M₁ M₂
α : ι → Type u_1
g : (i : ι) → α i → M₁ i
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
this : (i : ι) → DecidableEq (α i) := fun i => Classical.decEq (α i)
n : ℕ
IH :
∀ m < n,
∀ (A : (i : ι) → Finset (α i)),
∑ i : ι, #(A i) = m → (f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ piFinset A, f fun i => g i (r i)
A : (i : ι) → Finset (α i)
h : ∑ i : ι, #(A i) = n
Ai_empty : ∀ (i : ι), A i ≠ ∅
Ai_singleton : ∀ (i : ι), #(A i) ≤ 1
Ai_card : ∀ (i : ι), #(A i) = 1
r : (i : ι) → α i
hr : r ∈ piFinset A
i : ι
j : α i
hj : j ∈ A i
⊢ r i ∈ A i
|
981a316f387f732a
|
IsAdjoinRoot.aequiv_map
|
Mathlib/RingTheory/IsAdjoinRoot.lean
|
theorem aequiv_map (h : IsAdjoinRoot S f) (h' : IsAdjoinRoot T f) (z : R[X]) :
h.aequiv h' (h.map z) = h'.map z
|
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
z : R[X]
⊢ (h.aequiv h') (h.map z) = h'.map z
|
rw [aequiv, AlgEquiv.coe_mk, Equiv.coe_fn_mk, liftHom_map, aeval_eq]
|
no goals
|
497385a3e1316c2d
|
MeasureTheory.SimpleFunc.measurableSet_cut
|
Mathlib/MeasureTheory/Function/SimpleFunc.lean
|
theorem measurableSet_cut (r : α → β → Prop) (f : α →ₛ β) (h : ∀ b, MeasurableSet { a | r a b }) :
MeasurableSet { a | r a (f a) }
|
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
r : α → β → Prop
f : α →ₛ β
h : ∀ (b : β), MeasurableSet {a | r a b}
⊢ MeasurableSet {a | r a (f a)}
|
have : { a | r a (f a) } = ⋃ b ∈ range f, { a | r a b } ∩ f ⁻¹' {b} := by
ext a
suffices r a (f a) ↔ ∃ i, r a (f i) ∧ f a = f i by simpa
exact ⟨fun h => ⟨a, ⟨h, rfl⟩⟩, fun ⟨a', ⟨h', e⟩⟩ => e.symm ▸ h'⟩
|
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
r : α → β → Prop
f : α →ₛ β
h : ∀ (b : β), MeasurableSet {a | r a b}
this : {a | r a (f a)} = ⋃ b ∈ range ⇑f, {a | r a b} ∩ ⇑f ⁻¹' {b}
⊢ MeasurableSet {a | r a (f a)}
|
5a97b308e7974c2c
|
LinearMap.continuous_of_seq_closed_graph
|
Mathlib/Analysis/Normed/Operator/Banach.lean
|
theorem LinearMap.continuous_of_seq_closed_graph
(hg : ∀ (u : ℕ → E) (x y), Tendsto u atTop (𝓝 x) → Tendsto (g ∘ u) atTop (𝓝 y) → y = g x) :
Continuous g
|
case mk
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_5
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
g : E →ₗ[𝕜] F
hg : ∀ (u : ℕ → E) (x : E) (y : F), Tendsto u atTop (𝓝 x) → Tendsto (⇑g ∘ u) atTop (𝓝 y) → y = g x
φ : ℕ → E × F
x : E
y : F
hφg : ∀ (n : ℕ), φ n ∈ ↑g.graph
hφ : Tendsto φ atTop (𝓝 (x, y))
this : ⇑g ∘ Prod.fst ∘ φ = Prod.snd ∘ φ
⊢ Tendsto (Prod.snd ∘ φ) atTop (𝓝 y)
|
exact (continuous_snd.tendsto _).comp hφ
|
no goals
|
2673a9b6b5f9f074
|
TensorProduct.exists_finsupp_left
|
Mathlib/LinearAlgebra/TensorProduct/Finiteness.lean
|
theorem exists_finsupp_left (x : M ⊗[R] N) :
∃ S : M →₀ N, x = S.sum fun m n ↦ m ⊗ₜ[R] n
|
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
x : M
y : N
⊢ x ⊗ₜ[R] y = (Finsupp.single x y).sum fun m n => m ⊗ₜ[R] n
|
simp
|
no goals
|
60177b288117e180
|
Polynomial.reverse_natDegree_le
|
Mathlib/Algebra/Polynomial/Reverse.lean
|
theorem reverse_natDegree_le (f : R[X]) : f.reverse.natDegree ≤ f.natDegree
|
R : Type u_1
inst✝ : Semiring R
f : R[X]
n : ℕ
hn : ↑f.natDegree < ↑n
⊢ f.reverse.coeff n = 0
|
rw [Nat.cast_lt] at hn
|
R : Type u_1
inst✝ : Semiring R
f : R[X]
n : ℕ
hn : f.natDegree < n
⊢ f.reverse.coeff n = 0
|
8e53e10aac3451f2
|
Sigma.uncurry_mulSingle_mulSingle
|
Mathlib/Algebra/Group/Pi/Lemmas.lean
|
theorem uncurry_mulSingle_mulSingle [DecidableEq α] [∀ a, DecidableEq (β a)] [∀ a b, One (γ a b)]
(a : α) (b : β a) (x : γ a b) :
Sigma.uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle (Sigma.mk a b) x
|
α : Type u_3
β : α → Type u_4
γ : (a : α) → β a → Type u_5
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (β a)
inst✝ : (a : α) → (b : β a) → One (γ a b)
a : α
b : β a
x : γ a b
⊢ uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle ⟨a, b⟩ x
|
rw [← curry_mulSingle ⟨a, b⟩, uncurry_curry]
|
no goals
|
3ee2b9c65813aef6
|
closure_residualEq
|
Mathlib/Topology/Baire/BaireMeasurable.lean
|
theorem closure_residualEq {s : Set α} (hs : IsLocallyClosed s) : closure s =ᵇ s
|
α : Type u_1
inst✝ : TopologicalSpace α
s : Set α
hs : IsLocallyClosed s
⊢ ∀ᵇ (x : α), x ∈ closure s ↔ x ∈ s
|
filter_upwards [coborder_mem_residual hs] with x hx
|
case h
α : Type u_1
inst✝ : TopologicalSpace α
s : Set α
hs : IsLocallyClosed s
x : α
hx : x ∈ coborder s
⊢ x ∈ closure s ↔ x ∈ s
|
eb5283df85eaa4a7
|
CategoryTheory.MorphismProperty.LeftFractionRel.symm
|
Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
|
lemma symm {X Y : C} {z₁ z₂ : W.LeftFraction X Y} (h : LeftFractionRel z₁ z₂) :
LeftFractionRel z₂ z₁
|
C : Type u_1
inst✝ : Category.{u_3, u_1} C
W : MorphismProperty C
X Y : C
z₁ z₂ : W.LeftFraction X Y
h : LeftFractionRel z₁ z₂
⊢ LeftFractionRel z₂ z₁
|
obtain ⟨Z, t₁, t₂, hst, hft, ht⟩ := h
|
case intro.intro.intro.intro.intro
C : Type u_1
inst✝ : Category.{u_3, u_1} C
W : MorphismProperty C
X Y : C
z₁ z₂ : W.LeftFraction X Y
Z : C
t₁ : z₁.Y' ⟶ Z
t₂ : z₂.Y' ⟶ Z
hst : z₁.s ≫ t₁ = z₂.s ≫ t₂
hft : z₁.f ≫ t₁ = z₂.f ≫ t₂
ht : W (z₁.s ≫ t₁)
⊢ LeftFractionRel z₂ z₁
|
8e8b91861665f29a
|
IsCoprime.ne_zero_or_ne_zero
|
Mathlib/RingTheory/Coprime/Basic.lean
|
theorem IsCoprime.ne_zero_or_ne_zero [Nontrivial R] (h : IsCoprime x y) : x ≠ 0 ∨ y ≠ 0
|
R : Type u
inst✝¹ : CommSemiring R
x y : R
inst✝ : Nontrivial R
h : IsCoprime x y
⊢ x ≠ 0 ∨ y ≠ 0
|
apply not_or_of_imp
|
case a
R : Type u
inst✝¹ : CommSemiring R
x y : R
inst✝ : Nontrivial R
h : IsCoprime x y
⊢ x = 0 → y ≠ 0
|
10b7192cc54ac7d2
|
Module.End.map_smul_of_iInf_iSup_genEigenspace_ne_bot
|
Mathlib/LinearAlgebra/Eigenspace/Basic.lean
|
@[deprecated map_smul_of_iInf_genEigenspace_ne_bot (since := "2024-10-23")]
lemma map_smul_of_iInf_iSup_genEigenspace_ne_bot [NoZeroSMulDivisors R M]
{L F : Type*} [SMul R L] [FunLike F L (End R M)] [MulActionHomClass F R L (End R M)] (f : F)
(μ : L → R) (h_ne : ⨅ x, ⨆ k : ℕ, (f x).genEigenspace (μ x) k ≠ ⊥)
(t : R) (x : L) :
μ (t • x) = t • μ x
|
R : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : NoZeroSMulDivisors R M
L : Type u_1
F : Type u_2
inst✝² : SMul R L
inst✝¹ : FunLike F L (End R M)
inst✝ : MulActionHomClass F R L (End R M)
f : F
μ : L → R
h_ne : ⨅ x, ⨆ k, ((f x).genEigenspace (μ x)) ↑k ≠ ⊥
t : R
x : L
⊢ μ (t • x) = t • μ x
|
simp_rw [iSup_genEigenspace_eq] at h_ne
|
R : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : NoZeroSMulDivisors R M
L : Type u_1
F : Type u_2
inst✝² : SMul R L
inst✝¹ : FunLike F L (End R M)
inst✝ : MulActionHomClass F R L (End R M)
f : F
μ : L → R
t : R
x : L
h_ne : ⨅ x, (f x).maxGenEigenspace (μ x) ≠ ⊥
⊢ μ (t • x) = t • μ x
|
ccb37027875f6905
|
ClassGroup.exists_mem_finsetApprox
|
Mathlib/NumberTheory/ClassNumber/Finite.lean
|
theorem exists_mem_finsetApprox (a : S) {b} (hb : b ≠ (0 : R)) :
∃ q : S,
∃ r ∈ finsetApprox bS adm, abv (Algebra.norm R (r • a - b • q)) <
abv (Algebra.norm R (algebraMap R S b))
|
case intro.intro.intro
R : Type u_1
S : Type u_2
inst✝⁷ : EuclideanDomain R
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
inst✝⁴ : Algebra R S
abv : AbsoluteValue R ℤ
ι : Type u_5
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
bS : Basis ι R S
adm : abv.IsAdmissible
inst✝¹ : Infinite R
inst✝ : DecidableEq R
a : S
b : R
hb : b ≠ 0
dim_pos : 0 < Fintype.card ι
ε : ℝ := ↑(normBound abv bS) ^ (-1 / ↑(Fintype.card ι))
ε_eq : ε = ↑(normBound abv bS) ^ (-1 / ↑(Fintype.card ι))
hε : 0 < ε
ε_le : ↑(normBound abv bS) * (abv b • ε) ^ ↑(Fintype.card ι) ≤ ↑(abv b) ^ ↑(Fintype.card ι)
μ : Fin (cardM bS adm).succ ↪ R := distinctElems bS adm
hμ : μ = distinctElems bS adm
s : ι →₀ R := bS.repr a
s_eq : ∀ (i : ι), s i = (bS.repr a) i
qs : Fin (cardM bS adm).succ → ι → R := fun j i => μ j * s i / b
rs : Fin (cardM bS adm).succ → ι → R := fun j i => μ j * s i % b
r_eq : ∀ (j : Fin (cardM bS adm).succ) (i : ι), rs j i = μ j * s i % b
μ_eq : ∀ (i : ι) (j : Fin (cardM bS adm).succ), μ j * s i = b * qs j i + rs j i
μ_mul_a_eq : ∀ (j : Fin (cardM bS adm).succ), μ j • a = b • ∑ i : ι, qs j i • bS i + ∑ i : ι, rs j i • bS i
j k : Fin (adm.card ε ^ Fintype.card ι).succ
j_ne_k : j ≠ k
hjk : ∀ (k_1 : ι), ↑(abv (μ k * s k_1 % b - μ j * s k_1 % b)) < abv b • ε
⊢ ∃ q, ∃ r ∈ finsetApprox bS adm, abv ((Algebra.norm R) (r • a - b • q)) < abv ((Algebra.norm R) ((algebraMap R S) b))
|
have hjk' : ∀ i, (abv (rs k i - rs j i) : ℝ) < abv b • ε := by simpa only [r_eq] using hjk
|
case intro.intro.intro
R : Type u_1
S : Type u_2
inst✝⁷ : EuclideanDomain R
inst✝⁶ : CommRing S
inst✝⁵ : IsDomain S
inst✝⁴ : Algebra R S
abv : AbsoluteValue R ℤ
ι : Type u_5
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
bS : Basis ι R S
adm : abv.IsAdmissible
inst✝¹ : Infinite R
inst✝ : DecidableEq R
a : S
b : R
hb : b ≠ 0
dim_pos : 0 < Fintype.card ι
ε : ℝ := ↑(normBound abv bS) ^ (-1 / ↑(Fintype.card ι))
ε_eq : ε = ↑(normBound abv bS) ^ (-1 / ↑(Fintype.card ι))
hε : 0 < ε
ε_le : ↑(normBound abv bS) * (abv b • ε) ^ ↑(Fintype.card ι) ≤ ↑(abv b) ^ ↑(Fintype.card ι)
μ : Fin (cardM bS adm).succ ↪ R := distinctElems bS adm
hμ : μ = distinctElems bS adm
s : ι →₀ R := bS.repr a
s_eq : ∀ (i : ι), s i = (bS.repr a) i
qs : Fin (cardM bS adm).succ → ι → R := fun j i => μ j * s i / b
rs : Fin (cardM bS adm).succ → ι → R := fun j i => μ j * s i % b
r_eq : ∀ (j : Fin (cardM bS adm).succ) (i : ι), rs j i = μ j * s i % b
μ_eq : ∀ (i : ι) (j : Fin (cardM bS adm).succ), μ j * s i = b * qs j i + rs j i
μ_mul_a_eq : ∀ (j : Fin (cardM bS adm).succ), μ j • a = b • ∑ i : ι, qs j i • bS i + ∑ i : ι, rs j i • bS i
j k : Fin (adm.card ε ^ Fintype.card ι).succ
j_ne_k : j ≠ k
hjk : ∀ (k_1 : ι), ↑(abv (μ k * s k_1 % b - μ j * s k_1 % b)) < abv b • ε
hjk' : ∀ (i : ι), ↑(abv (rs k i - rs j i)) < abv b • ε
⊢ ∃ q, ∃ r ∈ finsetApprox bS adm, abv ((Algebra.norm R) (r • a - b • q)) < abv ((Algebra.norm R) ((algebraMap R S) b))
|
57a52f480b46c47f
|
Mathlib.Meta.NormNum.isRat_mul
|
Mathlib/Tactic/NormNum/Basic.lean
|
theorem isRat_mul {α} [Ring α] {f : α → α → α} {a b : α} {na nb nc : ℤ} {da db dc k : ℕ} :
f = HMul.hMul → IsRat a na da → IsRat b nb db →
Int.mul na nb = Int.mul k nc →
Nat.mul da db = Nat.mul k dc →
IsRat (f a b) nc dc
|
case mk.mk
α : Type u_1
inst✝ : Ring α
na nb nc : ℤ
da db dc k : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h₁ : na * nb = ↑k * nc
h₂ : da * db = k * dc
⊢ IsRat (↑na * ⅟↑da * (↑nb * ⅟↑db)) nc dc
|
have : Invertible (↑(da * db) : α) := by simpa using invertibleMul (da:α) db
|
case mk.mk
α : Type u_1
inst✝ : Ring α
na nb nc : ℤ
da db dc k : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h₁ : na * nb = ↑k * nc
h₂ : da * db = k * dc
this : Invertible ↑(da * db)
⊢ IsRat (↑na * ⅟↑da * (↑nb * ⅟↑db)) nc dc
|
9b529ea192c16dfe
|
Finset.prod_diag
|
Mathlib/Algebra/BigOperators/Group/Finset/Basic.lean
|
@[to_additive (attr := simp)]
lemma prod_diag [DecidableEq α] (s : Finset α) (f : α × α → β) :
∏ i ∈ s.diag, f i = ∏ i ∈ s, f (i, i)
|
α : Type u_3
β : Type u_4
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α × α → β
⊢ ∏ i ∈ s.diag, f i = ∏ i ∈ s, f (i, i)
|
apply prod_nbij' Prod.fst (fun i ↦ (i, i)) <;> simp
|
no goals
|
f7b97ff981814e1c
|
continuousOn_boolIndicator_iff_isClopen
|
Mathlib/Topology/Clopen.lean
|
theorem continuousOn_boolIndicator_iff_isClopen (s U : Set X) :
ContinuousOn U.boolIndicator s ↔ IsClopen (((↑) : s → X) ⁻¹' U)
|
X : Type u
inst✝ : TopologicalSpace X
s U : Set X
⊢ Continuous (s.restrict U.boolIndicator) ↔ Continuous (Subtype.val ⁻¹' U).boolIndicator
|
rfl
|
no goals
|
86662e5cedab6fa9
|
ZMod.sum_Ico_eq_card_lt
|
Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean
|
theorem sum_Ico_eq_card_lt {p q : ℕ} :
∑ a ∈ Ico 1 (p / 2).succ, a * q / p =
#{x ∈ Ico 1 (p / 2).succ ×ˢ Ico 1 (q / 2).succ | x.2 * p ≤ x.1 * q} :=
if hp0 : p = 0 then by simp [hp0, Finset.ext_iff]
else
calc
∑ a ∈ Ico 1 (p / 2).succ, a * q / p =
∑ a ∈ Ico 1 (p / 2).succ, #{x ∈ Ico 1 (q / 2).succ | x * p ≤ a * q} :=
Finset.sum_congr rfl fun x hx => div_eq_filter_card (Nat.pos_of_ne_zero hp0) <|
calc
x * q / p ≤ p / 2 * q / p
|
p q : ℕ
hp0 : ¬p = 0
⊢ ∑ a ∈ Ico 1 (p / 2).succ, #(filter (fun x => x * p ≤ a * q) (Ico 1 (q / 2).succ)) =
#(filter (fun x => x.2 * p ≤ x.1 * q) (Ico 1 (p / 2).succ ×ˢ Ico 1 (q / 2).succ))
|
rw [← card_sigma]
|
p q : ℕ
hp0 : ¬p = 0
⊢ #((Ico 1 (p / 2).succ).sigma fun a => filter (fun x => x * p ≤ a * q) (Ico 1 (q / 2).succ)) =
#(filter (fun x => x.2 * p ≤ x.1 * q) (Ico 1 (p / 2).succ ×ˢ Ico 1 (q / 2).succ))
|
f481f56c219ea2f8
|
CFC.spectrum_nonempty
|
Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unital.lean
|
/-- In an `R`-algebra with a continuous functional calculus, every element satisfying the predicate
has nonempty `R`-spectrum. -/
lemma CFC.spectrum_nonempty [Nontrivial A] (a : A) (ha : p a
|
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : IsTopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
instCFC : ContinuousFunctionalCalculus R p
inst✝ : Nontrivial A
a : A
ha : autoParam (p a) _auto✝
h : spectrum R a = ∅
⊢ 1 = 0
|
rw [← cfc_one R a, ← cfc_zero R a]
|
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : IsTopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
instCFC : ContinuousFunctionalCalculus R p
inst✝ : Nontrivial A
a : A
ha : autoParam (p a) _auto✝
h : spectrum R a = ∅
⊢ cfc 1 a = cfc 0 a
|
b77b52135f225a17
|
MeasureTheory.integral_mul_upcrossingsBefore_le_integral
|
Mathlib/Probability/Martingale/Upcrossing.lean
|
theorem integral_mul_upcrossingsBefore_le_integral [IsFiniteMeasure μ] (hf : Submartingale f ℱ μ)
(hfN : ∀ ω, a ≤ f N ω) (hfzero : 0 ≤ f 0) (hab : a < b) :
(b - a) * μ[upcrossingsBefore a b f N] ≤ μ[f N] :=
calc
(b - a) * μ[upcrossingsBefore a b f N] ≤
μ[∑ k ∈ Finset.range N, upcrossingStrat a b f N k * (f (k + 1) - f k)]
|
case refine_2
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N : ℕ
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hfN : ∀ (ω : Ω), a ≤ f N ω
hfzero : 0 ≤ f 0
hab : a < b
⊢ (fun a_1 => (b - a) * ↑(upcrossingsBefore a b f N a_1)) ≤ᶠ[ae μ]
∑ k ∈ Finset.range N, upcrossingStrat a b f N k * (f (k + 1) - f k)
|
filter_upwards with ω
|
case refine_2.h
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N : ℕ
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hfN : ∀ (ω : Ω), a ≤ f N ω
hfzero : 0 ≤ f 0
hab : a < b
ω : Ω
⊢ (b - a) * ↑(upcrossingsBefore a b f N ω) ≤ (∑ k ∈ Finset.range N, upcrossingStrat a b f N k * (f (k + 1) - f k)) ω
|
0afa9533cf5ecfc3
|
gcd_pow_right_dvd_pow_gcd
|
Mathlib/Algebra/GCDMonoid/Basic.lean
|
theorem gcd_pow_right_dvd_pow_gcd [GCDMonoid α] {a b : α} {k : ℕ} :
gcd a (b ^ k) ∣ gcd a b ^ k
|
case pos
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b : α
k : ℕ
hg : a = 0 ∧ b = 0
⊢ gcd a (b ^ k) ∣ gcd a b ^ k
|
rcases hg with ⟨rfl, rfl⟩
|
case pos.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
k : ℕ
⊢ gcd 0 (0 ^ k) ∣ gcd 0 0 ^ k
|
15a2a158e00914e2
|
Std.DHashMap.Internal.List.mem_eraseKey_of_key_beq_eq_false
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem mem_eraseKey_of_key_beq_eq_false [BEq α] {a : α}
{l : List ((a : α) × β a)} (p : (a : α) × β a) (hne : (p.1 == a) = false) :
p ∈ eraseKey a l ↔ p ∈ l
|
α : Type u
β : α → Type v
inst✝ : BEq α
a : α
p : (a : α) × β a
hne : (p.fst == a) = false
head✝ : (a : α) × β a
tail✝ : List ((a : α) × β a)
ih : p ∈ eraseKey a tail✝ ↔ p ∈ tail✝
h : ¬(head✝.fst == a) = true
⊢ p ∈ ⟨head✝.fst, head✝.snd⟩ :: eraseKey a tail✝ ↔ p = head✝ ∨ p ∈ tail✝
|
simp only [List.mem_cons, ih]
|
no goals
|
997dbbc69c0b9544
|
WittVector.frobeniusRotation_nonzero
|
Mathlib/RingTheory/WittVector/FrobeniusFractionField.lean
|
theorem frobeniusRotation_nonzero {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
frobeniusRotation p ha₁ ha₂ ≠ 0
|
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : IsAlgClosed k
a₁ a₂ : 𝕎 k
ha₁ : a₁.coeff 0 ≠ 0
ha₂ : a₂.coeff 0 ≠ 0
h : frobeniusRotation p ha₁ ha₂ = 0
⊢ False
|
apply solution_nonzero p ha₁ ha₂
|
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : IsAlgClosed k
a₁ a₂ : 𝕎 k
ha₁ : a₁.coeff 0 ≠ 0
ha₂ : a₂.coeff 0 ≠ 0
h : frobeniusRotation p ha₁ ha₂ = 0
⊢ solution p a₁ a₂ = 0
|
cd34513eeff41152
|
List.kerase_comm
|
Mathlib/Data/List/Sigma.lean
|
theorem kerase_comm (a₁ a₂) (l : List (Sigma β)) :
kerase a₂ (kerase a₁ l) = kerase a₁ (kerase a₂ l) :=
if h : a₁ = a₂ then by simp [h]
else
if ha₁ : a₁ ∈ l.keys then
if ha₂ : a₂ ∈ l.keys then
match l, kerase a₁ l, exists_of_kerase ha₁, ha₂ with
| _, _, ⟨b₁, l₁, l₂, a₁_nin_l₁, rfl, rfl⟩, _ =>
if h' : a₂ ∈ l₁.keys then by
simp [kerase_append_left h',
kerase_append_right (mt (mem_keys_kerase_of_ne h).mp a₁_nin_l₁)]
else by
simp [kerase_append_right h', kerase_append_right a₁_nin_l₁,
@kerase_cons_ne _ _ _ a₂ ⟨a₁, b₁⟩ _ (Ne.symm h)]
else by simp [ha₂, mt mem_keys_of_mem_keys_kerase ha₂]
else by simp [ha₁, mt mem_keys_of_mem_keys_kerase ha₁]
|
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : a₁ = a₂
⊢ kerase a₂ (kerase a₁ l) = kerase a₁ (kerase a₂ l)
|
simp [h]
|
no goals
|
ed896846edee459a
|
UniqueFactorizationMonoid.induction_on_prime
|
Mathlib/RingTheory/UniqueFactorizationDomain/Defs.lean
|
theorem induction_on_prime {P : α → Prop} (a : α) (h₁ : P 0) (h₂ : ∀ x : α, IsUnit x → P x)
(h₃ : ∀ a p : α, a ≠ 0 → Prime p → P a → P (p * a)) : P a
|
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
P : α → Prop
a : α
h₁ : P 0
h₂ : ∀ (x : α), IsUnit x → P x
h₃ : ∀ (a p : α), a ≠ 0 → Irreducible p → P a → P (p * a)
⊢ P a
|
exact WfDvdMonoid.induction_on_irreducible a h₁ h₂ h₃
|
no goals
|
0be901e5bcf8cebe
|
mem_span_C_coeff
|
Mathlib/RingTheory/Polynomial/Basic.lean
|
theorem mem_span_C_coeff : f ∈ Ideal.span { g : R[X] | ∃ i : ℕ, g = C (coeff f i) }
|
case h.e'_5
R : Type u
inst✝ : Semiring R
f : R[X]
p : Ideal R[X] := Ideal.span {g | ∃ i, g = C (f.coeff i)}
n : ℕ
_hn : n ∈ f.support
this✝ : C (f.coeff n) ∈ p
this : (monomial n) 1 • C (f.coeff n) ∈ p
⊢ C (f.coeff n) * X ^ n = (monomial n) 1 • C (f.coeff n)
|
simp only [monomial_mul_C, one_mul, smul_eq_mul]
|
case h.e'_5
R : Type u
inst✝ : Semiring R
f : R[X]
p : Ideal R[X] := Ideal.span {g | ∃ i, g = C (f.coeff i)}
n : ℕ
_hn : n ∈ f.support
this✝ : C (f.coeff n) ∈ p
this : (monomial n) 1 • C (f.coeff n) ∈ p
⊢ C (f.coeff n) * X ^ n = (monomial n) (f.coeff n)
|
99c6c17abeda5d8d
|
CStarModule.inner_sub_right
|
Mathlib/Analysis/CStarAlgebra/Module/Defs.lean
|
@[simp] lemma inner_sub_right {x y z : E} : ⟪x, y - z⟫ = ⟪x, y⟫ - ⟪x, z⟫
|
A : Type u_1
E : Type u_2
inst✝¹⁰ : NonUnitalRing A
inst✝⁹ : StarRing A
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module ℂ A
inst✝⁶ : Module ℂ E
inst✝⁵ : PartialOrder A
inst✝⁴ : SMul Aᵐᵒᵖ E
inst✝³ : Norm A
inst✝² : Norm E
inst✝¹ : CStarModule A E
inst✝ : StarModule ℂ A
x y z : E
⊢ inner x (y - z) = inner x y - inner x z
|
simp [← innerₛₗ_apply]
|
no goals
|
a6b0d1fc66ded6d2
|
WeierstrassCurve.Projective.nonsingularLift_negMap
|
Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
|
lemma nonsingularLift_negMap {P : PointClass F} (hP : W.NonsingularLift P) :
W.NonsingularLift <| W.negMap P
|
case mk
F : Type u
inst✝ : Field F
W : Projective F
P : PointClass F
a✝ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk (⇑(MulAction.orbitRel Fˣ (Fin 3 → F))) a✝)
⊢ W.NonsingularLift (W.negMap (Quot.mk (⇑(MulAction.orbitRel Fˣ (Fin 3 → F))) a✝))
|
exact nonsingular_neg hP
|
no goals
|
6968edc5ae947f66
|
AntilipschitzWith.isBounded_of_image2_left
|
Mathlib/Topology/MetricSpace/Antilipschitz.lean
|
theorem isBounded_of_image2_left (f : α → β → γ) {K₁ : ℝ≥0}
(hf : ∀ b, AntilipschitzWith K₁ fun a => f a b) {s : Set α} {t : Set β}
(hst : IsBounded (Set.image2 f s t)) : IsBounded s ∨ IsBounded t
|
case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f : α → β → γ
K₁ : ℝ≥0
hf : ∀ (b : β), AntilipschitzWith K₁ fun a => f a b
s : Set α
t : Set β
hst : ¬Bornology.IsBounded s ∧ ¬Bornology.IsBounded t
b : β
hb : b ∈ t
⊢ ¬Bornology.IsBounded (image2 f s t)
|
have : ¬IsBounded (Set.image2 f s {b}) := by
intro h
apply hst.1
rw [Set.image2_singleton_right] at h
replace h := (hf b).isBounded_preimage h
exact h.subset (subset_preimage_image _ _)
|
case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f : α → β → γ
K₁ : ℝ≥0
hf : ∀ (b : β), AntilipschitzWith K₁ fun a => f a b
s : Set α
t : Set β
hst : ¬Bornology.IsBounded s ∧ ¬Bornology.IsBounded t
b : β
hb : b ∈ t
this : ¬Bornology.IsBounded (image2 f s {b})
⊢ ¬Bornology.IsBounded (image2 f s t)
|
b07e0f4f99225630
|
Multiset.bind_powerset_len
|
Mathlib/Data/Multiset/Powerset.lean
|
theorem bind_powerset_len {α : Type*} (S : Multiset α) :
(bind (Multiset.range (card S + 1)) fun k => S.powersetCard k) = S.powerset
|
α : Type u_2
S : Multiset α
⊢ ((range (S.card + 1)).bind fun k => powersetCard k S) = S.powerset
|
induction S using Quotient.inductionOn
|
case h
α : Type u_2
a✝ : List α
⊢ ((range (card ⟦a✝⟧ + 1)).bind fun k => powersetCard k ⟦a✝⟧) = powerset ⟦a✝⟧
|
a9e87c78cc183e21
|
ExpGrowth.expGrowthSup_inv
|
Mathlib/Analysis/Asymptotics/ExpGrowth.lean
|
lemma expGrowthSup_inv {u : ℕ → ℝ≥0∞} :
expGrowthSup u⁻¹ = - expGrowthInf u
|
u : ℕ → ℝ≥0∞
⊢ expGrowthSup u⁻¹ = -expGrowthInf u
|
rw [expGrowthInf, ← limsup_neg]
|
u : ℕ → ℝ≥0∞
⊢ expGrowthSup u⁻¹ = limsup (-fun n => (u n).log / ↑n) atTop
|
ca4c1b2bc2a0d2ca
|
Polynomial.HasSeparableContraction.eq_degree
|
Mathlib/RingTheory/Polynomial/SeparableDegree.lean
|
theorem HasSeparableContraction.eq_degree {f : F[X]} (hf : HasSeparableContraction 1 f) :
hf.degree = f.natDegree
|
F : Type u_1
inst✝ : CommSemiring F
f : F[X]
hf : HasSeparableContraction 1 f
⊢ hf.degree = f.natDegree
|
let ⟨a, ha⟩ := hf.dvd_degree'
|
F : Type u_1
inst✝ : CommSemiring F
f : F[X]
hf : HasSeparableContraction 1 f
a : ℕ
ha : hf.degree * 1 ^ a = f.natDegree
⊢ hf.degree = f.natDegree
|
b7d299362a82ef7a
|
Equiv.Perm.count_le_one_of_centralizer_le_alternating
|
Mathlib/GroupTheory/SpecificGroups/Alternating/Centralizer.lean
|
theorem count_le_one_of_centralizer_le_alternating
(h : Subgroup.centralizer {g} ≤ alternatingGroup α) :
∀ i, g.cycleType.count i ≤ 1
|
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g : Perm α
h : Subgroup.centralizer {g} ≤ alternatingGroup α
c : Perm α
hc : c ∈ g.cycleFactorsFinset
d : Perm α
hd : d ∈ g.cycleFactorsFinset
hm : #c.support = #d.support
hm' : c ≠ d
τ : Perm { x // x ∈ g.cycleFactorsFinset } := swap ⟨c, hc⟩ ⟨d, hd⟩
a : g.Basis
x : { x // x ∈ g.cycleFactorsFinset }
hx : ¬x = ⟨c, hc⟩
hx' : ¬x = ⟨d, hd⟩
⊢ #(↑(τ x)).support = #(↑x).support
|
rw [Equiv.swap_apply_of_ne_of_ne hx hx']
|
no goals
|
1a7e68d832b229d5
|
Subgroup.index_le_of_leftCoset_cover_const
|
Mathlib/GroupTheory/CosetCover.lean
|
theorem index_le_of_leftCoset_cover_const : H.index ≤ s.card
|
case inr
G : Type u_1
inst✝ : Group G
ι : Type u_2
s : Finset ι
H : Subgroup G
g : ι → G
hcovers : ⋃ i ∈ s, g i • ↑H = Set.univ
h : H.index > 0
⊢ H.index ≤ s.card
|
rw [leftCoset_cover_const_iff_surjOn, Set.surjOn_iff_surjective] at hcovers
|
case inr
G : Type u_1
inst✝ : Group G
ι : Type u_2
s : Finset ι
H : Subgroup G
g : ι → G
hcovers : Function.Surjective ((↑s).restrict fun x => ↑(g x))
h : H.index > 0
⊢ H.index ≤ s.card
|
de9bbc984b56e937
|
AlgebraicGeometry.StructureSheaf.toBasicOpen_injective
|
Mathlib/AlgebraicGeometry/StructureSheaf.lean
|
theorem toBasicOpen_injective (f : R) : Function.Injective (toBasicOpen R f)
|
case intro.intro.mk.intro.intro.mk
R : Type u
inst✝ : CommRing R
f a b : R
hb : b ∈ Submonoid.powers f
c d : R
hd : d ∈ Submonoid.powers f
h_eq : const R a b (PrimeSpectrum.basicOpen f) ⋯ = const R c d (PrimeSpectrum.basicOpen f) ⋯
⊢ IsLocalization.mk' (Localization.Away f) a ⟨b, hb⟩ = IsLocalization.mk' (Localization.Away f) c ⟨d, hd⟩
|
rw [IsLocalization.eq]
|
case intro.intro.mk.intro.intro.mk
R : Type u
inst✝ : CommRing R
f a b : R
hb : b ∈ Submonoid.powers f
c d : R
hd : d ∈ Submonoid.powers f
h_eq : const R a b (PrimeSpectrum.basicOpen f) ⋯ = const R c d (PrimeSpectrum.basicOpen f) ⋯
⊢ ∃ c_1, ↑c_1 * (↑⟨d, hd⟩ * a) = ↑c_1 * (↑⟨b, hb⟩ * c)
|
99cd46dea5cb621c
|
AlgHom.IsArithFrobAt.mk_apply
|
Mathlib/RingTheory/Frobenius.lean
|
lemma mk_apply (x) : Ideal.Quotient.mk Q (φ x) = x ^ Nat.card (R ⧸ Q.under R)
|
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
φ : S →ₐ[R] S
Q : Ideal S
H : φ.IsArithFrobAt Q
x : S
⊢ φ x - x ^ Nat.card (R ⧸ Ideal.under R Q) ∈ Q
|
exact H x
|
no goals
|
bc6ddec39ff0b2f0
|
Turing.ToPartrec.Code.exists_code
|
Mathlib/Computability/TMConfig.lean
|
theorem exists_code {n} {f : List.Vector ℕ n →. ℕ} (hf : Nat.Partrec' f) :
∃ c : Code, ∀ v : List.Vector ℕ n, c.eval v.1 = pure <$> f v
|
case rfind.intro.mp.intro.intro
n✝ : ℕ
f✝ : List.Vector ℕ n✝ →. ℕ
n : ℕ
f : List.Vector ℕ (n + 1) → ℕ
a✝ : Nat.Partrec' ↑f
cf : Code
v : List.Vector ℕ n
hf : ∀ (a : ℕ), cf.eval (a :: ↑v) = Part.some [f (a ::ᵥ v)]
v' : List ℕ
h1 :
v' ∈
PFun.fix
(fun v =>
(cf.eval v).bind fun y =>
Part.some (if y.headI = 0 then Sum.inl (v.headI.succ :: v.tail) else Sum.inr (v.headI.succ :: v.tail)))
(0 :: ↑v)
⊢ ∃ a, (f (a ::ᵥ v) = 0 ∧ ∀ {m : ℕ}, m < a → ¬f (m ::ᵥ v) = 0) ∧ pure a = [v'.headI.pred]
|
suffices ∀ v₁ : List ℕ, v' ∈ PFun.fix
(fun v => (cf.eval v).bind fun y => Part.some <|
if y.headI = 0 then Sum.inl (v.headI.succ :: v.tail)
else Sum.inr (v.headI.succ :: v.tail)) v₁ →
∀ n, (v₁ = n :: v.val) → (∀ m < n, ¬f (m ::ᵥ v) = 0) →
∃ a : ℕ,
(f (a ::ᵥ v) = 0 ∧ ∀ {m : ℕ}, m < a → ¬f (m ::ᵥ v) = 0) ∧ [a] = [v'.headI.pred]
by exact this _ h1 0 rfl (by rintro _ ⟨⟩)
|
case rfind.intro.mp.intro.intro
n✝ : ℕ
f✝ : List.Vector ℕ n✝ →. ℕ
n : ℕ
f : List.Vector ℕ (n + 1) → ℕ
a✝ : Nat.Partrec' ↑f
cf : Code
v : List.Vector ℕ n
hf : ∀ (a : ℕ), cf.eval (a :: ↑v) = Part.some [f (a ::ᵥ v)]
v' : List ℕ
h1 :
v' ∈
PFun.fix
(fun v =>
(cf.eval v).bind fun y =>
Part.some (if y.headI = 0 then Sum.inl (v.headI.succ :: v.tail) else Sum.inr (v.headI.succ :: v.tail)))
(0 :: ↑v)
⊢ ∀ (v₁ : List ℕ),
v' ∈
PFun.fix
(fun v =>
(cf.eval v).bind fun y =>
Part.some (if y.headI = 0 then Sum.inl (v.headI.succ :: v.tail) else Sum.inr (v.headI.succ :: v.tail)))
v₁ →
∀ (n_1 : ℕ),
v₁ = n_1 :: ↑v →
(∀ m < n_1, ¬f (m ::ᵥ v) = 0) →
∃ a, (f (a ::ᵥ v) = 0 ∧ ∀ {m : ℕ}, m < a → ¬f (m ::ᵥ v) = 0) ∧ [a] = [v'.headI.pred]
|
01823c87e1740c3b
|
torusIntegral_dim1
|
Mathlib/MeasureTheory/Integral/TorusIntegral.lean
|
theorem torusIntegral_dim1 (f : ℂ¹ → E) (c : ℂ¹) (R : ℝ¹) :
(∯ x in T(c, R), f x) = ∮ z in C(c 0, R 0), f fun _ => z
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : (Fin 1 → ℂ) → E
c : Fin 1 → ℂ
R : Fin 1 → ℝ
H₁ : (⇑(MeasurableEquiv.funUnique (Fin 1) ℝ).symm ⁻¹' Icc 0 fun x => 2 * π) = Icc 0 (2 * π)
H₂ : torusMap c R = fun θ x => circleMap (c 0) (R 0) (θ 0)
⊢ ∫ (x : ℝ) in Icc 0 (2 * π),
(∏ i : Fin 1, ↑(R i) * cexp (↑((MeasurableEquiv.funUnique (Fin 1) ℝ).symm x i) * I) * I) •
f ((fun θ x => circleMap (c 0) (R 0) (θ 0)) ((MeasurableEquiv.funUnique (Fin 1) ℝ).symm x)) =
∫ (x : ℝ) in Icc 0 (2 * π), deriv (circleMap (c 0) (R 0)) x • f fun x_1 => circleMap (c 0) (R 0) x ∂volume
|
simp [circleMap_zero]
|
no goals
|
34148b6ecc6aa62c
|
isSemisimpleModule_biSup_of_isSemisimpleModule_submodule
|
Mathlib/RingTheory/SimpleModule/Basic.lean
|
lemma isSemisimpleModule_biSup_of_isSemisimpleModule_submodule {s : Set ι} {p : ι → Submodule R M}
(hp : ∀ i ∈ s, IsSemisimpleModule R (p i)) :
IsSemisimpleModule R ↥(⨆ i ∈ s, p i)
|
ι : Type u_1
R : Type u_2
inst✝² : Ring R
M : Type u_4
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set ι
p : ι → Submodule R M
hp : ∀ i ∈ s, IsSemisimpleModule R ↥(p i)
q : Submodule R M := ⨆ i ∈ s, p i
p' : ι → Submodule R ↥q := fun i => Submodule.comap q.subtype (p i)
⊢ IsSemisimpleModule R ↥(⨆ i ∈ s, p i)
|
have hp₀ : ∀ i ∈ s, p i ≤ LinearMap.range q.subtype := fun i hi ↦ by
simpa only [Submodule.range_subtype] using le_biSup _ hi
|
ι : Type u_1
R : Type u_2
inst✝² : Ring R
M : Type u_4
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set ι
p : ι → Submodule R M
hp : ∀ i ∈ s, IsSemisimpleModule R ↥(p i)
q : Submodule R M := ⨆ i ∈ s, p i
p' : ι → Submodule R ↥q := fun i => Submodule.comap q.subtype (p i)
hp₀ : ∀ i ∈ s, p i ≤ LinearMap.range q.subtype
⊢ IsSemisimpleModule R ↥(⨆ i ∈ s, p i)
|
eaf87fd728503096
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.