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
|
|---|---|---|---|---|---|---|
Ordinal.range_omega
|
Mathlib/SetTheory/Cardinal/Aleph.lean
|
theorem range_omega : range omega = {x | ω ≤ x ∧ IsInitial x}
|
case h.mpr
x : Ordinal.{u_1}
⊢ x ∈ {x | ω ≤ x ∧ x.IsInitial} → x ∈ range ⇑ω_
|
rintro ⟨ha', ha⟩
|
case h.mpr.intro
x : Ordinal.{u_1}
ha' : ω ≤ x
ha : x.IsInitial
⊢ x ∈ range ⇑ω_
|
2b8a699686971ec4
|
WeierstrassCurve.Projective.Point.toAffine_add
|
Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
|
lemma toAffine_add {P Q : Fin 3 → F} (hP : W.Nonsingular P) (hQ : W.Nonsingular Q) :
toAffine W (W.add P Q) = toAffine W P + toAffine W Q
|
case neg
F : Type u
inst✝ : Field F
W : Projective F
P Q : Fin 3 → F
hP : W.Nonsingular P
hQ : W.Nonsingular Q
hPz : ¬P z = 0
hQz : ¬Q z = 0
hxy : ¬(P x * Q z = Q x * P z ∧ P y * Q z = W.negY Q * P z)
⊢ toAffine W (W.add P Q) = toAffine W P + toAffine W Q
|
have := toAffine_add_of_Z_ne_zero hP hQ hPz hQz hxy
|
case neg
F : Type u
inst✝ : Field F
W : Projective F
P Q : Fin 3 → F
hP : W.Nonsingular P
hQ : W.Nonsingular Q
hPz : ¬P z = 0
hQz : ¬Q z = 0
hxy : ¬(P x * Q z = Q x * P z ∧ P y * Q z = W.negY Q * P z)
this :
toAffine W
![(Projective.toAffine W).addX (P x / P z) (Q x / Q z)
((Projective.toAffine W).slope (P x / P z) (Q x / Q z) (P y / P z) (Q y / Q z)),
(Projective.toAffine W).addY (P x / P z) (Q x / Q z) (P y / P z)
((Projective.toAffine W).slope (P x / P z) (Q x / Q z) (P y / P z) (Q y / Q z)),
1] =
toAffine W P + toAffine W Q
⊢ toAffine W (W.add P Q) = toAffine W P + toAffine W Q
|
7a72ea913c00d8ec
|
Nat.digits_add
|
Mathlib/Data/Nat/Digits.lean
|
theorem digits_add (b : ℕ) (h : 1 < b) (x y : ℕ) (hxb : x < b) (hxy : x ≠ 0 ∨ y ≠ 0) :
digits b (x + b * y) = x :: digits b y
|
case intro.succ
x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ n✝ + 1 ≠ 0
⊢ (b + 2).digits (x + (b + 2) * (n✝ + 1)) = x :: (b + 2).digits (n✝ + 1)
|
dsimp [digits]
|
case intro.succ
x b : ℕ
h : 1 < b + 2
hxb : x < b + 2
n✝ : ℕ
hxy : x ≠ 0 ∨ n✝ + 1 ≠ 0
⊢ (b + 2).digitsAux ⋯ (x + (b + 2) * (n✝ + 1)) = x :: (b + 2).digitsAux ⋯ (n✝ + 1)
|
5707ca6647bd00ed
|
Polynomial.isLocalHom_expand
|
Mathlib/Algebra/Polynomial/Expand.lean
|
theorem isLocalHom_expand {p : ℕ} (hp : 0 < p) : IsLocalHom (expand R p)
|
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
f : R[X]
hf1 : IsUnit ((expand R p) f)
⊢ IsUnit f
|
have hf2 := eq_C_of_degree_eq_zero (degree_eq_zero_of_isUnit hf1)
|
R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : ℕ
hp : 0 < p
f : R[X]
hf1 : IsUnit ((expand R p) f)
hf2 : (expand R p) f = C (((expand R p) f).coeff 0)
⊢ IsUnit f
|
39ad0872e0293086
|
CompactIccSpace.mk'
|
Mathlib/Topology/Order/Compact.lean
|
lemma CompactIccSpace.mk' [TopologicalSpace α] [Preorder α]
(h : ∀ {a b : α}, a ≤ b → IsCompact (Icc a b)) : CompactIccSpace α where
isCompact_Icc {a b}
|
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
h : ∀ {a b : α}, a ≤ b → IsCompact (Icc a b)
a b : α
hab : ¬a ≤ b
⊢ IsCompact ∅
|
exact isCompact_empty
|
no goals
|
a8529e4e18c5748e
|
Finset.powersetCard_map
|
Mathlib/Data/Finset/Powerset.lean
|
theorem powersetCard_map {β : Type*} (f : α ↪ β) (n : ℕ) (s : Finset α) :
powersetCard n (s.map f) = (powersetCard n s).map (mapEmbedding f).toEmbedding :=
ext fun t => by
simp only [card_map, mem_powersetCard, le_eq_subset, gt_iff_lt, mem_map, mapEmbedding_apply]
constructor
· classical
intro h
have : map f (filter (fun x => (f x ∈ t)) s) = t
|
case mp
α : Type u_1
β : Type u_2
f : α ↪ β
n : ℕ
s : Finset α
t : Finset β
h : t ⊆ map f s ∧ #t = n
this : map f (filter (fun x => f x ∈ t) s) = t
⊢ filter (fun x => f x ∈ t) s ⊆ s ∧ n = n
|
simp
|
no goals
|
dfde83e9b4eb52a7
|
CompHausLike.LocallyConstant.presheaf_ext
|
Mathlib/Condensed/Discrete/LocallyConstant.lean
|
/--
To check equality of two elements of `X(S)`, it suffices to check equality after composing with
each `X(S) → X(Sᵢ)`.
-/
lemma presheaf_ext (X : (CompHausLike.{u} P)ᵒᵖ ⥤ Type max u w)
[PreservesFiniteProducts X] (x y : X.obj ⟨S⟩)
[HasExplicitFiniteCoproducts.{u} P]
(h : ∀ (a : Fiber f), X.map (sigmaIncl f a).op x = X.map (sigmaIncl f a).op y) : x = y
|
case a.a.h
P : TopCat → Prop
inst✝³ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)
S : CompHausLike P
Y : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)
inst✝² : HasProp P PUnit.{u + 1}
f : LocallyConstant (↑S.toTop) (Y.obj (op (of P PUnit.{u + 1})))
X : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)
inst✝¹ : PreservesFiniteProducts X
x y : X.obj (op S)
inst✝ : HasExplicitFiniteCoproducts P
a : Fiber ⇑f
h : X.map (sigmaIncl f a).op x = X.map (sigmaIncl f a).op y
⊢ sigmaComparison X (fun a => ↑(fiber f a).toTop) ((X.mapIso (sigmaIso f).op).hom x) a =
sigmaComparison X (fun a => ↑(fiber f a).toTop) ((X.mapIso (sigmaIso f).op).hom y) a
|
rw [← sigmaComparison_comp_sigmaIso] at h
|
case a.a.h
P : TopCat → Prop
inst✝³ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)
S : CompHausLike P
Y : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)
inst✝² : HasProp P PUnit.{u + 1}
f : LocallyConstant (↑S.toTop) (Y.obj (op (of P PUnit.{u + 1})))
X : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)
inst✝¹ : PreservesFiniteProducts X
x y : X.obj (op S)
inst✝ : HasExplicitFiniteCoproducts P
a : Fiber ⇑f
h :
((X.mapIso (sigmaIso f).op).hom ≫ (sigmaComparison X fun a => ↑(fiber f a).toTop) ≫ fun g => g a) x =
((X.mapIso (sigmaIso f).op).hom ≫ (sigmaComparison X fun a => ↑(fiber f a).toTop) ≫ fun g => g a) y
⊢ sigmaComparison X (fun a => ↑(fiber f a).toTop) ((X.mapIso (sigmaIso f).op).hom x) a =
sigmaComparison X (fun a => ↑(fiber f a).toTop) ((X.mapIso (sigmaIso f).op).hom y) a
|
4aad38c3a12edfe7
|
GaloisConnection.u_eq
|
Mathlib/Order/GaloisConnection/Defs.lean
|
theorem u_eq {z : α} {y : β} : u y = z ↔ ∀ x, x ≤ z ↔ l x ≤ y
|
α : Type u
β : Type v
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
⊢ u y = z ↔ ∀ (x : α), x ≤ z ↔ l x ≤ y
|
constructor
|
case mp
α : Type u
β : Type v
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
⊢ u y = z → ∀ (x : α), x ≤ z ↔ l x ≤ y
case mpr
α : Type u
β : Type v
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
⊢ (∀ (x : α), x ≤ z ↔ l x ≤ y) → u y = z
|
f90e2defec673558
|
aux1
|
Mathlib/Algebra/Jordan/Basic.lean
|
theorem aux1 {a b c : A} :
⁅L a + L b + L c, L (a * a) + L (b * b) + L (c * c) +
2 • L (a * b) + 2 • L (c * a) + 2 • L (b * c)⁆
=
⁅L a, L (a * a)⁆ + ⁅L a, L (b * b)⁆ + ⁅L a, L (c * c)⁆ +
⁅L a, 2 • L (a * b)⁆ + ⁅L a, 2 • L (c * a)⁆ + ⁅L a, 2 • L (b * c)⁆ +
(⁅L b, L (a * a)⁆ + ⁅L b, L (b * b)⁆ + ⁅L b, L (c * c)⁆ +
⁅L b, 2 • L (a * b)⁆ + ⁅L b, 2 • L (c * a)⁆ + ⁅L b, 2 • L (b * c)⁆) +
(⁅L c, L (a * a)⁆ + ⁅L c, L (b * b)⁆ + ⁅L c, L (c * c)⁆ +
⁅L c, 2 • L (a * b)⁆ + ⁅L c, 2 • L (c * a)⁆ + ⁅L c, 2 • L (b * c)⁆)
|
A : Type u_1
inst✝ : NonUnitalNonAssocCommRing A
a b c : A
⊢ ⁅L a + L b + L c, L (a * a) + L (b * b) + L (c * c) + 2 • L (a * b) + 2 • L (c * a) + 2 • L (b * c)⁆ =
⁅L a, L (a * a)⁆ + ⁅L a, L (b * b)⁆ + ⁅L a, L (c * c)⁆ + ⁅L a, 2 • L (a * b)⁆ + ⁅L a, 2 • L (c * a)⁆ +
⁅L a, 2 • L (b * c)⁆ +
(⁅L b, L (a * a)⁆ + ⁅L b, L (b * b)⁆ + ⁅L b, L (c * c)⁆ + ⁅L b, 2 • L (a * b)⁆ + ⁅L b, 2 • L (c * a)⁆ +
⁅L b, 2 • L (b * c)⁆) +
(⁅L c, L (a * a)⁆ + ⁅L c, L (b * b)⁆ + ⁅L c, L (c * c)⁆ + ⁅L c, 2 • L (a * b)⁆ + ⁅L c, 2 • L (c * a)⁆ +
⁅L c, 2 • L (b * c)⁆)
|
rw [add_lie, add_lie]
|
A : Type u_1
inst✝ : NonUnitalNonAssocCommRing A
a b c : A
⊢ ⁅L a, L (a * a) + L (b * b) + L (c * c) + 2 • L (a * b) + 2 • L (c * a) + 2 • L (b * c)⁆ +
⁅L b, L (a * a) + L (b * b) + L (c * c) + 2 • L (a * b) + 2 • L (c * a) + 2 • L (b * c)⁆ +
⁅L c, L (a * a) + L (b * b) + L (c * c) + 2 • L (a * b) + 2 • L (c * a) + 2 • L (b * c)⁆ =
⁅L a, L (a * a)⁆ + ⁅L a, L (b * b)⁆ + ⁅L a, L (c * c)⁆ + ⁅L a, 2 • L (a * b)⁆ + ⁅L a, 2 • L (c * a)⁆ +
⁅L a, 2 • L (b * c)⁆ +
(⁅L b, L (a * a)⁆ + ⁅L b, L (b * b)⁆ + ⁅L b, L (c * c)⁆ + ⁅L b, 2 • L (a * b)⁆ + ⁅L b, 2 • L (c * a)⁆ +
⁅L b, 2 • L (b * c)⁆) +
(⁅L c, L (a * a)⁆ + ⁅L c, L (b * b)⁆ + ⁅L c, L (c * c)⁆ + ⁅L c, 2 • L (a * b)⁆ + ⁅L c, 2 • L (c * a)⁆ +
⁅L c, 2 • L (b * c)⁆)
|
b5c23462450b58db
|
Equiv.Perm.support_subtype_perm
|
Mathlib/GroupTheory/Perm/Support.lean
|
theorem support_subtype_perm [DecidableEq α] {s : Finset α} (f : Perm α) (h) :
(f.subtypePerm h : Perm s).support = ({x | f x ≠ x} : Finset s)
|
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : Perm α
h : ∀ (x : α), x ∈ s ↔ f x ∈ s
⊢ (f.subtypePerm h).support = filter (fun x => f ↑x ≠ ↑x) univ
|
ext
|
case h
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : Perm α
h : ∀ (x : α), x ∈ s ↔ f x ∈ s
a✝ : { x // x ∈ s }
⊢ a✝ ∈ (f.subtypePerm h).support ↔ a✝ ∈ filter (fun x => f ↑x ≠ ↑x) univ
|
ba506bad3e009e97
|
MeasureTheory.measure_isClosed_eq_of_forall_lintegral_eq_of_isFiniteMeasure
|
Mathlib/MeasureTheory/Measure/HasOuterApproxClosed.lean
|
theorem measure_isClosed_eq_of_forall_lintegral_eq_of_isFiniteMeasure {Ω : Type*}
[MeasurableSpace Ω] [TopologicalSpace Ω] [HasOuterApproxClosed Ω]
[OpensMeasurableSpace Ω] {μ ν : Measure Ω} [IsFiniteMeasure μ]
(h : ∀ (f : Ω →ᵇ ℝ≥0), ∫⁻ x, f x ∂μ = ∫⁻ x, f x ∂ν) {F : Set Ω} (F_closed : IsClosed F) :
μ F = ν F
|
case measure_univ_lt_top
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
inst✝³ : TopologicalSpace Ω
inst✝² : HasOuterApproxClosed Ω
inst✝¹ : OpensMeasurableSpace Ω
μ ν : Measure Ω
inst✝ : IsFiniteMeasure μ
h : ∀ (f : Ω →ᵇ ℝ≥0), ∫⁻ (x : Ω), ↑(f x) ∂μ = ∫⁻ (x : Ω), ↑(f x) ∂ν
F : Set Ω
F_closed : IsClosed F
whole : μ univ = ν univ
⊢ ν univ < ⊤
|
simp [← whole]
|
no goals
|
545c1e4b7e0daa43
|
Asymptotics.isLittleO_norm_left
|
Mathlib/Analysis/Asymptotics/Defs.lean
|
theorem isLittleO_norm_left : (fun x => ‖f' x‖) =o[l] g ↔ f' =o[l] g
|
α : Type u_1
F : Type u_4
E' : Type u_6
inst✝¹ : Norm F
inst✝ : SeminormedAddCommGroup E'
g : α → F
f' : α → E'
l : Filter α
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l (fun x => ‖f' x‖) g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f' g
|
exact forall₂_congr fun _ _ => isBigOWith_norm_left
|
no goals
|
403b9aa052c68398
|
bernsteinPolynomial.sum_mul_smul
|
Mathlib/RingTheory/Polynomial/Bernstein.lean
|
theorem sum_mul_smul (n : ℕ) :
(∑ ν ∈ Finset.range (n + 1), (ν * (ν - 1)) • bernsteinPolynomial R n ν) =
(n * (n - 1)) • X ^ 2
|
R : Type u_1
inst✝ : CommRing R
n : ℕ
x : MvPolynomial Bool R := MvPolynomial.X true
y : MvPolynomial Bool R := MvPolynomial.X false
pderiv_true_x : (pderiv true) x = 1
pderiv_true_y : (pderiv true) y = 0
e : Bool → R[X] := fun i => bif i then X else 1 - X
⊢ ∑ ν ∈ Finset.range (n + 1), (ν * (ν - 1)) • bernsteinPolynomial R n ν = (n * (n - 1)) • X ^ 2
|
trans MvPolynomial.aeval e (pderiv true (pderiv true ((x + y) ^ n))) * X ^ 2
|
R : Type u_1
inst✝ : CommRing R
n : ℕ
x : MvPolynomial Bool R := MvPolynomial.X true
y : MvPolynomial Bool R := MvPolynomial.X false
pderiv_true_x : (pderiv true) x = 1
pderiv_true_y : (pderiv true) y = 0
e : Bool → R[X] := fun i => bif i then X else 1 - X
⊢ ∑ ν ∈ Finset.range (n + 1), (ν * (ν - 1)) • bernsteinPolynomial R n ν =
(MvPolynomial.aeval e) ((pderiv true) ((pderiv true) ((x + y) ^ n))) * X ^ 2
R : Type u_1
inst✝ : CommRing R
n : ℕ
x : MvPolynomial Bool R := MvPolynomial.X true
y : MvPolynomial Bool R := MvPolynomial.X false
pderiv_true_x : (pderiv true) x = 1
pderiv_true_y : (pderiv true) y = 0
e : Bool → R[X] := fun i => bif i then X else 1 - X
⊢ (MvPolynomial.aeval e) ((pderiv true) ((pderiv true) ((x + y) ^ n))) * X ^ 2 = (n * (n - 1)) • X ^ 2
|
5a1ea5f98d0a949e
|
isPreconnected_of_forall_constant
|
Mathlib/Topology/Connected/Clopen.lean
|
theorem isPreconnected_of_forall_constant {s : Set α}
(hs : ∀ f : α → Bool, ContinuousOn f s → ∀ x ∈ s, ∀ y ∈ s, f x = f y) : IsPreconnected s
|
α : Type u
inst✝ : TopologicalSpace α
s : Set α
hs : ∀ (f : α → Bool), ContinuousOn f s → ∀ x ∈ s, ∀ y ∈ s, f x = f y
u v : Set α
u_op : IsOpen u
v_op : IsOpen v
hsuv : s ⊆ u ∪ v
x : α
x_in_s : x ∈ s
x_in_u : x ∈ u
H : s ∩ (u ∩ v) = ∅
y : α
y_in_s : y ∈ s
y_in_v : y ∈ v
hy : y ∉ u
⊢ IsClosed (Subtype.val ⁻¹' v)ᶜ
|
exact (v_op.preimage continuous_subtype_val).isClosed_compl
|
no goals
|
0b9dc97844bbc91c
|
Function.Injective.of_comp_right
|
Mathlib/Logic/Function/Basic.lean
|
theorem Injective.of_comp_right {g : γ → α} (I : Injective (f ∘ g)) (hg : Surjective g) :
Injective f := fun x y h ↦ by
obtain ⟨x, rfl⟩ := hg x
obtain ⟨y, rfl⟩ := hg y
exact congr_arg g (I h)
|
case intro
α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
g : γ → α
I : Injective (f ∘ g)
hg : Surjective g
y : α
x : γ
h : f (g x) = f y
⊢ g x = y
|
obtain ⟨y, rfl⟩ := hg y
|
case intro.intro
α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
g : γ → α
I : Injective (f ∘ g)
hg : Surjective g
x y : γ
h : f (g x) = f (g y)
⊢ g x = g y
|
6d531765884ca3ef
|
Lean.Order.admissible_pprod_snd
|
Mathlib/.lake/packages/lean4/src/lean/Init/Internal/Order/Basic.lean
|
theorem admissible_pprod_snd {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (P : β → Prop)
(hadm : admissible P) : admissible (fun (x : α ×' β) => P x.2)
|
α : Sort u
β : Sort v
inst✝¹ : CCPO α
inst✝ : CCPO β
P : β → Prop
hadm : admissible P
c : α ×' β → Prop
hchain : chain c
h : ∀ (x : α ×' β), c x → (fun x => P x.snd) x
⊢ P (CCPO.csup c).snd
|
apply hadm _ (PProd.chain.chain_snd hchain)
|
α : Sort u
β : Sort v
inst✝¹ : CCPO α
inst✝ : CCPO β
P : β → Prop
hadm : admissible P
c : α ×' β → Prop
hchain : chain c
h : ∀ (x : α ×' β), c x → (fun x => P x.snd) x
⊢ ∀ (x : β), PProd.chain.snd c x → P x
|
ad0d9d2474ff8268
|
IsAssociatedPrime.annihilator_le
|
Mathlib/RingTheory/Ideal/AssociatedPrime.lean
|
theorem IsAssociatedPrime.annihilator_le (h : IsAssociatedPrime I M) :
(⊤ : Submodule R M).annihilator ≤ I
|
case intro.intro
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hI : Ideal.IsPrime (ker (toSpanSingleton R M x))
⊢ ⊤.annihilator ≤ ker (toSpanSingleton R M x)
|
rw [← Submodule.annihilator_span_singleton]
|
case intro.intro
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x : M
hI : Ideal.IsPrime (ker (toSpanSingleton R M x))
⊢ ⊤.annihilator ≤ (Submodule.span R {x}).annihilator
|
194886cc2bb570ce
|
Order.krullDim_pos_iff
|
Mathlib/Order/KrullDimension.lean
|
lemma krullDim_pos_iff : 0 < krullDim α ↔ ∃ x y : α, x < y
|
α : Type u_1
inst✝ : Preorder α
⊢ krullDim α ≤ 0 ↔ ∀ (x y : α), ¬x < y
|
simp_rw [← isMax_iff_forall_not_lt, ← krullDim_nonpos_iff_forall_isMax]
|
no goals
|
dc766689907bf295
|
ENNReal.half_lt_self
|
Mathlib/Data/ENNReal/Inv.lean
|
theorem half_lt_self (hz : a ≠ 0) (ht : a ≠ ∞) : a / 2 < a
|
case intro
a : ℝ≥0
hz : a ≠ 0
⊢ a / 2 < a
case intro
a : ℝ≥0
hz : a ≠ 0
⊢ 2 ≠ 0
|
exacts [NNReal.half_lt_self hz, two_ne_zero' _]
|
no goals
|
4240ca8b153ca5da
|
Submonoid.LocalizationMap.sec_spec'
|
Mathlib/GroupTheory/MonoidLocalization/Basic.lean
|
theorem sec_spec' {f : LocalizationMap S N} (z : N) :
f.toMap (f.sec z).1 = f.toMap (f.sec z).2 * z
|
M : Type u_1
inst✝¹ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝ : CommMonoid N
f : S.LocalizationMap N
z : N
⊢ f.toMap (f.sec z).1 = f.toMap ↑(f.sec z).2 * z
|
rw [mul_comm, sec_spec]
|
no goals
|
9d8069dcf2618fd1
|
MeasureTheory.StronglyMeasurable.integral_kernel_prod_right
|
Mathlib/Probability/Kernel/MeasurableIntegral.lean
|
theorem StronglyMeasurable.integral_kernel_prod_right ⦃f : α → β → E⦄
(hf : StronglyMeasurable (uncurry f)) : StronglyMeasurable fun x => ∫ y, f x y ∂κ x
|
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : IsSFiniteKernel κ
inst✝ : NormedSpace ℝ E
f : α → β → E
hf : StronglyMeasurable (uncurry f)
hE : CompleteSpace E
this✝¹ : MeasurableSpace E := borel E
this✝ : BorelSpace E
this : TopologicalSpace.SeparableSpace ↑(range (uncurry f) ∪ {0})
s : ℕ → SimpleFunc (α × β) E := SimpleFunc.approxOn (uncurry f) ⋯ (range (uncurry f) ∪ {0}) 0 ⋯
s' : ℕ → α → SimpleFunc β E := fun n x => (s n).comp (Prod.mk x) ⋯
f' : ℕ → α → E := fun n => {x | Integrable (f x) (κ x)}.indicator fun x => SimpleFunc.integral (κ x) (s' n x)
⊢ ∀ (n : ℕ), StronglyMeasurable (f' n)
|
intro n
|
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : IsSFiniteKernel κ
inst✝ : NormedSpace ℝ E
f : α → β → E
hf : StronglyMeasurable (uncurry f)
hE : CompleteSpace E
this✝¹ : MeasurableSpace E := borel E
this✝ : BorelSpace E
this : TopologicalSpace.SeparableSpace ↑(range (uncurry f) ∪ {0})
s : ℕ → SimpleFunc (α × β) E := SimpleFunc.approxOn (uncurry f) ⋯ (range (uncurry f) ∪ {0}) 0 ⋯
s' : ℕ → α → SimpleFunc β E := fun n x => (s n).comp (Prod.mk x) ⋯
f' : ℕ → α → E := fun n => {x | Integrable (f x) (κ x)}.indicator fun x => SimpleFunc.integral (κ x) (s' n x)
n : ℕ
⊢ StronglyMeasurable (f' n)
|
8e2e9c2ee13e9a95
|
Array.map_induction
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem map_induction (as : Array α) (f : α → β) (motive : Nat → Prop) (h0 : motive 0)
(p : Fin as.size → β → Prop) (hs : ∀ i, motive i.1 → p i (f as[i]) ∧ motive (i+1)) :
motive as.size ∧
∃ eq : (as.map f).size = as.size, ∀ i h, p ⟨i, h⟩ ((as.map f)[i])
|
case neg
α : Type u_1
β : Type u_2
as : Array α
f : α → β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → p i (f as[i]) ∧ motive (↑i + 1)
i : Fin as.size
b : Array β
m : motive ↑i
eq : b.size = ↑i
w : ∀ (i : Fin as.size) (h2 : ↑i < b.size), p i b[↑i]
j : Fin as.size
h✝ : ↑j < ((fun r a => r.push (f a)) b as[i]).size
h : ↑j < b.size + 1
h' : ¬↑j < b.size
⊢ p j (f as[↑i])
|
simp only [show j = i by omega]
|
case neg
α : Type u_1
β : Type u_2
as : Array α
f : α → β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → p i (f as[i]) ∧ motive (↑i + 1)
i : Fin as.size
b : Array β
m : motive ↑i
eq : b.size = ↑i
w : ∀ (i : Fin as.size) (h2 : ↑i < b.size), p i b[↑i]
j : Fin as.size
h✝ : ↑j < ((fun r a => r.push (f a)) b as[i]).size
h : ↑j < b.size + 1
h' : ¬↑j < b.size
⊢ p i (f as[↑i])
|
07b92593a639a2fd
|
Orientation.oangle_eq_of_angle_eq_of_sign_eq
|
Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
|
theorem oangle_eq_of_angle_eq_of_sign_eq {w x y z : V}
(h : InnerProductGeometry.angle w x = InnerProductGeometry.angle y z)
(hs : (o.oangle w x).sign = (o.oangle y z).sign) : o.oangle w x = o.oangle y z
|
case inr.inr
V : Type u_1
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
w x y : V
h : InnerProductGeometry.angle w x = InnerProductGeometry.angle y 0
hs : (o.oangle w x).sign = (o.oangle y 0).sign
⊢ (o.oangle w x).sign = 0 ∧ (o.oangle y 0).sign = 0
|
simpa using hs
|
no goals
|
ec88cb80dbeb7f16
|
LinearMap.bot_lt_ker_of_det_eq_zero
|
Mathlib/LinearAlgebra/Determinant.lean
|
theorem bot_lt_ker_of_det_eq_zero {𝕜 : Type*} [Field 𝕜] [Module 𝕜 M] {f : M →ₗ[𝕜] M}
(hf : LinearMap.det f = 0) : ⊥ < LinearMap.ker f
|
M : Type u_2
inst✝² : AddCommGroup M
𝕜 : Type u_7
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M →ₗ[𝕜] M
hf : LinearMap.det f = 0
this : FiniteDimensional 𝕜 M
⊢ ⊥ < ker f
|
contrapose hf
|
M : Type u_2
inst✝² : AddCommGroup M
𝕜 : Type u_7
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M →ₗ[𝕜] M
this : FiniteDimensional 𝕜 M
hf : ¬⊥ < ker f
⊢ ¬LinearMap.det f = 0
|
92fd01011447bbe2
|
Ideal.ideal_prod_prime
|
Mathlib/RingTheory/Ideal/Prod.lean
|
theorem ideal_prod_prime (I : Ideal (R × S)) :
I.IsPrime ↔
(∃ p : Ideal R, p.IsPrime ∧ I = Ideal.prod p ⊤) ∨
∃ p : Ideal S, p.IsPrime ∧ I = Ideal.prod ⊤ p
|
case mp.inl
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I : Ideal (R × S)
hI : ((map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)).IsPrime
h : map (RingHom.fst R S) I = ⊤
⊢ (∃ p, p.IsPrime ∧ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I) = p.prod ⊤) ∨
∃ p, p.IsPrime ∧ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I) = ⊤.prod p
|
right
|
case mp.inl.h
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I : Ideal (R × S)
hI : ((map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)).IsPrime
h : map (RingHom.fst R S) I = ⊤
⊢ ∃ p, p.IsPrime ∧ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I) = ⊤.prod p
|
5d31973d7dbcd867
|
LinearMap.det_smul
|
Mathlib/LinearAlgebra/Determinant.lean
|
theorem det_smul [Module.Free A M] (c : A) (f : M →ₗ[A] M) :
LinearMap.det (c • f) = c ^ Module.finrank A M * LinearMap.det f
|
case pos
M : Type u_2
inst✝³ : AddCommGroup M
A : Type u_5
inst✝² : CommRing A
inst✝¹ : Module A M
inst✝ : Module.Free A M
c : A
f : M →ₗ[A] M
a✝ : Nontrivial A
H : ∃ s, Nonempty (Basis { x // x ∈ s } A M)
this : Module.Finite A M
⊢ LinearMap.det (c • f) = c ^ Module.finrank A M * LinearMap.det f
|
simp only [← det_toMatrix (Module.finBasis A M), LinearEquiv.map_smul,
Fintype.card_fin, Matrix.det_smul]
|
no goals
|
8fdbe434c6a19498
|
isLindelof_open_iff_eq_countable_iUnion_of_isTopologicalBasis
|
Mathlib/Topology/Compactness/Lindelof.lean
|
theorem isLindelof_open_iff_eq_countable_iUnion_of_isTopologicalBasis (b : ι → Set X)
(hb : IsTopologicalBasis (Set.range b)) (hb' : ∀ i, IsLindelof (b i)) (U : Set X) :
IsLindelof U ∧ IsOpen U ↔ ∃ s : Set ι, s.Countable ∧ U = ⋃ i ∈ s, b i
|
case mp.intro.intro.intro.intro.intro.refine_1
X : Type u
ι : Type u_1
inst✝ : TopologicalSpace X
b : ι → Set X
hb : IsTopologicalBasis (range b)
hb' : ∀ (i : ι), IsLindelof (b i)
Y : Type u
f' : Y → ι
h₁ : IsLindelof (⋃ i, (b ∘ f') i)
h₂ : IsOpen (⋃ i, (b ∘ f') i)
hf' : ∀ (i : Y), b (f' i) = (b ∘ f') i
t : Set Y
ht : t.Countable ∧ ⋃ i, (b ∘ f') i ⊆ ⋃ i ∈ t, (b ∘ f') i
i : Y
hi : i ∈ t
⊢ (b ∘ f') i ⊆ ⋃ x, b ↑x
|
exact Set.subset_iUnion (fun i : t.image f' => b i) ⟨_, mem_image_of_mem _ hi⟩
|
no goals
|
5ea85c22866d42e2
|
Function.update_eq_updateFinset
|
Mathlib/Data/Finset/Update.lean
|
theorem update_eq_updateFinset {i y} :
Function.update x i y = updateFinset x {i} (uniqueElim y)
|
ι : Type u_1
π : ι → Sort u_2
x : (i : ι) → π i
inst✝ : DecidableEq ι
i : ι
y : π i
⊢ update x i y = updateFinset x {i} (uniqueElim y)
|
congr with j
|
case h
ι : Type u_1
π : ι → Sort u_2
x : (i : ι) → π i
inst✝ : DecidableEq ι
i : ι
y : π i
j : ι
⊢ update x i y j = updateFinset x {i} (uniqueElim y) j
|
f513edede4d792eb
|
MeasureTheory.ae_nonneg_of_forall_setIntegral_nonneg_of_sigmaFinite
|
Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
|
theorem ae_nonneg_of_forall_setIntegral_nonneg_of_sigmaFinite [SigmaFinite μ] {f : α → ℝ}
(hf_int_finite : ∀ s, MeasurableSet s → μ s < ∞ → IntegrableOn f s μ)
(hf_zero : ∀ s, MeasurableSet s → μ s < ∞ → 0 ≤ ∫ x in s, f x ∂μ) : 0 ≤ᵐ[μ] f
|
case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → IntegrableOn f s μ
hf_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
t : Set α
t_meas : MeasurableSet t
t_lt_top : μ t < ⊤
⊢ ∀ᵐ (x : α) ∂μ.restrict t, 0 x ≤ f x
|
apply ae_nonneg_restrict_of_forall_setIntegral_nonneg_inter (hf_int_finite t t_meas t_lt_top)
|
case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → IntegrableOn f s μ
hf_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
t : Set α
t_meas : MeasurableSet t
t_lt_top : μ t < ⊤
⊢ ∀ (s : Set α), MeasurableSet s → μ (s ∩ t) < ⊤ → 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ
|
c952d9bd03e52640
|
Filter.tendsto_iff_ptendsto
|
Mathlib/Order/Filter/Partial.lean
|
theorem tendsto_iff_ptendsto (l₁ : Filter α) (l₂ : Filter β) (s : Set α) (f : α → β) :
Tendsto f (l₁ ⊓ 𝓟 s) l₂ ↔ PTendsto (PFun.res f s) l₁ l₂
|
α : Type u
β : Type v
l₁ : Filter α
l₂ : Filter β
s : Set α
f : α → β
⊢ Tendsto f (l₁ ⊓ 𝓟 s) l₂ ↔ PTendsto (PFun.res f s) l₁ l₂
|
simp only [Tendsto, PTendsto, pmap_res]
|
no goals
|
1ad49e0b0e6acd7e
|
Metric.cthickening_subset_iUnion_closedBall_of_lt
|
Mathlib/Topology/MetricSpace/Thickening.lean
|
theorem cthickening_subset_iUnion_closedBall_of_lt {α : Type*} [PseudoMetricSpace α] (E : Set α)
{δ δ' : ℝ} (hδ₀ : 0 < δ') (hδδ' : δ < δ') : cthickening δ E ⊆ ⋃ x ∈ E, closedBall x δ'
|
α : Type u_2
inst✝ : PseudoMetricSpace α
E : Set α
δ δ' : ℝ
hδ₀ : 0 < δ'
hδδ' : δ < δ'
x : α
hx : x ∈ thickening δ' E
⊢ x ∈ ⋃ x ∈ E, closedBall x δ'
|
obtain ⟨y, hy₁, hy₂⟩ := mem_thickening_iff.mp hx
|
case intro.intro
α : Type u_2
inst✝ : PseudoMetricSpace α
E : Set α
δ δ' : ℝ
hδ₀ : 0 < δ'
hδδ' : δ < δ'
x : α
hx : x ∈ thickening δ' E
y : α
hy₁ : y ∈ E
hy₂ : dist x y < δ'
⊢ x ∈ ⋃ x ∈ E, closedBall x δ'
|
b330ebd17268c278
|
BoundedContinuousFunction.dist_lt_iff_of_compact
|
Mathlib/Topology/ContinuousMap/Bounded/Basic.lean
|
theorem dist_lt_iff_of_compact [CompactSpace α] (C0 : (0 : ℝ) < C) :
dist f g < C ↔ ∀ x : α, dist (f x) (g x) < C
|
case mpr
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
f g : α →ᵇ β
C : ℝ
inst✝ : CompactSpace α
C0 : 0 < C
⊢ (∀ (x : α), dist (f x) (g x) < C) → dist f g < C
|
by_cases h : Nonempty α
|
case pos
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
f g : α →ᵇ β
C : ℝ
inst✝ : CompactSpace α
C0 : 0 < C
h : Nonempty α
⊢ (∀ (x : α), dist (f x) (g x) < C) → dist f g < C
case neg
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
f g : α →ᵇ β
C : ℝ
inst✝ : CompactSpace α
C0 : 0 < C
h : ¬Nonempty α
⊢ (∀ (x : α), dist (f x) (g x) < C) → dist f g < C
|
fb7b148d1f803c70
|
Ideal.Filtration.submodule_closure_single
|
Mathlib/RingTheory/Filtration.lean
|
theorem submodule_closure_single :
AddSubmonoid.closure (⋃ i, single R i '' (F.N i : Set M)) = F.submodule.toAddSubmonoid
|
case neg
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F : I.Filtration M
i : ℕ
m : M
hm : m ∈ ↑(F.N i)
j : ℕ
h : ¬i = j
⊢ 0 ∈ F.N j
|
exact (F.N j).zero_mem
|
no goals
|
bd336799b08b1c57
|
Multiset.map_count_True_eq_filter_card
|
Mathlib/Data/Multiset/Filter.lean
|
theorem map_count_True_eq_filter_card (s : Multiset α) (p : α → Prop) [DecidablePred p] :
(s.map p).count True = card (s.filter p)
|
α : Type u_1
s : Multiset α
p : α → Prop
inst✝ : DecidablePred p
⊢ count True (map p s) = (filter p s).card
|
simp only [count_eq_card_filter_eq, filter_map, card_map, Function.id_comp,
eq_true_eq_id, Function.comp_apply]
|
no goals
|
be5c1f40ec148462
|
Set.wellFoundedOn_range
|
Mathlib/Order/WellFoundedSet.lean
|
theorem wellFoundedOn_range : (range f).WellFoundedOn r ↔ WellFounded (r on f)
|
case mk.intro.refine_1
α : Type u_2
β : Type u_3
r : α → α → Prop
f : β → α
f' : β → ↑(range f) := fun c => ⟨f c, ⋯⟩
h : WellFounded (r on f)
c : β
⊢ ∀ {a : β} {b : ↑(range f)}, r ↑b ↑(f' a) → ∃ c, f' c = b
|
rintro _ ⟨_, c', rfl⟩ -
|
case mk.intro.refine_1.mk.intro
α : Type u_2
β : Type u_3
r : α → α → Prop
f : β → α
f' : β → ↑(range f) := fun c => ⟨f c, ⋯⟩
h : WellFounded (r on f)
c a✝ c' : β
⊢ ∃ c, f' c = ⟨f c', ⋯⟩
|
cfcccc1dfe69da6c
|
PowerSeries.map_surjective
|
Mathlib/RingTheory/PowerSeries/Basic.lean
|
theorem map_surjective (f : S →+* T) (hf : Function.Surjective f) :
Function.Surjective (PowerSeries.map f)
|
case h.h
S : Type u_2
T : Type u_3
inst✝¹ : Semiring S
inst✝ : Semiring T
f : S →+* T
hf : Function.Surjective ⇑f
g : T⟦X⟧
k : ℕ
⊢ f (Classical.choose ⋯) = (coeff T k) g
|
exact Classical.choose_spec (hf ((coeff T k) g))
|
no goals
|
22da55e7c554d77c
|
MeasureTheory.tilted_eq_withDensity_nnreal
|
Mathlib/MeasureTheory/Measure/Tilted.lean
|
lemma tilted_eq_withDensity_nnreal (μ : Measure α) (f : α → ℝ) :
μ.tilted f = μ.withDensity (fun x ↦ ((↑) : ℝ≥0 → ℝ≥0∞)
(⟨exp (f x) / ∫ x, exp (f x) ∂μ, by positivity⟩ : ℝ≥0))
|
case e_f.h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
x : α
⊢ ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) = ↑⟨rexp (f x) / ∫ (x : α), rexp (f x) ∂μ, ⋯⟩
|
rw [ENNReal.ofReal_eq_coe_nnreal]
|
no goals
|
bedb4f144f9ee107
|
Ideal.absNorm_span_singleton
|
Mathlib/RingTheory/Ideal/Norm/AbsNorm.lean
|
theorem absNorm_span_singleton (r : S) :
absNorm (span ({r} : Set S)) = (Algebra.norm ℤ r).natAbs
|
case neg
S : Type u_1
inst✝⁴ : CommRing S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
r : S
hr : ¬r = 0
this : Fintype (S ⧸ span {r}) := (span {r}).fintypeQuotientOfFreeOfNeBot ⋯
b : Basis (Module.Free.ChooseBasisIndex ℤ S) ℤ S := Module.Free.chooseBasis ℤ S
⊢ (LinearMap.det
(↑ℤ (Submodule.subtype (span {r})) ∘ₗ
(↑(b.equiv (basisSpanSingleton b hr)
(Equiv.refl (Module.Free.ChooseBasisIndex ℤ S)))).toIntLinearMap)).natAbs =
(LinearMap.det ((Algebra.lmul ℤ S) r)).natAbs
|
congr
|
case neg.e_m.h.e_6.h
S : Type u_1
inst✝⁴ : CommRing S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
r : S
hr : ¬r = 0
this : Fintype (S ⧸ span {r}) := (span {r}).fintypeQuotientOfFreeOfNeBot ⋯
b : Basis (Module.Free.ChooseBasisIndex ℤ S) ℤ S := Module.Free.chooseBasis ℤ S
⊢ ↑ℤ (Submodule.subtype (span {r})) ∘ₗ
(↑(b.equiv (basisSpanSingleton b hr) (Equiv.refl (Module.Free.ChooseBasisIndex ℤ S)))).toIntLinearMap =
(Algebra.lmul ℤ S) r
|
d5532931e84e3a93
|
Topology.RelCWComplex.cellFrontier_subset_skeletonLT
|
Mathlib/Topology/CWComplex/Classical/Basic.lean
|
lemma RelCWComplex.cellFrontier_subset_skeletonLT [RelCWComplex C D] (n : ℕ) (j : cell C n) :
cellFrontier n j ⊆ skeletonLT C n
|
case intro.h
X : Type u_1
t : TopologicalSpace X
C D : Set X
inst✝ : RelCWComplex C D
n : ℕ
j : cell C n
I : (m : ℕ) → Finset (cell C m)
hI : cellFrontier n j ⊆ D ∪ ⋃ m, ⋃ (_ : m < n), ⋃ j ∈ I m, closedCell m j
⊢ ⋃ m, ⋃ (_ : m < n), ⋃ j ∈ I m, closedCell m j ⊆ ⋃ m, ⋃ (_ : ↑m < ↑n), ⋃ j, closedCell m j
|
intro x xmem
|
case intro.h
X : Type u_1
t : TopologicalSpace X
C D : Set X
inst✝ : RelCWComplex C D
n : ℕ
j : cell C n
I : (m : ℕ) → Finset (cell C m)
hI : cellFrontier n j ⊆ D ∪ ⋃ m, ⋃ (_ : m < n), ⋃ j ∈ I m, closedCell m j
x : X
xmem : x ∈ ⋃ m, ⋃ (_ : m < n), ⋃ j ∈ I m, closedCell m j
⊢ x ∈ ⋃ m, ⋃ (_ : ↑m < ↑n), ⋃ j, closedCell m j
|
b66d81e5a34117fe
|
Equiv.Perm.eq_sign_of_surjective_hom
|
Mathlib/GroupTheory/Perm/Sign.lean
|
theorem eq_sign_of_surjective_hom {s : Perm α →* ℤˣ} (hs : Surjective s) : s = sign :=
have : ∀ {f}, IsSwap f → s f = -1 := fun {f} ⟨x, y, hxy, hxy'⟩ =>
hxy'.symm ▸
by_contradiction fun h => by
have : ∀ f, IsSwap f → s f = 1 := fun f ⟨a, b, hab, hab'⟩ => by
rw [← isConj_iff_eq, ← Or.resolve_right (Int.units_eq_one_or _) h, hab']
exact s.map_isConj (isConj_swap hab hxy)
let ⟨g, hg⟩ := hs (-1)
let ⟨l, hl⟩ := (truncSwapFactors g).out
have : ∀ a ∈ l.map s, a = (1 : ℤˣ) := fun a ha =>
let ⟨g, hg⟩ := List.mem_map.1 ha
hg.2 ▸ this _ (hl.2 _ hg.1)
have : s l.prod = 1
|
α : Type u
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Perm α →* ℤˣ
hs : Surjective ⇑s
f✝ : Perm α
x✝¹ : f✝.IsSwap
x y : α
hxy : x ≠ y
hxy' : f✝ = swap x y
h : ¬s (swap x y) = -1
f : Perm α
x✝ : f.IsSwap
a b : α
hab : a ≠ b
hab' : f = swap a b
⊢ IsConj (s (swap a b)) (s (swap x y))
|
exact s.map_isConj (isConj_swap hab hxy)
|
no goals
|
8e0d79dcb0016e04
|
BitVec.getLsbD_sshiftRight
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem getLsbD_sshiftRight (x : BitVec w) (s i : Nat) :
getLsbD (x.sshiftRight s) i =
(!decide (w ≤ i) && if s + i < w then x.getLsbD (s + i) else x.msb)
|
case pos
w : Nat
x : BitVec w
s i : Nat
hmsb : x.msb = false
hi : i ≥ w
⊢ x.getLsbD (s + i) = (!decide (w ≤ i) && (decide (s + i < w) && x.getLsbD (s + i)))
|
simp only [hi, decide_true, Bool.not_true, Bool.false_and]
|
case pos
w : Nat
x : BitVec w
s i : Nat
hmsb : x.msb = false
hi : i ≥ w
⊢ x.getLsbD (s + i) = false
|
3860ec5babbfcdfd
|
EuclideanGeometry.dist_smul_vadd_eq_dist
|
Mathlib/Geometry/Euclidean/Basic.lean
|
theorem dist_smul_vadd_eq_dist {v : V} (p₁ p₂ : P) (hv : v ≠ 0) (r : ℝ) :
dist (r • v +ᵥ p₁) p₂ = dist p₁ p₂ ↔ r = 0 ∨ r = -2 * ⟪v, p₁ -ᵥ p₂⟫ / ⟪v, v⟫
|
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
hvi : inner v v ≠ 0
hd : discrim (inner v v) (2 * inner v (p₁ -ᵥ p₂)) 0 = 2 * inner v (p₁ -ᵥ p₂) * (2 * inner v (p₁ -ᵥ p₂))
⊢ inner v v * (r * r) + 2 * inner v (p₁ -ᵥ p₂) * r + 0 = 0 ↔ r = 0 ∨ r = -2 * inner v (p₁ -ᵥ p₂) / inner v v
|
rw [quadratic_eq_zero_iff hvi hd, neg_add_cancel, zero_div, neg_mul_eq_neg_mul, ←
mul_sub_right_distrib, sub_eq_add_neg, ← mul_two, mul_assoc, mul_div_assoc, mul_div_mul_left,
mul_div_assoc]
|
case hc
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
hvi : inner v v ≠ 0
hd : discrim (inner v v) (2 * inner v (p₁ -ᵥ p₂)) 0 = 2 * inner v (p₁ -ᵥ p₂) * (2 * inner v (p₁ -ᵥ p₂))
⊢ 2 ≠ 0
|
44b00dbdc3b3f9e2
|
CategoryTheory.ShortComplex.HomologyData.right_homologyIso_eq_left_homologyIso_trans_iso
|
Mathlib/Algebra/Homology/ShortComplex/Homology.lean
|
lemma HomologyData.right_homologyIso_eq_left_homologyIso_trans_iso
(h : S.HomologyData) [S.HasHomology] :
h.right.homologyIso = h.left.homologyIso ≪≫ h.iso
|
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S : ShortComplex C
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.iso = h.left.homologyIso.symm ≪≫ h.right.homologyIso
|
ext
|
case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S : ShortComplex C
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.iso.hom = (h.left.homologyIso.symm ≪≫ h.right.homologyIso).hom
|
17b29b5f5a626f43
|
ae_eq_zero_of_integral_smooth_smul_eq_zero
|
Mathlib/Analysis/Distribution/AEEqOfIntegralContDiff.lean
|
theorem ae_eq_zero_of_integral_smooth_smul_eq_zero [SigmaCompactSpace M]
(hf : LocallyIntegrable f μ)
(h : ∀ g : M → ℝ, ContMDiff I 𝓘(ℝ) ∞ g → HasCompactSupport g → ∫ x, g x • f x ∂μ = 0) :
∀ᵐ x ∂μ, f x = 0
|
case h.refine_2
E : Type u_1
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : FiniteDimensional ℝ E
F : Type u_2
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : CompleteSpace F
H : Type u_3
inst✝⁷ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_4
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
inst✝⁴ : IsManifold I ∞ M
inst✝³ : MeasurableSpace M
inst✝² : BorelSpace M
inst✝¹ : T2Space M
f : M → F
μ : Measure M
inst✝ : SigmaCompactSpace M
hf : LocallyIntegrable f μ
h : ∀ (g : M → ℝ), ContMDiff I 𝓘(ℝ, ℝ) ∞ g → HasCompactSupport g → ∫ (x : M), g x • f x ∂μ = 0
this✝⁴ : LocallyCompactSpace H
this✝³ : LocallyCompactSpace M
this✝² : SecondCountableTopology H
this✝¹ : SecondCountableTopology M
this✝ : MetrizableSpace M
x✝ : MetricSpace M := metrizableSpaceMetric M
s : Set M
hs : IsCompact s
δ : ℝ
δpos : 0 < δ
hδ : IsCompact (cthickening δ s)
u : ℕ → ℝ
u_pos : ∀ (n : ℕ), u n ∈ Ioo 0 δ
u_lim : Tendsto u atTop (𝓝 0)
v : ℕ → Set M := fun n => thickening (u n) s
K : Set M
K_compact : IsCompact K
vK : ∀ (n : ℕ), v n ⊆ K
g : ℕ → M → ℝ
g_supp : ∀ (n : ℕ), support (g n) = v n
g_diff : ∀ (n : ℕ), ContMDiff I 𝓘(ℝ, ℝ) ∞ (g n)
g_range : ∀ (n : ℕ), range (g n) ⊆ Icc 0 1
hg : ∀ (n : ℕ), ∀ x ∈ s, g n x = 1
bound : M → ℝ := K.indicator fun x => ‖f x‖
A : ∀ (n : ℕ), AEStronglyMeasurable (fun x => g n x • f x) μ
B : Integrable bound μ
n : ℕ
x : M
hxK : x ∉ K
this : g n x = 0
⊢ ‖g n x‖ * ‖f x‖ ≤ 0
|
simp [this]
|
no goals
|
28fe4c32a4a6619f
|
WeierstrassCurve.Jacobian.smul_equiv_smul
|
Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
|
lemma smul_equiv_smul (P Q : Fin 3 → R) {u v : R} (hu : IsUnit u) (hv : IsUnit v) :
u • P ≈ v • Q ↔ P ≈ Q
|
R : Type r
inst✝ : CommRing R
P Q : Fin 3 → R
u v : R
hu : IsUnit u
hv : IsUnit v
⊢ u • P ≈ v • Q ↔ P ≈ Q
|
rw [← Quotient.eq_iff_equiv, ← Quotient.eq_iff_equiv, smul_eq P hu, smul_eq Q hv]
|
no goals
|
f39d76a9b9e30427
|
InformationTheory.not_differentiableWithinAt_klFun_Iio_zero
|
Mathlib/InformationTheory/KullbackLeibler/KLFun.lean
|
lemma not_differentiableWithinAt_klFun_Iio_zero : ¬ DifferentiableWithinAt ℝ klFun (Iio 0) 0
|
⊢ Tendsto (deriv klFun) (nhdsWithin 0 (Iio 0)) atBot
|
rw [deriv_klFun]
|
⊢ Tendsto log (nhdsWithin 0 (Iio 0)) atBot
|
ca4c2cf48091d252
|
Equiv.Perm.pow_mod_card_support_cycleOf_self_apply
|
Mathlib/GroupTheory/Perm/Cycle/Factors.lean
|
theorem pow_mod_card_support_cycleOf_self_apply [DecidableEq α] [Fintype α]
(f : Perm α) (n : ℕ) (x : α) : (f ^ (n % #(f.cycleOf x).support)) x = (f ^ n) x
|
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
n : ℕ
x : α
⊢ (f ^ (n % #(f.cycleOf x).support)) x = (f ^ n) x
|
by_cases hx : f x = x
|
case pos
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
n : ℕ
x : α
hx : f x = x
⊢ (f ^ (n % #(f.cycleOf x).support)) x = (f ^ n) x
case neg
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f : Perm α
n : ℕ
x : α
hx : ¬f x = x
⊢ (f ^ (n % #(f.cycleOf x).support)) x = (f ^ n) x
|
a2e5f09535723482
|
Profinite.NobelingProof.CC_exact
|
Mathlib/Topology/Category/Profinite/Nobeling.lean
|
theorem CC_exact {f : LocallyConstant C ℤ} (hf : Linear_CC' C hsC ho f = 0) :
∃ y, πs C o y = f
|
case refine_3.h.mk.inr.h.e_6.h
I : Type u
C : Set (I → Bool)
inst✝¹ : LinearOrder I
inst✝ : WellFoundedLT I
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x1 x2 => x1 < x2
f : LocallyConstant ↑C ℤ
hf :
⇑((LocallyConstant.comapₗ ℤ { toFun := CC'₁ C hsC ho, continuous_toFun := ⋯ }) f) =
⇑((LocallyConstant.comapₗ ℤ { toFun := CC'₀ C ho, continuous_toFun := ⋯ }) f)
C₀C : ↑(C0 C ho) → ↑C := fun x => ⟨↑x, ⋯⟩
h₀ : Continuous C₀C
C₁C : ↑(π (C1 C ho) fun x => ord I x < o) → ↑C := fun x => ⟨SwapTrue o ↑x, ⋯⟩
h₁ : Continuous C₁C
x : I → Bool
hx : x ∈ C
hx₁ : x ∈ C1 C ho
hx₁' : ↑(ProjRestrict C (fun x => ord I x < o) ⟨x, hx⟩) ∈ π (C1 C ho) fun x => ord I x < o
⊢ SwapTrue o ↑(ProjRestrict C (fun x => ord I x < o) ⟨x, hx⟩) = x
|
exact C1_projOrd C hsC ho hx₁
|
no goals
|
c7ebbbfd480d7eed
|
Std.DHashMap.Internal.Raw₀.contains_of_contains_insertIfNew'
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/RawLemmas.lean
|
theorem contains_of_contains_insertIfNew' [EquivBEq α] [LawfulHashable α] (h : m.1.WF) {k a : α}
{v : β k} :
(m.insertIfNew k v).contains a → ¬((k == a) ∧ m.contains k = false) → m.contains a
|
α : Type u
β : α → Type v
m : Raw₀ α β
inst✝³ : BEq α
inst✝² : Hashable α
inst✝¹ : EquivBEq α
inst✝ : LawfulHashable α
h : m.val.WF
k a : α
v : β k
⊢ (m.insertIfNew k v).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true
|
simp_to_model [insertIfNew] using List.containsKey_of_containsKey_insertEntryIfNew'
|
no goals
|
129fb185f1b6dc87
|
Vitali.exists_disjoint_subfamily_covering_enlargement
|
Mathlib/MeasureTheory/Covering/Vitali.lean
|
theorem exists_disjoint_subfamily_covering_enlargement (B : ι → Set α) (t : Set ι) (δ : ι → ℝ)
(τ : ℝ) (hτ : 1 < τ) (δnonneg : ∀ a ∈ t, 0 ≤ δ a) (R : ℝ) (δle : ∀ a ∈ t, δ a ≤ R)
(hne : ∀ a ∈ t, (B a).Nonempty) :
∃ u ⊆ t,
u.PairwiseDisjoint B ∧ ∀ a ∈ t, ∃ b ∈ u, (B a ∩ B b).Nonempty ∧ δ a ≤ τ * δ b
|
case intro.intro.intro
α : Type u_1
ι : Type u_2
B : ι → Set α
t : Set ι
δ : ι → ℝ
τ : ℝ
hτ : 1 < τ
δnonneg : ∀ a ∈ t, 0 ≤ δ a
R : ℝ
δle : ∀ a ∈ t, δ a ≤ R
hne : ∀ a ∈ t, (B a).Nonempty
T : Set (Set ι) :=
{u |
u ⊆ t ∧
u.PairwiseDisjoint B ∧ ∀ a ∈ t, ∀ b ∈ u, (B a ∩ B b).Nonempty → ∃ c ∈ u, (B a ∩ B c).Nonempty ∧ δ a ≤ τ * δ c}
u : Set ι
hu : Maximal (fun x => x ∈ T) u
a : ι
hat : a ∈ t
hcon : ∀ b ∈ u, (B a ∩ B b).Nonempty → τ * δ b < δ a
a_disj : ∀ c ∈ u, Disjoint (B a) (B c)
A : Set ι := {a' | a' ∈ t ∧ ∀ c ∈ u, Disjoint (B a') (B c)}
Anonempty : A.Nonempty
m : ℝ := sSup (δ '' A)
bddA : BddAbove (δ '' A)
a' : ι
a'A : a' ∈ A
ha' : m / τ ≤ δ a'
⊢ False
|
clear hat hcon a_disj a
|
case intro.intro.intro
α : Type u_1
ι : Type u_2
B : ι → Set α
t : Set ι
δ : ι → ℝ
τ : ℝ
hτ : 1 < τ
δnonneg : ∀ a ∈ t, 0 ≤ δ a
R : ℝ
δle : ∀ a ∈ t, δ a ≤ R
hne : ∀ a ∈ t, (B a).Nonempty
T : Set (Set ι) :=
{u |
u ⊆ t ∧
u.PairwiseDisjoint B ∧ ∀ a ∈ t, ∀ b ∈ u, (B a ∩ B b).Nonempty → ∃ c ∈ u, (B a ∩ B c).Nonempty ∧ δ a ≤ τ * δ c}
u : Set ι
hu : Maximal (fun x => x ∈ T) u
A : Set ι := {a' | a' ∈ t ∧ ∀ c ∈ u, Disjoint (B a') (B c)}
Anonempty : A.Nonempty
m : ℝ := sSup (δ '' A)
bddA : BddAbove (δ '' A)
a' : ι
a'A : a' ∈ A
ha' : m / τ ≤ δ a'
⊢ False
|
e38a150de4970f9c
|
SimplexCategory.iso_eq_iso_refl
|
Mathlib/AlgebraicTopology/SimplexCategory/Basic.lean
|
theorem iso_eq_iso_refl {x : SimplexCategory} (e : x ≅ x) : e = Iso.refl x
|
case w.a
x : SimplexCategory
e : x ≅ x
h : Finset.univ.card = x.len + 1
eq₁ : RelIso.toRelEmbedding (orderIsoOfIso e) = Finset.univ.orderEmbOfFin h
eq₂ : RelIso.toRelEmbedding (orderIsoOfIso (Iso.refl x)) = Finset.univ.orderEmbOfFin h
⊢ Hom.toOrderHom e.hom = Hom.toOrderHom (Iso.refl x).hom
|
convert congr_arg (fun φ => (OrderEmbedding.toOrderHom φ)) (eq₁.trans eq₂.symm)
|
case h.e'_2
x : SimplexCategory
e : x ≅ x
h : Finset.univ.card = x.len + 1
eq₁ : RelIso.toRelEmbedding (orderIsoOfIso e) = Finset.univ.orderEmbOfFin h
eq₂ : RelIso.toRelEmbedding (orderIsoOfIso (Iso.refl x)) = Finset.univ.orderEmbOfFin h
⊢ Hom.toOrderHom e.hom = OrderEmbedding.toOrderHom (RelIso.toRelEmbedding (orderIsoOfIso e))
|
c8a68730c47018a8
|
MeasureTheory.withDensity_eq_zero_iff
|
Mathlib/MeasureTheory/Measure/WithDensity.lean
|
theorem withDensity_eq_zero_iff {f : α → ℝ≥0∞} (hf : AEMeasurable f μ) :
μ.withDensity f = 0 ↔ f =ᵐ[μ] 0
|
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ μ.withDensity f = 0 ↔ f =ᶠ[ae μ] 0
|
rw [← measure_univ_eq_zero, withDensity_apply _ .univ, restrict_univ, lintegral_eq_zero_iff' hf]
|
no goals
|
c9442168a7b3da0c
|
Finset.filter_and
|
Mathlib/Data/Finset/Basic.lean
|
theorem filter_and (s : Finset α) : (s.filter fun a => p a ∧ q a) = s.filter p ∩ s.filter q :=
ext fun _ => by simp [mem_filter, mem_inter, and_comm, and_left_comm, and_self_iff, and_assoc]
|
α : Type u_1
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
x✝ : α
⊢ x✝ ∈ filter (fun a => p a ∧ q a) s ↔ x✝ ∈ filter p s ∩ filter q s
|
simp [mem_filter, mem_inter, and_comm, and_left_comm, and_self_iff, and_assoc]
|
no goals
|
9c62be78010bf282
|
Equiv.Perm.OnCycleFactors.kerParam_range_eq_centralizer_of_count_le_one
|
Mathlib/GroupTheory/SpecificGroups/Alternating/Centralizer.lean
|
theorem OnCycleFactors.kerParam_range_eq_centralizer_of_count_le_one
(h_count : ∀ i, g.cycleType.count i ≤ 1) :
(kerParam g).range = Subgroup.centralizer {g}
|
case h.H.a
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g : Perm α
h_count : ∀ (i : ℕ), Multiset.count i g.cycleType ≤ 1
x : Perm α
hx : x ∈ Subgroup.centralizer {g}
c : { x // x ∈ g.cycleFactorsFinset }
⊢ ↑(((toPermHom g) ⟨x, ⋯⟩) c) = ↑(1 c)
|
rw [← Multiset.nodup_iff_count_le_one, cycleType_def,
Multiset.nodup_map_iff_inj_on (cycleFactorsFinset g).nodup] at h_count
|
case h.H.a
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g : Perm α
h_count :
∀ x ∈ g.cycleFactorsFinset.val, ∀ y ∈ g.cycleFactorsFinset.val, (card ∘ support) x = (card ∘ support) y → x = y
x : Perm α
hx : x ∈ Subgroup.centralizer {g}
c : { x // x ∈ g.cycleFactorsFinset }
⊢ ↑(((toPermHom g) ⟨x, ⋯⟩) c) = ↑(1 c)
|
50f9021ffb5b7a29
|
frattini_le_comap_frattini_of_surjective
|
Mathlib/GroupTheory/Frattini.lean
|
lemma frattini_le_comap_frattini_of_surjective (hφ : Function.Surjective φ) :
frattini G ≤ (frattini H).comap φ
|
G : Type u_1
H : Type u_2
inst✝¹ : Group G
inst✝ : Group H
φ : G →* H
hφ : Function.Surjective ⇑φ
⊢ ∀ i ∈ {H_1 | IsCoatom H_1}, ⨅ a ∈ {H | IsCoatom H}, a ≤ comap φ i
|
intro M hM
|
G : Type u_1
H : Type u_2
inst✝¹ : Group G
inst✝ : Group H
φ : G →* H
hφ : Function.Surjective ⇑φ
M : Subgroup H
hM : M ∈ {H_1 | IsCoatom H_1}
⊢ ⨅ a ∈ {H | IsCoatom H}, a ≤ comap φ M
|
07175ba0874095b4
|
int_prod_range_nonneg
|
Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean
|
theorem int_prod_range_nonneg (m : ℤ) (n : ℕ) (hn : Even n) :
0 ≤ ∏ k ∈ Finset.range n, (m - k)
|
case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ ∏ k ∈ Finset.range (n + 1 + (n + 1)), (m - ↑k)
|
rw [← two_mul, mul_add, mul_one, ← one_add_one_eq_two, ← add_assoc,
Finset.prod_range_succ, Finset.prod_range_succ, mul_assoc]
|
case intro.succ
m : ℤ
n : ℕ
ihn : 0 ≤ ∏ k ∈ Finset.range (2 * n), (m - ↑k)
⊢ 0 ≤ (∏ x ∈ Finset.range ((1 + 1) * n), (m - ↑x)) * ((m - ↑((1 + 1) * n)) * (m - ↑((1 + 1) * n + 1)))
|
845865b3fc92c079
|
SimpleGraph.isClique_map_finset_iff_of_nontrivial
|
Mathlib/Combinatorics/SimpleGraph/Clique.lean
|
theorem isClique_map_finset_iff_of_nontrivial (ht : t.Nontrivial) :
(G.map f).IsClique t ↔ ∃ (s : Finset α), G.IsClique s ∧ s.map f = t
|
case mpr
α : Type u_1
β : Type u_2
G : SimpleGraph α
f : α ↪ β
t : Finset β
ht : t.Nontrivial
⊢ (∃ s, G.IsClique ↑s ∧ map f s = t) → (SimpleGraph.map f G).IsClique ↑t
|
rintro ⟨s, hs, rfl⟩
|
case mpr.intro.intro
α : Type u_1
β : Type u_2
G : SimpleGraph α
f : α ↪ β
s : Finset α
hs : G.IsClique ↑s
ht : (map f s).Nontrivial
⊢ (SimpleGraph.map f G).IsClique ↑(map f s)
|
666a9cd7c64db5fe
|
min_assoc
|
Mathlib/Order/Defs/LinearOrder.lean
|
lemma min_assoc (a b c : α) : min (min a b) c = min a (min b c)
|
case h₃.h₂
α : Type u_1
inst✝ : LinearOrder α
a b c d : α
h₁ : d ≤ a
h₂ : d ≤ min b c
⊢ d ≤ c
|
apply le_trans h₂
|
case h₃.h₂
α : Type u_1
inst✝ : LinearOrder α
a b c d : α
h₁ : d ≤ a
h₂ : d ≤ min b c
⊢ min b c ≤ c
|
c74984dcee9d4eb0
|
MeasureTheory.unifIntegrable_subsingleton
|
Mathlib/MeasureTheory/Function/UniformIntegrable.lean
|
theorem unifIntegrable_subsingleton [Subsingleton ι] (hp_one : 1 ≤ p) (hp_top : p ≠ ∞)
{f : ι → α → β} (hf : ∀ i, MemLp (f i) p μ) : UnifIntegrable f p μ
|
case pos.intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
inst✝ : Subsingleton ι
hp_one : 1 ≤ p
hp_top : p ≠ ⊤
f : ι → α → β
hf : ∀ (i : ι), MemLp (f i) p μ
ε : ℝ
hε : 0 < ε
i : ι
δ : ℝ
hδpos : 0 < δ
hδ : ∀ (s : Set α), MeasurableSet s → μ s ≤ ENNReal.ofReal δ → eLpNorm (s.indicator (f i)) p μ ≤ ENNReal.ofReal ε
j : ι
s : Set α
hs : MeasurableSet s
hμs : μ s ≤ ENNReal.ofReal δ
⊢ eLpNorm (s.indicator (f j)) p μ ≤ ENNReal.ofReal ε
|
convert hδ s hs hμs
|
no goals
|
b4be6a9aa99176d2
|
MeasureTheory.Measure.tendsto_addHaar_inter_smul_one_of_density_one_aux
|
Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
|
theorem tendsto_addHaar_inter_smul_one_of_density_one_aux (s : Set E) (hs : MeasurableSet s)
(x : E) (h : Tendsto (fun r => μ (s ∩ closedBall x r) / μ (closedBall x r)) (𝓝[>] 0) (𝓝 1))
(t : Set E) (ht : MeasurableSet t) (h't : μ t ≠ 0) (h''t : μ t ≠ ∞) :
Tendsto (fun r : ℝ => μ (s ∩ ({x} + r • t)) / μ ({x} + r • t)) (𝓝[>] 0) (𝓝 1)
|
case e_a
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
s : Set E
hs : MeasurableSet s
x : E
h : Tendsto (fun r => μ (s ∩ closedBall x r) / μ (closedBall x r)) (𝓝[>] 0) (𝓝 1)
t : Set E
ht : MeasurableSet t
h't : μ t ≠ 0
h''t : μ t ≠ ⊤
u v : Set E
uzero : μ u ≠ 0
utop : μ u ≠ ⊤
vmeas : MeasurableSet v
⊢ μ u - μ (vᶜ ∩ u) = μ (v ∩ u)
|
rw [inter_comm _ u, inter_comm _ u, eq_comm]
|
case e_a
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
s : Set E
hs : MeasurableSet s
x : E
h : Tendsto (fun r => μ (s ∩ closedBall x r) / μ (closedBall x r)) (𝓝[>] 0) (𝓝 1)
t : Set E
ht : MeasurableSet t
h't : μ t ≠ 0
h''t : μ t ≠ ⊤
u v : Set E
uzero : μ u ≠ 0
utop : μ u ≠ ⊤
vmeas : MeasurableSet v
⊢ μ (u ∩ v) = μ u - μ (u ∩ vᶜ)
|
a092845449b3addf
|
Array.filterMap_flatMap
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem filterMap_flatMap {β γ} (l : Array α) (g : α → Array β) (f : β → Option γ) :
(l.flatMap g).filterMap f = l.flatMap fun a => (g a).filterMap f
|
α : Type u_1
β : Type u_2
γ : Type u_3
l : Array α
g : α → Array β
f : β → Option γ
⊢ filterMap f (flatMap g l) = flatMap (fun a => filterMap f (g a)) l
|
rcases l with ⟨l⟩
|
case mk
α : Type u_1
β : Type u_2
γ : Type u_3
g : α → Array β
f : β → Option γ
l : List α
⊢ filterMap f (flatMap g { toList := l }) = flatMap (fun a => filterMap f (g a)) { toList := l }
|
2e88c183d4eabbce
|
SimplexCategory.mkOfSucc_δ_gt
|
Mathlib/AlgebraicTopology/SimplexCategory/Basic.lean
|
/-- If `i + 1 > j`, `mkOfSucc i ≫ δ j` is the morphism `⦋1⦌ ⟶ ⦋n⦌` that
sends `0` and `1` to `i + 1` and `i + 2`, respectively. -/
lemma mkOfSucc_δ_gt {n : ℕ} {i : Fin n} {j : Fin (n + 2)}
(h : j < i.succ.castSucc) :
mkOfSucc i ≫ δ j = mkOfSucc i.succ
|
case a.h.h.h.«_@».Mathlib.AlgebraicTopology.SimplexCategory.Defs._hyg.913.«1».h
n : ℕ
i : Fin n
j : Fin (n + 2)
h : j < i.succ.castSucc
⊢ j ≤ ((Hom.toOrderHom (mkOfSucc i)) ((fun i => i) ⟨1, ⋯⟩)).castSucc
|
exact Nat.le_of_lt h
|
no goals
|
d2722ed2284db630
|
List.mk_mem_sym2
|
Mathlib/Data/List/Sym.lean
|
theorem mk_mem_sym2 {xs : List α} {a b : α} (ha : a ∈ xs) (hb : b ∈ xs) :
s(a, b) ∈ xs.sym2
|
case cons.inl.inl.h
α : Type u_1
b : α
xs : List α
ih : b ∈ xs → b ∈ xs → s(b, b) ∈ xs.sym2
⊢ s(b, b) = s(b, b)
|
rfl
|
no goals
|
2e917f6e418f8710
|
MeasureTheory.integral_exp_pos
|
Mathlib/MeasureTheory/Integral/Bochner.lean
|
lemma integral_exp_pos {μ : Measure α} {f : α → ℝ} [hμ : NeZero μ]
(hf : Integrable (fun x ↦ Real.exp (f x)) μ) :
0 < ∫ x, Real.exp (f x) ∂μ
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
hμ : NeZero μ
hf : Integrable (fun x => Real.exp (f x)) μ
⊢ 0 < μ (Function.support fun x => Real.exp (f x))
|
suffices (Function.support fun x ↦ Real.exp (f x)) = Set.univ by simp [this, hμ.out]
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
hμ : NeZero μ
hf : Integrable (fun x => Real.exp (f x)) μ
⊢ (Function.support fun x => Real.exp (f x)) = univ
|
2514b71f6019debc
|
MeasureTheory.SignedMeasure.findExistsOneDivLT_min
|
Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
|
theorem findExistsOneDivLT_min (hi : ¬s ≤[i] 0) {m : ℕ}
(hm : m < findExistsOneDivLT s i) : ¬ExistsOneDivLT s i m
|
α : Type u_1
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hi : ¬s ≤[i] 0
m : ℕ
hm : m < Nat.find ⋯
⊢ ¬MeasureTheory.SignedMeasure.ExistsOneDivLT s i m
|
exact Nat.find_min _ hm
|
no goals
|
c1ddab5c74d4c5c1
|
BitVec.getMsbD_concat
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem getMsbD_concat {i w : Nat} {b : Bool} {x : BitVec w} :
(x.concat b).getMsbD i = if i < w then x.getMsbD i else decide (i = w) && b
|
case neg
i w : Nat
b : Bool
x : BitVec w
h₀ : ¬i = w
h₁ : ¬i < w
a✝ : i < w + 1
⊢ b = false
|
omega
|
no goals
|
d05db0a79a970455
|
IsNilpotent.exp_add_of_commute
|
Mathlib/RingTheory/Nilpotent/Exp.lean
|
theorem exp_add_of_commute {a b : A} (h₁ : Commute a b) (h₂ : IsNilpotent a) (h₃ : IsNilpotent b) :
exp (a + b) = exp a * exp b
|
case intro.intro
A : Type u_1
inst✝¹ : Ring A
inst✝ : Algebra ℚ A
a b : A
h₁ : Commute a b
n₁ : ℕ
hn₁ : a ^ n₁ = 0
n₂ : ℕ
hn₂ : b ^ n₂ = 0
N : ℕ := n₁ ⊔ n₂
h₄ : a ^ (N + 1) = 0
h₅ : b ^ (N + 1) = 0
R2N : Finset ℕ := range (2 * N + 1)
hR2N : R2N = range (2 * N + 1)
RN : Finset ℕ := range (N + 1)
hRN : RN = range (N + 1)
s₁ :
∑ i ∈ R2N, (↑i !)⁻¹ • (a + b) ^ i =
∑ ij ∈ filter (fun ij => ij.1 + ij.2 ≤ 2 * N) (R2N ×ˢ R2N), ((↑ij.1!)⁻¹ * (↑ij.2!)⁻¹) • (a ^ ij.1 * b ^ ij.2)
z₁ : ∑ ij ∈ filter (fun ij => ¬ij.1 + ij.2 ≤ 2 * N) (R2N ×ˢ R2N), ((↑ij.1!)⁻¹ * (↑ij.2!)⁻¹) • (a ^ ij.1 * b ^ ij.2) = 0
split₁ :
∑ x ∈ filter (fun x => x.1 + x.2 ≤ 2 * N) (R2N ×ˢ R2N), ((↑x.1!)⁻¹ * (↑x.2!)⁻¹) • (a ^ x.1 * b ^ x.2) +
∑ x ∈ filter (fun x => ¬x.1 + x.2 ≤ 2 * N) (R2N ×ˢ R2N), ((↑x.1!)⁻¹ * (↑x.2!)⁻¹) • (a ^ x.1 * b ^ x.2) =
∑ x ∈ R2N ×ˢ R2N, ((↑x.1!)⁻¹ * (↑x.2!)⁻¹) • (a ^ x.1 * b ^ x.2)
⊢ ∑ i ∈ R2N, (↑i !)⁻¹ • (a + b) ^ i = (∑ i ∈ RN, (↑i !)⁻¹ • a ^ i) * ∑ i ∈ RN, (↑i !)⁻¹ • b ^ i
|
rw [z₁, add_zero] at split₁
|
case intro.intro
A : Type u_1
inst✝¹ : Ring A
inst✝ : Algebra ℚ A
a b : A
h₁ : Commute a b
n₁ : ℕ
hn₁ : a ^ n₁ = 0
n₂ : ℕ
hn₂ : b ^ n₂ = 0
N : ℕ := n₁ ⊔ n₂
h₄ : a ^ (N + 1) = 0
h₅ : b ^ (N + 1) = 0
R2N : Finset ℕ := range (2 * N + 1)
hR2N : R2N = range (2 * N + 1)
RN : Finset ℕ := range (N + 1)
hRN : RN = range (N + 1)
s₁ :
∑ i ∈ R2N, (↑i !)⁻¹ • (a + b) ^ i =
∑ ij ∈ filter (fun ij => ij.1 + ij.2 ≤ 2 * N) (R2N ×ˢ R2N), ((↑ij.1!)⁻¹ * (↑ij.2!)⁻¹) • (a ^ ij.1 * b ^ ij.2)
z₁ : ∑ ij ∈ filter (fun ij => ¬ij.1 + ij.2 ≤ 2 * N) (R2N ×ˢ R2N), ((↑ij.1!)⁻¹ * (↑ij.2!)⁻¹) • (a ^ ij.1 * b ^ ij.2) = 0
split₁ :
∑ x ∈ filter (fun x => x.1 + x.2 ≤ 2 * N) (R2N ×ˢ R2N), ((↑x.1!)⁻¹ * (↑x.2!)⁻¹) • (a ^ x.1 * b ^ x.2) =
∑ x ∈ R2N ×ˢ R2N, ((↑x.1!)⁻¹ * (↑x.2!)⁻¹) • (a ^ x.1 * b ^ x.2)
⊢ ∑ i ∈ R2N, (↑i !)⁻¹ • (a + b) ^ i = (∑ i ∈ RN, (↑i !)⁻¹ • a ^ i) * ∑ i ∈ RN, (↑i !)⁻¹ • b ^ i
|
925becc4d11e37f5
|
Matrix.vecMul_surjective_iff_isUnit
|
Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
|
theorem vecMul_surjective_iff_isUnit {A : Matrix m m R} :
Function.Surjective A.vecMul ↔ IsUnit A
|
m : Type u
inst✝² : DecidableEq m
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Fintype m
A : Matrix m m R
⊢ (Function.Surjective fun v => v ᵥ* A) ↔ IsUnit A
|
rw [vecMul_surjective_iff_exists_left_inverse, exists_left_inverse_iff_isUnit]
|
no goals
|
68d65ce87950505f
|
ProbabilityTheory.Kernel.measurable_kernel_prod_mk_left'
|
Mathlib/Probability/Kernel/MeasurableLIntegral.lean
|
theorem measurable_kernel_prod_mk_left' [IsSFiniteKernel η] {s : Set (β × γ)} (hs : MeasurableSet s)
(a : α) : Measurable fun b => η (a, b) (Prod.mk b ⁻¹' s)
|
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
s : Set (β × γ)
hs : MeasurableSet s
a : α
this : ∀ (b : β), Prod.mk b ⁻¹' s = {c | ((a, b), c) ∈ {p | (p.1.2, p.2) ∈ s}}
⊢ Measurable fun b => (η (a, b)) (Prod.mk b ⁻¹' s)
|
simp_rw [this]
|
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
s : Set (β × γ)
hs : MeasurableSet s
a : α
this : ∀ (b : β), Prod.mk b ⁻¹' s = {c | ((a, b), c) ∈ {p | (p.1.2, p.2) ∈ s}}
⊢ Measurable fun b => (η (a, b)) {c | ((a, b), c) ∈ {p | (p.1.2, p.2) ∈ s}}
|
294fa3b0e5a4ba28
|
Complex.sin_pi_div_two
|
Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
|
theorem sin_pi_div_two : sin (π / 2) = 1 :=
calc
sin (π / 2) = Real.sin (π / 2)
|
⊢ sin (↑π / 2) = sin ↑(π / 2)
|
simp
|
no goals
|
13ffcbe8ac348cd9
|
RingQuot.mkAlgHom_rel
|
Mathlib/Algebra/RingQuot.lean
|
theorem mkAlgHom_rel {s : A → A → Prop} {x y : A} (w : s x y) :
mkAlgHom S s x = mkAlgHom S s y
|
S : Type uS
inst✝² : CommSemiring S
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
s : A → A → Prop
x y : A
w : s x y
⊢ (mkAlgHom S s) x = (mkAlgHom S s) y
|
simp [mkAlgHom_def, mkRingHom_def, Quot.sound (Rel.of w)]
|
no goals
|
19211ff2cf6e7d06
|
MeasureTheory.condExp_congr_ae
|
Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
|
theorem condExp_congr_ae (h : f =ᵐ[μ] g) : μ[f|m] =ᵐ[μ] μ[g|m]
|
case pos
α : Type u_1
E : Type u_3
m m₀ : MeasurableSpace α
μ : Measure α
f g : α → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
h : f =ᶠ[ae μ] g
hm : m ≤ m₀
⊢ μ[f|m] =ᶠ[ae μ] μ[g|m]
|
by_cases hμm : SigmaFinite (μ.trim hm)
|
case pos
α : Type u_1
E : Type u_3
m m₀ : MeasurableSpace α
μ : Measure α
f g : α → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
h : f =ᶠ[ae μ] g
hm : m ≤ m₀
hμm : SigmaFinite (μ.trim hm)
⊢ μ[f|m] =ᶠ[ae μ] μ[g|m]
case neg
α : Type u_1
E : Type u_3
m m₀ : MeasurableSpace α
μ : Measure α
f g : α → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
h : f =ᶠ[ae μ] g
hm : m ≤ m₀
hμm : ¬SigmaFinite (μ.trim hm)
⊢ μ[f|m] =ᶠ[ae μ] μ[g|m]
|
e0e9f7f4839f4674
|
AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq
|
Mathlib/AlgebraicTopology/DoldKan/Faces.lean
|
theorem comp_Hσ_eq {Y : C} {n a q : ℕ} {φ : Y ⟶ X _⦋n + 1⦌} (v : HigherFacesVanish q φ)
(hnaq : n = a + q) :
φ ≫ (Hσ q).f (n + 1) =
-φ ≫ X.δ ⟨a + 1, Nat.succ_lt_succ (Nat.lt_succ_iff.mpr (Nat.le.intro hnaq.symm))⟩ ≫
X.σ ⟨a, Nat.lt_succ_iff.mpr (Nat.le.intro hnaq.symm)⟩
|
case a
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n a q : ℕ
φ : Y ⟶ X _⦋n + 1⦌
v : HigherFacesVanish q φ
hnaq : n = a + q
hnaq_shift : ∀ (d : ℕ), n + d = a + d + q
simplif : ∀ (a b c d e f : Y ⟶ X _⦋n + 1⦌), b = f → d + e = 0 → c + a = 0 → a + b + (c + d + e) = f
⊢ Odd (a + (a + 1))
|
exact ⟨a, by omega⟩
|
no goals
|
964779d74b03b839
|
ZMod.isSquare_neg_one_iff'
|
Mathlib/NumberTheory/SumTwoSquares.lean
|
theorem ZMod.isSquare_neg_one_iff' {n : ℕ} (hn : Squarefree n) :
IsSquare (-1 : ZMod n) ↔ ∀ {q : ℕ}, q ∣ n → q % 4 ≠ 3
|
n : ℕ
hn : Squarefree n
help : ∀ (a b : ZMod 4), a ≠ 3 → b ≠ 3 → a * b ≠ 3
⊢ IsSquare (-1) ↔ ∀ {q : ℕ}, q ∣ n → q % 4 ≠ 3
|
rw [ZMod.isSquare_neg_one_iff hn]
|
n : ℕ
hn : Squarefree n
help : ∀ (a b : ZMod 4), a ≠ 3 → b ≠ 3 → a * b ≠ 3
⊢ (∀ {q : ℕ}, Nat.Prime q → q ∣ n → q % 4 ≠ 3) ↔ ∀ {q : ℕ}, q ∣ n → q % 4 ≠ 3
|
2086e5554fd0b596
|
Set.iUnion_prod_of_monotone
|
Mathlib/Data/Set/Lattice.lean
|
theorem iUnion_prod_of_monotone [SemilatticeSup α] {s : α → Set β} {t : α → Set γ} (hs : Monotone s)
(ht : Monotone t) : ⋃ x, s x ×ˢ t x = (⋃ x, s x) ×ˢ ⋃ x, t x
|
case h.mk.left
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : SemilatticeSup α
s : α → Set β
t : α → Set γ
hs : Monotone s
ht : Monotone t
z : β
w : γ
x : α
hz : z ∈ s x
hw : w ∈ t x
⊢ (∃ i, z ∈ s i) ∧ ∃ i, w ∈ t i
|
exact ⟨⟨x, hz⟩, x, hw⟩
|
no goals
|
6c8a94814fe2d781
|
Option.all_guard
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
|
theorem all_guard (p : α → Prop) [DecidablePred p] (a : α) :
Option.all q (guard p a) = (!p a || q a)
|
α : Type u_1
q : α → Bool
p : α → Prop
inst✝ : DecidablePred p
a : α
⊢ Option.all q (guard p a) = (!decide (p a) || q a)
|
simp only [guard]
|
α : Type u_1
q : α → Bool
p : α → Prop
inst✝ : DecidablePred p
a : α
⊢ Option.all q (if p a then some a else none) = (!decide (p a) || q a)
|
9b1dd0ac49b2d23d
|
CategoryTheory.Localization.Monoidal.rightUnitor_hom_app
|
Mathlib/CategoryTheory/Localization/Monoidal.lean
|
lemma rightUnitor_hom_app (X : C) :
(ρ_ ((L').obj X)).hom =
(L').obj X ◁ (ε' L W ε).inv ≫ (μ _ _ _ _ _).hom ≫
(L').map (ρ_ X).hom
|
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝² : MonoidalCategory C
inst✝¹ : W.IsMonoidal
inst✝ : L.IsLocalization W
unit : D
ε : L.obj (𝟙_ C) ≅ unit
X : C
⊢ (ρ_ (L'.obj X)).hom = L'.obj X ◁ (ε' L W ε).inv ≫ (μ L W ε X (𝟙_ C)).hom ≫ L'.map (ρ_ X).hom
|
dsimp [monoidalCategoryStruct, rightUnitor]
|
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝² : MonoidalCategory C
inst✝¹ : W.IsMonoidal
inst✝ : L.IsLocalization W
unit : D
ε : L.obj (𝟙_ C) ≅ unit
X : C
⊢ ((tensorBifunctor L W ε).obj (L'.obj X)).map ε.inv ≫
(liftNatTrans L' W (tensorRight (𝟙_ C) ⋙ L') L' ((tensorBifunctor L W ε).flip.obj (L'.obj (𝟙_ C)))
(𝟭 (LocalizedMonoidal L W ε)) (whiskerRight (rightUnitorNatIso C).hom L' ≫ L.leftUnitor.hom)).app
(L'.obj X) =
((tensorBifunctor L W ε).obj (L'.obj X)).map (ε' L W ε).inv ≫ (μ L W ε X (𝟙_ C)).hom ≫ L'.map (ρ_ X).hom
|
57a5c56b0a9e267c
|
Topology.IsScott.scott_eq_upper_of_completeLinearOrder
|
Mathlib/Topology/Order/ScottTopology.lean
|
lemma scott_eq_upper_of_completeLinearOrder : scott α univ = upper α
|
case a.h.a
α : Type u_1
inst✝ : CompleteLinearOrder α
this✝ : TopologicalSpace α := upper α
U : Set α
this : TopologicalSpace α := scott α univ
⊢ IsOpen U ↔ U = univ ∨ ∃ a, (Iic a)ᶜ = U
|
rw [@isOpen_iff_Iic_compl_or_univ _ _ (scott α univ) ({ topology_eq_scott := rfl }) U]
|
no goals
|
feb5d9ba88e61dd3
|
Submodule.baseChange_span
|
Mathlib/LinearAlgebra/TensorProduct/Tower.lean
|
@[simp]
lemma baseChange_span (s : Set M) :
(span R s).baseChange A = span A (TensorProduct.mk R A M 1 '' s)
|
case intro.intro
R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set M
m : M
hm : m ∈ span R s
⊢ ((TensorProduct.mk R A M) 1) m ∈ ↑(span A (⇑((TensorProduct.mk R A M) 1) '' s))
|
apply span_induction (p := fun m' _ ↦ (1 : A) ⊗ₜ[R] m' ∈ span A (TensorProduct.mk R A M 1 '' s))
(hx := hm)
|
case intro.intro.mem
R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set M
m : M
hm : m ∈ span R s
⊢ ∀ (x : M) (h : x ∈ s), (fun m' x => 1 ⊗ₜ[R] m' ∈ span A (⇑((TensorProduct.mk R A M) 1) '' s)) x ⋯
case intro.intro.zero
R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set M
m : M
hm : m ∈ span R s
⊢ 1 ⊗ₜ[R] 0 ∈ span A (⇑((TensorProduct.mk R A M) 1) '' s)
case intro.intro.add
R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set M
m : M
hm : m ∈ span R s
⊢ ∀ (x y : M) (hx : x ∈ span R s) (hy : y ∈ span R s),
(fun m' x => 1 ⊗ₜ[R] m' ∈ span A (⇑((TensorProduct.mk R A M) 1) '' s)) x hx →
(fun m' x => 1 ⊗ₜ[R] m' ∈ span A (⇑((TensorProduct.mk R A M) 1) '' s)) y hy →
(fun m' x => 1 ⊗ₜ[R] m' ∈ span A (⇑((TensorProduct.mk R A M) 1) '' s)) (x + y) ⋯
case intro.intro.smul
R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set M
m : M
hm : m ∈ span R s
⊢ ∀ (a : R) (x : M) (hx : x ∈ span R s),
(fun m' x => 1 ⊗ₜ[R] m' ∈ span A (⇑((TensorProduct.mk R A M) 1) '' s)) x hx →
(fun m' x => 1 ⊗ₜ[R] m' ∈ span A (⇑((TensorProduct.mk R A M) 1) '' s)) (a • x) ⋯
|
dcaedd5200da7dda
|
LinearOrderedCommGroupWithZero.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete_of_ne_zero
|
Mathlib/GroupTheory/ArchimedeanDensely.lean
|
lemma LinearOrderedCommGroupWithZero.wellFoundedOn_setOf_le_lt_iff_nonempty_discrete_of_ne_zero
{G₀ : Type*} [LinearOrderedCommGroupWithZero G₀] [Nontrivial G₀ˣ] {g : G₀} (hg : g ≠ 0) :
Set.WellFoundedOn {x : G₀ | g ≤ x} (· < ·) ↔ Nonempty (G₀ ≃*o ℤₘ₀)
|
case refine_1
G₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero G₀
inst✝ : Nontrivial G₀ˣ
g : G₀
hg : g ≠ 0
this : ({x | g ≤ x}.WellFoundedOn fun x1 x2 => x1 < x2) ↔ {x | Units.mk0 g hg ≤ x}.WellFoundedOn fun x1 x2 => x1 < x2
f : G₀ˣ ≃*o Multiplicative ℤ
⊢ G₀ ≃* ℤₘ₀
|
exact WithZero.withZeroUnitsEquiv.symm.trans f.withZero
|
no goals
|
dd175bef7c0a0720
|
WeierstrassCurve.exists_variableChange_of_char_ne_two_or_three
|
Mathlib/AlgebraicGeometry/EllipticCurve/IsomOfJ.lean
|
private lemma exists_variableChange_of_char_ne_two_or_three
{p : ℕ} [CharP F p] (hchar2 : p ≠ 2) (hchar3 : p ≠ 3) (heq : E.j = E'.j) :
∃ C : VariableChange F, E.variableChange C = E'
|
case pos.intro
F : Type u_1
inst✝⁶ : Field F
inst✝⁵ : IsSepClosed F
E✝ E'✝ : WeierstrassCurve F
inst✝⁴ : E✝.IsElliptic
inst✝³ : E'✝.IsElliptic
p : ℕ
inst✝² : CharP F p
hchar2 : 2 ≠ 0
hchar3 : 3 ≠ 0
this✝³ : NeZero 2
this✝² : NeZero 4
this✝¹ : NeZero 6
this✝ : Invertible 2 := invertibleOfNonzero hchar2
this : Invertible 3 := invertibleOfNonzero hchar3
E : WeierstrassCurve F
inst✝¹ : E.IsElliptic
h✝¹ : E.IsShortNF
E' : WeierstrassCurve F
inst✝ : E'.IsElliptic
h✝ : E'.IsShortNF
heq : E.a₄ ^ 3 * E'.a₆ ^ 2 = E'.a₄ ^ 3 * E.a₆ ^ 2
ha₄✝ : ¬E.a₄ = 0
ha₆ : E.a₆ = 0
ha₄ : E.a₄ ≠ 0
ha₆' : E'.a₆ = 0
ha₄' : E'.a₄ ≠ 0
u : F
hu : u ^ 4 = E.a₄ / E'.a₄
⊢ ∃ C, E.variableChange C = E'
|
have hu0 : u ≠ 0 := by
rw [← pow_ne_zero_iff four_ne_zero, hu, div_ne_zero_iff]
exact ⟨ha₄, ha₄'⟩
|
case pos.intro
F : Type u_1
inst✝⁶ : Field F
inst✝⁵ : IsSepClosed F
E✝ E'✝ : WeierstrassCurve F
inst✝⁴ : E✝.IsElliptic
inst✝³ : E'✝.IsElliptic
p : ℕ
inst✝² : CharP F p
hchar2 : 2 ≠ 0
hchar3 : 3 ≠ 0
this✝³ : NeZero 2
this✝² : NeZero 4
this✝¹ : NeZero 6
this✝ : Invertible 2 := invertibleOfNonzero hchar2
this : Invertible 3 := invertibleOfNonzero hchar3
E : WeierstrassCurve F
inst✝¹ : E.IsElliptic
h✝¹ : E.IsShortNF
E' : WeierstrassCurve F
inst✝ : E'.IsElliptic
h✝ : E'.IsShortNF
heq : E.a₄ ^ 3 * E'.a₆ ^ 2 = E'.a₄ ^ 3 * E.a₆ ^ 2
ha₄✝ : ¬E.a₄ = 0
ha₆ : E.a₆ = 0
ha₄ : E.a₄ ≠ 0
ha₆' : E'.a₆ = 0
ha₄' : E'.a₄ ≠ 0
u : F
hu : u ^ 4 = E.a₄ / E'.a₄
hu0 : u ≠ 0
⊢ ∃ C, E.variableChange C = E'
|
5599f8482dc6841e
|
ClassGroup.normBound_pos
|
Mathlib/NumberTheory/ClassNumber/Finite.lean
|
theorem normBound_pos : 0 < normBound abv bS
|
case intro.a.a
R : Type u_1
S : Type u_2
inst✝⁵ : EuclideanDomain R
inst✝⁴ : CommRing S
inst✝³ : IsDomain S
inst✝² : Algebra R S
abv : AbsoluteValue R ℤ
ι : Type u_5
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
bS : Basis ι R S
h : ∀ (i j k : ι), (Algebra.leftMulMatrix bS) (bS i) j k = 0
i j k : ι
⊢ (Algebra.leftMulMatrix bS) (bS i) j k = 0 j k
|
simp [h, DMatrix.zero_apply]
|
no goals
|
963a57f6107a0e82
|
Set.chainHeight_union_eq
|
Mathlib/Order/Height.lean
|
theorem chainHeight_union_eq (s t : Set α) (H : ∀ a ∈ s, ∀ b ∈ t, a < b) :
(s ∪ t).chainHeight = s.chainHeight + t.chainHeight
|
α : Type u_1
inst✝ : Preorder α
s t : Set α
H : ∀ a ∈ s, ∀ b ∈ t, a < b
l : List α
hl : l ∈ s.subchain
l' : List α
hl' : l' ∈ t.subchain
h : t.chainHeight = ↑l'.length
⊢ l.length + l'.length ≤ (l ++ l').length + 0
|
simp
|
no goals
|
5b4afeceba92ad8b
|
MvPolynomial.comp_aeval
|
Mathlib/Algebra/MvPolynomial/Eval.lean
|
theorem comp_aeval {B : Type*} [CommSemiring B] [Algebra R B] (φ : S₁ →ₐ[R] B) :
φ.comp (aeval f) = aeval fun i => φ (f i)
|
R : Type u
S₁ : Type v
σ : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : CommSemiring S₁
inst✝² : Algebra R S₁
f : σ → S₁
B : Type u_2
inst✝¹ : CommSemiring B
inst✝ : Algebra R B
φ : S₁ →ₐ[R] B
⊢ φ.comp (aeval f) = aeval fun i => φ (f i)
|
ext i
|
case hf
R : Type u
S₁ : Type v
σ : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : CommSemiring S₁
inst✝² : Algebra R S₁
f : σ → S₁
B : Type u_2
inst✝¹ : CommSemiring B
inst✝ : Algebra R B
φ : S₁ →ₐ[R] B
i : σ
⊢ (φ.comp (aeval f)) (X i) = (aeval fun i => φ (f i)) (X i)
|
f133e2b6967db436
|
IsCyclotomicExtension.Rat.Three.eq_one_or_neg_one_of_unit_of_congruent
|
Mathlib/NumberTheory/Cyclotomic/Three.lean
|
theorem eq_one_or_neg_one_of_unit_of_congruent
[NumberField K] [IsCyclotomicExtension {3} ℚ K] (hcong : ∃ n : ℤ, λ ^ 2 ∣ (u - n : 𝓞 K)) :
u = 1 ∨ u = -1
|
K : Type u_1
inst✝² : Field K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
u : (𝓞 K)ˣ
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
hcong : ∃ n, 3 ∣ ↑u - ↑n
⊢ u = 1 ∨ u = -1
|
have hζ := IsCyclotomicExtension.zeta_spec 3 ℚ K
|
K : Type u_1
inst✝² : Field K
ζ : K
hζ✝ : IsPrimitiveRoot ζ ↑3
u : (𝓞 K)ˣ
inst✝¹ : NumberField K
inst✝ : IsCyclotomicExtension {3} ℚ K
hcong : ∃ n, 3 ∣ ↑u - ↑n
hζ : IsPrimitiveRoot (zeta 3 ℚ K) ↑3
⊢ u = 1 ∨ u = -1
|
220139a45fa38b2d
|
AddMonoidAlgebra.Monic.mul
|
Mathlib/Algebra/MonoidAlgebra/Degree.lean
|
lemma Monic.mul
(hD : D.Injective) (hadd : ∀ a1 a2, D (a1 + a2) = D a1 + D a2)
(hp : p.Monic D) (hq : q.Monic D) : (p * q).Monic D
|
R : Type u_1
A : Type u_3
B : Type u_5
inst✝⁶ : Semiring R
inst✝⁵ : LinearOrder B
inst✝⁴ : OrderBot B
p q : R[A]
D : A → B
inst✝³ : AddZeroClass A
inst✝² : Add B
inst✝¹ : AddLeftStrictMono B
inst✝ : AddRightStrictMono B
hD : Function.Injective D
hadd : ∀ (a1 a2 : A), D (a1 + a2) = D a1 + D a2
hp : Monic D p
hq : Monic D q
⊢ leadingCoeff D p = 1
|
exact hp
|
no goals
|
17d05e24584ac857
|
Finset.small_alternating_pow_of_small_tripling
|
Mathlib/Combinatorics/Additive/SmallTripling.lean
|
/-- If `A` has small tripling, say with constant `K`, then `A` has small alternating powers, in the
sense that `|A^±1 * ... * A^±1|` is at most `|A|` times a constant exponential in the number of
terms in the product.
When `A` is symmetric (`A⁻¹ = A`), the base of the exponential can be lowered from `K ^ 3` to `K`,
where `K` is the tripling constant. See `Finset.small_pow_of_small_tripling`. -/
@[to_additive
"If `A` has small tripling, say with constant `K`, then `A` has small alternating powers, in the
sense that `|±A ± ... ± A|` is at most `|A|` times a constant exponential in the number of
terms in the product.
When `A` is symmetric (`-A = A`), the base of the exponential can be lowered from `K ^ 3` to `K`,
where `K` is the tripling constant. See `Finset.small_nsmul_of_small_tripling`."]
lemma small_alternating_pow_of_small_tripling (hm : 3 ≤ m) (hA : #(A ^ 3) ≤ K * #A) (ε : Fin m → ℤ)
(hε : ∀ i, |ε i| = 1) :
#((finRange m).map fun i ↦ A ^ ε i).prod ≤ K ^ (3 * (m - 2)) * #A
|
case inr
G : Type u_1
inst✝¹ : DecidableEq G
inst✝ : Group G
A : Finset G
K : ℝ
m : ℕ
hm : 3 ≤ m
hA : ↑(#(A ^ 3)) ≤ K * ↑(#A)
ε : Fin m → ℤ
hε : ∀ (i : Fin m), |ε i| = 1
hm₀ : m ≠ 0
hε₀ : ∀ (i : Fin m), ε i ≠ 0
hA₀ : A.Nonempty
hK₁ : 1 ≤ K
δ : Fin 3 → ℤ
hδ : ∀ (i : Fin 3), |δ i| = 1
⊢ ↑(#(A ^ δ 0 * A ^ δ 1 * A ^ δ 2)) ≤ K ^ 3 * ↑(#A)
|
simp only [zero_le_one, abs_eq, Int.reduceNeg, forall_iff_succ, isValue, succ_zero_eq_one,
succ_one_eq_two, IsEmpty.forall_iff, and_true] at hδ
|
case inr
G : Type u_1
inst✝¹ : DecidableEq G
inst✝ : Group G
A : Finset G
K : ℝ
m : ℕ
hm : 3 ≤ m
hA : ↑(#(A ^ 3)) ≤ K * ↑(#A)
ε : Fin m → ℤ
hε : ∀ (i : Fin m), |ε i| = 1
hm₀ : m ≠ 0
hε₀ : ∀ (i : Fin m), ε i ≠ 0
hA₀ : A.Nonempty
hK₁ : 1 ≤ K
δ : Fin 3 → ℤ
hδ : (δ 0 = 1 ∨ δ 0 = -1) ∧ (δ 1 = 1 ∨ δ 1 = -1) ∧ (δ 2 = 1 ∨ δ 2 = -1)
⊢ ↑(#(A ^ δ 0 * A ^ δ 1 * A ^ δ 2)) ≤ K ^ 3 * ↑(#A)
|
647fdb3ae1591fd5
|
PFunctor.M.ext_aux
|
Mathlib/Data/PFunctor/Univariate/M.lean
|
theorem ext_aux [Inhabited (M F)] [DecidableEq F.A] {n : ℕ} (x y z : M F) (hx : Agree' n z x)
(hy : Agree' n z y) (hrec : ∀ ps : Path F, n = ps.length → iselect ps x = iselect ps y) :
x.approx (n + 1) = y.approx (n + 1)
|
case succ.step.step.f.f
F : PFunctor.{u}
inst✝¹ : Inhabited F.M
inst✝ : DecidableEq F.A
n : ℕ
n_ih :
∀ (x y z : F.M),
Agree' n z x →
Agree' n z y →
(∀ (ps : Path F), n = length ps → iselect ps x = iselect ps y) → x.approx (n + 1) = y.approx (n + 1)
z : F.M
a✝⁹ : F.A
x✝¹ y✝¹ : F.B a✝⁹ → F.M
a✝⁸ : ∀ (i : F.B a✝⁹), Agree' n (x✝¹ i) (y✝¹ i)
a✝⁷ : z = M.mk ⟨a✝⁹, x✝¹⟩
a✝⁶ : F.A
x✝ y✝ : F.B a✝⁶ → F.M
a✝⁵ : ∀ (i : F.B a✝⁶), Agree' n (x✝ i) (y✝ i)
a✝⁴ : z = M.mk ⟨a✝⁶, x✝⟩
a✝³ : F.A
f✝¹ : F.B a✝³ → F.M
a✝² : M.mk ⟨a✝³, f✝¹⟩ = M.mk ⟨a✝⁹, y✝¹⟩
a✝¹ : F.A
f✝ : F.B a✝¹ → F.M
a✝ : M.mk ⟨a✝¹, f✝⟩ = M.mk ⟨a✝⁶, y✝⟩
hrec : ∀ (ps : Path F), n + 1 = length ps → iselect ps (M.mk ⟨a✝³, f✝¹⟩) = iselect ps (M.mk ⟨a✝¹, f✝⟩)
⊢ (M.mk ⟨a✝³, f✝¹⟩).approx (n + 1 + 1) = (M.mk ⟨a✝¹, f✝⟩).approx (n + 1 + 1)
|
subst z
|
case succ.step.step.f.f
F : PFunctor.{u}
inst✝¹ : Inhabited F.M
inst✝ : DecidableEq F.A
n : ℕ
n_ih :
∀ (x y z : F.M),
Agree' n z x →
Agree' n z y →
(∀ (ps : Path F), n = length ps → iselect ps x = iselect ps y) → x.approx (n + 1) = y.approx (n + 1)
a✝⁸ : F.A
x✝¹ y✝¹ : F.B a✝⁸ → F.M
a✝⁷ : ∀ (i : F.B a✝⁸), Agree' n (x✝¹ i) (y✝¹ i)
a✝⁶ : F.A
x✝ y✝ : F.B a✝⁶ → F.M
a✝⁵ : ∀ (i : F.B a✝⁶), Agree' n (x✝ i) (y✝ i)
a✝⁴ : F.A
f✝¹ : F.B a✝⁴ → F.M
a✝³ : M.mk ⟨a✝⁴, f✝¹⟩ = M.mk ⟨a✝⁸, y✝¹⟩
a✝² : F.A
f✝ : F.B a✝² → F.M
a✝¹ : M.mk ⟨a✝², f✝⟩ = M.mk ⟨a✝⁶, y✝⟩
hrec : ∀ (ps : Path F), n + 1 = length ps → iselect ps (M.mk ⟨a✝⁴, f✝¹⟩) = iselect ps (M.mk ⟨a✝², f✝⟩)
a✝ : M.mk ⟨a✝⁸, x✝¹⟩ = M.mk ⟨a✝⁶, x✝⟩
⊢ (M.mk ⟨a✝⁴, f✝¹⟩).approx (n + 1 + 1) = (M.mk ⟨a✝², f✝⟩).approx (n + 1 + 1)
|
4a16a3c615b0519f
|
CategoryTheory.unit_mateEquiv
|
Mathlib/CategoryTheory/Adjunction/Mates.lean
|
theorem unit_mateEquiv (α : TwoSquare G L₁ L₂ H) (c : C) :
G.map (adj₁.unit.app c) ≫ (mateEquiv adj₁ adj₂ α).app _ =
adj₂.unit.app _ ≫ R₂.map (α.app _)
|
C : Type u₁
D : Type u₂
E : Type u₃
F : Type u₄
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
inst✝ : Category.{v₄, u₄} F
G : C ⥤ E
H : D ⥤ F
L₁ : C ⥤ D
R₁ : D ⥤ C
L₂ : E ⥤ F
R₂ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
α : TwoSquare G L₁ L₂ H
c : C
⊢ adj₂.unit.app (G.obj c) ≫
R₂.map (α.app c ≫ (L₁ ⋙ H).map (adj₁.unit.app c)) ≫ R₂.map (H.map (adj₁.counit.app (L₁.obj c))) =
adj₂.unit.app (G.obj c) ≫ R₂.map (α.app c)
|
rw [R₂.map_comp]
|
C : Type u₁
D : Type u₂
E : Type u₃
F : Type u₄
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
inst✝ : Category.{v₄, u₄} F
G : C ⥤ E
H : D ⥤ F
L₁ : C ⥤ D
R₁ : D ⥤ C
L₂ : E ⥤ F
R₂ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
α : TwoSquare G L₁ L₂ H
c : C
⊢ adj₂.unit.app (G.obj c) ≫
(R₂.map (α.app c) ≫ R₂.map ((L₁ ⋙ H).map (adj₁.unit.app c))) ≫ R₂.map (H.map (adj₁.counit.app (L₁.obj c))) =
adj₂.unit.app (G.obj c) ≫ R₂.map (α.app c)
|
75158210b8e0ab27
|
PowerSeries.coeff_succ_X_mul
|
Mathlib/RingTheory/PowerSeries/Basic.lean
|
theorem coeff_succ_X_mul (n : ℕ) (φ : R⟦X⟧) : coeff R (n + 1) (X * φ) = coeff R n φ
|
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (coeff R (n + 1)) (X * φ) = (coeff R n) φ
|
simp only [coeff, Finsupp.single_add, add_comm n 1]
|
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () 1 + single () n)) (X * φ) = (MvPowerSeries.coeff R (single () n)) φ
|
98d9de423b9dd68f
|
Algebra.norm_eq_zero_iff
|
Mathlib/RingTheory/Norm/Basic.lean
|
theorem norm_eq_zero_iff [IsDomain R] [IsDomain S] [Module.Free R S] [Module.Finite R S] {x : S} :
norm R x = 0 ↔ x = 0
|
case mp.intro.intro.refine_2
R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : Ring S
inst✝⁴ : Algebra R S
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : Free R S
inst✝ : Module.Finite R S
x : S
b : Basis (Free.ChooseBasisIndex R S) R S := Free.chooseBasis R S
decEq : DecidableEq (Free.ChooseBasisIndex R S) := Classical.decEq (Free.ChooseBasisIndex R S)
v : Free.ChooseBasisIndex R S → R
v_ne : v ≠ 0
hv : ⇑(b.repr (x * ∑ i : Free.ChooseBasisIndex R S, v i • b i)) = 0
⊢ ∑ i : Free.ChooseBasisIndex R S, v i • b i ≠ 0
|
contrapose! v_ne with sum_eq
|
case mp.intro.intro.refine_2
R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : Ring S
inst✝⁴ : Algebra R S
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : Free R S
inst✝ : Module.Finite R S
x : S
b : Basis (Free.ChooseBasisIndex R S) R S := Free.chooseBasis R S
decEq : DecidableEq (Free.ChooseBasisIndex R S) := Classical.decEq (Free.ChooseBasisIndex R S)
v : Free.ChooseBasisIndex R S → R
hv : ⇑(b.repr (x * ∑ i : Free.ChooseBasisIndex R S, v i • b i)) = 0
sum_eq : ∑ i : Free.ChooseBasisIndex R S, v i • b i = 0
⊢ v = 0
|
b22c4acf9f81550f
|
Monotone.tendsto_le_alternating_series
|
Mathlib/Analysis/SpecificLimits/Normed.lean
|
theorem Monotone.tendsto_le_alternating_series
(hfl : Tendsto (fun n ↦ ∑ i ∈ range n, (-1) ^ i * f i) atTop (𝓝 l))
(hfm : Monotone f) (k : ℕ) : l ≤ ∑ i ∈ range (2 * k), (-1) ^ i * f i
|
E : Type u_2
inst✝² : OrderedRing E
inst✝¹ : TopologicalSpace E
inst✝ : OrderClosedTopology E
l : E
f : ℕ → E
hfl : Tendsto (fun n => ∑ i ∈ Finset.range n, (-1) ^ i * f i) atTop (𝓝 l)
hfm : Monotone f
k : ℕ
ha : Antitone fun n => ∑ i ∈ Finset.range (2 * n), (-1) ^ i * f i
⊢ l ≤ ∑ i ∈ Finset.range (2 * k), (-1) ^ i * f i
|
exact ha.le_of_tendsto (hfl.comp (tendsto_atTop_mono (fun n ↦ by dsimp; omega) tendsto_id)) _
|
no goals
|
8204a47cf4df7c65
|
Ordinal.bsup_comp
|
Mathlib/SetTheory/Ordinal/Arithmetic.lean
|
theorem bsup_comp {o o' : Ordinal.{max u v}} {f : ∀ a < o, Ordinal.{max u v w}}
(hf : ∀ {i j} (hi) (hj), i ≤ j → f i hi ≤ f j hj) {g : ∀ a < o', Ordinal.{max u v}}
(hg : blsub.{_, u} o' g = o) :
(bsup.{_, w} o' fun a ha => f (g a ha) (by rw [← hg]; apply lt_blsub)) = bsup.{_, w} o f
|
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
a : Ordinal.{max u v}
ha : a < o'
⊢ g a ha < o
|
rw [← hg]
|
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal.{max u v}
f : (a : Ordinal.{max u v}) → a < o → Ordinal.{max u v w}
hf : ∀ {i j : Ordinal.{max u v}} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal.{max u v}) → a < o' → Ordinal.{max u v}
hg : o'.blsub g = o
a : Ordinal.{max u v}
ha : a < o'
⊢ g a ha < o'.blsub g
|
2780919a3a9c7fa6
|
seminormFromBounded_of_mul_is_mul
|
Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean
|
theorem seminormFromBounded_of_mul_is_mul (f_nonneg : 0 ≤ f)
(f_mul : ∀ x y : R, f (x * y) ≤ c * f x * f y) {x : R}
(hx : ∀ y : R, f (x * y) = f x * f y) (y : R) :
seminormFromBounded' f (x * y) = seminormFromBounded' f x * seminormFromBounded' f y
|
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x : R
hx : ∀ (y : R), f (x * y) = f x * f y
y : R
⊢ seminormFromBounded' f (x * y) = f x * seminormFromBounded' f y
|
simp only [seminormFromBounded', mul_assoc, hx, mul_div_assoc,
Real.mul_iSup_of_nonneg (f_nonneg _)]
|
no goals
|
ef647cab5d35766f
|
Algebra.FormallySmooth.of_isLocalization
|
Mathlib/RingTheory/Smooth/Basic.lean
|
theorem of_isLocalization : FormallySmooth R Rₘ
|
case h
R Rₘ : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing Rₘ
M : Submonoid R
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization M Rₘ
Q : Type u
inst✝¹ : CommRing Q
inst✝ : Algebra R Q
I : Ideal Q
e : I ^ 2 = ⊥
f : Rₘ →ₐ[R] Q ⧸ I
this✝ : ∀ (x : ↥M), IsUnit ((algebraMap R Q) ↑x)
this : Rₘ →ₐ[R] Q :=
let __src := IsLocalization.lift this✝;
{ toRingHom := __src, commutes' := ⋯ }
⊢ (Ideal.Quotient.mkₐ R I).comp this = f
|
apply AlgHom.coe_ringHom_injective
|
case h.a
R Rₘ : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing Rₘ
M : Submonoid R
inst✝³ : Algebra R Rₘ
inst✝² : IsLocalization M Rₘ
Q : Type u
inst✝¹ : CommRing Q
inst✝ : Algebra R Q
I : Ideal Q
e : I ^ 2 = ⊥
f : Rₘ →ₐ[R] Q ⧸ I
this✝ : ∀ (x : ↥M), IsUnit ((algebraMap R Q) ↑x)
this : Rₘ →ₐ[R] Q :=
let __src := IsLocalization.lift this✝;
{ toRingHom := __src, commutes' := ⋯ }
⊢ ↑((Ideal.Quotient.mkₐ R I).comp this) = ↑f
|
c255f8ab1df303c7
|
orthogonalProjection_orthogonal_val
|
Mathlib/Analysis/InnerProductSpace/Projection.lean
|
theorem orthogonalProjection_orthogonal_val (u : E) :
(orthogonalProjection Kᗮ u : E) = u - orthogonalProjection K u :=
eq_orthogonalProjection_of_mem_orthogonal' (sub_orthogonalProjection_mem_orthogonal _)
(K.le_orthogonal_orthogonal (orthogonalProjection K u).2) <| by simp
|
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
u : E
⊢ u = u - ↑((orthogonalProjection K) u) + ↑((orthogonalProjection K) u)
|
simp
|
no goals
|
c46bfc1d61ea2db4
|
Finset.gcd_mul_left
|
Mathlib/Algebra/GCDMonoid/Finset.lean
|
theorem gcd_mul_left {a : α} : (s.gcd fun x ↦ a * f x) = normalize a * s.gcd f
|
case refine_1
α : Type u_2
β : Type u_3
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Finset β
f : β → α
a : α
⊢ (∅.gcd fun x => a * f x) = normalize a * ∅.gcd f
|
simp
|
no goals
|
2fbe9fbe832756a5
|
Finset.shadow_singleton
|
Mathlib/Combinatorics/SetFamily/Shadow.lean
|
theorem shadow_singleton (a : α) : ∂ {{a}} = {∅}
|
α : Type u_1
inst✝ : DecidableEq α
a : α
⊢ ∂ {{a}} = {∅}
|
simp [shadow]
|
no goals
|
4e99d1d02a66f08a
|
Filter.Tendsto.if
|
Mathlib/Order/Filter/Tendsto.lean
|
theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
[∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 { x | p x }) l₂)
(h₁ : Tendsto g (l₁ ⊓ 𝓟 { x | ¬p x }) l₂) :
Tendsto (fun x => if p x then f x else g x) l₁ l₂
|
case h
α : Type u_1
β : Type u_2
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : ∀ s ∈ l₂, {x | x ∈ {x | p x} → x ∈ f ⁻¹' s} ∈ l₁
h₁ : ∀ s ∈ l₂, {x | x ∈ {x | ¬p x} → x ∈ g ⁻¹' s} ∈ l₁
s : Set β
hs : s ∈ l₂
x : α
hp₀ : p x → x ∈ f ⁻¹' s
hp₁ : ¬p x → x ∈ g ⁻¹' s
⊢ x ∈ (fun x => if p x then f x else g x) ⁻¹' s
|
rw [mem_preimage]
|
case h
α : Type u_1
β : Type u_2
l₁ : Filter α
l₂ : Filter β
f g : α → β
p : α → Prop
inst✝ : (x : α) → Decidable (p x)
h₀ : ∀ s ∈ l₂, {x | x ∈ {x | p x} → x ∈ f ⁻¹' s} ∈ l₁
h₁ : ∀ s ∈ l₂, {x | x ∈ {x | ¬p x} → x ∈ g ⁻¹' s} ∈ l₁
s : Set β
hs : s ∈ l₂
x : α
hp₀ : p x → x ∈ f ⁻¹' s
hp₁ : ¬p x → x ∈ g ⁻¹' s
⊢ (if p x then f x else g x) ∈ s
|
75dfb26837786deb
|
CategoryTheory.Limits.limitCurrySwapCompLimIsoLimitCurryCompLim_hom_π_π
|
Mathlib/CategoryTheory/Limits/Fubini.lean
|
theorem limitCurrySwapCompLimIsoLimitCurryCompLim_hom_π_π {j} {k} :
(limitCurrySwapCompLimIsoLimitCurryCompLim G).hom ≫ limit.π _ j ≫ limit.π _ k =
(limit.π _ k ≫ limit.π _ j : limit (_ ⋙ lim) ⟶ _)
|
J : Type u_1
K : Type u_2
inst✝⁵ : Category.{u_6, u_1} J
inst✝⁴ : Category.{u_5, u_2} K
C : Type u_3
inst✝³ : Category.{u_4, u_3} C
G : J × K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasLimit (curry.obj G ⋙ lim)
j : J
k : K
⊢ (limitIsoLimitCurryCompLim (Prod.swap K J ⋙ G)).inv ≫
limit.π (Prod.swap K J ⋙ G) ((Prod.braiding K J).inverse.obj (j, k)) ≫
(Iso.refl (Prod.swap K J ⋙ G)).inv.app ((Prod.braiding K J).inverse.obj (j, k)) ≫
G.map ((Prod.braiding K J).counit.app (j, k)) =
limit.π (curry.obj (Prod.swap K J ⋙ G) ⋙ lim) k ≫ limit.π ((curry.obj (Prod.swap K J ⋙ G)).obj k) j
|
dsimp [Equivalence.counit]
|
J : Type u_1
K : Type u_2
inst✝⁵ : Category.{u_6, u_1} J
inst✝⁴ : Category.{u_5, u_2} K
C : Type u_3
inst✝³ : Category.{u_4, u_3} C
G : J × K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasLimit (curry.obj G ⋙ lim)
j : J
k : K
⊢ (limitIsoLimitCurryCompLim (Prod.swap K J ⋙ G)).inv ≫
limit.π (Prod.swap K J ⋙ G) (k, j) ≫ 𝟙 (G.obj (j, k)) ≫ G.map (𝟙 j, 𝟙 k) =
limit.π (curry.obj (Prod.swap K J ⋙ G) ⋙ lim) k ≫ limit.π ((curry.obj (Prod.swap K J ⋙ G)).obj k) j
|
8a461539900f6f44
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.