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
|
|---|---|---|---|---|---|---|
WeierstrassCurve.Affine.CoordinateRing.XYIdeal_neg_mul
|
Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
|
lemma XYIdeal_neg_mul {x y : F} (h : W.Nonsingular x y) :
XYIdeal W x (C <| W.negY x y) * XYIdeal W x (C y) = XIdeal W x
|
case h.e'_2.h.inr
F : Type u
inst✝ : Field F
W : Affine F
x y : F
h : W.Nonsingular x y
Y_rw :
(Y - C (C y)) * (Y - C (C (W.negY x y))) -
C (X - C x) * (C (X ^ 2 + C (x + W.a₂) * X + C (x ^ 2 + W.a₂ * x + W.a₄)) - C (C W.a₁) * Y) =
W.polynomial * 1
hy : 2 * y + W.a₁ * x + W.a₃ ≠ 0
W_Y : F := 2 * y + W.a₁ * x + W.a₃
⊢ C (C (2 * y + W.a₁ * x + W.a₃)) *
(0 * (C (X ^ 2 + C (x + W.a₂) * X + C (x ^ 2 + W.a₂ * x + W.a₄)) - C (C W.a₁) * Y)) =
C (C (2 * y + W.a₁ * x + W.a₃)) *
(1 + 0 * C (X - C x) + C (C W_Y⁻¹) * (Y - C (C y)) + C (C (W_Y⁻¹ * -1)) * (Y - C (C (-y - W.a₁ * x - W.a₃))))
|
simp only [W_Y, mul_add, ← mul_assoc, ← C_mul, mul_inv_cancel₀ hy]
|
case h.e'_2.h.inr
F : Type u
inst✝ : Field F
W : Affine F
x y : F
h : W.Nonsingular x y
Y_rw :
(Y - C (C y)) * (Y - C (C (W.negY x y))) -
C (X - C x) * (C (X ^ 2 + C (x + W.a₂) * X + C (x ^ 2 + W.a₂ * x + W.a₄)) - C (C W.a₁) * Y) =
W.polynomial * 1
hy : 2 * y + W.a₁ * x + W.a₃ ≠ 0
W_Y : F := 2 * y + W.a₁ * x + W.a₃
⊢ C (C (2 * y + W.a₁ * x + W.a₃)) * 0 * (C (X ^ 2 + C (x + W.a₂) * X + C (x ^ 2 + W.a₂ * x + W.a₄)) - C (C W.a₁) * Y) =
C (C (2 * y + W.a₁ * x + W.a₃)) * 1 + C (C (2 * y + W.a₁ * x + W.a₃)) * 0 * C (X - C x) + C (C 1) * (Y - C (C y)) +
C (C (1 * -1)) * (Y - C (C (-y - W.a₁ * x - W.a₃)))
|
a91b7de170ddf2df
|
VertexOperator.coeff_eq_zero_of_lt_order
|
Mathlib/Algebra/Vertex/VertexOperator.lean
|
theorem coeff_eq_zero_of_lt_order (A : VertexOperator R V) (n : ℤ) (x : V)
(h : n < HahnSeries.order ((HahnModule.of R).symm (A x))) : coeff A n x = 0
|
R : Type u_1
V : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup V
inst✝ : Module R V
A : VertexOperator R V
n : ℤ
x : V
h : n < ((HahnModule.of R).symm (A x)).order
⊢ (coeff A n) x = 0
|
rw [coeff_eq_ncoeff, ncoeff_eq_zero_of_lt_order A (-n - 1) x]
|
R : Type u_1
V : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup V
inst✝ : Module R V
A : VertexOperator R V
n : ℤ
x : V
h : n < ((HahnModule.of R).symm (A x)).order
⊢ -(-n - 1) - 1 < ((HahnModule.of R).symm (A x)).order
|
9542f332c3e527ee
|
FinitePlace.mulSupport_finite
|
Mathlib/NumberTheory/NumberField/FinitePlaces.lean
|
theorem mulSupport_finite {x : K} (h_x_nezero : x ≠ 0) :
(Function.mulSupport fun w : FinitePlace K ↦ w x).Finite
|
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
a b : 𝓞 K
hb : b ∈ nonZeroDivisors (𝓞 K)
h_x_nezero : (algebraMap (𝓞 K) K) a / (algebraMap (𝓞 K) K) b ≠ 0
⊢ (Function.mulSupport fun w => w ((algebraMap (𝓞 K) K) a / (algebraMap (𝓞 K) K) b)).Finite
|
simp_all only [ne_eq, div_eq_zero_iff, FaithfulSMul.algebraMap_eq_zero_iff, not_or, map_div₀]
|
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
a b : 𝓞 K
hb : b ∈ nonZeroDivisors (𝓞 K)
h_x_nezero : ¬a = 0 ∧ ¬b = 0
⊢ (Function.mulSupport fun w => w ((algebraMap (𝓞 K) K) a) / w ((algebraMap (𝓞 K) K) b)).Finite
|
ed8d1c38a85537eb
|
Multiset.prod_hom₂_ne_zero
|
Mathlib/Algebra/BigOperators/Group/Multiset/Basic.lean
|
theorem prod_hom₂_ne_zero [CommMonoid γ] {s : Multiset ι} (hs : s ≠ 0) (f : α → β → γ)
(hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d) (f₁ : ι → α) (f₂ : ι → β) :
(s.map fun i => f (f₁ i) (f₂ i)).prod = f (s.map f₁).prod (s.map f₂).prod
|
case h
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_6
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
f : α → β → γ
hf : ∀ (a b : α) (c d : β), f (a * b) (c * d) = f a c * f b d
f₁ : ι → α
f₂ : ι → β
a✝ : List ι
hs : ⟦a✝⟧ ≠ 0
⊢ (map (fun i => f (f₁ i) (f₂ i)) ⟦a✝⟧).prod = f (map f₁ ⟦a✝⟧).prod (map f₂ ⟦a✝⟧).prod
|
aesop (add simp List.prod_hom₂_nonempty)
|
no goals
|
27df2ec069e39e33
|
CategoryTheory.regularTopology.parallelPair_pullback_initial
|
Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean
|
theorem parallelPair_pullback_initial {X B : C} (π : X ⟶ B)
(c : PullbackCone π π) (hc : IsLimit c) :
(parallelPair (C := (Sieve.ofArrows (fun (_ : Unit) => X) (fun _ => π)).arrows.categoryᵒᵖ)
(Y := op ((Presieve.categoryMk _ (c.fst ≫ π) ⟨_, c.fst, π, ofArrows.mk (), rfl⟩)))
(X := op ((Presieve.categoryMk _ π (Sieve.ofArrows_mk _ _ Unit.unit))))
(Quiver.Hom.op (Over.homMk c.fst))
(Quiver.Hom.op (Over.homMk c.snd c.condition.symm))).Initial
|
case h₁
C : Type u_1
inst✝ : Category.{u_4, u_1} C
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ ∀ (Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryᵒᵖ),
Nonempty (op ((Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯) ⟶ Z)
|
intro ⟨Z⟩
|
case h₁
C : Type u_1
inst✝ : Category.{u_4, u_1} C
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
⊢ Nonempty (op ((Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯) ⟶ op Z)
|
d548d8c18bc207b1
|
Polynomial.hilbertPoly_mul_one_sub_pow_add
|
Mathlib/RingTheory/Polynomial/HilbertPoly.lean
|
lemma hilbertPoly_mul_one_sub_pow_add (p : F[X]) (d e : ℕ) :
hilbertPoly (p * (1 - X) ^ e) (d + e) = hilbertPoly p d
|
F : Type u_1
inst✝¹ : Field F
inst✝ : CharZero F
p : F[X]
d e : ℕ
⊢ (p * (1 - X) ^ e).hilbertPoly (d + e) = p.hilbertPoly d
|
induction e with
| zero => simp
| succ e he => rw [pow_add, pow_one, ← mul_assoc, ← add_assoc, hilbertPoly_mul_one_sub_succ, he]
|
no goals
|
afc62f2d64fc85e6
|
NNReal.summable_schlomilch_iff
|
Mathlib/Analysis/PSeries.lean
|
theorem summable_schlomilch_iff {C : ℕ} {u : ℕ → ℕ} {f : ℕ → ℝ≥0}
(hf : ∀ ⦃m n⦄, 0 < m → m ≤ n → f n ≤ f m)
(h_pos : ∀ n, 0 < u n) (hu_strict : StrictMono u)
(hC_nonzero : C ≠ 0) (h_succ_diff : SuccDiffBounded C u) :
(Summable fun k : ℕ => (u (k + 1) - (u k : ℝ≥0)) * f (u k)) ↔ Summable f
|
C : ℕ
u : ℕ → ℕ
f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu_strict : StrictMono u
hC_nonzero : C ≠ 0
h_succ_diff : SuccDiffBounded C u
⊢ (Summable fun k => (↑(u (k + 1)) - ↑(u k)) * f (u k)) ↔ Summable f
|
simp only [← tsum_coe_ne_top_iff_summable, Ne, not_iff_not, ENNReal.coe_mul]
|
C : ℕ
u : ℕ → ℕ
f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_pos : ∀ (n : ℕ), 0 < u n
hu_strict : StrictMono u
hC_nonzero : C ≠ 0
h_succ_diff : SuccDiffBounded C u
⊢ ∑' (b : ℕ), ↑(↑(u (b + 1)) - ↑(u b)) * ↑(f (u b)) = ⊤ ↔ ∑' (b : ℕ), ↑(f b) = ⊤
|
04bdd8552d6d0c58
|
Filter.eventuallyConst_atTop_nat
|
Mathlib/Order/Filter/EventuallyConst.lean
|
lemma eventuallyConst_atTop_nat {f : ℕ → α} :
EventuallyConst f atTop ↔ ∃ n, ∀ m, n ≤ m → f (m + 1) = f m
|
α : Type u_1
f : ℕ → α
⊢ (∃ i, ∀ (j : ℕ), i ≤ j → f j = f i) ↔ ∃ n, ∀ (m : ℕ), n ≤ m → f (m + 1) = f m
|
refine exists_congr fun n ↦ ⟨fun h m hm ↦ ?_, fun h m hm ↦ ?_⟩
|
case refine_1
α : Type u_1
f : ℕ → α
n : ℕ
h : ∀ (j : ℕ), n ≤ j → f j = f n
m : ℕ
hm : n ≤ m
⊢ f (m + 1) = f m
case refine_2
α : Type u_1
f : ℕ → α
n : ℕ
h : ∀ (m : ℕ), n ≤ m → f (m + 1) = f m
m : ℕ
hm : n ≤ m
⊢ f m = f n
|
2a5354aa8c8f975c
|
GroupWithZero.dvd_iff
|
Mathlib/Algebra/GroupWithZero/Divisibility.lean
|
/-- `∣` is not a useful definition if an inverse is available. -/
@[simp]
lemma GroupWithZero.dvd_iff {m n : α} : m ∣ n ↔ (m = 0 → n = 0)
|
case refine_1
α : Type u_1
inst✝ : GroupWithZero α
m n : α
x✝ : m ∣ n
hm : m = 0
a : α
ha : n = m * a
⊢ n = 0
|
simp [hm, ha]
|
no goals
|
8c07e094e9905dbc
|
CategoryTheory.Quotient.compClosure_iff_self
|
Mathlib/CategoryTheory/Quotient.lean
|
lemma compClosure_iff_self [h : Congruence r] {X Y : C} (f g : X ⟶ Y) :
CompClosure r f g ↔ r f g
|
case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
hfg : CompClosure r f g
⊢ r f g
|
induction' hfg with m m' hm
|
case mp.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
m m' : C
hm : X ⟶ m
m₁✝ m₂✝ : m ⟶ m'
g✝ : m' ⟶ Y
h✝ : r m₁✝ m₂✝
⊢ r (hm ≫ m₁✝ ≫ g✝) (hm ≫ m₂✝ ≫ g✝)
|
c4ae7ee6099a17ac
|
cfcₙHom_of_cfcHom_map_quasispectrum
|
Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
|
lemma cfcₙHom_of_cfcHom_map_quasispectrum {a : A} (ha : p a) :
∀ f : C(σₙ R a, R)₀, σₙ R (cfcₙHom_of_cfcHom R ha f) = range f
|
case h.mp
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : Semifield R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : IsTopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : TopologicalSpace A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
a : A
ha : p a
f : C(↑(σₙ R a), R)₀
x : R
⊢ x ∈ range ⇑((compStarAlgHom' R R { toFun := Set.inclusion ⋯, continuous_toFun := ⋯ }) (toContinuousMapHom f)) ∪ {0} →
x ∈ range ⇑f
|
rintro (⟨x, rfl⟩ | rfl)
|
case h.mp.inl.intro
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : Semifield R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : IsTopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : TopologicalSpace A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
a : A
ha : p a
f : C(↑(σₙ R a), R)₀
x : ↑(spectrum R a)
⊢ ((compStarAlgHom' R R { toFun := Set.inclusion ⋯, continuous_toFun := ⋯ }) (toContinuousMapHom f)) x ∈ range ⇑f
case h.mp.inr
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : Semifield R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : IsTopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : TopologicalSpace A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
a : A
ha : p a
f : C(↑(σₙ R a), R)₀
⊢ 0 ∈ range ⇑f
|
c7d41f5330214066
|
Polynomial.support_derivativeFinsupp_subset_range
|
Mathlib/Algebra/Polynomial/Derivative.lean
|
theorem support_derivativeFinsupp_subset_range {p : R[X]} {n : ℕ} (h : p.natDegree < n) :
(derivativeFinsupp p).support ⊆ range n
|
R : Type u
inst✝ : Semiring R
p : R[X]
n : ℕ
h : p.natDegree < n
⊢ (Finsupp.onFinset (range (p.natDegree + 1)) (fun x => (⇑derivative)^[x] p) ⋯).support ⊆ range n
|
exact Finsupp.support_onFinset_subset.trans (Finset.range_subset.mpr h)
|
no goals
|
f53dd0fd16286f86
|
MeasureTheory.LevyProkhorov.continuous_equiv_symm_probabilityMeasure
|
Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
|
lemma LevyProkhorov.continuous_equiv_symm_probabilityMeasure :
Continuous (LevyProkhorov.equiv (α := ProbabilityMeasure Ω)).symm
|
case intro.intro.intro.intro.intro.intro
Ω : Type u_1
inst✝³ : PseudoMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
inst✝ : SeparableSpace Ω
P : ProbabilityMeasure Ω
ε : ℝ
ε_pos : ε > 0
third_ε_pos : 0 < ε / 3
third_ε_pos' : 0 < ENNReal.ofReal (ε / 3)
Es : ℕ → Set Ω
Es_mble : ∀ (n : ℕ), MeasurableSet (Es n)
Es_bdd : ∀ (n : ℕ), Bornology.IsBounded (Es n)
Es_diam : ∀ (n : ℕ), diam (Es n) ≤ ε / 3
Es_cover : ⋃ n, Es n = univ
Es_disjoint : Pairwise fun n m => Disjoint (Es n) (Es m)
N : ℕ
hN : ↑P (⋃ j ∈ Iio N, Es j)ᶜ < ENNReal.ofReal (ε / 3)
Js_finite : {J | J ⊆ Iio N}.Finite
Gs : Set (Set Ω) := (fun J => thickening (ε / 3) (⋃ j ∈ J, Es j)) '' {J | J ⊆ Iio N}
Gs_open : ∀ (J : Set ℕ), IsOpen (thickening (ε / 3) (⋃ j ∈ J, Es j))
⊢ ∀ᶠ (x : ProbabilityMeasure Ω) in 𝓝 P,
dist ((equiv (ProbabilityMeasure Ω)).symm x) ((equiv (ProbabilityMeasure Ω)).symm P) < ε
|
have mem_nhds_P (G : Set Ω) (G_open : IsOpen G) :
{Q | P.toMeasure G < Q.toMeasure G + ENNReal.ofReal (ε/3)} ∈ 𝓝 P :=
P.toMeasure_add_pos_gt_mem_nhds G_open third_ε_pos'
|
case intro.intro.intro.intro.intro.intro
Ω : Type u_1
inst✝³ : PseudoMetricSpace Ω
inst✝² : MeasurableSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
inst✝ : SeparableSpace Ω
P : ProbabilityMeasure Ω
ε : ℝ
ε_pos : ε > 0
third_ε_pos : 0 < ε / 3
third_ε_pos' : 0 < ENNReal.ofReal (ε / 3)
Es : ℕ → Set Ω
Es_mble : ∀ (n : ℕ), MeasurableSet (Es n)
Es_bdd : ∀ (n : ℕ), Bornology.IsBounded (Es n)
Es_diam : ∀ (n : ℕ), diam (Es n) ≤ ε / 3
Es_cover : ⋃ n, Es n = univ
Es_disjoint : Pairwise fun n m => Disjoint (Es n) (Es m)
N : ℕ
hN : ↑P (⋃ j ∈ Iio N, Es j)ᶜ < ENNReal.ofReal (ε / 3)
Js_finite : {J | J ⊆ Iio N}.Finite
Gs : Set (Set Ω) := (fun J => thickening (ε / 3) (⋃ j ∈ J, Es j)) '' {J | J ⊆ Iio N}
Gs_open : ∀ (J : Set ℕ), IsOpen (thickening (ε / 3) (⋃ j ∈ J, Es j))
mem_nhds_P : ∀ (G : Set Ω), IsOpen G → {Q | ↑P G < ↑Q G + ENNReal.ofReal (ε / 3)} ∈ 𝓝 P
⊢ ∀ᶠ (x : ProbabilityMeasure Ω) in 𝓝 P,
dist ((equiv (ProbabilityMeasure Ω)).symm x) ((equiv (ProbabilityMeasure Ω)).symm P) < ε
|
1196bd5a9632bf03
|
Affine.Simplex.reindex_reindex_symm
|
Mathlib/LinearAlgebra/AffineSpace/Independent.lean
|
theorem reindex_reindex_symm {m n : ℕ} (s : Simplex k P m) (e : Fin (m + 1) ≃ Fin (n + 1)) :
(s.reindex e).reindex e.symm = s
|
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
m n : ℕ
s : Simplex k P m
e : Fin (m + 1) ≃ Fin (n + 1)
⊢ (s.reindex e).reindex e.symm = s
|
rw [← reindex_trans, Equiv.self_trans_symm, reindex_refl]
|
no goals
|
b2e5e2423f27403a
|
Std.DHashMap.Internal.List.getValue?_eq_getEntry?
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem getValue?_eq_getEntry? [BEq α] {l : List ((_ : α) × β)} {a : α} :
getValue? a l = (getEntry? a l).map (·.2)
|
α : Type u
β : Type v
inst✝ : BEq α
l : List ((_ : α) × β)
a : α
⊢ getValue? a l = Option.map (fun x => x.snd) (getEntry? a l)
|
induction l using assoc_induction
|
case nil
α : Type u
β : Type v
inst✝ : BEq α
a : α
⊢ getValue? a [] = Option.map (fun x => x.snd) (getEntry? a [])
case cons
α : Type u
β : Type v
inst✝ : BEq α
a k✝ : α
v✝ : β
tail✝ : List ((_ : α) × β)
a✝ : getValue? a tail✝ = Option.map (fun x => x.snd) (getEntry? a tail✝)
⊢ getValue? a (⟨k✝, v✝⟩ :: tail✝) = Option.map (fun x => x.snd) (getEntry? a (⟨k✝, v✝⟩ :: tail✝))
|
687d94ddd91ab084
|
MeasureTheory.leastGE_eq_min
|
Mathlib/Probability/Martingale/BorelCantelli.lean
|
theorem leastGE_eq_min (π : Ω → ℕ) (r : ℝ) (ω : Ω) {n : ℕ} (hπn : ∀ ω, π ω ≤ n) :
leastGE f r (π ω) ω = min (π ω) (leastGE f r n ω)
|
case pos
Ω : Type u_1
f : ℕ → Ω → ℝ
π : Ω → ℕ
r : ℝ
ω : Ω
n : ℕ
hπn : ∀ (ω : Ω), π ω ≤ n
hle : π ω ≤ leastGE f r n ω
h : ∃ j ∈ Set.Icc 0 (π ω), f j ω ∈ Set.Ici r
⊢ π ω ≤ hitting f (Set.Ici r) 0 (π ω) ω
|
refine hle.trans (Eq.le ?_)
|
case pos
Ω : Type u_1
f : ℕ → Ω → ℝ
π : Ω → ℕ
r : ℝ
ω : Ω
n : ℕ
hπn : ∀ (ω : Ω), π ω ≤ n
hle : π ω ≤ leastGE f r n ω
h : ∃ j ∈ Set.Icc 0 (π ω), f j ω ∈ Set.Ici r
⊢ leastGE f r n ω = hitting f (Set.Ici r) 0 (π ω) ω
|
ed2cf0baa21c4237
|
Nat.Linear.PolyCnstr.denote_mul
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
|
theorem PolyCnstr.denote_mul (ctx : Context) (k : Nat) (c : PolyCnstr) : (c.mul (k+1)).denote ctx = c.denote ctx
|
case mk
ctx : Context
k : Nat
eq : Bool
lhs rhs : Poly
⊢ denote ctx (mul (k + 1) { eq := eq, lhs := lhs, rhs := rhs }) = denote ctx { eq := eq, lhs := lhs, rhs := rhs }
|
have : k ≠ 0 → k + 1 ≠ 1 := by intro h; match k with | 0 => contradiction | k+1 => simp [Nat.succ.injEq]
|
case mk
ctx : Context
k : Nat
eq : Bool
lhs rhs : Poly
this : k ≠ 0 → k + 1 ≠ 1
⊢ denote ctx (mul (k + 1) { eq := eq, lhs := lhs, rhs := rhs }) = denote ctx { eq := eq, lhs := lhs, rhs := rhs }
|
135a439c1fc286b8
|
Dynamics.coverMincard_le_netMaxcard
|
Mathlib/Dynamics/TopologicalEntropy/NetEntropy.lean
|
/-- Given an entourage `U` and a time `n`, a minimal dynamical cover by `U ○ U` has a smaller
cardinality than a maximal dynamical net by `U`. This lemma is the second of two key results to
compare two versions topological entropy: with cover and with nets. -/
lemma coverMincard_le_netMaxcard (T : X → X) (F : Set X) {U : Set (X × X)} (U_rfl : idRel ⊆ U)
(U_symm : SymmetricRel U) (n : ℕ) :
coverMincard T F (U ○ U) n ≤ netMaxcard T F U n
|
X : Type u_1
T : X → X
F : Set X
U : Set (X × X)
U_rfl : idRel ⊆ U
U_symm : SymmetricRel U
n : ℕ
h✝ : netMaxcard T F U n < ⊤
s : Finset X
s_net : IsDynNetIn T F U n ↑s
s_netMaxcard : ↑s.card = netMaxcard T F U n
h : ¬IsDynCoverOf T F (U ○ U) n ↑s
x : X
x_F : x ∈ F
x_uncov : ∀ x_1 ∈ s, x ∉ ball x_1 (dynEntourage T (U ○ U) n)
larger_net : IsDynNetIn T F U n ↑(insert x s)
x_s : x ∈ s
⊢ x ∈ ball x idRel
|
simp only [ball, mem_preimage, mem_idRel]
|
no goals
|
78a05381e650bf91
|
Turing.ToPartrec.Code.fix_eval
|
Mathlib/Computability/TMConfig.lean
|
theorem fix_eval (f) : (fix f).eval =
PFun.fix fun v => (f.eval v).map fun v =>
if v.headI = 0 then Sum.inl v.tail else Sum.inr v.tail
|
f : Code
⊢ f.fix.eval = PFun.fix fun v => Part.map (fun v => if v.headI = 0 then Sum.inl v.tail else Sum.inr v.tail) (f.eval v)
|
simp [eval]
|
no goals
|
a2d428e524749890
|
ContinuousMultilinearMap.hasBasis_nhds_zero_of_basis
|
Mathlib/Topology/Algebra/Module/Multilinear/Topology.lean
|
theorem hasBasis_nhds_zero_of_basis {ι : Type*} {p : ι → Prop} {b : ι → Set F}
(h : (𝓝 (0 : F)).HasBasis p b) :
(𝓝 (0 : ContinuousMultilinearMap 𝕜 E F)).HasBasis
(fun Si : Set (Π i, E i) × ι => IsVonNBounded 𝕜 Si.1 ∧ p Si.2)
fun Si => { f | MapsTo f Si.1 (b Si.2) }
|
case refine_2
𝕜 : Type u_1
ι✝ : Type u_2
E : ι✝ → Type u_3
F : Type u_4
inst✝⁷ : NormedField 𝕜
inst✝⁶ : (i : ι✝) → TopologicalSpace (E i)
inst✝⁵ : (i : ι✝) → AddCommGroup (E i)
inst✝⁴ : (i : ι✝) → Module 𝕜 (E i)
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜 F
inst✝¹ : TopologicalSpace F
inst✝ : IsTopologicalAddGroup F
ι : Type u_5
p : ι → Prop
b : ι → Set F
h : (𝓝 0).HasBasis p b
this✝ : UniformSpace F := IsTopologicalAddGroup.toUniformSpace F
this : UniformAddGroup F
⊢ DirectedOn (fun x1 x2 => x1 ⊆ x2) {s | IsVonNBounded 𝕜 s}
|
exact directedOn_of_sup_mem fun _ _ => Bornology.IsVonNBounded.union
|
no goals
|
40e37d0cf509b7bc
|
Continuous.exists_forall_le_of_hasCompactMulSupport
|
Mathlib/Topology/Order/Compact.lean
|
theorem Continuous.exists_forall_le_of_hasCompactMulSupport [ClosedIicTopology α] [Nonempty β]
[One α] {f : β → α} (hf : Continuous f) (h : HasCompactMulSupport f) :
∃ x : β, ∀ y : β, f x ≤ f y
|
case intro.intro.intro
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : ClosedIicTopology α
inst✝¹ : Nonempty β
inst✝ : One α
f : β → α
hf : Continuous f
h : HasCompactMulSupport f
x : β
hx : ∀ (i : β), f x ≤ f i
⊢ ∃ x, ∀ (y : β), f x ≤ f y
|
exact ⟨x, hx⟩
|
no goals
|
486261c2aee938dc
|
FirstOrder.Language.ElementaryEmbedding.map_formula
|
Mathlib/ModelTheory/ElementaryMaps.lean
|
theorem map_formula (f : M ↪ₑ[L] N) {α : Type*} (φ : L.Formula α) (x : α → M) :
φ.Realize (f ∘ x) ↔ φ.Realize x
|
L : Language
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
f : M ↪ₑ[L] N
α : Type u_5
φ : L.Formula α
x : α → M
⊢ φ.Realize (⇑f ∘ x) ↔ φ.Realize x
|
rw [Formula.Realize, Formula.Realize, ← f.map_boundedFormula, Unique.eq_default (f ∘ default)]
|
no goals
|
9885612a339f98d4
|
SeparatingDual.t2Space
|
Mathlib/Analysis/NormedSpace/HahnBanach/SeparatingDual.lean
|
theorem t2Space [T2Space R] : T2Space V
|
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T2Space R
⊢ T2Space V
|
apply (t2Space_iff _).2 (fun {x} {y} hxy ↦ ?_)
|
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T2Space R
x y : V
hxy : x ≠ y
⊢ ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v
|
4550ff38167d811f
|
NumberField.mixedEmbedding.norm_unit
|
Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
|
theorem norm_unit (u : (𝓞 K)ˣ) :
mixedEmbedding.norm (mixedEmbedding K u) = 1
|
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
u : (𝓞 K)ˣ
⊢ mixedEmbedding.norm ((mixedEmbedding K) ((algebraMap (𝓞 K) K) ↑u)) = 1
|
rw [norm_eq_norm, Units.norm, Rat.cast_one]
|
no goals
|
4c804f965b90f8ea
|
Std.DHashMap.Internal.Raw₀.wfImp_expandIfNecessary
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/WF.lean
|
theorem wfImp_expandIfNecessary [BEq α] [Hashable α] [EquivBEq α] [LawfulHashable α] (m : Raw₀ α β)
(h : Raw.WFImp m.1) : Raw.WFImp (expandIfNecessary m).1
|
case isFalse.refine_2
α : Type u
β : α → Type v
inst✝³ : BEq α
inst✝² : Hashable α
inst✝¹ : EquivBEq α
inst✝ : LawfulHashable α
m : Raw₀ α β
size : Nat
buckets : Array (AssocList α β)
hm : 0 < { size := size, buckets := buckets }.buckets.size
h : Raw.WFImp ⟨{ size := size, buckets := buckets }, hm⟩.val
h✝ :
¬Std.DHashMap.Internal.numBucketsForCapacity✝ ⟨{ size := size, buckets := buckets }, hm⟩.1.size ≤
⟨{ size := size, buckets := buckets }, hm⟩.1.buckets.size
this : toListModel (expand ⟨buckets, hm⟩).val ~ toListModel buckets
⊢ (toListModel ⟨{ size := size, buckets := buckets }, hm⟩.val.buckets).length =
(toListModel
⟨{ size := ⟨{ size := size, buckets := buckets }, hm⟩.1.size,
buckets := (expand ⟨⟨{ size := size, buckets := buckets }, hm⟩.1.buckets, ⋯⟩).val },
⋯⟩.val.buckets).length
|
simpa using this.symm.length_eq
|
no goals
|
1c1b7d9917a856cf
|
inv_zpow'
|
Mathlib/Algebra/Group/Basic.lean
|
@[to_additive (attr := simp) zsmul_neg']
lemma inv_zpow' (a : α) (n : ℤ) : a⁻¹ ^ n = a ^ (-n)
|
α : Type u_1
inst✝ : DivisionMonoid α
a : α
n : ℤ
⊢ a⁻¹ ^ n = a ^ (-n)
|
rw [inv_zpow, zpow_neg]
|
no goals
|
add5a4260d0d109c
|
Set.einfsep_insert
|
Mathlib/Topology/MetricSpace/Infsep.lean
|
theorem einfsep_insert : einfsep (insert x s) =
(⨅ (y ∈ s) (_ : x ≠ y), edist x y) ⊓ s.einfsep
|
case inr.inl
α : Type u_1
inst✝ : PseudoEMetricSpace α
s : Set α
y : α
hy : y ∈ s
z : α
hyz : y ≠ z
⊢ ⨅ y ∈ s, ⨅ (_ : z ≠ y), edist z y ≤ edist y z ∨ s.einfsep ≤ edist y z
|
rw [edist_comm]
|
case inr.inl
α : Type u_1
inst✝ : PseudoEMetricSpace α
s : Set α
y : α
hy : y ∈ s
z : α
hyz : y ≠ z
⊢ ⨅ y ∈ s, ⨅ (_ : z ≠ y), edist z y ≤ edist z y ∨ s.einfsep ≤ edist z y
|
f40a03789d1fa38e
|
Ideal.Quotient.quotient_ring_saturate
|
Mathlib/RingTheory/Ideal/Quotient/Defs.lean
|
theorem quotient_ring_saturate (s : Set R) :
mk I ⁻¹' (mk I '' s) = ⋃ x : I, (fun y => x.1 + y) '' s
|
case h
R : Type u
inst✝¹ : Ring R
I : Ideal R
inst✝ : I.IsTwoSided
s : Set R
x : R
⊢ x ∈ ⇑(mk I) ⁻¹' (⇑(mk I) '' s) ↔ x ∈ ⋃ x, (fun y => ↑x + y) '' s
|
simp only [mem_preimage, mem_image, mem_iUnion, Ideal.Quotient.eq]
|
case h
R : Type u
inst✝¹ : Ring R
I : Ideal R
inst✝ : I.IsTwoSided
s : Set R
x : R
⊢ (∃ x_1 ∈ s, x_1 - x ∈ I) ↔ ∃ i, ∃ x_1 ∈ s, ↑i + x_1 = x
|
6db8fbab47f6b2ab
|
Finset.prod_eq_mul
|
Mathlib/Algebra/BigOperators/Group/Finset/Basic.lean
|
theorem prod_eq_mul {s : Finset α} {f : α → β} (a b : α) (hn : a ≠ b)
(h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1) (ha : a ∉ s → f a = 1) (hb : b ∉ s → f b = 1) :
∏ x ∈ s, f x = f a * f b
|
α : Type u_3
β : Type u_4
inst✝ : CommMonoid β
s : Finset α
f : α → β
a b : α
hn : a ≠ b
h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1
ha : a ∉ s → f a = 1
hb : b ∉ s → f b = 1
this : DecidableEq α
⊢ ∏ x ∈ s, f x = f a * f b
|
by_cases h₁ : a ∈ s <;> by_cases h₂ : b ∈ s
|
case pos
α : Type u_3
β : Type u_4
inst✝ : CommMonoid β
s : Finset α
f : α → β
a b : α
hn : a ≠ b
h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1
ha : a ∉ s → f a = 1
hb : b ∉ s → f b = 1
this : DecidableEq α
h₁ : a ∈ s
h₂ : b ∈ s
⊢ ∏ x ∈ s, f x = f a * f b
case neg
α : Type u_3
β : Type u_4
inst✝ : CommMonoid β
s : Finset α
f : α → β
a b : α
hn : a ≠ b
h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1
ha : a ∉ s → f a = 1
hb : b ∉ s → f b = 1
this : DecidableEq α
h₁ : a ∈ s
h₂ : b ∉ s
⊢ ∏ x ∈ s, f x = f a * f b
case pos
α : Type u_3
β : Type u_4
inst✝ : CommMonoid β
s : Finset α
f : α → β
a b : α
hn : a ≠ b
h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1
ha : a ∉ s → f a = 1
hb : b ∉ s → f b = 1
this : DecidableEq α
h₁ : a ∉ s
h₂ : b ∈ s
⊢ ∏ x ∈ s, f x = f a * f b
case neg
α : Type u_3
β : Type u_4
inst✝ : CommMonoid β
s : Finset α
f : α → β
a b : α
hn : a ≠ b
h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1
ha : a ∉ s → f a = 1
hb : b ∉ s → f b = 1
this : DecidableEq α
h₁ : a ∉ s
h₂ : b ∉ s
⊢ ∏ x ∈ s, f x = f a * f b
|
b9106c52ac5adf76
|
IsCyclotomicExtension.finite_of_singleton
|
Mathlib/NumberTheory/Cyclotomic/Basic.lean
|
theorem finite_of_singleton [IsDomain B] [h : IsCyclotomicExtension {n} A B] :
Module.Finite A B
|
n : ℕ+
A : Type u
B : Type v
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsDomain B
h : IsCyclotomicExtension {n} A B
⊢ (Subalgebra.toSubmodule (adjoin A {b | ∃ n_1 ∈ {n}, b ^ ↑n_1 = 1})).FG
|
refine fg_adjoin_of_finite ?_ fun b hb => ?_
|
case refine_1
n : ℕ+
A : Type u
B : Type v
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsDomain B
h : IsCyclotomicExtension {n} A B
⊢ {b | ∃ n_1 ∈ {n}, b ^ ↑n_1 = 1}.Finite
case refine_2
n : ℕ+
A : Type u
B : Type v
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsDomain B
h : IsCyclotomicExtension {n} A B
b : B
hb : b ∈ {b | ∃ n_1 ∈ {n}, b ^ ↑n_1 = 1}
⊢ IsIntegral A b
|
cc2a3c4a254e9a04
|
Finset.prod_sum
|
Mathlib/Algebra/BigOperators/Ring/Finset.lean
|
/-- The product over a sum can be written as a sum over the product of sets, `Finset.Pi`.
`Finset.prod_univ_sum` is an alternative statement when the product is over `univ`. -/
lemma prod_sum (s : Finset ι) (t : ∀ i, Finset (κ i)) (f : ∀ i, κ i → α) :
∏ a ∈ s, ∑ b ∈ t a, f a b = ∑ p ∈ s.pi t, ∏ x ∈ s.attach, f x.1 (p x.1 x.2)
|
ι : Type u_1
α : Type u_3
κ : ι → Type u_6
inst✝¹ : CommSemiring α
inst✝ : DecidableEq ι
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
a : ι
s : Finset ι
ha : a ∉ s
ih : ∏ a ∈ s, ∑ b ∈ t a, f a b = ∑ p ∈ s.pi t, ∏ x ∈ s.attach, f (↑x) (p ↑x ⋯)
⊢ ∀ x ∈ t a, ∀ y ∈ t a, x ≠ y → Disjoint (image (Pi.cons s a x) (s.pi t)) (image (Pi.cons s a y) (s.pi t))
|
intro x _ y _ h
|
ι : Type u_1
α : Type u_3
κ : ι → Type u_6
inst✝¹ : CommSemiring α
inst✝ : DecidableEq ι
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
a : ι
s : Finset ι
ha : a ∉ s
ih : ∏ a ∈ s, ∑ b ∈ t a, f a b = ∑ p ∈ s.pi t, ∏ x ∈ s.attach, f (↑x) (p ↑x ⋯)
x : κ a
a✝¹ : x ∈ t a
y : κ a
a✝ : y ∈ t a
h : x ≠ y
⊢ Disjoint (image (Pi.cons s a x) (s.pi t)) (image (Pi.cons s a y) (s.pi t))
|
13d6d8ff7aa531dd
|
is_descending_rev_series_of_is_ascending
|
Mathlib/GroupTheory/Nilpotent.lean
|
theorem is_descending_rev_series_of_is_ascending {H : ℕ → Subgroup G} {n : ℕ} (hn : H n = ⊤)
(hasc : IsAscendingCentralSeries H) : IsDescendingCentralSeries fun m : ℕ => H (n - m)
|
G : Type u_1
inst✝ : Group G
H : ℕ → Subgroup G
n : ℕ
hn : H n = ⊤
hasc : IsAscendingCentralSeries H
⊢ IsDescendingCentralSeries fun m => H (n - m)
|
obtain ⟨h0, hH⟩ := hasc
|
case intro
G : Type u_1
inst✝ : Group G
H : ℕ → Subgroup G
n : ℕ
hn : H n = ⊤
h0 : H 0 = ⊥
hH : ∀ (x : G) (n : ℕ), x ∈ H (n + 1) → ∀ (g : G), x * g * x⁻¹ * g⁻¹ ∈ H n
⊢ IsDescendingCentralSeries fun m => H (n - m)
|
2e0985d2d77b7a82
|
List.mapIdx_reverse
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/MapIdx.lean
|
theorem mapIdx_reverse {l : List α} {f : Nat → α → β} :
l.reverse.mapIdx f = (mapIdx (fun i => f (l.length - 1 - i)) l).reverse
|
α : Type u_1
β : Type u_2
l : List α
f : Nat → α → β
i : Nat
h : l.length ≤ i
⊢ (mapIdx (fun i => f (l.length - 1 - i)) l).reverse.length ≤ i
|
simp [h]
|
no goals
|
8086284ec8908f69
|
Normal.exists_isSplittingField
|
Mathlib/FieldTheory/Normal/Basic.lean
|
theorem Normal.exists_isSplittingField [h : Normal F K] [FiniteDimensional F K] :
∃ p : F[X], IsSplittingField F K p
|
case refine_2
F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
s : Basis (↑(Basis.ofVectorSpaceIndex F K)) F K := Basis.ofVectorSpace F K
x : ↑(Basis.ofVectorSpaceIndex F K)
⊢ (map (algebraMap F K) (∏ x : ↑(Basis.ofVectorSpaceIndex F K), minpoly F (s x))).IsRoot (s x)
|
rw [IsRoot.def, eval_map, ← aeval_def, map_prod]
|
case refine_2
F : Type u_1
K : Type u_2
inst✝³ : Field F
inst✝² : Field K
inst✝¹ : Algebra F K
h : Normal F K
inst✝ : FiniteDimensional F K
s : Basis (↑(Basis.ofVectorSpaceIndex F K)) F K := Basis.ofVectorSpace F K
x : ↑(Basis.ofVectorSpaceIndex F K)
⊢ ∏ x_1 : ↑(Basis.ofVectorSpaceIndex F K), (aeval (s x)) (minpoly F (s x_1)) = 0
|
cf09608356970b0b
|
Digraph.toSimpleGraphStrict_top
|
Mathlib/Combinatorics/Digraph/Orientation.lean
|
@[simp]
lemma toSimpleGraphStrict_top : (⊤ : Digraph V).toSimpleGraphStrict = ⊤
|
case Adj.h.h.a
V : Type u_1
x✝¹ x✝ : V
⊢ ⊤.toSimpleGraphStrict.Adj x✝¹ x✝ ↔ ⊤.Adj x✝¹ x✝
|
exact ⟨And.left, fun h ↦ ⟨h.ne, trivial, trivial⟩⟩
|
no goals
|
4eed4830ef54132b
|
descPochhammer_natDegree
|
Mathlib/RingTheory/Polynomial/Pochhammer.lean
|
theorem descPochhammer_natDegree (n : ℕ) [NoZeroDivisors R] [Nontrivial R] :
(descPochhammer R n).natDegree = n
|
case succ
R : Type u
inst✝² : Ring R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
n✝ : ℕ
hn : (descPochhammer R (n✝ + 1)).natDegree = n✝ + 1
this : (X - ↑(n✝ + 1)).natDegree = 1
⊢ descPochhammer R (n✝ + 1) ≠ 0
|
refine ne_zero_of_natDegree_gt <| hn.symm ▸ Nat.add_one_pos _
|
no goals
|
57895a57672af1e9
|
TensorProduct.exists_multiset
|
Mathlib/LinearAlgebra/TensorProduct/Finiteness.lean
|
theorem exists_multiset (x : M ⊗[R] N) :
∃ S : Multiset (M × N), x = (S.map fun i ↦ i.1 ⊗ₜ[R] i.2).sum
|
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
⊢ 0 = (Multiset.map (fun i => i.1 ⊗ₜ[R] i.2) 0).sum
|
simp
|
no goals
|
9710e818bf6f1606
|
mul_eq_of_eq_mul_inv
|
Mathlib/Algebra/Group/Basic.lean
|
theorem mul_eq_of_eq_mul_inv (h : a = c * b⁻¹) : a * b = c
|
G : Type u_3
inst✝ : Group G
a b c : G
h : a = c * b⁻¹
⊢ a * b = c
|
simp [h]
|
no goals
|
001033476801b2c2
|
mul_left_inj_of_comparable
|
Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
|
@[to_additive]
lemma mul_left_inj_of_comparable [MulRightStrictMono α] {a b c : α} (h : b ≤ c ∨ c ≤ b) :
c * a = b * a ↔ c = b
|
α : Type u_1
inst✝² : Mul α
inst✝¹ : PartialOrder α
inst✝ : MulRightStrictMono α
a b c : α
h : b ≤ c ∨ c ≤ b
h' : ¬c = b
⊢ ¬c * a = b * a
|
obtain h | h := h
|
case inl
α : Type u_1
inst✝² : Mul α
inst✝¹ : PartialOrder α
inst✝ : MulRightStrictMono α
a b c : α
h' : ¬c = b
h : b ≤ c
⊢ ¬c * a = b * a
case inr
α : Type u_1
inst✝² : Mul α
inst✝¹ : PartialOrder α
inst✝ : MulRightStrictMono α
a b c : α
h' : ¬c = b
h : c ≤ b
⊢ ¬c * a = b * a
|
298e7bc96f7b1c47
|
Filter.mem_iInf_finset
|
Mathlib/Order/Filter/Finite.lean
|
theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
(t ∈ ⨅ a ∈ s, f a) ↔ ∃ p : α → Set β, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a
|
case refine_1.intro.intro
α : Type u
β : Type v
s : Finset α
f : α → Filter β
p : Subtype (Membership.mem s) → Set β
hp : ∀ (i : Subtype (Membership.mem s)), p i ∈ f ↑i
h : ⋂ i, p i ∈ ⨅ x, f ↑x
⊢ ∀ (x : Subtype (Membership.mem s)), (fun a => if h : a ∈ s then p ⟨a, h⟩ else univ) ↑(id x) = p x
|
rintro ⟨a, ha⟩
|
case refine_1.intro.intro.mk
α : Type u
β : Type v
s : Finset α
f : α → Filter β
p : Subtype (Membership.mem s) → Set β
hp : ∀ (i : Subtype (Membership.mem s)), p i ∈ f ↑i
h : ⋂ i, p i ∈ ⨅ x, f ↑x
a : α
ha : a ∈ s
⊢ (fun a => if h : a ∈ s then p ⟨a, h⟩ else univ) ↑(id ⟨a, ha⟩) = p ⟨a, ha⟩
|
9233bcf1393f0994
|
integral_smul_const
|
Mathlib/MeasureTheory/Integral/SetIntegral.lean
|
theorem integral_smul_const {𝕜 : Type*} [RCLike 𝕜] [NormedSpace 𝕜 E] [CompleteSpace E]
(f : X → 𝕜) (c : E) :
∫ x, f x • c ∂μ = (∫ x, f x ∂μ) • c
|
case neg
X : Type u_1
E : Type u_3
inst✝⁵ : MeasurableSpace X
μ : Measure X
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
𝕜 : Type u_6
inst✝² : RCLike 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : CompleteSpace E
f : X → 𝕜
c : E
hf : ¬Integrable f μ
⊢ ∫ (x : X), f x • c ∂μ = (∫ (x : X), f x ∂μ) • c
|
by_cases hc : c = 0
|
case pos
X : Type u_1
E : Type u_3
inst✝⁵ : MeasurableSpace X
μ : Measure X
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
𝕜 : Type u_6
inst✝² : RCLike 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : CompleteSpace E
f : X → 𝕜
c : E
hf : ¬Integrable f μ
hc : c = 0
⊢ ∫ (x : X), f x • c ∂μ = (∫ (x : X), f x ∂μ) • c
case neg
X : Type u_1
E : Type u_3
inst✝⁵ : MeasurableSpace X
μ : Measure X
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
𝕜 : Type u_6
inst✝² : RCLike 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : CompleteSpace E
f : X → 𝕜
c : E
hf : ¬Integrable f μ
hc : ¬c = 0
⊢ ∫ (x : X), f x • c ∂μ = (∫ (x : X), f x ∂μ) • c
|
aac8ef1cc4baf728
|
VitaliFamily.ae_tendsto_measure_inter_div
|
Mathlib/MeasureTheory/Covering/Differentiation.lean
|
theorem ae_tendsto_measure_inter_div (s : Set α) :
∀ᵐ x ∂μ.restrict s, Tendsto (fun a => μ (s ∩ a) / μ a) (v.filterAt x) (𝓝 1)
|
α : Type u_1
inst✝³ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
s : Set α
⊢ ∀ᵐ (x : α) ∂μ.restrict s, Tendsto (fun a => μ (s ∩ a) / μ a) (v.filterAt x) (𝓝 1)
|
let t := toMeasurable μ s
|
α : Type u_1
inst✝³ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
s : Set α
t : Set α := toMeasurable μ s
⊢ ∀ᵐ (x : α) ∂μ.restrict s, Tendsto (fun a => μ (s ∩ a) / μ a) (v.filterAt x) (𝓝 1)
|
8186fdd8c3259bbd
|
SpectrumRestricts.nnreal_iff_spectralRadius_le
|
Mathlib/Analysis/Normed/Algebra/Spectrum.lean
|
lemma nnreal_iff_spectralRadius_le [Algebra ℝ A] {a : A} {t : ℝ≥0} (ht : spectralRadius ℝ a ≤ t) :
SpectrumRestricts a ContinuousMap.realToNNReal ↔
spectralRadius ℝ (algebraMap ℝ A t - a) ≤ t
|
case refine_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
this : spectrum ℝ a ⊆ Set.Icc (-↑t) ↑t
h : ∀ x ∈ spectrum ℝ a, ‖↑t - x‖₊ ≤ t
⊢ ∀ x ∈ spectrum ℝ a, 0 ≤ x
|
peel h with x hx h_le
|
case refine_2.h.h
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
this : spectrum ℝ a ⊆ Set.Icc (-↑t) ↑t
h : ∀ x ∈ spectrum ℝ a, ‖↑t - x‖₊ ≤ t
x : ℝ
hx : x ∈ spectrum ℝ a
h_le : ‖↑t - x‖₊ ≤ t
⊢ 0 ≤ x
|
23e88e5a29773e00
|
Vector.any_eq
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lemmas.lean
|
theorem any_eq {xs : Vector α n} {p : α → Bool} : xs.any p = decide (∃ i : Nat, ∃ h, p (xs[i]'h))
|
case neg
α : Type u_1
n : Nat
xs : Vector α n
p : α → Bool
h : ¬xs.any p = true
⊢ xs.any p = decide (∃ i h, p xs[i] = true)
|
simp_all [any_eq_false]
|
no goals
|
ae6da32304da43f5
|
SimpleGraph.chromaticNumber_le_iff_colorable
|
Mathlib/Combinatorics/SimpleGraph/Coloring.lean
|
theorem chromaticNumber_le_iff_colorable {n : ℕ} : G.chromaticNumber ≤ n ↔ G.Colorable n
|
V : Type u
G : SimpleGraph V
n : ℕ
h : G.chromaticNumber ≤ ↑n
this : ∃ n, G.Colorable n
⊢ G.Colorable n
|
obtain ⟨m, hm⟩ := this
|
case intro
V : Type u
G : SimpleGraph V
n : ℕ
h : G.chromaticNumber ≤ ↑n
m : ℕ
hm : G.Colorable m
⊢ G.Colorable n
|
4ec1c55975e623fc
|
analyticGroupoid_prod
|
Mathlib/Geometry/Manifold/AnalyticManifold.lean
|
theorem analyticGroupoid_prod {E A : Type} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
[TopologicalSpace A] {F B : Type} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
[TopologicalSpace B] {I : ModelWithCorners 𝕜 E A} {J : ModelWithCorners 𝕜 F B}
{f : PartialHomeomorph A A} {g : PartialHomeomorph B B}
(fa : f ∈ analyticGroupoid I) (ga : g ∈ analyticGroupoid J) :
f.prod g ∈ analyticGroupoid (I.prod J)
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E A : Type
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : TopologicalSpace A
F B : Type
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
I : ModelWithCorners 𝕜 E A
J : ModelWithCorners 𝕜 F B
f : PartialHomeomorph A A
g : PartialHomeomorph B B
fa : f ∈ analyticGroupoid I
ga : g ∈ analyticGroupoid J
pe : range ↑(I.prod J) = (range ↑I).prod (range ↑J)
⊢ f.prod g ∈ analyticGroupoid (I.prod J)
|
simp only [mem_analyticGroupoid, Function.comp, image_subset_iff] at fa ga ⊢
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E A : Type
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : TopologicalSpace A
F B : Type
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : TopologicalSpace B
I : ModelWithCorners 𝕜 E A
J : ModelWithCorners 𝕜 F B
f : PartialHomeomorph A A
g : PartialHomeomorph B B
pe : range ↑(I.prod J) = (range ↑I).prod (range ↑J)
fa :
AnalyticOn 𝕜 (↑I ∘ ↑f ∘ ↑I.symm) (↑I.symm ⁻¹' f.source ∩ range ↑I) ∧
AnalyticOn 𝕜 (↑I ∘ ↑f.symm ∘ ↑I.symm) (↑I.symm ⁻¹' f.target ∩ range ↑I)
ga :
AnalyticOn 𝕜 (↑J ∘ ↑g ∘ ↑J.symm) (↑J.symm ⁻¹' g.source ∩ range ↑J) ∧
AnalyticOn 𝕜 (↑J ∘ ↑g.symm ∘ ↑J.symm) (↑J.symm ⁻¹' g.target ∩ range ↑J)
⊢ AnalyticOn 𝕜 (↑(I.prod J) ∘ ↑(f.prod g) ∘ ↑(I.prod J).symm)
(↑(I.prod J).symm ⁻¹' (f.prod g).source ∩ range ↑(I.prod J)) ∧
AnalyticOn 𝕜 (↑(I.prod J) ∘ ↑(f.prod g).symm ∘ ↑(I.prod J).symm)
(↑(I.prod J).symm ⁻¹' (f.prod g).target ∩ range ↑(I.prod J))
|
a63b9a12fa883575
|
Submodule.goursat_surjective
|
Mathlib/LinearAlgebra/Goursat.lean
|
/-- **Goursat's lemma** for a submodule of a product with surjective projections.
If `L` is a submodule of `M × N` which projects fully on both factors, then there exist submodules
`M' ≤ M` and `N' ≤ N` such that `M' × N' ≤ L` and the image of `L` in `(M ⧸ M') × (N ⧸ N')` is the
graph of an isomorphism of `R`-modules `(M ⧸ M') ≃ (N ⧸ N')`.
`M` and `N` can be explicitly constructed as `L.goursatFst` and `L.goursatSnd` respectively. -/
lemma goursat_surjective : ∃ e : (M ⧸ L.goursatFst) ≃ₗ[R] N ⧸ L.goursatSnd,
LinearMap.range ((L.goursatFst.mkQ.prodMap L.goursatSnd.mkQ).comp L.subtype) = e.graph
|
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
L : Submodule R (M × N)
hL₁ : Surjective (Prod.fst ∘ ⇑L.subtype)
hL₂ : Surjective (Prod.snd ∘ ⇑L.subtype)
e : M ⧸ L.goursatFst ≃+ N ⧸ L.goursatSnd
he :
(((QuotientAddGroup.mk' L.toAddSubgroup.goursatFst).prodMap (QuotientAddGroup.mk' L.toAddSubgroup.goursatSnd)).comp
L.toAddSubgroup.subtype).range =
e.toAddMonoidHom.graph
r : R
x : M ⧸ L.goursatFst
⊢ r • (x, e x) ∈
(((QuotientAddGroup.mk' L.toAddSubgroup.goursatFst).prodMap (QuotientAddGroup.mk' L.toAddSubgroup.goursatSnd)).comp
L.toAddSubgroup.subtype).range
|
have : (x, e x) ∈ e.toAddMonoidHom.graph := rfl
|
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
L : Submodule R (M × N)
hL₁ : Surjective (Prod.fst ∘ ⇑L.subtype)
hL₂ : Surjective (Prod.snd ∘ ⇑L.subtype)
e : M ⧸ L.goursatFst ≃+ N ⧸ L.goursatSnd
he :
(((QuotientAddGroup.mk' L.toAddSubgroup.goursatFst).prodMap (QuotientAddGroup.mk' L.toAddSubgroup.goursatSnd)).comp
L.toAddSubgroup.subtype).range =
e.toAddMonoidHom.graph
r : R
x : M ⧸ L.goursatFst
this : (x, e x) ∈ e.toAddMonoidHom.graph
⊢ r • (x, e x) ∈
(((QuotientAddGroup.mk' L.toAddSubgroup.goursatFst).prodMap (QuotientAddGroup.mk' L.toAddSubgroup.goursatSnd)).comp
L.toAddSubgroup.subtype).range
|
6911146a30de3dd6
|
Std.DHashMap.Internal.List.containsKey_cons_eq_false
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem containsKey_cons_eq_false [BEq α] {l : List ((a : α) × β a)} {k a : α} {v : β k} :
(containsKey a (⟨k, v⟩ :: l) = false) ↔ ((k == a) = false) ∧ (containsKey a l = false)
|
α : Type u
β : α → Type v
inst✝ : BEq α
l : List ((a : α) × β a)
k a : α
v : β k
⊢ containsKey a (⟨k, v⟩ :: l) = false ↔ (k == a) = false ∧ containsKey a l = false
|
simp [containsKey_cons, not_or]
|
no goals
|
d481c3eefe9b8882
|
UniformSpace.Completion.mem_uniformity_dist
|
Mathlib/Topology/MetricSpace/Completion.lean
|
theorem mem_uniformity_dist (s : Set (Completion α × Completion α)) :
s ∈ 𝓤 (Completion α) ↔ ∃ ε > 0, ∀ {a b}, dist a b < ε → (a, b) ∈ s
|
case mp.intro.intro.intro.intro.intro
α : Type u
inst✝ : PseudoMetricSpace α
s : Set (Completion α × Completion α)
hs : s ∈ 𝓤 (Completion α)
t : Set (Completion α × Completion α)
ht : t ∈ 𝓤 (Completion α)
tclosed : IsClosed t
ts : t ⊆ s
A : {x | (↑x.1, ↑x.2) ∈ t} ∈ 𝓤 α
ε : ℝ
εpos : ε > 0
hε : ∀ ⦃a b : α⦄, dist a b < ε → (a, b) ∈ {x | (↑x.1, ↑x.2) ∈ t}
x y : Completion α
hxy : dist x y < ε
this : ε ≤ dist x y ∨ (x, y) ∈ t
⊢ (x, y) ∈ s
|
simp only [not_le.mpr hxy, false_or, not_le] at this
|
case mp.intro.intro.intro.intro.intro
α : Type u
inst✝ : PseudoMetricSpace α
s : Set (Completion α × Completion α)
hs : s ∈ 𝓤 (Completion α)
t : Set (Completion α × Completion α)
ht : t ∈ 𝓤 (Completion α)
tclosed : IsClosed t
ts : t ⊆ s
A : {x | (↑x.1, ↑x.2) ∈ t} ∈ 𝓤 α
ε : ℝ
εpos : ε > 0
hε : ∀ ⦃a b : α⦄, dist a b < ε → (a, b) ∈ {x | (↑x.1, ↑x.2) ∈ t}
x y : Completion α
hxy : dist x y < ε
this : (x, y) ∈ t
⊢ (x, y) ∈ s
|
c4dfc92c04080ea5
|
Equiv.Perm.mem_cycleType_iff
|
Mathlib/GroupTheory/Perm/Cycle/Type.lean
|
theorem mem_cycleType_iff {n : ℕ} {σ : Perm α} :
n ∈ cycleType σ ↔ ∃ c τ, σ = c * τ ∧ Disjoint c τ ∧ IsCycle c ∧ c.support.card = n
|
case mp.mk.mk.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
n : ℕ
l : List (Perm α)
h : n ∈ l.prod.cycleType
x✝ : Trunc { l_1 // l_1.prod = l.prod ∧ (∀ g ∈ l_1, g.IsCycle) ∧ List.Pairwise Disjoint l_1 }
hlc : ∀ g ∈ l, g.IsCycle
hld : List.Pairwise Disjoint l
⊢ ∃ c τ, l.prod = c * τ ∧ c.Disjoint τ ∧ c.IsCycle ∧ c.support.card = n
|
rw [cycleType_eq _ rfl hlc hld, Multiset.mem_coe, List.mem_map] at h
|
case mp.mk.mk.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
n : ℕ
l : List (Perm α)
h : ∃ a ∈ l, (Finset.card ∘ support) a = n
x✝ : Trunc { l_1 // l_1.prod = l.prod ∧ (∀ g ∈ l_1, g.IsCycle) ∧ List.Pairwise Disjoint l_1 }
hlc : ∀ g ∈ l, g.IsCycle
hld : List.Pairwise Disjoint l
⊢ ∃ c τ, l.prod = c * τ ∧ c.Disjoint τ ∧ c.IsCycle ∧ c.support.card = n
|
d7502a60859fe51e
|
Equiv.Perm.subtypeCongr.symm
|
Mathlib/Logic/Equiv/Basic.lean
|
theorem Perm.subtypeCongr.symm : (ep.subtypeCongr en).symm = Perm.subtypeCongr ep.symm en.symm
|
ε : Type u_9
p : ε → Prop
inst✝ : DecidablePred p
ep : Perm { a // p a }
en : Perm { a // ¬p a }
⊢ Equiv.symm (ep.subtypeCongr en) = subtypeCongr (Equiv.symm ep) (Equiv.symm en)
|
ext x
|
case H
ε : Type u_9
p : ε → Prop
inst✝ : DecidablePred p
ep : Perm { a // p a }
en : Perm { a // ¬p a }
x : ε
⊢ (Equiv.symm (ep.subtypeCongr en)) x = (subtypeCongr (Equiv.symm ep) (Equiv.symm en)) x
|
2d99a37b0398671d
|
CategoryTheory.IsPushout.isVanKampen_iff
|
Mathlib/CategoryTheory/Adhesive.lean
|
theorem IsPushout.isVanKampen_iff (H : IsPushout f g h i) :
H.IsVanKampen ↔ IsVanKampenColimit (PushoutCocone.mk h i H.w)
|
case mp.refine_5.mpr
C : Type u
inst✝ : Category.{v, u} C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
H✝ : IsPushout f g h i
H : H✝.IsVanKampen
F' : WalkingSpan ⥤ C
c' : Cocone F'
α : F' ⟶ span f g
fα : c'.pt ⟶ (PushoutCocone.mk h i ⋯).pt
eα : α ≫ (PushoutCocone.mk h i ⋯).ι = c'.ι ≫ (Functor.const WalkingSpan).map fα
hα : NatTrans.Equifibered α
⊢ (∀ (j : WalkingSpan), IsPullback (c'.ι.app j) (α.app j) fα ((PushoutCocone.mk h i ⋯).ι.app j)) →
IsPullback (c'.ι.app WalkingSpan.left) (α.app WalkingSpan.left) fα h ∧
IsPullback (c'.ι.app WalkingSpan.right) (α.app WalkingSpan.right) fα i
|
intro h
|
case mp.refine_5.mpr
C : Type u
inst✝ : Category.{v, u} C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h✝ : X ⟶ Z
i : Y ⟶ Z
H✝ : IsPushout f g h✝ i
H : H✝.IsVanKampen
F' : WalkingSpan ⥤ C
c' : Cocone F'
α : F' ⟶ span f g
fα : c'.pt ⟶ (PushoutCocone.mk h✝ i ⋯).pt
eα : α ≫ (PushoutCocone.mk h✝ i ⋯).ι = c'.ι ≫ (Functor.const WalkingSpan).map fα
hα : NatTrans.Equifibered α
h : ∀ (j : WalkingSpan), IsPullback (c'.ι.app j) (α.app j) fα ((PushoutCocone.mk h✝ i ⋯).ι.app j)
⊢ IsPullback (c'.ι.app WalkingSpan.left) (α.app WalkingSpan.left) fα h✝ ∧
IsPullback (c'.ι.app WalkingSpan.right) (α.app WalkingSpan.right) fα i
|
03b3318bb2e454c2
|
IsMulFreimanHom.mono
|
Mathlib/Combinatorics/Additive/FreimanHom.lean
|
@[to_additive]
lemma IsMulFreimanHom.mono (hmn : m ≤ n) (hf : IsMulFreimanHom n A B f) :
IsMulFreimanHom m A B f where
mapsTo := hf.mapsTo
map_prod_eq_map_prod s t hsA htA hs ht h
|
case inr.intro.refine_2
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : CancelCommMonoid β
A : Set α
B : Set β
f : α → β
m n : ℕ
hmn : m ≤ n
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = m
ht : t.card = m
h : s.prod = t.prod
a✝ : α
ha✝ : a✝ ∈ A
a : α
ha : a ∈ t + replicate (n - m) a✝
⊢ a ∈ A
|
rw [Multiset.mem_add] at ha
|
case inr.intro.refine_2
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : CancelCommMonoid β
A : Set α
B : Set β
f : α → β
m n : ℕ
hmn : m ≤ n
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = m
ht : t.card = m
h : s.prod = t.prod
a✝ : α
ha✝ : a✝ ∈ A
a : α
ha : a ∈ t ∨ a ∈ replicate (n - m) a✝
⊢ a ∈ A
|
b2311f9c87a69848
|
DirichletCharacter.factorsThrough_iff_ker_unitsMap
|
Mathlib/NumberTheory/DirichletCharacter/Basic.lean
|
/-- A Dirichlet character `χ` factors through `d | n` iff its associated unit-group hom is trivial
on the kernel of `ZMod.unitsMap`. -/
lemma factorsThrough_iff_ker_unitsMap {d : ℕ} [NeZero n] (hd : d ∣ n) :
FactorsThrough χ d ↔ (ZMod.unitsMap hd).ker ≤ χ.toUnitHom.ker
|
case refine_1
R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
d : ℕ
inst✝ : NeZero n
hd : d ∣ n
x✝ : χ.FactorsThrough d
x : (ZMod n)ˣ
hx : x ∈ (ZMod.unitsMap hd).ker
w✝ : d ∣ n
χ₀ : DirichletCharacter R d
hχ₀ : χ = (changeLevel w✝) χ₀
⊢ x ∈ (toUnitHom χ).ker
|
rw [MonoidHom.mem_ker, hχ₀, changeLevel_toUnitHom, MonoidHom.comp_apply, hx, map_one]
|
no goals
|
c8fa781f768f7329
|
IsZGroup.of_injective
|
Mathlib/GroupTheory/SpecificGroups/ZGroup.lean
|
theorem of_injective [hG' : IsZGroup G'] (hf : Function.Injective f) : IsZGroup G
|
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
hG' : ∀ (p : ℕ), Nat.Prime p → ∀ (P : Sylow p G'), IsCyclic ↥↑P
hf : Function.Injective ⇑f
p : ℕ
hp : Nat.Prime p
P : Sylow p G
⊢ IsCyclic ↥↑P
|
obtain ⟨Q, hQ⟩ := P.exists_comap_eq_of_injective hf
|
case intro
G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
hG' : ∀ (p : ℕ), Nat.Prime p → ∀ (P : Sylow p G'), IsCyclic ↥↑P
hf : Function.Injective ⇑f
p : ℕ
hp : Nat.Prime p
P : Sylow p G
Q : Sylow p G'
hQ : Subgroup.comap f ↑Q = ↑P
⊢ IsCyclic ↥↑P
|
c14359612b1097e9
|
orthonormal_subtype_iff_ite
|
Mathlib/Analysis/InnerProductSpace/Orthonormal.lean
|
theorem orthonormal_subtype_iff_ite [DecidableEq E] {s : Set E} :
Orthonormal 𝕜 (Subtype.val : s → E) ↔ ∀ v ∈ s, ∀ w ∈ s, ⟪v, w⟫ = if v = w then 1 else 0
|
case mp
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : DecidableEq E
s : Set E
h : ∀ (i j : { x // x ∈ s }), inner ↑i ↑j = if i = j then 1 else 0
v : E
hv : v ∈ s
w : E
hw : w ∈ s
⊢ inner v w = if v = w then 1 else 0
|
convert h ⟨v, hv⟩ ⟨w, hw⟩ using 1
|
case h.e'_3
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : DecidableEq E
s : Set E
h : ∀ (i j : { x // x ∈ s }), inner ↑i ↑j = if i = j then 1 else 0
v : E
hv : v ∈ s
w : E
hw : w ∈ s
⊢ (if v = w then 1 else 0) = if ⟨v, hv⟩ = ⟨w, hw⟩ then 1 else 0
|
215f388e20565e1c
|
Array.map_filterMap
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem map_filterMap (f : α → Option β) (g : β → γ) (l : Array α) :
map g (filterMap f l) = filterMap (fun x => (f x).map g) l
|
case mk
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
g : β → γ
toList✝ : List α
⊢ map g (filterMap f { toList := toList✝ }) = filterMap (fun x => Option.map g (f x)) { toList := toList✝ }
|
simp [List.map_filterMap]
|
no goals
|
06e8d21c0c8a1df4
|
Basis.flag_le_ker_dual
|
Mathlib/LinearAlgebra/Basis/Flag.lean
|
theorem flag_le_ker_dual (b : Basis (Fin n) R M) (k : Fin n) :
b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k)
|
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
k : Fin n
⊢ b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k)
|
nontriviality R
|
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
k : Fin n
a✝ : Nontrivial R
⊢ b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k)
|
2680ceded4b0a4a4
|
String.extract.go₂_add_right_cancel
|
Mathlib/.lake/packages/batteries/Batteries/Data/String/Lemmas.lean
|
theorem extract.go₂_add_right_cancel (s : List Char) (i e n : Nat) :
go₂ s ⟨i + n⟩ ⟨e + n⟩ = go₂ s ⟨i⟩ ⟨e⟩
|
s : List Char
i e n : Nat
⊢ go₂ s { byteIdx := i + n } { byteIdx := e + n } = go₂ s { byteIdx := i } { byteIdx := e }
|
apply utf8InductionOn s ⟨i⟩ ⟨e⟩ (motive := fun s i =>
go₂ s ⟨i.byteIdx + n⟩ ⟨e + n⟩ = go₂ s i ⟨e⟩)
<;> simp only [ne_eq, go₂, pos_add_char, implies_true, ↓reduceIte]
|
case ind
s : List Char
i e n : Nat
⊢ ∀ (c : Char) (cs : List Char) (i : Pos),
¬i = { byteIdx := e } →
go₂ cs { byteIdx := i.byteIdx + c.utf8Size + n } { byteIdx := e + n } = go₂ cs (i + c) { byteIdx := e } →
(if { byteIdx := i.byteIdx + n } = { byteIdx := e + n } then []
else c :: go₂ cs ({ byteIdx := i.byteIdx + n } + c) { byteIdx := e + n }) =
if i = { byteIdx := e } then [] else c :: go₂ cs (i + c) { byteIdx := e }
|
aa43f0044528d480
|
measurable_to_countable
|
Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
|
theorem measurable_to_countable [MeasurableSpace α] [Countable α] [MeasurableSpace β] {f : β → α}
(h : ∀ y, MeasurableSet (f ⁻¹' {f y})) : Measurable f := fun s _ => by
rw [← biUnion_preimage_singleton]
refine MeasurableSet.iUnion fun y => MeasurableSet.iUnion fun hy => ?_
by_cases hyf : y ∈ range f
· rcases hyf with ⟨y, rfl⟩
apply h
· simp only [preimage_singleton_eq_empty.2 hyf, MeasurableSet.empty]
|
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : Countable α
inst✝ : MeasurableSpace β
f : β → α
h : ∀ (y : β), MeasurableSet (f ⁻¹' {f y})
s : Set α
x✝ : MeasurableSet s
⊢ MeasurableSet (⋃ y ∈ s, f ⁻¹' {y})
|
refine MeasurableSet.iUnion fun y => MeasurableSet.iUnion fun hy => ?_
|
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : Countable α
inst✝ : MeasurableSpace β
f : β → α
h : ∀ (y : β), MeasurableSet (f ⁻¹' {f y})
s : Set α
x✝ : MeasurableSet s
y : α
hy : y ∈ s
⊢ MeasurableSet (f ⁻¹' {y})
|
650f582eeb8f0ee3
|
FractionalIdeal.mem_div_iff_of_nonzero
|
Mathlib/RingTheory/FractionalIdeal/Operations.lean
|
theorem mem_div_iff_of_nonzero {I J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) {x} :
x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I
|
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
I J : FractionalIdeal R₁⁰ K
h : J ≠ 0
x : K
⊢ x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I
|
rw [div_nonzero h]
|
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
I J : FractionalIdeal R₁⁰ K
h : J ≠ 0
x : K
⊢ x ∈ ⟨↑I / ↑J, ⋯⟩ ↔ ∀ y ∈ J, x * y ∈ I
|
16a839d94995fb99
|
eigenvalue_nonneg_of_nonneg
|
Mathlib/Analysis/InnerProductSpace/Spectrum.lean
|
theorem eigenvalue_nonneg_of_nonneg {μ : ℝ} {T : E →ₗ[𝕜] E} (hμ : HasEigenvalue T μ)
(hnn : ∀ x : E, 0 ≤ RCLike.re ⟪x, T x⟫) : 0 ≤ μ
|
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re (inner x (T x))
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
⊢ RCLike.re (inner v (T v)) = μ * ‖v‖ ^ 2
|
have := congr_arg RCLike.re (inner_product_apply_eigenvector hv.1)
|
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 ≤ RCLike.re (inner x (T x))
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
this : RCLike.re (inner v (T v)) = RCLike.re (↑μ * ↑‖v‖ ^ 2)
⊢ RCLike.re (inner v (T v)) = μ * ‖v‖ ^ 2
|
492082ccb8bb9f68
|
List.prod_pos
|
Mathlib/Algebra/Order/BigOperators/GroupWithZero/List.lean
|
lemma prod_pos {s : List R} (h : ∀ a ∈ s, 0 < a) : 0 < s.prod
|
case nil
R : Type u_1
inst✝⁴ : CommMonoidWithZero R
inst✝³ : PartialOrder R
inst✝² : ZeroLEOneClass R
inst✝¹ : PosMulStrictMono R
inst✝ : NeZero 1
h : ∀ (a : R), a ∈ [] → 0 < a
⊢ 0 < [].prod
|
simp
|
no goals
|
38ed21843183e9b5
|
Fin.zero_eq_one_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
|
theorem zero_eq_one_iff {n : Nat} [NeZero n] : (0 : Fin n) = 1 ↔ n = 1
|
n : Nat
inst✝ : NeZero n
⊢ 0 = 1 ↔ n = 1
|
constructor
|
case mp
n : Nat
inst✝ : NeZero n
⊢ 0 = 1 → n = 1
case mpr
n : Nat
inst✝ : NeZero n
⊢ n = 1 → 0 = 1
|
1b6c9cdc3a95a9f5
|
AlgebraicGeometry.Proj.SpecMap_awayMap_awayι
|
Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Basic.lean
|
@[reassoc]
lemma SpecMap_awayMap_awayι :
Spec.map (CommRingCat.ofHom (awayMap 𝒜 g_deg hx)) ≫ awayι 𝒜 f f_deg hm =
awayι 𝒜 x (hx ▸ SetLike.mul_mem_graded f_deg g_deg) (hm.trans_le (m.le_add_right m'))
|
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
m' : ℕ
g : A
g_deg : g ∈ 𝒜 m'
x : A
hx : x = f * g
⊢ Spec.map (CommRingCat.ofHom (awayMap 𝒜 g_deg hx)) ≫ awayι 𝒜 f f_deg hm = awayι 𝒜 x ⋯ ⋯
|
rw [awayι, awayι, Iso.eq_inv_comp, basicOpenIsoSpec_hom, basicOpenToSpec_SpecMap_awayMap_assoc,
← basicOpenIsoSpec_hom _ _ f_deg hm, Iso.hom_inv_id_assoc, Scheme.homOfLE_ι]
|
no goals
|
2318ee59dae8782b
|
MeasureTheory.SignedMeasure.bddBelow_measureOfNegatives
|
Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
|
theorem bddBelow_measureOfNegatives : BddBelow s.measureOfNegatives
|
α : Type u_1
inst✝ : MeasurableSpace α
s : SignedMeasure α
h : ∀ (x : ℝ), ∃ x_1 ∈ s.measureOfNegatives, x_1 < x
f : ℕ → ℝ
hf : ∀ (n : ℕ), f n ∈ s.measureOfNegatives ∧ f n < -↑n
B : ℕ → Set α
hmeas : ∀ (n : ℕ), MeasurableSet (B n)
hr : ∀ (n : ℕ), s ≤[B n] 0
h_lt : ∀ (n : ℕ), ↑s (B n) < -↑n
A : Set α := ⋃ n, B n
hA : A = ⋃ n, B n
n : ℕ
⊢ ↑s ((⋃ i, B i) \ B n) + ↑s (B n) ≤ ↑s (B n)
|
refine add_le_of_nonpos_left ?_
|
α : Type u_1
inst✝ : MeasurableSpace α
s : SignedMeasure α
h : ∀ (x : ℝ), ∃ x_1 ∈ s.measureOfNegatives, x_1 < x
f : ℕ → ℝ
hf : ∀ (n : ℕ), f n ∈ s.measureOfNegatives ∧ f n < -↑n
B : ℕ → Set α
hmeas : ∀ (n : ℕ), MeasurableSet (B n)
hr : ∀ (n : ℕ), s ≤[B n] 0
h_lt : ∀ (n : ℕ), ↑s (B n) < -↑n
A : Set α := ⋃ n, B n
hA : A = ⋃ n, B n
n : ℕ
⊢ ↑s ((⋃ i, B i) \ B n) ≤ 0
|
317f19e924fb7de4
|
isFiniteLength_of_exists_compositionSeries
|
Mathlib/RingTheory/FiniteLength.lean
|
theorem isFiniteLength_of_exists_compositionSeries
(h : ∃ s : CompositionSeries (Submodule R M), s.head = ⊥ ∧ s.last = ⊤) :
IsFiniteLength R M :=
Submodule.topEquiv.isFiniteLength <| by
obtain ⟨s, s_head, s_last⟩ := h
rw [← s_last]
suffices ∀ i, IsFiniteLength R (s i) from this (Fin.last _)
intro i
induction' i using Fin.induction with i ih
· change IsFiniteLength R s.head; rw [s_head]; exact .of_subsingleton
let cov := s.step i
have := (covBy_iff_quot_is_simple cov.le).mp cov
have := ((s i.castSucc).comap (s i.succ).subtype).equivMapOfInjective
_ (Submodule.injective_subtype _)
rw [Submodule.map_comap_subtype, inf_of_le_right cov.le] at this
exact .of_simple_quotient (this.symm.isFiniteLength ih)
|
case intro.intro.succ
R : Type u_1
inst✝² : Ring R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : CompositionSeries (Submodule R M)
s_head : RelSeries.head s = ⊥
s_last : RelSeries.last s = ⊤
i : Fin s.length
ih : IsFiniteLength R ↥(s.toFun i.castSucc)
cov : JordanHolderLattice.IsMaximal (s.toFun i.castSucc) (s.toFun i.succ) := s.step i
this✝ : IsSimpleModule R (↥(s.toFun i.succ) ⧸ Submodule.comap (s.toFun i.succ).subtype (s.toFun i.castSucc))
this :
↥(Submodule.comap (s.toFun i.succ).subtype (s.toFun i.castSucc)) ≃ₗ[R]
↥(Submodule.map (s.toFun i.succ).subtype (Submodule.comap (s.toFun i.succ).subtype (s.toFun i.castSucc)))
⊢ IsFiniteLength R ↥(s.toFun i.succ)
|
rw [Submodule.map_comap_subtype, inf_of_le_right cov.le] at this
|
case intro.intro.succ
R : Type u_1
inst✝² : Ring R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : CompositionSeries (Submodule R M)
s_head : RelSeries.head s = ⊥
s_last : RelSeries.last s = ⊤
i : Fin s.length
ih : IsFiniteLength R ↥(s.toFun i.castSucc)
cov : JordanHolderLattice.IsMaximal (s.toFun i.castSucc) (s.toFun i.succ) := s.step i
this✝ : IsSimpleModule R (↥(s.toFun i.succ) ⧸ Submodule.comap (s.toFun i.succ).subtype (s.toFun i.castSucc))
this : ↥(Submodule.comap (s.toFun i.succ).subtype (s.toFun i.castSucc)) ≃ₗ[R] ↥(s.toFun i.castSucc)
⊢ IsFiniteLength R ↥(s.toFun i.succ)
|
9accf3c3b4183124
|
Ordinal.opow_add
|
Mathlib/SetTheory/Ordinal/Exponential.lean
|
theorem opow_add (a b c : Ordinal) : a ^ (b + c) = a ^ b * a ^ c
|
case inr.inr.H₂
a b : Ordinal.{u_1}
a0 : a ≠ 0
a1 : 1 < a
c : Ordinal.{u_1}
IH : a ^ (b + c) = a ^ b * a ^ c
⊢ a ^ (b + succ c) = a ^ b * a ^ succ c
|
rw [add_succ, opow_succ, IH, opow_succ, mul_assoc]
|
no goals
|
afa4314c87d949ea
|
MeasureTheory.eLpNorm_mono_nnnorm_ae
|
Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
|
theorem eLpNorm_mono_nnnorm_ae {f : α → F} {g : α → G} (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ ‖g x‖₊) :
eLpNorm f p μ ≤ eLpNorm g p μ
|
α : Type u_1
F : Type u_4
G : Type u_5
m0 : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
⊢ (if p = 0 then 0 else if p = ⊤ then eLpNormEssSup f μ else eLpNorm' f p.toReal μ) ≤
if p = 0 then 0 else if p = ⊤ then eLpNormEssSup g μ else eLpNorm' g p.toReal μ
|
split_ifs
|
case pos
α : Type u_1
F : Type u_4
G : Type u_5
m0 : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
h✝ : p = 0
⊢ 0 ≤ 0
case pos
α : Type u_1
F : Type u_4
G : Type u_5
m0 : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
h✝¹ : ¬p = 0
h✝ : p = ⊤
⊢ eLpNormEssSup f μ ≤ eLpNormEssSup g μ
case neg
α : Type u_1
F : Type u_4
G : Type u_5
m0 : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
h✝¹ : ¬p = 0
h✝ : ¬p = ⊤
⊢ eLpNorm' f p.toReal μ ≤ eLpNorm' g p.toReal μ
|
c947aa79422e40ae
|
PowerBasis.equivOfRoot_map
|
Mathlib/RingTheory/PowerBasis.lean
|
theorem equivOfRoot_map (pb : PowerBasis A S) (e : S ≃ₐ[A] S') (h₁ h₂) :
pb.equivOfRoot (pb.map e) h₁ h₂ = e
|
case h
S : Type u_2
inst✝⁴ : Ring S
A : Type u_4
inst✝³ : CommRing A
S' : Type u_7
inst✝² : CommRing S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
h₁ : (aeval pb.gen) (minpoly A (pb.map e).gen) = 0
h₂ : (aeval (pb.map e).gen) (minpoly A pb.gen) = 0
x : S
⊢ (pb.equivOfRoot (pb.map e) h₁ h₂) x = e x
|
obtain ⟨f, rfl⟩ := pb.exists_eq_aeval' x
|
case h.intro
S : Type u_2
inst✝⁴ : Ring S
A : Type u_4
inst✝³ : CommRing A
S' : Type u_7
inst✝² : CommRing S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
h₁ : (aeval pb.gen) (minpoly A (pb.map e).gen) = 0
h₂ : (aeval (pb.map e).gen) (minpoly A pb.gen) = 0
f : A[X]
⊢ (pb.equivOfRoot (pb.map e) h₁ h₂) ((aeval pb.gen) f) = e ((aeval pb.gen) f)
|
4ff31263b0b81a61
|
Polynomial.dickson_one_one_eq_chebyshev_C
|
Mathlib/RingTheory/Polynomial/Dickson.lean
|
theorem dickson_one_one_eq_chebyshev_C : ∀ n, dickson 1 (1 : R) n = Chebyshev.C R n
| 0 => by
simp only [Chebyshev.C_zero, mul_one, one_comp, dickson_zero]
norm_num
| 1 => by
rw [dickson_one, Nat.cast_one, Chebyshev.C_one]
| n + 2 => by
rw [dickson_add_two, C_1, Nat.cast_add, Nat.cast_two, Chebyshev.C_add_two,
dickson_one_one_eq_chebyshev_C (n + 1), dickson_one_one_eq_chebyshev_C n]
push_cast
ring
|
R : Type u_1
inst✝ : CommRing R
⊢ 3 - ↑1 = Chebyshev.C R ↑0
|
norm_num
|
no goals
|
b6460d95bc6e9fea
|
List.Vector.insertIdx_comm
|
Mathlib/Data/Vector/Basic.lean
|
theorem insertIdx_comm (a b : α) (i j : Fin (n + 1)) (h : i ≤ j) :
∀ v : Vector α n,
(v.insertIdx a i).insertIdx b j.succ = (v.insertIdx b j).insertIdx a (Fin.castSucc i)
| ⟨l, hl⟩ => by
refine Subtype.eq ?_
simp only [insertIdx_val, Fin.val_succ, Fin.castSucc, Fin.coe_castAdd]
apply List.insertIdx_comm
· assumption
· rw [hl]
exact Nat.le_of_succ_le_succ j.2
|
α : Type u_1
n : ℕ
a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑(insertIdx b j.succ (insertIdx a i ⟨l, hl⟩)) = ↑(insertIdx a i.castSucc (insertIdx b j ⟨l, hl⟩))
|
simp only [insertIdx_val, Fin.val_succ, Fin.castSucc, Fin.coe_castAdd]
|
α : Type u_1
n : ℕ
a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ List.insertIdx (↑j + 1) b (List.insertIdx (↑i) a l) = List.insertIdx (↑i) a (List.insertIdx (↑j) b l)
|
e169c22cbc8ad2b0
|
AlgebraicGeometry.exists_lift_of_germInjective_aux
|
Mathlib/AlgebraicGeometry/SpreadingOut.lean
|
lemma exists_lift_of_germInjective_aux {U : X.Opens} {x : X} (hxU)
(φ : A ⟶ X.presheaf.stalk x) (φRA : R ⟶ A) (φRX : R ⟶ Γ(X, U))
(hφRA : RingHom.FiniteType φRA.hom)
(e : φRA ≫ φ = φRX ≫ X.presheaf.germ U x hxU) :
∃ (V : X.Opens) (hxV : x ∈ V),
V ≤ U ∧ RingHom.range φ.hom ≤ RingHom.range (X.presheaf.germ V x hxV).hom
|
case mk.intro
X : Scheme
R A : CommRingCat
U : X.Opens
x : ↑↑X.toPresheafedSpace
hxU : x ∈ U
φ : A ⟶ X.presheaf.stalk x
φRA : R ⟶ A
φRX : R ⟶ Γ(X, U)
e : φRA ≫ φ = φRX ≫ X.presheaf.germ U x hxU
this✝² : Algebra ↑R ↑A := (CommRingCat.Hom.hom φRA).toAlgebra
s : Finset ↑A
hs : Algebra.adjoin ↑R ↑s = ⊤
W : ↑A → TopologicalSpace.Opens ↑↑X.toPresheafedSpace
hxW : ∀ (t : ↑A), x ∈ W t
f : (t : ↑A) → ToType (X.presheaf.obj (Opposite.op (W t)))
hf : ∀ (t : ↑A), (ConcreteCategory.hom (X.presheaf.germ (W t) x ⋯)) (f t) = (ConcreteCategory.hom φ) t
H : x ∈ s.inf W ⊓ U
this✝¹ : Algebra ↑R ↑Γ(X, U) := (CommRingCat.Hom.hom φRX).toAlgebra
this✝ : Algebra ↑R ↑(X.presheaf.stalk x) := (CommRingCat.Hom.hom (φRX ≫ X.presheaf.germ U x hxU)).toAlgebra
this : Algebra ↑R ↑(X.presheaf.obj (Opposite.op (s.inf W ⊓ U))) :=
(CommRingCat.Hom.hom (φRX ≫ X.presheaf.map (homOfLE ⋯).op)).toAlgebra
φ' : ↑A →ₐ[↑R] ↑(X.presheaf.stalk x) :=
let __src := CommRingCat.Hom.hom φ;
{ toRingHom := __src, commutes' := ⋯ }
ψ : ↑Γ(X, s.inf W ⊓ U) →ₐ[↑R] ↑(X.presheaf.stalk x) :=
let __src := CommRingCat.Hom.hom (X.presheaf.germ (s.inf W ⊓ U) x H);
{ toRingHom := __src, commutes' := ⋯ }
⊢ ⇑φ' '' ↑s ⊆ ↑ψ.range
|
rintro _ ⟨i, hi, rfl : φ i = _⟩
|
case mk.intro.intro.intro
X : Scheme
R A : CommRingCat
U : X.Opens
x : ↑↑X.toPresheafedSpace
hxU : x ∈ U
φ : A ⟶ X.presheaf.stalk x
φRA : R ⟶ A
φRX : R ⟶ Γ(X, U)
e : φRA ≫ φ = φRX ≫ X.presheaf.germ U x hxU
this✝² : Algebra ↑R ↑A := (CommRingCat.Hom.hom φRA).toAlgebra
s : Finset ↑A
hs : Algebra.adjoin ↑R ↑s = ⊤
W : ↑A → TopologicalSpace.Opens ↑↑X.toPresheafedSpace
hxW : ∀ (t : ↑A), x ∈ W t
f : (t : ↑A) → ToType (X.presheaf.obj (Opposite.op (W t)))
hf : ∀ (t : ↑A), (ConcreteCategory.hom (X.presheaf.germ (W t) x ⋯)) (f t) = (ConcreteCategory.hom φ) t
H : x ∈ s.inf W ⊓ U
this✝¹ : Algebra ↑R ↑Γ(X, U) := (CommRingCat.Hom.hom φRX).toAlgebra
this✝ : Algebra ↑R ↑(X.presheaf.stalk x) := (CommRingCat.Hom.hom (φRX ≫ X.presheaf.germ U x hxU)).toAlgebra
this : Algebra ↑R ↑(X.presheaf.obj (Opposite.op (s.inf W ⊓ U))) :=
(CommRingCat.Hom.hom (φRX ≫ X.presheaf.map (homOfLE ⋯).op)).toAlgebra
φ' : ↑A →ₐ[↑R] ↑(X.presheaf.stalk x) :=
let __src := CommRingCat.Hom.hom φ;
{ toRingHom := __src, commutes' := ⋯ }
ψ : ↑Γ(X, s.inf W ⊓ U) →ₐ[↑R] ↑(X.presheaf.stalk x) :=
let __src := CommRingCat.Hom.hom (X.presheaf.germ (s.inf W ⊓ U) x H);
{ toRingHom := __src, commutes' := ⋯ }
i : ↑A
hi : i ∈ ↑s
⊢ (ConcreteCategory.hom φ) i ∈ ↑ψ.range
|
b042b93e0fb8cec3
|
AlgebraicTopology.DoldKan.N₁Γ₀_hom_app_f_f
|
Mathlib/AlgebraicTopology/DoldKan/GammaCompN.lean
|
theorem N₁Γ₀_hom_app_f_f (K : ChainComplex C ℕ) (n : ℕ) :
(N₁Γ₀.hom.app K).f.f n = (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv.f.f n
|
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
n : ℕ
⊢ (N₁Γ₀.hom.app K).f.f n = (Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv.f.f n
|
rw [N₁Γ₀_hom_app]
|
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
n : ℕ
⊢ ((Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv ≫ (toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).hom).f.f
n =
(Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.inv.f.f n
|
ad3ce58090f74d82
|
PseudoMetricSpace.le_two_mul_dist_ofPreNNDist
|
Mathlib/Topology/Metrizable/Uniformity.lean
|
theorem le_two_mul_dist_ofPreNNDist (d : X → X → ℝ≥0) (dist_self : ∀ x, d x x = 0)
(dist_comm : ∀ x y, d x y = d y x)
(hd : ∀ x₁ x₂ x₃ x₄, d x₁ x₄ ≤ 2 * max (d x₁ x₂) (max (d x₂ x₃) (d x₃ x₄))) (x y : X) :
↑(d x y) ≤ 2 * @dist X
(@PseudoMetricSpace.toDist X (PseudoMetricSpace.ofPreNNDist d dist_self dist_comm)) x y
|
case intro.intro.refine_3.inr
X : Type u_1
d : X → X → ℝ≥0
dist_self : ∀ (x : X), d x x = 0
dist_comm : ∀ (x y : X), d x y = d y x
hd : ∀ (x₁ x₂ x₃ x₄ : X), d x₁ x₄ ≤ 2 * (d x₁ x₂ ⊔ (d x₂ x₃ ⊔ d x₃ x₄))
hd₀_trans : Transitive fun x y => d x y = 0
this : IsTrans X fun x y => d x y = 0
x y : X
l : List X
ihn : ∀ m < l.length, ∀ (x y : X) (l : List X), l.length = m → d x y ≤ 2 * (zipWith d (x :: l) (l ++ [y])).sum
L : List ℝ≥0 := zipWith d (x :: l) (l ++ [y])
hL_len : L.length = l.length + 1
hd₀ : d x y ≠ 0
s : Set ℕ := {m | 2 * (take m L).sum ≤ L.sum}
hs₀ : 0 ∈ s
hsne : s.Nonempty
M : ℕ
hMl✝ : M ≤ l.length
hMs : IsGreatest s M
hM_lt : M < L.length
hM_ltx : M < (x :: l).length
hM_lty : M < (l ++ [y]).length
hMl : M < l.length
hlen : (drop (M + 1) l).length = l.length - (M + 1)
hlen_lt : l.length - (M + 1) < l.length
⊢ d l[M] y ≤ L.sum
|
refine (ihn _ hlen_lt _ y _ hlen).trans ?_
|
case intro.intro.refine_3.inr
X : Type u_1
d : X → X → ℝ≥0
dist_self : ∀ (x : X), d x x = 0
dist_comm : ∀ (x y : X), d x y = d y x
hd : ∀ (x₁ x₂ x₃ x₄ : X), d x₁ x₄ ≤ 2 * (d x₁ x₂ ⊔ (d x₂ x₃ ⊔ d x₃ x₄))
hd₀_trans : Transitive fun x y => d x y = 0
this : IsTrans X fun x y => d x y = 0
x y : X
l : List X
ihn : ∀ m < l.length, ∀ (x y : X) (l : List X), l.length = m → d x y ≤ 2 * (zipWith d (x :: l) (l ++ [y])).sum
L : List ℝ≥0 := zipWith d (x :: l) (l ++ [y])
hL_len : L.length = l.length + 1
hd₀ : d x y ≠ 0
s : Set ℕ := {m | 2 * (take m L).sum ≤ L.sum}
hs₀ : 0 ∈ s
hsne : s.Nonempty
M : ℕ
hMl✝ : M ≤ l.length
hMs : IsGreatest s M
hM_lt : M < L.length
hM_ltx : M < (x :: l).length
hM_lty : M < (l ++ [y]).length
hMl : M < l.length
hlen : (drop (M + 1) l).length = l.length - (M + 1)
hlen_lt : l.length - (M + 1) < l.length
⊢ 2 * (zipWith d (l[M] :: drop (M + 1) l) (drop (M + 1) l ++ [y])).sum ≤ L.sum
|
a217eb6776c388b0
|
Real.tendsto_sum_range_one_div_nat_succ_atTop
|
Mathlib/Analysis/PSeries.lean
|
theorem tendsto_sum_range_one_div_nat_succ_atTop :
Tendsto (fun n => ∑ i ∈ Finset.range n, (1 / (i + 1) : ℝ)) atTop atTop
|
i : ℕ
⊢ 0 ≤ 1 / (↑i + 1)
|
positivity
|
no goals
|
f6048eb1630d795c
|
RingHom.OfLocalizationSpanTarget.ofLocalizationSpan
|
Mathlib/RingTheory/LocalProperties/Basic.lean
|
theorem RingHom.OfLocalizationSpanTarget.ofLocalizationSpan
(hP : RingHom.OfLocalizationSpanTarget @P)
(hP' : RingHom.StableUnderCompositionWithLocalizationAwaySource @P) :
RingHom.OfLocalizationSpan @P
|
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : OfLocalizationSpanTarget P
hP' : StableUnderCompositionWithLocalizationAwaySource P
R S : Type u
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
s : Set R
hs : Ideal.span s = ⊤
hs' : ∀ (r : ↑s), P (Localization.awayMap f ↑r)
⊢ P f
|
apply_fun Ideal.map f at hs
|
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : OfLocalizationSpanTarget P
hP' : StableUnderCompositionWithLocalizationAwaySource P
R S : Type u
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
s : Set R
hs' : ∀ (r : ↑s), P (Localization.awayMap f ↑r)
hs : Ideal.map f (Ideal.span s) = Ideal.map f ⊤
⊢ P f
|
4181d293dd91340a
|
ThreeGPFree.eq_right
|
Mathlib/Combinatorics/Additive/AP/Three/Defs.lean
|
@[to_additive] lemma ThreeGPFree.eq_right (hs : ThreeGPFree s) :
∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → ∀ ⦃c⦄, c ∈ s → a * c = b * b → b = c
|
α : Type u_2
inst✝ : CancelCommMonoid α
s : Set α
hs : ThreeGPFree s
⊢ ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → b = c
|
rintro a ha b hb c hc habc
|
α : Type u_2
inst✝ : CancelCommMonoid α
s : Set α
hs : ThreeGPFree s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
habc : a * c = b * b
⊢ b = c
|
4028df386179b41e
|
weightedVSub_mem_vectorSpan_pair
|
Mathlib/LinearAlgebra/AffineSpace/Independent.lean
|
theorem weightedVSub_mem_vectorSpan_pair {p : ι → P} (h : AffineIndependent k p) {w w₁ w₂ : ι → k}
{s : Finset ι} (hw : ∑ i ∈ s, w i = 0) (hw₁ : ∑ i ∈ s, w₁ i = 1)
(hw₂ : ∑ i ∈ s, w₂ i = 1) :
s.weightedVSub p w ∈
vectorSpan k ({s.affineCombination k p w₁, s.affineCombination k p w₂} : Set P) ↔
∃ r : k, ∀ i ∈ s, w i = r * (w₁ i - w₂ i)
|
case refine_1.intro
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
ι : Type u_4
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 0
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
r : k
hr : (s.weightedVSub p) (r • (w₁ - w₂) - w) = 0
i : ι
hi : i ∈ s
hw' : ∑ j ∈ s, (r • (w₁ - w₂) - w) j = 0
⊢ w i = r * (w₁ i - w₂ i)
|
have hr' := h s _ hw' hr i hi
|
case refine_1.intro
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
ι : Type u_4
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 0
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
r : k
hr : (s.weightedVSub p) (r • (w₁ - w₂) - w) = 0
i : ι
hi : i ∈ s
hw' : ∑ j ∈ s, (r • (w₁ - w₂) - w) j = 0
hr' : (r • (w₁ - w₂) - w) i = 0
⊢ w i = r * (w₁ i - w₂ i)
|
6e1484c0d97194ef
|
Orientation.oangle_add
|
Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
|
theorem oangle_add {x y z : V} (hx : x ≠ 0) (hy : y ≠ 0) (hz : z ≠ 0) :
o.oangle x y + o.oangle y z = o.oangle x z
|
V : Type u_1
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y z : V
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ 0 < ‖y‖ ^ 2
|
positivity
|
no goals
|
9ab057dbb8d9890d
|
Polynomial.roots_expand_pow
|
Mathlib/FieldTheory/Perfect.lean
|
theorem roots_expand_pow :
(expand R (p ^ n) f).roots = p ^ n • f.roots.map (iterateFrobeniusEquiv R p n).symm
|
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsDomain R
p n : ℕ
inst✝¹ : ExpChar R p
f : R[X]
inst✝ : PerfectRing R p
r : R
⊢ p ^ n * (filter (fun x => r ^ p ^ n = x) f.roots).card =
p ^ n * (filter (fun a => r = (iterateFrobeniusEquiv R p n).symm a) f.roots).card
|
congr
|
case e_a.e_a.e_p
R : Type u_1
inst✝³ : CommRing R
inst✝² : IsDomain R
p n : ℕ
inst✝¹ : ExpChar R p
f : R[X]
inst✝ : PerfectRing R p
r : R
⊢ (fun x => r ^ p ^ n = x) = fun a => r = (iterateFrobeniusEquiv R p n).symm a
|
a4f5e4fcb5483444
|
FractionalIdeal.div_spanSingleton
|
Mathlib/RingTheory/FractionalIdeal/Operations.lean
|
theorem div_spanSingleton (J : FractionalIdeal R₁⁰ K) (d : K) :
J / spanSingleton R₁⁰ d = spanSingleton R₁⁰ d⁻¹ * J
|
case neg.a
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
J : FractionalIdeal R₁⁰ K
d : K
hd : ¬d = 0
h_spand : spanSingleton R₁⁰ d ≠ 0
x : K
hx : ∀ y ∈ ↑(spanSingleton R₁⁰ d), x * y ∈ ↑J
⊢ x ∈ ↑(1 / spanSingleton R₁⁰ d * J)
|
specialize hx d (mem_spanSingleton_self R₁⁰ d)
|
case neg.a
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
J : FractionalIdeal R₁⁰ K
d : K
hd : ¬d = 0
h_spand : spanSingleton R₁⁰ d ≠ 0
x : K
hx : x * d ∈ ↑J
⊢ x ∈ ↑(1 / spanSingleton R₁⁰ d * J)
|
3a4f3cf63940a3cf
|
AlgebraicGeometry.spread_out_unique_of_isGermInjective'
|
Mathlib/AlgebraicGeometry/SpreadingOut.lean
|
/--
A variant of `spread_out_unique_of_isGermInjective`
whose condition is an equality of scheme morphisms instead of ring homomorphisms.
-/
lemma spread_out_unique_of_isGermInjective' {x : X} [X.IsGermInjectiveAt x]
(f g : X ⟶ Y)
(e : X.fromSpecStalk x ≫ f = X.fromSpecStalk x ≫ g) :
∃ (U : X.Opens), x ∈ U ∧ U.ι ≫ f = U.ι ≫ g
|
case H.a
X Y : Scheme
x : ↑↑X.toPresheafedSpace
inst✝ : X.IsGermInjectiveAt x
f g : X ⟶ Y
e : X.fromSpecStalk x ≫ f = X.fromSpecStalk x ≫ g
⊢ Spec.map (Scheme.Hom.stalkMap f x) = Spec.map (Y.presheaf.stalkSpecializes ⋯ ≫ Scheme.Hom.stalkMap g x)
|
rw [← cancel_mono (Y.fromSpecStalk _)]
|
case H.a
X Y : Scheme
x : ↑↑X.toPresheafedSpace
inst✝ : X.IsGermInjectiveAt x
f g : X ⟶ Y
e : X.fromSpecStalk x ≫ f = X.fromSpecStalk x ≫ g
⊢ Spec.map (Scheme.Hom.stalkMap f x) ≫ Y.fromSpecStalk ((ConcreteCategory.hom f.base) x) =
Spec.map (Y.presheaf.stalkSpecializes ⋯ ≫ Scheme.Hom.stalkMap g x) ≫
Y.fromSpecStalk ((ConcreteCategory.hom f.base) x)
|
d4de83ebc27f644e
|
Real.deriv_binEntropy
|
Mathlib/Analysis/SpecialFunctions/BinaryEntropy.lean
|
/-- Binary entropy has derivative `log (1 - p) - log p`.
It's not differentiable at `0` or `1` but the junk values of `deriv` and `log` coincide there. -/
lemma deriv_binEntropy (p : ℝ) : deriv binEntropy p = log (1 - p) - log p
|
case pos.intro
p : ℝ
hp₀ : p ≠ 0
hp₁ : 1 - p ≠ 0
⊢ deriv binEntropy p = log (1 - p) - log p
|
rw [binEntropy_eq_negMulLog_add_negMulLog_one_sub', deriv_add, deriv_comp_const_sub,
deriv_negMulLog hp₀, deriv_negMulLog hp₁]
|
case pos.intro
p : ℝ
hp₀ : p ≠ 0
hp₁ : 1 - p ≠ 0
⊢ -log p - 1 + -(-log (1 - p) - 1) = log (1 - p) - log p
case pos.intro.hf
p : ℝ
hp₀ : p ≠ 0
hp₁ : 1 - p ≠ 0
⊢ DifferentiableAt ℝ negMulLog p
case pos.intro.hg
p : ℝ
hp₀ : p ≠ 0
hp₁ : 1 - p ≠ 0
⊢ DifferentiableAt ℝ (fun p => (1 - p).negMulLog) p
|
0fb63a8146fa8624
|
Polynomial.card_roots_le_derivative
|
Mathlib/Analysis/Calculus/LocalExtr/Polynomial.lean
|
theorem card_roots_le_derivative (p : ℝ[X]) :
Multiset.card p.roots ≤ Multiset.card (derivative p).roots + 1 :=
calc
Multiset.card p.roots = ∑ x ∈ p.roots.toFinset, p.roots.count x :=
(Multiset.toFinset_sum_count_eq _).symm
_ = ∑ x ∈ p.roots.toFinset, (p.roots.count x - 1 + 1) :=
(Eq.symm <| Finset.sum_congr rfl fun _ hx => tsub_add_cancel_of_le <|
Nat.succ_le_iff.2 <| Multiset.count_pos.2 <| Multiset.mem_toFinset.1 hx)
_ = (∑ x ∈ p.roots.toFinset, (p.rootMultiplicity x - 1)) + p.roots.toFinset.card
|
p : ℝ[X]
x : ℝ
hx : x ∈ (derivative p).roots.toFinset \ p.roots.toFinset
⊢ 0 < Multiset.count x (derivative p).roots
|
rw [Multiset.count_pos, ← Multiset.mem_toFinset]
|
p : ℝ[X]
x : ℝ
hx : x ∈ (derivative p).roots.toFinset \ p.roots.toFinset
⊢ x ∈ (derivative p).roots.toFinset
|
08e969b6e08acf5a
|
MeasureTheory.FiniteMeasure.limsup_measure_closed_le_of_tendsto
|
Mathlib/MeasureTheory/Measure/Portmanteau.lean
|
theorem FiniteMeasure.limsup_measure_closed_le_of_tendsto {Ω ι : Type*} {L : Filter ι}
[MeasurableSpace Ω] [TopologicalSpace Ω] [HasOuterApproxClosed Ω]
[OpensMeasurableSpace Ω] {μ : FiniteMeasure Ω}
{μs : ι → FiniteMeasure Ω} (μs_lim : Tendsto μs L (𝓝 μ)) {F : Set Ω} (F_closed : IsClosed F) :
(L.limsup fun i ↦ (μs i : Measure Ω) F) ≤ (μ : Measure Ω) F
|
case inr.h.intro
Ω : Type u_1
ι : Type u_2
L : Filter ι
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : HasOuterApproxClosed Ω
inst✝ : OpensMeasurableSpace Ω
μ : FiniteMeasure Ω
μs : ι → FiniteMeasure Ω
μs_lim : Tendsto μs L (𝓝 μ)
F : Set Ω
F_closed : IsClosed F
hne : L.NeBot
ε : ℝ≥0
ε_pos : 0 < ε
a✝ : ↑μ F < ⊤
ε_pos' : ↑ε / 2 ≠ 0
fs : ℕ → Ω →ᵇ ℝ≥0 := F_closed.apprSeq
key₁ : Tendsto (fun n => ∫⁻ (ω : Ω), ↑((fs n) ω) ∂↑μ) atTop (𝓝 (↑μ F))
room₁ : ↑μ F < ↑μ F + ↑ε / 2
M : ℕ
hM : ∀ b ≥ M, ∫⁻ (ω : Ω), ↑((fs b) ω) ∂↑μ < ↑μ F + ↑ε / 2
key₂ : Tendsto (fun i => ∫⁻ (x : Ω), ↑((fs M) x) ∂↑(μs i)) L (𝓝 (∫⁻ (x : Ω), ↑((fs M) x) ∂↑μ))
room₂ : ∫⁻ (a : Ω), ↑((fs M) a) ∂↑μ < ∫⁻ (a : Ω), ↑((fs M) a) ∂↑μ + ↑ε / 2
⊢ limsup (fun i => ↑(μs i) F) L ≤ ↑μ F + ↑ε
|
have ev_near := key₂.eventually_le_const room₂
|
case inr.h.intro
Ω : Type u_1
ι : Type u_2
L : Filter ι
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : HasOuterApproxClosed Ω
inst✝ : OpensMeasurableSpace Ω
μ : FiniteMeasure Ω
μs : ι → FiniteMeasure Ω
μs_lim : Tendsto μs L (𝓝 μ)
F : Set Ω
F_closed : IsClosed F
hne : L.NeBot
ε : ℝ≥0
ε_pos : 0 < ε
a✝ : ↑μ F < ⊤
ε_pos' : ↑ε / 2 ≠ 0
fs : ℕ → Ω →ᵇ ℝ≥0 := F_closed.apprSeq
key₁ : Tendsto (fun n => ∫⁻ (ω : Ω), ↑((fs n) ω) ∂↑μ) atTop (𝓝 (↑μ F))
room₁ : ↑μ F < ↑μ F + ↑ε / 2
M : ℕ
hM : ∀ b ≥ M, ∫⁻ (ω : Ω), ↑((fs b) ω) ∂↑μ < ↑μ F + ↑ε / 2
key₂ : Tendsto (fun i => ∫⁻ (x : Ω), ↑((fs M) x) ∂↑(μs i)) L (𝓝 (∫⁻ (x : Ω), ↑((fs M) x) ∂↑μ))
room₂ : ∫⁻ (a : Ω), ↑((fs M) a) ∂↑μ < ∫⁻ (a : Ω), ↑((fs M) a) ∂↑μ + ↑ε / 2
ev_near : ∀ᶠ (a : ι) in L, ∫⁻ (x : Ω), ↑((fs M) x) ∂↑(μs a) ≤ ∫⁻ (a : Ω), ↑((fs M) a) ∂↑μ + ↑ε / 2
⊢ limsup (fun i => ↑(μs i) F) L ≤ ↑μ F + ↑ε
|
ffd329bb427f57b4
|
generator_maximal_submoduleImage_dvd
|
Mathlib/LinearAlgebra/FreeModule/PID.lean
|
theorem generator_maximal_submoduleImage_dvd {N O : Submodule R M} (hNO : N ≤ O) {ϕ : O →ₗ[R] R}
(hϕ : ∀ ψ : O →ₗ[R] R, ¬ϕ.submoduleImage N < ψ.submoduleImage N)
[(ϕ.submoduleImage N).IsPrincipal] (y : M) (yN : y ∈ N)
(ϕy_eq : ϕ ⟨y, hNO yN⟩ = generator (ϕ.submoduleImage N)) (ψ : O →ₗ[R] R) :
generator (ϕ.submoduleImage N) ∣ ψ ⟨y, hNO yN⟩
|
case intro.intro
R : Type u_2
inst✝⁵ : CommRing R
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
N O : Submodule R M
hNO : N ≤ O
ϕ : ↥O →ₗ[R] R
hϕ : ∀ (ψ : ↥O →ₗ[R] R), ¬ϕ.submoduleImage N < ψ.submoduleImage N
inst✝ : (ϕ.submoduleImage N).IsPrincipal
y : M
yN : y ∈ N
ϕy_eq : ϕ ⟨y, ⋯⟩ = generator (ϕ.submoduleImage N)
ψ : ↥O →ₗ[R] R
a : R := generator (ϕ.submoduleImage N)
d : R := generator (span R {a, ψ ⟨y, ⋯⟩})
d_dvd_left : d ∣ a
d_dvd_right : d ∣ ψ ⟨y, ⋯⟩
r₁ r₂ : R
d_eq : d = r₁ * a + r₂ * ψ ⟨y, ⋯⟩
ψ' : ↥O →ₗ[R] R := r₁ • ϕ + r₂ • ψ
this : span R {d} ≤ ψ'.submoduleImage N
⊢ ψ'.submoduleImage N = span R {generator (ϕ.submoduleImage N)}
|
rw [span_singleton_generator]
|
case intro.intro
R : Type u_2
inst✝⁵ : CommRing R
M : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
N O : Submodule R M
hNO : N ≤ O
ϕ : ↥O →ₗ[R] R
hϕ : ∀ (ψ : ↥O →ₗ[R] R), ¬ϕ.submoduleImage N < ψ.submoduleImage N
inst✝ : (ϕ.submoduleImage N).IsPrincipal
y : M
yN : y ∈ N
ϕy_eq : ϕ ⟨y, ⋯⟩ = generator (ϕ.submoduleImage N)
ψ : ↥O →ₗ[R] R
a : R := generator (ϕ.submoduleImage N)
d : R := generator (span R {a, ψ ⟨y, ⋯⟩})
d_dvd_left : d ∣ a
d_dvd_right : d ∣ ψ ⟨y, ⋯⟩
r₁ r₂ : R
d_eq : d = r₁ * a + r₂ * ψ ⟨y, ⋯⟩
ψ' : ↥O →ₗ[R] R := r₁ • ϕ + r₂ • ψ
this : span R {d} ≤ ψ'.submoduleImage N
⊢ ψ'.submoduleImage N = ϕ.submoduleImage N
|
4b17bcc7455f624f
|
Real.quadratic_root_cos_pi_div_five
|
Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
|
theorem quadratic_root_cos_pi_div_five :
letI c := cos (π / 5)
4 * c ^ 2 - 2 * c - 1 = 0
|
θ : ℝ := π / 5
hθ : θ = π / 5
c : ℝ := cos θ
⊢ 4 * c ^ 2 - 2 * c - 1 = 0
|
set s := sin θ
|
θ : ℝ := π / 5
hθ : θ = π / 5
c : ℝ := cos θ
s : ℝ := sin θ
⊢ 4 * c ^ 2 - 2 * c - 1 = 0
|
9a015197b0eb09bb
|
QPF.liftp_iff'
|
Mathlib/Data/QPF/Univariate/Basic.lean
|
theorem liftp_iff' {α : Type u} (p : α → Prop) (x : F α) :
Liftp p x ↔ ∃ u : q.P α, abs u = x ∧ ∀ i, p (u.snd i)
|
case mpr
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ (∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)) → Liftp p x
|
rintro ⟨⟨a, f⟩, h₀, h₁⟩
|
case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B ⟨a, f⟩.fst), p (⟨a, f⟩.snd i)
⊢ Liftp p x
|
c3df4c9273e86559
|
Finset.prod_multiset_count_of_subset
|
Mathlib/Algebra/BigOperators/Group/Finset/Basic.lean
|
theorem prod_multiset_count_of_subset [DecidableEq α] [CommMonoid α] (m : Multiset α) (s : Finset α)
(hs : m.toFinset ⊆ s) : m.prod = ∏ i ∈ s, i ^ m.count i
|
α : Type u_3
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
⊢ m.toFinset ⊆ s → m.prod = ∏ i ∈ s, i ^ Multiset.count i m
|
refine Quot.induction_on m fun l => ?_
|
α : Type u_3
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
l : List α
⊢ Multiset.toFinset (Quot.mk (⇑(isSetoid α)) l) ⊆ s →
Multiset.prod (Quot.mk (⇑(isSetoid α)) l) = ∏ i ∈ s, i ^ Multiset.count i (Quot.mk (⇑(isSetoid α)) l)
|
e4be7971d594c2a8
|
MeasureTheory.addHaar_image_le_mul_of_det_lt
|
Mathlib/MeasureTheory/Function/Jacobian.lean
|
theorem addHaar_image_le_mul_of_det_lt (A : E →L[ℝ] E) {m : ℝ≥0}
(hm : ENNReal.ofReal |A.det| < m) :
∀ᶠ δ in 𝓝[>] (0 : ℝ≥0),
∀ (s : Set E) (f : E → E), ApproximatesLinearOn f A s δ → μ (f '' s) ≤ m * μ s
|
case h
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
A : E →L[ℝ] E
m : ℝ≥0
hm : ENNReal.ofReal |A.det| < ↑m
d : ℝ≥0∞ := ENNReal.ofReal |A.det|
ε : ℝ
hε : μ (closedBall 0 ε + ⇑A '' closedBall 0 1) < ↑m * μ (closedBall 0 1)
εpos : 0 < ε
this : Iio ⟨ε, ⋯⟩ ∈ 𝓝 0
δ : ℝ≥0
s : Set E
f : E → E
hf : ApproximatesLinearOn f A s δ
hδ : ↑δ < ε
I : ∀ (x : E) (r : ℝ), x ∈ s → 0 ≤ r → μ (f '' (s ∩ closedBall x r)) ≤ ↑m * μ (closedBall x r)
a : ℝ≥0∞
ha : 0 < a
⊢ μ (f '' s) ≤ ↑m * (μ s + a)
|
obtain ⟨t, r, t_count, ts, rpos, st, μt⟩ :
∃ (t : Set E) (r : E → ℝ),
t.Countable ∧
t ⊆ s ∧
(∀ x : E, x ∈ t → 0 < r x) ∧
(s ⊆ ⋃ x ∈ t, closedBall x (r x)) ∧
(∑' x : ↥t, μ (closedBall (↑x) (r ↑x))) ≤ μ s + a :=
Besicovitch.exists_closedBall_covering_tsum_measure_le μ ha.ne' (fun _ => Ioi 0) s
fun x _ δ δpos => ⟨δ / 2, by simp [half_pos δpos, δpos]⟩
|
case h.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
A : E →L[ℝ] E
m : ℝ≥0
hm : ENNReal.ofReal |A.det| < ↑m
d : ℝ≥0∞ := ENNReal.ofReal |A.det|
ε : ℝ
hε : μ (closedBall 0 ε + ⇑A '' closedBall 0 1) < ↑m * μ (closedBall 0 1)
εpos : 0 < ε
this : Iio ⟨ε, ⋯⟩ ∈ 𝓝 0
δ : ℝ≥0
s : Set E
f : E → E
hf : ApproximatesLinearOn f A s δ
hδ : ↑δ < ε
I : ∀ (x : E) (r : ℝ), x ∈ s → 0 ≤ r → μ (f '' (s ∩ closedBall x r)) ≤ ↑m * μ (closedBall x r)
a : ℝ≥0∞
ha : 0 < a
t : Set E
r : E → ℝ
t_count : t.Countable
ts : t ⊆ s
rpos : ∀ x ∈ t, 0 < r x
st : s ⊆ ⋃ x ∈ t, closedBall x (r x)
μt : ∑' (x : ↑t), μ (closedBall (↑x) (r ↑x)) ≤ μ s + a
⊢ μ (f '' s) ≤ ↑m * (μ s + a)
|
35c8118ffea35652
|
Array.flatten_eq_push_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem flatten_eq_push_iff {xs : Array (Array α)} {ys : Array α} {y : α} :
xs.flatten = ys.push y ↔
∃ (as : Array (Array α)) (bs : Array α) (cs : Array (Array α)),
xs = as.push (bs.push y) ++ cs ∧ (∀ l, l ∈ cs → l = #[]) ∧ ys = as.flatten ++ bs
|
case of.mk
α : Type u_1
y : α
xs : List (List α)
ys : List α
⊢ ((∃ as bs, xs = as ++ bs ∧ ys = as.flatten ∧ [y] = bs.flatten) ∨
∃ as bs c cs ds, xs = as ++ (bs ++ c :: cs) :: ds ∧ ys = as.flatten ++ bs ∧ [y] = c :: cs ++ ds.flatten) ↔
∃ as bs cs,
(List.map List.toArray xs).toArray = as.push (bs.push y) ++ cs ∧
(∀ (l : Array α), l ∈ cs → l = #[]) ∧ { toList := ys } = as.flatten ++ bs
|
constructor
|
case of.mk.mp
α : Type u_1
y : α
xs : List (List α)
ys : List α
⊢ ((∃ as bs, xs = as ++ bs ∧ ys = as.flatten ∧ [y] = bs.flatten) ∨
∃ as bs c cs ds, xs = as ++ (bs ++ c :: cs) :: ds ∧ ys = as.flatten ++ bs ∧ [y] = c :: cs ++ ds.flatten) →
∃ as bs cs,
(List.map List.toArray xs).toArray = as.push (bs.push y) ++ cs ∧
(∀ (l : Array α), l ∈ cs → l = #[]) ∧ { toList := ys } = as.flatten ++ bs
case of.mk.mpr
α : Type u_1
y : α
xs : List (List α)
ys : List α
⊢ (∃ as bs cs,
(List.map List.toArray xs).toArray = as.push (bs.push y) ++ cs ∧
(∀ (l : Array α), l ∈ cs → l = #[]) ∧ { toList := ys } = as.flatten ++ bs) →
(∃ as bs, xs = as ++ bs ∧ ys = as.flatten ∧ [y] = bs.flatten) ∨
∃ as bs c cs ds, xs = as ++ (bs ++ c :: cs) :: ds ∧ ys = as.flatten ++ bs ∧ [y] = c :: cs ++ ds.flatten
|
dbe592481896286a
|
EReal.sign_mul_inv_abs
|
Mathlib/Data/Real/EReal.lean
|
lemma sign_mul_inv_abs (a : EReal) : (sign a) * (a.abs : EReal)⁻¹ = a⁻¹
|
case h_real.inr.inr
a : ℝ
a_pos : 0 < a
⊢ (↑(↑a).abs)⁻¹ = (↑a)⁻¹
|
simp only [abs_def a, coe_ennreal_ofReal, abs_nonneg, max_eq_left]
|
case h_real.inr.inr
a : ℝ
a_pos : 0 < a
⊢ (↑|a|)⁻¹ = (↑a)⁻¹
|
ac24005922bb1b5a
|
FreeGroup.Red.cons_nil_iff_singleton
|
Mathlib/GroupTheory/FreeGroup/Basic.lean
|
theorem cons_nil_iff_singleton {x b} : Red ((x, b) :: L) [] ↔ Red L [(x, not b)] :=
Iff.intro
(fun h => by
have h₁ : Red ((x, not b) :: (x, b) :: L) [(x, not b)] := cons_cons h
have h₂ : Red ((x, not b) :: (x, b) :: L) L := ReflTransGen.single Step.cons_not_rev
let ⟨L', h₁, h₂⟩ := church_rosser h₁ h₂
rw [singleton_iff] at h₁
subst L'
assumption)
fun h => (cons_cons h).tail Step.cons_not
|
α : Type u
L : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁✝ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
L' : List (α × Bool)
h₁ : L' = [(x, !b)]
h₂ : Red L L'
⊢ Red L [(x, !b)]
|
subst L'
|
α : Type u
L : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
h₂ : Red L [(x, !b)]
⊢ Red L [(x, !b)]
|
76d3bdec0b2e0f0e
|
ModularCyclotomicCharacter.id
|
Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean
|
lemma id : χ₀ n (RingEquiv.refl L) = 1
|
case inr
L : Type u
inst✝² : CommRing L
inst✝¹ : IsDomain L
n : ℕ
inst✝ : NeZero n
t : ↥(rootsOfUnity n L)
this✝ : 1 ≤ Fintype.card ↥(rootsOfUnity n L)
h : 1 = Fintype.card ↥(rootsOfUnity n L)
this : Subsingleton ↥(rootsOfUnity n L)
⊢ (RingEquiv.refl L) ↑↑t = ↑(↑t ^ ZMod.val 1)
|
obtain rfl : t = 1 := Subsingleton.elim t 1
|
case inr
L : Type u
inst✝² : CommRing L
inst✝¹ : IsDomain L
n : ℕ
inst✝ : NeZero n
this✝ : 1 ≤ Fintype.card ↥(rootsOfUnity n L)
h : 1 = Fintype.card ↥(rootsOfUnity n L)
this : Subsingleton ↥(rootsOfUnity n L)
⊢ (RingEquiv.refl L) ↑↑1 = ↑(↑1 ^ ZMod.val 1)
|
e6a95e075637730f
|
MeasureTheory.IsFundamentalDomain.essSup_measure_restrict
|
Mathlib/MeasureTheory/Group/FundamentalDomain.lean
|
theorem essSup_measure_restrict (hs : IsFundamentalDomain G s μ) {f : α → ℝ≥0∞}
(hf : ∀ γ : G, ∀ x : α, f (γ • x) = f x) : essSup f (μ.restrict s) = essSup f μ
|
case h
G : Type u_1
α : Type u_3
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace α
s : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
hs : IsFundamentalDomain G s μ
f : α → ℝ≥0∞
hf : ∀ (γ : G) (x : α), f (γ • x) = f x
a : ℝ≥0∞
ha : μ ({x | a < f x} ∩ s) = 0
γ : G
x : α
⊢ γ⁻¹ • x ∈ {x | a < f x} ↔ x ∈ {x | a < f x}
|
simp only [mem_setOf_eq, hf γ⁻¹ x]
|
no goals
|
a614a13e054bad33
|
Matrix.trace_one
|
Mathlib/LinearAlgebra/Matrix/Trace.lean
|
theorem trace_one : trace (1 : Matrix n n R) = Fintype.card n
|
n : Type u_3
R : Type u_6
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : AddCommMonoidWithOne R
⊢ trace 1 = ↑(Fintype.card n)
|
simp_rw [trace, diag_one, Pi.one_def, Finset.sum_const, nsmul_one, Finset.card_univ]
|
no goals
|
435b81581bcb1989
|
ProbabilityTheory.setLIntegral_stieltjesOfMeasurableRat
|
Mathlib/Probability/Kernel/Disintegration/CDFToKernel.lean
|
lemma setLIntegral_stieltjesOfMeasurableRat [IsFiniteKernel κ] (hf : IsRatCondKernelCDF f κ ν)
(a : α) (x : ℝ) {s : Set β} (hs : MeasurableSet s) :
∫⁻ b in s, ENNReal.ofReal (stieltjesOfMeasurableRat f hf.measurable (a, b) x) ∂(ν a)
= κ a (s ×ˢ Iic x)
|
case neg.h.e_6.h.e_a.h
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
inst✝ : IsFiniteKernel κ
hf : IsRatCondKernelCDF f κ ν
a : α
x : ℝ
s : Set β
hs : MeasurableSet s
hρ_zero : ¬(ν a).restrict s = 0
h :
∫⁻ (b : β) in s, ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) x) ∂ν a =
∫⁻ (b : β) in s, ⨅ r, ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) ↑↑r) ∂ν a
h_nonempty : Nonempty { r' // x < ↑r' }
y : ℝ
⊢ (∀ (a : ℚ), x < ↑a → y ≤ ↑a) ↔ y ≤ x
|
exact ⟨le_of_forall_lt_rat_imp_le, fun hyx q hq ↦ hyx.trans hq.le⟩
|
no goals
|
2b5f63b20150553c
|
List.exists_pw_disjoint_with_card
|
Mathlib/GroupTheory/Perm/Cycle/PossibleTypes.lean
|
theorem List.exists_pw_disjoint_with_card {α : Type*} [Fintype α]
{c : List ℕ} (hc : c.sum ≤ Fintype.card α) :
∃ o : List (List α),
o.map length = c ∧ (∀ s ∈ o, s.Nodup) ∧ Pairwise List.Disjoint o
|
case h.left
α : Type u_2
inst✝ : Fintype α
c : List ℕ
hc : c.sum ≤ Fintype.card α
klift : (n : ℕ) → n < Fintype.card α → Fin (Fintype.card α) := fun n hn => ⟨n, hn⟩
klift' : (l : List ℕ) → (∀ a ∈ l, a < Fintype.card α) → List (Fin (Fintype.card α)) := fun l hl => pmap klift l hl
hc'_lt : ∀ l ∈ c.ranges, ∀ n ∈ l, n < Fintype.card α
l : List (List (Fin (Fintype.card α))) := pmap klift' c.ranges hc'_lt
hl : ∀ (a : List ℕ) (ha : a ∈ c.ranges), map (⇑Fin.valEmbedding) (klift' a ⋯) = a
⊢ map length (map (map ⇑(Fintype.equivFin α).symm) l) = map length c.ranges
|
simp only [l, klift', map_map, map_pmap, Function.comp_apply, length_map, length_pmap,
pmap_eq_map]
|
no goals
|
463233383e1ded3a
|
Nat.fib_add
|
Mathlib/Data/Nat/Fib/Basic.lean
|
theorem fib_add (m n : ℕ) : fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1)
|
m n : ℕ
⊢ fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1)
|
induction' n with n ih generalizing m
|
case zero
m : ℕ
⊢ fib (m + 0 + 1) = fib m * fib 0 + fib (m + 1) * fib (0 + 1)
case succ
n : ℕ
ih : ∀ (m : ℕ), fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1)
m : ℕ
⊢ fib (m + (n + 1) + 1) = fib m * fib (n + 1) + fib (m + 1) * fib (n + 1 + 1)
|
b5bcd98a5f87fcbc
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.