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
|
|---|---|---|---|---|---|---|
ProbabilityTheory.Kernel.integral_withDensity
|
Mathlib/Probability/Kernel/WithDensity.lean
|
theorem integral_withDensity {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
{f : β → E} [IsSFiniteKernel κ] {a : α} {g : α → β → ℝ≥0}
(hg : Measurable (Function.uncurry g)) :
∫ b, f b ∂withDensity κ (fun a b => g a b) a = ∫ b, g a b • f b ∂κ a
|
case hf
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f : β → E
inst✝ : IsSFiniteKernel κ
a : α
g : α → β → ℝ≥0
hg : Measurable (Function.uncurry g)
⊢ Measurable (Function.uncurry fun a b => ↑(g a b))
|
fun_prop
|
no goals
|
a452ee35b1f07cfc
|
Set.star_mem_center
|
Mathlib/Algebra/Star/Center.lean
|
theorem Set.star_mem_center (ha : a ∈ Set.center R) : star a ∈ Set.center R where
comm
|
R : Type u_1
inst✝¹ : Mul R
inst✝ : StarMul R
a : R
ha : a ∈ center R
b c : R
⊢ star (a * star c * star b) = b * star (a * star c)
|
rw [star_mul, star_star]
|
no goals
|
c15bad2514aa2cf1
|
tendsto_tsum_of_dominated_convergence
|
Mathlib/Analysis/Normed/Group/Tannery.lean
|
/-- **Tannery's theorem**: topological sums commute with termwise limits, when the norms of the
summands are eventually uniformly bounded by a summable function.
(This is the special case of the Lebesgue dominated convergence theorem for the counting measure
on a discrete set. However, we prove it under somewhat weaker assumptions than the general
measure-theoretic result, e.g. `G` is not assumed to be an `ℝ`-vector space or second countable,
and the limit is along an arbitrary filter rather than `atTop ℕ`.)
See also:
* `MeasureTheory.tendsto_integral_of_dominated_convergence` (for general integrals, but
with more assumptions on `G`)
* `continuous_tsum` (continuity of infinite sums in a parameter)
-/
lemma tendsto_tsum_of_dominated_convergence {α β G : Type*} {𝓕 : Filter α}
[NormedAddCommGroup G] [CompleteSpace G]
{f : α → β → G} {g : β → G} {bound : β → ℝ} (h_sum : Summable bound)
(hab : ∀ k : β, Tendsto (f · k) 𝓕 (𝓝 (g k)))
(h_bound : ∀ᶠ n in 𝓕, ∀ k, ‖f n k‖ ≤ bound k) :
Tendsto (∑' k, f · k) 𝓕 (𝓝 (∑' k, g k))
|
α : Type u_1
β : Type u_2
G : Type u_3
𝓕 : Filter α
inst✝¹ : NormedAddCommGroup G
inst✝ : CompleteSpace G
f : α → β → G
g : β → G
bound : β → ℝ
h_sum : Summable bound
hab : ∀ (k : β), Tendsto (fun x => f x k) 𝓕 (𝓝 (g k))
h_bound : ∀ᶠ (n : α) in 𝓕, ∀ (k : β), ‖f n k‖ ≤ bound k
h✝¹ : Nonempty β
h✝ : 𝓕.NeBot
h_g_le : ∀ (k : β), ‖g k‖ ≤ bound k
h_sumg : Summable fun x => ‖g x‖
h_suma : ∀ᶠ (n : α) in 𝓕, Summable fun x => ‖f n x‖
ε : ℝ
hε : ε > 0
S : ℝ
hS : HasSum bound S
T : Finset β
hT : dist (∑ b ∈ T, bound b) S < ε / 3
⊢ ∑' (k : ↑(↑T)ᶜ), bound ↑k = S - ∑ b ∈ T, bound b
|
simpa only [sum_add_tsum_compl h_sum, eq_sub_iff_add_eq'] using hS.tsum_eq
|
no goals
|
d4198172206cf97e
|
WittVector.coeff_p_pow_eq_zero
|
Mathlib/RingTheory/WittVector/Identities.lean
|
theorem coeff_p_pow_eq_zero [CharP R p] {i j : ℕ} (hj : j ≠ i) : ((p : 𝕎 R) ^ i).coeff j = 0
|
case succ.succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CharP R p
i : ℕ
hi : ∀ {j : ℕ}, j ≠ i → (↑p ^ i).coeff j = 0
n✝ : ℕ
hj : n✝ + 1 ≠ i + 1
⊢ (verschiebung (↑p ^ i)).coeff (n✝ + 1) ^ p = 0
|
rw [verschiebung_coeff_succ, hi (ne_of_apply_ne _ hj), zero_pow hp.out.ne_zero]
|
no goals
|
0456d8b61855531e
|
PullbackCone.IsLimit.equivPullbackObj_symm_apply_fst
|
Mathlib/CategoryTheory/Limits/Shapes/Types.lean
|
@[simp]
lemma equivPullbackObj_symm_apply_fst (x : Types.PullbackObj f g) :
c.fst ((equivPullbackObj hc).symm x) = x.1.1
|
X Y S : Type v
f : X ⟶ S
g : Y ⟶ S
c : PullbackCone f g
hc : IsLimit c
x : Types.PullbackObj f g
⊢ c.fst ((equivPullbackObj hc).symm x) = (↑x).1
|
obtain ⟨x, rfl⟩ := (equivPullbackObj hc).surjective x
|
case intro
X Y S : Type v
f : X ⟶ S
g : Y ⟶ S
c : PullbackCone f g
hc : IsLimit c
x : c.pt
⊢ c.fst ((equivPullbackObj hc).symm ((equivPullbackObj hc) x)) = (↑((equivPullbackObj hc) x)).1
|
54db9da2c6aaa66b
|
IsPrimitiveRoot.arg
|
Mathlib/RingTheory/RootsOfUnity/Complex.lean
|
theorem IsPrimitiveRoot.arg {n : ℕ} {ζ : ℂ} (h : IsPrimitiveRoot ζ n) (hn : n ≠ 0) :
∃ i : ℤ, ζ.arg = i / n * (2 * Real.pi) ∧ IsCoprime i n ∧ i.natAbs < n
|
case neg.convert_2.refine_2
n : ℕ
hn : n ≠ 0
i : ℕ
h : i < n
hin : i.Coprime n
h₂ : ¬i * 2 ≤ n
⊢ (↑i - ↑n) * (2 * Real.pi / ↑n) ≤ 0
|
exact mul_nonpos_of_nonpos_of_nonneg (sub_nonpos.mpr <| mod_cast h.le)
(div_nonneg (by simp [Real.pi_pos.le]) <| by simp)
|
no goals
|
27e9c2564262c07b
|
prime_factors_unique
|
Mathlib/RingTheory/UniqueFactorizationDomain/Basic.lean
|
theorem prime_factors_unique [CancelCommMonoidWithZero α] :
∀ {f g : Multiset α},
(∀ x ∈ f, Prime x) → (∀ x ∈ g, Prime x) → f.prod ~ᵤ g.prod → Multiset.Rel Associated f g
|
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
⊢ ∀ {f g : Multiset α}, (∀ x ∈ f, Prime x) → (∀ x ∈ g, Prime x) → f.prod ~ᵤ g.prod → Multiset.Rel Associated f g
|
intro f
|
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
f : Multiset α
⊢ ∀ {g : Multiset α}, (∀ x ∈ f, Prime x) → (∀ x ∈ g, Prime x) → f.prod ~ᵤ g.prod → Multiset.Rel Associated f g
|
076a07413cee2004
|
Ordinal.log_opow_mul_add
|
Mathlib/SetTheory/Ordinal/Exponential.lean
|
theorem log_opow_mul_add {b u v w : Ordinal} (hb : 1 < b) (hv : v ≠ 0) (hw : w < b ^ u) :
log b (b ^ u * v + w) = u + log b v
|
case right
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hw : w < b ^ u
⊢ b ^ u * v + b ^ u ≤ b ^ succ (u + log b v)
|
rw [← mul_succ, ← add_succ, opow_add]
|
case right
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hw : w < b ^ u
⊢ b ^ u * succ v ≤ b ^ u * b ^ succ (log b v)
|
fdca12373d77fc9a
|
CategoryTheory.PreGaloisCategory.has_decomp_connected_components_aux
|
Mathlib/CategoryTheory/Galois/Decomposition.lean
|
private lemma has_decomp_connected_components_aux (F : C ⥤ FintypeCat.{w}) [FiberFunctor F]
(n : ℕ) : ∀ (X : C), n = Nat.card (F.obj X) → ∃ (ι : Type) (f : ι → C)
(g : (i : ι) → (f i) ⟶ X) (_ : IsColimit (Cofan.mk X g)),
(∀ i, IsConnected (f i)) ∧ Finite ι
|
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
n : ℕ
⊢ ∀ (X : C), n = Nat.card (F.obj X).carrier → ∃ ι f g x, (∀ (i : ι), IsConnected (f i)) ∧ Finite ι
|
induction' n using Nat.strongRecOn with n hi
|
case ind
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
n : ℕ
hi : ∀ m < n, ∀ (X : C), m = Nat.card (F.obj X).carrier → ∃ ι f g x, (∀ (i : ι), IsConnected (f i)) ∧ Finite ι
⊢ ∀ (X : C), n = Nat.card (F.obj X).carrier → ∃ ι f g x, (∀ (i : ι), IsConnected (f i)) ∧ Finite ι
|
8c6babb797aa0c98
|
Polynomial.mul_scaleRoots_of_noZeroDivisors
|
Mathlib/RingTheory/Polynomial/ScaleRoots.lean
|
lemma mul_scaleRoots_of_noZeroDivisors (p q : R[X]) (r : R) [NoZeroDivisors R] :
(p * q).scaleRoots r = p.scaleRoots r * q.scaleRoots r
|
case pos
R : Type u_1
inst✝¹ : CommSemiring R
p q : R[X]
r : R
inst✝ : NoZeroDivisors R
hp : p = 0
⊢ (p * q).scaleRoots r = p.scaleRoots r * q.scaleRoots r
|
simp [hp]
|
no goals
|
2faef2df62866efd
|
CategoryTheory.Functor.isConnected_iff_of_final
|
Mathlib/CategoryTheory/Limits/IsConnected.lean
|
theorem isConnected_iff_of_final (F : C ⥤ D) [F.Final] : IsConnected C ↔ IsConnected D
|
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.Final
⊢ IsConnected C ↔ IsConnected D
|
rw [isConnected_iff_colimit_constPUnitFunctor_iso_pUnit.{max v u v₂ u₂} C,
isConnected_iff_colimit_constPUnitFunctor_iso_pUnit.{max v u v₂ u₂} D]
|
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.Final
⊢ Nonempty (Limits.colimit (constPUnitFunctor C) ≅ PUnit.{(max v u v₂ u₂) + 1}) ↔
Nonempty (Limits.colimit (constPUnitFunctor D) ≅ PUnit.{(max v u v₂ u₂) + 1})
|
765f67438475d3d8
|
fermatLastTheoremWith'_polynomial
|
Mathlib/NumberTheory/FLT/Polynomial.lean
|
theorem fermatLastTheoremWith'_polynomial {n : ℕ} (hn : 3 ≤ n) (chn : (n : k) ≠ 0) :
FermatLastTheoremWith' k[X] n
|
k : Type u_1
inst✝ : Field k
n : ℕ
hn✝ : 3 ≤ n
chn : ↑n ≠ 0
a b c : k[X]
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
a' b' : k[X]
d : k[X] := gcd a b
heq : d ^ n * (a' ^ n + b' ^ n) = c ^ n
eq_a : a = d * a'
eq_b : b = d * b'
hd : d ≠ 0
hn : 0 < n
hdncn : ∀ (a : k[X]), Multiset.count a (normalizedFactors d) ≤ Multiset.count a (normalizedFactors c)
⊢ ∀ (a : k[X]), Multiset.count a (normalizedFactors d) ≤ Multiset.count a (normalizedFactors c)
|
exact hdncn
|
no goals
|
0b2f8f9d4d152b49
|
CategoryTheory.MorphismProperty.IsStableUnderProductsOfShape.mk
|
Mathlib/CategoryTheory/MorphismProperty/Limits.lean
|
lemma IsStableUnderProductsOfShape.mk (J : Type*) [W.RespectsIso]
(hW : ∀ (X₁ X₂ : J → C) [HasProduct X₁] [HasProduct X₂]
(f : ∀ j, X₁ j ⟶ X₂ j) (_ : ∀ (j : J), W (f j)),
W (Limits.Pi.map f)) : W.IsStableUnderProductsOfShape J
|
C : Type u
inst✝¹ : Category.{v, u} C
W : MorphismProperty C
J : Type u_1
inst✝ : W.RespectsIso
hW :
∀ (X₁ X₂ : J → C) [inst : HasProduct X₁] [inst_1 : HasProduct X₂] (f : (j : J) → X₁ j ⟶ X₂ j),
(∀ (j : J), W (f j)) → W (Limits.Pi.map f)
X₁ X₂ : Discrete J ⥤ C
c₁ : Cone X₁
c₂ : Cone X₂
hc₁ : IsLimit c₁
hc₂ : IsLimit c₂
f : X₁ ⟶ X₂
hf : W.functorCategory (Discrete J) f
φ : (j : J) → X₁.obj { as := j } ⟶ X₂.obj { as := j } := fun j => f.app { as := j }
this : HasLimit X₁
⊢ W (hc₂.lift { pt := c₁.pt, π := c₁.π ≫ f })
|
have : HasLimit X₂ := ⟨c₂, hc₂⟩
|
C : Type u
inst✝¹ : Category.{v, u} C
W : MorphismProperty C
J : Type u_1
inst✝ : W.RespectsIso
hW :
∀ (X₁ X₂ : J → C) [inst : HasProduct X₁] [inst_1 : HasProduct X₂] (f : (j : J) → X₁ j ⟶ X₂ j),
(∀ (j : J), W (f j)) → W (Limits.Pi.map f)
X₁ X₂ : Discrete J ⥤ C
c₁ : Cone X₁
c₂ : Cone X₂
hc₁ : IsLimit c₁
hc₂ : IsLimit c₂
f : X₁ ⟶ X₂
hf : W.functorCategory (Discrete J) f
φ : (j : J) → X₁.obj { as := j } ⟶ X₂.obj { as := j } := fun j => f.app { as := j }
this✝ : HasLimit X₁
this : HasLimit X₂
⊢ W (hc₂.lift { pt := c₁.pt, π := c₁.π ≫ f })
|
e8bcc319c9a1955e
|
Stream'.WSeq.exists_of_mem_join
|
Mathlib/Data/Seq/WSeq.lean
|
theorem exists_of_mem_join {a : α} : ∀ {S : WSeq (WSeq α)}, a ∈ join S → ∃ s, s ∈ S ∧ a ∈ s
|
case h2.h3
α : Type u
a : α
ss : WSeq α
h : a ∈ ss
S : WSeq (WSeq α)
s : WSeq α
IH :
∀ (s_1 : WSeq α) (S_1 : WSeq (WSeq α)),
s_1.append S_1.join = s.append S.join → a ∈ s_1.append S_1.join → a ∈ s_1 ∨ ∃ s, s ∈ S_1 ∧ a ∈ s
ej : (s.append S.join).think = (s.append S.join).think
m : a ∈ s.append S.join
⊢ a ∈ s ∨ ∃ s, s ∈ S ∧ a ∈ s
|
apply IH _ _ rfl m
|
no goals
|
ec68064248c6eec8
|
integrable_exp_neg_mul_sq
|
Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
|
theorem integrable_exp_neg_mul_sq {b : ℝ} (hb : 0 < b) :
Integrable fun x : ℝ => exp (-b * x ^ 2)
|
b : ℝ
hb : 0 < b
⊢ Integrable (fun x => rexp (-b * x ^ 2)) volume
|
simpa using integrable_rpow_mul_exp_neg_mul_sq hb (by norm_num : (-1 : ℝ) < 0)
|
no goals
|
43cf0bce12faa9c9
|
ProbabilityTheory.integrable_rpow_abs_mul_exp_add_of_integrable_exp_mul
|
Mathlib/Probability/Moments/IntegrableExpMul.lean
|
/-- If `exp ((v + t) * X)` and `exp ((v - t) * X)` are integrable
then for nonnegative `p : ℝ` and any `x ∈ [0, |t|)`,
`|X| ^ p * exp (v * X + x * |X|)` is integrable. -/
lemma integrable_rpow_abs_mul_exp_add_of_integrable_exp_mul {x : ℝ}
(h_int_pos : Integrable (fun ω ↦ exp ((v + t) * X ω)) μ)
(h_int_neg : Integrable (fun ω ↦ exp ((v - t) * X ω)) μ) (h_nonneg : 0 ≤ x) (hx : x < |t|)
{p : ℝ} (hp : 0 ≤ p) :
Integrable (fun a ↦ |X a| ^ p * exp (v * X a + x * |X a|)) μ
|
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t v x : ℝ
h_int_pos : Integrable (fun ω => rexp ((v + t) * X ω)) μ
h_int_neg : Integrable (fun ω => rexp ((v - t) * X ω)) μ
h_nonneg : 0 ≤ x
hx : x < |t|
p : ℝ
hp : 0 ≤ p
⊢ t ≠ 0
|
suffices |t| ≠ 0 by simpa
|
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t v x : ℝ
h_int_pos : Integrable (fun ω => rexp ((v + t) * X ω)) μ
h_int_neg : Integrable (fun ω => rexp ((v - t) * X ω)) μ
h_nonneg : 0 ≤ x
hx : x < |t|
p : ℝ
hp : 0 ≤ p
⊢ |t| ≠ 0
|
6d408f5eb4922de2
|
HomologicalComplex.homotopyCofiber.inlX_desc_f
|
Mathlib/Algebra/Homology/HomotopyCofiber.lean
|
@[reassoc (attr := simp)]
lemma inlX_desc_f (i j : ι) (hjk : c.Rel j i) :
inlX φ i j hjk ≫ (desc φ α hα).f j = hα.hom i j
|
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝¹ : HasHomotopyCofiber φ
inst✝ : DecidableRel c.Rel
α : G ⟶ K
hα : Homotopy (φ ≫ α) 0
j : ι
hjk : c.Rel j (c.next j)
⊢ inlX φ (c.next j) j hjk ≫ (desc φ α hα).f j = hα.hom (c.next j) j
|
dsimp [desc]
|
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝¹ : HasHomotopyCofiber φ
inst✝ : DecidableRel c.Rel
α : G ⟶ K
hα : Homotopy (φ ≫ α) 0
j : ι
hjk : c.Rel j (c.next j)
⊢ (inlX φ (c.next j) j hjk ≫
if hj : c.Rel j (c.next j) then fstX φ j (c.next j) hj ≫ hα.hom (c.next j) j + sndX φ j ≫ α.f j
else sndX φ j ≫ α.f j) =
hα.hom (c.next j) j
|
056c26232b147ff6
|
Basis.SmithNormalForm.toAddSubgroup_index_eq_pow_mul_prod
|
Mathlib/LinearAlgebra/FreeModule/Int.lean
|
/-- Given a submodule `N` in Smith normal form of a free `R`-module, its index as an additive
subgroup is an appropriate power of the cardinality of `R` multiplied by the product of the
indexes of the ideals generated by each basis vector. -/
lemma toAddSubgroup_index_eq_pow_mul_prod [Module R M] {N : Submodule R M}
(snf : Basis.SmithNormalForm N ι n) :
N.toAddSubgroup.index = Nat.card R ^ (Fintype.card ι - n) *
∏ i : Fin n, (Ideal.span {snf.a i}).toAddSubgroup.index
|
case h.e'_4
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Fintype ι
inst✝ : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf : ∀ (i : Fin n), ↑(bN i) = a i • bM (f i)
N' : Submodule R (ι → R) := Submodule.map bM.equivFun N
hN' : N' = Submodule.map bM.equivFun N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' : ∀ (i : Fin n), ↑(bN' i) = Pi.single (f i) (a i)
hNN' : N.toAddSubgroup.index = N'.toAddSubgroup.index
c : Fin n → R
i : ι
h : ¬∃ j, f j = i
⊢ (∑ x : Fin n, c x • if i = f x then a x else 0) = 0
|
convert Finset.sum_const_zero with j
|
case h.e'_2.a
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Fintype ι
inst✝ : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf : ∀ (i : Fin n), ↑(bN i) = a i • bM (f i)
N' : Submodule R (ι → R) := Submodule.map bM.equivFun N
hN' : N' = Submodule.map bM.equivFun N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' : ∀ (i : Fin n), ↑(bN' i) = Pi.single (f i) (a i)
hNN' : N.toAddSubgroup.index = N'.toAddSubgroup.index
c : Fin n → R
i : ι
h : ¬∃ j, f j = i
j : Fin n
a✝ : j ∈ Finset.univ
⊢ (c j • if i = f j then a j else 0) = 0
|
3d7a9cb7455a5c0f
|
Nat.card_of_subsingleton
|
Mathlib/SetTheory/Cardinal/Finite.lean
|
theorem card_of_subsingleton (a : α) [Subsingleton α] : Nat.card α = 1
|
α : Type u_1
a : α
inst✝ : Subsingleton α
this : Fintype α := Fintype.ofSubsingleton a
⊢ Nat.card α = 1
|
rw [card_eq_fintype_card, Fintype.card_ofSubsingleton a]
|
no goals
|
a1246ff58d2ee7ee
|
nodup_permsOfList
|
Mathlib/Data/Fintype/Perm.lean
|
theorem nodup_permsOfList : ∀ {l : List α}, l.Nodup → (permsOfList l).Nodup
| [], _ => by simp [permsOfList]
| a :: l, hl => by
have hl' : l.Nodup := hl.of_cons
have hln' : (permsOfList l).Nodup := nodup_permsOfList hl'
have hmeml : ∀ {f : Perm α}, f ∈ permsOfList l → f a = a := fun {f} hf =>
not_not.1 (mt (mem_of_mem_permsOfList hf _) (nodup_cons.1 hl).1)
rw [permsOfList, List.nodup_append, List.nodup_flatMap, pairwise_iff_getElem]
refine ⟨?_, ⟨⟨?_,?_ ⟩, ?_⟩⟩
· exact hln'
· exact fun _ _ => hln'.map fun _ _ => mul_left_cancel
· intros i j hi hj hij x hx₁ hx₂
let ⟨f, hf⟩ := List.mem_map.1 hx₁
let ⟨g, hg⟩ := List.mem_map.1 hx₂
have hix : x a = l[i]
|
α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
hl : (a :: l).Nodup
hl' : l.Nodup
hln' : (permsOfList l).Nodup
hmeml : ∀ {f : Equiv.Perm α}, f ∈ permsOfList l → f a = a
f : Equiv.Perm α
hf₁ : f ∈ permsOfList l
hf₂ : f ∈ flatMap (fun b => List.map (fun f => Equiv.swap a b * f) (permsOfList l)) l
x : α
hx : x ∈ l
hx' : f ∈ List.map (fun f => Equiv.swap a x * f) (permsOfList l)
g : Equiv.Perm α
hg : g ∈ permsOfList l ∧ Equiv.swap a x * g = f
⊢ (Equiv.swap a x * g) (g⁻¹ x) = a
|
simp
|
no goals
|
1438bc15e355e5ea
|
Module.reflection_mul_reflection_zpow_apply_self
|
Mathlib/LinearAlgebra/Reflection.lean
|
/-- A formula for $(r_1 r_2)^m x$, where $m$ is an integer. This is the special case of
`Module.reflection_mul_reflection_zpow_apply` with $z = x$. -/
lemma reflection_mul_reflection_zpow_apply_self (m : ℤ)
(t : R := f y * g x - 2) (ht : t = f y * g x - 2
|
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
f g : Dual R M
hf : f x = 2
hg : g y = 2
t : optParam R (f y * g x - 2)
ht : autoParam (t = f y * g x - 2) _auto✝
S_eval_t_sub_two :
∀ (k : ℤ),
Polynomial.eval t (S R (k - 2)) = (f y * g x - 2) * Polynomial.eval t (S R (k - 1)) - Polynomial.eval t (S R k)
m : ℕ
ih :
((reflection hf * reflection hg) ^ (-↑m)) x =
(Polynomial.eval t (S R (-↑m)) + Polynomial.eval t (S R (-↑m - 1))) • x +
(Polynomial.eval t (S R (-↑m - 1)) * -g x) • y
⊢ (Polynomial.eval t (S R (-↑m)) + Polynomial.eval t (S R (-↑m - 1))) * (-(g x * 1) - 2 * -(g x * 1)) +
Polynomial.eval t (S R (-↑m - 1)) * -g x * (1 - 2 * 1 - f y * -(g x * 1)) =
Polynomial.eval t (S R (-1 + -↑m - 1)) * -g x * 1
|
linear_combination (norm := ring_nf) g x * S_eval_t_sub_two (-m)
|
no goals
|
f7647e25720205c5
|
Algebra.TensorProduct.not_isField_of_transcendental
|
Mathlib/RingTheory/LinearDisjoint.lean
|
theorem _root_.Algebra.TensorProduct.not_isField_of_transcendental
(A : Type v) [CommRing A] (B : Type w) [CommRing B] [Algebra R A] [Algebra R B]
[Module.Flat R A] [Module.Flat R B] [Algebra.Transcendental R A] [Algebra.Transcendental R B] :
¬IsField (A ⊗[R] B) := fun H ↦ by
letI := H.toField
obtain ⟨a, hta⟩ := ‹Algebra.Transcendental R A›
obtain ⟨b, htb⟩ := ‹Algebra.Transcendental R B›
have ha : Function.Injective (algebraMap R A) := Algebra.injective_of_transcendental
have hb : Function.Injective (algebraMap R B) := Algebra.injective_of_transcendental
let fa : A →ₐ[R] A ⊗[R] B := Algebra.TensorProduct.includeLeft
let fb : B →ₐ[R] A ⊗[R] B := Algebra.TensorProduct.includeRight
have hfa : Function.Injective fa := Algebra.TensorProduct.includeLeft_injective hb
have hfb : Function.Injective fb := Algebra.TensorProduct.includeRight_injective ha
haveI := hfa.isDomain fa.toRingHom
haveI := hfb.isDomain fb.toRingHom
haveI := ha.isDomain _
haveI : Module.Flat R (toSubmodule fa.range) :=
.of_linearEquiv (AlgEquiv.ofInjective fa hfa).symm.toLinearEquiv
have key1 : Module.rank R ↥(fa.range ⊓ fb.range) ≤ 1 :=
(include_range R A B).rank_inf_le_one_of_flat_left
let ga : R[X] →ₐ[R] A := aeval a
let gb : R[X] →ₐ[R] B := aeval b
let gab := fa.comp ga
replace hta : Function.Injective ga := transcendental_iff_injective.1 hta
replace htb : Function.Injective gb := transcendental_iff_injective.1 htb
have htab : Function.Injective gab := hfa.comp hta
algebraize_only [ga.toRingHom, gb.toRingHom]
let f := Algebra.TensorProduct.mapOfCompatibleSMul R[X] R A B
haveI := Algebra.TensorProduct.nontrivial_of_algebraMap_injective_of_isDomain R[X] A B hta htb
have hf : Function.Injective f := RingHom.injective _
have key2 : gab.range ≤ fa.range ⊓ fb.range
|
R : Type u
inst✝⁸ : CommRing R
A : Type v
inst✝⁷ : CommRing A
B : Type w
inst✝⁶ : CommRing B
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R B
inst✝³ : Module.Flat R A
inst✝² : Module.Flat R B
inst✝¹ : Algebra.Transcendental R A
inst✝ : Algebra.Transcendental R B
H : IsField (A ⊗[R] B)
⊢ False
|
letI := H.toField
|
R : Type u
inst✝⁸ : CommRing R
A : Type v
inst✝⁷ : CommRing A
B : Type w
inst✝⁶ : CommRing B
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R B
inst✝³ : Module.Flat R A
inst✝² : Module.Flat R B
inst✝¹ : Algebra.Transcendental R A
inst✝ : Algebra.Transcendental R B
H : IsField (A ⊗[R] B)
this : Field (A ⊗[R] B) := H.toField
⊢ False
|
ae40762afcd6e13c
|
summable_indicator_mod_iff_summable
|
Mathlib/Analysis/SumOverResidueClass.lean
|
/-- A sequence `f` with values in an additive topological group `R` is summable on the
residue class of `k` mod `m` if and only if `f (m*n + k)` is summable. -/
lemma summable_indicator_mod_iff_summable {R : Type*} [AddCommGroup R] [TopologicalSpace R]
[IsTopologicalAddGroup R] (m : ℕ) [hm : NeZero m] (k : ℕ) (f : ℕ → R) :
Summable ({n : ℕ | (n : ZMod m) = k}.indicator f) ↔ Summable fun n ↦ f (m * n + k)
|
R : Type u_1
inst✝² : AddCommGroup R
inst✝¹ : TopologicalSpace R
inst✝ : IsTopologicalAddGroup R
m : ℕ
hm : NeZero m
k : ℕ
f : ℕ → R
g : ℕ → ℕ := fun n => m * n + k
⊢ Summable ({n | ↑n = ↑k ∧ k ≤ n}.indicator f) ↔ Summable fun n => f (m * n + k)
|
have hg : Function.Injective g := fun m n hmn ↦ by simpa [g, hm.ne] using hmn
|
R : Type u_1
inst✝² : AddCommGroup R
inst✝¹ : TopologicalSpace R
inst✝ : IsTopologicalAddGroup R
m : ℕ
hm : NeZero m
k : ℕ
f : ℕ → R
g : ℕ → ℕ := fun n => m * n + k
hg : Function.Injective g
⊢ Summable ({n | ↑n = ↑k ∧ k ≤ n}.indicator f) ↔ Summable fun n => f (m * n + k)
|
ea5dd927c9817359
|
PrimeSpectrum.denseRange_comap_iff_minimalPrimes
|
Mathlib/RingTheory/Spectrum/Prime/Topology.lean
|
@[stacks 00FL]
lemma denseRange_comap_iff_minimalPrimes :
DenseRange (comap f) ↔ ∀ I (h : I ∈ minimalPrimes R), ⟨I, h.1.1⟩ ∈ Set.range (comap f)
|
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
H : RingHom.ker f ≤ nilradical R
I : Ideal R
hI : Minimal (fun q => q.IsPrime ∧ ⊥ ≤ q) I
⊢ Minimal (fun q => q.IsPrime ∧ RingHom.ker f ≤ q) I
|
convert hI using 2 with p
|
case h.e'_3.h.a
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
H : RingHom.ker f ≤ nilradical R
I : Ideal R
hI : Minimal (fun q => q.IsPrime ∧ ⊥ ≤ q) I
p : Ideal R
⊢ p.IsPrime ∧ RingHom.ker f ≤ p ↔ p.IsPrime ∧ ⊥ ≤ p
|
ee79b196a5fb714f
|
Ideal.subset_union_prime'
|
Mathlib/RingTheory/Ideal/Operations.lean
|
theorem subset_union_prime' {R : Type u} [CommRing R] {s : Finset ι} {f : ι → Ideal R} {a b : ι}
(hp : ∀ i ∈ s, IsPrime (f i)) {I : Ideal R} :
((I : Set R) ⊆ f a ∪ f b ∪ ⋃ i ∈ (↑s : Set ι), f i) ↔ I ≤ f a ∨ I ≤ f b ∨ ∃ i ∈ s, I ≤ f i
|
ι : Type u_1
R : Type u
inst✝ : CommRing R
f : ι → Ideal R
I : Ideal R
n : ℕ
ih :
∀ {s : Finset ι} {a b : ι},
(∀ i ∈ s, (f i).IsPrime) →
s.card = n → ↑I ⊆ ↑(f a) ∪ ↑(f b) ∪ ⋃ i ∈ ↑s, ↑(f i) → I ≤ f a ∨ I ≤ f b ∨ ∃ i ∈ s, I ≤ f i
a b i j : ι
hfji : f j ≤ f i
u : Finset ι
hju : j ∉ u
hit : i ∉ insert j u
hn : (insert j u).card = n
h : ↑I ⊆ ↑(f a) ∪ ↑(f b) ∪ ⋃ i_1 ∈ ↑(insert i (insert j u)), ↑(f i_1)
hp : (f i).IsPrime ∧ (f j).IsPrime ∧ ∀ x ∈ u, (f x).IsPrime
hjt : j ∈ insert j u
⊢ (f i).IsPrime ∧ ∀ x ∈ u, (f x).IsPrime
|
exact ⟨hp.1, hp.2.2⟩
|
no goals
|
fa41770a7d2d9fd9
|
ProbabilityTheory.variance_le_sub_mul_sub
|
Mathlib/Probability/Variance.lean
|
/-- **The Bhatia-Davis inequality on variance**
The variance of a random variable `X` satisfying `a ≤ X ≤ b` almost everywhere is at most
`(b - 𝔼 X) * (𝔼 X - a)`. -/
lemma variance_le_sub_mul_sub [IsProbabilityMeasure μ] {a b : ℝ} {X : Ω → ℝ}
(h : ∀ᵐ ω ∂μ, X ω ∈ Set.Icc a b) (hX : AEMeasurable X μ) :
variance X μ ≤ (b - μ[X]) * (μ[X] - a)
|
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
a b : ℝ
X : Ω → ℝ
h : ∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b
hX : AEMeasurable X μ
ha : ∀ᵐ (ω : Ω) ∂μ, a ≤ X ω
hb : ∀ᵐ (ω : Ω) ∂μ, X ω ≤ b
hX_int₂ : Integrable (fun ω => -X ω ^ 2) μ
hX_int₁ : Integrable (fun ω => (a + b) * X ω) μ
h0 : 0 ≤ -∫ (x : Ω), (X ^ 2) x ∂μ + (a + b) * ∫ (x : Ω), X x ∂μ - a * b
⊢ ∫ (x : Ω), (X ^ 2) x ∂μ - (∫ (x : Ω), X x ∂μ) ^ 2 ≤ (a + b) * ∫ (x : Ω), X x ∂μ - a * b - (∫ (x : Ω), X x ∂μ) ^ 2
|
linarith
|
no goals
|
d31be09bb6b21fe3
|
CategoryTheory.NonPreadditiveAbelian.σ_comp
|
Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
|
theorem σ_comp {X Y : C} (f : X ⟶ Y) : σ ≫ f = Limits.prod.map f f ≫ σ
|
case mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ ⋯).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ ⋯) ≫ g = prod.map f f ≫ σ
⊢ σ ≫ f = prod.map f f ≫ σ
|
suffices hfg : f = g by rw [← hg, Cofork.π_ofπ, hfg]
|
case mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
f : X ⟶ Y
g : (CokernelCofork.ofπ σ ⋯).pt ⟶ Y
hg : Cofork.π (CokernelCofork.ofπ σ ⋯) ≫ g = prod.map f f ≫ σ
⊢ f = g
|
b7d15c6a05369a0f
|
CoxeterSystem.getD_leftInvSeq_mul_wordProd
|
Mathlib/GroupTheory/Coxeter/Inversion.lean
|
theorem getD_leftInvSeq_mul_wordProd (ω : List B) (j : ℕ) :
((lis ω).getD j 1) * π ω = π (ω.eraseIdx j)
|
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.wordProd (take j ω) * (Option.map cs.simple ω[j]?).getD 1 * (cs.wordProd (take j ω))⁻¹ *
cs.wordProd (take (j + 1) ω ++ drop (j + 1) ω) =
cs.wordProd (take j ω ++ drop (j + 1) ω)
|
rw [take_succ]
|
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.wordProd (take j ω) * (Option.map cs.simple ω[j]?).getD 1 * (cs.wordProd (take j ω))⁻¹ *
cs.wordProd (take j ω ++ ω[j]?.toList ++ drop (j + 1) ω) =
cs.wordProd (take j ω ++ drop (j + 1) ω)
|
5b8cc6ccfadd733b
|
HomologicalComplex.mapBifunctor₂₃.d₁_eq
|
Mathlib/Algebra/Homology/BifunctorAssociator.lean
|
lemma d₁_eq {i₁ i₁' : ι₁} (h₁ : c₁.Rel i₁ i₁') (i₂ : ι₂) (i₃ : ι₃) (j : ι₄) :
d₁ F G₂₃ K₁ K₂ K₃ c₁₂ c₂₃ c₄ i₁ i₂ i₃ j =
(ComplexShape.ε₁ c₁ c₂₃ c₄ (i₁, ComplexShape.π c₂ c₃ c₂₃ (i₂, i₃))) •
((F.map (K₁.d i₁ i₁'))).app ((G₂₃.obj (K₂.X i₂)).obj (K₃.X i₃)) ≫
ιOrZero F G₂₃ K₁ K₂ K₃ c₁₂ c₂₃ c₄ _ i₂ i₃ j
|
C₁ : Type u_1
C₂ : Type u_2
C₂₃ : Type u_4
C₃ : Type u_5
C₄ : Type u_6
inst✝²² : Category.{u_15, u_1} C₁
inst✝²¹ : Category.{u_17, u_2} C₂
inst✝²⁰ : Category.{u_16, u_5} C₃
inst✝¹⁹ : Category.{u_13, u_6} C₄
inst✝¹⁸ : Category.{u_14, u_4} C₂₃
inst✝¹⁷ : HasZeroMorphisms C₁
inst✝¹⁶ : HasZeroMorphisms C₂
inst✝¹⁵ : HasZeroMorphisms C₃
inst✝¹⁴ : Preadditive C₂₃
inst✝¹³ : Preadditive C₄
F : C₁ ⥤ C₂₃ ⥤ C₄
G₂₃ : C₂ ⥤ C₃ ⥤ C₂₃
inst✝¹² : G₂₃.PreservesZeroMorphisms
inst✝¹¹ : ∀ (X₂ : C₂), (G₂₃.obj X₂).PreservesZeroMorphisms
inst✝¹⁰ : F.PreservesZeroMorphisms
inst✝⁹ : ∀ (X₁ : C₁), (F.obj X₁).Additive
ι₁ : Type u_7
ι₂ : Type u_8
ι₃ : Type u_9
ι₁₂ : Type u_10
ι₂₃ : Type u_11
ι₄ : Type u_12
inst✝⁸ : DecidableEq ι₄
c₁ : ComplexShape ι₁
c₂ : ComplexShape ι₂
c₃ : ComplexShape ι₃
K₁ : HomologicalComplex C₁ c₁
K₂ : HomologicalComplex C₂ c₂
K₃ : HomologicalComplex C₃ c₃
c₁₂ : ComplexShape ι₁₂
c₂₃ : ComplexShape ι₂₃
c₄ : ComplexShape ι₄
inst✝⁷ : TotalComplexShape c₁ c₂ c₁₂
inst✝⁶ : TotalComplexShape c₁₂ c₃ c₄
inst✝⁵ : TotalComplexShape c₂ c₃ c₂₃
inst✝⁴ : TotalComplexShape c₁ c₂₃ c₄
inst✝³ : K₂.HasMapBifunctor K₃ G₂₃ c₂₃
inst✝² : c₁.Associative c₂ c₃ c₁₂ c₂₃ c₄
inst✝¹ : DecidableEq ι₂₃
inst✝ : K₁.HasMapBifunctor (K₂.mapBifunctor K₃ G₂₃ c₂₃) F c₄
i₁ : ι₁
i₂ : ι₂
i₃ : ι₃
j : ι₄
h₁ : c₁.Rel i₁ (c₁.next i₁)
⊢ d₁ F G₂₃ K₁ K₂ K₃ c₁₂ c₂₃ c₄ i₁ i₂ i₃ j =
c₁.ε₁ c₂₃ c₄ (i₁, c₂.π c₃ c₂₃ (i₂, i₃)) •
(F.map (K₁.d i₁ (c₁.next i₁))).app ((G₂₃.obj (K₂.X i₂)).obj (K₃.X i₃)) ≫
ιOrZero F G₂₃ K₁ K₂ K₃ c₁₂ c₂₃ c₄ (c₁.next i₁) i₂ i₃ j
|
rfl
|
no goals
|
717697c3dc2065d9
|
Subgroup.exists_pow_mem_of_index_ne_zero
|
Mathlib/GroupTheory/Index.lean
|
@[to_additive]
lemma exists_pow_mem_of_index_ne_zero (h : H.index ≠ 0) (a : G) :
∃ n, 0 < n ∧ n ≤ H.index ∧ a ^ n ∈ H
|
G : Type u_1
inst✝ : Group G
H : Subgroup G
h : H.index ≠ 0
a : G
hc : ∀ (x x_1 : ℕ), ¬(x ≠ x_1 ∧ x ≤ H.index ∧ x_1 ≤ H.index ∧ ↑(a ^ x_1) = ↑(a ^ x))
f : ↑(Set.Icc 0 H.index) → G ⧸ H := fun n => ↑(a ^ ↑n)
hf : Function.Injective f
this : Finite (G ⧸ H)
⊢ False
|
have hcard := Finite.card_le_of_injective f hf
|
G : Type u_1
inst✝ : Group G
H : Subgroup G
h : H.index ≠ 0
a : G
hc : ∀ (x x_1 : ℕ), ¬(x ≠ x_1 ∧ x ≤ H.index ∧ x_1 ≤ H.index ∧ ↑(a ^ x_1) = ↑(a ^ x))
f : ↑(Set.Icc 0 H.index) → G ⧸ H := fun n => ↑(a ^ ↑n)
hf : Function.Injective f
this : Finite (G ⧸ H)
hcard : Nat.card ↑(Set.Icc 0 H.index) ≤ Nat.card (G ⧸ H)
⊢ False
|
e678927c1f4a5913
|
SzemerediRegularity.sum_density_div_card_le_density_add_eps
|
Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean
|
theorem sum_density_div_card_le_density_add_eps [Nonempty α]
(hPα : #P.parts * 16 ^ #P.parts ≤ card α) (hPε : ↑100 ≤ ↑4 ^ #P.parts * ε ^ 5)
(hε₁ : ε ≤ 1) {hU : U ∈ P.parts} {hV : V ∈ P.parts} {A B : Finset (Finset α)}
(hA : A ⊆ (chunk hP G ε hU).parts) (hB : B ⊆ (chunk hP G ε hV).parts) :
(∑ ab ∈ A.product B, G.edgeDensity ab.1 ab.2 : ℝ) / (#A * #B) ≤
G.edgeDensity (A.biUnion id) (B.biUnion id) + ε ^ 5 / 49
|
α : Type u_1
inst✝³ : Fintype α
inst✝² : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
U V : Finset α
inst✝ : Nonempty α
hPα : #P.parts * 16 ^ #P.parts ≤ Fintype.card α
hPε : 100 ≤ 4 ^ #P.parts * ε ^ 5
hε₁ : ε ≤ 1
hU : U ∈ P.parts
hV : V ∈ P.parts
A B : Finset (Finset α)
hA : A ⊆ (chunk hP G ε hU).parts
hB : B ⊆ (chunk hP G ε hV).parts
⊢ ↑(G.edgeDensity (A.biUnion id) (B.biUnion id)) ≤ 1
|
exact mod_cast G.edgeDensity_le_one _ _
|
no goals
|
15003bb13a21ffca
|
Nat.testBit_bit_succ
|
Mathlib/Data/Nat/Bits.lean
|
lemma testBit_bit_succ (m b n) : testBit (bit b n) (succ m) = testBit n m
|
m : ℕ
b : Bool
n : ℕ
⊢ (bit b n).testBit m.succ = n.testBit m
|
have : bodd (((bit b n) >>> 1) >>> m) = bodd (n >>> m) := by
simp only [shiftRight_eq_div_pow]
simp [← div2_val, div2_bit]
|
m : ℕ
b : Bool
n : ℕ
this : (bit b n >>> 1 >>> m).bodd = (n >>> m).bodd
⊢ (bit b n).testBit m.succ = n.testBit m
|
de09e232ea3ace89
|
FractionalIdeal.div_spanSingleton
|
Mathlib/RingTheory/FractionalIdeal/Operations.lean
|
theorem div_spanSingleton (J : FractionalIdeal R₁⁰ K) (d : K) :
J / spanSingleton R₁⁰ d = spanSingleton R₁⁰ d⁻¹ * J
|
case neg.a
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
J : FractionalIdeal R₁⁰ K
d : K
hd : ¬d = 0
h_spand : spanSingleton R₁⁰ d ≠ 0
⊢ J / spanSingleton R₁⁰ d ≤ 1 / spanSingleton R₁⁰ d * J
|
intro x hx
|
case neg.a
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
J : FractionalIdeal R₁⁰ K
d : K
hd : ¬d = 0
h_spand : spanSingleton R₁⁰ d ≠ 0
x : K
hx : x ∈ (fun a => ↑a) (J / spanSingleton R₁⁰ d)
⊢ x ∈ (fun a => ↑a) (1 / spanSingleton R₁⁰ d * J)
|
3a4f3cf63940a3cf
|
FormalMultilinearSeries.radius_right_inv_pos_of_radius_pos_aux1
|
Mathlib/Analysis/Analytic/Inverse.lean
|
theorem radius_right_inv_pos_of_radius_pos_aux1 (n : ℕ) (p : ℕ → ℝ) (hp : ∀ k, 0 ≤ p k) {r a : ℝ}
(hr : 0 ≤ r) (ha : 0 ≤ a) :
∑ k ∈ Ico 2 (n + 1),
a ^ k *
∑ c ∈ ({c | 1 < Composition.length c}.toFinset : Finset (Composition k)),
r ^ c.length * ∏ j, p (c.blocksFun j) ≤
∑ j ∈ Ico 2 (n + 1), r ^ j * (∑ k ∈ Ico 1 n, a ^ k * p k) ^ j :=
calc
∑ k ∈ Ico 2 (n + 1),
a ^ k *
∑ c ∈ ({c | 1 < Composition.length c}.toFinset : Finset (Composition k)),
r ^ c.length * ∏ j, p (c.blocksFun j) =
∑ k ∈ Ico 2 (n + 1),
∑ c ∈ ({c | 1 < Composition.length c}.toFinset : Finset (Composition k)),
∏ j, r * (a ^ c.blocksFun j * p (c.blocksFun j))
|
case a
n : ℕ
p : ℕ → ℝ
hp : ∀ (k : ℕ), 0 ≤ p k
r a : ℝ
hr : 0 ≤ r
ha : 0 ≤ a
j : ℕ
a✝ : j ∈ Ico 2 (n + 1)
⊢ ∑ s ∈ Fintype.piFinset fun x => Ico 1 n, ∏ j : Fin j, r * (a ^ s j * p (s j)) =
r ^ j * (∑ k ∈ Ico 1 n, a ^ k * p k) ^ j
|
simp only [← @MultilinearMap.mkPiAlgebra_apply ℝ (Fin j) _ ℝ]
|
case a
n : ℕ
p : ℕ → ℝ
hp : ∀ (k : ℕ), 0 ≤ p k
r a : ℝ
hr : 0 ≤ r
ha : 0 ≤ a
j : ℕ
a✝ : j ∈ Ico 2 (n + 1)
⊢ (∑ x ∈ Fintype.piFinset fun x => Ico 1 n, (MultilinearMap.mkPiAlgebra ℝ (Fin j) ℝ) fun j => r * (a ^ x j * p (x j))) =
r ^ j * (∑ k ∈ Ico 1 n, a ^ k * p k) ^ j
|
5c2dd9dd9e093d01
|
Polynomial.exists_primitive_lcm_of_isPrimitive
|
Mathlib/RingTheory/Polynomial/Content.lean
|
theorem exists_primitive_lcm_of_isPrimitive {p q : R[X]} (hp : p.IsPrimitive) (hq : q.IsPrimitive) :
∃ r : R[X], r.IsPrimitive ∧ ∀ s : R[X], p ∣ s ∧ q ∣ s ↔ r ∣ s
|
case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hp : p.IsPrimitive
hq : q.IsPrimitive
h : ∃ n r, r.natDegree = n ∧ r.IsPrimitive ∧ p ∣ r ∧ q ∣ r
r : R[X]
rdeg : r.natDegree = Nat.find h
rprim : IsUnit (r.coeff 0)
pr : p ∣ r
qr : q ∣ r
con : ∃ n s, s.natDegree = n ∧ (p ∣ s ∧ q ∣ s) ∧ ¬r ∣ s
s : R[X]
sdeg : s.natDegree = Nat.find con
rs : ¬r ∣ s
ps : p ∣ s
qs : q ∣ s
s0 : s ≠ 0
hs : r.natDegree ≤ s.natDegree
sC : s.natDegree ≤ 0
⊢ False
|
rw [eq_C_of_natDegree_le_zero (le_trans hs sC), ← dvd_content_iff_C_dvd] at rs
|
case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hp : p.IsPrimitive
hq : q.IsPrimitive
h : ∃ n r, r.natDegree = n ∧ r.IsPrimitive ∧ p ∣ r ∧ q ∣ r
r : R[X]
rdeg : r.natDegree = Nat.find h
rprim : IsUnit (r.coeff 0)
pr : p ∣ r
qr : q ∣ r
con : ∃ n s, s.natDegree = n ∧ (p ∣ s ∧ q ∣ s) ∧ ¬r ∣ s
s : R[X]
sdeg : s.natDegree = Nat.find con
rs : ¬r.coeff 0 ∣ s.content
ps : p ∣ s
qs : q ∣ s
s0 : s ≠ 0
hs : r.natDegree ≤ s.natDegree
sC : s.natDegree ≤ 0
⊢ False
|
806b283d42e7cf3d
|
BoxIntegral.Integrable.tendsto_integralSum_toFilter_prod_self_inf_iUnion_eq_uniformity
|
Mathlib/Analysis/BoxIntegral/Basic.lean
|
theorem tendsto_integralSum_toFilter_prod_self_inf_iUnion_eq_uniformity (h : Integrable I l f vol) :
Tendsto (fun π : TaggedPrepartition I × TaggedPrepartition I =>
(integralSum f vol π.1, integralSum f vol π.2))
((l.toFilter I ×ˢ l.toFilter I) ⊓ 𝓟 {π | π.1.iUnion = π.2.iUnion}) (𝓤 F)
|
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I : Box ι
inst✝ : Fintype ι
l : IntegrationParams
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
h : Integrable I l f vol
ε : ℝ
ε0 : 0 < ε / 2
⊢ ∃ ia,
(∀ (c : ℝ≥0), l.RCond (ia c)) ∧
∀
x ∈
{π | ∃ c, l.MemBaseSet I c (ia c) π} ×ˢ {π | ∃ c, l.MemBaseSet I c (ia c) π} ∩ {π | π.1.iUnion = π.2.iUnion},
(integralSum f vol x.1, integralSum f vol x.2) ∈ {p | dist p.1 p.2 ≤ ε}
|
use h.convergenceR (ε / 2), h.convergenceR_cond (ε / 2)
|
case right
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I : Box ι
inst✝ : Fintype ι
l : IntegrationParams
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
h : Integrable I l f vol
ε : ℝ
ε0 : 0 < ε / 2
⊢ ∀
x ∈
{π | ∃ c, l.MemBaseSet I c (h.convergenceR (ε / 2) c) π} ×ˢ
{π | ∃ c, l.MemBaseSet I c (h.convergenceR (ε / 2) c) π} ∩
{π | π.1.iUnion = π.2.iUnion},
(integralSum f vol x.1, integralSum f vol x.2) ∈ {p | dist p.1 p.2 ≤ ε}
|
08a8f06d71e014c5
|
Asymptotics.isBigOWith_iff_exists_eq_mul
|
Mathlib/Analysis/Asymptotics/Lemmas.lean
|
theorem isBigOWith_iff_exists_eq_mul (hc : 0 ≤ c) :
IsBigOWith c l u v ↔ ∃ φ : α → 𝕜, (∀ᶠ x in l, ‖φ x‖ ≤ c) ∧ u =ᶠ[l] φ * v
|
case mpr
α : Type u_1
𝕜 : Type u_15
inst✝ : NormedDivisionRing 𝕜
c : ℝ
l : Filter α
u v : α → 𝕜
hc : 0 ≤ c
⊢ (∃ φ, (∀ᶠ (x : α) in l, ‖φ x‖ ≤ c) ∧ u =ᶠ[l] φ * v) → IsBigOWith c l u v
|
rintro ⟨φ, hφ, h⟩
|
case mpr.intro.intro
α : Type u_1
𝕜 : Type u_15
inst✝ : NormedDivisionRing 𝕜
c : ℝ
l : Filter α
u v : α → 𝕜
hc : 0 ≤ c
φ : α → 𝕜
hφ : ∀ᶠ (x : α) in l, ‖φ x‖ ≤ c
h : u =ᶠ[l] φ * v
⊢ IsBigOWith c l u v
|
c2c8aee6ef1774de
|
Polynomial.Gal.mul_splits_in_splittingField_of_mul
|
Mathlib/FieldTheory/PolynomialGaloisGroup.lean
|
theorem mul_splits_in_splittingField_of_mul {p₁ q₁ p₂ q₂ : F[X]} (hq₁ : q₁ ≠ 0) (hq₂ : q₂ ≠ 0)
(h₁ : p₁.Splits (algebraMap F q₁.SplittingField))
(h₂ : p₂.Splits (algebraMap F q₂.SplittingField)) :
(p₁ * p₂).Splits (algebraMap F (q₁ * q₂).SplittingField)
|
case hf
F : Type u_1
inst✝ : Field F
p₁ q₁ p₂ q₂ : F[X]
hq₁ : q₁ ≠ 0
hq₂ : q₂ ≠ 0
h₁ : Splits (algebraMap F q₁.SplittingField) p₁
h₂ : Splits (algebraMap F q₂.SplittingField) p₂
⊢ Splits ((↑(SplittingField.lift q₁ ⋯)).comp (algebraMap F q₁.SplittingField)) p₁
|
exact splits_comp_of_splits _ _ h₁
|
no goals
|
12f0bbd6ecef4d4b
|
LinearMap.commute_pow_left_of_commute
|
Mathlib/Algebra/Module/LinearMap/End.lean
|
theorem commute_pow_left_of_commute
[Semiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {σ₁₂ : R →+* R₂}
{f : M →ₛₗ[σ₁₂] M₂} {g : Module.End R M} {g₂ : Module.End R₂ M₂}
(h : g₂.comp f = f.comp g) (k : ℕ) : (g₂ ^ k).comp f = f.comp (g ^ k)
|
case zero
R : Type u_1
R₂ : Type u_2
M : Type u_4
M₂ : Type u_6
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Semiring R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
σ₁₂ : R →+* R₂
f : M →ₛₗ[σ₁₂] M₂
g : Module.End R M
g₂ : Module.End R₂ M₂
h : comp g₂ f = f.comp g
⊢ comp (g₂ ^ 0) f = f.comp (g ^ 0)
|
simp only [pow_zero, one_eq_id, id_comp, comp_id]
|
no goals
|
b5769a82a32d21d9
|
AnalyticAt.apply_eq_zero_of_order_toNat_ne_zero
|
Mathlib/Analysis/Analytic/Order.lean
|
/-- An analytic function vanishes at a point if its order is nonzero when converted to ℕ. -/
lemma apply_eq_zero_of_order_toNat_ne_zero (hf : AnalyticAt 𝕜 f z₀) :
hf.order.toNat ≠ 0 → f z₀ = 0
|
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
⊢ f z₀ = 0 → ¬hf.order = ⊤ → f z₀ = 0
|
tauto
|
no goals
|
9dcb2d5157a801f6
|
Finset.exists_ne_one_of_prod_ne_one
|
Mathlib/Algebra/BigOperators/Group/Finset/Basic.lean
|
theorem exists_ne_one_of_prod_ne_one (h : ∏ x ∈ s, f x ≠ 1) : ∃ a ∈ s, f a ≠ 1
|
α : Type u_3
β : Type u_4
s : Finset α
f : α → β
inst✝ : CommMonoid β
h : ∏ x ∈ s, f x ≠ 1
⊢ ∃ a ∈ s, f a ≠ 1
|
rw [← prod_filter_ne_one] at h
|
α : Type u_3
β : Type u_4
s : Finset α
f : α → β
inst✝ : CommMonoid β
h : ∏ x ∈ filter (fun x => f x ≠ 1) s, f x ≠ 1
⊢ ∃ a ∈ s, f a ≠ 1
|
305c9d27d8422aed
|
NonUnitalNonAssocRing.ext
|
Mathlib/Algebra/Ring/Ext.lean
|
theorem ext ⦃inst₁ inst₂ : NonUnitalNonAssocRing R⦄
(h_add : local_hAdd[R, inst₁] = local_hAdd[R, inst₂])
(h_mul : local_hMul[R, inst₁] = local_hMul[R, inst₂]) :
inst₁ = inst₂
|
case mk.mk.mk.mk.e_toAddCommGroup
R : Type u
toAddCommGroup✝¹ : AddCommGroup R
mul✝¹ : R → R → R
left_distrib✝¹ : ∀ (a b c : R), a * (b + c) = a * b + a * c
right_distrib✝¹ : ∀ (a b c : R), (a + b) * c = a * c + b * c
zero_mul✝¹ : ∀ (a : R), 0 * a = 0
mul_zero✝¹ : ∀ (a : R), a * 0 = 0
toAddCommGroup✝ : AddCommGroup R
mul✝ : R → R → R
left_distrib✝ : ∀ (a b c : R), a * (b + c) = a * b + a * c
right_distrib✝ : ∀ (a b c : R), (a + b) * c = a * c + b * c
zero_mul✝ : ∀ (a : R), 0 * a = 0
mul_zero✝ : ∀ (a : R), a * 0 = 0
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
⊢ toAddCommGroup✝¹ = toAddCommGroup✝
|
(ext : 1; assumption)
|
no goals
|
c47255c0f38a615d
|
Subgroup.mem_iSup_of_directed
|
Mathlib/Algebra/Group/Subgroup/Lattice.lean
|
theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {K : ι → Subgroup G} (hK : Directed (· ≤ ·) K)
{x : G} : x ∈ (iSup K : Subgroup G) ↔ ∃ i, x ∈ K i
|
case refine_2.intro.intro.intro.intro
G : Type u_1
inst✝ : Group G
ι : Sort u_2
hι : Nonempty ι
K : ι → Subgroup G
hK : Directed (fun x1 x2 => x1 ≤ x2) K
x✝ : G
hx : x✝ ∈ closure (⋃ i, ↑(K i))
x y : G
hx✝ : x ∈ closure (⋃ i, ↑(K i))
hy✝ : y ∈ closure (⋃ i, ↑(K i))
i : ι
hi : x ∈ K i
j : ι
hj : y ∈ K j
k : ι
hki : K i ≤ K k
hkj : K j ≤ K k
⊢ ∃ i, x * y ∈ K i
|
exact ⟨k, mul_mem (hki hi) (hkj hj)⟩
|
no goals
|
313a31a341bc01d2
|
CategoryTheory.Comonad.ComonadicityInternal.comparisonAdjunction_unit_app
|
Mathlib/CategoryTheory/Monad/Comonadicity.lean
|
theorem comparisonAdjunction_unit_app
[∀ A : adj.toComonad.Coalgebra, HasEqualizer (G.map A.a) (adj.unit.app (G.obj A.A))] (B : C) :
(comparisonAdjunction adj).unit.app B = limit.lift _ (unitFork adj B)
|
case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝ : ∀ (A : adj.toComonad.Coalgebra), HasEqualizer (G.map A.a) (adj.unit.app (G.obj A.A))
B : C
⊢ (comparisonAdjunction adj).unit.app B ≫
equalizer.ι (G.map ((comparison adj).obj B).a) (adj.unit.app (G.toPrefunctor.1 ((comparison adj).obj B).A)) =
limit.lift (parallelPair (G.map (F.map (adj.unit.app B))) (adj.unit.app (G.obj (F.obj B)))) (unitFork adj B) ≫
equalizer.ι (G.map ((comparison adj).obj B).a) (adj.unit.app (G.toPrefunctor.1 ((comparison adj).obj B).A))
|
change
equalizer.lift ((adj.homEquiv B _) (𝟙 _)) _ ≫ equalizer.ι _ _ =
equalizer.lift _ _ ≫ equalizer.ι _ _
|
case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝ : ∀ (A : adj.toComonad.Coalgebra), HasEqualizer (G.map A.a) (adj.unit.app (G.obj A.A))
B : C
⊢ equalizer.lift ((adj.homEquiv B (F.obj B)) (𝟙 (F.obj B))) ⋯ ≫
equalizer.ι (G.map ((comparison adj).obj B).a) (adj.unit.app (G.toPrefunctor.1 ((comparison adj).obj B).A)) =
equalizer.lift (adj.unit.app B) ⋯ ≫ equalizer.ι (G.map (F.map (adj.unit.app B))) (adj.unit.app (G.obj (F.obj B)))
|
56285f6d00a0cc25
|
CategoryTheory.Grothendieck.eqToHom_eq
|
Mathlib/CategoryTheory/Grothendieck.lean
|
lemma eqToHom_eq {X Y : Grothendieck F} (hF : X = Y) :
eqToHom hF = { base := eqToHom (by subst hF; rfl), fiber := eqToHom (by subst hF; simp) }
|
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₁
inst✝ : Category.{v₁, u₁} D
F : C ⥤ Cat
X : Grothendieck F
⊢ (F.map (eqToHom ⋯)).obj X.fiber = X.fiber
|
simp
|
no goals
|
59bdc65a2b8ed05d
|
xInTermsOfW_vars_aux
|
Mathlib/RingTheory/WittVector/WittPolynomial.lean
|
theorem xInTermsOfW_vars_aux (n : ℕ) :
n ∈ (xInTermsOfW p ℚ n).vars ∧ (xInTermsOfW p ℚ n).vars ⊆ range (n + 1)
|
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ n ∈ (xInTermsOfW p ℚ n).vars ∧ (xInTermsOfW p ℚ n).vars ⊆ range (n + 1)
|
induction n using Nat.strongRecOn with | ind n ih => ?_
|
case ind
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
ih : ∀ m < n, m ∈ (xInTermsOfW p ℚ m).vars ∧ (xInTermsOfW p ℚ m).vars ⊆ range (m + 1)
⊢ n ∈ (xInTermsOfW p ℚ n).vars ∧ (xInTermsOfW p ℚ n).vars ⊆ range (n + 1)
|
6a6d3bb57935e668
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.mem_of_insertRupUnits
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.lean
|
theorem mem_of_insertRupUnits {n : Nat} (f : DefaultFormula n) (units : CNF.Clause (PosFin n))
(c : DefaultClause n) :
c ∈ toList (insertRupUnits f units).1 → c ∈ units.map Clause.unit ∨ c ∈ toList f
|
case isFalse.inr
n : Nat
f : DefaultFormula n
units : CNF.Clause (PosFin n)
c : DefaultClause n
h :
some c ∈ f.clauses.toList ∨
(∃ a,
(a, false) ∈ (List.foldl insertUnit (f.rupUnits, f.assignments, false) units).fst.toList ∧
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, false) = c ∨
(a, true) ∈ (List.foldl insertUnit (f.rupUnits, f.assignments, false) units).fst.toList ∧
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, true) = c) ∨
∃ a,
(a, false) ∈ f.ratUnits.toList ∧ Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, false) = c ∨
(a, true) ∈ f.ratUnits.toList ∧ Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, true) = c
hb : ∀ (l : Literal (PosFin n)), l ∈ (f.rupUnits, f.assignments, false).fst.toList → l ∈ f.rupUnits.toList ∨ l ∈ units
acc : Array (Literal (PosFin n)) × Array Assignment × Bool
ih : ∀ (l : Literal (PosFin n)), l ∈ acc.fst.toList → l ∈ f.rupUnits.toList ∨ l ∈ units
unit : Literal (PosFin n)
unit_in_units : unit ∈ units
l : Literal (PosFin n)
h✝ : ¬hasAssignment unit.snd acc.2.fst[unit.fst.val]! = true
l_eq_unit : l = (unit.fst, unit.snd)
⊢ (unit.fst, unit.snd) ∈ f.rupUnits.toList ∨ (unit.fst, unit.snd) ∈ units
|
exact Or.inr unit_in_units
|
no goals
|
d2213faecfa0fcb1
|
MeasureTheory.norm_integral_sub_setIntegral_le
|
Mathlib/MeasureTheory/Integral/SetIntegral.lean
|
theorem norm_integral_sub_setIntegral_le [IsFiniteMeasure μ] {C : ℝ}
(hf : ∀ᵐ (x : X) ∂μ, ‖f x‖ ≤ C) {s : Set X} (hs : MeasurableSet s) (hf1 : Integrable f μ) :
‖∫ (x : X), f x ∂μ - ∫ x in s, f x ∂μ‖ ≤ (μ sᶜ).toReal * C
|
X : Type u_1
E : Type u_3
mX : MeasurableSpace X
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f : X → E
μ : Measure X
inst✝ : IsFiniteMeasure μ
C : ℝ
hf : ∀ᵐ (x : X) ∂μ, ‖f x‖ ≤ C
s : Set X
hs : MeasurableSet s
hf1 : Integrable f μ
h0 : ∫ (x : X), f x ∂μ - ∫ (x : X) in s, f x ∂μ = ∫ (x : X) in sᶜ, f x ∂μ
h1 : ∫ (x : X) in sᶜ, ‖f x‖ ∂μ ≤ ∫ (x : X) in sᶜ, C ∂μ
h2 : ∫ (x : X) in sᶜ, C ∂μ = (μ sᶜ).toReal * C
⊢ ‖∫ (x : X) in sᶜ, f x ∂μ‖ ≤ ∫ (x : X) in sᶜ, C ∂μ
|
exact le_trans (norm_integral_le_integral_norm f) h1
|
no goals
|
4ebc5dd21284b746
|
Filter.Tendsto.const_mul_atTop'
|
Mathlib/Order/Filter/AtTopBot/Archimedean.lean
|
theorem Tendsto.const_mul_atTop' (hr : 0 < r) (hf : Tendsto f l atTop) :
Tendsto (fun x => r * f x) l atTop
|
α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
⊢ Tendsto (fun x => r * f x) l atTop
|
refine tendsto_atTop.2 fun b => ?_
|
α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
⊢ ∀ᶠ (a : α) in l, b ≤ r * f a
|
ea722137e0e97e5b
|
ZMod.neg_eq_self_mod_two
|
Mathlib/Data/ZMod/Basic.lean
|
theorem neg_eq_self_mod_two (a : ZMod 2) : -a = a
|
case «1».h
⊢ ↑(-1) = 1
|
rfl
|
no goals
|
98e52898ae8fbe55
|
PadicSeq.norm_mul
|
Mathlib/NumberTheory/Padics/PadicNumbers.lean
|
theorem norm_mul (f g : PadicSeq p) : (f * g).norm = f.norm * g.norm
|
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ (if hf : f * g ≈ 0 then 0 else padicNorm p (↑(f * g) (stationaryPoint hf))) =
(if hf : f ≈ 0 then 0 else padicNorm p (↑f (stationaryPoint hf))) *
if hf : g ≈ 0 then 0 else padicNorm p (↑g (stationaryPoint hf))
|
have hfg := mul_not_equiv_zero hf hg
|
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : ¬f * g ≈ 0
⊢ (if hf : f * g ≈ 0 then 0 else padicNorm p (↑(f * g) (stationaryPoint hf))) =
(if hf : f ≈ 0 then 0 else padicNorm p (↑f (stationaryPoint hf))) *
if hf : g ≈ 0 then 0 else padicNorm p (↑g (stationaryPoint hf))
|
5d67169ade4a773a
|
μ_limsup_le_one
|
Mathlib/Analysis/Normed/Ring/SmoothingSeminorm.lean
|
theorem μ_limsup_le_one {s : ℕ → ℕ} (hs_le : ∀ n : ℕ, s n ≤ n) {x : R} {ψ : ℕ → ℕ}
(hψ_lim : Tendsto ((fun n : ℕ => ↑(s n) / (n : ℝ)) ∘ ψ) atTop (𝓝 0)) :
limsup (fun n : ℕ => μ x ^ ((s (ψ n) : ℝ) * (1 / (ψ n : ℝ)))) atTop ≤ 1
|
R : Type u_1
inst✝ : CommRing R
μ : RingSeminorm R
s : ℕ → ℕ
hs_le : ∀ (n : ℕ), s n ≤ n
x : R
ψ : ℕ → ℕ
hψ_lim : Tendsto ((fun n => ↑(s n) / ↑n) ∘ ψ) atTop (𝓝 0)
c : ℝ
hc_bd : ∀ (x_1 : ℝ) (x_2 : ℕ), (∀ (b : ℕ), x_2 ≤ b → μ x ^ (↑(s (ψ b)) * (1 / ↑(ψ b))) ≤ x_1) → c ≤ x_1
hμx : ¬μ x < 1
hμ_lim : ∀ (U : Set ℝ), 1 ∈ U → IsOpen U → ∃ N, ∀ (n : ℕ), N ≤ n → μ x ^ (↑(s (ψ n)) * (1 / ↑(ψ n))) ∈ U
ε : ℝ
hε : 0 < ε
⊢ 1 ∈ Set.Ioo 0 (1 + ε)
|
simp only [Set.mem_Ioo, zero_lt_one, lt_add_iff_pos_right, hε, and_self]
|
no goals
|
56e579c9d7dd8cf5
|
BitVec.shiftRight_sub_one_eq_shiftConcat
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem shiftRight_sub_one_eq_shiftConcat (n : BitVec w) (hwn : 0 < wn) :
n >>> (wn - 1) = (n >>> wn).shiftConcat (n.getLsbD (wn - 1))
|
case pred.isFalse.e_i
w wn : Nat
n : BitVec w
hwn : 0 < wn
i : Nat
h : i < w
h✝ : ¬i = 0
⊢ wn - 1 + i = wn + (i - 1)
|
omega
|
no goals
|
50919c461ed9204f
|
Nat.finMulAntidiag_one
|
Mathlib/Algebra/Order/Antidiag/Nat.lean
|
theorem finMulAntidiag_one {d : ℕ} :
finMulAntidiag d 1 = {fun _ => 1}
|
case h.mpr
d : ℕ
⊢ ∏ i : Fin d, (fun x => 1) i = 1 ∧ 1 ≠ 0
|
simp only [prod_const_one, implies_true, ne_eq, one_ne_zero, not_false_eq_true, and_self]
|
no goals
|
7d8f41c0f8c962c2
|
Real.borel_eq_generateFrom_Iio_rat
|
Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
|
theorem borel_eq_generateFrom_Iio_rat : borel ℝ = .generateFrom (⋃ a : ℚ, {Iio (a : ℝ)})
|
⊢ ∀ t ∈ range Iio, MeasurableSet t
|
rintro _ ⟨a, rfl⟩
|
case intro
a : ℝ
⊢ MeasurableSet (Iio a)
|
dccc6ba8ada3f3ac
|
ProbabilityTheory.measure_ge_le_exp_mul_mgf
|
Mathlib/Probability/Moments/Basic.lean
|
theorem measure_ge_le_exp_mul_mgf [IsFiniteMeasure μ] (ε : ℝ) (ht : 0 ≤ t)
(h_int : Integrable (fun ω => exp (t * X ω)) μ) :
(μ {ω | ε ≤ X ω}).toReal ≤ exp (-t * ε) * mgf X μ t
|
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
ht_pos : 0 < t
⊢ (rexp (t * ε))⁻¹ * ∫ (x : Ω), (fun ω => rexp (t * X ω)) x ∂μ = rexp (-t * ε) * mgf X μ t
|
rw [neg_mul, exp_neg]
|
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
ht_pos : 0 < t
⊢ (rexp (t * ε))⁻¹ * ∫ (x : Ω), (fun ω => rexp (t * X ω)) x ∂μ = (rexp (t * ε))⁻¹ * mgf X μ t
|
d0b4656bb63daebb
|
contDiff_iff_ftaylorSeries
|
Mathlib/Analysis/Calculus/ContDiff/Defs.lean
|
theorem contDiff_iff_ftaylorSeries {n : ℕ∞} :
ContDiff 𝕜 n f ↔ HasFTaylorSeriesUpTo n f (ftaylorSeries 𝕜 f)
|
case mp
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type uE
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type uF
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
n : ℕ∞
⊢ ContDiff 𝕜 (↑n) f → HasFTaylorSeriesUpTo (↑n) f (ftaylorSeries 𝕜 f)
|
rw [← contDiffOn_univ, ← hasFTaylorSeriesUpToOn_univ_iff, ← ftaylorSeriesWithin_univ]
|
case mp
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type uE
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type uF
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
n : ℕ∞
⊢ ContDiffOn 𝕜 (↑n) f univ → HasFTaylorSeriesUpToOn (↑n) f (ftaylorSeriesWithin 𝕜 f univ) univ
|
0b68cf261d89baaf
|
Localization.mem_range_mapToFractionRing_iff
|
Mathlib/RingTheory/Localization/AsSubring.lean
|
theorem mem_range_mapToFractionRing_iff (B : Type*) [CommRing B] [Algebra A B] [IsLocalization S B]
(hS : S ≤ A⁰) (x : K) :
x ∈ (mapToFractionRing K S B hS).range ↔
∃ (a s : A) (hs : s ∈ S), x = IsLocalization.mk' K a ⟨s, hS hs⟩ :=
⟨by
rintro ⟨x, rfl⟩
obtain ⟨a, s, rfl⟩ := IsLocalization.mk'_surjective S x
use a, s, s.2
apply IsLocalization.lift_mk', by
rintro ⟨a, s, hs, rfl⟩
use IsLocalization.mk' _ a ⟨s, hs⟩
apply IsLocalization.lift_mk'⟩
|
case h
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
a : A
s : ↥S
⊢ (mapToFractionRing K S B hS).toRingHom (IsLocalization.mk' B a s) = IsLocalization.mk' K a ⟨↑s, ⋯⟩
|
apply IsLocalization.lift_mk'
|
no goals
|
68d824c2f8020338
|
ProbabilityTheory.IndepFun.integral_mul_of_integrable
|
Mathlib/Probability/Integration.lean
|
theorem IndepFun.integral_mul_of_integrable (hXY : IndepFun X Y μ) (hX : Integrable X μ)
(hY : Integrable Y μ) : integral μ (X * Y) = integral μ X * integral μ Y
|
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : Integrable X μ
hY : Integrable Y μ
pos : ℝ → ℝ := fun x => x ⊔ 0
neg : ℝ → ℝ := fun x => -x ⊔ 0
posm : Measurable pos
negm : Measurable neg
⊢ integral μ (X * Y) = integral μ X * integral μ Y
|
let Xp := pos ∘ X
|
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : Integrable X μ
hY : Integrable Y μ
pos : ℝ → ℝ := fun x => x ⊔ 0
neg : ℝ → ℝ := fun x => -x ⊔ 0
posm : Measurable pos
negm : Measurable neg
Xp : Ω → ℝ := pos ∘ X
⊢ integral μ (X * Y) = integral μ X * integral μ Y
|
1836e7e522e593a2
|
exteriorPower.ιMulti_span
|
Mathlib/LinearAlgebra/ExteriorPower/Basic.lean
|
/-- The image of `exteriorPower.ιMulti` spans `⋀[R]^n M`. -/
lemma ιMulti_span :
Submodule.span R (Set.range (ιMulti R n)) = (⊤ : Submodule R (⋀[R]^n M))
|
case a
R : Type u
inst✝² : CommRing R
n : ℕ
M : Type u_1
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ Submodule.span R (Set.range fun a => (ExteriorAlgebra.ιMulti R n) a) = ⋀[R]^n M
|
exact ExteriorAlgebra.ιMulti_span_fixedDegree R n
|
no goals
|
ad0fa8e0b2d37c81
|
Array.foldr_induction
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem foldr_induction
{as : Array α} (motive : Nat → β → Prop) {init : β} (h0 : motive as.size init) {f : α → β → β}
(hf : ∀ i : Fin as.size, ∀ b, motive (i.1 + 1) b → motive i.1 (f as[i] b)) :
motive 0 (as.foldr f init)
|
α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive as.size init
f : α → β → β
hf : ∀ (i : Fin as.size) (b : β), motive (↑i + 1) b → motive (↑i) (f as[i] b)
⊢ motive 0 (if 0 < as.size then foldrM.fold f as 0 as.size ⋯ init else init).run
|
split
|
case isTrue
α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive as.size init
f : α → β → β
hf : ∀ (i : Fin as.size) (b : β), motive (↑i + 1) b → motive (↑i) (f as[i] b)
h✝ : 0 < as.size
⊢ motive 0 (foldrM.fold f as 0 as.size ⋯ init).run
case isFalse
α : Type u_1
β : Type u_2
as : Array α
motive : Nat → β → Prop
init : β
h0 : motive as.size init
f : α → β → β
hf : ∀ (i : Fin as.size) (b : β), motive (↑i + 1) b → motive (↑i) (f as[i] b)
h✝ : ¬0 < as.size
⊢ motive 0 (Id.run init)
|
36c52e13ffc37b61
|
Subalgebra.inv_mem_of_root_of_coeff_zero_ne_zero
|
Mathlib/RingTheory/Algebraic/Basic.lean
|
theorem Subalgebra.inv_mem_of_root_of_coeff_zero_ne_zero {x : A} {p : K[X]}
(aeval_eq : aeval x p = 0) (coeff_zero_ne : p.coeff 0 ≠ 0) : (x⁻¹ : L) ∈ A
|
K : Type u_1
L : Type u_2
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
A : Subalgebra K L
x : ↥A
p : K[X]
aeval_eq : (aeval x) p = 0
coeff_zero_ne : p.coeff 0 ≠ 0
this : (↑x)⁻¹ = (-p.coeff 0)⁻¹ • ↑((aeval x) p.divX)
⊢ (-p.coeff 0)⁻¹ • ↑((aeval x) p.divX) ∈ A
|
exact A.smul_mem (aeval x _).2 _
|
no goals
|
440f3b608db59a1e
|
Finset.strictMono_iff_forall_lt_cons
|
Mathlib/Data/Finset/Interval.lean
|
/-- A function `f` from `Finset α` is strictly monotone if and only if `f s < f (cons a s ha)` for
all `s` and `a ∉ s`. -/
lemma strictMono_iff_forall_lt_cons : StrictMono f ↔ ∀ s ⦃a⦄ ha, f s < f (cons a s ha)
|
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f : Finset α → β
⊢ StrictMono f ↔ ∀ (s : Finset α) ⦃a : α⦄ (ha : a ∉ s), f s < f (cons a s ha)
|
simp [strictMono_iff_forall_covBy, covBy_iff_exists_cons]
|
no goals
|
e995ec8ad786815e
|
Num.castNum_eq_bitwise
|
Mathlib/Data/Num/Lemmas.lean
|
theorem castNum_eq_bitwise {f : Num → Num → Num} {g : Bool → Bool → Bool}
(p : PosNum → PosNum → Num)
(gff : g false false = false) (f00 : f 0 0 = 0)
(f0n : ∀ n, f 0 (pos n) = cond (g false true) (pos n) 0)
(fn0 : ∀ n, f (pos n) 0 = cond (g true false) (pos n) 0)
(fnn : ∀ m n, f (pos m) (pos n) = p m n) (p11 : p 1 1 = cond (g true true) 1 0)
(p1b : ∀ b n, p 1 (PosNum.bit b n) = bit (g true b) (cond (g false true) (pos n) 0))
(pb1 : ∀ a m, p (PosNum.bit a m) 1 = bit (g a true) (cond (g true false) (pos m) 0))
(pbb : ∀ a b m n, p (PosNum.bit a m) (PosNum.bit b n) = bit (g a b) (p m n)) :
∀ m n : Num, (f m n : ℕ) = Nat.bitwise g m n
|
case pos.pos.bit1.bit1
f : Num → Num → Num
g : Bool → Bool → Bool
p : PosNum → PosNum → Num
gff : g false false = false
f00 : f 0 0 = 0
f0n : ∀ (n : PosNum), f 0 (pos n) = bif g false true then pos n else 0
fn0 : ∀ (n : PosNum), f (pos n) 0 = bif g true false then pos n else 0
fnn : ∀ (m n : PosNum), f (pos m) (pos n) = p m n
p11 : p 1 1 = bif g true true then 1 else 0
p1b : ∀ (b : Bool) (n : PosNum), p 1 (PosNum.bit b n) = bit (g true b) (bif g false true then pos n else 0)
pb1 : ∀ (a : Bool) (m : PosNum), p (PosNum.bit a m) 1 = bit (g a true) (bif g true false then pos m else 0)
pbb : ∀ (a b : Bool) (m n : PosNum), p (PosNum.bit a m) (PosNum.bit b n) = bit (g a b) (p m n)
this : ∀ (b : Bool) (n : PosNum), (bif b then ↑n else 0) = ↑(bif b then pos n else 0)
this' : ∀ (b : Bool) (n : PosNum), ↑(pos (PosNum.bit b n)) = Nat.bit b ↑n
m : PosNum
IH : ∀ (n : PosNum), ↑(p m n) = Nat.bitwise g ↑(pos m) ↑(pos n)
n : PosNum
⊢ ↑(p (PosNum.bit true m) (PosNum.bit true n)) = Nat.bit (g true true) (Nat.bitwise g ↑m ↑n)
case pos.pos.bit1.bit0
f : Num → Num → Num
g : Bool → Bool → Bool
p : PosNum → PosNum → Num
gff : g false false = false
f00 : f 0 0 = 0
f0n : ∀ (n : PosNum), f 0 (pos n) = bif g false true then pos n else 0
fn0 : ∀ (n : PosNum), f (pos n) 0 = bif g true false then pos n else 0
fnn : ∀ (m n : PosNum), f (pos m) (pos n) = p m n
p11 : p 1 1 = bif g true true then 1 else 0
p1b : ∀ (b : Bool) (n : PosNum), p 1 (PosNum.bit b n) = bit (g true b) (bif g false true then pos n else 0)
pb1 : ∀ (a : Bool) (m : PosNum), p (PosNum.bit a m) 1 = bit (g a true) (bif g true false then pos m else 0)
pbb : ∀ (a b : Bool) (m n : PosNum), p (PosNum.bit a m) (PosNum.bit b n) = bit (g a b) (p m n)
this : ∀ (b : Bool) (n : PosNum), (bif b then ↑n else 0) = ↑(bif b then pos n else 0)
this' : ∀ (b : Bool) (n : PosNum), ↑(pos (PosNum.bit b n)) = Nat.bit b ↑n
m : PosNum
IH : ∀ (n : PosNum), ↑(p m n) = Nat.bitwise g ↑(pos m) ↑(pos n)
n : PosNum
⊢ ↑(p (PosNum.bit true m) (PosNum.bit false n)) = Nat.bit (g true false) (Nat.bitwise g ↑m ↑n)
case pos.pos.bit0.bit1
f : Num → Num → Num
g : Bool → Bool → Bool
p : PosNum → PosNum → Num
gff : g false false = false
f00 : f 0 0 = 0
f0n : ∀ (n : PosNum), f 0 (pos n) = bif g false true then pos n else 0
fn0 : ∀ (n : PosNum), f (pos n) 0 = bif g true false then pos n else 0
fnn : ∀ (m n : PosNum), f (pos m) (pos n) = p m n
p11 : p 1 1 = bif g true true then 1 else 0
p1b : ∀ (b : Bool) (n : PosNum), p 1 (PosNum.bit b n) = bit (g true b) (bif g false true then pos n else 0)
pb1 : ∀ (a : Bool) (m : PosNum), p (PosNum.bit a m) 1 = bit (g a true) (bif g true false then pos m else 0)
pbb : ∀ (a b : Bool) (m n : PosNum), p (PosNum.bit a m) (PosNum.bit b n) = bit (g a b) (p m n)
this : ∀ (b : Bool) (n : PosNum), (bif b then ↑n else 0) = ↑(bif b then pos n else 0)
this' : ∀ (b : Bool) (n : PosNum), ↑(pos (PosNum.bit b n)) = Nat.bit b ↑n
m : PosNum
IH : ∀ (n : PosNum), ↑(p m n) = Nat.bitwise g ↑(pos m) ↑(pos n)
n : PosNum
⊢ ↑(p (PosNum.bit false m) (PosNum.bit true n)) = Nat.bit (g false true) (Nat.bitwise g ↑m ↑n)
case pos.pos.bit0.bit0
f : Num → Num → Num
g : Bool → Bool → Bool
p : PosNum → PosNum → Num
gff : g false false = false
f00 : f 0 0 = 0
f0n : ∀ (n : PosNum), f 0 (pos n) = bif g false true then pos n else 0
fn0 : ∀ (n : PosNum), f (pos n) 0 = bif g true false then pos n else 0
fnn : ∀ (m n : PosNum), f (pos m) (pos n) = p m n
p11 : p 1 1 = bif g true true then 1 else 0
p1b : ∀ (b : Bool) (n : PosNum), p 1 (PosNum.bit b n) = bit (g true b) (bif g false true then pos n else 0)
pb1 : ∀ (a : Bool) (m : PosNum), p (PosNum.bit a m) 1 = bit (g a true) (bif g true false then pos m else 0)
pbb : ∀ (a b : Bool) (m n : PosNum), p (PosNum.bit a m) (PosNum.bit b n) = bit (g a b) (p m n)
this : ∀ (b : Bool) (n : PosNum), (bif b then ↑n else 0) = ↑(bif b then pos n else 0)
this' : ∀ (b : Bool) (n : PosNum), ↑(pos (PosNum.bit b n)) = Nat.bit b ↑n
m : PosNum
IH : ∀ (n : PosNum), ↑(p m n) = Nat.bitwise g ↑(pos m) ↑(pos n)
n : PosNum
⊢ ↑(p (PosNum.bit false m) (PosNum.bit false n)) = Nat.bit (g false false) (Nat.bitwise g ↑m ↑n)
|
all_goals
rw [← show ∀ n : PosNum, ↑(p m n) = Nat.bitwise g ↑m ↑n from IH]
rw [← bit_to_nat, pbb]
|
no goals
|
d446b0d6506ab74a
|
preconnectedSpace_iff_connectedComponent
|
Mathlib/Topology/Connected/Basic.lean
|
theorem preconnectedSpace_iff_connectedComponent :
PreconnectedSpace α ↔ ∀ x : α, connectedComponent x = univ
|
case mpr
α : Type u
inst✝ : TopologicalSpace α
h : ∀ (x : α), connectedComponent x = univ
⊢ PreconnectedSpace α
|
rcases isEmpty_or_nonempty α with hα | hα
|
case mpr.inl
α : Type u
inst✝ : TopologicalSpace α
h : ∀ (x : α), connectedComponent x = univ
hα : IsEmpty α
⊢ PreconnectedSpace α
case mpr.inr
α : Type u
inst✝ : TopologicalSpace α
h : ∀ (x : α), connectedComponent x = univ
hα : Nonempty α
⊢ PreconnectedSpace α
|
e6948b2a1277dd55
|
toMul_multiset_sum
|
Mathlib/Algebra/BigOperators/Group/Finset/Defs.lean
|
theorem toMul_multiset_sum (s : Multiset (Additive α)) : s.sum.toMul = (s.map toMul).prod
|
α : Type u_3
inst✝ : CommMonoid α
s : Multiset (Additive α)
⊢ toMul s.sum = (Multiset.map (⇑toMul) s).prod
|
simp [toMul, ofMul]
|
α : Type u_3
inst✝ : CommMonoid α
s : Multiset (Additive α)
⊢ s.sum = s.prod
|
810c6fd03f48374d
|
CategoryTheory.Triangulated.TStructure.le_monotone
|
Mathlib/CategoryTheory/Triangulated/TStructure/Basic.lean
|
lemma le_monotone : Monotone t.le
|
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
t : TStructure C
H : ℕ → Prop := fun a => ∀ (n : ℤ), t.le n ≤ t.le (n + ↑a)
H_zero : H 0
H_one : H 1
H_add : ∀ (a b c : ℕ), a + b = c → H a → H b → H c
⊢ ∀ (a : ℕ), H a
|
intro a
|
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
t : TStructure C
H : ℕ → Prop := fun a => ∀ (n : ℤ), t.le n ≤ t.le (n + ↑a)
H_zero : H 0
H_one : H 1
H_add : ∀ (a b c : ℕ), a + b = c → H a → H b → H c
a : ℕ
⊢ H a
|
37a0503483d0a558
|
MDifferentiableWithinAt.clm_apply
|
Mathlib/Geometry/Manifold/MFDeriv/NormedSpace.lean
|
theorem MDifferentiableWithinAt.clm_apply {g : M → F₁ →L[𝕜] F₂} {f : M → F₁} {s : Set M} {x : M}
(hg : MDifferentiableWithinAt I 𝓘(𝕜, F₁ →L[𝕜] F₂) g s x)
(hf : MDifferentiableWithinAt I 𝓘(𝕜, F₁) f s x) :
MDifferentiableWithinAt I 𝓘(𝕜, F₂) (fun x => g x (f x)) s x :=
DifferentiableWithinAt.comp_mdifferentiableWithinAt (t := univ)
(g := fun x : (F₁ →L[𝕜] F₂) × F₁ => x.1 x.2)
(by apply (Differentiable.differentiableAt _).differentiableWithinAt
exact differentiable_fst.clm_apply differentiable_snd) (hg.prod_mk_space hf)
(by simp_rw [mapsTo_univ])
|
𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
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
F₁ : Type u_14
inst✝³ : NormedAddCommGroup F₁
inst✝² : NormedSpace 𝕜 F₁
F₂ : Type u_15
inst✝¹ : NormedAddCommGroup F₂
inst✝ : NormedSpace 𝕜 F₂
g : M → F₁ →L[𝕜] F₂
f : M → F₁
s : Set M
x : M
hg : MDifferentiableWithinAt I 𝓘(𝕜, F₁ →L[𝕜] F₂) g s x
hf : MDifferentiableWithinAt I 𝓘(𝕜, F₁) f s x
⊢ DifferentiableWithinAt 𝕜 (fun x => x.1 x.2) univ (g x, f x)
|
apply (Differentiable.differentiableAt _).differentiableWithinAt
|
𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
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
F₁ : Type u_14
inst✝³ : NormedAddCommGroup F₁
inst✝² : NormedSpace 𝕜 F₁
F₂ : Type u_15
inst✝¹ : NormedAddCommGroup F₂
inst✝ : NormedSpace 𝕜 F₂
g : M → F₁ →L[𝕜] F₂
f : M → F₁
s : Set M
x : M
hg : MDifferentiableWithinAt I 𝓘(𝕜, F₁ →L[𝕜] F₂) g s x
hf : MDifferentiableWithinAt I 𝓘(𝕜, F₁) f s x
⊢ Differentiable 𝕜 fun x => x.1 x.2
|
a547ab9a62b5927c
|
CoxeterSystem.not_isReduced_alternatingWord
|
Mathlib/GroupTheory/Coxeter/Length.lean
|
theorem not_isReduced_alternatingWord (i i' : B) {m : ℕ} (hM : M i i' ≠ 0) (hm : m > M i i') :
¬cs.IsReduced (alternatingWord i i' m)
|
case refl
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m : ℕ
hM : M.M i i' ≠ 0
⊢ ¬cs.IsReduced (alternatingWord i i' (M.M i i').succ)
|
suffices h : ℓ (π (alternatingWord i i' (M i i' + 1))) < M i i' + 1 by
unfold IsReduced
rw [Nat.succ_eq_add_one, length_alternatingWord]
omega
|
case refl
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m : ℕ
hM : M.M i i' ≠ 0
⊢ cs.length (cs.wordProd (alternatingWord i i' (M.M i i' + 1))) < M.M i i' + 1
|
f64124f674aa1270
|
lipschitzGroup.conjAct_smul_ι_mem_range_ι
|
Mathlib/LinearAlgebra/CliffordAlgebra/SpinGroup.lean
|
theorem conjAct_smul_ι_mem_range_ι {x : (CliffordAlgebra Q)ˣ} (hx : x ∈ lipschitzGroup Q)
[Invertible (2 : R)] (m : M) :
ConjAct.toConjAct x • ι Q m ∈ LinearMap.range (ι Q)
|
R : Type u_1
inst✝³ : CommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
Q : QuadraticForm R M
x : (CliffordAlgebra Q)ˣ
hx : x ∈ lipschitzGroup Q
inst✝ : Invertible 2
m : M
⊢ ConjAct.toConjAct x • (ι Q) m ∈ LinearMap.range (ι Q)
|
unfold lipschitzGroup at hx
|
R : Type u_1
inst✝³ : CommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
Q : QuadraticForm R M
x : (CliffordAlgebra Q)ˣ
hx : x ∈ Subgroup.closure (Units.val ⁻¹' Set.range ⇑(ι Q))
inst✝ : Invertible 2
m : M
⊢ ConjAct.toConjAct x • (ι Q) m ∈ LinearMap.range (ι Q)
|
5df234339fc72163
|
Compactum.cl_cl
|
Mathlib/Topology/Category/Compactum.lean
|
theorem cl_cl {X : Compactum} (A : Set X) : cl (cl A) ⊆ cl A
|
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B ∈ F, X.str ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
⊢ X.str F ∈ Compactum.cl A
|
let C1 := insert AA C0
|
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B ∈ F, X.str ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
⊢ X.str F ∈ Compactum.cl A
|
1c30fb7238f2120d
|
IsSemiprimaryRing.induction
|
Mathlib/RingTheory/HopkinsLevitzki.lean
|
theorem induction
{P : ∀ (M : Type u) [AddCommGroup M] [Module R₀ M] [Module R M], Prop}
(h0 : ∀ (M) [AddCommGroup M] [Module R₀ M] [Module R M] [IsScalarTower R₀ R M]
[IsSemisimpleModule R M], Module.IsTorsionBySet R M (Ring.jacobson R) → P M)
(h1 : ∀ (M) [AddCommGroup M] [Module R₀ M] [Module R M] [IsScalarTower R₀ R M],
let N := Ring.jacobson R • (⊤ : Submodule R M); P N → P (M ⧸ N) → P M) :
P M
|
case succ.zero
R₀ : Type u_1
R : Type u_2
inst✝⁷ : Ring R₀
inst✝⁶ : Ring R
inst✝⁵ : Module R₀ R
inst✝⁴ : IsSemiprimaryRing R
P : (M : Type u) → [inst : AddCommGroup M] → [inst_1 : Module R₀ M] → [inst : Module R M] → Prop
ss : IsSemisimpleRing (R ⧸ Ring.jacobson R)
Jac : Ideal R := Ring.jacobson R
h0 :
∀ (M : Type u) [inst : AddCommGroup M] [inst_1 : Module R₀ M] [inst_2 : Module R M] [inst_3 : IsScalarTower R₀ R M]
[inst_4 : IsSemisimpleModule R M], Module.IsTorsionBySet R M ↑Jac → P M
h1 :
∀ (M : Type u) [inst : AddCommGroup M] [inst_1 : Module R₀ M] [inst_2 : Module R M] [inst_3 : IsScalarTower R₀ R M],
let N := Jac • ⊤;
P ↥N → P (M ⧸ N) → P M
this :
∀ {M : Type u} [inst : AddCommGroup M] [inst_1 : Module R₀ M] [inst_2 : Module R M] [inst_3 : IsScalarTower R₀ R M],
Jac ≤ Module.annihilator R M → P M
M : Type u
inst✝³ : AddCommGroup M
inst✝² : Module R₀ M
inst✝¹ : Module R M
inst✝ : IsScalarTower R₀ R M
ih :
∀ (M : Type u) [inst : AddCommGroup M] [inst_1 : Module R₀ M] [inst_2 : Module R M] [inst_3 : IsScalarTower R₀ R M],
Jac ^ 0 ≤ Module.annihilator R M → P M
hn : Jac ≤ Module.annihilator R M
⊢ P M
|
exact this hn
|
no goals
|
18de1097a1dd67d8
|
PadicSeq.norm_nonarchimedean
|
Mathlib/NumberTheory/Padics/PadicNumbers.lean
|
theorem norm_nonarchimedean (f g : PadicSeq p) : (f + g).norm ≤ max f.norm g.norm
|
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : g ≈ 0
hfg' : f + g ≈ f
⊢ (f + g).norm ≤ f.norm ⊔ g.norm
|
have hcfg : (f + g).norm = f.norm := norm_equiv hfg'
|
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : ¬f ≈ 0
hg : g ≈ 0
hfg' : f + g ≈ f
hcfg : (f + g).norm = f.norm
⊢ (f + g).norm ≤ f.norm ⊔ g.norm
|
4a919ac1cede5d3f
|
Ideal.subset_union_prime'
|
Mathlib/RingTheory/Ideal/Operations.lean
|
theorem subset_union_prime' {R : Type u} [CommRing R] {s : Finset ι} {f : ι → Ideal R} {a b : ι}
(hp : ∀ i ∈ s, IsPrime (f i)) {I : Ideal R} :
((I : Set R) ⊆ f a ∪ f b ∪ ⋃ i ∈ (↑s : Set ι), f i) ↔ I ≤ f a ∨ I ≤ f b ∨ ∃ i ∈ s, I ≤ f i
|
case pos.h.inr.inl
ι : Type u_1
R : Type u
inst✝ : CommRing R
f : ι → Ideal R
I : Ideal R
n : ℕ
a b i : ι
t : Finset ι
hit : i ∉ t
hn : t.card = n
h : ↑I ⊆ ↑(f a) ∪ ↑(f b) ∪ ⋃ i_1 ∈ ↑(insert i t), ↑(f i_1)
hp : (f i).IsPrime ∧ ∀ x ∈ t, (f x).IsPrime
Ht : ¬∃ j ∈ t, f j ≤ f i
Ha : f a ≤ f i
h' : ↑I ⊆ ↑(f i) ∪ ↑(f b) ∪ ⋃ j ∈ ↑t, ↑(f j)
ih : I ≤ f b
⊢ I ≤ f b ∨ ∃ i_1 ∈ insert i t, I ≤ f i_1
|
exact Or.inl ih
|
no goals
|
fa41770a7d2d9fd9
|
Finset.memberSubfamily_union_nonMemberSubfamily
|
Mathlib/Combinatorics/SetFamily/Compression/Down.lean
|
theorem memberSubfamily_union_nonMemberSubfamily (a : α) (𝒜 : Finset (Finset α)) :
𝒜.memberSubfamily a ∪ 𝒜.nonMemberSubfamily a = 𝒜.image fun s => s.erase a
|
case pos
α : Type u_1
inst✝ : DecidableEq α
a : α
𝒜 : Finset (Finset α)
s : Finset α
hs : s ∈ 𝒜
ha : a ∈ s
⊢ insert a (s.erase a) ∈ 𝒜 ∧ a ∉ s.erase a ∨ s.erase a ∈ 𝒜 ∧ a ∉ s.erase a
|
exact Or.inl ⟨by rwa [insert_erase ha], not_mem_erase _ _⟩
|
no goals
|
e84640d1d865ba15
|
finprod_apply_ne_one
|
Mathlib/Algebra/BigOperators/Finprod.lean
|
theorem finprod_apply_ne_one (f : α → M) (a : α) : ∏ᶠ _ : f a ≠ 1, f a = f a
|
α : Type u_1
M : Type u_5
inst✝ : CommMonoid M
f : α → M
a : α
⊢ ∏ᶠ (_ : f a ≠ 1), f a = f a
|
rw [← mem_mulSupport, finprod_eq_mulIndicator_apply, mulIndicator_mulSupport]
|
no goals
|
8158e1dabf1a7043
|
IsArtinianRing.isUnit_submonoid_eq_of_isIntegral
|
Mathlib/RingTheory/Artinian/Algebra.lean
|
theorem isUnit_submonoid_eq_of_isIntegral [Algebra.IsIntegral R A] : IsUnit.submonoid A = A⁰
|
case h
R : Type u_1
A : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsArtinianRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : Algebra.IsIntegral R A
x✝ : A
⊢ x✝ ∈ IsUnit.submonoid A ↔ x✝ ∈ A⁰
|
simpa [IsUnit.mem_submonoid_iff] using isUnit_iff_nonZeroDivisor_of_isIntegral' (R := R)
|
no goals
|
4c3b08554612886b
|
Multiset.inter_le_right
|
Mathlib/Data/Multiset/UnionInter.lean
|
lemma inter_le_right : s ∩ t ≤ t
|
case neg
α : Type u_1
inst✝ : DecidableEq α
a : α
s : Multiset α
IH : ∀ {t : Multiset α}, s ∩ t ≤ t
t : Multiset α
h : a ∉ t
⊢ (a ::ₘ s) ∩ t ≤ t
|
simp [h, IH]
|
no goals
|
e30103a6354a110c
|
Equiv.Perm.cycleOf_mul_of_apply_right_eq_self
|
Mathlib/GroupTheory/Perm/Cycle/Factors.lean
|
theorem cycleOf_mul_of_apply_right_eq_self [DecidableRel f.SameCycle]
[DecidableRel (f * g).SameCycle]
(h : Commute f g) (x : α) (hx : g x = x) : (f * g).cycleOf x = f.cycleOf x
|
case neg
α : Type u_2
f g : Perm α
inst✝¹ : DecidableRel f.SameCycle
inst✝ : DecidableRel (f * g).SameCycle
h : Commute f g
x : α
hx : g x = x
y : α
hxy : f.SameCycle x y
⊢ (f * g).SameCycle x y
|
obtain ⟨z, rfl⟩ := hxy
|
case neg.intro
α : Type u_2
f g : Perm α
inst✝¹ : DecidableRel f.SameCycle
inst✝ : DecidableRel (f * g).SameCycle
h : Commute f g
x : α
hx : g x = x
z : ℤ
⊢ (f * g).SameCycle x ((f ^ z) x)
|
9f223ade6df5a61f
|
Polynomial.coeff_hermite_explicit
|
Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
|
theorem coeff_hermite_explicit :
∀ n k : ℕ, coeff (hermite (2 * n + k)) k = (-1) ^ n * (2 * n - 1)‼ * Nat.choose (2 * n + k) k
| 0, _ => by simp
| n + 1, 0 => by
convert coeff_hermite_succ_zero (2 * n + 1) using 1
-- Porting note: ring_nf did not solve the goal on line 165
rw [coeff_hermite_explicit n 1, (by rw [Nat.left_distrib, mul_one, Nat.add_one_sub_one] :
2 * (n + 1) - 1 = 2 * n + 1), Nat.doubleFactorial_add_one, Nat.choose_zero_right,
Nat.choose_one_right, pow_succ]
push_cast
ring
| n + 1, k + 1 => by
let hermite_explicit : ℕ → ℕ → ℤ := fun n k =>
(-1) ^ n * (2 * n - 1)‼ * Nat.choose (2 * n + k) k
have hermite_explicit_recur :
∀ n k : ℕ,
hermite_explicit (n + 1) (k + 1) =
hermite_explicit (n + 1) k - (k + 2) * hermite_explicit n (k + 2)
|
n k : ℕ
hermite_explicit : ℕ → ℕ → ℤ := fun n k => (-1) ^ n * ↑(2 * n - 1)‼ * ↑((2 * n + k).choose k)
hermite_explicit_recur :
∀ (n k : ℕ), hermite_explicit (n + 1) (k + 1) = hermite_explicit (n + 1) k - (↑k + 2) * hermite_explicit n (k + 2)
⊢ 2 * (n + 1) + k = 2 * n + (k + 2)
|
ring
|
no goals
|
76b4bea6433d05b5
|
Polynomial.EisensteinCriterionAux.isUnit_of_natDegree_eq_zero_of_isPrimitive
|
Mathlib/RingTheory/EisensteinCriterion.lean
|
theorem isUnit_of_natDegree_eq_zero_of_isPrimitive {p q : R[X]}
-- Porting note: stated using `IsPrimitive` which is defeq to old statement.
(hu : IsPrimitive (p * q)) (hpm : p.natDegree = 0) : IsUnit p
|
R : Type u_1
inst✝ : CommRing R
p q : R[X]
hu : (p * q).IsPrimitive
hpm : p.natDegree = 0
⊢ C (p.coeff 0) ∣ p * q
|
rw [← eq_C_of_degree_le_zero (natDegree_eq_zero_iff_degree_le_zero.1 hpm)]
|
R : Type u_1
inst✝ : CommRing R
p q : R[X]
hu : (p * q).IsPrimitive
hpm : p.natDegree = 0
⊢ p ∣ p * q
|
447194fa7b9cf99d
|
Fin.map_valEmbedding_Ici
|
Mathlib/Order/Interval/Finset/Fin.lean
|
theorem map_valEmbedding_Ici : (Ici a).map Fin.valEmbedding = Icc ↑a (n - 1)
|
case h.mpr.succ
x n✝ : ℕ
a : Fin (n✝ + 1)
⊢ ↑a ≤ x ∧ x ≤ n✝ + 1 - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x
|
exact fun hx => ⟨⟨x, Nat.lt_succ_iff.2 hx.2⟩, hx.1, rfl⟩
|
no goals
|
659a5c83d884a7cb
|
Finset.iSup_insert_update
|
Mathlib/Order/CompleteLattice/Finset.lean
|
theorem iSup_insert_update {x : α} {t : Finset α} (f : α → β) {s : β} (hx : x ∉ t) :
⨆ i ∈ insert x t, Function.update f x s i = s ⊔ ⨆ i ∈ t, f i
|
case e_a.e_s.h.e_s.h.h
α : Type u_2
β : Type u_3
inst✝¹ : CompleteLattice β
inst✝ : DecidableEq α
t : Finset α
f : α → β
s : β
i : α
hi : i ∈ t
hx : i ∉ t
⊢ False
|
exact hx hi
|
no goals
|
f80925da6cd69053
|
IsMulFreimanIso.mono
|
Mathlib/Combinatorics/Additive/FreimanHom.lean
|
@[to_additive]
lemma IsMulFreimanIso.mono {hmn : m ≤ n} (hf : IsMulFreimanIso n A B f) :
IsMulFreimanIso m A B f where
bijOn := hf.bijOn
map_prod_eq_map_prod s t hsA htA hs ht
|
case inr.intro.refine_2
α : Type u_2
β : Type u_3
inst✝¹ : CancelCommMonoid α
inst✝ : CancelCommMonoid β
A : Set α
B : Set β
f : α → β
m n : ℕ
hmn : m ≤ n
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = m
ht : t.card = m
a✝ : α
ha✝ : a✝ ∈ A
a : α
ha : a ∈ t + replicate (n - m) a✝
⊢ a ∈ A
|
rw [Multiset.mem_add] at ha
|
case inr.intro.refine_2
α : Type u_2
β : Type u_3
inst✝¹ : CancelCommMonoid α
inst✝ : CancelCommMonoid β
A : Set α
B : Set β
f : α → β
m n : ℕ
hmn : m ≤ n
hf : IsMulFreimanIso n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = m
ht : t.card = m
a✝ : α
ha✝ : a✝ ∈ A
a : α
ha : a ∈ t ∨ a ∈ replicate (n - m) a✝
⊢ a ∈ A
|
4d38848292c1597f
|
Nat.div2_bit
|
Mathlib/Data/Nat/Bits.lean
|
lemma div2_bit (b n) : div2 (bit b n) = n
|
b : Bool
n : ℕ
⊢ (bit b n).div2 = n
|
rw [bit_val, div2_val, Nat.add_comm, add_mul_div_left, div_eq_of_lt, Nat.zero_add]
<;> cases b
<;> decide
|
no goals
|
dab866d736182597
|
MeasureTheory.SimpleFunc.eapprox_lt_top
|
Mathlib/MeasureTheory/Function/SimpleFunc.lean
|
theorem eapprox_lt_top (f : α → ℝ≥0∞) (n : ℕ) (a : α) : eapprox f n a < ∞
|
case pos
α : Type u_1
inst✝ : MeasurableSpace α
f : α → ℝ≥0∞
n : ℕ
a : α
b : ℕ
a✝ : b ∈ Finset.range n
h✝ : MeasurableSet {a | ennrealRatEmbed b ≤ f a}
⊢ {a | ennrealRatEmbed b ≤ f a}.indicator (Function.const α (ennrealRatEmbed b)) a < ⊤
|
calc
{ a : α | ennrealRatEmbed b ≤ f a }.indicator (fun _ => ennrealRatEmbed b) a ≤
ennrealRatEmbed b :=
indicator_le_self _ _ a
_ < ⊤ := ENNReal.coe_lt_top
|
no goals
|
a31470243a3f9f84
|
List.exists_pw_disjoint_with_card
|
Mathlib/GroupTheory/Perm/Cycle/PossibleTypes.lean
|
theorem List.exists_pw_disjoint_with_card {α : Type*} [Fintype α]
{c : List ℕ} (hc : c.sum ≤ Fintype.card α) :
∃ o : List (List α),
o.map length = c ∧ (∀ s ∈ o, s.Nodup) ∧ Pairwise List.Disjoint o
|
α : Type u_2
inst✝ : Fintype α
c : List ℕ
hc : c.sum ≤ Fintype.card α
klift : (n : ℕ) → n < Fintype.card α → Fin (Fintype.card α) := fun n hn => ⟨n, hn⟩
klift' : (l : List ℕ) → (∀ a ∈ l, a < Fintype.card α) → List (Fin (Fintype.card α)) := fun l hl => pmap klift l hl
l : List ℕ
hl : l ∈ c.ranges
n : ℕ
hn : n ∈ l
⊢ n < c.sum
|
rw [← mem_mem_ranges_iff_lt_sum]
|
α : Type u_2
inst✝ : Fintype α
c : List ℕ
hc : c.sum ≤ Fintype.card α
klift : (n : ℕ) → n < Fintype.card α → Fin (Fintype.card α) := fun n hn => ⟨n, hn⟩
klift' : (l : List ℕ) → (∀ a ∈ l, a < Fintype.card α) → List (Fin (Fintype.card α)) := fun l hl => pmap klift l hl
l : List ℕ
hl : l ∈ c.ranges
n : ℕ
hn : n ∈ l
⊢ ∃ s ∈ c.ranges, n ∈ s
|
463233383e1ded3a
|
List.unzip_zip_right
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Zip.lean
|
theorem unzip_zip_right :
∀ {l₁ : List α} {l₂ : List β}, length l₂ ≤ length l₁ → (unzip (zip l₁ l₂)).2 = l₂
| [], l₂, _ => by simp_all
| l₁, [], _ => by simp
| a :: l₁, b :: l₂, h => by
simp only [zip_cons_cons, unzip_cons, unzip_zip_right (le_of_succ_le_succ h)]
|
α : Type u_1
β : Type u_2
l₂ : List β
x✝ : l₂.length ≤ [].length
⊢ ([].zip l₂).unzip.snd = l₂
|
simp_all
|
no goals
|
f6544f1eafdebf70
|
CategoryTheory.Idempotents.isIdempotentComplete_iff_hasEqualizer_of_id_and_idempotent
|
Mathlib/CategoryTheory/Idempotents/Basic.lean
|
theorem isIdempotentComplete_iff_hasEqualizer_of_id_and_idempotent :
IsIdempotentComplete C ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p
|
case create
C : Type u_1
inst✝ : Category.{u_2, u_1} C
a✝ : IsIdempotentComplete C
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : C
i : Y ⟶ X
e : X ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p
s : Fork (𝟙 X) p
⊢ (s.ι ≫ e) ≫ (Fork.ofι i ⋯).ι = s.ι ∧
∀
{m :
((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
((Functor.const WalkingParallelPair).obj (Fork.ofι i ⋯).pt).obj WalkingParallelPair.zero},
m ≫ (Fork.ofι i ⋯).ι = s.ι → m = s.ι ≫ e
|
constructor
|
case create.left
C : Type u_1
inst✝ : Category.{u_2, u_1} C
a✝ : IsIdempotentComplete C
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : C
i : Y ⟶ X
e : X ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p
s : Fork (𝟙 X) p
⊢ (s.ι ≫ e) ≫ (Fork.ofι i ⋯).ι = s.ι
case create.right
C : Type u_1
inst✝ : Category.{u_2, u_1} C
a✝ : IsIdempotentComplete C
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : C
i : Y ⟶ X
e : X ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p
s : Fork (𝟙 X) p
⊢ ∀
{m :
((Functor.const WalkingParallelPair).obj s.pt).obj WalkingParallelPair.zero ⟶
((Functor.const WalkingParallelPair).obj (Fork.ofι i ⋯).pt).obj WalkingParallelPair.zero},
m ≫ (Fork.ofι i ⋯).ι = s.ι → m = s.ι ≫ e
|
b9521a8a1dfa70fd
|
MeasureTheory.hasFiniteIntegral_toReal_iff
|
Mathlib/MeasureTheory/Function/L1Space/HasFiniteIntegral.lean
|
lemma hasFiniteIntegral_toReal_iff {f : α → ℝ≥0∞} (hf : ∀ᵐ x ∂μ, f x ≠ ∞) :
HasFiniteIntegral (fun x ↦ (f x).toReal) μ ↔ ∫⁻ x, f x ∂μ ≠ ∞
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x ≠ ⊤
⊢ HasFiniteIntegral (fun x => (f x).toReal) μ ↔ ∫⁻ (x : α), f x ∂μ ≠ ⊤
|
have : ∀ᵐ x ∂μ, .ofReal (f x).toReal = f x := by filter_upwards [hf] with x hx; simp [hx]
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x ≠ ⊤
this : ∀ᵐ (x : α) ∂μ, ENNReal.ofReal (f x).toReal = f x
⊢ HasFiniteIntegral (fun x => (f x).toReal) μ ↔ ∫⁻ (x : α), f x ∂μ ≠ ⊤
|
fac8a1e91be27dc4
|
AlgebraicGeometry.Scheme.homOfLE_app
|
Mathlib/AlgebraicGeometry/Restrict.lean
|
theorem Scheme.homOfLE_app {U V : X.Opens} (e : U ≤ V) (W : Opens V) :
(X.homOfLE e).app W =
X.presheaf.map (homOfLE <| X.ι_image_homOfLE_le_ι_image e W).op
|
X : Scheme
U V : X.Opens
e : U ≤ V
W : (↑V).Opens
e₁ : Hom.app (X.homOfLE e ≫ V.ι) (V.ι ''ᵁ W) = Hom.app U.ι (V.ι ''ᵁ W) ≫ (↑U).presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
(↑V).presheaf.map (eqToIso this).hom.op ≫ Hom.app (X.homOfLE e) (V.ι ⁻¹ᵁ V.ι ''ᵁ W) =
Hom.app (X.homOfLE e) W ≫ (↑U).presheaf.map ((Opens.map (X.homOfLE e).base).map (eqToIso this).hom.op.unop).op
e₃ :
Hom.app (X.homOfLE e) W =
X.presheaf.map ((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
X.presheaf.map (inv ((Hom.opensFunctor U.ι).map ((Opens.map (X.homOfLE e).base).map (eqToHom this))).op)
⊢ Hom.app (X.homOfLE e) W = X.presheaf.map (homOfLE ⋯).op
|
rw [e₃, ← Functor.map_comp]
|
X : Scheme
U V : X.Opens
e : U ≤ V
W : (↑V).Opens
e₁ : Hom.app (X.homOfLE e ≫ V.ι) (V.ι ''ᵁ W) = Hom.app U.ι (V.ι ''ᵁ W) ≫ (↑U).presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
(↑V).presheaf.map (eqToIso this).hom.op ≫ Hom.app (X.homOfLE e) (V.ι ⁻¹ᵁ V.ι ''ᵁ W) =
Hom.app (X.homOfLE e) W ≫ (↑U).presheaf.map ((Opens.map (X.homOfLE e).base).map (eqToIso this).hom.op.unop).op
e₃ :
Hom.app (X.homOfLE e) W =
X.presheaf.map ((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
X.presheaf.map (inv ((Hom.opensFunctor U.ι).map ((Opens.map (X.homOfLE e).base).map (eqToHom this))).op)
⊢ X.presheaf.map
(((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
inv ((Hom.opensFunctor U.ι).map ((Opens.map (X.homOfLE e).base).map (eqToHom this))).op) =
X.presheaf.map (homOfLE ⋯).op
|
389fba341e18e4b3
|
ball_one_eq
|
Mathlib/Analysis/Normed/Group/Basic.lean
|
theorem ball_one_eq (r : ℝ) : ball (1 : E) r = { x | ‖x‖ < r } :=
Set.ext fun a => by simp
|
E : Type u_5
inst✝ : SeminormedGroup E
r : ℝ
a : E
⊢ a ∈ ball 1 r ↔ a ∈ {x | ‖x‖ < r}
|
simp
|
no goals
|
c36e270c57eaabcd
|
CochainComplex.HomComplex.Cochain.leftUnshift_units_smul
|
Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
|
@[simp]
lemma leftUnshift_units_smul {n' a : ℤ} (γ : Cochain (K⟦a⟧) L n') (n : ℤ)
(hn : n + a = n') (x : Rˣ) :
(x • γ).leftUnshift n hn = x • γ.leftUnshift n hn
|
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L : CochainComplex C ℤ
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
x : Rˣ
⊢ (x • γ).leftUnshift n hn = x • γ.leftUnshift n hn
|
apply leftUnshift_smul
|
no goals
|
735cce28459b5483
|
Submodule.coe_dualCoannihilator_span
|
Mathlib/LinearAlgebra/Dual.lean
|
@[simp]
lemma coe_dualCoannihilator_span (s : Set (Module.Dual R M)) :
((span R s).dualCoannihilator : Set M) = {x | ∀ f ∈ s, f x = 0}
|
case h
R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set (Dual R M)
x : M
this : ∀ (φ : Dual R M), x ∈ LinearMap.ker φ ↔ φ ∈ LinearMap.ker ((Dual.eval R M) x)
⊢ (∀ φ ∈ span R s, φ ∈ LinearMap.ker ((Dual.eval R M) x)) ↔ ∀ f ∈ s, f ∈ LinearMap.ker ((Dual.eval R M) x)
|
exact span_le
|
no goals
|
f2343ad38b9ecd7b
|
List.Sublist.sym
|
Mathlib/Data/List/Sym.lean
|
theorem Sublist.sym (n : ℕ) {xs ys : List α} (h : xs <+ ys) : xs.sym n <+ ys.sym n :=
match n, h with
| 0, _ => by simp [List.sym]
| n + 1, .slnil => by simp only [refl]
| n + 1, .cons a h => by
rw [List.sym, ← nil_append (List.sym (n + 1) xs)]
apply Sublist.append (nil_sublist _)
exact h.sym (n + 1)
| n + 1, .cons₂ a h => by
rw [List.sym, List.sym]
apply Sublist.append
· exact ((cons₂ a h).sym n).map _
· exact h.sym (n + 1)
|
α : Type u_1
n✝ : ℕ
xs ys : List α
h✝ : xs <+ ys
n : ℕ
l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
⊢ map (fun p => a ::ₛ p) (List.sym n (a :: l₁✝)) ++ List.sym (n + 1) l₁✝ <+
map (fun p => a ::ₛ p) (List.sym n (a :: l₂✝)) ++ List.sym (n + 1) l₂✝
|
apply Sublist.append
|
case hl
α : Type u_1
n✝ : ℕ
xs ys : List α
h✝ : xs <+ ys
n : ℕ
l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
⊢ map (fun p => a ::ₛ p) (List.sym n (a :: l₁✝)) <+ map (fun p => a ::ₛ p) (List.sym n (a :: l₂✝))
case hr
α : Type u_1
n✝ : ℕ
xs ys : List α
h✝ : xs <+ ys
n : ℕ
l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
⊢ List.sym (n + 1) l₁✝ <+ List.sym (n + 1) l₂✝
|
d3891099e3ec45ad
|
List.prev_reverse_eq_next
|
Mathlib/Data/List/Cycle.lean
|
theorem prev_reverse_eq_next (l : List α) (h : Nodup l) (x : α) (hx : x ∈ l) :
prev l.reverse x (mem_reverse.mpr hx) = next l x hx
|
case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l[k] ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.reverse.prev l[k] ⋯ = (pmap l.next l ⋯)[k]
|
simp_rw [getElem_eq_getElem_reverse (l := l), pmap_next_eq_rotate_one _ h]
|
case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l : List α
h : l.Nodup
k : ℕ
hk : k < l.length
hx : l[k] ∈ l
lpos : 0 < l.length
key : l.length - 1 - k < l.length
⊢ l.reverse.prev l.reverse[l.length - 1 - k] ⋯ = (l.rotate 1)[k]
|
223a9f0719f3b161
|
Affine.Simplex.circumsphere_reindex
|
Mathlib/Geometry/Euclidean/Circumcenter.lean
|
theorem circumsphere_reindex {m n : ℕ} (s : Simplex ℝ P m) (e : Fin (m + 1) ≃ Fin (n + 1)) :
(s.reindex e).circumsphere = s.circumsphere
|
case refine_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
m n : ℕ
s : Simplex ℝ P m
e : Fin (m + 1) ≃ Fin (n + 1)
⊢ (s.reindex e).circumsphere.center ∈ affineSpan ℝ (Set.range (s.reindex e).points)
|
exact (s.reindex e).circumsphere_unique_dist_eq.1.1
|
no goals
|
4450e8b52c9c2999
|
Orientation.oangle_add_right_eq_arctan_of_oangle_eq_pi_div_two
|
Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
|
theorem oangle_add_right_eq_arctan_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
o.oangle x (x + y) = Real.arctan (‖y‖ / ‖x‖)
|
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ o.oangle x (x + y) = ↑(Real.arctan (‖y‖ / ‖x‖))
|
have hs : (o.oangle x (x + y)).sign = 1 := by
rw [oangle_sign_add_right, h, Real.Angle.sign_coe_pi_div_two]
|
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
hs : (o.oangle x (x + y)).sign = 1
⊢ o.oangle x (x + y) = ↑(Real.arctan (‖y‖ / ‖x‖))
|
45dcf7e3fc3510ff
|
Pi.isAtom_iff_eq_single
|
Mathlib/Order/Atoms.lean
|
theorem isAtom_iff_eq_single [DecidableEq ι] [∀ i, PartialOrder (π i)]
[∀ i, OrderBot (π i)] {f : ∀ i, π i} :
IsAtom f ↔ ∃ i a, IsAtom a ∧ f = Function.update ⊥ i a
|
case mp
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ IsAtom f → ∃ i a, IsAtom a ∧ f = Function.update ⊥ i a
case mpr
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ (∃ i a, IsAtom a ∧ f = Function.update ⊥ i a) → IsAtom f
|
case mp =>
intro h
have ⟨i, h, hbot⟩ := isAtom_iff.1 h
refine ⟨_, _, h, funext fun j => if hij : j = i then hij ▸ by simp else ?_⟩
rw [Function.update_of_ne hij, hbot _ hij, bot_apply]
|
case mpr
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ (∃ i a, IsAtom a ∧ f = Function.update ⊥ i a) → IsAtom f
|
d8e4c77da6e7ba4c
|
leOnePart_mul_oneLePart
|
Mathlib/Algebra/Order/Group/PosPart.lean
|
@[to_additive] lemma leOnePart_mul_oneLePart (a : α) : a⁻ᵐ * a⁺ᵐ = |a|ₘ
|
α : Type u_1
inst✝³ : Lattice α
inst✝² : Group α
inst✝¹ : MulLeftMono α
inst✝ : MulRightMono α
a : α
⊢ a⁻ᵐ * a⁺ᵐ = mabs a
|
rw [oneLePart_def, mul_sup, mul_one, leOnePart_def, sup_mul, one_mul, inv_mul_cancel, sup_assoc,
← @sup_assoc _ _ a, sup_eq_right.2 le_sup_right]
|
α : Type u_1
inst✝³ : Lattice α
inst✝² : Group α
inst✝¹ : MulLeftMono α
inst✝ : MulRightMono α
a : α
⊢ a ⊔ a⁻¹ ⊔ 1 = mabs a
|
17b9e31b8452bb9c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.