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
|
|---|---|---|---|---|---|---|
MeasureTheory.Content.outerMeasure_preimage
|
Mathlib/MeasureTheory/Measure/Content.lean
|
theorem outerMeasure_preimage (f : G ≃ₜ G) (h : ∀ ⦃K : Compacts G⦄, μ (K.map f f.continuous) = μ K)
(A : Set G) : μ.outerMeasure (f ⁻¹' A) = μ.outerMeasure A
|
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, μ (Compacts.map ⇑f ⋯ K) = μ K
A : Set G
⊢ μ.outerMeasure (⇑f ⁻¹' A) = μ.outerMeasure A
|
refine inducedOuterMeasure_preimage _ μ.innerContent_iUnion_nat μ.innerContent_mono _
(fun _ => f.isOpen_preimage) ?_
|
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, μ (Compacts.map ⇑f ⋯ K) = μ K
A : Set G
⊢ ∀ (s : Set G) (hs : IsOpen s),
μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }
|
5fb08ae1cd62239e
|
MvPolynomial.eval₂_comp_right
|
Mathlib/Algebra/MvPolynomial/Eval.lean
|
theorem eval₂_comp_right {S₂} [CommSemiring S₂] (k : S₁ →+* S₂) (f : R →+* S₁) (g : σ → S₁) (p) :
k (eval₂ f g p) = eval₂ k (k ∘ g) (map f p)
|
case h_X
R : Type u
S₁ : Type v
σ : Type u_1
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
S₂ : Type u_2
inst✝ : CommSemiring S₂
k : S₁ →+* S₂
f : R →+* S₁
g : σ → S₁
p✝ p : MvPolynomial σ R
s : σ
hp : k (eval₂ f g p) = eval₂ k (⇑k ∘ g) ((map f) p)
⊢ k (eval₂ f g (p * X s)) = eval₂ k (⇑k ∘ g) ((map f) (p * X s))
|
rw [eval₂_mul, k.map_mul, (map f).map_mul, eval₂_mul, map_X, hp, eval₂_X, eval₂_X]
|
case h_X
R : Type u
S₁ : Type v
σ : Type u_1
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
S₂ : Type u_2
inst✝ : CommSemiring S₂
k : S₁ →+* S₂
f : R →+* S₁
g : σ → S₁
p✝ p : MvPolynomial σ R
s : σ
hp : k (eval₂ f g p) = eval₂ k (⇑k ∘ g) ((map f) p)
⊢ eval₂ k (⇑k ∘ g) ((map f) p) * k (g s) = eval₂ k (⇑k ∘ g) ((map f) p) * (⇑k ∘ g) s
|
8cc38ece9b3c3561
|
MulAction.smul_orbit_eq_orbit_smul
|
Mathlib/GroupTheory/GroupAction/Blocks.lean
|
@[to_additive]
lemma smul_orbit_eq_orbit_smul (N : Subgroup G) [nN : N.Normal] (a : X) (g : G) :
g • orbit N a = orbit N (g • a)
|
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
⊢ (range fun i => g • i • a) = range fun m => m • g • a
|
ext
|
case h
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
x✝ : X
⊢ (x✝ ∈ range fun i => g • i • a) ↔ x✝ ∈ range fun m => m • g • a
|
766ddba81456486f
|
CategoryTheory.PreGaloisCategory.exists_lift_of_mono_of_isConnected
|
Mathlib/CategoryTheory/Galois/Full.lean
|
/--
Let `X` be an object of a Galois category with fiber functor `F` and `Y` a sub-`Aut F`-set
of `F.obj X`, on which `Aut F` acts transitively (i.e. which is connected in the Galois category
of finite `Aut F`-sets). Then there exists a connected sub-object `Z` of `X` and an isomorphism
`Y ≅ F.obj X` as `Aut F`-sets such that the obvious triangle commutes.
For a version without the connectedness assumption, see `exists_lift_of_mono`.
-/
lemma exists_lift_of_mono_of_isConnected (X : C) (Y : Action FintypeCat.{u} (Aut F))
(i : Y ⟶ (functorToAction F).obj X) [Mono i] [IsConnected Y] : ∃ (Z : C) (f : Z ⟶ X)
(u : Y ≅ (functorToAction F).obj Z),
IsConnected Z ∧ Mono f ∧ i = u.hom ≫ (functorToAction F).map f
|
case intro.intro.intro.intro.intro.intro.intro.a
C : Type u
inst✝⁴ : Category.{v, u} C
F : C ⥤ FintypeCat
inst✝³ : GaloisCategory C
inst✝² : FiberFunctor F
X : C
Y : Action FintypeCat (Aut F)
i : Y ⟶ (functorToAction F).obj X
inst✝¹ : Mono i
inst✝ : IsConnected Y
y : ((forget₂ (Action FintypeCat (Aut F)) FintypeCat).obj Y).carrier
Z : C
f : Z ⟶ X
z : (F.obj Z).carrier
hz : F.map f z = i.hom y
hc : IsConnected Z
hm : Mono f
this : IsConnected ((functorToAction F).obj Z)
u : Y ≅ (functorToAction F).obj Z
hu : (forget₂ (Action FintypeCat (Aut F)) FintypeCat).map u.hom y = z
⊢ i.hom y = F.map f z
|
exact hz.symm
|
no goals
|
e21793d61d28be88
|
CategoryTheory.SimplicialThickening.functor_id
|
Mathlib/AlgebraicTopology/SimplicialNerve.lean
|
lemma functor_id (J : Type u) [LinearOrder J] :
(functor (OrderHom.id (α := J))) = EnrichedFunctor.id _ _
|
J : Type u
inst✝ : LinearOrder J
⊢ functor OrderHom.id = EnrichedFunctor.id SSet (SimplicialThickening J)
|
refine EnrichedFunctor.ext _ (fun _ ↦ rfl) fun i j ↦ ?_
|
J : Type u
inst✝ : LinearOrder J
i j : SimplicialThickening J
⊢ (functor OrderHom.id).map i j ≫ eqToHom ⋯ = (EnrichedFunctor.id SSet (SimplicialThickening J)).map i j
|
88586f3926674e71
|
IsNilpotent.pow_succ
|
Mathlib/RingTheory/Nilpotent/Defs.lean
|
lemma IsNilpotent.pow_succ (n : ℕ) {S : Type*} [MonoidWithZero S] {x : S}
(hx : IsNilpotent x) : IsNilpotent (x ^ n.succ)
|
n : ℕ
S : Type u_3
inst✝ : MonoidWithZero S
x : S
hx : IsNilpotent x
⊢ IsNilpotent (x ^ n.succ)
|
obtain ⟨N, hN⟩ := hx
|
case intro
n : ℕ
S : Type u_3
inst✝ : MonoidWithZero S
x : S
N : ℕ
hN : x ^ N = 0
⊢ IsNilpotent (x ^ n.succ)
|
8d2a151272b83159
|
Int.le_bmod
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
|
theorem le_bmod {x : Int} {m : Nat} (h : 0 < m) : - (m/2) ≤ Int.bmod x m
|
case isFalse.inr.H
x : Int
m : Nat
h✝ : 0 < m
w : (↑m + 1) / 2 ≤ x % ↑m
q : Int
h : ↑m % 2 = 1
⊢ 2 ≠ 0
|
decide
|
no goals
|
c8cfe301519f3ee0
|
CategoryTheory.Limits.IsZero.obj
|
Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
|
theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZero (F.obj X)
|
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject D
F : C ⥤ D
hF : IsZero F
X : C
G : C ⥤ D := (Functor.const C).obj 0
hG : IsZero G
e : F ≅ G := hF.iso hG
⊢ IsZero (F.obj X)
|
exact (isZero_zero _).of_iso (e.app X)
|
no goals
|
5d1397e75923b8ad
|
CategoryTheory.MorphismProperty.cancel_left_of_respectsIso
|
Mathlib/CategoryTheory/MorphismProperty/Basic.lean
|
theorem cancel_left_of_respectsIso (P : MorphismProperty C) [hP : RespectsIso P] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] : P (f ≫ g) ↔ P g :=
⟨fun h => by simpa using RespectsIso.precomp P (inv f) (f ≫ g) h, RespectsIso.precomp P f g⟩
|
C : Type u
inst✝¹ : Category.{v, u} C
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
h : P (f ≫ g)
⊢ P g
|
simpa using RespectsIso.precomp P (inv f) (f ≫ g) h
|
no goals
|
7b942987bbba9db2
|
LinearMap.pi_zero
|
Mathlib/LinearAlgebra/Pi.lean
|
theorem pi_zero : pi (fun _ => 0 : (i : ι) → M₂ →ₗ[R] φ i) = 0
|
R : Type u
M₂ : Type w
ι : Type x
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
⊢ (pi fun x => 0) = 0
|
ext
|
case h.h
R : Type u
M₂ : Type w
ι : Type x
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
x✝¹ : M₂
x✝ : ι
⊢ (pi fun x => 0) x✝¹ x✝ = 0 x✝¹ x✝
|
98e3c81b32863162
|
AlgebraicGeometry.IsAffineOpen.isLocalization_basicOpen
|
Mathlib/AlgebraicGeometry/AffineScheme.lean
|
theorem isLocalization_basicOpen :
IsLocalization.Away f Γ(X, X.basicOpen f)
|
X : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ IsLocalization.Away f ↑Γ(X, X.basicOpen f)
|
apply
(IsLocalization.isLocalization_iff_of_ringEquiv (Submonoid.powers f)
(asIso <| basicOpenSectionsToAffine hU f).commRingCatIsoToRingEquiv).mpr
|
X : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ IsLocalization (Submonoid.powers f) ↑Γ(Spec Γ(X, U), PrimeSpectrum.basicOpen f)
|
1260db3b92cc0a2c
|
Polynomial.Chebyshev.T_complex_cos
|
Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean
|
theorem T_complex_cos (n : ℤ) : (T ℂ n).eval (cos θ) = cos (n * θ)
|
case add_two
θ : ℂ
n : ℕ
ih1 : eval (cos θ) (T ℂ (↑n + 1)) = cos (↑(↑n + 1) * θ)
ih2 : eval (cos θ) (T ℂ ↑n) = cos (↑↑n * θ)
⊢ eval (cos θ) (T ℂ (↑n + 2)) = cos (↑(↑n + 2) * θ)
|
simp only [T_add_two, eval_sub, eval_mul, eval_X, eval_ofNat, ih1, ih2, sub_eq_iff_eq_add,
cos_add_cos]
|
case add_two
θ : ℂ
n : ℕ
ih1 : eval (cos θ) (T ℂ (↑n + 1)) = cos (↑(↑n + 1) * θ)
ih2 : eval (cos θ) (T ℂ ↑n) = cos (↑↑n * θ)
⊢ 2 * cos θ * cos (↑(↑n + 1) * θ) = 2 * cos ((↑(↑n + 2) * θ + ↑↑n * θ) / 2) * cos ((↑(↑n + 2) * θ - ↑↑n * θ) / 2)
|
67b4e5604fca0521
|
Std.Sat.CNF.mem_cons
|
Mathlib/.lake/packages/lean4/src/lean/Std/Sat/CNF/Basic.lean
|
theorem mem_cons {v : α} {c} {f : CNF α} :
Mem v (c :: f : CNF α) ↔ (Clause.Mem v c ∨ Mem v f)
|
α : Type u_1
v : α
c : Clause α
f : CNF α
⊢ Mem v (c :: f) ↔ Clause.Mem v c ∨ Mem v f
|
simp [Mem]
|
no goals
|
93e9a114719833cb
|
ZMod.val_cast_of_lt
|
Mathlib/Data/ZMod/Basic.lean
|
theorem val_cast_of_lt {n : ℕ} {a : ℕ} (h : a < n) : (a : ZMod n).val = a
|
n a : ℕ
h : a < n
⊢ (↑a).val = a
|
rw [val_natCast, Nat.mod_eq_of_lt h]
|
no goals
|
62cf33afc30a5aba
|
Polynomial.dickson_one_one_zmod_p
|
Mathlib/RingTheory/Polynomial/Dickson.lean
|
theorem dickson_one_one_zmod_p (p : ℕ) [Fact p.Prime] : dickson 1 (1 : ZMod p) p = X ^ p
|
case neg
p : ℕ
inst✝ : Fact (Nat.Prime p)
K : Type
w✝¹ : Field K
w✝ : CharP K p
H : Set.univ.Infinite
h : {x | ∃ y, x = y + y⁻¹ ∧ y ≠ 0}.Finite
x : K
hx : ¬x = 0
⊢ ∃ i, (∃ y, i = y + y⁻¹ ∧ ¬y = 0) ∧ (i = x + x⁻¹ ∨ x = 0)
|
simp only [hx, or_false, exists_eq_right]
|
case neg
p : ℕ
inst✝ : Fact (Nat.Prime p)
K : Type
w✝¹ : Field K
w✝ : CharP K p
H : Set.univ.Infinite
h : {x | ∃ y, x = y + y⁻¹ ∧ y ≠ 0}.Finite
x : K
hx : ¬x = 0
⊢ ∃ y, x + x⁻¹ = y + y⁻¹ ∧ ¬y = 0
|
84ee1673e653698a
|
Finset.sup_singleton''
|
Mathlib/Data/Finset/Lattice/Fold.lean
|
theorem sup_singleton'' (s : Finset β) (f : β → α) :
(s.sup fun b => {f b}) = s.image f
|
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
s : Finset β
f : β → α
⊢ (s.sup fun b => {f b}) = image f s
|
ext a
|
case h
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
s : Finset β
f : β → α
a : α
⊢ (a ∈ s.sup fun b => {f b}) ↔ a ∈ image f s
|
83a374c07579c963
|
IsGreatest.nnnorm_cfc_nnreal
|
Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Isometric.lean
|
lemma IsGreatest.nnnorm_cfc_nnreal [Nontrivial A] (f : ℝ≥0 → ℝ≥0) (a : A)
(hf : ContinuousOn f (σ ℝ≥0 a)
|
A : Type u_1
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : NormedAlgebra ℝ A
inst✝⁴ : PartialOrder A
inst✝³ : StarOrderedRing A
inst✝² : IsometricContinuousFunctionalCalculus ℝ A IsSelfAdjoint
inst✝¹ : NonnegSpectrumClass ℝ A
inst✝ : Nontrivial A
f : ℝ≥0 → ℝ≥0
a : A
hf : autoParam (ContinuousOn f (σ ℝ≥0 a)) _auto✝
ha : autoParam (0 ≤ a) _auto✝
⊢ IsGreatest (f '' σ ℝ≥0 a) ‖cfc f a‖₊
|
rw [cfc_nnreal_eq_real]
|
A : Type u_1
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : NormedAlgebra ℝ A
inst✝⁴ : PartialOrder A
inst✝³ : StarOrderedRing A
inst✝² : IsometricContinuousFunctionalCalculus ℝ A IsSelfAdjoint
inst✝¹ : NonnegSpectrumClass ℝ A
inst✝ : Nontrivial A
f : ℝ≥0 → ℝ≥0
a : A
hf : autoParam (ContinuousOn f (σ ℝ≥0 a)) _auto✝
ha : autoParam (0 ≤ a) _auto✝
⊢ IsGreatest (f '' σ ℝ≥0 a) ‖cfc (fun x => ↑(f x.toNNReal)) a‖₊
|
d0555952bd1af9c1
|
MeasureTheory.tendsto_integral_smul_of_tendsto_average_norm_sub
|
Mathlib/MeasureTheory/Integral/Average.lean
|
theorem tendsto_integral_smul_of_tendsto_average_norm_sub
[CompleteSpace E]
{ι : Type*} {a : ι → Set α} {l : Filter ι} {f : α → E} {c : E} {g : ι → α → ℝ} (K : ℝ)
(hf : Tendsto (fun i ↦ ⨍ y in a i, ‖f y - c‖ ∂μ) l (𝓝 0))
(f_int : ∀ᶠ i in l, IntegrableOn f (a i) μ)
(hg : Tendsto (fun i ↦ ∫ y, g i y ∂μ) l (𝓝 1))
(g_supp : ∀ᶠ i in l, Function.support (g i) ⊆ a i)
(g_bound : ∀ᶠ i in l, ∀ x, |g i x| ≤ K / (μ (a i)).toReal) :
Tendsto (fun i ↦ ∫ y, g i y • f y ∂μ) l (𝓝 c)
|
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
μ : Measure α
inst✝ : CompleteSpace E
ι : Type u_4
a : ι → Set α
l : Filter ι
f : α → E
c : E
g : ι → α → ℝ
K : ℝ
hf : Tendsto (fun i => ⨍ (y : α) in a i, ‖f y - c‖ ∂μ) l (𝓝 0)
f_int : ∀ᶠ (i : ι) in l, IntegrableOn f (a i) μ
hg : Tendsto (fun i => ∫ (y : α), g i y ∂μ) l (𝓝 1)
g_supp : ∀ᶠ (i : ι) in l, support (g i) ⊆ a i
g_bound : ∀ᶠ (i : ι) in l, ∀ (x : α), |g i x| ≤ K / (μ (a i)).toReal
g_int : ∀ᶠ (i : ι) in l, Integrable (g i) μ
i : ι
hif : IntegrableOn f (a i) μ
hig : Integrable (g i) μ
hisupp : support (g i) ⊆ a i
hibound : ∀ (x : α), |g i x| ≤ K / (μ (a i)).toReal
A : (support fun y => g i y • f y) ⊆ a i
⊢ IntegrableOn (fun y => g i y • f y) (a i) μ
|
apply Integrable.smul_of_top_right hif
|
α : Type u_1
E : Type u_2
m0 : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
μ : Measure α
inst✝ : CompleteSpace E
ι : Type u_4
a : ι → Set α
l : Filter ι
f : α → E
c : E
g : ι → α → ℝ
K : ℝ
hf : Tendsto (fun i => ⨍ (y : α) in a i, ‖f y - c‖ ∂μ) l (𝓝 0)
f_int : ∀ᶠ (i : ι) in l, IntegrableOn f (a i) μ
hg : Tendsto (fun i => ∫ (y : α), g i y ∂μ) l (𝓝 1)
g_supp : ∀ᶠ (i : ι) in l, support (g i) ⊆ a i
g_bound : ∀ᶠ (i : ι) in l, ∀ (x : α), |g i x| ≤ K / (μ (a i)).toReal
g_int : ∀ᶠ (i : ι) in l, Integrable (g i) μ
i : ι
hif : IntegrableOn f (a i) μ
hig : Integrable (g i) μ
hisupp : support (g i) ⊆ a i
hibound : ∀ (x : α), |g i x| ≤ K / (μ (a i)).toReal
A : (support fun y => g i y • f y) ⊆ a i
⊢ MemLp (g i) ⊤ (μ.restrict (a i))
|
7e4f16c60f002777
|
Set.bijOn_empty_iff_right
|
Mathlib/Data/Set/Function.lean
|
theorem bijOn_empty_iff_right : BijOn f ∅ t ↔ t = ∅ :=
⟨fun h ↦ by simpa using h.surjOn, by rintro rfl; exact bijOn_empty f⟩
|
α : Type u_1
β : Type u_2
t : Set β
f : α → β
⊢ t = ∅ → BijOn f ∅ t
|
rintro rfl
|
α : Type u_1
β : Type u_2
f : α → β
⊢ BijOn f ∅ ∅
|
239da8e82873d9af
|
MeasureTheory.lintegral_pow_le_pow_lintegral_fderiv_aux
|
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean
|
theorem lintegral_pow_le_pow_lintegral_fderiv_aux [Fintype ι]
{p : ℝ} (hp : Real.IsConjExponent #ι p)
{u : (ι → ℝ) → F} (hu : ContDiff ℝ 1 u)
(h2u : HasCompactSupport u) :
∫⁻ x, ‖u x‖ₑ ^ p ≤ (∫⁻ x, ‖fderiv ℝ u x‖ₑ) ^ p
|
ι : Type u_1
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : Fintype ι
p : ℝ
hp : (↑#ι).IsConjExponent p
u : (ι → ℝ) → F
hu : ContDiff ℝ 1 u
h2u : HasCompactSupport u
this : 1 ≤ ↑#ι - 1
⊢ ∫⁻ (x : ι → ℝ), ‖u x‖ₑ ^ p ≤ (∫⁻ (x : ι → ℝ), ‖fderiv ℝ u x‖ₑ) ^ p
|
calc ∫⁻ x, ‖u x‖ₑ ^ p
= ∫⁻ x, (‖u x‖ₑ ^ (1 / (#ι - 1 : ℝ))) ^ (#ι : ℝ) := by
congr! 2 with x
rw [← ENNReal.rpow_mul, hp.conj_eq]
field_simp
_ = ∫⁻ x, ∏ _i : ι, ‖u x‖ₑ ^ (1 / (#ι - 1 : ℝ)) := by
congr! 2 with x
simp_rw [prod_const]
norm_cast
_ ≤ ∫⁻ x, ∏ i, (∫⁻ xᵢ, ‖fderiv ℝ u (update x i xᵢ)‖ₑ) ^ ((1 : ℝ) / (#ι - 1 : ℝ)) := ?_
_ ≤ (∫⁻ x, ‖fderiv ℝ u x‖ₑ) ^ p := by
apply lintegral_prod_lintegral_pow_le _ hp
have : Continuous (fderiv ℝ u) := hu.continuous_fderiv le_rfl
fun_prop
|
ι : Type u_1
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : Fintype ι
p : ℝ
hp : (↑#ι).IsConjExponent p
u : (ι → ℝ) → F
hu : ContDiff ℝ 1 u
h2u : HasCompactSupport u
this : 1 ≤ ↑#ι - 1
⊢ ∫⁻ (x : ι → ℝ), ∏ _i : ι, ‖u x‖ₑ ^ (1 / (↑#ι - 1)) ≤
∫⁻ (x : ι → ℝ), ∏ i : ι, (∫⁻ (xᵢ : ℝ), ‖fderiv ℝ u (update x i xᵢ)‖ₑ) ^ (1 / (↑#ι - 1))
|
5098921b770834eb
|
isNoetherian_iff_submodule_quotient
|
Mathlib/RingTheory/Noetherian/Basic.lean
|
theorem isNoetherian_iff_submodule_quotient (S : Submodule R P) :
IsNoetherian R P ↔ IsNoetherian R S ∧ IsNoetherian R (P ⧸ S)
|
R : Type u_1
P : Type u_4
inst✝² : Ring R
inst✝¹ : AddCommGroup P
inst✝ : Module R P
S : Submodule R P
x✝ : IsNoetherian R ↥S ∧ IsNoetherian R (P ⧸ S)
left✝ : IsNoetherian R ↥S
right✝ : IsNoetherian R (P ⧸ S)
⊢ LinearMap.range S.subtype = LinearMap.ker S.mkQ
|
rw [Submodule.ker_mkQ, Submodule.range_subtype]
|
no goals
|
9bbbb93e25dc3271
|
Finsupp.lmapDomain_disjoint_ker
|
Mathlib/LinearAlgebra/Finsupp/Supported.lean
|
theorem lmapDomain_disjoint_ker (f : α → α') {s : Set α}
(H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b) :
Disjoint (supported M R s) (ker (lmapDomain M R f))
|
case intro
α : Type u_1
M : Type u_2
R : Type u_5
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
α' : Type u_7
f : α → α'
s : Set α
H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b
l : α →₀ M
h₁ : l ∈ ↑(supported M R s)
h₂ : (l.sum fun a => single (f a)) = 0
⊢ l = 0
|
ext x
|
case intro.h
α : Type u_1
M : Type u_2
R : Type u_5
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
α' : Type u_7
f : α → α'
s : Set α
H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b
l : α →₀ M
h₁ : l ∈ ↑(supported M R s)
h₂ : (l.sum fun a => single (f a)) = 0
x : α
⊢ l x = 0 x
|
13c609db9f843127
|
LieModule.weightSpaceOfIsLieTower_aux
|
Mathlib/Algebra/Lie/LieTheorem.lean
|
/-- An auxiliary lemma used only in the definition `LieModule.weightSpaceOfIsLieTower` below. -/
private lemma weightSpaceOfIsLieTower_aux (z : L) (v : V) (hv : v ∈ weightSpace V χ) :
⁅z, v⁆ ∈ weightSpace V χ
|
R : Type u_1
L : Type u_2
A : Type u_3
V : Type u_4
inst✝¹⁹ : CommRing R
inst✝¹⁸ : IsPrincipalIdealRing R
inst✝¹⁷ : IsDomain R
inst✝¹⁶ : CharZero R
inst✝¹⁵ : LieRing L
inst✝¹⁴ : LieAlgebra R L
inst✝¹³ : LieRing A
inst✝¹² : LieAlgebra R A
inst✝¹¹ : Bracket L A
inst✝¹⁰ : Bracket A L
inst✝⁹ : AddCommGroup V
inst✝⁸ : Module R V
inst✝⁷ : Module.Free R V
inst✝⁶ : Module.Finite R V
inst✝⁵ : LieRingModule L V
inst✝⁴ : LieModule R L V
inst✝³ : LieRingModule A V
inst✝² : LieModule R A V
inst✝¹ : IsLieTower L A V
inst✝ : IsLieTower A L V
χ : A → R
z : L
v : V
hv : ∀ (x : A), ⁅x, v⁆ = χ x • v
a : A
hv' : v ≠ 0
U' : ℕ →o Submodule R V :=
{ toFun := fun n => Submodule.span R {x | ∃ i < n, ((toEnd R L V) z ^ i) v = x}, monotone' := ⋯ }
map_U'_le : ∀ (n : ℕ), Submodule.map ((toEnd R L V) z) (U' n) ≤ U' (n + 1)
T_apply_succ : ∀ (w : A) (n : ℕ), Submodule.map (LieModule.T χ w) (U' (n + 1)) ≤ U' n
U : LieSubmodule R A V := { toSubmodule := ⨆ k, U' k, lie_mem := ⋯ }
hzU : ∀ x ∈ U, ((toEnd R L V) z) x ∈ U
trace_za_zero : (LinearMap.trace R ↥U) ((toEnd R A ↥U) ⁅z, a⁆) = 0
w : A
key : ∀ (i : ℕ), i ≠ 0 → ∃ j < i, Submodule.map (LieModule.T χ w) (U' i) ≤ U' j
x : ↥U
this : ↑x ∈ (LieModule.T χ w).maxGenEigenspace 0
⊢ ∃ n, (LieModule.T χ w ^ n) x = 0
|
simp only [Module.End.mem_maxGenEigenspace, zero_smul, sub_zero] at this
|
R : Type u_1
L : Type u_2
A : Type u_3
V : Type u_4
inst✝¹⁹ : CommRing R
inst✝¹⁸ : IsPrincipalIdealRing R
inst✝¹⁷ : IsDomain R
inst✝¹⁶ : CharZero R
inst✝¹⁵ : LieRing L
inst✝¹⁴ : LieAlgebra R L
inst✝¹³ : LieRing A
inst✝¹² : LieAlgebra R A
inst✝¹¹ : Bracket L A
inst✝¹⁰ : Bracket A L
inst✝⁹ : AddCommGroup V
inst✝⁸ : Module R V
inst✝⁷ : Module.Free R V
inst✝⁶ : Module.Finite R V
inst✝⁵ : LieRingModule L V
inst✝⁴ : LieModule R L V
inst✝³ : LieRingModule A V
inst✝² : LieModule R A V
inst✝¹ : IsLieTower L A V
inst✝ : IsLieTower A L V
χ : A → R
z : L
v : V
hv : ∀ (x : A), ⁅x, v⁆ = χ x • v
a : A
hv' : v ≠ 0
U' : ℕ →o Submodule R V :=
{ toFun := fun n => Submodule.span R {x | ∃ i < n, ((toEnd R L V) z ^ i) v = x}, monotone' := ⋯ }
map_U'_le : ∀ (n : ℕ), Submodule.map ((toEnd R L V) z) (U' n) ≤ U' (n + 1)
T_apply_succ : ∀ (w : A) (n : ℕ), Submodule.map (LieModule.T χ w) (U' (n + 1)) ≤ U' n
U : LieSubmodule R A V := { toSubmodule := ⨆ k, U' k, lie_mem := ⋯ }
hzU : ∀ x ∈ U, ((toEnd R L V) z) x ∈ U
trace_za_zero : (LinearMap.trace R ↥U) ((toEnd R A ↥U) ⁅z, a⁆) = 0
w : A
key : ∀ (i : ℕ), i ≠ 0 → ∃ j < i, Submodule.map (LieModule.T χ w) (U' i) ≤ U' j
x : ↥U
this : ∃ k, (LieModule.T χ w ^ k) ↑x = 0
⊢ ∃ n, (LieModule.T χ w ^ n) x = 0
|
6a6e6c619a907741
|
Cardinal.isPrimePow_iff
|
Mathlib/SetTheory/Cardinal/Divisibility.lean
|
theorem isPrimePow_iff {a : Cardinal} : IsPrimePow a ↔ ℵ₀ ≤ a ∨ ∃ n : ℕ, a = n ∧ IsPrimePow n
|
case neg.intro
a : ℕ
h : ¬ℵ₀ ≤ ↑a
⊢ (∃ p k, Prime p ∧ 0 < k ∧ p ^ k = ↑a) → ∃ n, ↑a = ↑n ∧ ∃ p k, Nat.Prime p ∧ 0 < k ∧ p ^ k = n
|
rintro ⟨p, k, hp, hk, hpk⟩
|
case neg.intro.intro.intro.intro.intro
a : ℕ
h : ¬ℵ₀ ≤ ↑a
p : Cardinal.{u_1}
k : ℕ
hp : Prime p
hk : 0 < k
hpk : p ^ k = ↑a
⊢ ∃ n, ↑a = ↑n ∧ ∃ p k, Nat.Prime p ∧ 0 < k ∧ p ^ k = n
|
a84b61c12666a126
|
Valued.continuous_valuation
|
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
theorem Valued.continuous_valuation [Valued K Γ₀] : Continuous (v : K → Γ₀)
|
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
⊢ ContinuousAt (⇑v) x
|
rcases eq_or_ne x 0 with (rfl | h)
|
case inl
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ ContinuousAt (⇑v) 0
case inr
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
h : x ≠ 0
⊢ ContinuousAt (⇑v) x
|
40ad4a371f000982
|
Cardinal.empty_theory_categorical
|
Mathlib/ModelTheory/Satisfiability.lean
|
theorem empty_theory_categorical (T : Language.empty.Theory) : κ.Categorical T := fun M N hM hN =>
by rw [empty.nonempty_equiv_iff, hM, hN]
|
κ : Cardinal.{w}
T : Language.empty.Theory
M N : T.ModelType
hM : #↑M = κ
hN : #↑N = κ
⊢ Nonempty (↑M ≃[Language.empty] ↑N)
|
rw [empty.nonempty_equiv_iff, hM, hN]
|
no goals
|
f578a7941449a572
|
ZNum.abs_to_nat
|
Mathlib/Data/Num/Lemmas.lean
|
theorem abs_to_nat : ∀ n, (abs n : ℕ) = Int.natAbs n
| 0 => rfl
| pos p => congr_arg Int.natAbs p.to_nat_to_int
| neg p => show Int.natAbs ((p : ℕ) : ℤ) = Int.natAbs (-p) by rw [p.to_nat_to_int, Int.natAbs_neg]
|
p : PosNum
⊢ (↑↑p).natAbs = (-↑p).natAbs
|
rw [p.to_nat_to_int, Int.natAbs_neg]
|
no goals
|
5cf4e60ef8bb2c4a
|
ConvexOn.leftDeriv_le_rightDeriv_of_mem_interior
|
Mathlib/Analysis/Convex/Deriv.lean
|
lemma leftDeriv_le_rightDeriv_of_mem_interior (hfc : ConvexOn ℝ S f) (hxs : x ∈ interior S) :
derivWithin f (Iio x) x ≤ derivWithin f (Ioi x) x
|
case intro.intro.intro.refine_2.intro.intro.intro.refine_1
S : Set ℝ
f : ℝ → ℝ
x : ℝ
hfc : ConvexOn ℝ S f
hxs : x ∈ interior S
a b : ℝ
hxab : x ∈ Ioo a b
habs : Ioo a b ⊆ S
z : ℝ
hzs : z ∈ S
hzx : z < x
⊢ {y | y ∈ S ∧ x < y}.Nonempty
|
obtain ⟨z, hxz, hzb⟩ := exists_between hxab.2
|
case intro.intro.intro.refine_2.intro.intro.intro.refine_1.intro.intro
S : Set ℝ
f : ℝ → ℝ
x : ℝ
hfc : ConvexOn ℝ S f
hxs : x ∈ interior S
a b : ℝ
hxab : x ∈ Ioo a b
habs : Ioo a b ⊆ S
z✝ : ℝ
hzs : z✝ ∈ S
hzx : z✝ < x
z : ℝ
hxz : x < z
hzb : z < b
⊢ {y | y ∈ S ∧ x < y}.Nonempty
|
ee20e04546739631
|
AddMonoidAlgebra.mapDomain_mul
|
Mathlib/Algebra/MonoidAlgebra/MapDomain.lean
|
theorem mapDomain_mul {α : Type*} {β : Type*} {α₂ : Type*} [Semiring β] [Add α] [Add α₂]
{F : Type*} [FunLike F α α₂] [AddHomClass F α α₂] (f : F) (x y : AddMonoidAlgebra β α) :
mapDomain f (x * y) = mapDomain f x * mapDomain f y
|
case e_g
α : Type u_3
β : Type u_4
α₂ : Type u_5
inst✝⁴ : Semiring β
inst✝³ : Add α
inst✝² : Add α₂
F : Type u_6
inst✝¹ : FunLike F α α₂
inst✝ : AddHomClass F α α₂
f : F
x y : β[α]
⊢ (fun a b => sum y fun a_1 b_1 => single (f a + f a_1) (b * b_1)) = fun a m =>
sum (mapDomain (⇑f) y) fun a₂ b₂ => single (f a + a₂) (m * b₂)
|
ext a b
|
case e_g.h.h.H
α : Type u_3
β : Type u_4
α₂ : Type u_5
inst✝⁴ : Semiring β
inst✝³ : Add α
inst✝² : Add α₂
F : Type u_6
inst✝¹ : FunLike F α α₂
inst✝ : AddHomClass F α α₂
f : F
x y : β[α]
a : α
b : β
x✝ : α₂
⊢ (sum y fun a_1 b_1 => single (f a + f a_1) (b * b_1)) x✝ =
(sum (mapDomain (⇑f) y) fun a₂ b₂ => single (f a + a₂) (b * b₂)) x✝
|
b46c385eaf47b5df
|
CommRing.toRing_injective
|
Mathlib/Algebra/Ring/Ext.lean
|
theorem toRing_injective : Function.Injective (@toRing R)
|
case mk.mk
R : Type u
toRing✝¹ : Ring R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toRing✝ : Ring R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toRing = toRing
⊢ mk mul_comm✝¹ = mk mul_comm✝
|
congr
|
no goals
|
f5e0d8bb4c5d830f
|
Valuation.subgroups_basis
|
Mathlib/Topology/Algebra/Valued/ValuationTopology.lean
|
theorem subgroups_basis : RingSubgroupsBasis fun γ : Γ₀ˣ => (v.ltAddSubgroup γ : AddSubgroup R) :=
{ inter
|
case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x : R
γ γx : Γ₀ˣ
Hx : v x = ↑γx
y : R
vy_lt : v y < ↑(γx⁻¹ * γ)
⊢ y ∈ (fun x_1 => x * x_1) ⁻¹' ↑(v.ltAddSubgroup γ)
|
change (v (x * y) : Γ₀) < γ
|
case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x : R
γ γx : Γ₀ˣ
Hx : v x = ↑γx
y : R
vy_lt : v y < ↑(γx⁻¹ * γ)
⊢ v (x * y) < ↑γ
|
ae2f24a204597808
|
PowerSeries.exp_mul_exp_eq_exp_add
|
Mathlib/RingTheory/PowerSeries/WellKnown.lean
|
theorem exp_mul_exp_eq_exp_add [Algebra ℚ A] (a b : A) :
rescale a (exp A) * rescale b (exp A) = rescale (a + b) (exp A)
|
case h.e_a
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
a b : A
n x : ℕ
hx : x ∈ Finset.range n.succ
⊢ x ! * (n - x)! ∣ n !
|
apply factorial_mul_factorial_dvd_factorial (mem_range_succ_iff.1 hx)
|
no goals
|
afb10c577ff818e3
|
Lean.Order.fix_eq
|
Mathlib/.lake/packages/lean4/src/lean/Init/Internal/Order/Basic.lean
|
theorem fix_eq {f : α → α} (hf : monotone f) : fix f hf = f (fix f hf)
|
α : Sort u
inst✝ : CCPO α
f : α → α
hf : monotone f
⊢ fix f hf = f (fix f hf)
|
apply rel_antisymm
|
case a
α : Sort u
inst✝ : CCPO α
f : α → α
hf : monotone f
⊢ fix f hf ⊑ f (fix f hf)
case a
α : Sort u
inst✝ : CCPO α
f : α → α
hf : monotone f
⊢ f (fix f hf) ⊑ fix f hf
|
68786671fa9501e6
|
HasSum.mul_of_nonarchimedean
|
Mathlib/Topology/Algebra/InfiniteSum/Nonarchimedean.lean
|
theorem HasSum.mul_of_nonarchimedean {f : α → R} {g : β → R} {a b : R} (hf : HasSum f a)
(hg : HasSum g b) : HasSum (fun i : α × β ↦ f i.1 * g i.2) (a * b)
|
α : Type u_1
β : Type u_2
R : Type u_3
inst✝³ : Ring R
inst✝² : UniformSpace R
inst✝¹ : UniformAddGroup R
inst✝ : NonarchimedeanRing R
f : α → R
g : β → R
a b : R
hf : HasSum (⇑UniformSpace.Completion.toCompl ∘ f) ↑a
hg : HasSum (⇑UniformSpace.Completion.toCompl ∘ g) ↑b
⊢ HasSum (⇑UniformSpace.Completion.toCompl ∘ fun i => f i.1 * g i.2) ↑(a * b)
|
simp only [Function.comp_def, UniformSpace.Completion.toCompl_apply,
UniformSpace.Completion.coe_mul]
|
α : Type u_1
β : Type u_2
R : Type u_3
inst✝³ : Ring R
inst✝² : UniformSpace R
inst✝¹ : UniformAddGroup R
inst✝ : NonarchimedeanRing R
f : α → R
g : β → R
a b : R
hf : HasSum (⇑UniformSpace.Completion.toCompl ∘ f) ↑a
hg : HasSum (⇑UniformSpace.Completion.toCompl ∘ g) ↑b
⊢ HasSum (fun x => ↑(f x.1) * ↑(g x.2)) (↑a * ↑b)
|
86707fdd4057400d
|
Filter.eventuallyEq_univ
|
Mathlib/Order/Filter/Basic.lean
|
theorem eventuallyEq_univ {s : Set α} {l : Filter α} : s =ᶠ[l] univ ↔ s ∈ l
|
α : Type u
s : Set α
l : Filter α
⊢ s =ᶠ[l] univ ↔ s ∈ l
|
simp [eventuallyEq_set]
|
no goals
|
e77d7bdcdb5b65ae
|
Rat.add_mul
|
Mathlib/Data/Rat/Defs.lean
|
theorem add_mul : (a + b) * c = a * c + b * c :=
numDenCasesOn' a fun n₁ d₁ h₁ ↦ numDenCasesOn' b fun n₂ d₂ h₂ ↦ numDenCasesOn' c fun n₃ d₃ h₃ ↦ by
simp only [ne_eq, Int.natCast_eq_zero, h₁, not_false_eq_true, h₂, divInt_add_divInt,
Int.mul_eq_zero, or_self, h₃, divInt_mul_divInt]
rw [← divInt_mul_right (Int.natCast_ne_zero.2 h₃), Int.add_mul, Int.add_mul]
ac_rfl
|
a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * ↑d₂ + n₂ * ↑d₁) * n₃ /. (↑d₁ * ↑d₂ * ↑d₃) =
(n₁ * n₃ * (↑d₂ * ↑d₃) + n₂ * n₃ * (↑d₁ * ↑d₃)) /. (↑d₁ * ↑d₃ * (↑d₂ * ↑d₃))
|
rw [← divInt_mul_right (Int.natCast_ne_zero.2 h₃), Int.add_mul, Int.add_mul]
|
a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * ↑d₂ * n₃ * ↑d₃ + n₂ * ↑d₁ * n₃ * ↑d₃) /. (↑d₁ * ↑d₂ * ↑d₃ * ↑d₃) =
(n₁ * n₃ * (↑d₂ * ↑d₃) + n₂ * n₃ * (↑d₁ * ↑d₃)) /. (↑d₁ * ↑d₃ * (↑d₂ * ↑d₃))
|
9b5f0510bd507357
|
Order.height_nat
|
Mathlib/Order/KrullDimension.lean
|
@[simp] lemma height_nat (n : ℕ) : height n = n
|
case ind.a
n : ℕ
ih : ∀ m < n, height m = ↑m
⊢ height n ≤ ↑n
|
apply height_le_coe_iff.mpr
|
case ind.a
n : ℕ
ih : ∀ m < n, height m = ↑m
⊢ ∀ y < n, height y < ↑n
|
9e49d4a85f26ebf2
|
Pi.isAtom_iff
|
Mathlib/Order/Atoms.lean
|
theorem isAtom_iff {f : ∀ i, π i} [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)] :
IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ j, j ≠ i → f j = ⊥
|
case c
ι : Type u_4
π : ι → Type u
f : (i : ι) → π i
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
hbot✝ : f ≠ ⊥
h : ∀ b < f, b = ⊥
i : ι
hbot : f i ≠ ⊥
⊢ ∀ b < f i, b = ⊥
case d
ι : Type u_4
π : ι → Type u
f : (i : ι) → π i
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
hbot✝ : f ≠ ⊥
h : ∀ b < f, b = ⊥
i : ι
hbot : f i ≠ ⊥
⊢ ∀ (j : ι), j ≠ i → f j = ⊥
|
case c =>
intro b hb
have := h (Function.update ⊥ i b)
simp only [lt_def, le_def, Pi.eq_bot_iff, and_imp, forall_exists_index] at this
simpa using this
(fun j => by by_cases h : j = i; { subst h; simpa using le_of_lt hb }; simp [h])
i (by simpa using hb) i
|
case d
ι : Type u_4
π : ι → Type u
f : (i : ι) → π i
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
hbot✝ : f ≠ ⊥
h : ∀ b < f, b = ⊥
i : ι
hbot : f i ≠ ⊥
⊢ ∀ (j : ι), j ≠ i → f j = ⊥
|
116210e72cdaa30b
|
Finset.card_div_choose_le_card_shadow_div_choose
|
Mathlib/Combinatorics/SetFamily/LYM.lean
|
theorem card_div_choose_le_card_shadow_div_choose (hr : r ≠ 0)
(h𝒜 : (𝒜 : Set (Finset α)).Sized r) : (#𝒜 : 𝕜) / (Fintype.card α).choose r
≤ #(∂ 𝒜) / (Fintype.card α).choose (r - 1)
|
case h.e'_4
𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
r : ℕ
hr : r + 1 ≠ 0
hr' : r + 1 ≤ Fintype.card α
h𝒜 : #𝒜 * (r + 1) ≤ #(∂ 𝒜) * (Fintype.card α - r)
⊢ #(∂ 𝒜) * (Fintype.card α).choose (r + 1) * (r + 1) = #(∂ 𝒜) * (Fintype.card α - r) * (Fintype.card α).choose r
|
simp only [mul_assoc, choose_succ_right_eq, mul_eq_mul_left_iff]
|
case h.e'_4
𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
r : ℕ
hr : r + 1 ≠ 0
hr' : r + 1 ≤ Fintype.card α
h𝒜 : #𝒜 * (r + 1) ≤ #(∂ 𝒜) * (Fintype.card α - r)
⊢ (Fintype.card α).choose r * (Fintype.card α - r) = (Fintype.card α - r) * (Fintype.card α).choose r ∨ #(∂ 𝒜) = 0
|
39fd5f73c0c4b048
|
MvPolynomial.constantCoeff_comp_C
|
Mathlib/Algebra/MvPolynomial/Basic.lean
|
theorem constantCoeff_comp_C : constantCoeff.comp (C : R →+* MvPolynomial σ R) = RingHom.id R
|
case a
R : Type u
σ : Type u_1
inst✝ : CommSemiring R
x : R
⊢ (constantCoeff.comp C) x = (RingHom.id R) x
|
exact constantCoeff_C σ x
|
no goals
|
30a8200202bcedbf
|
Vector.pmap_pmap
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Attach.lean
|
theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f : ∀ b, q b → γ) (l : Vector α n) (H₁ H₂) :
pmap f (pmap g l H₁) H₂ =
pmap (α := { x // x ∈ l }) (fun a h => f (g a h) (H₂ (g a h) (mem_pmap_of_mem a.2))) l.attach
(fun a _ => H₁ a a.2)
|
α : Type u_1
β : Type u_2
γ : Type u_3
n : Nat
p : α → Prop
q : β → Prop
g : (a : α) → p a → β
f : (b : β) → q b → γ
l : Vector α n
H₁ : ∀ (a : α), a ∈ l → p a
H₂ : ∀ (a : β), a ∈ pmap g l H₁ → q a
⊢ pmap f (pmap g l H₁) H₂ = pmap (fun a h => f (g a.val h) ⋯) l.attach ⋯
|
rcases l with ⟨l, rfl⟩
|
case mk
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
q : β → Prop
g : (a : α) → p a → β
f : (b : β) → q b → γ
l : Array α
H₁ : ∀ (a : α), a ∈ { toArray := l, size_toArray := ⋯ } → p a
H₂ : ∀ (a : β), a ∈ pmap g { toArray := l, size_toArray := ⋯ } H₁ → q a
⊢ pmap f (pmap g { toArray := l, size_toArray := ⋯ } H₁) H₂ =
pmap (fun a h => f (g a.val h) ⋯) { toArray := l, size_toArray := ⋯ }.attach ⋯
|
687567af1048eabd
|
BoxIntegral.Box.distortion_eq_of_sub_eq_div
|
Mathlib/Analysis/BoxIntegral/Box/Basic.lean
|
theorem distortion_eq_of_sub_eq_div {I J : Box ι} {r : ℝ}
(h : ∀ i, I.upper i - I.lower i = (J.upper i - J.lower i) / r) :
distortion I = distortion J
|
ι : Type u_1
inst✝ : Fintype ι
I J : Box ι
r : ℝ
h : ∀ (i : ι), I.upper i - I.lower i = (J.upper i - J.lower i) / r
i : ι
hr : ¬0 < r
⊢ False
|
have := div_nonpos_of_nonneg_of_nonpos (sub_nonneg.2 <| J.lower_le_upper i) (not_lt.1 hr)
|
ι : Type u_1
inst✝ : Fintype ι
I J : Box ι
r : ℝ
h : ∀ (i : ι), I.upper i - I.lower i = (J.upper i - J.lower i) / r
i : ι
hr : ¬0 < r
this : (J.upper i - J.lower i) / r ≤ 0
⊢ False
|
9a94211851805cc5
|
Orientation.oangle_eq_pi_iff_angle_eq_pi
|
Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
|
theorem oangle_eq_pi_iff_angle_eq_pi {x y : V} :
o.oangle x y = π ↔ InnerProductGeometry.angle x y = π
|
V : Type u_1
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
⊢ o.oangle x y = ↑π ↔ InnerProductGeometry.angle x y = π
|
by_cases hx : x = 0
|
case pos
V : Type u_1
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
hx : x = 0
⊢ o.oangle x y = ↑π ↔ InnerProductGeometry.angle x y = π
case neg
V : Type u_1
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
hx : ¬x = 0
⊢ o.oangle x y = ↑π ↔ InnerProductGeometry.angle x y = π
|
359e33c58bfa1ce6
|
RingHom.IsStableUnderBaseChange.mk
|
Mathlib/RingTheory/RingHomProperties.lean
|
theorem IsStableUnderBaseChange.mk (h₁ : RespectsIso @P)
(h₂ :
∀ ⦃R S T⦄ [CommRing R] [CommRing S] [CommRing T],
∀ [Algebra R S] [Algebra R T],
P (algebraMap R T) →
P (Algebra.TensorProduct.includeLeftRingHom : S →+* TensorProduct R S T)) :
IsStableUnderBaseChange @P
|
case e_a.H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
h₁ : RespectsIso P
h₂ :
∀ ⦃R S T : Type u⦄ [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] [inst_3 : Algebra R S]
[inst_4 : Algebra R T], P (algebraMap R T) → P Algebra.TensorProduct.includeLeftRingHom
R S R' S' : Type u
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : CommRing R'
inst✝⁷ : CommRing S'
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R R'
inst✝⁴ : Algebra R S'
inst✝³ : Algebra S S'
inst✝² : Algebra R' S'
inst✝¹ : IsScalarTower R S S'
inst✝ : IsScalarTower R R' S'
h : Algebra.IsPushout R S R' S'
H : P (algebraMap R S)
e : TensorProduct R R' S ≃ₛₗ[id R'] S' := ⋯.equiv
f' : TensorProduct R R' S →ₐ[R] S' :=
Algebra.TensorProduct.productMap (IsScalarTower.toAlgHom R R' S') (IsScalarTower.toAlgHom R S S')
x✝ : TensorProduct R R' S
x : R'
y : S
⊢ (↑R ↑e) (x ⊗ₜ[R] y) = f'.toLinearMap (x ⊗ₜ[R] y)
|
simp [e, f', IsBaseChange.equiv_tmul, Algebra.smul_def]
|
no goals
|
b9f11fd814b95109
|
Finset.noncommProd_induction
|
Mathlib/Data/Finset/NoncommProd.lean
|
@[to_additive]
lemma noncommProd_induction (s : Finset α) (f : α → β) (comm)
(p : β → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p (f x)) :
p (s.noncommProd f comm)
|
α : Type u_3
β : Type u_4
inst✝ : Monoid β
s : Finset α
f : α → β
comm : (↑s).Pairwise (Commute on f)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
b : β
hb : b ∈ Multiset.map f s.val
⊢ ?m.19078
|
simpa using hb
|
no goals
|
a8fc2db953f6e503
|
MvPowerSeries.le_lexOrder_iff
|
Mathlib/RingTheory/MvPowerSeries/LexOrder.lean
|
theorem le_lexOrder_iff {φ : MvPowerSeries σ R} {w : WithTop (Lex (σ →₀ ℕ))} :
w ≤ lexOrder φ ↔ (∀ (d : σ →₀ ℕ) (_ : toLex d < w), coeff R d φ = 0)
|
case mp
σ : Type u_1
R : Type u_2
inst✝² : Semiring R
inst✝¹ : LinearOrder σ
inst✝ : WellFoundedGT σ
φ : MvPowerSeries σ R
w : WithTop (Lex (σ →₀ ℕ))
h : w ≤ φ.lexOrder
d : σ →₀ ℕ
hd : ↑(toLex d) < w
⊢ (coeff R d) φ = 0
|
apply coeff_eq_zero_of_lt_lexOrder
|
case mp.h
σ : Type u_1
R : Type u_2
inst✝² : Semiring R
inst✝¹ : LinearOrder σ
inst✝ : WellFoundedGT σ
φ : MvPowerSeries σ R
w : WithTop (Lex (σ →₀ ℕ))
h : w ≤ φ.lexOrder
d : σ →₀ ℕ
hd : ↑(toLex d) < w
⊢ ↑(toLex d) < φ.lexOrder
|
d7714d2e3d7a9ca5
|
FirstOrder.Language.LHom.id_onBoundedFormula
|
Mathlib/ModelTheory/Syntax.lean
|
theorem id_onBoundedFormula :
((LHom.id L).onBoundedFormula : L.BoundedFormula α n → L.BoundedFormula α n) = id
|
case h.falsum
L : Language
α : Type u'
n n✝ : ℕ
⊢ (LHom.id L).onBoundedFormula falsum = id falsum
|
rfl
|
no goals
|
b7ef961ddafe7473
|
FirstOrder.Language.PartialEquiv.le_iff
|
Mathlib/ModelTheory/PartialEquiv.lean
|
theorem le_iff {f g : M ≃ₚ[L] N} : f ≤ g ↔
∃ dom_le_dom : f.dom ≤ g.dom,
∃ cod_le_cod : f.cod ≤ g.cod,
∀ x, inclusion cod_le_cod (f.toEquiv x) = g.toEquiv (inclusion dom_le_dom x)
|
case mpr.intro.intro
L : Language
M : Type w
N : Type w'
inst✝¹ : L.Structure M
inst✝ : L.Structure N
f g : M ≃ₚ[L] N
dom_le_dom : f.dom ≤ g.dom
le_cod : f.cod ≤ g.cod
h_eq : ∀ (x : ↥f.dom), (inclusion le_cod) (f.toEquiv x) = g.toEquiv ((inclusion dom_le_dom) x)
⊢ f ≤ g
|
rw [le_def]
|
case mpr.intro.intro
L : Language
M : Type w
N : Type w'
inst✝¹ : L.Structure M
inst✝ : L.Structure N
f g : M ≃ₚ[L] N
dom_le_dom : f.dom ≤ g.dom
le_cod : f.cod ≤ g.cod
h_eq : ∀ (x : ↥f.dom), (inclusion le_cod) (f.toEquiv x) = g.toEquiv ((inclusion dom_le_dom) x)
⊢ ∃ (h : f.dom ≤ g.dom),
g.cod.subtype.comp (g.toEquiv.toEmbedding.comp (inclusion h)) = f.cod.subtype.comp f.toEquiv.toEmbedding
|
1bd2616433ae1fcd
|
EuclideanGeometry.Sphere.IsDiameter.right_eq_of_isDiameter
|
Mathlib/Geometry/Euclidean/Sphere/Basic.lean
|
lemma IsDiameter.right_eq_of_isDiameter (h₁₂ : s.IsDiameter p₁ p₂) (h₁₃ : s.IsDiameter p₁ p₃) :
p₂ = p₃
|
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p₁ p₂ p₃ : P
h₁₂ : s.IsDiameter p₁ p₂
h₁₃ : s.IsDiameter p₁ p₃
⊢ p₂ = p₃
|
rw [← h₁₂.pointReflection_center_left, ← h₁₃.pointReflection_center_left]
|
no goals
|
e0458f14bbfc85eb
|
Ordinal.principal_add_iff_zero_or_omega0_opow
|
Mathlib/SetTheory/Ordinal/Principal.lean
|
theorem principal_add_iff_zero_or_omega0_opow :
Principal (· + ·) o ↔ o = 0 ∨ o ∈ Set.range (ω ^ · : Ordinal → Ordinal)
|
o : Ordinal.{u}
⊢ Principal (fun x1 x2 => x1 + x2) o ↔ o = 0 ∨ o ∈ Set.range fun x => ω ^ x
|
rcases eq_or_ne o 0 with (rfl | ho)
|
case inl
⊢ Principal (fun x1 x2 => x1 + x2) 0 ↔ 0 = 0 ∨ 0 ∈ Set.range fun x => ω ^ x
case inr
o : Ordinal.{u}
ho : o ≠ 0
⊢ Principal (fun x1 x2 => x1 + x2) o ↔ o = 0 ∨ o ∈ Set.range fun x => ω ^ x
|
b95345052c5b9163
|
Ordinal.toPGame_nmul
|
Mathlib/SetTheory/Game/Ordinal.lean
|
theorem toPGame_nmul (a b : Ordinal) : (a ⨳ b).toPGame ≈ a.toPGame * b.toPGame
|
case refine_1
a b : Ordinal.{u_1}
i : (a ⨳ b).toPGame.LeftMoves
⊢ (↑(toLeftMovesToPGame.symm i)).toPGame ⧏ a.toPGame * b.toPGame
|
rcases lt_nmul_iff.1 (toLeftMovesToPGame_symm_lt i) with ⟨c, hc, d, hd, h⟩
|
case refine_1.intro.intro.intro.intro
a b : Ordinal.{u_1}
i : (a ⨳ b).toPGame.LeftMoves
c : Ordinal.{u_1}
hc : c < a
d : Ordinal.{u_1}
hd : d < b
h : ↑(toLeftMovesToPGame.symm i) ♯ c ⨳ d ≤ c ⨳ b ♯ a ⨳ d
⊢ (↑(toLeftMovesToPGame.symm i)).toPGame ⧏ a.toPGame * b.toPGame
|
18382d4f22ac2836
|
Array.mapIdx_eq_push_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/MapIdx.lean
|
theorem mapIdx_eq_push_iff {l : Array α} {b : β} :
mapIdx f l = l₂.push b ↔
∃ (a : α) (l₁ : Array α), l = l₁.push a ∧ mapIdx f l₁ = l₂ ∧ f l₁.size a = b
|
case mp.intro.intro.intro.intro
α : Type u_1
β : Type u_2
f : Nat → α → β
l₁ : Array α
a : α
⊢ ∃ a_1 l₁_1, l₁.push a = l₁_1.push a_1 ∧ mapIdx f l₁_1 = mapIdx f l₁ ∧ f l₁_1.size a_1 = f ((l₁.push a).size - 1) a
|
exact ⟨a, l₁, by simp⟩
|
no goals
|
5f03d0e423345ad8
|
dNext_eq
|
Mathlib/Algebra/Homology/Homotopy.lean
|
theorem dNext_eq (f : ∀ i j, C.X i ⟶ D.X j) {i i' : ι} (w : c.Rel i i') :
dNext i f = C.d i i' ≫ f i' i
|
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D : HomologicalComplex V c
f : (i j : ι) → C.X i ⟶ D.X j
i i' : ι
w : c.Rel i i'
⊢ (dNext i) f = C.d i i' ≫ f i' i
|
obtain rfl := c.next_eq' w
|
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D : HomologicalComplex V c
f : (i j : ι) → C.X i ⟶ D.X j
i : ι
w : c.Rel i (c.next i)
⊢ (dNext i) f = C.d i (c.next i) ≫ f (c.next i) i
|
aa5efb47a07158b2
|
Module.FinitePresentation.fg_ker
|
Mathlib/Algebra/Module/FinitePresentation.lean
|
lemma Module.FinitePresentation.fg_ker [Module.Finite R M]
[h : Module.FinitePresentation R N] (l : M →ₗ[R] N) (hl : Function.Surjective l) :
(LinearMap.ker l).FG
|
case intro.intro
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R M
l : M →ₗ[R] N
hl : Function.Surjective ⇑l
s : Finset N
hs : Submodule.span R ↑s = ⊤
hs' : (LinearMap.ker (linearCombination R Subtype.val)).FG
H : Function.Surjective ⇑(linearCombination R Subtype.val)
f : ({ x // x ∈ s } →₀ R) →ₗ[R] M
hf : l ∘ₗ f = linearCombination R Subtype.val
x : M
y : { x // x ∈ s } →₀ R
hy : (linearCombination R Subtype.val) y = l x
⊢ (LinearMap.range f).mkQ x ∈ Submodule.map (LinearMap.range f).mkQ (LinearMap.ker l)
|
rw [← hf, LinearMap.comp_apply, eq_comm, ← sub_eq_zero, ← map_sub] at hy
|
case intro.intro
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R M
l : M →ₗ[R] N
hl : Function.Surjective ⇑l
s : Finset N
hs : Submodule.span R ↑s = ⊤
hs' : (LinearMap.ker (linearCombination R Subtype.val)).FG
H : Function.Surjective ⇑(linearCombination R Subtype.val)
f : ({ x // x ∈ s } →₀ R) →ₗ[R] M
hf : l ∘ₗ f = linearCombination R Subtype.val
x : M
y : { x // x ∈ s } →₀ R
hy : l (x - f y) = 0
⊢ (LinearMap.range f).mkQ x ∈ Submodule.map (LinearMap.range f).mkQ (LinearMap.ker l)
|
1eeff1d09d79515c
|
Bool.forall_bool'
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Bool.lean
|
theorem forall_bool' {p : Bool → Prop} (b : Bool) : (∀ x, p x) ↔ p b ∧ p !b :=
⟨fun h ↦ ⟨h _, h _⟩, fun ⟨h₁, h₂⟩ x ↦ by cases b <;> cases x <;> assumption⟩
|
p : Bool → Prop
b : Bool
x✝ : p b ∧ p !b
x : Bool
h₁ : p b
h₂ : p !b
⊢ p x
|
cases b <;> cases x <;> assumption
|
no goals
|
6b5e0c30f3648560
|
Order.height_coe_withTop
|
Mathlib/Order/KrullDimension.lean
|
@[simp] lemma height_coe_withTop (x : α) : height (x : WithTop α) = height x
|
case a.h
α : Type u_1
inst✝ : Preorder α
x : α
p : LTSeries α
hlast : RelSeries.last p = x
p' : LTSeries (WithTop α) := p.map (fun a => ↑a) ⋯
⊢ ↑p.length ≤ height ↑x
|
apply le_iSup₂_of_le p' (by simp [p', hlast]) (by simp [p'])
|
no goals
|
8eed977c64e112ed
|
EuclideanGeometry.collinear_iff_of_two_zsmul_oangle_eq
|
Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
|
theorem collinear_iff_of_two_zsmul_oangle_eq {p₁ p₂ p₃ p₄ p₅ p₆ : P}
(h : (2 : ℤ) • ∡ p₁ p₂ p₃ = (2 : ℤ) • ∡ p₄ p₅ p₆) :
Collinear ℝ ({p₁, p₂, p₃} : Set P) ↔ Collinear ℝ ({p₄, p₅, p₆} : Set P)
|
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Oriented ℝ V (Fin 2)
p₁ p₂ p₃ p₄ p₅ p₆ : P
h : 2 • ∡ p₁ p₂ p₃ = 2 • ∡ p₄ p₅ p₆
⊢ Collinear ℝ {p₁, p₂, p₃} ↔ Collinear ℝ {p₄, p₅, p₆}
|
simp_rw [← oangle_eq_zero_or_eq_pi_iff_collinear, ← Real.Angle.two_zsmul_eq_zero_iff, h]
|
no goals
|
28d314bc53c04be8
|
Sym2.lift_smul_lift
|
Mathlib/Data/Sym/Sym2.lean
|
lemma lift_smul_lift {α R N} [SMul R N] (f : { f : α → α → R // ∀ a₁ a₂, f a₁ a₂ = f a₂ a₁ })
(g : { g : α → α → N // ∀ a₁ a₂, g a₁ a₂ = g a₂ a₁ }) :
lift f • lift g = lift ⟨f.val • g.val, fun _ _ => by
rw [Pi.smul_apply', Pi.smul_apply', Pi.smul_apply', Pi.smul_apply', f.prop, g.prop]⟩
|
case h.mk.mk
α : Type u_4
R : Type u_5
N : Type u_6
inst✝ : SMul R N
f : { f // ∀ (a₁ a₂ : α), f a₁ a₂ = f a₂ a₁ }
g : { g // ∀ (a₁ a₂ : α), g a₁ a₂ = g a₂ a₁ }
x✝ : Sym2 α
i j : α
⊢ (lift f • lift g) (Quot.mk (Rel α) (i, j)) = lift ⟨↑f • ↑g, ⋯⟩ (Quot.mk (Rel α) (i, j))
|
simp_all only [Pi.smul_apply', lift_mk]
|
no goals
|
e4b10c2d349e7a48
|
AkraBazziRecurrence.GrowsPolynomially.eventually_atTop_nonneg_or_nonpos
|
Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
|
lemma eventually_atTop_nonneg_or_nonpos (hf : GrowsPolynomially f) :
(∀ᶠ x in atTop, 0 ≤ f x) ∨ (∀ᶠ x in atTop, f x ≤ 0)
|
case h.h.ha
f : ℝ → ℝ
hf : GrowsPolynomially f
c₁ : ℝ
left✝¹ : c₁ > 0
c₂ : ℝ
left✝ : c₂ > 0
heq : c₁ = c₂
n₀ : ℝ
hn₀ : ∀ b ≥ n₀, ∀ u ∈ Set.Icc (1 / 2 * b) b, f u = c₂ * f b
n : ℕ
hn : n ≥ 1
hyp_ind : ∀ z ∈ Set.Ico (n₀ ⊔ 2) (2 ^ n * (n₀ ⊔ 2)), f z = f (n₀ ⊔ 2)
z : ℝ
hz : z ∈ Set.Ico (2 ^ n * (n₀ ⊔ 2)) (2 ^ (n + 1) * (n₀ ⊔ 2))
z_nonneg : 0 ≤ z
le_2n : n₀ ⊔ 2 ≤ 2 ^ n * (n₀ ⊔ 2)
n₀_le_z : n₀ ≤ z
fz_eq_c₂fz : f z = c₂ * f z
z_to_half_z' : f (1 / 2 * z) = c₂ * f z
z_to_half_z : f (1 / 2 * z) = f z
⊢ 1 ≤ 2
|
norm_num
|
no goals
|
69674f7264744f71
|
AlgebraicGeometry.eq_top_of_sigmaSpec_subset_of_isCompact
|
Mathlib/AlgebraicGeometry/PointsPi.lean
|
lemma eq_top_of_sigmaSpec_subset_of_isCompact
(U : (Spec (.of (Π i, R i))).Opens) (V : Set (Spec (.of (Π i, R i))))
(hV : ↑(sigmaSpec R).opensRange ⊆ V)
(hV' : IsCompact (X := Spec (.of (Π i, R i))) V)
(hVU : V ⊆ U) : U = ⊤
|
ι : Type u
R : ι → CommRingCat
U : (Spec (CommRingCat.of ((i : ι) → ↑(R i)))).Opens
V : Set ↑↑(Spec (CommRingCat.of ((i : ι) → ↑(R i)))).toPresheafedSpace
hV : ↑(Scheme.Hom.opensRange (sigmaSpec R)) ⊆ V
hV' : IsCompact V
hVU : V ⊆ ↑U
s : Set ↑(CommRingCat.of ((i : ι) → ↑(R i)))
hs : U.carrierᶜ = zeroLocus s
t : Finset ↑s
ht : V ⊆ ⋃ i ∈ t, (basicOpen ↑i).carrier
⊢ V ⊆ ⋃ i ∈ ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) t), (basicOpen i).carrier
|
simpa using ht
|
no goals
|
016c4327c8b84e91
|
Set.exists_ne_of_one_lt_ncard
|
Mathlib/Data/Set/Card.lean
|
theorem exists_ne_of_one_lt_ncard (hs : 1 < s.ncard) (a : α) : ∃ b, b ∈ s ∧ b ≠ a
|
α : Type u_1
s : Set α
hs : 1 < s.ncard
a : α
hsf : s.Finite
⊢ ∃ b ∈ s, b ≠ a
|
rw [ncard_eq_toFinset_card _ hsf] at hs
|
α : Type u_1
s : Set α
a : α
hsf : s.Finite
hs : 1 < hsf.toFinset.card
⊢ ∃ b ∈ s, b ≠ a
|
d76822e87c887b17
|
smul_inv₀
|
Mathlib/Algebra/SMulWithZero.lean
|
theorem smul_inv₀ [SMulCommClass α β β] [IsScalarTower α β β] (c : α) (x : β) :
(c • x)⁻¹ = c⁻¹ • x⁻¹
|
case inr
α : Type u_5
β : Type u_6
inst✝⁴ : GroupWithZero α
inst✝³ : GroupWithZero β
inst✝² : MulActionWithZero α β
inst✝¹ : SMulCommClass α β β
inst✝ : IsScalarTower α β β
c : α
x : β
hc : c ≠ 0
⊢ (c • x)⁻¹ = c⁻¹ • x⁻¹
|
obtain rfl | hx := eq_or_ne x 0
|
case inr.inl
α : Type u_5
β : Type u_6
inst✝⁴ : GroupWithZero α
inst✝³ : GroupWithZero β
inst✝² : MulActionWithZero α β
inst✝¹ : SMulCommClass α β β
inst✝ : IsScalarTower α β β
c : α
hc : c ≠ 0
⊢ (c • 0)⁻¹ = c⁻¹ • 0⁻¹
case inr.inr
α : Type u_5
β : Type u_6
inst✝⁴ : GroupWithZero α
inst✝³ : GroupWithZero β
inst✝² : MulActionWithZero α β
inst✝¹ : SMulCommClass α β β
inst✝ : IsScalarTower α β β
c : α
x : β
hc : c ≠ 0
hx : x ≠ 0
⊢ (c • x)⁻¹ = c⁻¹ • x⁻¹
|
997ac284dc50742e
|
Finpartition.nonUniforms_bot
|
Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
|
theorem nonUniforms_bot (hε : 0 < ε) : (⊥ : Finpartition A).nonUniforms G ε = ∅
|
α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
⊢ ∀ (x : Finset α × Finset α), x ∉ ⊥.nonUniforms G ε
|
rintro ⟨u, v⟩
|
case mk
α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
u v : Finset α
⊢ (u, v) ∉ ⊥.nonUniforms G ε
|
0385a92f32889451
|
Polynomial.cyclotomic_dvd_geom_sum_of_dvd
|
Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
|
theorem cyclotomic_dvd_geom_sum_of_dvd (R) [Ring R] {d n : ℕ} (hdn : d ∣ n) (hd : d ≠ 1) :
cyclotomic d R ∣ ∑ i ∈ Finset.range n, X ^ i
|
case inr
R : Type u_1
inst✝ : Ring R
d n : ℕ
hdn : d ∣ n
hd : d ≠ 1
hn : n > 0
⊢ cyclotomic d ℤ ∣ ∏ i ∈ n.divisors.erase 1, cyclotomic i ℤ
|
apply Finset.dvd_prod_of_mem
|
case inr.ha
R : Type u_1
inst✝ : Ring R
d n : ℕ
hdn : d ∣ n
hd : d ≠ 1
hn : n > 0
⊢ d ∈ n.divisors.erase 1
|
059a49207424e859
|
Nat.Linear.Poly.denote_le_cancelAux
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
|
theorem Poly.denote_le_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
(h : denote_le ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂)) : denote_le ctx (cancelAux fuel m₁ m₂ r₁ r₂)
|
case succ
ctx : Context
fuel : Nat
ih :
∀ (m₁ m₂ r₁ r₂ : Poly),
denote_le ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂) → denote_le ctx (cancelAux fuel m₁ m₂ r₁ r₂)
m₁ m₂ r₁ r₂ : Poly
h : denote_le ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂)
⊢ denote_le ctx
(match m₁, m₂ with
| m₁, [] => (List.reverse r₁ ++ m₁, List.reverse r₂)
| [], m₂ => (List.reverse r₁, List.reverse r₂ ++ m₂)
| (k₁, v₁) :: m₁, (k₂, v₂) :: m₂ =>
bif blt v₁ v₂ then cancelAux fuel m₁ ((k₂, v₂) :: m₂) ((k₁, v₁) :: r₁) r₂
else
bif blt v₂ v₁ then cancelAux fuel ((k₁, v₁) :: m₁) m₂ r₁ ((k₂, v₂) :: r₂)
else
bif k₁.blt k₂ then cancelAux fuel m₁ m₂ r₁ ((k₂ - k₁, v₁) :: r₂)
else bif k₂.blt k₁ then cancelAux fuel m₁ m₂ ((k₁ - k₂, v₁) :: r₁) r₂ else cancelAux fuel m₁ m₂ r₁ r₂)
|
split <;> try (simp at h; assumption)
|
case succ.h_3
ctx : Context
fuel : Nat
ih :
∀ (m₁ m₂ r₁ r₂ : Poly),
denote_le ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂) → denote_le ctx (cancelAux fuel m₁ m₂ r₁ r₂)
r₁ r₂ m₁✝¹ m₂✝¹ : Poly
k₁✝ : Nat
v₁✝ : Var
m₁✝ : List (Nat × Var)
k₂✝ : Nat
v₂✝ : Var
m₂✝ : List (Nat × Var)
h : denote_le ctx (List.reverse r₁ ++ (k₁✝, v₁✝) :: m₁✝, List.reverse r₂ ++ (k₂✝, v₂✝) :: m₂✝)
⊢ denote_le ctx
(bif blt v₁✝ v₂✝ then cancelAux fuel m₁✝ ((k₂✝, v₂✝) :: m₂✝) ((k₁✝, v₁✝) :: r₁) r₂
else
bif blt v₂✝ v₁✝ then cancelAux fuel ((k₁✝, v₁✝) :: m₁✝) m₂✝ r₁ ((k₂✝, v₂✝) :: r₂)
else
bif k₁✝.blt k₂✝ then cancelAux fuel m₁✝ m₂✝ r₁ ((k₂✝ - k₁✝, v₁✝) :: r₂)
else bif k₂✝.blt k₁✝ then cancelAux fuel m₁✝ m₂✝ ((k₁✝ - k₂✝, v₁✝) :: r₁) r₂ else cancelAux fuel m₁✝ m₂✝ r₁ r₂)
|
ad8a8aef5a5a602f
|
eq_separableClosure_iff
|
Mathlib/FieldTheory/PurelyInseparable/Basic.lean
|
theorem eq_separableClosure_iff [Algebra.IsAlgebraic F E] (L : IntermediateField F E) :
L = separableClosure F E ↔ Algebra.IsSeparable F L ∧ IsPurelyInseparable L E :=
⟨by rintro rfl; exact ⟨isSeparable F E, isPurelyInseparable F E⟩,
fun ⟨_, _⟩ ↦ eq_separableClosure F E L⟩
|
F : Type u
E : Type v
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Algebra.IsAlgebraic F E
L : IntermediateField F E
⊢ L = separableClosure F E → Algebra.IsSeparable F ↥L ∧ IsPurelyInseparable (↥L) E
|
rintro rfl
|
F : Type u
E : Type v
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Algebra.IsAlgebraic F E
⊢ Algebra.IsSeparable F ↥(separableClosure F E) ∧ IsPurelyInseparable (↥(separableClosure F E)) E
|
8e041315e77074e0
|
BitVec.getLsbD_shiftLeftZeroExtend
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem getLsbD_shiftLeftZeroExtend (x : BitVec m) (n : Nat) :
getLsbD (shiftLeftZeroExtend x n) i = ((! decide (i < n)) && getLsbD x (i - n))
|
m i : Nat
x : BitVec m
n : Nat
⊢ (x.shiftLeftZeroExtend n).getLsbD i = (!decide (i < n) && x.getLsbD (i - n))
|
rw [shiftLeftZeroExtend_eq]
|
m i : Nat
x : BitVec m
n : Nat
⊢ (setWidth (m + n) x <<< n).getLsbD i = (!decide (i < n) && x.getLsbD (i - n))
|
fe225d2df00e0016
|
Array.any_eq_false'
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem any_eq_false' {p : α → Bool} {as : Array α} :
as.any p = false ↔ ∀ x, x ∈ as → ¬p x
|
α : Type u_1
p : α → Bool
as : Array α
⊢ (¬∃ x, x ∈ as ∧ p x = true) ↔ ∀ (x : α), x ∈ as → ¬p x = true
|
simp
|
no goals
|
7eaf041ddd6bd15a
|
Nat.Partrec.Code.hG
|
Mathlib/Computability/PartrecCode.lean
|
theorem hG : Primrec G
|
case hpr
a : Primrec fun a => ofNat (ℕ × Code) a.length
k✝ : Primrec fun a => (ofNat (ℕ × Code) a.1.length).1
n✝ : Primrec Prod.snd
k : Primrec fun a => (ofNat (ℕ × Code) a.1.1.length).1
n : Primrec fun a => a.1.2
k' : Primrec Prod.snd
c : Primrec fun a => (ofNat (ℕ × Code) a.1.1.length).2
⊢ Primrec fun a => do
let x ← Nat.Partrec.Code.lup a.1.1.1 ((ofNat (ℕ × Code) a.1.1.1.length).1, a.2.1) a.1.1.2
let y ← Nat.Partrec.Code.lup a.1.1.1 ((ofNat (ℕ × Code) a.1.1.1.length).1, a.2.2.1) a.1.1.2
some (Nat.pair x y)
|
have L := (Primrec.fst.comp Primrec.fst).comp
(Primrec.fst (α := (List (List (Option ℕ)) × ℕ) × ℕ)
(β := Code × Code × Option ℕ × Option ℕ))
|
case hpr
a : Primrec fun a => ofNat (ℕ × Code) a.length
k✝ : Primrec fun a => (ofNat (ℕ × Code) a.1.length).1
n✝ : Primrec Prod.snd
k : Primrec fun a => (ofNat (ℕ × Code) a.1.1.length).1
n : Primrec fun a => a.1.2
k' : Primrec Prod.snd
c : Primrec fun a => (ofNat (ℕ × Code) a.1.1.length).2
L : Primrec fun a => a.1.1.1
⊢ Primrec fun a => do
let x ← Nat.Partrec.Code.lup a.1.1.1 ((ofNat (ℕ × Code) a.1.1.1.length).1, a.2.1) a.1.1.2
let y ← Nat.Partrec.Code.lup a.1.1.1 ((ofNat (ℕ × Code) a.1.1.1.length).1, a.2.2.1) a.1.1.2
some (Nat.pair x y)
|
4867ddf124efd4e0
|
EReal.nhdsWithin_bot
|
Mathlib/Topology/Instances/EReal/Lemmas.lean
|
lemma nhdsWithin_bot : 𝓝[≠] (⊥ : EReal) = (atBot).map Real.toEReal
|
case neg.intro
x : ℝ
hx : ⊥ < ↑x
hx_top : ¬↑x = ⊤
⊢ ∃ i', Ioc ⊥ ↑i' ⊆ Iic ↑x ∩ {⊥}ᶜ
|
refine ⟨x, fun x ⟨h1, h2⟩ ↦ ?_⟩
|
case neg.intro
x✝¹ : ℝ
hx : ⊥ < ↑x✝¹
hx_top : ¬↑x✝¹ = ⊤
x : EReal
x✝ : x ∈ Ioc ⊥ ↑x✝¹
h1 : ⊥ < x
h2 : x ≤ ↑x✝¹
⊢ x ∈ Iic ↑x✝¹ ∩ {⊥}ᶜ
|
5f615563863ca2ef
|
emultiplicity_add_of_gt
|
Mathlib/RingTheory/Multiplicity.lean
|
theorem emultiplicity_add_of_gt {p a b : α} (h : emultiplicity p b < emultiplicity p a) :
emultiplicity p (a + b) = emultiplicity p b
|
α : Type u_1
inst✝ : Ring α
p a b : α
h : emultiplicity p b < emultiplicity p a
this : FiniteMultiplicity p b
⊢ emultiplicity p (a + b) = emultiplicity p b
|
rw [this.emultiplicity_eq_multiplicity] at *
|
α : Type u_1
inst✝ : Ring α
p a b : α
h : ↑(multiplicity p b) < emultiplicity p a
this : FiniteMultiplicity p b
⊢ emultiplicity p (a + b) = ↑(multiplicity p b)
|
0b0aa737ae8e63f5
|
EuclideanGeometry.eq_of_dist_eq_of_dist_eq_of_mem_of_finrank_eq_two
|
Mathlib/Geometry/Euclidean/Basic.lean
|
theorem eq_of_dist_eq_of_dist_eq_of_mem_of_finrank_eq_two {s : AffineSubspace ℝ P}
[FiniteDimensional ℝ s.direction] (hd : finrank ℝ s.direction = 2) {c₁ c₂ p₁ p₂ p : P}
(hc₁s : c₁ ∈ s) (hc₂s : c₂ ∈ s) (hp₁s : p₁ ∈ s) (hp₂s : p₂ ∈ s) (hps : p ∈ s) {r₁ r₂ : ℝ}
(hc : c₁ ≠ c₂) (hp : p₁ ≠ p₂) (hp₁c₁ : dist p₁ c₁ = r₁) (hp₂c₁ : dist p₂ c₁ = r₁)
(hpc₁ : dist p c₁ = r₁) (hp₁c₂ : dist p₁ c₂ = r₂) (hp₂c₂ : dist p₂ c₂ = r₂)
(hpc₂ : dist p c₂ = r₂) : p = p₁ ∨ p = p₂
|
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = 2
c₁ c₂ p₁ p₂ p : P
hc₁s : c₁ ∈ s
hc₂s : c₂ ∈ s
hp₁s : p₁ ∈ s
hp₂s : p₂ ∈ s
hps : p ∈ s
r₁ r₂ : ℝ
hc : c₁ ≠ c₂
hp : p₁ ≠ p₂
hp₁c₁ : dist p₁ c₁ = r₁
hp₂c₁ : dist p₂ c₁ = r₁
hpc₁ : dist p c₁ = r₁
hp₁c₂ : dist p₁ c₂ = r₂
hp₂c₂ : dist p₂ c₂ = r₂
hpc₂ : dist p c₂ = r₂
ho : inner (c₂ -ᵥ c₁) (p₂ -ᵥ p₁) = 0
hop : inner (c₂ -ᵥ c₁) (p -ᵥ p₁) = 0
b : Fin 2 → V := ![c₂ -ᵥ c₁, p₂ -ᵥ p₁]
hb : LinearIndependent ℝ b
hbs : Submodule.span ℝ (Set.range b) = s.direction
v : V
hv : v ∈ s.direction
hu : Finset.univ = {0, 1}
⊢ Set.range b = {c₂ -ᵥ c₁, p₂ -ᵥ p₁}
|
classical
rw [← Fintype.coe_image_univ, hu]
simp [b]
|
no goals
|
d020d573407e1b1f
|
Module.FinitePresentation.exists_lift_equiv_of_isLocalizedModule
|
Mathlib/Algebra/Module/FinitePresentation.lean
|
/--
Let `M` `N` be a finitely presented `R`-modules.
Any `Mₛ ≃ₗ[R] Nₛ` between the localizations at `S : Submonoid R` can be lifted to an
isomorphism between `Mᵣ ≃ₗ[R] Nᵣ` for some `r ∈ S`.
-/
lemma Module.FinitePresentation.exists_lift_equiv_of_isLocalizedModule
[Module.FinitePresentation R M] [Module.FinitePresentation R N]
(l : M' ≃ₗ[R] N') :
∃ (r : R) (hr : r ∈ S)
(l' : LocalizedModule (.powers r) M ≃ₗ[Localization (.powers r)]
LocalizedModule (.powers r) N),
(LocalizedModule.lift (.powers r) g fun s ↦ map_units g ⟨s.1, SetLike.le_def.mp
(Submonoid.powers_le.mpr hr) s.2⟩) ∘ₗ l'.toLinearMap =
l ∘ₗ (LocalizedModule.lift (.powers r) f fun s ↦ map_units f ⟨s.1, SetLike.le_def.mp
(Submonoid.powers_le.mpr hr) s.2⟩)
|
case intro.intro.intro.intro
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹² : CommRing R
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : Module R M
inst✝⁹ : AddCommGroup N
inst✝⁸ : Module R N
S : Submonoid R
M' : Type u_1
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
f : M →ₗ[R] M'
inst✝⁵ : IsLocalizedModule S f
N' : Type u_2
inst✝⁴ : AddCommGroup N'
inst✝³ : Module R N'
g : N →ₗ[R] N'
inst✝² : IsLocalizedModule S g
inst✝¹ : FinitePresentation R M
inst✝ : FinitePresentation R N
l : M' ≃ₗ[R] N'
l' : M →ₗ[R] N
s : ↥S
H : g ∘ₗ l' = s • ↑l ∘ₗ f
this : Function.Bijective ⇑((map S f g) l')
r : R
hr : r ∈ S
hr' : ∀ (t : R), r ∣ t → Function.Bijective ⇑((LocalizedModule.map (Submonoid.powers t)) l')
rs : Submonoid R := Submonoid.powers (r * ↑s)
Rᵣₛ : Type u_3 := Localization rs
⊢ ∃ r,
∃ (hr : r ∈ S),
∃ l',
LocalizedModule.lift (Submonoid.powers r) g ⋯ ∘ₗ ↑R ↑l' = ↑l ∘ₗ LocalizedModule.lift (Submonoid.powers r) f ⋯
|
have hsu : IsUnit (algebraMap R Rᵣₛ s) := isUnit_of_dvd_unit
(hu := IsLocalization.map_units (M := rs) Rᵣₛ ⟨_, Submonoid.mem_powers _⟩)
(map_dvd (algebraMap R Rᵣₛ) ⟨r, mul_comm _ _⟩)
|
case intro.intro.intro.intro
R : Type u_3
M : Type u_4
N : Type u_5
inst✝¹² : CommRing R
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : Module R M
inst✝⁹ : AddCommGroup N
inst✝⁸ : Module R N
S : Submonoid R
M' : Type u_1
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
f : M →ₗ[R] M'
inst✝⁵ : IsLocalizedModule S f
N' : Type u_2
inst✝⁴ : AddCommGroup N'
inst✝³ : Module R N'
g : N →ₗ[R] N'
inst✝² : IsLocalizedModule S g
inst✝¹ : FinitePresentation R M
inst✝ : FinitePresentation R N
l : M' ≃ₗ[R] N'
l' : M →ₗ[R] N
s : ↥S
H : g ∘ₗ l' = s • ↑l ∘ₗ f
this : Function.Bijective ⇑((map S f g) l')
r : R
hr : r ∈ S
hr' : ∀ (t : R), r ∣ t → Function.Bijective ⇑((LocalizedModule.map (Submonoid.powers t)) l')
rs : Submonoid R := Submonoid.powers (r * ↑s)
Rᵣₛ : Type u_3 := Localization rs
hsu : IsUnit ((algebraMap R Rᵣₛ) ↑s)
⊢ ∃ r,
∃ (hr : r ∈ S),
∃ l',
LocalizedModule.lift (Submonoid.powers r) g ⋯ ∘ₗ ↑R ↑l' = ↑l ∘ₗ LocalizedModule.lift (Submonoid.powers r) f ⋯
|
a097c231d57d7178
|
MulAction.disjoint_image_image_iff
|
Mathlib/GroupTheory/GroupAction/Defs.lean
|
theorem disjoint_image_image_iff {U V : Set α} :
letI := orbitRel G α
Disjoint (Quotient.mk' '' U) (Quotient.mk' '' V) ↔ ∀ x ∈ U, ∀ g : G, g • x ∉ V
|
case refine_2
G : Type u_1
α : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
U V : Set α
this : Setoid α := orbitRel G α
f : α → Quotient (orbitRel G α) := Quotient.mk'
⊢ (∀ x ∈ U, ∀ (g : G), g • x ∉ V) → Disjoint (f '' U) (f '' V)
|
intro h
|
case refine_2
G : Type u_1
α : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
U V : Set α
this : Setoid α := orbitRel G α
f : α → Quotient (orbitRel G α) := Quotient.mk'
h : ∀ x ∈ U, ∀ (g : G), g • x ∉ V
⊢ Disjoint (f '' U) (f '' V)
|
cd5f2363ba3b2a11
|
multiplicity_sub_of_gt
|
Mathlib/RingTheory/Multiplicity.lean
|
theorem multiplicity_sub_of_gt {p a b : α} (h : multiplicity p b < multiplicity p a)
(hfin : FiniteMultiplicity p b) : multiplicity p (a - b) = multiplicity p b
|
α : Type u_1
inst✝ : Ring α
p a b : α
h : multiplicity p b < multiplicity p a
hfin : FiniteMultiplicity p b
⊢ multiplicity p (a - b) = multiplicity p b
|
rw [sub_eq_add_neg, hfin.neg.multiplicity_add_of_gt] <;> rw [multiplicity_neg]
|
α : Type u_1
inst✝ : Ring α
p a b : α
h : multiplicity p b < multiplicity p a
hfin : FiniteMultiplicity p b
⊢ multiplicity p b < multiplicity p a
|
933befd822298c63
|
CategoryTheory.Triangulated.TStructure.exists_triangle
|
Mathlib/CategoryTheory/Triangulated/TStructure/Basic.lean
|
lemma exists_triangle (A : C) (n₀ n₁ : ℤ) (h : n₀ + 1 = n₁) :
∃ (X Y : C) (_ : t.le n₀ X) (_ : t.ge n₁ Y) (f : X ⟶ A) (g : A ⟶ Y)
(h : Y ⟶ X⟦(1 : ℤ)⟧), Triangle.mk f g h ∈ distTriang C
|
case refine_3
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
A : C
n₀ n₁ : ℤ
h✝ : n₀ + 1 = n₁
X Y : C
hX : t.le 0 X
hY : t.ge 1 Y
f : X ⟶ (shiftFunctor C n₀).obj A
g : (shiftFunctor C n₀).obj A ⟶ Y
h : Y ⟶ (shiftFunctor C 1).obj X
mem : Triangle.mk f g h ∈ distinguishedTriangles
T : Triangle C := (Triangle.shiftFunctor C (-n₀)).obj (Triangle.mk f g h)
e : ((shiftEquiv C n₀).functor ⋙ (shiftEquiv C n₀).inverse).obj A ≅ (𝟭 C).obj A := (shiftEquiv C n₀).unitIso.symm.app A
⊢ T.mor₃ ≫ (shiftFunctor C 1).map (𝟙 T.obj₁) =
𝟙 T.obj₃ ≫ ((-n₀).negOnePow • (shiftFunctor C (-n₀)).map h ≫ (shiftFunctorComm C 1 (-n₀)).hom.app X)
|
simp [T]
|
no goals
|
1024dfa167963c4d
|
NonAssocSemiring.ext
|
Mathlib/Algebra/Ring/Ext.lean
|
theorem ext ⦃inst₁ inst₂ : NonAssocSemiring 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
R : Type u
inst₂ : NonAssocSemiring R
toNonUnitalNonAssocSemiring✝ : NonUnitalNonAssocSemiring R
toOne✝ : One R
one_mul✝ : ∀ (a : R), 1 * a = a
mul_one✝ : ∀ (a : R), a * 1 = a
toNatCast✝ : NatCast R
natCast_zero✝ : NatCast.natCast 0 = 0
natCast_succ✝ : ∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
h : toNonUnitalNonAssocSemiring = toNonUnitalNonAssocSemiring
h_zero : Zero.zero = Zero.zero
h_one' : MulOneClass.toOne = MulOneClass.toOne
h_one : One.one = One.one
this✝ : toAddCommMonoidWithOne = toAddCommMonoidWithOne
this : toNatCast = toNatCast
⊢ mk one_mul✝ mul_one✝ natCast_zero✝ natCast_succ✝ = inst₂
|
cases inst₂
|
case mk.mk
R : Type u
toNonUnitalNonAssocSemiring✝¹ : NonUnitalNonAssocSemiring R
toOne✝¹ : One R
one_mul✝¹ : ∀ (a : R), 1 * a = a
mul_one✝¹ : ∀ (a : R), a * 1 = a
toNatCast✝¹ : NatCast R
natCast_zero✝¹ : NatCast.natCast 0 = 0
natCast_succ✝¹ : ∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1
toNonUnitalNonAssocSemiring✝ : NonUnitalNonAssocSemiring R
toOne✝ : One R
one_mul✝ : ∀ (a : R), 1 * a = a
mul_one✝ : ∀ (a : R), a * 1 = a
toNatCast✝ : NatCast R
natCast_zero✝ : NatCast.natCast 0 = 0
natCast_succ✝ : ∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
h : toNonUnitalNonAssocSemiring = toNonUnitalNonAssocSemiring
h_zero : Zero.zero = Zero.zero
h_one' : MulOneClass.toOne = MulOneClass.toOne
h_one : One.one = One.one
this✝ : toAddCommMonoidWithOne = toAddCommMonoidWithOne
this : toNatCast = toNatCast
⊢ mk one_mul✝¹ mul_one✝¹ natCast_zero✝¹ natCast_succ✝¹ = mk one_mul✝ mul_one✝ natCast_zero✝ natCast_succ✝
|
92f30e4f0a6c2ba5
|
FirstOrder.Language.LHom.comp_onBoundedFormula
|
Mathlib/ModelTheory/Syntax.lean
|
theorem comp_onBoundedFormula {L'' : Language} (φ : L' →ᴸ L'') (ψ : L →ᴸ L') :
((φ.comp ψ).onBoundedFormula : L.BoundedFormula α n → L''.BoundedFormula α n) =
φ.onBoundedFormula ∘ ψ.onBoundedFormula
|
case h
L : Language
L' : Language
α : Type u'
n : ℕ
L'' : Language
φ : L' →ᴸ L''
ψ : L →ᴸ L'
f : L.BoundedFormula α n
⊢ (φ.comp ψ).onBoundedFormula f = (φ.onBoundedFormula ∘ ψ.onBoundedFormula) f
|
induction f with
| falsum => rfl
| equal => simp [Term.bdEqual]
| rel => simp only [onBoundedFormula, comp_onRelation, comp_onTerm, Function.comp_apply]; rfl
| imp _ _ ih1 ih2 =>
simp only [onBoundedFormula, Function.comp_apply, ih1, ih2, eq_self_iff_true, and_self_iff]
| all _ ih3 => simp only [ih3, onBoundedFormula, Function.comp_apply]
|
no goals
|
b02807e179750b12
|
MeasureTheory.AEEqFun.coeFn_compQuasiMeasurePreserving
|
Mathlib/MeasureTheory/Function/AEEqFun.lean
|
theorem coeFn_compQuasiMeasurePreserving (g : β →ₘ[ν] γ) (hf : QuasiMeasurePreserving f μ ν) :
g.compQuasiMeasurePreserving f hf =ᵐ[μ] g ∘ f
|
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : MeasurableSpace α
μ : Measure α
inst✝¹ : TopologicalSpace γ
inst✝ : MeasurableSpace β
ν : Measure β
f : α → β
g : β →ₘ[ν] γ
hf : QuasiMeasurePreserving f μ ν
⊢ ↑(mk (↑g ∘ f) ⋯) =ᶠ[ae μ] ↑g ∘ f
|
apply coeFn_mk
|
no goals
|
c59f5e0d5f1d86dc
|
MeasureTheory.MemLp.exists_boundedContinuous_eLpNorm_sub_le
|
Mathlib/MeasureTheory/Function/ContinuousMapDense.lean
|
theorem MemLp.exists_boundedContinuous_eLpNorm_sub_le [μ.WeaklyRegular] (hp : p ≠ ∞) {f : α → E}
(hf : MemLp f p μ) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
∃ g : α →ᵇ E, eLpNorm (f - (g : α → E)) p μ ≤ ε ∧ MemLp g p μ
|
case intro.intro.intro.intro
α : Type u_1
inst✝⁶ : TopologicalSpace α
inst✝⁵ : NormalSpace α
inst✝⁴ : MeasurableSpace α
inst✝³ : BorelSpace α
E : Type u_2
inst✝² : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ E
inst✝ : μ.WeaklyRegular
hp : p ≠ ⊤
f : α → E
hf : MemLp f p μ
ε✝ : ℝ≥0∞
hε✝ : ε✝ ≠ 0
c : E
t : Set α
ht : MeasurableSet t
htμ : μ t < ⊤
ε : ℝ≥0∞
hε : ε ≠ 0
δ : ℝ≥0∞
δpos : 0 < δ
hδ :
∀ (f g : α → E),
AEStronglyMeasurable f μ →
AEStronglyMeasurable g μ → eLpNorm f p μ ≤ δ → eLpNorm g p μ ≤ δ → eLpNorm (f + g) p μ < ε
η : ℝ≥0
ηpos : 0 < η
hη : ∀ (s : Set α), μ s ≤ ↑η → eLpNorm (s.indicator fun _x => c) p μ ≤ δ
hη_pos' : 0 < ↑η
⊢ ∃ g, eLpNorm (g - t.indicator fun x => c) p μ ≤ ε ∧ Continuous g ∧ MemLp g p μ ∧ IsBounded (range g)
|
obtain ⟨s, st, s_closed, μs⟩ : ∃ s, s ⊆ t ∧ IsClosed s ∧ μ (t \ s) < η :=
ht.exists_isClosed_diff_lt htμ.ne hη_pos'.ne'
|
case intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝⁶ : TopologicalSpace α
inst✝⁵ : NormalSpace α
inst✝⁴ : MeasurableSpace α
inst✝³ : BorelSpace α
E : Type u_2
inst✝² : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ E
inst✝ : μ.WeaklyRegular
hp : p ≠ ⊤
f : α → E
hf : MemLp f p μ
ε✝ : ℝ≥0∞
hε✝ : ε✝ ≠ 0
c : E
t : Set α
ht : MeasurableSet t
htμ : μ t < ⊤
ε : ℝ≥0∞
hε : ε ≠ 0
δ : ℝ≥0∞
δpos : 0 < δ
hδ :
∀ (f g : α → E),
AEStronglyMeasurable f μ →
AEStronglyMeasurable g μ → eLpNorm f p μ ≤ δ → eLpNorm g p μ ≤ δ → eLpNorm (f + g) p μ < ε
η : ℝ≥0
ηpos : 0 < η
hη : ∀ (s : Set α), μ s ≤ ↑η → eLpNorm (s.indicator fun _x => c) p μ ≤ δ
hη_pos' : 0 < ↑η
s : Set α
st : s ⊆ t
s_closed : IsClosed s
μs : μ (t \ s) < ↑η
⊢ ∃ g, eLpNorm (g - t.indicator fun x => c) p μ ≤ ε ∧ Continuous g ∧ MemLp g p μ ∧ IsBounded (range g)
|
7e6196982c59c5fe
|
Polynomial.Chebyshev.S_eval_neg_two
|
Mathlib/RingTheory/Polynomial/Chebyshev.lean
|
theorem S_eval_neg_two (n : ℤ) : (S R n).eval (-2) = n.negOnePow * (n + 1)
|
case one
R : Type u_1
inst✝ : CommRing R
⊢ eval (-2) (S R 1) = ↑↑(Int.negOnePow 1) * (↑1 + 1)
|
simp
|
case one
R : Type u_1
inst✝ : CommRing R
⊢ -2 = -1 + -1
|
ed0948eda57a7e26
|
liminf_mul_le
|
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
lemma liminf_mul_le (h₁ : 0 ≤ᶠ[f] u) (h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u)
(h₃ : 0 ≤ᶠ[f] v) (h₄ : IsCoboundedUnder (fun x1 x2 ↦ x1 ≥ x2) f v) :
liminf (u * v) f ≤ (limsup u f) * liminf v f
|
ι : Type u_1
f : Filter ι
inst✝ : f.NeBot
u v : ι → ℝ
h₁ : 0 ≤ᶠ[f] u
h₂ : IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u
h₃ : 0 ≤ᶠ[f] v
h₄ : IsCoboundedUnder (fun x1 x2 => x1 ≥ x2) f v
h : IsCoboundedUnder (fun x1 x2 => x1 ≥ x2) f (u * v)
h' : IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f fun x => u x * v x
a : ℝ
a_u : a > limsup u f
b : ℝ
b_v : b > liminf v f
c : ℝ
c_ab : c > a * b
⊢ ∃ᶠ (a : ι) in f, (u * v) a < c
|
refine ((frequently_lt_of_liminf_lt h₄ b_v).and_eventually ((eventually_lt_of_limsup_lt a_u).and
(h₁.and h₃))).mono fun x ⟨x_v, x_u, u_0, v_0⟩ ↦ ?_
|
ι : Type u_1
f : Filter ι
inst✝ : f.NeBot
u v : ι → ℝ
h₁ : 0 ≤ᶠ[f] u
h₂ : IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u
h₃ : 0 ≤ᶠ[f] v
h₄ : IsCoboundedUnder (fun x1 x2 => x1 ≥ x2) f v
h : IsCoboundedUnder (fun x1 x2 => x1 ≥ x2) f (u * v)
h' : IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f fun x => u x * v x
a : ℝ
a_u : a > limsup u f
b : ℝ
b_v : b > liminf v f
c : ℝ
c_ab : c > a * b
x : ι
x✝ : v x < b ∧ u x < a ∧ 0 x ≤ u x ∧ 0 x ≤ v x
x_v : v x < b
x_u : u x < a
u_0 : 0 x ≤ u x
v_0 : 0 x ≤ v x
⊢ (u * v) x < c
|
caf48efa54f2ac3f
|
Associates.finite_factors
|
Mathlib/RingTheory/DedekindDomain/Factorization.lean
|
theorem Associates.finite_factors {I : Ideal R} (hI : I ≠ 0) :
∀ᶠ v : HeightOneSpectrum R in Filter.cofinite,
((Associates.mk v.asIdeal).count (Associates.mk I).factors : ℤ) = 0
|
case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDedekindDomain R
I : Ideal R
hI : I ≠ 0
v : HeightOneSpectrum R
⊢ v ∈ {v | ¬↑((Associates.mk v.asIdeal).count (Associates.mk I).factors) = 0} ↔ v ∈ {v | v.asIdeal ∣ I}
|
simp_rw [Int.natCast_eq_zero]
|
case h
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDedekindDomain R
I : Ideal R
hI : I ≠ 0
v : HeightOneSpectrum R
⊢ v ∈ {v | ¬(Associates.mk v.asIdeal).count (Associates.mk I).factors = 0} ↔ v ∈ {v | v.asIdeal ∣ I}
|
3ce74cb6fd43575e
|
CategoryTheory.comp_rightAdjointMate
|
Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
|
theorem comp_rightAdjointMate {X Y Z : C} [HasRightDual X] [HasRightDual Y] [HasRightDual Z]
{f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g)ᘁ = gᘁ ≫ fᘁ
|
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
X Y Z : C
inst✝² : HasRightDual X
inst✝¹ : HasRightDual Y
inst✝ : HasRightDual Z
f : X ⟶ Y
g : Y ⟶ Z
⊢ η_ Y Yᘁ ≫ Y ◁ ((ρ_ Yᘁ).inv ≫ Yᘁ ◁ η_ X Xᘁ ≫ Yᘁ ◁ f ▷ Xᘁ ≫ (α_ Yᘁ Y Xᘁ).inv ≫ ε_ Y Yᘁ ▷ Xᘁ ≫ (λ_ Xᘁ).hom) ≫ g ▷ Xᘁ =
𝟙 (𝟙_ C) ⊗≫ (η_ Y Yᘁ ▷ 𝟙_ C ≫ (Y ⊗ Yᘁ) ◁ η_ X Xᘁ) ⊗≫ Y ◁ Yᘁ ◁ f ▷ Xᘁ ⊗≫ Y ◁ ε_ Y Yᘁ ▷ Xᘁ ⊗≫ g ▷ Xᘁ ⊗≫ 𝟙 (Z ⊗ Xᘁ)
|
monoidal
|
no goals
|
9d45d24ba2271614
|
AbsoluteValue.exists_partition_int
|
Mathlib/NumberTheory/ClassNumber/AdmissibleAbs.lean
|
theorem exists_partition_int (n : ℕ) {ε : ℝ} (hε : 0 < ε) {b : ℤ} (hb : b ≠ 0) (A : Fin n → ℤ) :
∃ t : Fin n → Fin ⌈1 / ε⌉₊,
∀ i₀ i₁, t i₀ = t i₁ → ↑(abs (A i₁ % b - A i₀ % b)) < abs b • ε
|
case refine_2
n : ℕ
ε : ℝ
hε : 0 < ε
b : ℤ
hb : b ≠ 0
A : Fin n → ℤ
hb' : 0 < ↑|b|
hbε : 0 < |b| • ε
hfloor : ∀ (i : Fin n), 0 ≤ ⌊↑(A i % b) / |b| • ε⌋
i₀ i₁ : Fin n
hi✝¹ : (fun i => ⟨⌊↑(A i % b) / |b| • ε⌋.natAbs, ⋯⟩) i₀ = (fun i => ⟨⌊↑(A i % b) / |b| • ε⌋.natAbs, ⋯⟩) i₁
hi✝ : ⌊↑(A i₀ % b) / |b| • ε⌋ = ⌊↑(A i₁ % b) / |b| • ε⌋
hi : |↑(A i₀ % b) / |b| • ε - ↑(A i₁ % b) / |b| • ε| < 1
⊢ ↑|A i₁ % b - A i₀ % b| < |b| • ε
|
rw [abs_sub_comm, ← sub_div, abs_div, abs_of_nonneg hbε.le, div_lt_iff₀ hbε, one_mul] at hi
|
case refine_2
n : ℕ
ε : ℝ
hε : 0 < ε
b : ℤ
hb : b ≠ 0
A : Fin n → ℤ
hb' : 0 < ↑|b|
hbε : 0 < |b| • ε
hfloor : ∀ (i : Fin n), 0 ≤ ⌊↑(A i % b) / |b| • ε⌋
i₀ i₁ : Fin n
hi✝¹ : (fun i => ⟨⌊↑(A i % b) / |b| • ε⌋.natAbs, ⋯⟩) i₀ = (fun i => ⟨⌊↑(A i % b) / |b| • ε⌋.natAbs, ⋯⟩) i₁
hi✝ : ⌊↑(A i₀ % b) / |b| • ε⌋ = ⌊↑(A i₁ % b) / |b| • ε⌋
hi : |↑(A i₁ % b) - ↑(A i₀ % b)| < |b| • ε
⊢ ↑|A i₁ % b - A i₀ % b| < |b| • ε
|
b91f00c7ed7d0496
|
Ideal.exists_minimalPrimes_le
|
Mathlib/RingTheory/Ideal/MinimalPrime/Basic.lean
|
theorem Ideal.exists_minimalPrimes_le [J.IsPrime] (e : I ≤ J) : ∃ p ∈ I.minimalPrimes, p ≤ J
|
case ih.refine_2
R : Type u_1
inst✝¹ : CommSemiring R
I J : Ideal R
inst✝ : J.IsPrime
e : I ≤ J
S : Set (Ideal R)ᵒᵈ := {p | IsPrime p ∧ I ≤ OrderDual.ofDual p}
c : Set (Ideal R)
hc : c ⊆ S
hc' : IsChain (fun x1 x2 => x1 ≤ x2) c
J' : (Ideal R)ᵒᵈ
hJ' : J' ∈ c
⊢ ∀ z ∈ c, z ≤ OrderDual.toDual (sInf c)
|
rintro z hz
|
case ih.refine_2
R : Type u_1
inst✝¹ : CommSemiring R
I J : Ideal R
inst✝ : J.IsPrime
e : I ≤ J
S : Set (Ideal R)ᵒᵈ := {p | IsPrime p ∧ I ≤ OrderDual.ofDual p}
c : Set (Ideal R)
hc : c ⊆ S
hc' : IsChain (fun x1 x2 => x1 ≤ x2) c
J' : (Ideal R)ᵒᵈ
hJ' : J' ∈ c
z : (Ideal R)ᵒᵈ
hz : z ∈ c
⊢ z ≤ OrderDual.toDual (sInf c)
|
c1ef3455a9a6ac1a
|
star_div₀
|
Mathlib/Algebra/Star/Basic.lean
|
theorem star_div₀ [CommGroupWithZero R] [StarMul R] (x y : R) : star (x / y) = star x / star y
|
case a
R : Type u
inst✝¹ : CommGroupWithZero R
inst✝ : StarMul R
x y : R
⊢ op (star (x / y)) = op (star x / star y)
|
rw [division_def, op_div, mul_comm, star_mul, star_inv₀, op_mul, op_inv]
|
no goals
|
c770a63732011bf2
|
pow_sub_one_dvd_differentIdeal_aux
|
Mathlib/RingTheory/DedekindDomain/Different.lean
|
lemma pow_sub_one_dvd_differentIdeal_aux [IsFractionRing B L] [IsDedekindDomain A]
[NoZeroSMulDivisors A B] [Module.Finite A B]
{p : Ideal A} [p.IsMaximal] (P : Ideal B) {e : ℕ} (he : e ≠ 0) (hp : p ≠ ⊥)
(hP : P ^ e ∣ p.map (algebraMap A B)) : P ^ (e - 1) ∣ differentIdeal A B
|
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : FiniteDimensional K L
inst✝⁸ : Algebra.IsSeparable K L
inst✝⁷ : IsIntegralClosure B A L
inst✝⁶ : IsIntegrallyClosed A
inst✝⁵ : IsDedekindDomain B
inst✝⁴ : IsFractionRing B L
inst✝³ : IsDedekindDomain A
inst✝² : NoZeroSMulDivisors A B
inst✝¹ : Module.Finite A B
p : Ideal A
inst✝ : p.IsMaximal
P : Ideal B
e : ℕ
he : e ≠ 0
hp : p ≠ ⊥
hP : P ^ e ∣ Ideal.map (algebraMap A B) p
a : Ideal B
ha : Ideal.map (algebraMap A B) p = P ^ (e - 1) * a
hp' : ¬Ideal.map (algebraMap A B) p = ⊥
habot : a ≠ ⊥
hPbot : P ≠ ⊥
⊢ Ideal.map (algebraMap A B) p ∣ a ^ e
|
obtain ⟨b, hb⟩ := hP
|
case intro
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : FiniteDimensional K L
inst✝⁸ : Algebra.IsSeparable K L
inst✝⁷ : IsIntegralClosure B A L
inst✝⁶ : IsIntegrallyClosed A
inst✝⁵ : IsDedekindDomain B
inst✝⁴ : IsFractionRing B L
inst✝³ : IsDedekindDomain A
inst✝² : NoZeroSMulDivisors A B
inst✝¹ : Module.Finite A B
p : Ideal A
inst✝ : p.IsMaximal
P : Ideal B
e : ℕ
he : e ≠ 0
hp : p ≠ ⊥
a : Ideal B
ha : Ideal.map (algebraMap A B) p = P ^ (e - 1) * a
hp' : ¬Ideal.map (algebraMap A B) p = ⊥
habot : a ≠ ⊥
hPbot : P ≠ ⊥
b : Ideal B
hb : Ideal.map (algebraMap A B) p = P ^ e * b
⊢ Ideal.map (algebraMap A B) p ∣ a ^ e
|
18a0d9e4648de8c5
|
CategoryTheory.ShortComplex.exact_iff_epi
|
Mathlib/Algebra/Homology/ShortComplex/Exact.lean
|
lemma exact_iff_epi [HasZeroObject C] (hg : S.g = 0) :
S.Exact ↔ Epi S.f
|
case mp
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
S : ShortComplex C
inst✝ : HasZeroObject C
hg : S.g = 0
h : S.Exact
this : S.HasHomology
⊢ Epi S.f
|
simp only [exact_iff_isZero_homology] at h
|
case mp
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
S : ShortComplex C
inst✝ : HasZeroObject C
hg : S.g = 0
this : S.HasHomology
h : IsZero S.homology
⊢ Epi S.f
|
7032e0401db77092
|
LaurentSeries.exists_ratFunc_val_lt
|
Mathlib/RingTheory/LaurentSeries.lean
|
theorem exists_ratFunc_val_lt (f : K⸨X⸩) (γ : ℤₘ₀ˣ) :
∃ Q : RatFunc K, Valued.v (f - Q) < γ
|
K : Type u_2
inst✝ : Field K
f : K⸨X⸩
γ : ℤₘ₀ˣ
F : K⟦X⟧ := f.powerSeriesPart
hF : F = f.powerSeriesPart
⊢ ∃ Q, Valued.v (f - ↑Q) < ↑γ
|
by_cases ord_nonpos : f.order < 0
|
case pos
K : Type u_2
inst✝ : Field K
f : K⸨X⸩
γ : ℤₘ₀ˣ
F : K⟦X⟧ := f.powerSeriesPart
hF : F = f.powerSeriesPart
ord_nonpos : HahnSeries.order f < 0
⊢ ∃ Q, Valued.v (f - ↑Q) < ↑γ
case neg
K : Type u_2
inst✝ : Field K
f : K⸨X⸩
γ : ℤₘ₀ˣ
F : K⟦X⟧ := f.powerSeriesPart
hF : F = f.powerSeriesPart
ord_nonpos : ¬HahnSeries.order f < 0
⊢ ∃ Q, Valued.v (f - ↑Q) < ↑γ
|
cd30660ae57d9ba0
|
CategoryTheory.Sieve.overEquiv_pullback
|
Mathlib/CategoryTheory/Sites/Over.lean
|
lemma overEquiv_pullback {X : C} {Y₁ Y₂ : Over X} (f : Y₁ ⟶ Y₂) (S : Sieve Y₂) :
overEquiv _ (S.pullback f) = (overEquiv _ S).pullback f.left
|
case h.mpr.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X : C
Y₁ Y₂ : Over X
f : Y₁ ⟶ Y₂
S : Sieve Y₂
Z : C
g : Z ⟶ Y₁.left
W : Over X
a : W ⟶ Y₂
b : Z ⟶ W.left
h : S.arrows a
w : g ≫ f.left = b ≫ a.left
T : Over ((Functor.fromPUnit X).obj W.right) := Over.mk (b ≫ W.hom)
c : T ⟶ Y₁ := Over.homMk g ⋯
d : T ⟶ W := Over.homMk b ⋯
⊢ S.arrows (c ≫ f)
|
rw [show c ≫ f = d ≫ a by ext; exact w]
|
case h.mpr.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X : C
Y₁ Y₂ : Over X
f : Y₁ ⟶ Y₂
S : Sieve Y₂
Z : C
g : Z ⟶ Y₁.left
W : Over X
a : W ⟶ Y₂
b : Z ⟶ W.left
h : S.arrows a
w : g ≫ f.left = b ≫ a.left
T : Over ((Functor.fromPUnit X).obj W.right) := Over.mk (b ≫ W.hom)
c : T ⟶ Y₁ := Over.homMk g ⋯
d : T ⟶ W := Over.homMk b ⋯
⊢ S.arrows (d ≫ a)
|
7920ceaa92266301
|
Monoid.minOrder_eq_top
|
Mathlib/GroupTheory/Order/Min.lean
|
@[to_additive (attr := simp)]
lemma minOrder_eq_top : minOrder α = ⊤ ↔ IsTorsionFree α
|
α : Type u_1
inst✝ : Monoid α
⊢ minOrder α = ⊤ ↔ IsTorsionFree α
|
simp [minOrder, IsTorsionFree]
|
no goals
|
6ca97de145f5f933
|
blimsup_thickening_mul_ae_eq
|
Mathlib/MeasureTheory/Covering/LiminfLimsup.lean
|
theorem blimsup_thickening_mul_ae_eq (p : ℕ → Prop) (s : ℕ → Set α) {M : ℝ} (hM : 0 < M) (r : ℕ → ℝ)
(hr : Tendsto r atTop (𝓝 0)) :
(blimsup (fun i => thickening (M * r i) (s i)) atTop p : Set α) =ᵐ[μ]
(blimsup (fun i => thickening (r i) (s i)) atTop p : Set α)
|
α : Type u_1
inst✝⁵ : PseudoMetricSpace α
inst✝⁴ : SecondCountableTopology α
inst✝³ : MeasurableSpace α
inst✝² : BorelSpace α
μ : Measure α
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : IsUnifLocDoublingMeasure μ
p : ℕ → Prop
s : ℕ → Set α
M : ℝ
hM : 0 < M
r : ℕ → ℝ
hr : Tendsto r atTop (𝓝 0)
q : ℕ → Prop := fun i => p i ∧ 0 < r i
h₁ : blimsup (fun i => thickening (r i) (s i)) atTop p = blimsup (fun i => thickening (r i) (s i)) atTop q
h₂ : blimsup (fun i => thickening (M * r i) (s i)) atTop p = blimsup (fun i => thickening (M * r i) (s i)) atTop q
⊢ blimsup (fun i => thickening (M * r i) (s i)) atTop q =ᶠ[ae μ] blimsup (fun i => thickening (r i) (s i)) atTop q
|
exact blimsup_thickening_mul_ae_eq_aux μ q s hM r hr (Eventually.of_forall fun i hi => hi.2)
|
no goals
|
4c761ba1d6033096
|
TopologicalSpace.IsTopologicalBasis.open_eq_iUnion
|
Mathlib/Topology/Bases.lean
|
theorem IsTopologicalBasis.open_eq_iUnion {B : Set (Set α)} (hB : IsTopologicalBasis B) {u : Set α}
(ou : IsOpen u) : ∃ (β : Type u) (f : β → Set α), (u = ⋃ i, f i) ∧ ∀ i, f i ∈ B :=
⟨↥({ s ∈ B | s ⊆ u }), (↑), by
rw [← sUnion_eq_iUnion]
apply hB.open_eq_sUnion' ou, fun s => And.left s.2⟩
|
α : Type u
t : TopologicalSpace α
B : Set (Set α)
hB : IsTopologicalBasis B
u : Set α
ou : IsOpen u
⊢ u = ⋃ i, ↑i
|
rw [← sUnion_eq_iUnion]
|
α : Type u
t : TopologicalSpace α
B : Set (Set α)
hB : IsTopologicalBasis B
u : Set α
ou : IsOpen u
⊢ u = ⋃₀ {s | s ∈ B ∧ s ⊆ u}
|
c8cbda2582b5d56e
|
MeasureTheory.StronglyMeasurable.ae_eq_trim_of_stronglyMeasurable
|
Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
|
lemma ae_eq_trim_of_stronglyMeasurable (hm : m ≤ m₀) (hf : StronglyMeasurable[m] f)
(hg : StronglyMeasurable[m] g) (hfg : f =ᵐ[μ] g) : f =ᵐ[μ.trim hm] g
|
α : Type u_1
E : Type u_5
m m₀ : MeasurableSpace α
μ : Measure α
f g : α → E
inst✝¹ : TopologicalSpace E
inst✝ : MetrizableSpace E
hm : m ≤ m₀
hf : StronglyMeasurable f
hg : StronglyMeasurable g
hfg : f =ᶠ[ae μ] g
⊢ MeasurableSet {a | ¬f a = g a}
|
exact (hf.measurableSet_eq_fun hg).compl
|
no goals
|
9c7c552ff0f787dd
|
Metric.hausdorffDist_triangle
|
Mathlib/Topology/MetricSpace/HausdorffDistance.lean
|
theorem hausdorffDist_triangle (fin : hausdorffEdist s t ≠ ⊤) :
hausdorffDist s u ≤ hausdorffDist s t + hausdorffDist t u
|
α : Type u
inst✝ : PseudoMetricSpace α
s t u : Set α
fin : hausdorffEdist s t ≠ ⊤
h : ¬hausdorffEdist s u = ⊤
⊢ ¬hausdorffEdist t u = ⊤
|
rw [hausdorffEdist_comm] at fin
|
α : Type u
inst✝ : PseudoMetricSpace α
s t u : Set α
fin : hausdorffEdist t s ≠ ⊤
h : ¬hausdorffEdist s u = ⊤
⊢ ¬hausdorffEdist t u = ⊤
|
ed7585c050956a75
|
AdicCompletion.ofTensorProduct_iso
|
Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
|
private lemma ofTensorProduct_iso [Fintype ι] [IsNoetherianRing R] :
IsIso (ModuleCat.ofHom (ofTensorProduct I M))
|
case refine_3
R : Type u
inst✝⁴ : CommRing R
I : Ideal R
M : Type u
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type
f : (ι → R) →ₗ[R] M
hf : Function.Surjective ⇑f
inst✝¹ : Fintype ι
inst✝ : IsNoetherianRing R
⊢ IsIso (ModuleCat.ofHom 0)
|
apply Limits.isIso_of_isTerminal
<;> exact Limits.IsZero.isTerminal (ModuleCat.isZero_of_subsingleton _)
|
no goals
|
76224af4d5a35f57
|
PiNat.res_eq_res
|
Mathlib/Topology/MetricSpace/PiNat.lean
|
theorem res_eq_res {x y : ℕ → α} {n : ℕ} :
res x n = res y n ↔ ∀ ⦃m⦄, m < n → x m = y m
|
case mpr.zero
α : Type u_2
x y : ℕ → α
h : ∀ ⦃m : ℕ⦄, m < 0 → x m = y m
⊢ res x 0 = res y 0
|
simp
|
no goals
|
4a51f6885772b8d7
|
CategoryTheory.SmallObject.SuccStruct.ofCocone.map_comp
|
Mathlib/CategoryTheory/SmallObject/Iteration/FunctorOfCocone.lean
|
lemma map_comp (i₁ i₂ i₃ : J) (hi : i₁ ≤ i₂) (hi' : i₂ ≤ i₃) (hi₃ : i₃ ≤ j) :
map c i₁ i₃ (hi.trans hi') hi₃ =
map c i₁ i₂ hi (hi'.trans hi₃) ≫
map c i₂ i₃ hi' hi₃
|
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
J : Type u
inst✝ : LinearOrder J
j : J
F : ↑(Set.Iio j) ⥤ C
c : Cocone F
i₁ i₂ i₃ : J
hi : i₁ ≤ i₂
hi' : i₂ ≤ i₃
hi₃ : i₃ ≤ j
⊢ map c i₁ i₃ ⋯ hi₃ = map c i₁ i₂ hi ⋯ ≫ map c i₂ i₃ hi' hi₃
|
obtain hi₁₂ | rfl := hi.lt_or_eq
|
case inl
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
J : Type u
inst✝ : LinearOrder J
j : J
F : ↑(Set.Iio j) ⥤ C
c : Cocone F
i₁ i₂ i₃ : J
hi : i₁ ≤ i₂
hi' : i₂ ≤ i₃
hi₃ : i₃ ≤ j
hi₁₂ : i₁ < i₂
⊢ map c i₁ i₃ ⋯ hi₃ = map c i₁ i₂ hi ⋯ ≫ map c i₂ i₃ hi' hi₃
case inr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
J : Type u
inst✝ : LinearOrder J
j : J
F : ↑(Set.Iio j) ⥤ C
c : Cocone F
i₁ i₃ : J
hi₃ : i₃ ≤ j
hi : i₁ ≤ i₁
hi' : i₁ ≤ i₃
⊢ map c i₁ i₃ ⋯ hi₃ = map c i₁ i₁ hi ⋯ ≫ map c i₁ i₃ hi' hi₃
|
b2218895d6a3ba87
|
Std.DHashMap.Internal.AssocList.toList_filter
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.lean
|
theorem toList_filter {f : (a : α) → β a → Bool} {l : AssocList α β} :
Perm (l.filter f).toList (l.toList.filter fun p => f p.1 p.2)
|
α : Type u
β : α → Type v
f : (a : α) → β a → Bool
l✝ : AssocList α β
k : α
v : β k
t : AssocList α β
ih : ∀ (l : AssocList α β), (filter.go f l t).toList.Perm (l.toList ++ List.filter (fun p => f p.fst p.snd) t.toList)
l : AssocList α β
⊢ (filter.go f l (cons k v t)).toList.Perm (l.toList ++ List.filter (fun p => f p.fst p.snd) (cons k v t).toList)
|
simp only [filter.go, toList_cons, List.filter_cons, cond_eq_if]
|
α : Type u
β : α → Type v
f : (a : α) → β a → Bool
l✝ : AssocList α β
k : α
v : β k
t : AssocList α β
ih : ∀ (l : AssocList α β), (filter.go f l t).toList.Perm (l.toList ++ List.filter (fun p => f p.fst p.snd) t.toList)
l : AssocList α β
⊢ (if f k v = true then filter.go f (cons k v l) t else filter.go f l t).toList.Perm
(l.toList ++
if f k v = true then ⟨k, v⟩ :: List.filter (fun p => f p.fst p.snd) t.toList
else List.filter (fun p => f p.fst p.snd) t.toList)
|
092a53226e6b9f87
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.