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
|
|---|---|---|---|---|---|---|
Mathlib.Tactic.Ring.add_pf_add_lt
|
Mathlib/Tactic/Ring/Basic.lean
|
theorem add_pf_add_lt (a₁ : R) (_ : a₂ + b = c) : (a₁ + a₂) + b = a₁ + c
|
R : Type u_1
inst✝ : CommSemiring R
a₂ b c a₁ : R
x✝ : a₂ + b = c
⊢ a₁ + a₂ + b = a₁ + c
|
simp [*, add_assoc]
|
no goals
|
901ae75805bb27f1
|
Polynomial.sumIDeriv_apply_of_lt
|
Mathlib/Algebra/Polynomial/SumIteratedDerivative.lean
|
theorem sumIDeriv_apply_of_lt {p : R[X]} {n : ℕ} (hn : p.natDegree < n) :
sumIDeriv p = ∑ i ∈ range n, derivative^[i] p
|
R : Type u_1
inst✝ : Semiring R
p : R[X]
n : ℕ
hn : p.natDegree < n
⊢ (derivativeFinsupp p).support ⊆ range n
|
simp [hn]
|
no goals
|
382c86a4c222b5bf
|
integral_sin_sq_mul_cos_sq
|
Mathlib/Analysis/SpecialFunctions/Integrals.lean
|
theorem integral_sin_sq_mul_cos_sq :
∫ x in a..b, sin x ^ 2 * cos x ^ 2 = (b - a) / 8 - (sin (4 * b) - sin (4 * a)) / 32
|
a b : ℝ
h1 : ∀ (c : ℝ), (1 - c) / 2 * ((1 + c) / 2) = (1 - c ^ 2) / 4
h2 : Continuous fun x => cos (2 * x) ^ 2
⊢ ∀ (x : ℝ), cos x * sin x = sin (2 * x) / 2
|
intro
|
a b : ℝ
h1 : ∀ (c : ℝ), (1 - c) / 2 * ((1 + c) / 2) = (1 - c ^ 2) / 4
h2 : Continuous fun x => cos (2 * x) ^ 2
x✝ : ℝ
⊢ cos x✝ * sin x✝ = sin (2 * x✝) / 2
|
91a2e24802ea5818
|
Equiv.Perm.IsCycle.pow_iff
|
Mathlib/GroupTheory/Perm/Cycle/Basic.lean
|
theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
IsCycle (f ^ n) ↔ n.Coprime (orderOf f)
|
case intro.mpr.intro
β : Type u_3
inst✝ : Finite β
f : Perm β
hf : f.IsCycle
n : ℕ
val✝ : Fintype β
h : n.Coprime (orderOf f)
m : ℕ
hm : (f ^ n) ^ m = f
hf' : ((f ^ n) ^ m).IsCycle
x : β
hx : x ∈ (f ^ n).support
⊢ x ∈ ((f ^ n) ^ m).support
|
rw [hm]
|
case intro.mpr.intro
β : Type u_3
inst✝ : Finite β
f : Perm β
hf : f.IsCycle
n : ℕ
val✝ : Fintype β
h : n.Coprime (orderOf f)
m : ℕ
hm : (f ^ n) ^ m = f
hf' : ((f ^ n) ^ m).IsCycle
x : β
hx : x ∈ (f ^ n).support
⊢ x ∈ f.support
|
66cd6cfb46d266c4
|
CompletelyDistribLattice.MinimalAxioms.iSup_iInf_eq
|
Mathlib/Order/CompleteBooleanAlgebra.lean
|
lemma iSup_iInf_eq (f : ∀ i, κ i → α) :
let _ := minAx.toCompleteLattice
⨆ i, ⨅ j, f i j = ⨅ g : ∀ i, κ i, ⨆ i, f i (g i)
|
α : Type u
ι : Sort w
κ : ι → Sort w'
minAx : MinimalAxioms α
f : (i : ι) → κ i → α
x✝ : CompleteLattice α := minAx.toCompleteLattice
g : ((i : ι) → κ i) → ι
a : ι
ha : ∀ (b : κ a), ∃ f, ∃ (h : a = g f), h ▸ b = f (g f)
⊢ ⨅ i, f (g i) (i (g i)) ≤ ⨆ i, ⨅ j, f i j
|
refine le_trans ?_ (le_iSup _ a)
|
α : Type u
ι : Sort w
κ : ι → Sort w'
minAx : MinimalAxioms α
f : (i : ι) → κ i → α
x✝ : CompleteLattice α := minAx.toCompleteLattice
g : ((i : ι) → κ i) → ι
a : ι
ha : ∀ (b : κ a), ∃ f, ∃ (h : a = g f), h ▸ b = f (g f)
⊢ ⨅ i, f (g i) (i (g i)) ≤ ⨅ j, f a j
|
be0a16e095a6ee29
|
Filter.isBoundedUnder_le_mul_of_nonneg
|
Mathlib/Order/LiminfLimsup.lean
|
lemma isBoundedUnder_le_mul_of_nonneg [Mul α] [Zero α] [Preorder α] [PosMulMono α]
[MulPosMono α] {f : Filter ι} {u v : ι → α} (h₁ : 0 ≤ᶠ[f] u)
(h₂ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u)
(h₃ : 0 ≤ᶠ[f] v)
(h₄ : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f v) :
IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f (u * v)
|
case intro
α : Type u_1
ι : Type u_4
inst✝⁴ : Mul α
inst✝³ : Zero α
inst✝² : Preorder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
f : Filter ι
u v : ι → α
h₁ : 0 ≤ᶠ[f] u
h₂ : IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u
h₃ : 0 ≤ᶠ[f] v
h₄ : IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f v
U : α
hU : ∀ᶠ (x : ι) in f, u x ≤ U
⊢ IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f (u * v)
|
obtain ⟨V, hV⟩ := h₄.eventually_le
|
case intro.intro
α : Type u_1
ι : Type u_4
inst✝⁴ : Mul α
inst✝³ : Zero α
inst✝² : Preorder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
f : Filter ι
u v : ι → α
h₁ : 0 ≤ᶠ[f] u
h₂ : IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u
h₃ : 0 ≤ᶠ[f] v
h₄ : IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f v
U : α
hU : ∀ᶠ (x : ι) in f, u x ≤ U
V : α
hV : ∀ᶠ (x : ι) in f, v x ≤ V
⊢ IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f (u * v)
|
5d150f01f7a3ba19
|
IsSl2Triple.symm
|
Mathlib/Algebra/Lie/Sl2.lean
|
lemma symm (ht : IsSl2Triple h e f) : IsSl2Triple (-h) f e where
h_ne_zero
|
L : Type u_2
inst✝ : LieRing L
h e f : L
ht : IsSl2Triple h e f
⊢ ⁅f, e⁆ = -h
|
rw [← neg_eq_iff_eq_neg, lie_skew, ht.lie_e_f]
|
no goals
|
8d56a793b514175c
|
Real.fderiv_fourierChar_neg_bilinear_left_apply
|
Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
|
lemma fderiv_fourierChar_neg_bilinear_left_apply (v y : V) (w : W) :
fderiv ℝ (fun v ↦ (𝐞 (-L v w) : ℂ)) v y = -2 * π * I * L y w * 𝐞 (-L v w)
|
V : Type u_1
W : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
v y : V
w : W
⊢ 2 * ↑π * I * ↑(𝐞 (-(L v) w)) * ↑((L y) w) = 2 * ↑π * I * ↑((L y) w) * ↑(𝐞 (-(L v) w))
|
ring
|
no goals
|
4c67b50984595267
|
FermatLastTheoremForThreeGen.Solution.lambda_dvd_a_add_eta_sq_mul_b
|
Mathlib/NumberTheory/FLT/Three.lean
|
/-- Given `(S : Solution)`, we have that `λ ∣ (S.a + η ^ 2 * S.b)`. -/
lemma lambda_dvd_a_add_eta_sq_mul_b : λ ∣ (S.a + η ^ 2 * S.b)
|
K : Type u_1
inst✝ : Field K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
⊢ λ ∣ S.a + ↑η ^ 2 * S.b
|
rw [show S.a + η ^ 2 * S.b = (S.a + S.b) + λ ^ 2 * S.b + 2 * λ * S.b by rw [coe_eta]; ring]
|
K : Type u_1
inst✝ : Field K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
⊢ λ ∣ S.a + S.b + λ ^ 2 * S.b + 2 * λ * S.b
|
f2c6a6b69d1d3fef
|
Finsupp.some_single_some
|
Mathlib/Data/Finsupp/Basic.lean
|
theorem some_single_some [Zero M] (a : α) (m : M) :
(single (Option.some a) m : Option α →₀ M).some = single a m
|
α : Type u_1
M : Type u_5
inst✝ : Zero M
a : α
m : M
⊢ (single (Option.some a) m).some = single a m
|
ext b
|
case h
α : Type u_1
M : Type u_5
inst✝ : Zero M
a : α
m : M
b : α
⊢ (single (Option.some a) m).some b = (single a m) b
|
6bf60aa718869f43
|
ProbabilityTheory.gaussianPDFReal_inv_mul
|
Mathlib/Probability/Distributions/Gaussian.lean
|
lemma gaussianPDFReal_inv_mul {μ : ℝ} {v : ℝ≥0} {c : ℝ} (hc : c ≠ 0) (x : ℝ) :
gaussianPDFReal μ v (c⁻¹ * x) = |c| * gaussianPDFReal (c * μ) (⟨c^2, sq_nonneg _⟩ * v) x
|
case refine_2.e_x
μ : ℝ
v : ℝ≥0
c : ℝ
hc : c ≠ 0
x : ℝ
⊢ -(x - c * μ) ^ 2 / (c ^ 2 * (2 * ↑v)) = -(x - c * μ) ^ 2 / (2 * (c ^ 2 * ↑v))
|
congr 1
|
case refine_2.e_x.e_a
μ : ℝ
v : ℝ≥0
c : ℝ
hc : c ≠ 0
x : ℝ
⊢ c ^ 2 * (2 * ↑v) = 2 * (c ^ 2 * ↑v)
|
3d362dec61aca464
|
MeasureTheory.TendstoInMeasure.exists_seq_tendsto_ae
|
Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean
|
theorem TendstoInMeasure.exists_seq_tendsto_ae (hfg : TendstoInMeasure μ f atTop g) :
∃ ns : ℕ → ℕ, StrictMono ns ∧ ∀ᵐ x ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))
|
case intro.intro
α : Type u_1
E : Type u_4
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
h_lt_ε_real : ∀ (ε : ℝ), 0 < ε → ∃ k, 2 * 2⁻¹ ^ k < ε
ns : ℕ → ℕ := ExistsSeqTendstoAe.seqTendstoAeSeq hfg
S : ℕ → Set α := fun k => {x | 2⁻¹ ^ k ≤ dist (f (ns k) x) (g x)}
hμS_le : ∀ (k : ℕ), μ (S k) ≤ 2⁻¹ ^ k
s : Set α := limsup S atTop
hs : s = limsup S atTop
hμs : μ s = 0
x : α
ε : ℝ
hε : ε > 0
N k : ℕ
hk_lt_ε : 2 * 2⁻¹ ^ k < ε
n : ℕ
hn_ge : n ≥ N ⊔ (k - 1)
hNx : dist (f (ns n) x) (g x) < 2⁻¹ ^ n
h_inv_n_le_k : 2⁻¹ ^ n ≤ 2 * 2⁻¹ ^ k
⊢ dist (f (ns n) x) (g x) ≤ 2 * 2⁻¹ ^ k
|
exact le_trans hNx.le h_inv_n_le_k
|
no goals
|
125226675bee6dd7
|
finprod_eq_mulIndicator_apply
|
Mathlib/Algebra/BigOperators/Finprod.lean
|
theorem finprod_eq_mulIndicator_apply (s : Set α) (f : α → M) (a : α) :
∏ᶠ _ : a ∈ s, f a = mulIndicator s f a
|
α : Type u_1
M : Type u_5
inst✝ : CommMonoid M
s : Set α
f : α → M
a : α
⊢ ∏ᶠ (_ : a ∈ s), f a = s.mulIndicator f a
|
convert finprod_eq_if (M := M) (p := a ∈ s) (x := f a)
|
no goals
|
6f1b0d2d634b0a0d
|
smoothSheafCommRing.isUnit_stalk_iff
|
Mathlib/Geometry/Manifold/Sheaf/LocallyRingedSpace.lean
|
theorem smoothSheafCommRing.isUnit_stalk_iff {x : M}
(f : (smoothSheafCommRing IM 𝓘(𝕜) M 𝕜).presheaf.stalk x) :
IsUnit f ↔ f ∉ RingHom.ker (smoothSheafCommRing.eval IM 𝓘(𝕜) M 𝕜 x)
|
𝕜 : Type u
inst✝⁵ : NontriviallyNormedField 𝕜
EM : Type u_1
inst✝⁴ : NormedAddCommGroup EM
inst✝³ : NormedSpace 𝕜 EM
HM : Type u_2
inst✝² : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
M : Type u
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace HM M
x : M
S : TopCat.Presheaf CommRingCat (TopCat.of M) := (smoothSheafCommRing IM 𝓘(𝕜, 𝕜) M 𝕜).presheaf
U : Opens M
hxU : x ∈ U
f : C^∞⟮IM, ↥U; 𝓘(𝕜, 𝕜), 𝕜⟯
hf : (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x) ((CategoryTheory.ConcreteCategory.hom (S.germ U x hxU)) f) ≠ 0
hf' : f ⟨x, hxU⟩ ≠ 0
V₀ : Set ↥U
hV₀f : ∀ y ∈ V₀, f y ≠ 0
hV₀ : IsOpen V₀
hxV₀ : ⟨x, hxU⟩ ∈ V₀
V : Opens M := { carrier := Subtype.val '' V₀, is_open' := ⋯ }
hUV : V ≤ U
⊢ V₀ = Set.range (Set.inclusion hUV)
|
convert (Set.range_inclusion hUV).symm
|
case h.e'_2.h
𝕜 : Type u
inst✝⁵ : NontriviallyNormedField 𝕜
EM : Type u_1
inst✝⁴ : NormedAddCommGroup EM
inst✝³ : NormedSpace 𝕜 EM
HM : Type u_2
inst✝² : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
M : Type u
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace HM M
x : M
S : TopCat.Presheaf CommRingCat (TopCat.of M) := (smoothSheafCommRing IM 𝓘(𝕜, 𝕜) M 𝕜).presheaf
U : Opens M
hxU : x ∈ U
f : C^∞⟮IM, ↥U; 𝓘(𝕜, 𝕜), 𝕜⟯
hf : (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x) ((CategoryTheory.ConcreteCategory.hom (S.germ U x hxU)) f) ≠ 0
hf' : f ⟨x, hxU⟩ ≠ 0
V₀ : Set ↥U
hV₀f : ∀ y ∈ V₀, f y ≠ 0
hV₀ : IsOpen V₀
hxV₀ : ⟨x, hxU⟩ ∈ V₀
V : Opens M := { carrier := Subtype.val '' V₀, is_open' := ⋯ }
hUV : V ≤ U
e_1✝ : Set ↥U = Set ↑↑U
⊢ V₀ = {x | ↑x ∈ ↑V}
|
f7ca29d724eff4f4
|
LaurentPolynomial.isLocalization
|
Mathlib/Algebra/Polynomial/Laurent.lean
|
theorem isLocalization : IsLocalization (Submonoid.powers (X : R[X])) R[T;T⁻¹] :=
{ map_units' := fun ⟨t, ht⟩ => by
obtain ⟨n, rfl⟩ := ht
rw [algebraMap_eq_toLaurent, toLaurent_X_pow]
exact isUnit_T ↑n
surj' := fun f => by
induction' f using LaurentPolynomial.induction_on_mul_T with f n
have : X ^ n ∈ Submonoid.powers (X : R[X]) := ⟨n, rfl⟩
refine ⟨(f, ⟨_, this⟩), ?_⟩
simp only [algebraMap_eq_toLaurent, toLaurent_X_pow, mul_T_assoc, neg_add_cancel, T_zero,
mul_one]
exists_of_eq := fun {f g} => by
rw [algebraMap_eq_toLaurent, algebraMap_eq_toLaurent, Polynomial.toLaurent_inj]
rintro rfl
exact ⟨1, rfl⟩ }
|
R : Type u_1
inst✝ : CommSemiring R
x✝ : ↥(Submonoid.powers X)
t : R[X]
ht : t ∈ Submonoid.powers X
⊢ IsUnit ((algebraMap R[X] R[T;T⁻¹]) ↑⟨t, ht⟩)
|
obtain ⟨n, rfl⟩ := ht
|
case intro
R : Type u_1
inst✝ : CommSemiring R
x✝ : ↥(Submonoid.powers X)
n : ℕ
⊢ IsUnit ((algebraMap R[X] R[T;T⁻¹]) ↑⟨(fun x => X ^ x) n, ⋯⟩)
|
142317cb84f0217d
|
lt_inv_comm₀
|
Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
|
/-- See also `lt_inv_of_lt_inv₀` for a one-sided implication with one fewer assumption. -/
lemma lt_inv_comm₀ (ha : 0 < a) (hb : 0 < b) : a < b⁻¹ ↔ b < a⁻¹
|
G₀ : Type u_2
inst✝⁵ : GroupWithZero G₀
inst✝⁴ : PartialOrder G₀
inst✝³ : ZeroLEOneClass G₀
inst✝² : PosMulReflectLT G₀
a b : G₀
inst✝¹ : MulPosStrictMono G₀
inst✝ : PosMulStrictMono G₀
ha : 0 < a
hb : 0 < b
⊢ a < b⁻¹ ↔ b < a⁻¹
|
rw [← inv_lt_inv₀ (inv_pos.2 hb) ha, inv_inv]
|
no goals
|
47d89a3268cf1fcb
|
AlgebraicGeometry.sourceAffineLocally_isLocal
|
Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
|
theorem sourceAffineLocally_isLocal (h₁ : RingHom.RespectsIso P)
(h₂ : RingHom.LocalizationAwayPreserves P) (h₃ : RingHom.OfLocalizationSpan P) :
(sourceAffineLocally P).IsLocal
|
case to_basicOpen.a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
h₁ : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P
h₂ : RingHom.LocalizationAwayPreserves fun {R S} [CommRing R] [CommRing S] => P
h₃ : RingHom.OfLocalizationSpan fun {R S} [CommRing R] [CommRing S] => P
X Y : Scheme
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
H : sourceAffineLocally (fun {R S} [CommRing R] [CommRing S] => P) f
U : ↑X.affineOpens
hU : ↑U ≤ f ⁻¹ᵁ Y.basicOpen r
this : X.basicOpen ((ConcreteCategory.hom (Scheme.Hom.appLE f ⊤ ↑U ⋯)) r) = ↑U
⊢ P (CommRingCat.Hom.hom (Scheme.Hom.appLE f ⊤ ↑U ⋯))
|
exact H U
|
no goals
|
222ac1262a013627
|
RingSubgroupsBasis.hasBasis_nhds
|
Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean
|
theorem hasBasis_nhds (a : A) :
HasBasis (@nhds A hB.topology a) (fun _ => True) fun i => { b | b - a ∈ B i } :=
⟨by
intro s
rw [(hB.toRingFilterBasis.toAddGroupFilterBasis.nhds_hasBasis a).mem_iff]
simp only [true_and]
constructor
· rintro ⟨-, ⟨i, rfl⟩, hi⟩
use i
suffices h : { b : A | b - a ∈ B i } = (fun y => a + y) '' ↑(B i) by
rw [h]
assumption
simp only [image_add_left, neg_add_eq_sub]
ext b
simp
· rintro ⟨i, hi⟩
use B i
constructor
· use i
· rw [image_subset_iff]
rintro b b_in
apply hi
simpa using b_in⟩
|
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
a : A
s : Set A
i : ι
hi : (fun y => a + y) '' ↑(B i) ⊆ s
h : {b | b - a ∈ B i} = (fun y => a + y) '' ↑(B i)
⊢ (fun y => a + y) '' ↑(B i) ⊆ s
|
assumption
|
no goals
|
9189cb0f666030cd
|
Associates.factors_eq_some_iff_ne_zero
|
Mathlib/RingTheory/UniqueFactorizationDomain/FactorSet.lean
|
theorem factors_eq_some_iff_ne_zero {a : Associates α} :
(∃ s : Multiset { p : Associates α // Irreducible p }, a.factors = s) ↔ a ≠ 0
|
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
⊢ (∃ s, a.factors = ↑s) ↔ a ≠ 0
|
simp_rw [@eq_comm _ a.factors, ← WithTop.ne_top_iff_exists]
|
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
⊢ a.factors ≠ ⊤ ↔ a ≠ 0
|
b75a386d076c5824
|
CategoryTheory.Pretriangulated.Opposite.distinguished_cocone_triangle
|
Mathlib/CategoryTheory/Triangulated/Opposite/Pretriangulated.lean
|
lemma distinguished_cocone_triangle {X Y : Cᵒᵖ} (f : X ⟶ Y) :
∃ (Z : Cᵒᵖ) (g : Y ⟶ Z) (h : Z ⟶ X⟦(1 : ℤ)⟧),
Triangle.mk f g h ∈ distinguishedTriangles C
|
case intro.intro.intro
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasShift C ℤ
inst✝³ : HasZeroObject C
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
X Y : Cᵒᵖ
f : X ⟶ Y
Z : C
g : Z ⟶ Opposite.unop Y
h : Opposite.unop X ⟶ (shiftFunctor C 1).obj Z
H : Triangle.mk g f.unop h ∈ Pretriangulated.distinguishedTriangles
⊢ Opposite.unop
((triangleOpEquivalence C).inverse.obj
(Triangle.mk f g.op
((opShiftFunctorEquivalence C 1).counitIso.inv.app (Opposite.op Z) ≫ (shiftFunctor Cᵒᵖ 1).map h.op))) ≅
Triangle.mk g f.unop h
|
exact Triangle.isoMk _ _ (Iso.refl _) (Iso.refl _) (Iso.refl _) (by simp) (by simp)
(Quiver.Hom.op_inj (by simp [shift_unop_opShiftFunctorEquivalence_counitIso_inv_app]))
|
no goals
|
272fd5c34afae8cc
|
continuous_of_uniform_approx_of_continuous
|
Mathlib/Topology/UniformSpace/UniformConvergence.lean
|
theorem continuous_of_uniform_approx_of_continuous
(L : ∀ u ∈ 𝓤 β, ∃ F, Continuous F ∧ ∀ y, (f y, F y) ∈ u) : Continuous f :=
continuous_iff_continuousOn_univ.mpr <|
continuousOn_of_uniform_approx_of_continuousOn <| by
simpa [continuous_iff_continuousOn_univ] using L
|
α : Type u
β : Type v
inst✝¹ : UniformSpace β
f : α → β
inst✝ : TopologicalSpace α
L : ∀ u ∈ 𝓤 β, ∃ F, Continuous F ∧ ∀ (y : α), (f y, F y) ∈ u
⊢ ∀ u ∈ 𝓤 β, ∃ F, ContinuousOn F univ ∧ ∀ y ∈ univ, (f y, F y) ∈ u
|
simpa [continuous_iff_continuousOn_univ] using L
|
no goals
|
f0dfef3ce1b3096c
|
SimpleGraph.Subgraph.coe_deleteEdges_eq
|
Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
|
theorem coe_deleteEdges_eq (s : Set (Sym2 V)) :
(G'.deleteEdges s).coe = G'.coe.deleteEdges (Sym2.map (↑) ⁻¹' s)
|
V : Type u
G : SimpleGraph V
G' : G.Subgraph
s : Set (Sym2 V)
⊢ (G'.deleteEdges s).coe = G'.coe.deleteEdges (Sym2.map Subtype.val ⁻¹' s)
|
ext ⟨v, hv⟩ ⟨w, hw⟩
|
case Adj.h.mk.h.mk.a
V : Type u
G : SimpleGraph V
G' : G.Subgraph
s : Set (Sym2 V)
v : V
hv : v ∈ (G'.deleteEdges s).verts
w : V
hw : w ∈ (G'.deleteEdges s).verts
⊢ (G'.deleteEdges s).coe.Adj ⟨v, hv⟩ ⟨w, hw⟩ ↔ (G'.coe.deleteEdges (Sym2.map Subtype.val ⁻¹' s)).Adj ⟨v, hv⟩ ⟨w, hw⟩
|
4a500f910601c6eb
|
Nat.ascFactorial_eq_factorial_mul_choose'
|
Mathlib/Data/Nat/Choose/Basic.lean
|
theorem ascFactorial_eq_factorial_mul_choose' (n k : ℕ) :
n.ascFactorial k = k ! * (n + k - 1).choose k
|
n k : ℕ
⊢ n.ascFactorial k = k ! * (n + k - 1).choose k
|
cases n
|
case zero
k : ℕ
⊢ ascFactorial 0 k = k ! * (0 + k - 1).choose k
case succ
k n✝ : ℕ
⊢ (n✝ + 1).ascFactorial k = k ! * (n✝ + 1 + k - 1).choose k
|
007644bc8cc9572c
|
MeasureTheory.integral_fintype_prod_eq_prod
|
Mathlib/MeasureTheory/Integral/Pi.lean
|
theorem integral_fintype_prod_eq_prod (ι : Type*) [Fintype ι] {E : ι → Type*}
(f : (i : ι) → E i → 𝕜) [∀ i, MeasureSpace (E i)] [∀ i, SigmaFinite (volume : Measure (E i))] :
∫ x : (i : ι) → E i, ∏ i, f i (x i) = ∏ i, ∫ x, f i x
|
𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ ∫ (x : (b : Fin (card ι)) → E (e b)), ∏ i : ι, f i ((MeasurableEquiv.piCongrLeft E e) x i) =
∏ i : ι, ∫ (x : E i), f i x
|
simp_rw [← e.prod_comp, MeasurableEquiv.coe_piCongrLeft, Equiv.piCongrLeft_apply_apply,
MeasureTheory.integral_fin_nat_prod_eq_prod]
|
no goals
|
ab006eba2a45fcbb
|
Complex.hasSum_taylorSeries_log
|
Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean
|
/-- The Taylor series of the complex logarithm at `1` converges to the logarithm in the
open unit disk. -/
lemma hasSum_taylorSeries_log {z : ℂ} (hz : ‖z‖ < 1) :
HasSum (fun n : ℕ ↦ (-1) ^ (n + 1) * z ^ n / n) (log (1 + z))
|
case refine_2
z : ℂ
hz : ‖z‖ < 1
⊢ (fun x => logTaylor x z - log (1 + z)) =o[atTop] fun x => 1
|
refine IsLittleO.trans_isBigO ?_ <| isBigO_const_one ℂ (1 : ℝ) atTop
|
case refine_2
z : ℂ
hz : ‖z‖ < 1
⊢ (fun x => logTaylor x z - log (1 + z)) =o[atTop] fun _x => 1
|
c6ad5f4f2717ef3d
|
SimpleGraph.IsTuranMaximal.not_adj_trans
|
Mathlib/Combinatorics/SimpleGraph/Turan.lean
|
/-- In a Turán-maximal graph, non-adjacency is transitive. -/
lemma not_adj_trans (h : G.IsTuranMaximal r) (hts : ¬G.Adj t s) (hsu : ¬G.Adj s u) :
¬G.Adj t u
|
case right
V : Type u_1
inst✝¹ : Fintype V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
r : ℕ
s t u : V
hts : ¬G.Adj t s
hsu : ¬G.Adj s u
hst : ¬G.Adj s t
dst : G.degree s = G.degree t
dsu : G.degree s = G.degree u
h : G.Adj t u
cf : G.CliqueFree (r + 1)
nst : s ≠ t
ntu : t ≠ u
this : ¬(G.replaceVertex s t).Adj s u
l1 : (G.replaceVertex s t).degree s = G.degree s
⊢ #G.edgeFinset < #G.edgeFinset + (G.replaceVertex s t).degree s - (G.replaceVertex s t).degree u
|
have l2 : (G.replaceVertex s t).degree u = G.degree u - 1 := by
rw [degree, degree, ← card_singleton t, ← card_sdiff (by simp [h.symm])]
congr 1; ext v
simp only [mem_neighborFinset, mem_sdiff, mem_singleton, replaceVertex]
split_ifs <;> simp_all [adj_comm]
|
case right
V : Type u_1
inst✝¹ : Fintype V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
r : ℕ
s t u : V
hts : ¬G.Adj t s
hsu : ¬G.Adj s u
hst : ¬G.Adj s t
dst : G.degree s = G.degree t
dsu : G.degree s = G.degree u
h : G.Adj t u
cf : G.CliqueFree (r + 1)
nst : s ≠ t
ntu : t ≠ u
this : ¬(G.replaceVertex s t).Adj s u
l1 : (G.replaceVertex s t).degree s = G.degree s
l2 : (G.replaceVertex s t).degree u = G.degree u - 1
⊢ #G.edgeFinset < #G.edgeFinset + (G.replaceVertex s t).degree s - (G.replaceVertex s t).degree u
|
320247f515c2bcdc
|
Array.swap_swap
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem swap_swap (a : Array α) {i j : Nat} (hi hj) :
(a.swap i j hi hj).swap i j ((a.size_swap ..).symm ▸ hi) ((a.size_swap ..).symm ▸ hj) = a
|
case h₁
α : Type u_1
a : Array α
i j : Nat
hi : i < a.size
hj : j < a.size
⊢ ((a.swap i j hi hj).swap i j ⋯ ⋯).size = a.size
|
simp only [size_swap]
|
no goals
|
8af4d36a7bf83b1e
|
Set.MapsTo.restrict_surjective_iff
|
Mathlib/Data/Set/Function.lean
|
theorem MapsTo.restrict_surjective_iff (h : MapsTo f s t) :
Surjective (MapsTo.restrict _ _ _ h) ↔ SurjOn f s t
|
α : Type u_1
β : Type u_2
s : Set α
t : Set β
f : α → β
h : MapsTo f s t
h' : Surjective (restrict f s t h)
b : β
hb : b ∈ t
a : α
ha : a ∈ s
ha' : restrict f s t h ⟨a, ha⟩ = ⟨b, hb⟩
⊢ f a = b
|
simpa [Subtype.ext_iff] using ha'
|
no goals
|
3f017aab25bc5663
|
Dynamics.log_coverMincard_le_add
|
Mathlib/Dynamics/TopologicalEntropy/CoverEntropy.lean
|
lemma log_coverMincard_le_add {T : X → X} {F : Set X} (F_inv : MapsTo T F F)
{U : Set (X × X)} (U_symm : SymmetricRel U) {m n : ℕ} (m_pos : 0 < m) (n_pos : 0 < n) :
log (coverMincard T F (U ○ U) n) / n
≤ log (coverMincard T F U m) / m + log (coverMincard T F U m) / n
|
case inr
X : Type u_1
T : X → X
F : Set X
F_inv : MapsTo T F F
U : Set (X × X)
U_symm : SymmetricRel U
m n : ℕ
m_pos : 0 < m
n_pos : 0 < n
F_nemp : F.Nonempty
h_nm : 0 ≤ ↑(n / m)
h_log : 0 ≤ (↑(coverMincard T F U m)).log
⊢ (↑(coverMincard T F (U ○ U) n)).log / ↑n ≤ (↑(coverMincard T F U m)).log / ↑m + (↑(coverMincard T F U m)).log / ↑n
|
have n_div_n := EReal.div_self (natCast_ne_bot n) (natCast_ne_top n)
(Nat.cast_pos'.2 n_pos).ne.symm
|
case inr
X : Type u_1
T : X → X
F : Set X
F_inv : MapsTo T F F
U : Set (X × X)
U_symm : SymmetricRel U
m n : ℕ
m_pos : 0 < m
n_pos : 0 < n
F_nemp : F.Nonempty
h_nm : 0 ≤ ↑(n / m)
h_log : 0 ≤ (↑(coverMincard T F U m)).log
n_div_n : ↑n / ↑n = 1
⊢ (↑(coverMincard T F (U ○ U) n)).log / ↑n ≤ (↑(coverMincard T F U m)).log / ↑m + (↑(coverMincard T F U m)).log / ↑n
|
bfe34c9eb0da6d6f
|
Finset.pairwiseDisjoint_fibers
|
Mathlib/Data/Finset/Union.lean
|
private lemma pairwiseDisjoint_fibers : Set.PairwiseDisjoint ↑t fun a ↦ s.filter (f · = a) :=
fun x' hx y' hy hne ↦ by
simp_rw [disjoint_left, mem_filter]; rintro i ⟨_, rfl⟩ ⟨_, rfl⟩; exact hne rfl
|
case intro.intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
i : α
left✝¹ : i ∈ s
hx : f i ∈ ↑t
left✝ : i ∈ s
hy : f i ∈ ↑t
hne : f i ≠ f i
⊢ False
|
exact hne rfl
|
no goals
|
b21a107221de7caf
|
exists_continuous_one_zero_of_isCompact_of_isGδ
|
Mathlib/Topology/UrysohnsLemma.lean
|
theorem exists_continuous_one_zero_of_isCompact_of_isGδ [RegularSpace X] [LocallyCompactSpace X]
{s t : Set X} (hs : IsCompact s) (h's : IsGδ s) (ht : IsClosed t) (hd : Disjoint s t) :
∃ f : C(X, ℝ), s = f ⁻¹' {1} ∧ EqOn f 0 t ∧ HasCompactSupport f
∧ ∀ x, f x ∈ Icc (0 : ℝ) 1
|
case intro.intro.intro.intro.intro.intro.intro.intro.intro
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : RegularSpace X
inst✝ : LocallyCompactSpace X
s t : Set X
hs : IsCompact s
h's : IsGδ s
ht : IsClosed t
hd : Disjoint s t
U : ℕ → Set X
U_open : ∀ (n : ℕ), IsOpen (U n)
hU : s = ⋂ n, U n
m : Set X
m_comp : IsCompact m
sm : s ⊆ interior m
mt : m ⊆ tᶜ
f : ℕ → C(X, ℝ)
fs : ∀ (n : ℕ), EqOn (⇑(f n)) 1 s
fm : ∀ (n : ℕ), EqOn (⇑(f n)) 0 (U n ∩ interior m)ᶜ
_hf : ∀ (n : ℕ), HasCompactSupport ⇑(f n)
f_range : ∀ (n : ℕ) (x : X), (f n) x ∈ Icc 0 1
u : ℕ → ℝ
u_pos : ∀ (i : ℕ), 0 < u i
u_sum : Summable u
hu : ∑' (i : ℕ), u i = 1
⊢ ∃ f, s = ⇑f ⁻¹' {1} ∧ EqOn (⇑f) 0 t ∧ HasCompactSupport ⇑f ∧ ∀ (x : X), f x ∈ Icc 0 1
|
let g : X → ℝ := fun x ↦ ∑' n, u n * f n x
|
case intro.intro.intro.intro.intro.intro.intro.intro.intro
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : RegularSpace X
inst✝ : LocallyCompactSpace X
s t : Set X
hs : IsCompact s
h's : IsGδ s
ht : IsClosed t
hd : Disjoint s t
U : ℕ → Set X
U_open : ∀ (n : ℕ), IsOpen (U n)
hU : s = ⋂ n, U n
m : Set X
m_comp : IsCompact m
sm : s ⊆ interior m
mt : m ⊆ tᶜ
f : ℕ → C(X, ℝ)
fs : ∀ (n : ℕ), EqOn (⇑(f n)) 1 s
fm : ∀ (n : ℕ), EqOn (⇑(f n)) 0 (U n ∩ interior m)ᶜ
_hf : ∀ (n : ℕ), HasCompactSupport ⇑(f n)
f_range : ∀ (n : ℕ) (x : X), (f n) x ∈ Icc 0 1
u : ℕ → ℝ
u_pos : ∀ (i : ℕ), 0 < u i
u_sum : Summable u
hu : ∑' (i : ℕ), u i = 1
g : X → ℝ := fun x => ∑' (n : ℕ), u n * (f n) x
⊢ ∃ f, s = ⇑f ⁻¹' {1} ∧ EqOn (⇑f) 0 t ∧ HasCompactSupport ⇑f ∧ ∀ (x : X), f x ∈ Icc 0 1
|
06fdcc97382f69bb
|
Complex.ofReal_arctan
|
Mathlib/Analysis/SpecialFunctions/Complex/Arctan.lean
|
theorem ofReal_arctan (x : ℝ) : (Real.arctan x : ℂ) = arctan x
|
x : ℝ
⊢ ↑(Real.arctan x) = (↑x).arctan
|
conv_rhs => rw [← Real.tan_arctan x]
|
x : ℝ
⊢ ↑(Real.arctan x) = (↑(Real.tan (Real.arctan x))).arctan
|
d799d1afd10876e7
|
Nat.bisect_lt_stop
|
Mathlib/.lake/packages/batteries/Batteries/Data/Nat/Bisect.lean
|
theorem bisect_lt_stop {p : Nat → Bool} (h : start < stop) (hstart : p start = true)
(hstop : p stop = false) : bisect h hstart hstop < stop
|
case isTrue
start stop : Nat
p : Nat → Bool
h : start < stop
hstart : p start = true
hstop : p stop = false
h✝ : start < start.avg stop
⊢ (match hmid : p (start.avg stop) with
| false => bisect h✝ hstart hmid
| true => bisect ⋯ hmid hstop) <
stop
|
split
|
case isTrue.h_1
start stop : Nat
p : Nat → Bool
h : start < stop
hstart : p start = true
hstop : p stop = false
h✝ : start < start.avg stop
heq✝ : p (start.avg stop) = false
⊢ bisect h✝ hstart ⋯ < stop
case isTrue.h_2
start stop : Nat
p : Nat → Bool
h : start < stop
hstart : p start = true
hstop : p stop = false
h✝ : start < start.avg stop
heq✝ : p (start.avg stop) = true
⊢ bisect ⋯ ⋯ hstop < stop
|
fc35ee5a21c978ac
|
Int.two_pow_two_pow_add_two_pow_two_pow
|
Mathlib/NumberTheory/Multiplicity.lean
|
theorem Int.two_pow_two_pow_add_two_pow_two_pow {x y : ℤ} (hx : ¬2 ∣ x) (hxy : 4 ∣ x - y) (i : ℕ) :
emultiplicity 2 (x ^ 2 ^ i + y ^ 2 ^ i) = ↑(1 : ℕ)
|
x y : ℤ
hx : ¬2 ∣ x
hxy : 4 ∣ x - y
i : ℕ
⊢ Odd x
|
rwa [← Int.not_even_iff_odd, even_iff_two_dvd]
|
no goals
|
c2c4f247c9f39fe5
|
Sigma.isConnected_iff
|
Mathlib/Topology/Connected/Clopen.lean
|
theorem Sigma.isConnected_iff [∀ i, TopologicalSpace (π i)] {s : Set (Σi, π i)} :
IsConnected s ↔ ∃ i t, IsConnected t ∧ s = Sigma.mk i '' t
|
case refine_2.intro.intro.intro
ι : Type u_1
π : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (π i)
i : ι
t : Set (π i)
ht : IsConnected t
⊢ IsConnected (mk i '' t)
|
exact ht.image _ continuous_sigmaMk.continuousOn
|
no goals
|
1455e050525a61d2
|
MeasureTheory.SignedMeasure.toJordanDecomposition_zero
|
Mathlib/MeasureTheory/Decomposition/Jordan.lean
|
theorem toJordanDecomposition_zero : (0 : SignedMeasure α).toJordanDecomposition = 0
|
case a
α : Type u_1
inst✝ : MeasurableSpace α
⊢ (toJordanDecomposition 0).toSignedMeasure = toSignedMeasure 0
|
simp [toSignedMeasure_zero]
|
no goals
|
00269c9e6b672618
|
MeasureTheory.lintegral_comp_eq_lintegral_meas_le_mul_of_measurable
|
Mathlib/MeasureTheory/Integral/Layercake.lean
|
theorem lintegral_comp_eq_lintegral_meas_le_mul_of_measurable (μ : Measure α)
(f_nn : 0 ≤ f) (f_mble : Measurable f)
(g_intble : ∀ t > 0, IntervalIntegrable g volume 0 t) (g_mble : Measurable g)
(g_nn : ∀ t > 0, 0 ≤ g t) :
∫⁻ ω, ENNReal.ofReal (∫ t in (0)..f ω, g t) ∂μ =
∫⁻ t in Ioi 0, μ {a : α | t ≤ f a} * ENNReal.ofReal (g t)
|
α : Type u_1
inst✝ : MeasurableSpace α
f : α → ℝ
g : ℝ → ℝ
μ : Measure α
f_nn : 0 ≤ f
f_mble : Measurable f
g_intble : ∀ t > 0, IntervalIntegrable g volume 0 t
g_mble : Measurable g
g_nn : ∀ t > 0, 0 ≤ g t
f_nonneg : ∀ (ω : α), 0 ≤ f ω
H1 : ¬g =ᶠ[ae (volume.restrict (Ioi 0))] 0
s : ℝ
s_pos : s > 0
hs : 0 < ∫ (x : ℝ) in Ioc 0 s, g x ∂volume
h's : μ {a | s < f a} = ⊤
A : ∫⁻ (t : ℝ) in Ioi 0, μ {a | t ≤ f a} * ENNReal.ofReal (g t) = ⊤
⊢ ⊤ = ENNReal.ofReal (∫ (t : ℝ) in 0 ..s, g t) * ⊤
|
rw [ENNReal.mul_top]
|
α : Type u_1
inst✝ : MeasurableSpace α
f : α → ℝ
g : ℝ → ℝ
μ : Measure α
f_nn : 0 ≤ f
f_mble : Measurable f
g_intble : ∀ t > 0, IntervalIntegrable g volume 0 t
g_mble : Measurable g
g_nn : ∀ t > 0, 0 ≤ g t
f_nonneg : ∀ (ω : α), 0 ≤ f ω
H1 : ¬g =ᶠ[ae (volume.restrict (Ioi 0))] 0
s : ℝ
s_pos : s > 0
hs : 0 < ∫ (x : ℝ) in Ioc 0 s, g x ∂volume
h's : μ {a | s < f a} = ⊤
A : ∫⁻ (t : ℝ) in Ioi 0, μ {a | t ≤ f a} * ENNReal.ofReal (g t) = ⊤
⊢ ENNReal.ofReal (∫ (t : ℝ) in 0 ..s, g t) ≠ 0
|
6098eac6b53bede3
|
OrthonormalBasis.volume_parallelepiped
|
Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean
|
theorem OrthonormalBasis.volume_parallelepiped (b : OrthonormalBasis ι ℝ F) :
volume (parallelepiped b) = 1
|
ι : Type u_1
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
inst✝³ : MeasurableSpace F
inst✝² : BorelSpace F
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional ℝ F
b : OrthonormalBasis ι ℝ F
this : Fact (finrank ℝ F = finrank ℝ F)
⊢ volume (parallelepiped ⇑b) = 1
|
let o := (stdOrthonormalBasis ℝ F).toBasis.orientation
|
ι : Type u_1
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
inst✝³ : MeasurableSpace F
inst✝² : BorelSpace F
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional ℝ F
b : OrthonormalBasis ι ℝ F
this : Fact (finrank ℝ F = finrank ℝ F)
o : Orientation ℝ F (Fin (finrank ℝ F)) := (stdOrthonormalBasis ℝ F).toBasis.orientation
⊢ volume (parallelepiped ⇑b) = 1
|
6ace9de66174bbdf
|
Ordnode.Raised.dist_le'
|
Mathlib/Data/Ordmap/Ordset.lean
|
theorem Raised.dist_le' {n m} (H : Raised n m) : Nat.dist m n ≤ 1
|
n m : ℕ
H : Raised n m
⊢ m.dist n ≤ 1
|
rw [Nat.dist_comm]
|
n m : ℕ
H : Raised n m
⊢ n.dist m ≤ 1
|
914217f208d8a07a
|
MeasureTheory.SimpleFunc.range_eq_empty_of_isEmpty
|
Mathlib/MeasureTheory/Function/SimpleFunc.lean
|
theorem range_eq_empty_of_isEmpty {β} [hα : IsEmpty α] (f : α →ₛ β) : f.range = ∅
|
case intro
α : Type u_1
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : y ∈ f.range
⊢ False
|
rw [SimpleFunc.mem_range, Set.mem_range] at hy_mem
|
case intro
α : Type u_1
inst✝ : MeasurableSpace α
β : Type u_5
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : ∃ y_1, f y_1 = y
⊢ False
|
ba9f32d2d6566746
|
PowerSeries.binomialSeries_nat
|
Mathlib/RingTheory/PowerSeries/Binomial.lean
|
@[simp]
lemma binomialSeries_nat [CommRing A] (d : ℕ) :
binomialSeries A (d : ℤ) = (1 + X) ^ d
|
case pos
A : Type u_2
inst✝ : CommRing A
d n : ℕ
h : d < n
k : ℕ
hk : k ∈ range (d + 1)
hkd : k ≤ d
⊢ (coeff A (n - k)) ↑(d.choose k) = 0
|
rw [← map_natCast (C A), coeff_ne_zero_C (by omega)]
|
no goals
|
41f98537d51fbeb7
|
PowerBasis.dim_le_natDegree_of_root
|
Mathlib/RingTheory/PowerBasis.lean
|
theorem dim_le_natDegree_of_root (pb : PowerBasis A S) {p : A[X]} (ne_zero : p ≠ 0)
(root : aeval pb.gen p = 0) : pb.dim ≤ p.natDegree
|
S : Type u_2
inst✝² : Ring S
A : Type u_4
inst✝¹ : CommRing A
inst✝ : Algebra A S
pb : PowerBasis A S
p : A[X]
ne_zero : p ≠ 0
root : (aeval pb.gen) p = 0
hlt : p.natDegree < pb.dim
⊢ ∑ i : Fin pb.dim, (monomial ↑i) (p.coeff ↑i) = 0
|
refine Fintype.sum_eq_zero _ fun i => ?_
|
S : Type u_2
inst✝² : Ring S
A : Type u_4
inst✝¹ : CommRing A
inst✝ : Algebra A S
pb : PowerBasis A S
p : A[X]
ne_zero : p ≠ 0
root : (aeval pb.gen) p = 0
hlt : p.natDegree < pb.dim
i : Fin pb.dim
⊢ (monomial ↑i) (p.coeff ↑i) = 0
|
ce294df16a59e170
|
CategoryTheory.Limits.IsBilimit.total
|
Mathlib/CategoryTheory/Preadditive/Biproducts.lean
|
theorem IsBilimit.total {f : J → C} {b : Bicone f} (i : b.IsBilimit) :
∑ j : J, b.π j ≫ b.ι j = 𝟙 b.pt :=
i.isLimit.hom_ext fun j => by
classical
cases j
simp [sum_comp, b.ι_π, comp_dite]
|
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
J : Type
inst✝ : Fintype J
f : J → C
b : Bicone f
i : b.IsBilimit
j : Discrete J
⊢ (∑ j : J, b.π j ≫ b.ι j) ≫ b.toCone.π.app j = 𝟙 b.pt ≫ b.toCone.π.app j
|
cases j
|
case mk
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
J : Type
inst✝ : Fintype J
f : J → C
b : Bicone f
i : b.IsBilimit
as✝ : J
⊢ (∑ j : J, b.π j ≫ b.ι j) ≫ b.toCone.π.app { as := as✝ } = 𝟙 b.pt ≫ b.toCone.π.app { as := as✝ }
|
2d1f111e47cc7625
|
Subgroup.SchurZassenhausInduction.step2
|
Mathlib/GroupTheory/SchurZassenhaus.lean
|
theorem step2 (K : Subgroup G) [K.Normal] (hK : K ≤ N) : K = ⊥ ∨ K = N
|
case intro.refine_2
G : Type u
inst✝³ : Group G
N : Subgroup G
inst✝² : N.Normal
h1 : (Nat.card ↥N).Coprime N.index
h2 :
∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
Nat.card G' < Nat.card G →
∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
inst✝¹ : Finite G
K : Subgroup G
inst✝ : K.Normal
hK : K ≤ N
this : Function.Surjective ⇑(QuotientGroup.mk' K)
h4 : K ≠ ⊥ ∧ K ≠ N
h5 : Nat.card (G ⧸ K) < Nat.card G
h6 : (Nat.card ↥(map (QuotientGroup.mk' K) N)).Coprime (map (QuotientGroup.mk' K) N).index
H : Subgroup (G ⧸ K)
hH : (map (QuotientGroup.mk' K) N).IsComplement' H
⊢ comap (QuotientGroup.mk' K) H ≠ ⊤
|
rw [← comap_top (QuotientGroup.mk' K)]
|
case intro.refine_2
G : Type u
inst✝³ : Group G
N : Subgroup G
inst✝² : N.Normal
h1 : (Nat.card ↥N).Coprime N.index
h2 :
∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
Nat.card G' < Nat.card G →
∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
inst✝¹ : Finite G
K : Subgroup G
inst✝ : K.Normal
hK : K ≤ N
this : Function.Surjective ⇑(QuotientGroup.mk' K)
h4 : K ≠ ⊥ ∧ K ≠ N
h5 : Nat.card (G ⧸ K) < Nat.card G
h6 : (Nat.card ↥(map (QuotientGroup.mk' K) N)).Coprime (map (QuotientGroup.mk' K) N).index
H : Subgroup (G ⧸ K)
hH : (map (QuotientGroup.mk' K) N).IsComplement' H
⊢ comap (QuotientGroup.mk' K) H ≠ comap (QuotientGroup.mk' K) ⊤
|
1296e7e9af1910d3
|
CategoryTheory.Paths.morphismProperty_eq_top
|
Mathlib/CategoryTheory/PathCategory/MorphismProperty.lean
|
/-- A reformulation of `CategoryTheory.Paths.induction` in terms of `MorphismProperty`. -/
lemma morphismProperty_eq_top
(P : MorphismProperty (Paths V))
(id : ∀ {v : V}, P (𝟙 (of.obj v)))
(comp : ∀ {u v w : V} (p : of.obj u ⟶ of.obj v) (q : v ⟶ w), P p → P (p ≫ of.map q)) :
P = ⊤
|
V : Type u₁
inst✝ : Quiver V
P : MorphismProperty (Paths V)
id : ∀ {v : V}, P (𝟙 (of.obj v))
comp : ∀ {u v w : V} (p : of.obj u ⟶ of.obj v) (q : v ⟶ w), P p → P (p ≫ of.map q)
⊢ P = ⊤
|
ext
|
case h
V : Type u₁
inst✝ : Quiver V
P : MorphismProperty (Paths V)
id : ∀ {v : V}, P (𝟙 (of.obj v))
comp : ∀ {u v w : V} (p : of.obj u ⟶ of.obj v) (q : v ⟶ w), P p → P (p ≫ of.map q)
X✝ Y✝ : Paths V
f✝ : X✝ ⟶ Y✝
⊢ P f✝ ↔ ⊤ f✝
|
d99e50c08e2889c2
|
CategoryTheory.Pretriangulated.shiftFunctorAdd'_op_hom_app
|
Mathlib/CategoryTheory/Triangulated/Opposite/Basic.lean
|
lemma shiftFunctorAdd'_op_hom_app (X : Cᵒᵖ) (a₁ a₂ a₃ : ℤ) (h : a₁ + a₂ = a₃)
(b₁ b₂ b₃ : ℤ) (h₁ : a₁ + b₁ = 0) (h₂ : a₂ + b₂ = 0) (h₃ : a₃ + b₃ = 0) :
(shiftFunctorAdd' Cᵒᵖ a₁ a₂ a₃ h).hom.app X =
(shiftFunctorOpIso C _ _ h₃).hom.app X ≫
((shiftFunctorAdd' C b₁ b₂ b₃ (by omega)).inv.app X.unop).op ≫
(shiftFunctorOpIso C _ _ h₂).inv.app _ ≫
(shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C _ _ h₁).inv.app X)
|
C : Type u_1
inst✝¹ : Category.{?u.8759, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : ℤ
h₁ : a₁ + b₁ = 0
h₂ : a₂ + b₂ = 0
h₃ : a₃ + b₃ = 0
⊢ b₁ + b₂ = b₃
|
omega
|
no goals
|
b022e71c424a408a
|
Matrix.zero_vecMul
|
Mathlib/Data/Matrix/Mul.lean
|
theorem zero_vecMul [Fintype m] (A : Matrix m n α) : 0 ᵥ* A = 0
|
m : Type u_2
n : Type u_3
α : Type v
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A : Matrix m n α
⊢ 0 ᵥ* A = 0
|
ext
|
case h
m : Type u_2
n : Type u_3
α : Type v
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
A : Matrix m n α
x✝ : n
⊢ (0 ᵥ* A) x✝ = 0 x✝
|
6f71e2a75f0cc832
|
hasSum_one_div_nat_pow_mul_sin
|
Mathlib/NumberTheory/ZetaValues.lean
|
theorem hasSum_one_div_nat_pow_mul_sin {k : ℕ} (hk : k ≠ 0) {x : ℝ} (hx : x ∈ Icc (0 : ℝ) 1) :
HasSum (fun n : ℕ => 1 / (n : ℝ) ^ (2 * k + 1) * Real.sin (2 * π * n * x))
((-1 : ℝ) ^ (k + 1) * (2 * π) ^ (2 * k + 1) / 2 / (2 * k + 1)! *
(Polynomial.map (algebraMap ℚ ℝ) (Polynomial.bernoulli (2 * k + 1))).eval x)
|
case h.e'_6
k : ℕ
hk : k ≠ 0
x : ℝ
hx : x ∈ Icc 0 1
⊢ (-1) ^ (k + 1) * I * (2 * ↑π) ^ (2 * k + 1) / ↑(2 * k + 1)! * ↑(bernoulliFun (2 * k + 1) x) =
-(2 * ↑π * I) ^ (2 * k + 1) / ↑(2 * k + 1)! * ↑(bernoulliFun (2 * k + 1) x)
|
congr
|
case h.e'_6.e_a.e_a
k : ℕ
hk : k ≠ 0
x : ℝ
hx : x ∈ Icc 0 1
⊢ (-1) ^ (k + 1) * I * (2 * ↑π) ^ (2 * k + 1) = -(2 * ↑π * I) ^ (2 * k + 1)
|
4ffa37bf4994910e
|
iSup_ge_eq_iSup_nat_add
|
Mathlib/Order/CompleteLattice.lean
|
theorem iSup_ge_eq_iSup_nat_add (u : ℕ → α) (n : ℕ) : ⨆ i ≥ n, u i = ⨆ i, u (i + n)
|
case a
α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ ∀ (i : ℕ), u (i + n) ≤ ⨆ i, ⨆ (_ : i ≥ n), u i
|
exact fun i => le_sSup ⟨i + n, iSup_pos (Nat.le_add_left _ _)⟩
|
no goals
|
bc70894f4edb606a
|
Perfect.exists_nat_bool_injection
|
Mathlib/Topology/MetricSpace/Perfect.lean
|
theorem Perfect.exists_nat_bool_injection
(hC : Perfect C) (hnonempty : C.Nonempty) [CompleteSpace α] :
∃ f : (ℕ → Bool) → α, range f ⊆ C ∧ Continuous f ∧ Injective f
|
case property
α : Type u_1
inst✝¹ : MetricSpace α
C : Set α
hC : Perfect C
hnonempty : C.Nonempty
inst✝ : CompleteSpace α
u : ℕ → ℝ≥0∞
upos' : ∀ (n : ℕ), u n ∈ Ioo 0 1
hu : Tendsto u atTop (nhds 0)
upos : ∀ (n : ℕ), 0 < u n
P : Type (max 0 u_1) := { E // Perfect E ∧ E.Nonempty }
C0 C1 : {C : Set α} → Perfect C → C.Nonempty → {ε : ℝ≥0∞} → 0 < ε → Set α
h0 :
∀ {C : Set α} (hC : Perfect C) (hnonempty : C.Nonempty) {ε : ℝ≥0∞} (hε : 0 < ε),
Perfect (C0 hC hnonempty hε) ∧
(C0 hC hnonempty hε).Nonempty ∧ C0 hC hnonempty hε ⊆ C ∧ EMetric.diam (C0 hC hnonempty hε) ≤ ε
h1 :
∀ {C : Set α} (hC : Perfect C) (hnonempty : C.Nonempty) {ε : ℝ≥0∞} (hε : 0 < ε),
Perfect (C1 hC hnonempty hε) ∧
(C1 hC hnonempty hε).Nonempty ∧ C1 hC hnonempty hε ⊆ C ∧ EMetric.diam (C1 hC hnonempty hε) ≤ ε
hdisj :
∀ {C : Set α} (hC : Perfect C) (hnonempty : C.Nonempty) {ε : ℝ≥0∞} (hε : 0 < ε),
Disjoint (C0 hC hnonempty hε) (C1 hC hnonempty hε)
l : List Bool
ih : P
⊢ Perfect (C1 ⋯ ⋯ ⋯) ∧ (C1 ⋯ ⋯ ⋯).Nonempty
|
exact ⟨(h1 _ _ _).1, (h1 _ _ _).2.1⟩
|
no goals
|
ef9f9f33b845189a
|
Ordinal.isNormal_preOmega
|
Mathlib/SetTheory/Cardinal/Aleph.lean
|
theorem isNormal_preOmega : IsNormal preOmega
|
o : Ordinal.{u_1}
ho : o.IsLimit
a : Ordinal.{u_1}
ha : ∀ b < o, preOmega b ≤ a
b : Ordinal.{u_1}
hb : b < o
⊢ (preOmega b).card < a.card
|
apply lt_of_lt_of_le _ (card_le_card <| ha _ (ho.succ_lt hb))
|
o : Ordinal.{u_1}
ho : o.IsLimit
a : Ordinal.{u_1}
ha : ∀ b < o, preOmega b ≤ a
b : Ordinal.{u_1}
hb : b < o
⊢ (preOmega b).card < (preOmega (succ b)).card
|
a6ce36b2d6f95c46
|
MvPolynomial.isWeightedHomogeneous_monomial
|
Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
|
theorem isWeightedHomogeneous_monomial (w : σ → M) (d : σ →₀ ℕ) (r : R) {m : M}
(hm : weight w d = m) : IsWeightedHomogeneous w (monomial d r) m
|
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
d : σ →₀ ℕ
r : R
m : M
hm : (weight w) d = m
c : σ →₀ ℕ
hc : coeff c ((monomial d) r) ≠ 0
⊢ (weight w) c = m
|
rw [coeff_monomial] at hc
|
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
d : σ →₀ ℕ
r : R
m : M
hm : (weight w) d = m
c : σ →₀ ℕ
hc : (if d = c then r else 0) ≠ 0
⊢ (weight w) c = m
|
8e3ee3ec219eecc4
|
csSup_mem_of_not_isSuccPrelimit
|
Mathlib/Order/SuccPred/CompleteLinearOrder.lean
|
lemma csSup_mem_of_not_isSuccPrelimit
(hne : s.Nonempty) (hbdd : BddAbove s) (hlim : ¬ IsSuccPrelimit (sSup s)) : sSup s ∈ s
|
α : Type u_2
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hne : s.Nonempty
hbdd : BddAbove s
hlim : ¬IsSuccPrelimit (sSup s)
⊢ sSup s ∈ s
|
obtain ⟨y, hy⟩ := not_forall_not.mp hlim
|
case intro
α : Type u_2
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hne : s.Nonempty
hbdd : BddAbove s
hlim : ¬IsSuccPrelimit (sSup s)
y : α
hy : y ⋖ sSup s
⊢ sSup s ∈ s
|
f419e4f7b2c0f097
|
Real.b_ne_one'
|
Mathlib/Analysis/SpecialFunctions/Log/Base.lean
|
theorem b_ne_one' : b ≠ 1
|
b : ℝ
hb : 1 < b
⊢ b ≠ 1
|
linarith
|
no goals
|
f91dfa1112df941b
|
List.Vector.eraseIdx_insertIdx'
|
Mathlib/Data/Vector/Basic.lean
|
theorem eraseIdx_insertIdx' {v : Vector α (n + 1)} :
∀ {i : Fin (n + 1)} {j : Fin (n + 2)},
eraseIdx (j.succAbove i) (insertIdx a j v) = insertIdx a (i.predAbove j) (eraseIdx i v)
| ⟨i, hi⟩, ⟨j, hj⟩ => by
dsimp [insertIdx, eraseIdx, Fin.succAbove, Fin.predAbove]
rw [Subtype.mk_eq_mk]
simp only [Fin.lt_iff_val_lt_val]
split_ifs with hij
· rcases Nat.exists_eq_succ_of_ne_zero
(Nat.pos_iff_ne_zero.1 (lt_of_le_of_lt (Nat.zero_le _) hij)) with ⟨j, rfl⟩
rw [← List.insertIdx_eraseIdx_of_ge]
· simp; rfl
· simpa
· simpa [Nat.lt_succ_iff] using hij
· dsimp
rw [← List.insertIdx_eraseIdx_of_le i j _ _ _]
· rfl
· simpa
· simpa [not_lt] using hij
|
α : Type u_1
n : ℕ
a : α
v : Vector α (n + 1)
i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 2
⊢ (List.insertIdx j a ↑v).eraseIdx ↑(if i < j then ⟨i, ⋯⟩ else ⟨i + 1, ⋯⟩) =
List.insertIdx (↑(if h : i < j then ⟨j, hj⟩.pred ⋯ else ⟨j, hj⟩.castPred ⋯)) a
↑(match v with
| ⟨l, p⟩ => ⟨l.eraseIdx i, ⋯⟩)
|
split_ifs with hij
|
case pos
α : Type u_1
n : ℕ
a : α
v : Vector α (n + 1)
i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 2
hij : i < j
⊢ (List.insertIdx j a ↑v).eraseIdx ↑⟨i, ⋯⟩ =
List.insertIdx (↑(⟨j, hj⟩.pred ⋯)) a
↑(match v with
| ⟨l, p⟩ => ⟨l.eraseIdx i, ⋯⟩)
case neg
α : Type u_1
n : ℕ
a : α
v : Vector α (n + 1)
i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 2
hij : ¬i < j
⊢ (List.insertIdx j a ↑v).eraseIdx ↑⟨i + 1, ⋯⟩ =
List.insertIdx (↑(⟨j, hj⟩.castPred ⋯)) a
↑(match v with
| ⟨l, p⟩ => ⟨l.eraseIdx i, ⋯⟩)
|
8db247d22bea6750
|
MeasureTheory.setToFun_neg
|
Mathlib/MeasureTheory/Integral/SetToL1.lean
|
theorem setToFun_neg (hT : DominatedFinMeasAdditive μ T C) (f : α → E) :
setToFun μ T hT (-f) = -setToFun μ T hT f
|
case neg
α : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T : Set α → E →L[ℝ] F
C : ℝ
hT : DominatedFinMeasAdditive μ T C
f : α → E
hf : ¬Integrable f μ
⊢ ¬Integrable (-f) μ
|
rwa [← integrable_neg_iff] at hf
|
no goals
|
ac93434dec24c688
|
RingHom.OfLocalizationSpanTarget.ofIsLocalization
|
Mathlib/RingTheory/LocalProperties/Basic.lean
|
lemma RingHom.OfLocalizationSpanTarget.ofIsLocalization
(hP : RingHom.OfLocalizationSpanTarget P) (hP' : RingHom.RespectsIso P)
{R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) (s : Set S) (hs : Ideal.span s = ⊤)
(hT : ∀ r : s, ∃ (T : Type u) (_ : CommRing T) (_ : Algebra S T)
(_ : IsLocalization.Away (r : S) T), P ((algebraMap S T).comp f)) : P f
|
case intro.intro.intro.intro
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : OfLocalizationSpanTarget fun {R S} [CommRing R] [CommRing S] => P
hP' : RespectsIso fun {R S} [CommRing R] [CommRing S] => P
R S : Type u
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
s : Set S
hs : Ideal.span s = ⊤
hT✝ : ∀ (r : ↑s), ∃ T x x_1, ∃ (_ : IsLocalization.Away (↑r) T), P ((algebraMap S T).comp f)
r : ↑s
T : Type u
w✝² : CommRing T
w✝¹ : Algebra S T
w✝ : IsLocalization.Away (↑r) T
hT : P ((algebraMap S T).comp f)
⊢ P ((algebraMap S (Localization.Away ↑r)).comp f)
|
convert hP'.1 _
(Localization.algEquiv (R := S) (Submonoid.powers (r : S)) T).symm.toRingEquiv hT
|
case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : OfLocalizationSpanTarget fun {R S} [CommRing R] [CommRing S] => P
hP' : RespectsIso fun {R S} [CommRing R] [CommRing S] => P
R S : Type u
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
s : Set S
hs : Ideal.span s = ⊤
hT✝ : ∀ (r : ↑s), ∃ T x x_1, ∃ (_ : IsLocalization.Away (↑r) T), P ((algebraMap S T).comp f)
r : ↑s
T : Type u
w✝² : CommRing T
w✝¹ : Algebra S T
w✝ : IsLocalization.Away (↑r) T
hT : P ((algebraMap S T).comp f)
⊢ (algebraMap S (Localization.Away ↑r)).comp f =
(Localization.algEquiv (Submonoid.powers ↑r) T).symm.toRingEquiv.toRingHom.comp ((algebraMap S T).comp f)
|
e05ee18a3e87f750
|
ENNReal.mul_div_cancel_right
|
Mathlib/Data/ENNReal/Inv.lean
|
/-- See `ENNReal.mul_div_cancel_right'` for a stronger version. -/
protected lemma mul_div_cancel_right (hb₀ : b ≠ 0) (hb : b ≠ ∞) : a * b / b = a :=
ENNReal.mul_div_cancel_right' (by simp [hb₀]) (by simp [hb])
|
a b : ℝ≥0∞
hb₀ : b ≠ 0
hb : b ≠ ⊤
⊢ b = ⊤ → a = 0
|
simp [hb]
|
no goals
|
39621360c887d130
|
GaussianInt.mod_four_eq_three_of_nat_prime_of_prime
|
Mathlib/NumberTheory/Zsqrtd/QuadraticReciprocity.lean
|
theorem mod_four_eq_three_of_nat_prime_of_prime (p : ℕ) [hp : Fact p.Prime]
(hpi : Prime (p : ℤ[i])) : p % 4 = 3 :=
hp.1.eq_two_or_odd.elim
(fun hp2 => by
have := hpi.irreducible.isUnit_or_isUnit (a := ⟨1, 1⟩) (b := ⟨1, -1⟩)
simp [hp2, Zsqrtd.ext_iff, ← norm_eq_one_iff, norm_def] at this)
fun hp1 =>
by_contradiction fun hp3 : p % 4 ≠ 3 => by
have hp41 : p % 4 = 1
|
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ZMod p
hk : -1 = k * k
⊢ False
|
obtain ⟨k, k_lt_p, rfl⟩ : ∃ (k' : ℕ) (_ : k' < p), (k' : ZMod p) = k := by
exact ⟨k.val, k.val_lt, ZMod.natCast_zmod_val k⟩
|
case intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
hpi : Prime ↑p
hp1 : p % 2 = 1
hp3 : p % 4 ≠ 3
hp41 : p % 4 = 1
k : ℕ
k_lt_p : k < p
hk : -1 = ↑k * ↑k
⊢ False
|
9ab49eaa8ecd58e2
|
MvQPF.wEquiv.symm
|
Mathlib/Data/QPF/Multivariate/Constructions/Fix.lean
|
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x
|
case trans
n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x✝ y✝ x y z : (P F).W α
_e₁ : WEquiv x y
_e₂ : WEquiv y z
ih₁ : WEquiv y x
ih₂ : WEquiv z y
⊢ WEquiv z x
|
exact MvQPF.WEquiv.trans _ _ _ ih₂ ih₁
|
no goals
|
1c556c738b614841
|
RegularExpression.star_rmatch_iff
|
Mathlib/Computability/RegularExpressions.lean
|
theorem star_rmatch_iff (P : RegularExpression α) :
∀ x : List α, (star P).rmatch x ↔ ∃ S : List (List α), x
= S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t :=
fun x => by
have IH := fun t (_h : List.length t < List.length x) => star_rmatch_iff P t
clear star_rmatch_iff
constructor
· rcases x with - | ⟨a, x⟩
· intro _h
use []; dsimp; tauto
· rw [rmatch, deriv, mul_rmatch_iff]
rintro ⟨t, u, hs, ht, hu⟩
have hwf : u.length < (List.cons a x).length
|
α : Type u_1
inst✝ : DecidableEq α
P : RegularExpression α
a : α
x : List α
IH :
∀ (t : List α),
t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.flatten
⊢ U.flatten.length < (a :: x).length
|
rw [hsum.1, hsum.2]
|
α : Type u_1
inst✝ : DecidableEq α
P : RegularExpression α
a : α
x : List α
IH :
∀ (t : List α),
t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.flatten
⊢ U.flatten.length < (b :: (t ++ U.flatten)).length
|
8215ce2ddbd6bd2a
|
tendsto_integral_mulExpNegMulSq_comp
|
Mathlib/Analysis/SpecialFunctions/MulExpNegMulSqIntegral.lean
|
theorem tendsto_integral_mulExpNegMulSq_comp (g : E →ᵇ ℝ) :
Tendsto (fun ε => ∫ x, mulExpNegMulSq ε (g x) ∂P) (𝓝[>] 0) (𝓝 (∫ x, g x ∂P))
|
case a.intro
E : Type u_1
inst✝³ : TopologicalSpace E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
P : Measure E
inst✝ : IsFiniteMeasure P
g : E →ᵇ ℝ
u : ℕ → ℝ
hu : Tendsto u atTop (𝓝[>] 0)
N : ℕ
hupos : ∀ b ≥ N, u b ∈ Set.Ioi 0
⊢ Tendsto ((fun ε => ∫ (x : E), ε.mulExpNegMulSq (g x) ∂P) ∘ u) atTop (𝓝 (∫ (x : E), g x ∂P))
|
apply tendsto_integral_filter_of_norm_le_const ?h_meas ?h_bound ?h_lim
|
case h_meas
E : Type u_1
inst✝³ : TopologicalSpace E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
P : Measure E
inst✝ : IsFiniteMeasure P
g : E →ᵇ ℝ
u : ℕ → ℝ
hu : Tendsto u atTop (𝓝[>] 0)
N : ℕ
hupos : ∀ b ≥ N, u b ∈ Set.Ioi 0
⊢ ∀ᶠ (n : ℕ) in atTop, AEStronglyMeasurable (fun ω => (u n).mulExpNegMulSq (g ω)) P
case h_bound
E : Type u_1
inst✝³ : TopologicalSpace E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
P : Measure E
inst✝ : IsFiniteMeasure P
g : E →ᵇ ℝ
u : ℕ → ℝ
hu : Tendsto u atTop (𝓝[>] 0)
N : ℕ
hupos : ∀ b ≥ N, u b ∈ Set.Ioi 0
⊢ ∃ C, ∀ᶠ (n : ℕ) in atTop, ∀ᵐ (ω : E) ∂P, ‖(u n).mulExpNegMulSq (g ω)‖ ≤ C
case h_lim
E : Type u_1
inst✝³ : TopologicalSpace E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
P : Measure E
inst✝ : IsFiniteMeasure P
g : E →ᵇ ℝ
u : ℕ → ℝ
hu : Tendsto u atTop (𝓝[>] 0)
N : ℕ
hupos : ∀ b ≥ N, u b ∈ Set.Ioi 0
⊢ ∀ᵐ (ω : E) ∂P, Tendsto (fun n => (u n).mulExpNegMulSq (g ω)) atTop (𝓝 (g ω))
|
9677e28f00b7be5e
|
MeasureTheory.lintegral_lintegral_mul_inv
|
Mathlib/MeasureTheory/Group/Prod.lean
|
theorem lintegral_lintegral_mul_inv [IsMulLeftInvariant ν] (f : G → G → ℝ≥0∞)
(hf : AEMeasurable (uncurry f) (μ.prod ν)) :
(∫⁻ x, ∫⁻ y, f (y * x) x⁻¹ ∂ν ∂μ) = ∫⁻ x, ∫⁻ y, f x y ∂ν ∂μ
|
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f) (μ.prod ν)
h : Measurable fun z => (z.2 * z.1, z.1⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹) (μ.prod ν)
⊢ ∫⁻ (z : G × G), f (z.2 * z.1) z.1⁻¹ ∂μ.prod ν = ∫⁻ (z : G × G), f z.1 z.2 ∂μ.prod ν
|
conv_rhs => rw [← (measurePreserving_mul_prod_inv μ ν).map_eq]
|
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f) (μ.prod ν)
h : Measurable fun z => (z.2 * z.1, z.1⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹) (μ.prod ν)
⊢ ∫⁻ (z : G × G), f (z.2 * z.1) z.1⁻¹ ∂μ.prod ν =
∫⁻ (z : G × G), f z.1 z.2 ∂map (fun z => (z.2 * z.1, z.1⁻¹)) (μ.prod ν)
|
5030442f8dec594f
|
AffineSubspace.direction_affineSpan_insert
|
Mathlib/LinearAlgebra/AffineSpace/AffineSubspace/Basic.lean
|
theorem direction_affineSpan_insert {s : AffineSubspace k P} {p₁ p₂ : P} (hp₁ : p₁ ∈ s) :
(affineSpan k (insert p₂ (s : Set P))).direction =
Submodule.span k {p₂ -ᵥ p₁} ⊔ s.direction
|
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p₁ p₂ : P
hp₁ : p₁ ∈ s
⊢ (affineSpan k (↑s ∪ ↑(affineSpan k {p₂}))).direction = s.direction ⊔ Submodule.span k {p₂ -ᵥ p₁}
|
change (s ⊔ affineSpan k {p₂}).direction = _
|
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p₁ p₂ : P
hp₁ : p₁ ∈ s
⊢ (s ⊔ affineSpan k {p₂}).direction = s.direction ⊔ Submodule.span k {p₂ -ᵥ p₁}
|
35d3596013473b81
|
Nat.Partrec.Code.evaln_sound
|
Mathlib/Computability/PartrecCode.lean
|
theorem evaln_sound : ∀ {k c n x}, x ∈ evaln k c n → x ∈ eval c n
| 0, _, n, x, h => by simp [evaln] at h
| k + 1, c, n, x, h => by
induction' c with cf cg hf hg cf cg hf hg cf cg hf hg cf hf generalizing x n <;>
simp [eval, evaln, Option.bind_eq_some, Seq.seq] at h ⊢ <;>
obtain ⟨_, h⟩ := h
iterate 4 simpa [pure, PFun.pure, eq_comm] using h
· -- pair cf cg
rcases h with ⟨y, ef, z, eg, rfl⟩
exact ⟨_, hf _ _ ef, _, hg _ _ eg, rfl⟩
· --comp hf hg
rcases h with ⟨y, eg, ef⟩
exact ⟨_, hg _ _ eg, hf _ _ ef⟩
· -- prec cf cg
revert h
induction' n.unpair.2 with m IH generalizing x <;> simp [Option.bind_eq_some]
· apply hf
· refine fun y h₁ h₂ => ⟨y, IH _ ?_, ?_⟩
· have := evaln_mono k.le_succ h₁
simp [evaln, Option.bind_eq_some] at this
exact this.2
· exact hg _ _ h₂
· -- rfind' cf
rcases h with ⟨m, h₁, h₂⟩
by_cases m0 : m = 0 <;> simp [m0] at h₂
· exact
⟨0, ⟨by simpa [m0] using hf _ _ h₁, fun {m} => (Nat.not_lt_zero _).elim⟩, by simp [h₂]⟩
· have := evaln_sound h₂
simp [eval] at this
rcases this with ⟨y, ⟨hy₁, hy₂⟩, rfl⟩
refine
⟨y + 1, ⟨by simpa [add_comm, add_left_comm] using hy₁, fun {i} im => ?_⟩, by
simp [add_comm, add_left_comm]⟩
rcases i with - | i
· exact ⟨m, by simpa using hf _ _ h₁, m0⟩
· rcases hy₂ (Nat.lt_of_succ_lt_succ im) with ⟨z, hz, z0⟩
exact ⟨z, by simpa [add_comm, add_left_comm] using hz, z0⟩
|
k : ℕ
cf : Code
hf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n
n : ℕ
left✝ : n ≤ k
m : ℕ
h₁ : evaln (k + 1) cf n = some m
m0 : ¬m = 0
y : ℕ
hy₁ : 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1)))
hy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m + ((unpair n).2 + 1))), ¬a = 0
h₂ : evaln k cf.rfind' (Nat.pair (unpair n).1 ((unpair n).2 + 1)) = some (y + ((unpair n).2 + 1))
i : ℕ
im : i + 1 < y + 1
z : ℕ
hz : z ∈ cf.eval (Nat.pair (unpair n).1 (i + ((unpair n).2 + 1)))
z0 : ¬z = 0
⊢ z ∈ cf.eval (Nat.pair (unpair n).1 (i + 1 + (unpair n).2))
|
simpa [add_comm, add_left_comm] using hz
|
no goals
|
0a43fa3ebdc9ae7d
|
Asymptotics.IsBigOWith.prod_left_same
|
Mathlib/Analysis/Asymptotics/Defs.lean
|
theorem IsBigOWith.prod_left_same (hf : IsBigOWith c l f' k') (hg : IsBigOWith c l g' k') :
IsBigOWith c l (fun x => (f' x, g' x)) k'
|
α : Type u_1
E' : Type u_6
F' : Type u_7
G' : Type u_8
inst✝² : SeminormedAddCommGroup E'
inst✝¹ : SeminormedAddCommGroup F'
inst✝ : SeminormedAddCommGroup G'
c : ℝ
f' : α → E'
g' : α → F'
k' : α → G'
l : Filter α
hf : IsBigOWith c l f' k'
hg : IsBigOWith c l g' k'
⊢ IsBigOWith c l (fun x => (f' x, g' x)) k'
|
rw [isBigOWith_iff] at *
|
α : Type u_1
E' : Type u_6
F' : Type u_7
G' : Type u_8
inst✝² : SeminormedAddCommGroup E'
inst✝¹ : SeminormedAddCommGroup F'
inst✝ : SeminormedAddCommGroup G'
c : ℝ
f' : α → E'
g' : α → F'
k' : α → G'
l : Filter α
hf : ∀ᶠ (x : α) in l, ‖f' x‖ ≤ c * ‖k' x‖
hg : ∀ᶠ (x : α) in l, ‖g' x‖ ≤ c * ‖k' x‖
⊢ ∀ᶠ (x : α) in l, ‖(f' x, g' x)‖ ≤ c * ‖k' x‖
|
4d78b2c090b9c6ef
|
MvPolynomial.IsWeightedHomogeneous.weightedHomogeneousComponent_same
|
Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
|
theorem IsWeightedHomogeneous.weightedHomogeneousComponent_same {m : M} {p : MvPolynomial σ R}
(hp : IsWeightedHomogeneous w p m) :
weightedHomogeneousComponent w m p = p
|
case a
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
m : M
p : MvPolynomial σ R
hp : IsWeightedHomogeneous w p m
x : σ →₀ ℕ
⊢ (if (weight w) x = m then coeff x p else 0) = coeff x p
|
by_cases zero_coeff : coeff x p = 0
|
case pos
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
m : M
p : MvPolynomial σ R
hp : IsWeightedHomogeneous w p m
x : σ →₀ ℕ
zero_coeff : coeff x p = 0
⊢ (if (weight w) x = m then coeff x p else 0) = coeff x p
case neg
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
m : M
p : MvPolynomial σ R
hp : IsWeightedHomogeneous w p m
x : σ →₀ ℕ
zero_coeff : ¬coeff x p = 0
⊢ (if (weight w) x = m then coeff x p else 0) = coeff x p
|
61924f9884b810f2
|
Algebra.FormallyEtale.iff_exists_algEquiv_prod
|
Mathlib/RingTheory/Etale/Field.lean
|
theorem iff_exists_algEquiv_prod [EssFiniteType K A] :
FormallyEtale K A ↔
∃ (I : Type u) (_ : Finite I) (Ai : I → Type u) (_ : ∀ i, Field (Ai i))
(_ : ∀ i, Algebra K (Ai i)) (_ : A ≃ₐ[K] Π i, Ai i),
∀ i, Algebra.IsSeparable K (Ai i)
|
K A : Type u
inst✝³ : Field K
inst✝² : CommRing A
inst✝¹ : Algebra K A
inst✝ : EssFiniteType K A
I : Type u
w✝² : Finite I
Ai : I → Type u
w✝¹ : (i : I) → Field (Ai i)
w✝ : (i : I) → Algebra K (Ai i)
e : A ≃ₐ[K] (i : I) → Ai i
h✝ : ∀ (i : I), Algebra.IsSeparable K (Ai i)
i : I
this✝¹ : Algebra A (Ai i) := ((Pi.evalRingHom Ai i).comp e.toRingEquiv.toRingHom).toAlgebra
this✝ : IsScalarTower K A (Ai i)
this : FiniteType A (Ai i)
⊢ EssFiniteType K (Ai i)
|
exact EssFiniteType.comp K A (Ai i)
|
no goals
|
bed71e21534c428f
|
DualNumber.isMaximal_span_singleton_eps
|
Mathlib/RingTheory/DualNumber.lean
|
lemma isMaximal_span_singleton_eps [DivisionRing K] :
(Ideal.span {ε} : Ideal K[ε]).IsMaximal
|
case refine_2.inr.inr
K : Type u_2
inst✝ : DivisionRing K
hI : Ideal.span {ε} < ⊤
⊢ ⊤ = ⊤
|
simp
|
no goals
|
4856da4c4e023ce4
|
GromovHausdorff.toGHSpace_eq_toGHSpace_iff_isometryEquiv
|
Mathlib/Topology/MetricSpace/GromovHausdorff.lean
|
theorem toGHSpace_eq_toGHSpace_iff_isometryEquiv {X : Type u} [MetricSpace X] [CompactSpace X]
[Nonempty X] {Y : Type v} [MetricSpace Y] [CompactSpace Y] [Nonempty Y] :
toGHSpace X = toGHSpace Y ↔ Nonempty (X ≃ᵢ Y) :=
⟨by
simp only [toGHSpace]
rw [Quotient.eq]
rintro ⟨e⟩
have I :
(NonemptyCompacts.kuratowskiEmbedding X ≃ᵢ NonemptyCompacts.kuratowskiEmbedding Y) =
(range (kuratowskiEmbedding X) ≃ᵢ range (kuratowskiEmbedding Y))
|
X : Type u
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
Y : Type v
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
⊢ ⟦NonemptyCompacts.kuratowskiEmbedding X⟧ = ⟦NonemptyCompacts.kuratowskiEmbedding Y⟧ → Nonempty (X ≃ᵢ Y)
|
rw [Quotient.eq]
|
X : Type u
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
Y : Type v
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
⊢ IsometryRel.setoid (NonemptyCompacts.kuratowskiEmbedding X) (NonemptyCompacts.kuratowskiEmbedding Y) →
Nonempty (X ≃ᵢ Y)
|
458e5e4306906052
|
Turing.PartrecToTM2.tr_ret_respects
|
Mathlib/Computability/TMToPartrec.lean
|
theorem tr_ret_respects (k v s) : ∃ b₂,
TrCfg (stepRet k v) b₂ ∧
Reaches₁ (TM2.step tr)
⟨some (Λ'.ret (trCont k)), s, K'.elim (trList v) [] [] (trContStack k)⟩ b₂
|
case fix
f : Code
k : Cont
IH :
∀ (v : List ℕ) (s : Option Γ'),
∃ b₂,
TrCfg (stepRet k v) b₂ ∧
Reaches₁ (TM2.step tr) { l := some (Λ'.ret (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
b₂
v : List ℕ
s : Option Γ'
this :
if v.headI = 0 then natEnd (trList v).head?.iget = true ∧ (trList v).tail = trList v.tail
else natEnd (trList v).head?.iget = false ∧ (trList v).tail = (trNat v.headI).tail ++ Γ'.cons :: trList v.tail
⊢ ∃ b₂,
TrCfg (if v.headI = 0 then stepRet k v.tail else stepNormal f (Cont.fix f k) v.tail) b₂ ∧
Reaches₁ (TM2.step tr)
{ l := some (Λ'.ret (trCont (Cont.fix f k))), var := s,
stk := elim (trList v) [] [] (trContStack (Cont.fix f k)) }
b₂
|
by_cases h : v.headI = 0 <;> simp only [h, ite_true, ite_false] at this ⊢
|
case pos
f : Code
k : Cont
IH :
∀ (v : List ℕ) (s : Option Γ'),
∃ b₂,
TrCfg (stepRet k v) b₂ ∧
Reaches₁ (TM2.step tr) { l := some (Λ'.ret (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
b₂
v : List ℕ
s : Option Γ'
h : v.headI = 0
this : natEnd (trList v).head?.iget = true ∧ (trList v).tail = trList v.tail
⊢ ∃ b₂,
TrCfg (stepRet k v.tail) b₂ ∧
Reaches₁ (TM2.step tr)
{ l := some (Λ'.ret (trCont (Cont.fix f k))), var := s,
stk := elim (trList v) [] [] (trContStack (Cont.fix f k)) }
b₂
case neg
f : Code
k : Cont
IH :
∀ (v : List ℕ) (s : Option Γ'),
∃ b₂,
TrCfg (stepRet k v) b₂ ∧
Reaches₁ (TM2.step tr) { l := some (Λ'.ret (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
b₂
v : List ℕ
s : Option Γ'
h : ¬v.headI = 0
this : natEnd (trList v).head?.iget = false ∧ (trList v).tail = (trNat v.headI).tail ++ Γ'.cons :: trList v.tail
⊢ ∃ b₂,
TrCfg (stepNormal f (Cont.fix f k) v.tail) b₂ ∧
Reaches₁ (TM2.step tr)
{ l := some (Λ'.ret (trCont (Cont.fix f k))), var := s,
stk := elim (trList v) [] [] (trContStack (Cont.fix f k)) }
b₂
|
5079d8447f8a95d7
|
hasFDerivWithinAt_closure_of_tendsto_fderiv
|
Mathlib/Analysis/Calculus/FDeriv/Extend.lean
|
theorem hasFDerivWithinAt_closure_of_tendsto_fderiv {f : E → F} {s : Set E} {x : E} {f' : E →L[ℝ] F}
(f_diff : DifferentiableOn ℝ f s) (s_conv : Convex ℝ s) (s_open : IsOpen s)
(f_cont : ∀ y ∈ closure s, ContinuousWithinAt f s y)
(h : Tendsto (fun y => fderiv ℝ f y) (𝓝[s] x) (𝓝 f')) :
HasFDerivWithinAt f f' (closure s) x
|
case mk.intro
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
f' : E →L[ℝ] F
f_diff : DifferentiableOn ℝ f s
s_conv : Convex ℝ s
s_open : IsOpen s
f_cont : ∀ y ∈ closure s, ContinuousWithinAt f s y
h : Tendsto (fun y => fderiv ℝ f y) (𝓝[s] x) (𝓝 f')
hx : x ∈ closure s
ε : ℝ
ε_pos : 0 < ε
δ : ℝ
δ_pos : δ > 0
hδ : ∀ y ∈ s, dist y x < δ → ‖fderiv ℝ f y - f'‖ < ε
B : Set E := ball x δ
u v : E
u_in : (u, v).1 ∈ B ∩ s
v_in : (u, v).2 ∈ B ∩ s
conv : Convex ℝ (B ∩ s)
⊢ ‖f (u, v).2 - f (u, v).1 - (f' (u, v).2 - f' (u, v).1)‖ ≤ ε * ‖(u, v).2 - (u, v).1‖
|
have diff : DifferentiableOn ℝ f (B ∩ s) := f_diff.mono inter_subset_right
|
case mk.intro
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
s : Set E
x : E
f' : E →L[ℝ] F
f_diff : DifferentiableOn ℝ f s
s_conv : Convex ℝ s
s_open : IsOpen s
f_cont : ∀ y ∈ closure s, ContinuousWithinAt f s y
h : Tendsto (fun y => fderiv ℝ f y) (𝓝[s] x) (𝓝 f')
hx : x ∈ closure s
ε : ℝ
ε_pos : 0 < ε
δ : ℝ
δ_pos : δ > 0
hδ : ∀ y ∈ s, dist y x < δ → ‖fderiv ℝ f y - f'‖ < ε
B : Set E := ball x δ
u v : E
u_in : (u, v).1 ∈ B ∩ s
v_in : (u, v).2 ∈ B ∩ s
conv : Convex ℝ (B ∩ s)
diff : DifferentiableOn ℝ f (B ∩ s)
⊢ ‖f (u, v).2 - f (u, v).1 - (f' (u, v).2 - f' (u, v).1)‖ ≤ ε * ‖(u, v).2 - (u, v).1‖
|
b73104c22d482296
|
IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed
|
Mathlib/Topology/Compactness/Compact.lean
|
theorem IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed
{ι : Type v} [hι : Nonempty ι] (t : ι → Set X) (htd : Directed (· ⊇ ·) t)
(htn : ∀ i, (t i).Nonempty) (htc : ∀ i, IsCompact (t i)) (htcl : ∀ i, IsClosed (t i)) :
(⋂ i, t i).Nonempty
|
case intro.intro
X : Type u
inst✝ : TopologicalSpace X
ι : Type v
hι : Nonempty ι
t : ι → Set X
htd : Directed (fun x1 x2 => x1 ⊇ x2) t
htc : ∀ (i : ι), IsCompact (t i)
htcl : ∀ (i : ι), IsClosed (t i)
i₀ : ι := hι.some
htn : ∀ (i : ι), (t i).Nonempty
i j : ι
hji₀ : t i₀ ⊇ t j
hji : t i ⊇ t j
⊢ (t i₀ ∩ t i).Nonempty
|
exact (htn j).mono (subset_inter hji₀ hji)
|
no goals
|
6ce44587c65756d8
|
bernoulliPowerSeries_mul_exp_sub_one
|
Mathlib/NumberTheory/Bernoulli.lean
|
theorem bernoulliPowerSeries_mul_exp_sub_one : bernoulliPowerSeries A * (exp A - 1) = X
|
case h.succ.succ.h
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
hfact : ∀ (m : ℕ), ↑m ! ≠ 0
hite2 : (if n.succ = 0 then 1 else 0) = 0
x : ℕ × ℕ
h : x.1 + x.2 = n.succ
⊢ ↑x.2! * (↑x.2 + 1) = (↑x.2 + 1) * ↑x.2! ∨ (x.1 + x.2)! = 0
|
left
|
case h.succ.succ.h.h
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
hfact : ∀ (m : ℕ), ↑m ! ≠ 0
hite2 : (if n.succ = 0 then 1 else 0) = 0
x : ℕ × ℕ
h : x.1 + x.2 = n.succ
⊢ ↑x.2! * (↑x.2 + 1) = (↑x.2 + 1) * ↑x.2!
|
0c6cdd2eaa278054
|
EReal.nhds_bot_basis
|
Mathlib/Topology/Instances/EReal/Lemmas.lean
|
theorem nhds_bot_basis : (𝓝 (⊥ : EReal)).HasBasis (fun _ : ℝ ↦ True) (Iio ·)
|
case intro.intro
x : EReal
hx : ⊥ < x
y : ℚ
hxy : ↑↑y < x
⊢ ∃ i', True ∧ Iio ↑i' ⊆ Iio x
|
exact ⟨_, trivial, Iio_subset_Iio hxy.le⟩
|
no goals
|
ed8f653a28830301
|
EuclideanDomain.mod_eq_zero
|
Mathlib/Algebra/EuclideanDomain/Basic.lean
|
theorem mod_eq_zero {a b : R} : a % b = 0 ↔ b ∣ a :=
⟨fun h => by
rw [← div_add_mod a b, h, add_zero]
exact dvd_mul_right _ _, fun ⟨c, e⟩ => by
rw [e, ← add_left_cancel_iff, div_add_mod, add_zero]
haveI := Classical.dec
by_cases b0 : b = 0
· simp only [b0, zero_mul]
· rw [mul_div_cancel_left₀ _ b0]⟩
|
R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
⊢ b * c = b * (b * c / b)
|
by_cases b0 : b = 0
|
case pos
R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
b0 : b = 0
⊢ b * c = b * (b * c / b)
case neg
R : Type u
inst✝ : EuclideanDomain R
a b : R
x✝ : b ∣ a
c : R
e : a = b * c
this : (p : Prop) → Decidable p
b0 : ¬b = 0
⊢ b * c = b * (b * c / b)
|
b42d0fe6e6a8faaf
|
ContinuousLinearMap.apply_norm_sq_eq_inner_adjoint_left
|
Mathlib/Analysis/InnerProductSpace/Adjoint.lean
|
theorem apply_norm_sq_eq_inner_adjoint_left (A : E →L[𝕜] F) (x : E) :
‖A x‖ ^ 2 = re ⟪(A† ∘L A) x, x⟫
|
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
A : E →L[𝕜] F
x : E
⊢ ⟪((adjoint A).comp A) x, x⟫_𝕜 = ⟪(adjoint A) (A x), x⟫_𝕜
|
rfl
|
no goals
|
777303bf55f47c11
|
ENNReal.funMulInvSnorm_rpow
|
Mathlib/MeasureTheory/Integral/MeanInequalities.lean
|
theorem funMulInvSnorm_rpow {p : ℝ} (hp0 : 0 < p) {f : α → ℝ≥0∞} {a : α} :
funMulInvSnorm f p μ a ^ p = f a ^ p * (∫⁻ c, f c ^ p ∂μ)⁻¹
|
α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 < p
f : α → ℝ≥0∞
a : α
⊢ ((∫⁻ (c : α), f c ^ p ∂μ) ^ (1 / p))⁻¹ ^ p = (∫⁻ (c : α), f c ^ p ∂μ)⁻¹
|
rw [inv_rpow, ← rpow_mul, one_div_mul_cancel hp0.ne', rpow_one]
|
no goals
|
221200e8b4b5a745
|
MeasureTheory.Measure.IsEverywherePos.IsGdelta_of_isMulLeftInvariant
|
Mathlib/MeasureTheory/Measure/EverywherePos.lean
|
/-- If a compact closed set is everywhere positive with respect to a left-invariant measure on a
topological group, then it is a Gδ set. This is nontrivial, as there is no second-countability or
metrizability assumption in the statement, so a general compact closed set has no reason to be
a countable intersection of open sets. -/
@[to_additive]
lemma IsEverywherePos.IsGdelta_of_isMulLeftInvariant
{k : Set G} (h : μ.IsEverywherePos k) (hk : IsCompact k) (h'k : IsClosed k) :
IsGδ k
|
case intro.intro.intro.intro.intro
G : Type u_2
inst✝⁸ : Group G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : IsTopologicalGroup G
inst✝⁵ : LocallyCompactSpace G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
μ : Measure G
inst✝² : μ.IsMulLeftInvariant
inst✝¹ : IsFiniteMeasureOnCompacts μ
inst✝ : μ.InnerRegularCompactLTTop
k : Set G
h : μ.IsEverywherePos k
hk : IsCompact k
h'k : IsClosed k
u : ℕ → ℝ≥0∞
u_mem : ∀ (n : ℕ), u n ∈ Ioo 0 1
u_lim : Tendsto u atTop (𝓝 0)
W : ℕ → Set G
W_open : ∀ (n : ℕ), IsOpen (W n)
mem_W : ∀ (n : ℕ), 1 ∈ W n
hW : ∀ (n : ℕ), ∀ g ∈ W n * W n, μ (g • k \ k) < u n
V : ℕ → Set G := fun n => ⋂ i ∈ Finset.range n, W i
x : G
hx : x ∈ ⋂ n, V n * k
v : ℕ → G
hv : ∀ (i : ℕ), v i ∈ V i
y : ℕ → G
hy : ∀ (i : ℕ), y i ∈ k
hvy : ∀ (i : ℕ), (fun x1 x2 => x1 * x2) (v i) (y i) = x
z : G
zk : z ∈ k
hz : MapClusterPt z atTop y
A : ∀ (n : ℕ), μ ((x * z⁻¹) • k \ k) ≤ u n
⊢ x ∈ k
|
have B : μ (((x * z ⁻¹) • k) \ k) = 0 :=
le_antisymm (ge_of_tendsto u_lim (Eventually.of_forall A)) bot_le
|
case intro.intro.intro.intro.intro
G : Type u_2
inst✝⁸ : Group G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : IsTopologicalGroup G
inst✝⁵ : LocallyCompactSpace G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
μ : Measure G
inst✝² : μ.IsMulLeftInvariant
inst✝¹ : IsFiniteMeasureOnCompacts μ
inst✝ : μ.InnerRegularCompactLTTop
k : Set G
h : μ.IsEverywherePos k
hk : IsCompact k
h'k : IsClosed k
u : ℕ → ℝ≥0∞
u_mem : ∀ (n : ℕ), u n ∈ Ioo 0 1
u_lim : Tendsto u atTop (𝓝 0)
W : ℕ → Set G
W_open : ∀ (n : ℕ), IsOpen (W n)
mem_W : ∀ (n : ℕ), 1 ∈ W n
hW : ∀ (n : ℕ), ∀ g ∈ W n * W n, μ (g • k \ k) < u n
V : ℕ → Set G := fun n => ⋂ i ∈ Finset.range n, W i
x : G
hx : x ∈ ⋂ n, V n * k
v : ℕ → G
hv : ∀ (i : ℕ), v i ∈ V i
y : ℕ → G
hy : ∀ (i : ℕ), y i ∈ k
hvy : ∀ (i : ℕ), (fun x1 x2 => x1 * x2) (v i) (y i) = x
z : G
zk : z ∈ k
hz : MapClusterPt z atTop y
A : ∀ (n : ℕ), μ ((x * z⁻¹) • k \ k) ≤ u n
B : μ ((x * z⁻¹) • k \ k) = 0
⊢ x ∈ k
|
5dba91f75a485a07
|
MeasureTheory.Measure.mkMetric_le_liminf_tsum
|
Mathlib/MeasureTheory/Measure/Hausdorff.lean
|
theorem mkMetric_le_liminf_tsum {β : Type*} {ι : β → Type*} [∀ n, Countable (ι n)] (s : Set X)
{l : Filter β} (r : β → ℝ≥0∞) (hr : Tendsto r l (𝓝 0)) (t : ∀ n : β, ι n → Set X)
(ht : ∀ᶠ n in l, ∀ i, diam (t n i) ≤ r n) (hst : ∀ᶠ n in l, s ⊆ ⋃ i, t n i) (m : ℝ≥0∞ → ℝ≥0∞) :
mkMetric m s ≤ liminf (fun n => ∑' i, m (diam (t n i))) l
|
X : Type u_2
inst✝³ : EMetricSpace X
inst✝² : MeasurableSpace X
inst✝¹ : BorelSpace X
β : Type u_4
ι : β → Type u_5
inst✝ : ∀ (n : β), Countable (ι n)
s : Set X
l : Filter β
r : β → ℝ≥0∞
hr : Tendsto r l (𝓝 0)
t : (n : β) → ι n → Set X
ht : ∀ᶠ (n : β) in l, ∀ (i : ι n), diam (t n i) ≤ r n
hst : ∀ᶠ (n : β) in l, s ⊆ ⋃ i, t n i
m : ℝ≥0∞ → ℝ≥0∞
this : (n : β) → Encodable (ι n)
ε : ℝ≥0∞
hε : 0 < ε
⊢ ⨅ t, ⨅ (_ : s ⊆ iUnion t), ⨅ (_ : ∀ (n : ℕ), diam (t n) ≤ ε), ∑' (n : ℕ), ⨆ (_ : (t n).Nonempty), m (diam (t n)) ≤
liminf (fun n => ∑' (i : ι n), m (diam (t n i))) l
|
refine le_of_forall_gt_imp_ge_of_dense fun c hc => ?_
|
X : Type u_2
inst✝³ : EMetricSpace X
inst✝² : MeasurableSpace X
inst✝¹ : BorelSpace X
β : Type u_4
ι : β → Type u_5
inst✝ : ∀ (n : β), Countable (ι n)
s : Set X
l : Filter β
r : β → ℝ≥0∞
hr : Tendsto r l (𝓝 0)
t : (n : β) → ι n → Set X
ht : ∀ᶠ (n : β) in l, ∀ (i : ι n), diam (t n i) ≤ r n
hst : ∀ᶠ (n : β) in l, s ⊆ ⋃ i, t n i
m : ℝ≥0∞ → ℝ≥0∞
this : (n : β) → Encodable (ι n)
ε : ℝ≥0∞
hε : 0 < ε
c : ℝ≥0∞
hc : liminf (fun n => ∑' (i : ι n), m (diam (t n i))) l < c
⊢ ⨅ t, ⨅ (_ : s ⊆ iUnion t), ⨅ (_ : ∀ (n : ℕ), diam (t n) ≤ ε), ∑' (n : ℕ), ⨆ (_ : (t n).Nonempty), m (diam (t n)) ≤ c
|
45914e8e7bc6bf9d
|
CategoryTheory.PresheafHom.IsSheafFor.exists_app
|
Mathlib/CategoryTheory/Sites/SheafHom.lean
|
lemma exists_app (hx : x.Compatible) (g : Y ⟶ X) :
∃ (φ : F.obj (op Y) ⟶ G.obj (op Y)),
∀ {Z : C} (p : Z ⟶ Y) (hp : S (p ≫ g)), φ ≫ G.map p.op =
F.map p.op ≫ (x (p ≫ g) hp).app ⟨Over.mk (𝟙 Z)⟩
|
C : Type u
inst✝¹ : Category.{v, u} C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
hG : ⦃Y : C⦄ → (f : Y ⟶ X) → IsLimit (G.mapCone (Sieve.pullback f S).arrows.cocone.op)
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
Y : C
hx : x.Compatible
g : Y ⟶ X
c : Cone ((Sieve.pullback g S).arrows.diagram.op ⋙ G) :=
{ pt := F.obj (op Y),
π :=
{
app := fun x_1 =>
match x_1 with
| op { obj := Z, property := hZ } =>
F.map Z.hom.op ≫ (x (Z.hom ≫ g) hZ).app (op (Over.mk (𝟙 (unop (op ((𝟭 C).obj Z.left)))))),
naturality := ⋯ } }
⊢ ∃ φ,
∀ {Z : C} (p : Z ⟶ Y) (hp : S.arrows (p ≫ g)), φ ≫ G.map p.op = F.map p.op ≫ (x (p ≫ g) hp).app (op (Over.mk (𝟙 Z)))
|
use (hG g).lift c
|
case h
C : Type u
inst✝¹ : Category.{v, u} C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
hG : ⦃Y : C⦄ → (f : Y ⟶ X) → IsLimit (G.mapCone (Sieve.pullback f S).arrows.cocone.op)
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
Y : C
hx : x.Compatible
g : Y ⟶ X
c : Cone ((Sieve.pullback g S).arrows.diagram.op ⋙ G) :=
{ pt := F.obj (op Y),
π :=
{
app := fun x_1 =>
match x_1 with
| op { obj := Z, property := hZ } =>
F.map Z.hom.op ≫ (x (Z.hom ≫ g) hZ).app (op (Over.mk (𝟙 (unop (op ((𝟭 C).obj Z.left)))))),
naturality := ⋯ } }
⊢ ∀ {Z : C} (p : Z ⟶ Y) (hp : S.arrows (p ≫ g)),
(hG g).lift c ≫ G.map p.op = F.map p.op ≫ (x (p ≫ g) hp).app (op (Over.mk (𝟙 Z)))
|
8103034d905afbca
|
HasStrictDerivAt.clm_comp
|
Mathlib/Analysis/Calculus/Deriv/Mul.lean
|
theorem HasStrictDerivAt.clm_comp (hc : HasStrictDerivAt c c' x) (hd : HasStrictDerivAt d d' x) :
HasStrictDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x
|
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
x : 𝕜
G : Type u_2
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
⊢ HasStrictDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x
|
have := (hc.hasStrictFDerivAt.clm_comp hd.hasStrictFDerivAt).hasStrictDerivAt
|
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
x : 𝕜
G : Type u_2
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
this :
HasStrictDerivAt (fun y => (c y).comp (d y))
((((compL 𝕜 E F G) (c x)).comp (smulRight 1 d') + ((compL 𝕜 E F G).flip (d x)).comp (smulRight 1 c')) 1) x
⊢ HasStrictDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x
|
ac2874cca97d8015
|
Nat.one_ascFactorial
|
Mathlib/Data/Nat/Factorial/Basic.lean
|
theorem one_ascFactorial : ∀ (k : ℕ), (1 : ℕ).ascFactorial k = k.factorial
| 0 => ascFactorial_zero 1
| (k+1) => by
rw [ascFactorial_succ, one_ascFactorial k, Nat.add_comm, factorial_succ]
|
k : ℕ
⊢ ascFactorial 1 (k + 1) = (k + 1)!
|
rw [ascFactorial_succ, one_ascFactorial k, Nat.add_comm, factorial_succ]
|
no goals
|
087e1a0544fd70ba
|
NumberField.hermiteTheorem.finite_of_discr_bdd_of_isReal
|
Mathlib/NumberTheory/NumberField/Discriminant/Basic.lean
|
theorem finite_of_discr_bdd_of_isReal :
{K : { F : IntermediateField ℚ A // FiniteDimensional ℚ F} |
haveI : NumberField K := @NumberField.mk _ _ inferInstance K.prop
{w : InfinitePlace K | IsReal w}.Nonempty ∧ |discr K| ≤ N }.Finite
|
case intro.intro.refine_4
A : Type u_2
inst✝¹ : Field A
inst✝ : CharZero A
N : ℕ
D : ℕ := rankOfDiscrBdd N
B : ℝ≥0 := boundOfDiscBdd N
C : ℕ := ⌈(B ⊔ 1) ^ D * ↑(D.choose (D / 2))⌉₊
x✝¹ : { F // FiniteDimensional ℚ ↥F }
K : IntermediateField ℚ A
hK₀ : FiniteDimensional ℚ ↥K
x✝ : ⟨K, hK₀⟩ ∈ {K | {w | w.IsReal}.Nonempty ∧ |discr ↥↑K| ≤ ↑N}
hK₂ : |discr ↥↑⟨K, hK₀⟩| ≤ ↑N
this✝¹ : CharZero ↥K
this✝ : NumberField ↥K
w₀ : InfinitePlace ↥↑⟨K, hK₀⟩
hw₀ : w₀ ∈ {w | w.IsReal}
this : minkowskiBound (↥K) 1 < ↑(convexBodyLTFactor ↥K) * ↑B
x : 𝓞 ↥K
hx₁ : ℚ⟮↑x⟯ = ⊤
hx₂ : ∀ (w : InfinitePlace ↥K), w ↑x < ↑(B ⊔ 1)
hx : IsIntegral ℤ ((algebraMap (𝓞 ↥K) ↥K) x)
⊢ K = ℚ⟮↑↑x⟯
|
rw [← (IntermediateField.lift_injective _).eq_iff, eq_comm] at hx₁
|
case intro.intro.refine_4
A : Type u_2
inst✝¹ : Field A
inst✝ : CharZero A
N : ℕ
D : ℕ := rankOfDiscrBdd N
B : ℝ≥0 := boundOfDiscBdd N
C : ℕ := ⌈(B ⊔ 1) ^ D * ↑(D.choose (D / 2))⌉₊
x✝¹ : { F // FiniteDimensional ℚ ↥F }
K : IntermediateField ℚ A
hK₀ : FiniteDimensional ℚ ↥K
x✝ : ⟨K, hK₀⟩ ∈ {K | {w | w.IsReal}.Nonempty ∧ |discr ↥↑K| ≤ ↑N}
hK₂ : |discr ↥↑⟨K, hK₀⟩| ≤ ↑N
this✝¹ : CharZero ↥K
this✝ : NumberField ↥K
w₀ : InfinitePlace ↥↑⟨K, hK₀⟩
hw₀ : w₀ ∈ {w | w.IsReal}
this : minkowskiBound (↥K) 1 < ↑(convexBodyLTFactor ↥K) * ↑B
x : 𝓞 ↥K
hx₁ : IntermediateField.lift ⊤ = IntermediateField.lift ℚ⟮↑x⟯
hx₂ : ∀ (w : InfinitePlace ↥K), w ↑x < ↑(B ⊔ 1)
hx : IsIntegral ℤ ((algebraMap (𝓞 ↥K) ↥K) x)
⊢ K = ℚ⟮↑↑x⟯
|
258b240e119b72fe
|
MeasureTheory.limsup_trim
|
Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean
|
theorem limsup_trim (hm : m ≤ m0) {f : α → ℝ≥0∞} (hf : Measurable[m] f) :
limsup f (ae (μ.trim hm)) = limsup f (ae μ)
|
case h
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : α → ℝ≥0∞
hf : Measurable f
a : ℝ≥0∞
⊢ a ∈ {a | ∀ᵐ (n : α) ∂μ.trim hm, f n ≤ a} ↔ a ∈ {a | ∀ᵐ (n : α) ∂μ, f n ≤ a}
|
suffices h_meas_eq : μ { x | ¬f x ≤ a } = μ.trim hm { x | ¬f x ≤ a } by
simp_rw [Set.mem_setOf_eq, ae_iff, h_meas_eq]
|
case h
α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : α → ℝ≥0∞
hf : Measurable f
a : ℝ≥0∞
⊢ μ {x | ¬f x ≤ a} = (μ.trim hm) {x | ¬f x ≤ a}
|
77906aab397d62a7
|
isPreconnected_of_forall
|
Mathlib/Topology/Connected/Basic.lean
|
theorem isPreconnected_of_forall {s : Set α} (x : α)
(H : ∀ y ∈ s, ∃ t, t ⊆ s ∧ x ∈ t ∧ y ∈ t ∧ IsPreconnected t) : IsPreconnected s
|
case intro.intro.intro.intro.inl
α : Type u
inst✝ : TopologicalSpace α
s : Set α
x : α
H : ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
u v : Set α
hu : IsOpen u
hv : IsOpen v
hs : s ⊆ u ∪ v
z : α
zs : z ∈ s
zu : z ∈ u
y : α
ys : y ∈ s
yv : y ∈ v
xs : x ∈ s
xu : x ∈ u
⊢ (s ∩ (u ∩ v)).Nonempty
|
rcases H y ys with ⟨t, ts, xt, yt, ht⟩
|
case intro.intro.intro.intro.inl.intro.intro.intro.intro
α : Type u
inst✝ : TopologicalSpace α
s : Set α
x : α
H : ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
u v : Set α
hu : IsOpen u
hv : IsOpen v
hs : s ⊆ u ∪ v
z : α
zs : z ∈ s
zu : z ∈ u
y : α
ys : y ∈ s
yv : y ∈ v
xs : x ∈ s
xu : x ∈ u
t : Set α
ts : t ⊆ s
xt : x ∈ t
yt : y ∈ t
ht : IsPreconnected t
⊢ (s ∩ (u ∩ v)).Nonempty
|
72217f788baa5fcd
|
ONote.repr_opow
|
Mathlib/SetTheory/Ordinal/Notation.lean
|
theorem repr_opow (o₁ o₂) [NF o₁] [NF o₂] : repr (o₁ ^ o₂) = repr o₁ ^ repr o₂
|
case mk.intro.oadd.intro.mk.intro.succ
o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
m : ℕ
a0 : ONote
n : ℕ+
a' : ONote
e₁ : o₁.split = (a0.oadd n a', m)
N₁ : (a0.oadd n a').NF
r₁ : o₁.repr = (a0.oadd n a').repr + ↑m
this✝ : a0.NF
this : a'.NF
a00 : a0.repr ≠ 0
ad : ω ∣ a'.repr
al : a'.repr + ↑m < ω ^ a0.repr
aa : (a' + ↑m).repr = a'.repr + ↑m
b' : ONote
left✝ : b'.NF
k : ℕ
e₂ : o₂.split' = (b', k + 1)
r₂ : o₂.repr = ω * b'.repr + ↑(k + 1)
⊢ (match (scale 1 b', k + 1) with
| (b, 0) => (a0 * b).oadd 1 0
| (b, k.succ) =>
(a0 * b + a0.mulNat k).scale (a0.oadd n a') + (a0 * b).opowAux a0 ((a0.oadd n a').mulNat m) k m).repr =
(ω ^ a0.repr * ↑↑n + a'.repr + ↑m) ^ o₂.repr
|
simp [opow, opowAux2, r₂, opow_add, opow_mul, mul_assoc, add_assoc]
|
case mk.intro.oadd.intro.mk.intro.succ
o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
m : ℕ
a0 : ONote
n : ℕ+
a' : ONote
e₁ : o₁.split = (a0.oadd n a', m)
N₁ : (a0.oadd n a').NF
r₁ : o₁.repr = (a0.oadd n a').repr + ↑m
this✝ : a0.NF
this : a'.NF
a00 : a0.repr ≠ 0
ad : ω ∣ a'.repr
al : a'.repr + ↑m < ω ^ a0.repr
aa : (a' + ↑m).repr = a'.repr + ↑m
b' : ONote
left✝ : b'.NF
k : ℕ
e₂ : o₂.split' = (b', k + 1)
r₂ : o₂.repr = ω * b'.repr + ↑(k + 1)
⊢ ((ω ^ a0.repr) ^ ω) ^ b'.repr * ((ω ^ a0.repr) ^ k * (ω ^ a0.repr * ↑↑n + a'.repr)) +
((a0 * scale 1 b').opowAux a0 (a0.oadd n a' * ↑m) k m).repr =
((ω ^ a0.repr * ↑↑n + (a'.repr + ↑m)) ^ ω) ^ b'.repr *
((ω ^ a0.repr * ↑↑n + (a'.repr + ↑m)) ^ k * (ω ^ a0.repr * ↑↑n + (a'.repr + ↑m)))
|
778175cafc8055e7
|
SimpleGraph.colorable_iff_exists_bdd_nat_coloring
|
Mathlib/Combinatorics/SimpleGraph/Coloring.lean
|
theorem colorable_iff_exists_bdd_nat_coloring (n : ℕ) :
G.Colorable n ↔ ∃ C : G.Coloring ℕ, ∀ v, C v < n
|
case mpr.intro
V : Type u
G : SimpleGraph V
n : ℕ
C : G.Coloring ℕ
Cf : ∀ (v : V), C v < n
⊢ G.Colorable n
|
refine ⟨Coloring.mk ?_ ?_⟩
|
case mpr.intro.refine_1
V : Type u
G : SimpleGraph V
n : ℕ
C : G.Coloring ℕ
Cf : ∀ (v : V), C v < n
⊢ V → Fin n
case mpr.intro.refine_2
V : Type u
G : SimpleGraph V
n : ℕ
C : G.Coloring ℕ
Cf : ∀ (v : V), C v < n
⊢ ∀ {v w : V}, G.Adj v w → ?mpr.intro.refine_1 v ≠ ?mpr.intro.refine_1 w
|
d1efc174a6faab8a
|
TopologicalSpace.isTopologicalBasis_of_isOpen_of_nhds
|
Mathlib/Topology/Bases.lean
|
theorem isTopologicalBasis_of_isOpen_of_nhds {s : Set (Set α)} (h_open : ∀ u ∈ s, IsOpen u)
(h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v ∈ s, a ∈ v ∧ v ⊆ u) :
IsTopologicalBasis s :=
.of_hasBasis_nhds <| fun a ↦
(nhds_basis_opens a).to_hasBasis' (by simpa [and_assoc] using h_nhds a)
fun _ ⟨hts, hat⟩ ↦ (h_open _ hts).mem_nhds hat
|
α : Type u
t : TopologicalSpace α
s : Set (Set α)
h_open : ∀ u ∈ s, IsOpen u
h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v ∈ s, a ∈ v ∧ v ⊆ u
a : α
⊢ ∀ (i : Set α), a ∈ i ∧ IsOpen i → ∃ i', (i' ∈ s ∧ a ∈ i') ∧ id i' ⊆ i
|
simpa [and_assoc] using h_nhds a
|
no goals
|
f15e782a19fbea2c
|
root_X_pow_sub_C_ne_zero'
|
Mathlib/FieldTheory/KummerPolynomial.lean
|
lemma root_X_pow_sub_C_ne_zero' {n : ℕ} {a : K} (hn : 0 < n) (ha : a ≠ 0) :
(AdjoinRoot.root (X ^ n - C a)) ≠ 0
|
case inl
K : Type u
inst✝ : Field K
a : K
ha : a ≠ 0
hn : 0 < Nat.succ 0
⊢ root (X ^ Nat.succ 0 - C a) ≠ 0
|
rw [pow_one]
|
case inl
K : Type u
inst✝ : Field K
a : K
ha : a ≠ 0
hn : 0 < Nat.succ 0
⊢ root (X - C a) ≠ 0
|
153688240a8b7f53
|
Lean.Grind.Bool.not_eq_of_eq_true
|
Mathlib/.lake/packages/lean4/src/lean/Init/Grind/Lemmas.lean
|
theorem Bool.not_eq_of_eq_true {a : Bool} (h : a = true) : (!a) = false
|
a : Bool
h : a = true
⊢ (!a) = false
|
simp [h]
|
no goals
|
285707a31c5dceed
|
powersEquivPowers_apply
|
Mathlib/GroupTheory/OrderOfElement.lean
|
theorem powersEquivPowers_apply (h : orderOf x = orderOf y) (n : ℕ) :
powersEquivPowers h ⟨x ^ n, n, rfl⟩ = ⟨y ^ n, n, rfl⟩
|
G : Type u_1
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
x y : G
h : orderOf x = orderOf y
n : ℕ
⊢ (finCongr h) ⟨n % orderOf x, ⋯⟩ = ⟨n % orderOf y, ⋯⟩
|
simp [h]
|
no goals
|
50b349098b756c8a
|
padicNorm.values_discrete
|
Mathlib/NumberTheory/Padics/PadicNorm.lean
|
theorem values_discrete {q : ℚ} (hq : q ≠ 0) : ∃ z : ℤ, padicNorm p q = (p : ℚ) ^ (-z) :=
⟨padicValRat p q, by simp [padicNorm, hq]⟩
|
p : ℕ
q : ℚ
hq : q ≠ 0
⊢ padicNorm p q = ↑p ^ (-padicValRat p q)
|
simp [padicNorm, hq]
|
no goals
|
79f7011f2887507d
|
Action.rightDual_ρ
|
Mathlib/CategoryTheory/Action/Monoidal.lean
|
theorem rightDual_ρ [RightRigidCategory V] (h : H) : Xᘁ.ρ h = (X.ρ (h⁻¹ : H))ᘁ
|
V : Type (u + 1)
inst✝³ : LargeCategory V
inst✝² : MonoidalCategory V
H : Type u
inst✝¹ : Group H
X : Action V H
inst✝ : RightRigidCategory V
h : H
⊢ Xᘁ.ρ h = X.ρ h⁻¹ᘁ
|
rw [← SingleObj.inv_as_inv]
|
V : Type (u + 1)
inst✝³ : LargeCategory V
inst✝² : MonoidalCategory V
H : Type u
inst✝¹ : Group H
X : Action V H
inst✝ : RightRigidCategory V
h : H
⊢ Xᘁ.ρ h = X.ρ (inv h)ᘁ
case x
V : Type (u + 1)
inst✝³ : LargeCategory V
inst✝² : MonoidalCategory V
H : Type u
inst✝¹ : Group H
X : Action V H
inst✝ : RightRigidCategory V
h : H
⊢ SingleObj H
case y
V : Type (u + 1)
inst✝³ : LargeCategory V
inst✝² : MonoidalCategory V
H : Type u
inst✝¹ : Group H
X : Action V H
inst✝ : RightRigidCategory V
h : H
⊢ SingleObj H
|
467c60d5375160b7
|
strictConcaveOn_log_Ioi
|
Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean
|
theorem strictConcaveOn_log_Ioi : StrictConcaveOn ℝ (Ioi 0) log
|
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
⊢ y⁻¹ < (log y - log x) / (y - x)
|
rw [lt_div_iff₀ h]
|
x y z : ℝ
hx : 0 < x
hz : 0 < z
hxy : x < y
hyz : y < z
hy : 0 < y
h : 0 < y - x
⊢ y⁻¹ * (y - x) < log y - log x
|
b669e8d780cc761c
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.sat_of_confirmRupHint_insertRup_fold
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.lean
|
theorem sat_of_confirmRupHint_insertRup_fold {n : Nat} (f : DefaultFormula n)
(f_readyForRupAdd : ReadyForRupAdd f) (c : DefaultClause n) (rupHints : Array Nat)
(p : PosFin n → Bool) (pf : p ⊨ f) :
let fc := insertRupUnits f (negate c)
let confirmRupHint_fold_res := rupHints.foldl (confirmRupHint fc.1.clauses) (fc.1.assignments, [], false, false) 0 rupHints.size
confirmRupHint_fold_res.2.2.1 = true → p ⊨ c
|
case neg.intro.intro.inl.intro.inr.intro
n : Nat
f : DefaultFormula n
f_readyForRupAdd : f.ReadyForRupAdd
c : DefaultClause n
rupHints : Array Nat
p : PosFin n → Bool
pf : p ⊨ f
fc : DefaultFormula n × Bool := f.insertRupUnits c.negate
confirmRupHint_fold_res : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool :=
Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints
confirmRupHint_success : confirmRupHint_fold_res.snd.snd.fst = true
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := fc.fst.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (fc.fst.assignments, [], false, false)
h_inductive :
∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
motive (↑idx) acc →
fc.fst.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint fc.fst.clauses acc rupHints[idx])
left✝ : (Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst.size = n
h1 :
Limplies (PosFin n) fc.fst
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst
h2 :
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).snd.snd.fst = true →
Incompatible (PosFin n)
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst fc.fst
fc_incompatible_confirmRupHint_fold_res :
Incompatible (PosFin n) fc.fst
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst
pc :
∀ (x : PosFin n),
((x, false) ∈ Clause.toList c → decide (p x = false) = false) ∧
((x, true) ∈ Clause.toList c → decide (p x = true) = false)
unsat_c : DefaultClause n
unsat_c_in_fc : unsat_c ∈ fc.fst.toList
p_unsat_c : ¬(p ⊨ unsat_c)
v : PosFin n
v_in_neg_c : (v, true) ∈ c.negate
unsat_c_eq : Clause.unit (v, true) = unsat_c
⊢ False
|
simp only [negate_eq, List.mem_map, Prod.exists, Bool.exists_bool] at v_in_neg_c
|
case neg.intro.intro.inl.intro.inr.intro
n : Nat
f : DefaultFormula n
f_readyForRupAdd : f.ReadyForRupAdd
c : DefaultClause n
rupHints : Array Nat
p : PosFin n → Bool
pf : p ⊨ f
fc : DefaultFormula n × Bool := f.insertRupUnits c.negate
confirmRupHint_fold_res : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool :=
Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints
confirmRupHint_success : confirmRupHint_fold_res.snd.snd.fst = true
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := fc.fst.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (fc.fst.assignments, [], false, false)
h_inductive :
∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
motive (↑idx) acc →
fc.fst.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint fc.fst.clauses acc rupHints[idx])
left✝ : (Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst.size = n
h1 :
Limplies (PosFin n) fc.fst
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst
h2 :
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).snd.snd.fst = true →
Incompatible (PosFin n)
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst fc.fst
fc_incompatible_confirmRupHint_fold_res :
Incompatible (PosFin n) fc.fst
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst
pc :
∀ (x : PosFin n),
((x, false) ∈ Clause.toList c → decide (p x = false) = false) ∧
((x, true) ∈ Clause.toList c → decide (p x = true) = false)
unsat_c : DefaultClause n
unsat_c_in_fc : unsat_c ∈ fc.fst.toList
p_unsat_c : ¬(p ⊨ unsat_c)
v : PosFin n
unsat_c_eq : Clause.unit (v, true) = unsat_c
v_in_neg_c :
∃ a,
(a, false) ∈ c.toList ∧ Literal.negate (a, false) = (v, true) ∨
(a, true) ∈ c.toList ∧ Literal.negate (a, true) = (v, true)
⊢ False
|
5ee4e43f082bad4a
|
Padic.exi_rat_seq_conv_cauchy
|
Mathlib/NumberTheory/Padics/PadicNumbers.lean
|
theorem exi_rat_seq_conv_cauchy : IsCauSeq (padicNorm p) (limSeq f) := fun ε hε ↦ by
have hε3 : 0 < ε / 3 := div_pos hε (by norm_num)
let ⟨N, hN⟩ := exi_rat_seq_conv f hε3
let ⟨N2, hN2⟩ := f.cauchy₂ hε3
exists max N N2
intro j hj
suffices
padicNormE (limSeq f j - f (max N N2) + (f (max N N2) - limSeq f (max N N2)) : ℚ_[p]) < ε by
ring_nf at this ⊢
rw [← padicNormE.eq_padic_norm']
exact mod_cast this
apply lt_of_le_of_lt
· apply padicNormE.add_le
· rw [← add_thirds ε]
apply _root_.add_lt_add
· suffices padicNormE (limSeq f j - f j + (f j - f (max N N2)) : ℚ_[p]) < ε / 3 + ε / 3 by
simpa only [sub_add_sub_cancel]
apply lt_of_le_of_lt
· apply padicNormE.add_le
· apply _root_.add_lt_add
· rw [padicNormE.map_sub]
apply mod_cast hN j
exact le_of_max_le_left hj
· exact hN2 _ (le_of_max_le_right hj) _ (le_max_right _ _)
· apply mod_cast hN (max N N2)
apply le_max_left
|
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] ⇑padicNormE
ε : ℚ
hε : ε > 0
hε3 : 0 < ε / 3
⊢ ∃ i, ∀ j ≥ i, padicNorm p (limSeq f j - limSeq f i) < ε
|
let ⟨N, hN⟩ := exi_rat_seq_conv f hε3
|
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] ⇑padicNormE
ε : ℚ
hε : ε > 0
hε3 : 0 < ε / 3
N : ℕ
hN : ∀ i ≥ N, padicNormE (↑f i - ↑(limSeq f i)) < ε / 3
⊢ ∃ i, ∀ j ≥ i, padicNorm p (limSeq f j - limSeq f i) < ε
|
5532e11826254be6
|
NNRat.cast_injective
|
Mathlib/Data/Rat/Cast/CharZero.lean
|
lemma cast_injective : Injective ((↑) : ℚ≥0 → α)
|
α : Type u_3
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
p q : ℚ≥0
hpq : ↑p = ↑q
⊢ p = q
|
rw [NNRat.cast_def, NNRat.cast_def, Commute.div_eq_div_iff] at hpq
|
α : Type u_3
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
p q : ℚ≥0
hpq : ↑p.num * ↑q.den = ↑q.num * ↑p.den
⊢ p = q
case hbd
α : Type u_3
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
p q : ℚ≥0
hpq : ↑p.num / ↑p.den = ↑q.num / ↑q.den
⊢ Commute ↑p.den ↑q.den
case hb
α : Type u_3
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
p q : ℚ≥0
hpq : ↑p.num / ↑p.den = ↑q.num / ↑q.den
⊢ ↑p.den ≠ 0
case hd
α : Type u_3
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
p q : ℚ≥0
hpq : ↑p.num / ↑p.den = ↑q.num / ↑q.den
⊢ ↑q.den ≠ 0
|
db8f302d56c944d4
|
HallMarriageTheorem.hall_cond_of_restrict
|
Mathlib/Combinatorics/Hall/Finite.lean
|
theorem hall_cond_of_restrict {ι : Type u} {t : ι → Finset α} {s : Finset ι}
(ht : ∀ s : Finset ι, #s ≤ #(s.biUnion t)) (s' : Finset (s : Set ι)) :
#s' ≤ #(s'.biUnion fun a' => t a')
|
α : Type v
inst✝ : DecidableEq α
ι : Type u
t : ι → Finset α
s : Finset ι
ht : ∀ (s : Finset ι), #s ≤ #(s.biUnion t)
s' : Finset ↑↑s
⊢ #s' ≤ #(s'.biUnion fun a' => t ↑a')
|
rw [← card_image_of_injective s' Subtype.coe_injective]
|
α : Type v
inst✝ : DecidableEq α
ι : Type u
t : ι → Finset α
s : Finset ι
ht : ∀ (s : Finset ι), #s ≤ #(s.biUnion t)
s' : Finset ↑↑s
⊢ #(image (fun a => ↑a) s') ≤ #(s'.biUnion fun a' => t ↑a')
|
3655e829fac3e08f
|
ENat.add_one_natCast_le_withTop_of_lt
|
Mathlib/Data/ENat/Basic.lean
|
lemma add_one_natCast_le_withTop_of_lt {m : ℕ} {n : WithTop ℕ∞} (h : m < n) : (m + 1 : ℕ) ≤ n
|
m : ℕ
n✝ : WithTop ℕ∞
n : ℕ
h : ↑m < ↑n
⊢ ↑(m + 1) ≤ ↑n
|
simpa only [Nat.cast_le, ge_iff_le, Nat.cast_lt] using h
|
no goals
|
bb69bb09eeb550e5
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.