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
|
|---|---|---|---|---|---|---|
CategoryTheory.shiftFunctorCompIsoId_add'_inv_app
|
Mathlib/CategoryTheory/Shift/Basic.lean
|
lemma shiftFunctorCompIsoId_add'_inv_app :
(shiftFunctorCompIsoId C p' p hp).inv.app X =
(shiftFunctorCompIsoId C n' n hn).inv.app X ≫
(shiftFunctorCompIsoId C m' m hm).inv.app (X⟦n'⟧)⟦n⟧' ≫
(shiftFunctorAdd' C m n p h).inv.app (X⟦n'⟧⟦m'⟧) ≫
((shiftFunctorAdd' C n' m' p'
(by rw [← add_left_inj p, hp, ← h, add_assoc,
← add_assoc m', hm, zero_add, hn])).inv.app X)⟦p⟧'
|
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X : C
m n p m' n' p' : A
hm : m' + m = 0
hn : n' + n = 0
hp : p' + p = 0
h : m + n = p
⊢ p' + m + n = 0
|
rw [add_assoc, h, hp]
|
no goals
|
1740b8167511ce6d
|
CliffordAlgebra.evenOdd_induction
|
Mathlib/LinearAlgebra/CliffordAlgebra/Grading.lean
|
theorem evenOdd_induction (n : ZMod 2) {motive : ∀ x, x ∈ evenOdd Q n → Prop}
(range_ι_pow : ∀ (v) (h : v ∈ LinearMap.range (ι Q) ^ n.val),
motive v (Submodule.mem_iSup_of_mem ⟨n.val, n.natCast_zmod_val⟩ h))
(add : ∀ x y hx hy, motive x hx → motive y hy → motive (x + y) (Submodule.add_mem _ hx hy))
(ι_mul_ι_mul :
∀ m₁ m₂ x hx,
motive x hx →
motive (ι Q m₁ * ι Q m₂ * x)
(zero_add n ▸ SetLike.mul_mem_graded (ι_mul_ι_mem_evenOdd_zero Q m₁ m₂) hx))
(x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q n) : motive x hx
|
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
n : ZMod 2
motive : (x : CliffordAlgebra Q) → x ∈ evenOdd Q n → Prop
range_ι_pow : ∀ (v : CliffordAlgebra Q) (h : v ∈ LinearMap.range (ι Q) ^ n.val), motive v ⋯
add :
∀ (x y : CliffordAlgebra Q) (hx : x ∈ evenOdd Q n) (hy : y ∈ evenOdd Q n),
motive x hx → motive y hy → motive (x + y) ⋯
ι_mul_ι_mul :
∀ (m₁ m₂ : M) (x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q n), motive x hx → motive ((ι Q) m₁ * (ι Q) m₂ * x) ⋯
x : CliffordAlgebra Q
hx : x ∈ evenOdd Q n
⊢ motive x hx
|
apply Submodule.iSup_induction' (C := motive) _ _ (range_ι_pow 0 (Submodule.zero_mem _)) add
|
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
n : ZMod 2
motive : (x : CliffordAlgebra Q) → x ∈ evenOdd Q n → Prop
range_ι_pow : ∀ (v : CliffordAlgebra Q) (h : v ∈ LinearMap.range (ι Q) ^ n.val), motive v ⋯
add :
∀ (x y : CliffordAlgebra Q) (hx : x ∈ evenOdd Q n) (hy : y ∈ evenOdd Q n),
motive x hx → motive y hy → motive (x + y) ⋯
ι_mul_ι_mul :
∀ (m₁ m₂ : M) (x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q n), motive x hx → motive ((ι Q) m₁ * (ι Q) m₂ * x) ⋯
x : CliffordAlgebra Q
hx : x ∈ evenOdd Q n
⊢ ∀ (i : { n_1 // ↑n_1 = n }) (x : CliffordAlgebra Q) (hx : x ∈ LinearMap.range (ι Q) ^ ↑i), motive x ⋯
|
3b3d6ba6e257fdcc
|
List.sublist_of_orderEmbedding_getElem?_eq
|
Mathlib/Data/List/NodupEquivFin.lean
|
theorem sublist_of_orderEmbedding_getElem?_eq {l l' : List α} (f : ℕ ↪o ℕ)
(hf : ∀ ix : ℕ, l[ix]? = l'[f ix]?) : l <+ l'
|
α : Type u_1
hd : α
tl : List α
IH : ∀ {l' : List α} (f : ℕ ↪o ℕ), (∀ (ix : ℕ), tl[ix]? = l'[f ix]?) → tl <+ l'
l' : List α
f : ℕ ↪o ℕ
hf : ∀ (ix : ℕ), (hd :: tl)[ix]? = l'[f ix]?
w : f 0 < l'.length
h : l'[f 0] = hd
a b : ℕ
⊢ 0 < b + 1
|
exact b.succ_pos
|
no goals
|
1ef7e5e229e83d6a
|
Real.volume_pi_ball
|
Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
|
theorem volume_pi_ball (a : ι → ℝ) {r : ℝ} (hr : 0 < r) :
volume (Metric.ball a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι)
|
ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 < r
⊢ volume (Metric.ball a r) = ofReal ((2 * r) ^ Fintype.card ι)
|
simp only [MeasureTheory.volume_pi_ball a hr, volume_ball, Finset.prod_const]
|
ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 < r
⊢ ofReal (2 * r) ^ Finset.univ.card = ofReal ((2 * r) ^ Fintype.card ι)
|
6926f174b772b926
|
Submodule.goursat
|
Mathlib/LinearAlgebra/Goursat.lean
|
/-- **Goursat's lemma** for an arbitrary submodule of a product.
If `L` is a submodule of `M × N`, then there exist submodules `M'' ≤ M' ≤ M` and `N'' ≤ N' ≤ N` such
that `L ≤ M' × N'`, and `L` is (the image in `M × N` of) the preimage of the graph of an `R`-linear
isomorphism `M' ⧸ M'' ≃ N' ⧸ N''`. -/
lemma goursat : ∃ (M' : Submodule R M) (N' : Submodule R N) (M'' : Submodule R M')
(N'' : Submodule R N') (e : (M' ⧸ M'') ≃ₗ[R] N' ⧸ N''),
L = (e.graph.comap <| M''.mkQ.prodMap N''.mkQ).map (M'.subtype.prodMap N'.subtype)
|
case h.h.mk.mp
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)
M' : Submodule R M := map (LinearMap.fst R M N) L
N' : Submodule R N := map (LinearMap.snd R M N) L
P : ↥L →ₗ[R] ↥M' := (LinearMap.fst R M N).submoduleMap L
Q : ↥L →ₗ[R] ↥N' := (LinearMap.snd R M N).submoduleMap L
L' : Submodule R (↥M' × ↥N') := LinearMap.range (P.prod Q)
hL₁' : Surjective (Prod.fst ∘ ⇑L'.subtype)
hL₂' : Surjective (Prod.snd ∘ ⇑L'.subtype)
e : (↥M' ⧸ L'.goursatFst) ≃ₗ[R] ↥N' ⧸ L'.goursatSnd
he : LinearMap.range (L'.goursatFst.mkQ.prodMap L'.goursatSnd.mkQ ∘ₗ L'.subtype) = (↑e).graph
m : M
n : N
hmn : (m, n) ∈ L
⊢ (m, n) ∈ map (M'.subtype.prodMap N'.subtype) (LinearMap.range (P.prod Q))
|
simp only [mem_map, LinearMap.mem_range, prod_apply, Subtype.exists, Prod.exists, coe_prodMap,
coe_subtype, Prod.map_apply, Prod.mk.injEq, exists_and_right, exists_eq_right_right,
exists_eq_right, M', N', fst_apply, snd_apply]
|
case h.h.mk.mp
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)
M' : Submodule R M := map (LinearMap.fst R M N) L
N' : Submodule R N := map (LinearMap.snd R M N) L
P : ↥L →ₗ[R] ↥M' := (LinearMap.fst R M N).submoduleMap L
Q : ↥L →ₗ[R] ↥N' := (LinearMap.snd R M N).submoduleMap L
L' : Submodule R (↥M' × ↥N') := LinearMap.range (P.prod Q)
hL₁' : Surjective (Prod.fst ∘ ⇑L'.subtype)
hL₂' : Surjective (Prod.snd ∘ ⇑L'.subtype)
e : (↥M' ⧸ L'.goursatFst) ≃ₗ[R] ↥N' ⧸ L'.goursatSnd
he : LinearMap.range (L'.goursatFst.mkQ.prodMap L'.goursatSnd.mkQ ∘ₗ L'.subtype) = (↑e).graph
m : M
n : N
hmn : (m, n) ∈ L
⊢ ∃ (x : ∃ x, (m, x) ∈ L) (x_1 : ∃ a, (a, n) ∈ L),
∃ a b, ∃ (b_1 : (a, b) ∈ L), Pi.prod ⇑P ⇑Q ⟨(a, b), b_1⟩ = (⟨m, ⋯⟩, ⟨n, ⋯⟩)
|
8bafbf13c72f3711
|
Finset.support_sum_eq
|
Mathlib/Data/Finsupp/BigOperators.lean
|
theorem Finset.support_sum_eq [AddCommMonoid M] (s : Finset (ι →₀ M))
(hs : (s : Set (ι →₀ M)).PairwiseDisjoint Finsupp.support) :
(s.sum id).support = Finset.sup s Finsupp.support
|
case intro.intro.hr
ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : AddCommMonoid M
l : List (ι →₀ M)
hn : l.Nodup
hs : (↑l.toFinset).PairwiseDisjoint Finsupp.support
⊢ Symmetric (Disjoint on Finsupp.support)
|
intro x y hxy
|
case intro.intro.hr
ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : AddCommMonoid M
l : List (ι →₀ M)
hn : l.Nodup
hs : (↑l.toFinset).PairwiseDisjoint Finsupp.support
x y : ι →₀ M
hxy : (Disjoint on Finsupp.support) x y
⊢ (Disjoint on Finsupp.support) y x
|
67f7aca84a3dab37
|
FirstOrder.Language.Theory.isSatisfiable_iff_isFinitelySatisfiable
|
Mathlib/ModelTheory/Satisfiability.lean
|
theorem isSatisfiable_iff_isFinitelySatisfiable {T : L.Theory} :
T.IsSatisfiable ↔ T.IsFinitelySatisfiable :=
⟨Theory.IsSatisfiable.isFinitelySatisfiable, fun h => by
classical
set M : Finset T → Type max u v := fun T0 : Finset T =>
(h (T0.map (Function.Embedding.subtype fun x => x ∈ T)) T0.map_subtype_subset).some.Carrier
let M' := Filter.Product (Ultrafilter.of (Filter.atTop : Filter (Finset T))) M
have h' : M' ⊨ T
|
L : Language
T : L.Theory
h : T.IsFinitelySatisfiable
M : Finset ↑T → Type (max u v) := fun T0 => ↑(Nonempty.some ⋯)
M' : Type (max u v) := (↑(Ultrafilter.of Filter.atTop)).Product M
⊢ M' ⊨ T
|
refine ⟨fun φ hφ => ?_⟩
|
L : Language
T : L.Theory
h : T.IsFinitelySatisfiable
M : Finset ↑T → Type (max u v) := fun T0 => ↑(Nonempty.some ⋯)
M' : Type (max u v) := (↑(Ultrafilter.of Filter.atTop)).Product M
φ : L.Sentence
hφ : φ ∈ T
⊢ M' ⊨ φ
|
360797a9dc61769a
|
PartialHomeomorph.contDiffAt_symm
|
Mathlib/Analysis/Calculus/ContDiff/Operations.lean
|
theorem PartialHomeomorph.contDiffAt_symm [CompleteSpace E] (f : PartialHomeomorph E F)
{f₀' : E ≃L[𝕜] F} {a : F} (ha : a ∈ f.target)
(hf₀' : HasFDerivAt f (f₀' : E →L[𝕜] F) (f.symm a)) (hf : ContDiffAt 𝕜 n f (f.symm a)) :
ContDiffAt 𝕜 n f.symm a
|
case hsuc.intro.intro.intro.intro.refine_2
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type uF
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
n✝ : WithTop ℕ∞
inst✝ : CompleteSpace E
f : PartialHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑f.symm a)
n : ℕ
IH : ContDiffAt 𝕜 (↑↑n) (↑f) (↑f.symm a) → ContDiffAt 𝕜 (↑↑n) (↑f.symm) a
hf : ContDiffAt 𝕜 (↑↑n.succ) (↑f) (↑f.symm a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑f.symm a)
u : Set E
hu : u ∈ 𝓝 (↑f.symm a)
hff' : ∀ x ∈ u, HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑f.symm a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑f.symm a))
⊢ ContDiffAt 𝕜 (↑n) (inverse ∘ f' ∘ ↑f.symm) a
|
have h_deriv₂ : ContDiffAt 𝕜 n f.symm a := by
refine IH (hf.of_le ?_)
norm_cast
exact Nat.le_succ n
|
case hsuc.intro.intro.intro.intro.refine_2
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type uF
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
n✝ : WithTop ℕ∞
inst✝ : CompleteSpace E
f : PartialHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑f.symm a)
n : ℕ
IH : ContDiffAt 𝕜 (↑↑n) (↑f) (↑f.symm a) → ContDiffAt 𝕜 (↑↑n) (↑f.symm) a
hf : ContDiffAt 𝕜 (↑↑n.succ) (↑f) (↑f.symm a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑f.symm a)
u : Set E
hu : u ∈ 𝓝 (↑f.symm a)
hff' : ∀ x ∈ u, HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑f.symm a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑f.symm a))
h_deriv₂ : ContDiffAt 𝕜 (↑n) (↑f.symm) a
⊢ ContDiffAt 𝕜 (↑n) (inverse ∘ f' ∘ ↑f.symm) a
|
db52077be919f1af
|
krullTopology_mem_nhds_one_iff
|
Mathlib/FieldTheory/KrullTopology.lean
|
lemma krullTopology_mem_nhds_one_iff (K L : Type*) [Field K] [Field L] [Algebra K L]
(s : Set (L ≃ₐ[K] L)) : s ∈ 𝓝 1 ↔ ∃ E : IntermediateField K L,
FiniteDimensional K E ∧ (E.fixingSubgroup : Set (L ≃ₐ[K] L)) ⊆ s
|
case mp.intro.intro.intro.intro.intro.intro
K : Type u_1
L : Type u_2
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
s : Set (L ≃ₐ[K] L)
E : IntermediateField K L
fin : E ∈ finiteExts K L
hE : (fun g => g.carrier) E.fixingSubgroup ⊆ s
⊢ ∃ E, FiniteDimensional K ↥E ∧ ↑E.fixingSubgroup ⊆ s
|
exact ⟨E, fin, hE⟩
|
no goals
|
f860557d167209ce
|
inr_comp_cfcₙHom_eq_cfcₙAux
|
Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Basic.lean
|
lemma inr_comp_cfcₙHom_eq_cfcₙAux {A : Type*} [NonUnitalCStarAlgebra A] (a : A)
[ha : IsStarNormal a] : (inrNonUnitalStarAlgHom ℂ A).comp (cfcₙHom ha) =
cfcₙAux (isStarNormal_inr (R := ℂ) (A := A)) a ha
|
A : Type u_2
inst✝ : NonUnitalCStarAlgebra A
a : A
ha : IsStarNormal a
h : ∀ (a : A), IsStarNormal ↑a ↔ IsStarNormal a
⊢ ((inrNonUnitalStarAlgHom ℂ A).comp (cfcₙHom ha))
{ toContinuousMap := ContinuousMap.restrict (σₙ ℂ a) (ContinuousMap.id ℂ), map_zero' := ⋯ } =
↑a
|
congrm(inr $(cfcₙHom_id ha))
|
no goals
|
6489793b55e07998
|
LocalSubring.exists_le_valuationSubring
|
Mathlib/RingTheory/Valuation/LocalSubring.lean
|
@[stacks 00IA]
lemma LocalSubring.exists_le_valuationSubring (A : LocalSubring K) :
∃ B : ValuationSubring K, A ≤ B.toLocalSubring
|
case refine_2.mk.intro.mk.intro
K : Type u_3
inst✝ : Field K
A✝ : LocalSubring K
s : Set (LocalSubring K)
hs : s ⊆ Set.Ici A✝
H : IsChain (fun x1 x2 => x1 ≤ x2) s
y : LocalSubring K
hys : y ∈ s
inst : Nonempty ↑s
hdir : Directed LE.le (toSubring ∘ fun x => ↑x)
A : LocalSubring K
hA : A ∈ s
a : K
haA : a ∈ A.toSubring
h : IsUnit ((Subring.inclusion ⋯) ⟨a, haA⟩)
b : K
hb : b ∈ (mk (⨆ i, (↑i).toSubring)).toSubring
e : (Subring.inclusion ⋯) ⟨a, haA⟩ * ⟨b, hb⟩ = 1
B : { a // a ∈ s }
hbB : b ∈ (↑B).toSubring
⊢ IsUnit ⟨a, haA⟩
|
obtain ⟨C, hCA, hCB⟩ := H.directed ⟨A, hA⟩ B
|
case refine_2.mk.intro.mk.intro.intro.intro
K : Type u_3
inst✝ : Field K
A✝ : LocalSubring K
s : Set (LocalSubring K)
hs : s ⊆ Set.Ici A✝
H : IsChain (fun x1 x2 => x1 ≤ x2) s
y : LocalSubring K
hys : y ∈ s
inst : Nonempty ↑s
hdir : Directed LE.le (toSubring ∘ fun x => ↑x)
A : LocalSubring K
hA : A ∈ s
a : K
haA : a ∈ A.toSubring
h : IsUnit ((Subring.inclusion ⋯) ⟨a, haA⟩)
b : K
hb : b ∈ (mk (⨆ i, (↑i).toSubring)).toSubring
e : (Subring.inclusion ⋯) ⟨a, haA⟩ * ⟨b, hb⟩ = 1
B : { a // a ∈ s }
hbB : b ∈ (↑B).toSubring
C : { a // a ∈ s }
hCA : (fun x => ↑x) ⟨A, hA⟩ ≤ (fun x => ↑x) C
hCB : (fun x => ↑x) B ≤ (fun x => ↑x) C
⊢ IsUnit ⟨a, haA⟩
|
926576b935296dd2
|
smul_singleton_mem_nhds_of_sigmaCompact
|
Mathlib/Topology/Algebra/Group/OpenMapping.lean
|
theorem smul_singleton_mem_nhds_of_sigmaCompact
{U : Set G} (hU : U ∈ 𝓝 1) (x : X) : U • {x} ∈ 𝓝 x
|
G : Type u_1
X : Type u_2
inst✝⁹ : TopologicalSpace G
inst✝⁸ : TopologicalSpace X
inst✝⁷ : Group G
inst✝⁶ : IsTopologicalGroup G
inst✝⁵ : MulAction G X
inst✝⁴ : SigmaCompactSpace G
inst✝³ : BaireSpace X
inst✝² : T2Space X
inst✝¹ : ContinuousSMul G X
inst✝ : IsPretransitive G X
U : Set G
hU : U ∈ 𝓝 1
x : X
V : Set G
V_mem : V ∈ 𝓝 1
V_closed : IsClosed V
V_symm : V⁻¹ = V
VU : V * V ⊆ U
s : Set G
s_count : s.Countable
hs : ⋃ g ∈ s, g • V = univ
K : ℕ → Set G := compactCovering G
F : ℕ × ↑s → Set X := fun p => (K p.1 ∩ ↑p.2 • V) • {x}
this✝ : Nonempty X
this : Encodable ↑s
n : ℕ
g : G
hg : g ∈ s
H : IsCompact ((fun g => g • x) '' (K n ∩ g • V))
⊢ IsCompact (F (n, ⟨g, hg⟩))
|
simpa only [F, smul_singleton] using H
|
no goals
|
09fff4470c6f8515
|
List.mapFinIdx_append
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/MapIdx.lean
|
theorem mapFinIdx_append {K L : List α} {f : (i : Nat) → α → (h : i < (K ++ L).length) → β} :
(K ++ L).mapFinIdx f =
K.mapFinIdx (fun i a h => f i a (by simp; omega)) ++
L.mapFinIdx (fun i a h => f (i + K.length) a (by simp; omega))
|
case h
α : Type u_1
β : Type u_2
K L : List α
f : (i : Nat) → α → i < (K ++ L).length → β
i : Nat
h₁ : i < ((K ++ L).mapFinIdx f).length
h₂ : i < ((K.mapFinIdx fun i a h => f i a ⋯) ++ L.mapFinIdx fun i a h => f (i + K.length) a ⋯).length
⊢ f i (K ++ L)[i] ⋯ = if h : i < K.length then f i K[i] ⋯ else f (i - K.length + K.length) L[i - K.length] ⋯
|
split <;> rename_i h
|
case h.isTrue
α : Type u_1
β : Type u_2
K L : List α
f : (i : Nat) → α → i < (K ++ L).length → β
i : Nat
h₁ : i < ((K ++ L).mapFinIdx f).length
h₂ : i < ((K.mapFinIdx fun i a h => f i a ⋯) ++ L.mapFinIdx fun i a h => f (i + K.length) a ⋯).length
h : i < K.length
⊢ f i (K ++ L)[i] ⋯ = f i K[i] ⋯
case h.isFalse
α : Type u_1
β : Type u_2
K L : List α
f : (i : Nat) → α → i < (K ++ L).length → β
i : Nat
h₁ : i < ((K ++ L).mapFinIdx f).length
h₂ : i < ((K.mapFinIdx fun i a h => f i a ⋯) ++ L.mapFinIdx fun i a h => f (i + K.length) a ⋯).length
h : ¬i < K.length
⊢ f i (K ++ L)[i] ⋯ = f (i - K.length + K.length) L[i - K.length] ⋯
|
3176fb50755ce896
|
Measurable.liminf'
|
Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
|
theorem Measurable.liminf' {ι ι'} {f : ι → δ → α} {v : Filter ι} (hf : ∀ i, Measurable (f i))
{p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasCountableBasis p s) (hs : ∀ j, (s j).Countable) :
Measurable fun x => liminf (f · x) v
|
α : Type u_1
δ : Type u_4
inst✝⁴ : TopologicalSpace α
mα : MeasurableSpace α
inst✝³ : BorelSpace α
mδ : MeasurableSpace δ
inst✝² : ConditionallyCompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_5
ι' : Type u_6
f : ι → δ → α
v : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hv : v.HasCountableBasis p s
hs : ∀ (j : ι'), (s j).Countable
this✝ : Countable (Subtype p)
hp : Nonempty (Subtype p)
H : ¬∃ j, s ↑j = ∅
this : ∀ (i : ι'), Countable ↑(s i)
m : Subtype p → Set δ := fun j => {x | BddBelow (range fun i => f (↑i) x)}
m_meas : ∀ (j : Subtype p), MeasurableSet (m j)
mc_meas : MeasurableSet {x | ∀ (j : Subtype p), x ∉ m j}
j : Subtype p
reparam : δ → Subtype p → Subtype p := fun x => liminf_reparam (fun i => f i x) s p
F0 : Subtype p → δ → α := fun j x => ⨅ i, f (↑i) x
F0_meas : ∀ (j : Subtype p), Measurable (F0 j)
F1 : δ → α := fun x => F0 (reparam x j) x
hF1 : F1 = fun x => F0 (reparam x j) x
g : ℕ → Subtype p := Classical.choose ⋯
x : δ
⊢ ∃ n, x ∈ m (g n) ∨ ∀ (k : Subtype p), x ∉ m k
|
by_cases H : ∃ k, x ∈ m k
|
case pos
α : Type u_1
δ : Type u_4
inst✝⁴ : TopologicalSpace α
mα : MeasurableSpace α
inst✝³ : BorelSpace α
mδ : MeasurableSpace δ
inst✝² : ConditionallyCompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_5
ι' : Type u_6
f : ι → δ → α
v : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hv : v.HasCountableBasis p s
hs : ∀ (j : ι'), (s j).Countable
this✝ : Countable (Subtype p)
hp : Nonempty (Subtype p)
H✝ : ¬∃ j, s ↑j = ∅
this : ∀ (i : ι'), Countable ↑(s i)
m : Subtype p → Set δ := fun j => {x | BddBelow (range fun i => f (↑i) x)}
m_meas : ∀ (j : Subtype p), MeasurableSet (m j)
mc_meas : MeasurableSet {x | ∀ (j : Subtype p), x ∉ m j}
j : Subtype p
reparam : δ → Subtype p → Subtype p := fun x => liminf_reparam (fun i => f i x) s p
F0 : Subtype p → δ → α := fun j x => ⨅ i, f (↑i) x
F0_meas : ∀ (j : Subtype p), Measurable (F0 j)
F1 : δ → α := fun x => F0 (reparam x j) x
hF1 : F1 = fun x => F0 (reparam x j) x
g : ℕ → Subtype p := Classical.choose ⋯
x : δ
H : ∃ k, x ∈ m k
⊢ ∃ n, x ∈ m (g n) ∨ ∀ (k : Subtype p), x ∉ m k
case neg
α : Type u_1
δ : Type u_4
inst✝⁴ : TopologicalSpace α
mα : MeasurableSpace α
inst✝³ : BorelSpace α
mδ : MeasurableSpace δ
inst✝² : ConditionallyCompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_5
ι' : Type u_6
f : ι → δ → α
v : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hv : v.HasCountableBasis p s
hs : ∀ (j : ι'), (s j).Countable
this✝ : Countable (Subtype p)
hp : Nonempty (Subtype p)
H✝ : ¬∃ j, s ↑j = ∅
this : ∀ (i : ι'), Countable ↑(s i)
m : Subtype p → Set δ := fun j => {x | BddBelow (range fun i => f (↑i) x)}
m_meas : ∀ (j : Subtype p), MeasurableSet (m j)
mc_meas : MeasurableSet {x | ∀ (j : Subtype p), x ∉ m j}
j : Subtype p
reparam : δ → Subtype p → Subtype p := fun x => liminf_reparam (fun i => f i x) s p
F0 : Subtype p → δ → α := fun j x => ⨅ i, f (↑i) x
F0_meas : ∀ (j : Subtype p), Measurable (F0 j)
F1 : δ → α := fun x => F0 (reparam x j) x
hF1 : F1 = fun x => F0 (reparam x j) x
g : ℕ → Subtype p := Classical.choose ⋯
x : δ
H : ¬∃ k, x ∈ m k
⊢ ∃ n, x ∈ m (g n) ∨ ∀ (k : Subtype p), x ∉ m k
|
92aa2e449ca3c5d1
|
Lat.id_apply
|
Mathlib/Order/Category/Lat.lean
|
lemma id_apply (X : Lat) (x : X) :
(𝟙 X : X ⟶ X) x = x
|
X : Lat
x : ↑X
⊢ (ConcreteCategory.hom (𝟙 X)) x = x
|
simp
|
no goals
|
32c5b178eb0b3749
|
MeasureTheory.condExp_bot_ae_eq
|
Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
|
theorem condExp_bot_ae_eq (f : α → E) :
μ[f|⊥] =ᵐ[μ] fun _ => (μ Set.univ).toReal⁻¹ • ∫ x, f x ∂μ
|
case inl
α : Type u_1
E : Type u_3
m₀ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : α → E
⊢ 0[f|⊥] =ᶠ[ae 0] fun x => (0 Set.univ).toReal⁻¹ • ∫ (x : α), f x ∂0
|
rw [ae_zero]
|
case inl
α : Type u_1
E : Type u_3
m₀ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : α → E
⊢ 0[f|⊥] =ᶠ[⊥] fun x => (0 Set.univ).toReal⁻¹ • ∫ (x : α), f x ∂0
|
767e3c75448f429e
|
AlgebraicTopology.AlternatingFaceMapComplex.d_squared
|
Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean
|
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0
|
case h.mk.e_a.H
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.2 ≤ ↑ij.1) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (ij.2.castLT ⋯, ij.1.succ)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ (i, j).2 ≤ (i, j).1.castSucc
|
simpa [S] using hij
|
no goals
|
795ab48b2006c7af
|
AlgebraicGeometry.ProjectiveSpectrum.Proj.isLocalization_atPrime
|
Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
|
/--
If `x` is a point in the basic open set `D(f)` where `f` is a homogeneous element of positive
degree, then the homogeneously localized ring `A⁰ₓ` has the universal property of the localization
of `A⁰_f` at `φ(x)` where `φ : Proj|D(f) ⟶ Spec A⁰_f` is the morphism of locally ringed space
constructed as above.
-/
lemma isLocalization_atPrime (f) (x : pbo f) {m} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
@IsLocalization (Away 𝒜 f) _ ((toSpec 𝒜 f).base x).asIdeal.primeCompl
(AtPrime 𝒜 x.1.asHomogeneousIdeal.toIdeal) _
(mapId 𝒜 (Submonoid.powers_le.mpr x.2)).toAlgebra
|
case exists_of_eq.intro.intro.intro.intro.intro.intro
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
x : ↥(pbo f)
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
this : Algebra (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal) := (mapId 𝒜 ⋯).toAlgebra
y z : NumDenSameDeg 𝒜 (Submonoid.powers f)
e✝ :
(algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) (HomogeneousLocalization.mk y) =
(algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) (HomogeneousLocalization.mk z)
i : ℕ
c : A
hc : c ∈ 𝒜 i
hc' : c ∉ (↑x).asHomogeneousIdeal
e : c * (↑z.den * ↑y.num) = c * (↑y.den * ↑z.num)
⊢ HomogeneousLocalization.val
(↑⟨HomogeneousLocalization.mk { deg := m * i, num := ⟨c ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ }, ⋯⟩ *
HomogeneousLocalization.mk y) =
HomogeneousLocalization.val
(↑⟨HomogeneousLocalization.mk { deg := m * i, num := ⟨c ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ }, ⋯⟩ *
HomogeneousLocalization.mk z)
|
simp only [val_mul, val_mk, mk_eq_mk', ← IsLocalization.mk'_mul, Submonoid.mk_mul_mk,
IsLocalization.mk'_eq_iff_eq, mul_assoc]
|
case exists_of_eq.intro.intro.intro.intro.intro.intro
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
x : ↥(pbo f)
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
this : Algebra (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal) := (mapId 𝒜 ⋯).toAlgebra
y z : NumDenSameDeg 𝒜 (Submonoid.powers f)
e✝ :
(algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) (HomogeneousLocalization.mk y) =
(algebraMap (A⁰_ f) (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal)) (HomogeneousLocalization.mk z)
i : ℕ
c : A
hc : c ∈ 𝒜 i
hc' : c ∉ (↑x).asHomogeneousIdeal
e : c * (↑z.den * ↑y.num) = c * (↑y.den * ↑z.num)
⊢ (algebraMap A (Localization (Submonoid.powers f))) (f ^ i * (↑z.den * (c ^ m * ↑y.num))) =
(algebraMap A (Localization (Submonoid.powers f))) (f ^ i * (↑y.den * (c ^ m * ↑z.num)))
|
afc745eaf2bf3f81
|
Polynomial.add_scaleRoots_of_natDegree_eq
|
Mathlib/RingTheory/Polynomial/ScaleRoots.lean
|
lemma add_scaleRoots_of_natDegree_eq (p q : R[X]) (r : R) (h : natDegree p = natDegree q) :
r ^ (natDegree p - natDegree (p + q)) • (p + q).scaleRoots r =
p.scaleRoots r + q.scaleRoots r
|
case a
R : Type u_1
inst✝ : CommSemiring R
p q : R[X]
r : R
h : p.natDegree = q.natDegree
n : ℕ
⊢ (r ^ (p.natDegree - (p + q).natDegree) • (p + q).scaleRoots r).coeff n = (p.scaleRoots r + q.scaleRoots r).coeff n
|
simp only [coeff_smul, coeff_scaleRoots, coeff_add, smul_eq_mul,
mul_comm (r ^ _), ← pow_add, ← h, ← add_mul, add_comm (_ - n)]
|
case a
R : Type u_1
inst✝ : CommSemiring R
p q : R[X]
r : R
h : p.natDegree = q.natDegree
n : ℕ
⊢ (p.coeff n + q.coeff n) * r ^ ((p + q).natDegree - n) * r ^ (p.natDegree - (p + q).natDegree) =
(p.coeff n + q.coeff n) * r ^ (p.natDegree - n)
|
5945b7da60f24c45
|
Subgroup.Normal.commutator_le_of_self_sup_commutative_eq_top
|
Mathlib/GroupTheory/Abelianization.lean
|
theorem Subgroup.Normal.commutator_le_of_self_sup_commutative_eq_top {N : Subgroup G} [N.Normal]
{H : Subgroup G} (hHN : N ⊔ H = ⊤) (hH : Subgroup.IsCommutative H) :
_root_.commutator G ≤ N
|
G : Type u
inst✝¹ : Group G
N : Subgroup G
inst✝ : N.Normal
H : Subgroup G
hHN : N ⊔ H = ⊤
hH : H.IsCommutative
φ : ↥H →ₙ* G ⧸ N := ↑((QuotientGroup.mk' N).comp H.subtype)
⊢ Subgroup.map (QuotientGroup.mk' N) ⊤ = ⊤
|
rw [← MonoidHom.range_eq_map, MonoidHom.range_eq_top]
|
G : Type u
inst✝¹ : Group G
N : Subgroup G
inst✝ : N.Normal
H : Subgroup G
hHN : N ⊔ H = ⊤
hH : H.IsCommutative
φ : ↥H →ₙ* G ⧸ N := ↑((QuotientGroup.mk' N).comp H.subtype)
⊢ Function.Surjective ⇑(QuotientGroup.mk' N)
|
4f1c7225fbfaf09a
|
ModP.mul_ne_zero_of_pow_p_ne_zero
|
Mathlib/RingTheory/Perfection.lean
|
theorem mul_ne_zero_of_pow_p_ne_zero {x y : ModP O p} (hx : x ^ p ≠ 0) (hy : y ^ p ≠ 0) :
x * y ≠ 0
|
case pos
K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
r : O
hx : v ↑p ^ (1 / ↑p) < v ((algebraMap O K) r)
s : O
hy : v ↑p ^ (1 / ↑p) < v ((algebraMap O K) s)
h1p : 0 < 1 / ↑p
hvp : v ↑p = 0
⊢ v ↑p ≤ v ↑p ^ (1 / ↑p) * v ↑p ^ (1 / ↑p)
|
rw [hvp]
|
case pos
K : Type u₁
inst✝² : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝¹ : CommRing O
inst✝ : Algebra O K
hv : v.Integers O
p : ℕ
hp : Fact (Nat.Prime p)
r : O
hx : v ↑p ^ (1 / ↑p) < v ((algebraMap O K) r)
s : O
hy : v ↑p ^ (1 / ↑p) < v ((algebraMap O K) s)
h1p : 0 < 1 / ↑p
hvp : v ↑p = 0
⊢ 0 ≤ 0 ^ (1 / ↑p) * 0 ^ (1 / ↑p)
|
fcaa6e56fffb7efd
|
Real.exists_extension_norm_eq
|
Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean
|
theorem exists_extension_norm_eq (p : Subspace ℝ E) (f : p →L[ℝ] ℝ) :
∃ g : E →L[ℝ] ℝ, (∀ x : p, g x = f x) ∧ ‖g‖ = ‖f‖
|
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
p : Subspace ℝ E
f : ↥p →L[ℝ] ℝ
c : ℝ
hc : 0 < c
x : E
⊢ (fun x => ‖f‖ * ‖x‖) (c • x) = c * (fun x => ‖f‖ * ‖x‖) x
|
simp only [norm_smul c x, Real.norm_eq_abs, abs_of_pos hc, mul_left_comm]
|
no goals
|
0f306ef1f16e3415
|
CategoryTheory.Limits.preservesBinaryBiproduct_of_preservesBinaryProduct
|
Mathlib/CategoryTheory/Preadditive/Biproducts.lean
|
/-- A functor between preadditive categories that preserves (zero morphisms and) binary products
preserves binary biproducts. -/
lemma preservesBinaryBiproduct_of_preservesBinaryProduct {X Y : C} [PreservesLimit (pair X Y) F] :
PreservesBinaryBiproduct X Y F where
preserves {b} hb := ⟨isBinaryBilimitOfIsLimit _ <| IsLimit.ofIsoLimit
((IsLimit.postcomposeHomEquiv (diagramIsoPair _) (F.mapCone b.toCone)).symm
(isLimitOfPreserves F hb.isLimit)) <|
Cones.ext (by dsimp; rfl) fun j => by
rcases j with ⟨⟨⟩⟩ <;> simp⟩
|
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : Preadditive C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : Preadditive D
F : C ⥤ D
inst✝¹ : F.PreservesZeroMorphisms
X Y : C
inst✝ : PreservesLimit (pair X Y) F
b : BinaryBicone X Y
hb : b.IsBilimit
⊢ F.obj b.pt ≅ F.obj b.pt
|
rfl
|
no goals
|
07a7c7d65f60322c
|
PMF.toOuterMeasure_bindOnSupport_apply
|
Mathlib/Probability/ProbabilityMassFunction/Monad.lean
|
theorem toOuterMeasure_bindOnSupport_apply :
(p.bindOnSupport f).toOuterMeasure s =
∑' a, p a * if h : p a = 0 then 0 else (f a h).toOuterMeasure s
|
α : Type u_1
β : Type u_2
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
s : Set β
⊢ (p.bindOnSupport f).toOuterMeasure s = ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h).toOuterMeasure s
|
simp only [toOuterMeasure_apply, Set.indicator_apply, bindOnSupport_apply]
|
α : Type u_1
β : Type u_2
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
s : Set β
⊢ ∑' (x : β), s.indicator (⇑(p.bindOnSupport f)) x =
∑' (a : α), p a * if h : p a = 0 then 0 else ∑' (x : β), s.indicator (⇑(f a ⋯)) x
|
48552b8cdb86bb57
|
MeasureTheory.withDensity_inv_same₀
|
Mathlib/MeasureTheory/Measure/WithDensity.lean
|
lemma withDensity_inv_same₀ {μ : Measure α} {f : α → ℝ≥0∞}
(hf : AEMeasurable f μ) (hf_ne_zero : ∀ᵐ x ∂μ, f x ≠ 0) (hf_ne_top : ∀ᵐ x ∂μ, f x ≠ ∞) :
(μ.withDensity f).withDensity (fun x ↦ (f x)⁻¹) = μ
|
case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_ne_zero✝ : ∀ᵐ (x : α) ∂μ, f x ≠ 0
hf_ne_top✝ : ∀ᵐ (x : α) ∂μ, f x ≠ ⊤
x : α
hf_ne_zero : f x ≠ 0
hf_ne_top : f x ≠ ⊤
⊢ f x * (f x)⁻¹ = 1 x
|
rw [ENNReal.mul_inv_cancel hf_ne_zero hf_ne_top, Pi.one_apply]
|
no goals
|
afe625e716585194
|
MeasureTheory.absolutelyContinuous_of_isMulLeftInvariant
|
Mathlib/MeasureTheory/Group/Prod.lean
|
theorem absolutelyContinuous_of_isMulLeftInvariant [IsMulLeftInvariant ν] (hν : ν ≠ 0) : μ ≪ ν
|
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
hν : ν ≠ 0
s : Set G
sm : MeasurableSet s
hνs : ν s = 0
h1 : μ s = 0
⊢ μ s = 0
|
exact h1
|
no goals
|
3b30d34d996bb593
|
Array.toList_fst_unzip
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem toList_fst_unzip (as : Array (α × β)) :
as.unzip.1.toList = as.toList.unzip.1
|
α : Type u_1
β : Type u_2
as : Array (α × β)
⊢ as.unzip.fst.toList = as.toList.unzip.fst
|
simp
|
no goals
|
5d0be5483eada628
|
tprod_empty
|
Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
|
theorem tprod_empty [IsEmpty β] : ∏' b, f b = 1
|
α : Type u_1
β : Type u_2
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f : β → α
inst✝ : IsEmpty β
⊢ ∏' (b : β), f b = 1
|
rw [tprod_eq_prod (s := (∅ : Finset β))] <;> simp
|
no goals
|
38ca6830aa7e9b06
|
ZMod.LFunction_stdAddChar_eq_expZeta
|
Mathlib/NumberTheory/LSeries/ZMod.lean
|
/--
The `LFunction` of the function `x ↦ e (j * x)`, where `e : ZMod N → ℂ` is the standard additive
character, is `expZeta (j / N)`.
Note this is not at all obvious from the definitions, and we prove it by analytic continuation
from the convergence range.
-/
lemma LFunction_stdAddChar_eq_expZeta (j : ZMod N) (s : ℂ) (hjs : j ≠ 0 ∨ s ≠ 1) :
LFunction (fun k ↦ 𝕖 (j * k)) s = expZeta (ZMod.toAddCircle j) s
|
N : ℕ
inst✝ : NeZero N
j : ZMod N
s : ℂ
hjs : j ≠ 0 ∨ s ≠ 1
U : Set ℂ := if j = 0 then {z | z ≠ 1} else Set.univ
V : Set ℂ := {z | 1 < z.re}
hUo : IsOpen U
f : ℂ → ℂ := LFunction fun k => 𝕖 (j * k)
g : ℂ → ℂ := expZeta (toAddCircle j)
hU : ∀ {u : ℂ}, u ∈ U ↔ u ≠ 1 ∨ j ≠ 0
hf : AnalyticOnNhd ℂ f U
hg : AnalyticOnNhd ℂ g U
hUc : IsPreconnected U
hV : V ∈ 𝓝 2
hUmem : 2 ∈ U
hUmem' : s ∈ U
⊢ f =ᶠ[𝓝 2] g
|
filter_upwards [hV] with z using LFunction_stdAddChar_eq_expZeta_of_one_lt_re _
|
no goals
|
11c978f7c59083e2
|
CategoryTheory.Adjunction.full_L_of_isSplitEpi_unit_app
|
Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
|
/-- If each component of the unit is a split epimorphism, then the left adjoint is full. -/
lemma full_L_of_isSplitEpi_unit_app [∀ X, IsSplitEpi (h.unit.app X)] : L.Full where
map_surjective {X Y} f
|
case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : C), IsSplitEpi (h.unit.app X)
X Y : C
f : L.obj X ⟶ L.obj Y
⊢ L.map (section_ (h.unit.app Y)) = h.counit.app (L.obj Y)
|
rw [← comp_id (L.map (section_ (h.unit.app Y)))]
|
case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : C), IsSplitEpi (h.unit.app X)
X Y : C
f : L.obj X ⟶ L.obj Y
⊢ L.map (section_ (h.unit.app Y)) ≫ 𝟙 (L.obj ((𝟭 C).obj Y)) = h.counit.app (L.obj Y)
|
99582905f384847b
|
List.splitLengths_length_getElem
|
Mathlib/Data/List/SplitLengths.lean
|
theorem splitLengths_length_getElem {α : Type*} (l : List α) (sz : List ℕ)
(h : sz.sum ≤ l.length) (i : ℕ) (hi : i < (sz.splitLengths l).length) :
(sz.splitLengths l)[i].length = sz[i]'(by simpa using hi)
|
α : Type u_2
l : List α
sz : List ℕ
h : sz.sum ≤ l.length
i : ℕ
hi : i < (sz.splitLengths l).length
⊢ (sz.splitLengths l)[i].length = sz[i]
|
have := map_splitLengths_length l sz h
|
α : Type u_2
l : List α
sz : List ℕ
h : sz.sum ≤ l.length
i : ℕ
hi : i < (sz.splitLengths l).length
this : map length (sz.splitLengths l) = sz
⊢ (sz.splitLengths l)[i].length = sz[i]
|
4e55a93adad03450
|
MeasureTheory.exists_measure_iInter_lt
|
Mathlib/MeasureTheory/Measure/MeasureSpace.lean
|
theorem exists_measure_iInter_lt {α ι : Type*} {_ : MeasurableSpace α} {μ : Measure α}
[SemilatticeSup ι] [Countable ι] {f : ι → Set α}
(hm : ∀ i, NullMeasurableSet (f i) μ) {ε : ℝ≥0∞} (hε : 0 < ε) (hfin : ∃ i, μ (f i) ≠ ∞)
(hfem : ⋂ n, f n = ∅) : ∃ m, μ (⋂ n ≤ m, f n) < ε
|
α : Type u_8
ι : Type u_9
x✝ : MeasurableSpace α
μ : Measure α
inst✝¹ : SemilatticeSup ι
inst✝ : Countable ι
f : ι → Set α
hm : ∀ (i : ι), NullMeasurableSet (f i) μ
ε : ℝ≥0∞
hε : 0 < ε
hfin : ∃ i, μ (f i) ≠ ⊤
hfem : ⋂ n, f n = ∅
⊢ ∃ m, μ (⋂ n, ⋂ (_ : n ≤ m), f n) < ε
|
let F m := μ (⋂ n ≤ m, f n)
|
α : Type u_8
ι : Type u_9
x✝ : MeasurableSpace α
μ : Measure α
inst✝¹ : SemilatticeSup ι
inst✝ : Countable ι
f : ι → Set α
hm : ∀ (i : ι), NullMeasurableSet (f i) μ
ε : ℝ≥0∞
hε : 0 < ε
hfin : ∃ i, μ (f i) ≠ ⊤
hfem : ⋂ n, f n = ∅
F : ι → ℝ≥0∞ := fun m => μ (⋂ n, ⋂ (_ : n ≤ m), f n)
⊢ ∃ m, μ (⋂ n, ⋂ (_ : n ≤ m), f n) < ε
|
1f737bad22d86841
|
PhragmenLindelof.horizontal_strip
|
Mathlib/Analysis/Complex/PhragmenLindelof.lean
|
theorem horizontal_strip (hfd : DiffContOnCl ℂ f (im ⁻¹' Ioo a b))
(hB : ∃ c < π / (b - a), ∃ B, f =O[comap (_root_.abs ∘ re) atTop ⊓ 𝓟 (im ⁻¹' Ioo a b)]
fun z ↦ expR (B * expR (c * |z.re|)))
(hle_a : ∀ z : ℂ, im z = a → ‖f z‖ ≤ C) (hle_b : ∀ z, im z = b → ‖f z‖ ≤ C) (hza : a ≤ im z)
(hzb : im z ≤ b) : ‖f z‖ ≤ C
|
case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
C✝ : ℝ
f : ℂ → E
z : ℂ
C : ℝ
hC₀ : 0 < C
a b : ℝ
hza : a - b < z.im
hle_a : ∀ (z : ℂ), z.im = a - b → ‖f z‖ ≤ C
hzb : z.im < a + b
hle_b : ∀ (z : ℂ), z.im = a + b → ‖f z‖ ≤ C
hfd : DiffContOnCl ℂ f (im ⁻¹' Ioo (a - b) (a + b))
hab : a - b < a + b
hb : 0 < b
hπb : 0 < π / 2 / b
c : ℝ
hc : c < π / 2 / b
B : ℝ
hO : f =O[comap (abs ∘ re) atTop ⊓ 𝓟 (im ⁻¹' Ioo (a - b) (a + b))] fun z => expR (B * expR (c * |z.re|))
d : ℝ
hcd : c < d
hd₀ : 0 < d
hb' : d * b < π / 2
aff : ℂ → ℂ := fun w => ↑d * (w - ↑a * I)
g : ℝ → ℂ → ℂ := fun ε w => cexp (↑ε * (cexp (aff w) + cexp (-aff w)))
ε : ℝ
ε₀ : ε < 0
δ : ℝ
δ₀ : δ < 0
hδ : ∀ ⦃w : ℂ⦄, w.im ∈ Icc (a - b) (a + b) → ‖g ε w‖ ≤ expR (δ * expR (d * |w.re|))
hg₁ : ∀ (w : ℂ), w.im = a - b ∨ w.im = a + b → ‖g ε w‖ ≤ 1
R : ℝ
hzR : |z.re| < R
hR : ∀ (w : ℂ), |w.re| = R → w.im ∈ Ioo (a - b) (a + b) → ‖g ε w • f w‖ ≤ C
hR₀ : 0 < R
hgd : Differentiable ℂ (g ε)
hd : DiffContOnCl ℂ (fun w => g ε w • f w) (Ioo (-R) R ×ℂ Ioo (a - b) (a + b))
w : ℂ
him : ¬(w.im = a - b ∨ w.im = a + b)
hw : w ∈ {-R, R} ×ℂ Icc (a - b) (a + b)
⊢ ‖g ε w • f w‖ ≤ C
|
have hw' := eq_endpoints_or_mem_Ioo_of_mem_Icc hw.2
|
case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
C✝ : ℝ
f : ℂ → E
z : ℂ
C : ℝ
hC₀ : 0 < C
a b : ℝ
hza : a - b < z.im
hle_a : ∀ (z : ℂ), z.im = a - b → ‖f z‖ ≤ C
hzb : z.im < a + b
hle_b : ∀ (z : ℂ), z.im = a + b → ‖f z‖ ≤ C
hfd : DiffContOnCl ℂ f (im ⁻¹' Ioo (a - b) (a + b))
hab : a - b < a + b
hb : 0 < b
hπb : 0 < π / 2 / b
c : ℝ
hc : c < π / 2 / b
B : ℝ
hO : f =O[comap (abs ∘ re) atTop ⊓ 𝓟 (im ⁻¹' Ioo (a - b) (a + b))] fun z => expR (B * expR (c * |z.re|))
d : ℝ
hcd : c < d
hd₀ : 0 < d
hb' : d * b < π / 2
aff : ℂ → ℂ := fun w => ↑d * (w - ↑a * I)
g : ℝ → ℂ → ℂ := fun ε w => cexp (↑ε * (cexp (aff w) + cexp (-aff w)))
ε : ℝ
ε₀ : ε < 0
δ : ℝ
δ₀ : δ < 0
hδ : ∀ ⦃w : ℂ⦄, w.im ∈ Icc (a - b) (a + b) → ‖g ε w‖ ≤ expR (δ * expR (d * |w.re|))
hg₁ : ∀ (w : ℂ), w.im = a - b ∨ w.im = a + b → ‖g ε w‖ ≤ 1
R : ℝ
hzR : |z.re| < R
hR : ∀ (w : ℂ), |w.re| = R → w.im ∈ Ioo (a - b) (a + b) → ‖g ε w • f w‖ ≤ C
hR₀ : 0 < R
hgd : Differentiable ℂ (g ε)
hd : DiffContOnCl ℂ (fun w => g ε w • f w) (Ioo (-R) R ×ℂ Ioo (a - b) (a + b))
w : ℂ
him : ¬(w.im = a - b ∨ w.im = a + b)
hw : w ∈ {-R, R} ×ℂ Icc (a - b) (a + b)
hw' : w.im = a - b ∨ w.im = a + b ∨ w.im ∈ Ioo (a - b) (a + b)
⊢ ‖g ε w • f w‖ ≤ C
|
96530d0dcac40a71
|
Finset.antidiagonal.snd_le
|
Mathlib/Algebra/Order/Antidiag/Prod.lean
|
theorem antidiagonal.snd_le {n : A} {kl : A × A} (hlk : kl ∈ antidiagonal n) : kl.2 ≤ n
|
A : Type u_1
inst✝² : OrderedAddCommMonoid A
inst✝¹ : CanonicallyOrderedAdd A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ kl.2 ≤ n
|
rw [le_iff_exists_add]
|
A : Type u_1
inst✝² : OrderedAddCommMonoid A
inst✝¹ : CanonicallyOrderedAdd A
inst✝ : HasAntidiagonal A
n : A
kl : A × A
hlk : kl ∈ antidiagonal n
⊢ ∃ c, n = kl.2 + c
|
a346e570b0197919
|
EReal.add_pos
|
Mathlib/Data/Real/EReal.lean
|
theorem add_pos {a b : EReal} (ha : 0 < a) (hb : 0 < b) : 0 < a + b
|
case h_real
b : EReal
hb : 0 < b
a✝ : ℝ
ha : 0 < ↑a✝
⊢ 0 < ↑a✝ + b
|
induction b
|
case h_real.h_bot
a✝ : ℝ
ha : 0 < ↑a✝
hb : 0 < ⊥
⊢ 0 < ↑a✝ + ⊥
case h_real.h_real
a✝¹ : ℝ
ha : 0 < ↑a✝¹
a✝ : ℝ
hb : 0 < ↑a✝
⊢ 0 < ↑a✝¹ + ↑a✝
case h_real.h_top
a✝ : ℝ
ha : 0 < ↑a✝
hb : 0 < ⊤
⊢ 0 < ↑a✝ + ⊤
|
ea146a9f917f5977
|
CategoryTheory.Grothendieck.fiber_eqToHom
|
Mathlib/CategoryTheory/Grothendieck.lean
|
theorem fiber_eqToHom {X Y : Grothendieck F} (h : X = Y) :
(eqToHom h).fiber = eqToHom (by subst h; simp)
|
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₁
inst✝ : Category.{v₁, u₁} D
F : C ⥤ Cat
X : Grothendieck F
⊢ (F.map (eqToHom ⋯).base).obj X.fiber = X.fiber
|
simp
|
no goals
|
6408252bccdc4edc
|
Array.toList_filterMap'
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem toList_filterMap' (f : α → Option β) (l : Array α) (w : stop = l.size) :
(l.filterMap f 0 stop).toList = l.toList.filterMap f
|
α : Type u_1
β : Type u_2
f : α → Option β
l : Array α
⊢ (filterMap f l).toList = List.filterMap f l.toList
|
dsimp only [filterMap, filterMapM]
|
α : Type u_1
β : Type u_2
f : α → Option β
l : Array α
⊢ (foldlM
(fun bs a => do
let __do_lift ← f a
match __do_lift with
| some b => pure (bs.push b)
| none => pure bs)
#[] l).run.toList =
List.filterMap f l.toList
|
0bf06d250b5cdb33
|
gramSchmidt_orthogonal
|
Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
|
theorem gramSchmidt_orthogonal (f : ι → E) {a b : ι} (h₀ : a ≠ b) :
⟪gramSchmidt 𝕜 f a, gramSchmidt 𝕜 f b⟫ = 0
|
case neg.h
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : WellFoundedLT ι
f : ι → E
b✝ b : ι
ih : ∀ y < b, ∀ a < y, inner (gramSchmidt 𝕜 f a) (gramSchmidt 𝕜 f y) = 0
a : ι
h₀ : a < b
h : ¬gramSchmidt 𝕜 f a = 0
⊢ inner (gramSchmidt 𝕜 f a) (gramSchmidt 𝕜 f a) ≠ 0
|
rwa [inner_self_ne_zero]
|
no goals
|
a5e33da8a7158e66
|
ProbabilityTheory.cond_iInter
|
Mathlib/Probability/Independence/Basic.lean
|
/-- The probability of an intersection of preimages conditioning on another intersection factors
into a product. -/
lemma cond_iInter [Finite ι] (hY : ∀ i, Measurable (Y i))
(hindep : iIndepFun (fun _ ↦ mα.prod mβ) (fun i ω ↦ (X i ω, Y i ω)) μ)
(hf : ∀ i ∈ s, MeasurableSet[mα.comap (X i)] (f i))
(hy : ∀ i ∉ s, μ (Y i ⁻¹' t i) ≠ 0) (ht : ∀ i, MeasurableSet (t i)) :
μ[⋂ i ∈ s, f i | ⋂ i, Y i ⁻¹' t i] = ∏ i ∈ s, μ[f i | Y i in t i]
|
ι : Type u_6
Ω : Type u_7
α : Type u_8
β : Type u_9
mΩ : MeasurableSpace Ω
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure Ω
X : ι → Ω → α
Y : ι → Ω → β
f : ι → Set Ω
t : ι → Set β
s : Finset ι
inst✝ : Finite ι
hY : ∀ (i : ι), Measurable (Y i)
hindep : iIndepFun (fun x => mα.prod mβ) (fun i ω => (X i ω, Y i ω)) μ
hf : ∀ i ∈ s, MeasurableSet (f i)
hy : ∀ i ∉ s, μ (Y i ⁻¹' t i) ≠ 0
ht : ∀ (i : ι), MeasurableSet (t i)
this : IsProbabilityMeasure μ
val✝ : Fintype ι
g : ι → Set Ω := fun i' => if i' ∈ s then Y i' ⁻¹' t i' ∩ f i' else Y i' ⁻¹' t i'
i : ι
⊢ MeasurableSet (g i)
|
by_cases hi : i ∈ s <;> simp only [hi, ↓reduceIte, g]
|
case pos
ι : Type u_6
Ω : Type u_7
α : Type u_8
β : Type u_9
mΩ : MeasurableSpace Ω
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure Ω
X : ι → Ω → α
Y : ι → Ω → β
f : ι → Set Ω
t : ι → Set β
s : Finset ι
inst✝ : Finite ι
hY : ∀ (i : ι), Measurable (Y i)
hindep : iIndepFun (fun x => mα.prod mβ) (fun i ω => (X i ω, Y i ω)) μ
hf : ∀ i ∈ s, MeasurableSet (f i)
hy : ∀ i ∉ s, μ (Y i ⁻¹' t i) ≠ 0
ht : ∀ (i : ι), MeasurableSet (t i)
this : IsProbabilityMeasure μ
val✝ : Fintype ι
g : ι → Set Ω := fun i' => if i' ∈ s then Y i' ⁻¹' t i' ∩ f i' else Y i' ⁻¹' t i'
i : ι
hi : i ∈ s
⊢ MeasurableSet (Y i ⁻¹' t i ∩ f i)
case neg
ι : Type u_6
Ω : Type u_7
α : Type u_8
β : Type u_9
mΩ : MeasurableSpace Ω
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure Ω
X : ι → Ω → α
Y : ι → Ω → β
f : ι → Set Ω
t : ι → Set β
s : Finset ι
inst✝ : Finite ι
hY : ∀ (i : ι), Measurable (Y i)
hindep : iIndepFun (fun x => mα.prod mβ) (fun i ω => (X i ω, Y i ω)) μ
hf : ∀ i ∈ s, MeasurableSet (f i)
hy : ∀ i ∉ s, μ (Y i ⁻¹' t i) ≠ 0
ht : ∀ (i : ι), MeasurableSet (t i)
this : IsProbabilityMeasure μ
val✝ : Fintype ι
g : ι → Set Ω := fun i' => if i' ∈ s then Y i' ⁻¹' t i' ∩ f i' else Y i' ⁻¹' t i'
i : ι
hi : i ∉ s
⊢ MeasurableSet (Y i ⁻¹' t i)
|
299952e2d8d690c9
|
Order.Ideal.isProper_of_not_mem
|
Mathlib/Order/Ideal.lean
|
theorem isProper_of_not_mem {I : Ideal P} {p : P} (nmem : p ∉ I) : IsProper I :=
⟨fun hp ↦ by
have := mem_univ p
rw [← hp] at this
exact nmem this⟩
|
P : Type u_1
inst✝ : LE P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
⊢ False
|
have := mem_univ p
|
P : Type u_1
inst✝ : LE P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ univ
⊢ False
|
eedecb497d07f70f
|
Std.Sat.AIG.RefVec.zip.go_get_aux
|
Mathlib/.lake/packages/lean4/src/lean/Std/Sat/AIG/RefVecOperator/Zip.lean
|
theorem go_get_aux {aig : AIG α} (curr : Nat) (hcurr : curr ≤ len) (s : RefVec aig curr)
(lhs rhs : RefVec aig len) (f : (aig : AIG α) → BinaryInput aig → Entrypoint α)
[LawfulOperator α BinaryInput f] [chainable : LawfulZipOperator α f] :
-- The hfoo here is a trick to make the dependent type gods happy
∀ (idx : Nat) (hidx : idx < curr) (hfoo),
(go aig curr s hcurr lhs rhs f).vec.get idx (by omega)
=
(s.get idx hidx).cast hfoo
|
case isFalse
α : Type
inst✝² : Hashable α
inst✝¹ : DecidableEq α
len : Nat
aig : AIG α
curr : Nat
hcurr : curr ≤ len
s : aig.RefVec curr
lhs rhs : aig.RefVec len
f : (aig : AIG α) → aig.BinaryInput → Entrypoint α
inst✝ : LawfulOperator α BinaryInput f
chainable : LawfulZipOperator α f
idx : Nat
hidx : idx < curr
res : RefVecEntry α len
h✝ : ¬curr < len
hgo : { aig := aig, vec := ⋯ ▸ s } = res
⊢ ∀ (hfoo : aig.decls.size ≤ res.aig.decls.size), res.vec.get idx ⋯ = (s.get idx hidx).cast hfoo
|
rw [← hgo]
|
case isFalse
α : Type
inst✝² : Hashable α
inst✝¹ : DecidableEq α
len : Nat
aig : AIG α
curr : Nat
hcurr : curr ≤ len
s : aig.RefVec curr
lhs rhs : aig.RefVec len
f : (aig : AIG α) → aig.BinaryInput → Entrypoint α
inst✝ : LawfulOperator α BinaryInput f
chainable : LawfulZipOperator α f
idx : Nat
hidx : idx < curr
res : RefVecEntry α len
h✝ : ¬curr < len
hgo : { aig := aig, vec := ⋯ ▸ s } = res
⊢ ∀ (hfoo : aig.decls.size ≤ { aig := aig, vec := ⋯ ▸ s }.aig.decls.size),
{ aig := aig, vec := ⋯ ▸ s }.vec.get idx ⋯ = (s.get idx hidx).cast hfoo
|
90c056b58a9b7a80
|
orderOf_pow_dvd
|
Mathlib/GroupTheory/OrderOfElement.lean
|
theorem orderOf_pow_dvd (n : ℕ) : orderOf (x ^ n) ∣ orderOf x
|
G : Type u_1
inst✝ : Monoid G
x : G
n : ℕ
⊢ orderOf (x ^ n) ∣ orderOf x
|
rw [orderOf_dvd_iff_pow_eq_one, pow_right_comm, pow_orderOf_eq_one, one_pow]
|
no goals
|
68c1a84e882fb930
|
FreeGroup.Red.red_iff_irreducible
|
Mathlib/GroupTheory/FreeGroup/Basic.lean
|
theorem red_iff_irreducible {x1 b1 x2 b2} (h : (x1, b1) ≠ (x2, b2)) :
Red [(x1, !b1), (x2, b2)] L ↔ L = [(x1, !b1), (x2, b2)]
|
α : Type u
L : List (α × Bool)
x1 : α
b1 : Bool
x2 : α
b2 : Bool
h : (x1, b1) ≠ (x2, b2)
⊢ Red [(x1, !b1), (x2, b2)] L ↔ L = [(x1, !b1), (x2, b2)]
|
apply reflTransGen_iff_eq
|
case h
α : Type u
L : List (α × Bool)
x1 : α
b1 : Bool
x2 : α
b2 : Bool
h : (x1, b1) ≠ (x2, b2)
⊢ ∀ (b : List (α × Bool)), ¬Step [(x1, !b1), (x2, b2)] b
|
f87886f761db64c8
|
Array.mapM_map_eq_foldl
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem mapM_map_eq_foldl (as : Array α) (f : α → β) (i) :
mapM.map (m := Id) f as i b = as.foldl (start := i) (fun r a => r.push (f a)) b
|
α : Type u_1
β : Type u_2
b : Array β
as : Array α
f : α → β
i : Nat
⊢ (if hlt : i < as.size then do
let __do_lift ← f as[i]
mapM.map f as (i + 1) (b.push __do_lift)
else pure b) =
foldl (fun r a => r.push (f a)) b as i
|
split <;> rename_i h
|
case isTrue
α : Type u_1
β : Type u_2
b : Array β
as : Array α
f : α → β
i : Nat
h : i < as.size
⊢ (do
let __do_lift ← f as[i]
mapM.map f as (i + 1) (b.push __do_lift)) =
foldl (fun r a => r.push (f a)) b as i
case isFalse
α : Type u_1
β : Type u_2
b : Array β
as : Array α
f : α → β
i : Nat
h : ¬i < as.size
⊢ pure b = foldl (fun r a => r.push (f a)) b as i
|
a2d615417b2bd811
|
MonoidHom.noncommCoprod_range
|
Mathlib/GroupTheory/NoncommCoprod.lean
|
lemma noncommCoprod_range {M N P : Type*} [Group M] [Group N] [Group P]
(f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) :
(noncommCoprod f g comm).range = f.range ⊔ g.range
|
case a.left.intro
M : Type u_4
N : Type u_5
P : Type u_6
inst✝² : Group M
inst✝¹ : Group N
inst✝ : Group P
f : M →* P
g : N →* P
comm : ∀ (m : M) (n : N), Commute (f m) (g n)
a : M
⊢ f a ∈ (f.noncommCoprod g comm).range
|
exact ⟨(a, 1), by rw [noncommCoprod_apply, map_one, mul_one]⟩
|
no goals
|
a43981614b1c4850
|
SimpleGraph.Walk.takeUntil_takeUntil
|
Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkDecomp.lean
|
lemma takeUntil_takeUntil {w x : V} (p : G.Walk u v) (hw : w ∈ p.support)
(hx : x ∈ (p.takeUntil w hw).support) :
(p.takeUntil w hw).takeUntil x hx = p.takeUntil x (p.support_takeUntil_subset hw hx)
|
case case3
V : Type u
G : SimpleGraph V
v u : V
inst✝ : DecidableEq V
w x : V
p : G.Walk u v
a w' v' : V
hadj : G.Adj a v'
q : G.Walk v' w'
u' : V
hu'✝ : u' ∈ (cons hadj q).support
hau'✝ : ¬a = u'
hau' : a ≠ u'
x✝ : u' ∈ (cons hadj q).support
ih : ∀ (hx : x ∈ (q.takeUntil u' ⋯).support), (q.takeUntil u' ⋯).takeUntil x hx = q.takeUntil x ⋯
hx✝ : x ∈ ((cons hadj q).takeUntil u' hu'✝).support
hu' : u' ∈ q.support
hx : x = a ∨ x ∈ (q.takeUntil u' hu').support
⊢ ((cons hadj q).takeUntil u' hu'✝).takeUntil x hx✝ = (cons hadj q).takeUntil x ⋯
|
by_cases hx' : x = a
|
case pos
V : Type u
G : SimpleGraph V
v u : V
inst✝ : DecidableEq V
w x : V
p : G.Walk u v
a w' v' : V
hadj : G.Adj a v'
q : G.Walk v' w'
u' : V
hu'✝ : u' ∈ (cons hadj q).support
hau'✝ : ¬a = u'
hau' : a ≠ u'
x✝ : u' ∈ (cons hadj q).support
ih : ∀ (hx : x ∈ (q.takeUntil u' ⋯).support), (q.takeUntil u' ⋯).takeUntil x hx = q.takeUntil x ⋯
hx✝ : x ∈ ((cons hadj q).takeUntil u' hu'✝).support
hu' : u' ∈ q.support
hx : x = a ∨ x ∈ (q.takeUntil u' hu').support
hx' : x = a
⊢ ((cons hadj q).takeUntil u' hu'✝).takeUntil x hx✝ = (cons hadj q).takeUntil x ⋯
case neg
V : Type u
G : SimpleGraph V
v u : V
inst✝ : DecidableEq V
w x : V
p : G.Walk u v
a w' v' : V
hadj : G.Adj a v'
q : G.Walk v' w'
u' : V
hu'✝ : u' ∈ (cons hadj q).support
hau'✝ : ¬a = u'
hau' : a ≠ u'
x✝ : u' ∈ (cons hadj q).support
ih : ∀ (hx : x ∈ (q.takeUntil u' ⋯).support), (q.takeUntil u' ⋯).takeUntil x hx = q.takeUntil x ⋯
hx✝ : x ∈ ((cons hadj q).takeUntil u' hu'✝).support
hu' : u' ∈ q.support
hx : x = a ∨ x ∈ (q.takeUntil u' hu').support
hx' : ¬x = a
⊢ ((cons hadj q).takeUntil u' hu'✝).takeUntil x hx✝ = (cons hadj q).takeUntil x ⋯
|
c3b1f330685fe6f0
|
Cycle.support_formPerm
|
Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
|
theorem support_formPerm [Fintype α] (s : Cycle α) (h : Nodup s) (hn : Nontrivial s) :
support (formPerm s h) = s.toFinset
|
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Cycle α
h : s.Nodup
hn : s.Nontrivial
⊢ (s.formPerm h).support = s.toFinset
|
induction' s using Quot.inductionOn with s
|
case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : List α
h : Nodup (Quot.mk (⇑(IsRotated.setoid α)) s)
hn : Nontrivial (Quot.mk (⇑(IsRotated.setoid α)) s)
⊢ (formPerm (Quot.mk (⇑(IsRotated.setoid α)) s) h).support = toFinset (Quot.mk (⇑(IsRotated.setoid α)) s)
|
c975caac8b3ab4b4
|
Vector.toArray_mapM_go
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lemmas.lean
|
theorem toArray_mapM_go [Monad m] [LawfulMonad m] (f : α → m β) (v : Vector α n) (i h r) :
toArray <$> mapM.go f v i h r = Array.mapM.map f v.toArray i r.toArray
|
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
n : Nat
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
v : Vector α n
i : Nat
h : i ≤ n
r : Vector β i
⊢ (toArray <$>
if h' : i < n then do
let __do_lift ← f v[i]
mapM.go f v (i + 1) ⋯ (r.push __do_lift)
else pure (Vector.cast ⋯ r)) =
Array.mapM.map f v.toArray i r.toArray
|
unfold Array.mapM.map
|
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
n : Nat
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
v : Vector α n
i : Nat
h : i ≤ n
r : Vector β i
⊢ (toArray <$>
if h' : i < n then do
let __do_lift ← f v[i]
mapM.go f v (i + 1) ⋯ (r.push __do_lift)
else pure (Vector.cast ⋯ r)) =
if hlt : i < v.size then do
let __do_lift ← f v.toArray[i]
Array.mapM.map f v.toArray (i + 1) (r.push __do_lift)
else pure r.toArray
|
b8bb1e3d17c268d2
|
IsAntichain.volume_eq_zero
|
Mathlib/MeasureTheory/Order/UpperLower.lean
|
theorem IsAntichain.volume_eq_zero [Nonempty ι] (hs : IsAntichain (· ≤ ·) s) : volume s = 0
|
ι : Type u_1
inst✝¹ : Fintype ι
s : Set (ι → ℝ)
inst✝ : Nonempty ι
hs : IsAntichain (fun x1 x2 => x1 ≤ x2) s
⊢ s ⊆ frontier s
|
rw [← closure_diff_interior, hs.interior_eq_empty, diff_empty]
|
ι : Type u_1
inst✝¹ : Fintype ι
s : Set (ι → ℝ)
inst✝ : Nonempty ι
hs : IsAntichain (fun x1 x2 => x1 ≤ x2) s
⊢ s ⊆ closure s
|
e697af406be31b26
|
PFunctor.M.ext
|
Mathlib/Data/PFunctor/Univariate/M.lean
|
theorem ext [Inhabited (M F)] (x y : M F) (H : ∀ ps : Path F, iselect ps x = iselect ps y) :
x = y
|
case H.succ.hrec
F : PFunctor.{u}
inst✝ : Inhabited F.M
x y : F.M
H : ∀ (ps : Path F), (isubtree ps x).head = (isubtree ps y).head
i : ℕ
i_ih : x.approx i = y.approx i
ps : Path F
H' : i = length ps
⊢ iselect ps x = iselect ps y
|
cases H'
|
case H.succ.hrec.refl
F : PFunctor.{u}
inst✝ : Inhabited F.M
x y : F.M
H : ∀ (ps : Path F), (isubtree ps x).head = (isubtree ps y).head
ps : Path F
i_ih : x.approx (length ps) = y.approx (length ps)
⊢ iselect ps x = iselect ps y
|
d42c81fe4cdd416b
|
Submodule.span_preimage_eq
|
Mathlib/LinearAlgebra/Quotient/Basic.lean
|
theorem span_preimage_eq [RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {s : Set M₂} (h₀ : s.Nonempty)
(h₁ : s ⊆ range f) : span R (f ⁻¹' s) = (span R₂ s).comap f
|
R : Type u_1
M : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
R₂ : Type u_3
M₂ : Type u_4
inst✝³ : Ring R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
s : Set M₂
h₀ : s.Nonempty
h₁ : s ⊆ ↑(range f)
y : M₂ := Classical.choose h₀
hy : y ∈ s
⊢ ker f ≤ span R (⇑f ⁻¹' s)
|
rw [ker_le_iff]
|
R : Type u_1
M : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
R₂ : Type u_3
M₂ : Type u_4
inst✝³ : Ring R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
s : Set M₂
h₀ : s.Nonempty
h₁ : s ⊆ ↑(range f)
y : M₂ := Classical.choose h₀
hy : y ∈ s
⊢ ∃ y ∈ range f, ⇑f ⁻¹' {y} ⊆ ↑(span R (⇑f ⁻¹' s))
|
5560c859997de634
|
Matrix.det_eq_of_forall_row_eq_smul_add_const_aux
|
Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
|
theorem det_eq_of_forall_row_eq_smul_add_const_aux {A B : Matrix n n R} {s : Finset n} :
∀ (c : n → R) (_ : ∀ i, i ∉ s → c i = 0) (k : n) (_ : k ∉ s)
(_ : ∀ i j, A i j = B i j + c i * B k j), det A = det B
|
case empty
n : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
⊢ ∀ (c : n → R), (∀ i ∉ ∅, c i = 0) → ∀ k ∉ ∅, (∀ (i j : n), A i j = B i j + c i * B k j) → A.det = B.det
|
rintro c hs k - A_eq
|
case empty
n : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
hs : ∀ i ∉ ∅, c i = 0
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
⊢ A.det = B.det
|
7739d96b149cd534
|
Equiv.Perm.cycle_zpow_mem_support_iff
|
Mathlib/GroupTheory/Perm/Cycle/Basic.lean
|
theorem cycle_zpow_mem_support_iff {g : Perm α}
(hg : g.IsCycle) {n : ℤ} {x : α} (hx : g x ≠ x) :
(g ^ n) x = x ↔ n % #g.support = 0
|
case mp
α : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g : Perm α
hg : g.IsCycle
n : ℤ
x : α
hx : g x ≠ x
q : ℤ := n / ↑(#g.support)
r : ℤ := n % ↑(#g.support)
m : ℕ
hm : r = ↑m
div_euc : ↑m + ↑(orderOf g) * q = n ∧ m < orderOf g
⊢ (g ^ m) x = x → g ^ m = 1
|
intro hgm
|
case mp
α : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g : Perm α
hg : g.IsCycle
n : ℤ
x : α
hx : g x ≠ x
q : ℤ := n / ↑(#g.support)
r : ℤ := n % ↑(#g.support)
m : ℕ
hm : r = ↑m
div_euc : ↑m + ↑(orderOf g) * q = n ∧ m < orderOf g
hgm : (g ^ m) x = x
⊢ g ^ m = 1
|
53814599c33ac8eb
|
HomologicalComplex.extendCyclesIso_inv_iCycles
|
Mathlib/Algebra/Homology/Embedding/ExtendHomology.lean
|
@[reassoc (attr := simp)]
lemma extendCyclesIso_inv_iCycles :
(K.extendCyclesIso e hj').inv ≫ (K.extend e).iCycles j' =
K.iCycles j ≫ (K.extendXIso e hj').inv
|
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝⁴ : Category.{u_4, u_3} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroObject C
K : HomologicalComplex C c
e : c.Embedding c'
j : ι
j' : ι'
hj' : e.f j = j'
inst✝¹ : K.HasHomology j
inst✝ : (K.extend e).HasHomology j'
⊢ (K.extendCyclesIso e hj').inv ≫ (K.extend e).iCycles j' = K.iCycles j ≫ (K.extendXIso e hj').inv
|
simp only [← cancel_epi (K.extendCyclesIso e hj').hom, Iso.hom_inv_id_assoc,
extendCyclesIso_hom_iCycles_assoc, Iso.hom_inv_id, comp_id]
|
no goals
|
e2549df1b0ab6814
|
SeminormFamily.basisSets_intersect
|
Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
|
theorem basisSets_intersect (U V : Set E) (hU : U ∈ p.basisSets) (hV : V ∈ p.basisSets) :
∃ z ∈ p.basisSets, z ⊆ U ∩ V
|
case h
𝕜 : Type u_1
E : Type u_5
ι : Type u_8
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
U V : Set E
hU✝ : U ∈ p.basisSets
hV✝ : V ∈ p.basisSets
s : Finset ι
r₁ : ℝ
hr₁ : 0 < r₁
hU : U = (s.sup p).ball 0 r₁
t : Finset ι
r₂ : ℝ
hr₂ : 0 < r₂
hV : V = (t.sup p).ball 0 r₂
⊢ ((s ∪ t).sup p).ball 0 (r₁ ⊓ r₂) ∈ p.basisSets ∧ ((s ∪ t).sup p).ball 0 (r₁ ⊓ r₂) ⊆ U ∩ V
|
refine ⟨p.basisSets_mem (s ∪ t) (lt_min_iff.mpr ⟨hr₁, hr₂⟩), ?_⟩
|
case h
𝕜 : Type u_1
E : Type u_5
ι : Type u_8
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
U V : Set E
hU✝ : U ∈ p.basisSets
hV✝ : V ∈ p.basisSets
s : Finset ι
r₁ : ℝ
hr₁ : 0 < r₁
hU : U = (s.sup p).ball 0 r₁
t : Finset ι
r₂ : ℝ
hr₂ : 0 < r₂
hV : V = (t.sup p).ball 0 r₂
⊢ ((s ∪ t).sup p).ball 0 (r₁ ⊓ r₂) ⊆ U ∩ V
|
b495b149a3cd9a84
|
Matrix.mulVec_surjective_iff_exists_right_inverse
|
Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
|
theorem mulVec_surjective_iff_exists_right_inverse
[DecidableEq m] [Finite m] [Fintype n] {A : Matrix m n R} :
Function.Surjective A.mulVec ↔ ∃ B : Matrix n m R, A * B = 1
|
m : Type u
n : Type u'
R : Type u_2
inst✝³ : Semiring R
inst✝² : DecidableEq m
inst✝¹ : Finite m
inst✝ : Fintype n
A : Matrix m n R
⊢ Function.Surjective A.mulVec ↔ ∃ B, A * B = 1
|
cases nonempty_fintype m
|
case intro
m : Type u
n : Type u'
R : Type u_2
inst✝³ : Semiring R
inst✝² : DecidableEq m
inst✝¹ : Finite m
inst✝ : Fintype n
A : Matrix m n R
val✝ : Fintype m
⊢ Function.Surjective A.mulVec ↔ ∃ B, A * B = 1
|
e2574278ca6dc051
|
Vector.any_eq_false
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lemmas.lean
|
theorem any_eq_false {p : α → Bool} {xs : Vector α n} :
xs.any p = false ↔ ∀ (i : Nat) (_ : i < n), ¬p xs[i]
|
α : Type u_1
n : Nat
p : α → Bool
xs : Vector α n
⊢ (¬∃ i x, p xs[i] = true) ↔ ∀ (i : Nat) (x : i < n), ¬p xs[i] = true
|
simp
|
no goals
|
f691f53d621bf9a1
|
MeasureTheory.integral_simpleFunc_larger_space
|
Mathlib/MeasureTheory/Integral/Bochner.lean
|
theorem integral_simpleFunc_larger_space (hm : m ≤ m0) (f : @SimpleFunc β m F)
(hf_int : Integrable f μ) :
∫ x, f x ∂μ = ∑ x ∈ @SimpleFunc.range β F m f, ENNReal.toReal (μ (f ⁻¹' {x})) • x
|
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
β : Type u_6
m m0 : MeasurableSpace β
μ : Measure β
hm : m ≤ m0
f : β →ₛ F
hf_int : Integrable (⇑f) μ
⊢ Integrable (⇑(SimpleFunc.toLargerSpace hm f)) μ
|
rwa [SimpleFunc.coe_toLargerSpace_eq]
|
no goals
|
f561880c405f28b4
|
Fintype.nonempty_field_iff
|
Mathlib/FieldTheory/Cardinality.lean
|
theorem Fintype.nonempty_field_iff {α} [Fintype α] : Nonempty (Field α) ↔ IsPrimePow ‖α‖
|
α : Type u_1
inst✝ : Fintype α
⊢ IsPrimePow ‖α‖ → Nonempty (Field α)
|
rintro ⟨p, n, hp, hn, hα⟩
|
case intro.intro.intro.intro
α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Prime p
hn : 0 < n
hα : p ^ n = ‖α‖
⊢ Nonempty (Field α)
|
3fa2a395eda1ffe4
|
MeasureTheory.not_frequently_of_upcrossings_lt_top
|
Mathlib/Probability/Martingale/Convergence.lean
|
theorem not_frequently_of_upcrossings_lt_top (hab : a < b) (hω : upcrossings a b f ω ≠ ∞) :
¬((∃ᶠ n in atTop, f n ω < a) ∧ ∃ᶠ n in atTop, b < f n ω)
|
case intro
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hω : ∃ k, ∀ (N : ℕ), upcrossingsBefore a b f N ω < k
h₁ : ∀ (a_1 : ℕ), ∃ b ≥ a_1, f b ω < a
h₂ : ∀ (a : ℕ), ∃ b_1 ≥ a, b < f b_1 ω
⊢ False
|
refine Classical.not_not.2 hω ?_
|
case intro
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hω : ∃ k, ∀ (N : ℕ), upcrossingsBefore a b f N ω < k
h₁ : ∀ (a_1 : ℕ), ∃ b ≥ a_1, f b ω < a
h₂ : ∀ (a : ℕ), ∃ b_1 ≥ a, b < f b_1 ω
⊢ ¬∃ k, ∀ (N : ℕ), upcrossingsBefore a b f N ω < k
|
123352cc62fc6065
|
FractionalIdeal.mul_one_div_le_one
|
Mathlib/RingTheory/FractionalIdeal/Operations.lean
|
theorem mul_one_div_le_one {I : FractionalIdeal R₁⁰ K} : I * (1 / I) ≤ 1
|
case neg
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 : FractionalIdeal R₁⁰ K
hI : ¬I = 0
⊢ I * (1 / I) ≤ 1
|
rw [← coe_le_coe, coe_mul, coe_div hI, coe_one]
|
case neg
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 : FractionalIdeal R₁⁰ K
hI : ¬I = 0
⊢ ↑I * (1 / ↑I) ≤ 1
|
7b63428ed5392dc6
|
ProbabilityTheory.strong_law_Lp
|
Mathlib/Probability/StrongLaw.lean
|
theorem strong_law_Lp {p : ℝ≥0∞} (hp : 1 ≤ p) (hp' : p ≠ ∞) (X : ℕ → Ω → E)
(hℒp : MemLp (X 0) p μ) (hindep : Pairwise ((IndepFun · · μ) on X))
(hident : ∀ i, IdentDistrib (X i) (X 0) μ μ) :
Tendsto (fun (n : ℕ) => eLpNorm (fun ω => (n : ℝ) ⁻¹ • (∑ i ∈ range n, X i ω) - μ[X 0]) p μ)
atTop (𝓝 0)
|
case neg
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
p : ℝ≥0∞
hp : 1 ≤ p
hp' : p ≠ ⊤
X : ℕ → Ω → E
hℒp : MemLp (X 0) p μ
hindep : Pairwise ((fun x1 x2 => IndepFun x1 x2 μ) on X)
hident : ∀ (i : ℕ), IdentDistrib (X i) (X 0) μ μ
h : ¬∀ᵐ (ω : Ω) ∂μ, X 0 ω = 0
this : IsProbabilityMeasure μ
hmeas : ∀ (i : ℕ), AEStronglyMeasurable (X i) μ
hint : Integrable (X 0) μ
havg : ∀ (n : ℕ), AEStronglyMeasurable (fun ω => (↑n)⁻¹ • ∑ i ∈ range n, X i ω) μ
⊢ UnifIntegrable (fun n => (↑n)⁻¹ • ∑ i ∈ range n, X i) p μ
|
apply UniformIntegrable.unifIntegrable
|
case neg.hf
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
p : ℝ≥0∞
hp : 1 ≤ p
hp' : p ≠ ⊤
X : ℕ → Ω → E
hℒp : MemLp (X 0) p μ
hindep : Pairwise ((fun x1 x2 => IndepFun x1 x2 μ) on X)
hident : ∀ (i : ℕ), IdentDistrib (X i) (X 0) μ μ
h : ¬∀ᵐ (ω : Ω) ∂μ, X 0 ω = 0
this : IsProbabilityMeasure μ
hmeas : ∀ (i : ℕ), AEStronglyMeasurable (X i) μ
hint : Integrable (X 0) μ
havg : ∀ (n : ℕ), AEStronglyMeasurable (fun ω => (↑n)⁻¹ • ∑ i ∈ range n, X i ω) μ
⊢ UniformIntegrable (fun n => (↑n)⁻¹ • ∑ i ∈ range n, X i) p μ
|
8d69987f63824be4
|
MvPowerSeries.coeff_mul_right_one_sub_of_lt_order
|
Mathlib/RingTheory/MvPowerSeries/Order.lean
|
theorem coeff_mul_right_one_sub_of_lt_order (d : σ →₀ ℕ) (h : degree d < g.order) :
coeff R d ((1 - g) * f) = coeff R d f
|
σ : Type u_1
R : Type u_3
inst✝ : Ring R
f g : MvPowerSeries σ R
d : σ →₀ ℕ
h : ↑((weight fun x => 1) d) < g.order
⊢ (coeff R d) ((1 - g) * f) = (coeff R d) f
|
exact coeff_mul_right_one_sub_of_lt_weightedOrder _ h
|
no goals
|
9ca22027bb019392
|
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
n : ℕ
⊢ n ≤ 2 * n
|
omega
|
no goals
|
8204a47cf4df7c65
|
Matrix.Nondegenerate.toBilin'
|
Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
|
theorem _root_.Matrix.Nondegenerate.toBilin' {M : Matrix ι ι R₂} (h : M.Nondegenerate) :
M.toBilin'.Nondegenerate := fun x hx =>
h.eq_zero_of_ortho fun y => by simpa only [toBilin'_apply'] using hx y
|
R₂ : Type u_3
inst✝² : CommRing R₂
ι : Type u_6
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
M : Matrix ι ι R₂
h : M.Nondegenerate
x : ι → R₂
hx : ∀ (n : ι → R₂), ((Matrix.toBilin' M) x) n = 0
y : ι → R₂
⊢ x ⬝ᵥ M *ᵥ y = 0
|
simpa only [toBilin'_apply'] using hx y
|
no goals
|
1afb909a5fd4bc4d
|
spectrum_diagonal
|
Mathlib/LinearAlgebra/Eigenspace/Matrix.lean
|
/-- The spectrum of the diagonal operator is the range of the diagonal viewed as a function. -/
lemma spectrum_diagonal [Field R] (d : n → R) :
spectrum R (diagonal d) = Set.range d
|
case h
R : Type u_1
n : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : Field R
d : n → R
μ : R
⊢ μ ∈ spectrum R (diagonal d) ↔ μ ∈ Set.range d
|
rw [← AlgEquiv.spectrum_eq (toLinAlgEquiv <| Pi.basisFun R n), ← hasEigenvalue_iff_mem_spectrum]
|
case h
R : Type u_1
n : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : Field R
d : n → R
μ : R
⊢ HasEigenvalue ((toLinAlgEquiv (Pi.basisFun R n)) (diagonal d)) μ ↔ μ ∈ Set.range d
|
bc4a66fe7e0f27f7
|
MonomialOrder.div
|
Mathlib/RingTheory/MvPolynomial/Groebner.lean
|
theorem div {ι : Type*} {b : ι → MvPolynomial σ R}
(hb : ∀ i, IsUnit (m.leadingCoeff (b i))) (f : MvPolynomial σ R) :
∃ (g : ι →₀ (MvPolynomial σ R)) (r : MvPolynomial σ R),
f = Finsupp.linearCombination _ b g + r ∧
(∀ i, m.degree (b i * (g i)) ≼[m] m.degree f) ∧
(∀ c ∈ r.support, ∀ i, ¬ (m.degree (b i) ≤ c))
|
case neg
σ : Type u_1
m : MonomialOrder σ
R : Type u_2
inst✝ : CommRing R
ι : Type u_3
b : ι → MvPolynomial σ R
hb : ∀ (i : ι), IsUnit (m.leadingCoeff (b i))
f : MvPolynomial σ R
hb' : ∀ (i : ι), m.degree (b i) ≠ 0
hf0 : ¬f = 0
hf : ∀ (i : ι), ¬m.degree (b i) ≤ m.degree f
g' : ι →₀ MvPolynomial σ R
r' : MvPolynomial σ R
H' :
m.subLTerm f = (Finsupp.linearCombination (MvPolynomial σ R) b) g' + r' ∧
(∀ (i : ι), m.toSyn (m.degree (b i * g' i)) ≤ m.toSyn (m.degree (m.subLTerm f))) ∧
∀ c ∈ r'.support, ∀ (i : ι), ¬m.degree (b i) ≤ c
c : σ →₀ ℕ
hc : c ∈ (r' + (monomial (m.degree f)) (m.leadingCoeff f)).support
i : ι
hc' : c ∉ r'.support
⊢ ¬m.degree (b i) ≤ c
|
convert hf i
|
case h.e'_1.h.e'_4
σ : Type u_1
m : MonomialOrder σ
R : Type u_2
inst✝ : CommRing R
ι : Type u_3
b : ι → MvPolynomial σ R
hb : ∀ (i : ι), IsUnit (m.leadingCoeff (b i))
f : MvPolynomial σ R
hb' : ∀ (i : ι), m.degree (b i) ≠ 0
hf0 : ¬f = 0
hf : ∀ (i : ι), ¬m.degree (b i) ≤ m.degree f
g' : ι →₀ MvPolynomial σ R
r' : MvPolynomial σ R
H' :
m.subLTerm f = (Finsupp.linearCombination (MvPolynomial σ R) b) g' + r' ∧
(∀ (i : ι), m.toSyn (m.degree (b i * g' i)) ≤ m.toSyn (m.degree (m.subLTerm f))) ∧
∀ c ∈ r'.support, ∀ (i : ι), ¬m.degree (b i) ≤ c
c : σ →₀ ℕ
hc : c ∈ (r' + (monomial (m.degree f)) (m.leadingCoeff f)).support
i : ι
hc' : c ∉ r'.support
⊢ c = m.degree f
|
f995acdac7645677
|
EReal.limsup_add_bot_of_ne_top
|
Mathlib/Topology/Instances/EReal/Lemmas.lean
|
lemma limsup_add_bot_of_ne_top (h : limsup u f = ⊥) (h' : limsup v f ≠ ⊤) :
limsup (u + v) f = ⊥
|
α : Type u_3
f : Filter α
u v : α → EReal
h : limsup u f = ⊥
h' : limsup v f ≠ ⊤
⊢ ⊥ ≠ ⊤ ∨ limsup v f ≠ ⊥
|
exact .inl bot_ne_top
|
no goals
|
41c306a0a8f0f954
|
HallMarriageTheorem.hall_hard_inductive_step_A
|
Mathlib/Combinatorics/Hall/Finite.lean
|
theorem hall_hard_inductive_step_A {n : ℕ} (hn : Fintype.card ι = n + 1)
(ht : ∀ s : Finset ι, #s ≤ #(s.biUnion t))
(ih :
∀ {ι' : Type u} [Fintype ι'] (t' : ι' → Finset α),
Fintype.card ι' ≤ n →
(∀ s' : Finset ι', #s' ≤ #(s'.biUnion t')) →
∃ f : ι' → α, Function.Injective f ∧ ∀ x, f x ∈ t' x)
(ha : ∀ s : Finset ι, s.Nonempty → s ≠ univ → #s < #(s.biUnion t)) :
∃ f : ι → α, Function.Injective f ∧ ∀ x, f x ∈ t x
|
ι : Type u
α : Type v
inst✝¹ : DecidableEq α
t : ι → Finset α
inst✝ : Fintype ι
n : ℕ
hn : Fintype.card ι = n + 1
ht : ∀ (s : Finset ι), #s ≤ #(s.biUnion t)
ih :
∀ {ι' : Type u} [inst : Fintype ι'] (t' : ι' → Finset α),
Fintype.card ι' ≤ n →
(∀ (s' : Finset ι'), #s' ≤ #(s'.biUnion t')) → ∃ f, Function.Injective f ∧ ∀ (x : ι'), f x ∈ t' x
ha : ∀ (s : Finset ι), s.Nonempty → s ≠ univ → #s < #(s.biUnion t)
this✝ : Nonempty ι
this : DecidableEq ι
x : ι := Classical.arbitrary ι
y : α
hy : y ∈ t x
ι' : Set ι := {x' | x' ≠ x}
t' : ↑ι' → Finset α := fun x' => (t ↑x').erase y
card_ι' : Fintype.card ↑ι' = n
f' : ↑ι' → α
hfinj : Function.Injective f'
hfr : ∀ (x : ↑ι'), f' x ∈ t' x
z₁ z₂ : ι
⊢ ∀ {x : ↑ι'}, y ≠ f' x
|
intro x h
|
ι : Type u
α : Type v
inst✝¹ : DecidableEq α
t : ι → Finset α
inst✝ : Fintype ι
n : ℕ
hn : Fintype.card ι = n + 1
ht : ∀ (s : Finset ι), #s ≤ #(s.biUnion t)
ih :
∀ {ι' : Type u} [inst : Fintype ι'] (t' : ι' → Finset α),
Fintype.card ι' ≤ n →
(∀ (s' : Finset ι'), #s' ≤ #(s'.biUnion t')) → ∃ f, Function.Injective f ∧ ∀ (x : ι'), f x ∈ t' x
ha : ∀ (s : Finset ι), s.Nonempty → s ≠ univ → #s < #(s.biUnion t)
this✝ : Nonempty ι
this : DecidableEq ι
x✝ : ι := Classical.arbitrary ι
y : α
hy : y ∈ t x✝
ι' : Set ι := {x' | x' ≠ x✝}
t' : ↑ι' → Finset α := fun x' => (t ↑x').erase y
card_ι' : Fintype.card ↑ι' = n
f' : ↑ι' → α
hfinj : Function.Injective f'
hfr : ∀ (x : ↑ι'), f' x ∈ t' x
z₁ z₂ : ι
x : ↑ι'
h : y = f' x
⊢ False
|
258330b4009c5e5d
|
IsPrimitiveRoot.minpoly_dvd_pow_mod
|
Mathlib/RingTheory/RootsOfUnity/Minpoly.lean
|
theorem minpoly_dvd_pow_mod {p : ℕ} [hprime : Fact p.Prime] (hdiv : ¬p ∣ n) :
map (Int.castRingHom (ZMod p)) (minpoly ℤ μ) ∣
map (Int.castRingHom (ZMod p)) (minpoly ℤ (μ ^ p)) ^ p
|
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
p : ℕ
hprime : Fact (Nat.Prime p)
hdiv : ¬p ∣ n
Q : ℤ[X] := minpoly ℤ (μ ^ p)
hfrob : map (Int.castRingHom (ZMod p)) Q ^ p = map (Int.castRingHom (ZMod p)) ((expand ℤ p) Q)
⊢ map (Int.castRingHom (ZMod p)) (minpoly ℤ μ) ∣ map (Int.castRingHom (ZMod p)) ((expand ℤ p) Q)
|
apply RingHom.map_dvd (mapRingHom (Int.castRingHom (ZMod p)))
|
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
p : ℕ
hprime : Fact (Nat.Prime p)
hdiv : ¬p ∣ n
Q : ℤ[X] := minpoly ℤ (μ ^ p)
hfrob : map (Int.castRingHom (ZMod p)) Q ^ p = map (Int.castRingHom (ZMod p)) ((expand ℤ p) Q)
⊢ minpoly ℤ μ ∣ (expand ℤ p) Q
|
f3a17101a3651aa0
|
MeasureTheory.continuousOn_convolution_right_with_param
|
Mathlib/Analysis/Convolution.lean
|
theorem continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
(hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
(hf : LocallyIntegrable f μ) (hg : ContinuousOn (↿g) (s ×ˢ univ)) :
ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ)
|
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
F : Type uF
P : Type uP
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup E'
inst✝¹¹ : NormedAddCommGroup F
f : G → E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁶ : MeasurableSpace G
μ : Measure G
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : AddGroup G
inst✝³ : TopologicalSpace G
inst✝² : IsTopologicalAddGroup G
inst✝¹ : BorelSpace G
inst✝ : TopologicalSpace P
g : P → G → E'
s : Set P
k : Set G
hk : IsCompact k
hgs : ∀ (p : P) (x : G), p ∈ s → x ∉ k → g p x = 0
hf : LocallyIntegrable f μ
hg : ContinuousOn (↿g) (s ×ˢ univ)
H : ¬∀ p ∈ s, ∀ (x : G), g p x = 0
this✝ : LocallyCompactSpace G
q₀ : P
x₀ : G
hq₀ : (q₀, x₀).1 ∈ s
t : Set G
t_comp : IsCompact t
ht : t ∈ 𝓝 x₀
k' : Set G := -k +ᵥ t
k'_comp : IsCompact k'
g' : P × G → G → E' := fun p x => g p.1 (p.2 - x)
s' : Set (P × G) := s ×ˢ t
this : uncurry g' = uncurry g ∘ fun w => (w.1.1, w.1.2 - w.2)
⊢ ContinuousOn (uncurry g') (s' ×ˢ univ)
|
rw [this]
|
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
F : Type uF
P : Type uP
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup E'
inst✝¹¹ : NormedAddCommGroup F
f : G → E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁶ : MeasurableSpace G
μ : Measure G
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : AddGroup G
inst✝³ : TopologicalSpace G
inst✝² : IsTopologicalAddGroup G
inst✝¹ : BorelSpace G
inst✝ : TopologicalSpace P
g : P → G → E'
s : Set P
k : Set G
hk : IsCompact k
hgs : ∀ (p : P) (x : G), p ∈ s → x ∉ k → g p x = 0
hf : LocallyIntegrable f μ
hg : ContinuousOn (↿g) (s ×ˢ univ)
H : ¬∀ p ∈ s, ∀ (x : G), g p x = 0
this✝ : LocallyCompactSpace G
q₀ : P
x₀ : G
hq₀ : (q₀, x₀).1 ∈ s
t : Set G
t_comp : IsCompact t
ht : t ∈ 𝓝 x₀
k' : Set G := -k +ᵥ t
k'_comp : IsCompact k'
g' : P × G → G → E' := fun p x => g p.1 (p.2 - x)
s' : Set (P × G) := s ×ˢ t
this : uncurry g' = uncurry g ∘ fun w => (w.1.1, w.1.2 - w.2)
⊢ ContinuousOn (uncurry g ∘ fun w => (w.1.1, w.1.2 - w.2)) (s' ×ˢ univ)
|
a579c7593509cfe8
|
MeasurableEmbedding.rnDeriv_map
|
Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
|
lemma _root_.MeasurableEmbedding.rnDeriv_map (hf : MeasurableEmbedding f)
(μ ν : Measure α) [SigmaFinite μ] [SigmaFinite ν] :
(fun x ↦ (μ.map f).rnDeriv (ν.map f) (f x)) =ᵐ[ν] μ.rnDeriv ν
|
case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
this✝¹ : SigmaFinite (map f ν)
this✝ : SigmaFinite (map f (μ.singularPart ν))
this : SigmaFinite (map f (ν.withDensity (μ.rnDeriv ν)))
h_add :
(fun x => (map f (μ.singularPart ν) + map f (ν.withDensity (μ.rnDeriv ν))).rnDeriv (map f ν) (f x)) =ᶠ[ae ν] fun x =>
((map f (μ.singularPart ν)).rnDeriv (map f ν) + (map f (ν.withDensity (μ.rnDeriv ν))).rnDeriv (map f ν)) (f x)
⊢ (fun x => (map f (μ.singularPart ν)).rnDeriv (map f ν) x) =ᶠ[ae (map f ν)] 0
|
refine Measure.rnDeriv_eq_zero_of_mutuallySingular ?_ Measure.AbsolutelyContinuous.rfl
|
case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
this✝¹ : SigmaFinite (map f ν)
this✝ : SigmaFinite (map f (μ.singularPart ν))
this : SigmaFinite (map f (ν.withDensity (μ.rnDeriv ν)))
h_add :
(fun x => (map f (μ.singularPart ν) + map f (ν.withDensity (μ.rnDeriv ν))).rnDeriv (map f ν) (f x)) =ᶠ[ae ν] fun x =>
((map f (μ.singularPart ν)).rnDeriv (map f ν) + (map f (ν.withDensity (μ.rnDeriv ν))).rnDeriv (map f ν)) (f x)
⊢ map f (μ.singularPart ν) ⟂ₘ map f ν
|
ea80b5c7d85148f7
|
MvPolynomial.totalDegree_add_eq_left_of_totalDegree_lt
|
Mathlib/Algebra/MvPolynomial/Degrees.lean
|
theorem totalDegree_add_eq_left_of_totalDegree_lt {p q : MvPolynomial σ R}
(h : q.totalDegree < p.totalDegree) : (p + q).totalDegree = p.totalDegree
|
R : Type u
σ : Type u_1
inst✝ : CommSemiring R
p q : MvPolynomial σ R
h : q.totalDegree < p.totalDegree
hp : ¬p = 0
b : σ →₀ ℕ
hb₁ : b ∈ p.support
hb₂ : (p.support.sup fun m => (toMultiset m).card) = (toMultiset b).card
⊢ b ∉ q.support
|
contrapose! h
|
R : Type u
σ : Type u_1
inst✝ : CommSemiring R
p q : MvPolynomial σ R
hp : ¬p = 0
b : σ →₀ ℕ
hb₁ : b ∈ p.support
hb₂ : (p.support.sup fun m => (toMultiset m).card) = (toMultiset b).card
h : b ∈ q.support
⊢ p.totalDegree ≤ q.totalDegree
|
554f88c9f1d39d60
|
Set.Definable.image_comp_embedding
|
Mathlib/ModelTheory/Definability.lean
|
theorem Definable.image_comp_embedding {s : Set (β → M)} (h : A.Definable L s) (f : α ↪ β)
[Finite β] : A.Definable L ((fun g : β → M => g ∘ f) '' s)
|
case intro
M : Type w
A : Set M
L : Language
inst✝¹ : L.Structure M
α : Type u₁
β : Type u_1
s : Set (β → M)
h : A.Definable L s
f : α ↪ β
inst✝ : Finite β
val✝ : Fintype β
x : α → M
⊢ x ∈
(fun g => g ∘ Sum.inl) ''
((fun g => g ∘ ⇑((Equiv.ofInjective ⇑f ⋯).sumCongr (Fintype.equivFin ↑(range ⇑f)ᶜ).symm)) ''
((fun g => g ∘ ⇑(Equiv.Set.sumCompl (range ⇑f))) '' s)) ↔
x ∈ (fun g => g ∘ ⇑f) '' s
|
simp only [mem_preimage, mem_image, exists_exists_and_eq_and]
|
case intro
M : Type w
A : Set M
L : Language
inst✝¹ : L.Structure M
α : Type u₁
β : Type u_1
s : Set (β → M)
h : A.Definable L s
f : α ↪ β
inst✝ : Finite β
val✝ : Fintype β
x : α → M
⊢ (∃ a ∈ s,
((a ∘ ⇑(Equiv.Set.sumCompl (range ⇑f))) ∘
⇑((Equiv.ofInjective ⇑f ⋯).sumCongr (Fintype.equivFin ↑(range ⇑f)ᶜ).symm)) ∘
Sum.inl =
x) ↔
∃ x_1 ∈ s, x_1 ∘ ⇑f = x
|
7b3adb8c33237ade
|
CategoryTheory.Arrow.functor_ext
|
Mathlib/CategoryTheory/Comma/Arrow.lean
|
/-- Extensionality lemma for functors `C ⥤ D` which uses as an assumption
that the induced maps `Arrow C → Arrow D` coincide. -/
lemma Arrow.functor_ext {F G : C ⥤ D} (h : ∀ ⦃X Y : C⦄ (f : X ⟶ Y),
F.mapArrow.obj (Arrow.mk f) = G.mapArrow.obj (Arrow.mk f)) :
F = G :=
Functor.ext (fun X ↦ congr_arg Comma.left (h (𝟙 X))) (fun X Y f ↦ by
have := h f
simp only [Functor.mapArrow_obj, mk_eq_mk_iff] at this
tauto)
|
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F G : C ⥤ D
h : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), F.mapArrow.obj (mk f) = G.mapArrow.obj (mk f)
X Y : C
f : X ⟶ Y
this : ∃ hX hY, F.map (mk f).hom = eqToHom hX ≫ G.map (mk f).hom ≫ eqToHom ⋯
⊢ F.map f = eqToHom ⋯ ≫ G.map f ≫ eqToHom ⋯
|
tauto
|
no goals
|
8fbf458ec71e16c4
|
Polynomial.Monic.sub_of_right
|
Mathlib/Algebra/Polynomial/Monic.lean
|
theorem Monic.sub_of_right {p q : R[X]} (hq : q.leadingCoeff = -1) (hpq : degree p < degree q) :
Monic (p - q)
|
R : Type u
inst✝ : Ring R
p q : R[X]
hq : q.leadingCoeff = -1
hpq : p.degree < q.degree
this : (-q).coeff (-q).natDegree = 1
⊢ (p - q).Monic
|
rw [sub_eq_add_neg]
|
R : Type u
inst✝ : Ring R
p q : R[X]
hq : q.leadingCoeff = -1
hpq : p.degree < q.degree
this : (-q).coeff (-q).natDegree = 1
⊢ (p + -q).Monic
|
0f87bd252fa796db
|
Matrix.stdBasisMatrix_eq_of_single_single
|
Mathlib/Data/Matrix/Basis.lean
|
theorem stdBasisMatrix_eq_of_single_single (i : m) (j : n) (a : α) :
stdBasisMatrix i j a = Matrix.of (Pi.single i (Pi.single j a))
|
m : Type u_2
n : Type u_3
α : Type u_5
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Zero α
i : m
j : n
a : α
⊢ stdBasisMatrix i j a = of (Pi.single i (Pi.single j a))
|
ext a b
|
case a
m : Type u_2
n : Type u_3
α : Type u_5
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Zero α
i : m
j : n
a✝ : α
a : m
b : n
⊢ stdBasisMatrix i j a✝ a b = of (Pi.single i (Pi.single j a✝)) a b
|
4ae8f56c1d529f84
|
ProbabilityTheory.Kernel.IndepSet.measure_inter_eq_mul
|
Mathlib/Probability/Independence/Kernel.lean
|
theorem IndepSet.measure_inter_eq_mul {_m0 : MeasurableSpace Ω} (κ : Kernel α Ω) (μ : Measure α)
(h : IndepSet s t κ μ) : ∀ᵐ a ∂μ, κ a (s ∩ t) = κ a s * κ a t :=
Indep.indepSets h _ _ (by simp) (by simp)
|
α : Type u_1
Ω : Type u_2
_mα : MeasurableSpace α
s t : Set Ω
_m0 : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
h : IndepSet s t κ μ
⊢ s ∈ {s}
|
simp
|
no goals
|
04d47f0b74fc340f
|
AlgebraicGeometry.SurjectiveOnStalks.isEmbedding_pullback
|
Mathlib/AlgebraicGeometry/Morphisms/SurjectiveOnStalks.lean
|
/-- If `Y ⟶ S` is surjective on stalks, then for every `X ⟶ S`, `X ×ₛ Y` is a subset of
`X × Y` (cartesian product as topological spaces) with the induced topology. -/
lemma isEmbedding_pullback {X Y S : Scheme.{u}} (f : X ⟶ S) (g : Y ⟶ S) [SurjectiveOnStalks g] :
IsEmbedding (fun x ↦ ((pullback.fst f g).base x, (pullback.snd f g).base x))
|
case refine_2.intro.intro.intro.intro.intro.intro.refine_3
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
inst✝ : SurjectiveOnStalks g
L : ↑↑(pullback f g).toPresheafedSpace → ↑↑X.toPresheafedSpace × ↑↑Y.toPresheafedSpace :=
fun x => ((ConcreteCategory.hom (pullback.fst f g).base) x, (ConcreteCategory.hom (pullback.snd f g).base) x)
H :
∀ (R A B : CommRingCat) (f' : Spec A ⟶ Spec R) (g' : Spec B ⟶ Spec R) (iX : Spec A ⟶ X) (iY : Spec B ⟶ Y)
(iS : Spec R ⟶ S) (e₁ : f' ≫ iS = iX ≫ f) (e₂ : g' ≫ iS = iY ≫ g),
IsOpenImmersion iX →
IsOpenImmersion iY →
IsOpenImmersion iS → IsEmbedding (L ∘ ⇑(ConcreteCategory.hom (pullback.map f' g' f g iX iY iS e₁ e₂).base))
𝒰 : S.OpenCover := S.affineOpenCover.openCover
𝒱 : (i : (Scheme.Cover.pullbackCover 𝒰 f).J) → ((Scheme.Cover.pullbackCover 𝒰 f).obj i).OpenCover :=
fun i => ((Scheme.Cover.pullbackCover 𝒰 f).obj i).affineOpenCover.openCover
𝒲 : (i : (Scheme.Cover.pullbackCover 𝒰 g).J) → ((Scheme.Cover.pullbackCover 𝒰 g).obj i).OpenCover :=
fun i => ((Scheme.Cover.pullbackCover 𝒰 g).obj i).affineOpenCover.openCover
U : (i : (Scheme.Cover.pullbackCover 𝒰 f).J) × (𝒱 i).J × (𝒲 i).J →
TopologicalSpace.Opens (↑↑X.toPresheafedSpace × ↑↑Y.toPresheafedSpace) :=
fun ijk =>
{
carrier :=
{P |
P.1 ∈ Scheme.Hom.opensRange ((𝒱 ijk.fst).map ijk.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map ijk.fst) ∧
P.2 ∈ Scheme.Hom.opensRange ((𝒲 ijk.fst).map ijk.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map ijk.fst)},
is_open' := ⋯ }
this : Set.range L ⊆ ↑(iSup U)
𝓤 : Scheme.Cover (@IsOpenImmersion) (pullback f g) :=
Scheme.Cover.bind (Scheme.Pullback.openCoverOfBase 𝒰 f g) fun i =>
Scheme.Pullback.openCoverOfLeftRight (𝒱 i) (𝒲 i) (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i))
i : (i : (Scheme.Cover.pullbackCover 𝒰 f).J) × (𝒱 i).J × (𝒲 i).J
x : ↑↑(pullback f g).toPresheafedSpace
x₁ : ↑↑((𝒱 i.fst).obj i.snd.1).toPresheafedSpace
hx₁ :
(ConcreteCategory.hom ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst).base) x₁ =
((fun x => ((ConcreteCategory.hom (pullback.fst f g).base) x, (ConcreteCategory.hom (pullback.snd f g).base) x))
x).1
x₂ : ↑↑((𝒲 i.fst).obj i.snd.2).toPresheafedSpace
hx₂ :
(ConcreteCategory.hom ((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst).base) x₂ =
((fun x => ((ConcreteCategory.hom (pullback.fst f g).base) x, (ConcreteCategory.hom (pullback.snd f g).base) x))
x).2
x₁' :
↑↑(pullback (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst)).toPresheafedSpace
hx₁' :
(ConcreteCategory.hom
(pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst)).base)
x₁' =
x
x₂' :
↑↑(pullback (pullback.snd f g) ((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst)).toPresheafedSpace
hx₂' :
(ConcreteCategory.hom
(pullback.fst (pullback.snd f g) ((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst)).base)
x₂' =
x
z :
↑↑(pullback (pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst))
(pullback.fst (pullback.snd f g)
((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst))).toPresheafedSpace
hz :
(ConcreteCategory.hom
(pullback.fst
(pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst))
(pullback.fst (pullback.snd f g)
((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst))).base)
z =
x₁'
⊢ (ConcreteCategory.hom
((pullbackFstFstIso ((𝒱 i.fst).map i.snd.1 ≫ pullback.snd f (𝒰.map i.fst))
((𝒲 i.fst).map i.snd.2 ≫ pullback.snd g (𝒰.map i.fst)) f g
((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst)
((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst) (𝒰.map i.fst) ⋯ ⋯).hom ≫
𝓤.map i).base)
z =
(ConcreteCategory.hom
(pullback.fst
(pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst))
(pullback.fst (pullback.snd f g) ((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst)) ≫
pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst)).base)
z
|
congr 5
|
case refine_2.intro.intro.intro.intro.intro.intro.refine_3.e_a.e_a.e_self.e_self.e_self
X Y S : Scheme
f : X ⟶ S
g : Y ⟶ S
inst✝ : SurjectiveOnStalks g
L : ↑↑(pullback f g).toPresheafedSpace → ↑↑X.toPresheafedSpace × ↑↑Y.toPresheafedSpace :=
fun x => ((ConcreteCategory.hom (pullback.fst f g).base) x, (ConcreteCategory.hom (pullback.snd f g).base) x)
H :
∀ (R A B : CommRingCat) (f' : Spec A ⟶ Spec R) (g' : Spec B ⟶ Spec R) (iX : Spec A ⟶ X) (iY : Spec B ⟶ Y)
(iS : Spec R ⟶ S) (e₁ : f' ≫ iS = iX ≫ f) (e₂ : g' ≫ iS = iY ≫ g),
IsOpenImmersion iX →
IsOpenImmersion iY →
IsOpenImmersion iS → IsEmbedding (L ∘ ⇑(ConcreteCategory.hom (pullback.map f' g' f g iX iY iS e₁ e₂).base))
𝒰 : S.OpenCover := S.affineOpenCover.openCover
𝒱 : (i : (Scheme.Cover.pullbackCover 𝒰 f).J) → ((Scheme.Cover.pullbackCover 𝒰 f).obj i).OpenCover :=
fun i => ((Scheme.Cover.pullbackCover 𝒰 f).obj i).affineOpenCover.openCover
𝒲 : (i : (Scheme.Cover.pullbackCover 𝒰 g).J) → ((Scheme.Cover.pullbackCover 𝒰 g).obj i).OpenCover :=
fun i => ((Scheme.Cover.pullbackCover 𝒰 g).obj i).affineOpenCover.openCover
U : (i : (Scheme.Cover.pullbackCover 𝒰 f).J) × (𝒱 i).J × (𝒲 i).J →
TopologicalSpace.Opens (↑↑X.toPresheafedSpace × ↑↑Y.toPresheafedSpace) :=
fun ijk =>
{
carrier :=
{P |
P.1 ∈ Scheme.Hom.opensRange ((𝒱 ijk.fst).map ijk.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map ijk.fst) ∧
P.2 ∈ Scheme.Hom.opensRange ((𝒲 ijk.fst).map ijk.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map ijk.fst)},
is_open' := ⋯ }
this : Set.range L ⊆ ↑(iSup U)
𝓤 : Scheme.Cover (@IsOpenImmersion) (pullback f g) :=
Scheme.Cover.bind (Scheme.Pullback.openCoverOfBase 𝒰 f g) fun i =>
Scheme.Pullback.openCoverOfLeftRight (𝒱 i) (𝒲 i) (pullback.snd f (𝒰.map i)) (pullback.snd g (𝒰.map i))
i : (i : (Scheme.Cover.pullbackCover 𝒰 f).J) × (𝒱 i).J × (𝒲 i).J
x : ↑↑(pullback f g).toPresheafedSpace
x₁ : ↑↑((𝒱 i.fst).obj i.snd.1).toPresheafedSpace
hx₁ :
(ConcreteCategory.hom ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst).base) x₁ =
((fun x => ((ConcreteCategory.hom (pullback.fst f g).base) x, (ConcreteCategory.hom (pullback.snd f g).base) x))
x).1
x₂ : ↑↑((𝒲 i.fst).obj i.snd.2).toPresheafedSpace
hx₂ :
(ConcreteCategory.hom ((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst).base) x₂ =
((fun x => ((ConcreteCategory.hom (pullback.fst f g).base) x, (ConcreteCategory.hom (pullback.snd f g).base) x))
x).2
x₁' :
↑↑(pullback (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst)).toPresheafedSpace
hx₁' :
(ConcreteCategory.hom
(pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst)).base)
x₁' =
x
x₂' :
↑↑(pullback (pullback.snd f g) ((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst)).toPresheafedSpace
hx₂' :
(ConcreteCategory.hom
(pullback.fst (pullback.snd f g) ((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst)).base)
x₂' =
x
z :
↑↑(pullback (pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst))
(pullback.fst (pullback.snd f g)
((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst))).toPresheafedSpace
hz :
(ConcreteCategory.hom
(pullback.fst
(pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst))
(pullback.fst (pullback.snd f g)
((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst))).base)
z =
x₁'
⊢ (pullbackFstFstIso ((𝒱 i.fst).map i.snd.1 ≫ pullback.snd f (𝒰.map i.fst))
((𝒲 i.fst).map i.snd.2 ≫ pullback.snd g (𝒰.map i.fst)) f g
((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst)
((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst) (𝒰.map i.fst) ⋯ ⋯).hom ≫
𝓤.map i =
pullback.fst (pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst))
(pullback.fst (pullback.snd f g) ((𝒲 i.fst).map i.snd.2 ≫ (Scheme.Cover.pullbackCover 𝒰 g).map i.fst)) ≫
pullback.fst (pullback.fst f g) ((𝒱 i.fst).map i.snd.1 ≫ (Scheme.Cover.pullbackCover 𝒰 f).map i.fst)
|
9509c1734d72b9a6
|
RingHom.finiteType_holdsForLocalizationAway
|
Mathlib/RingTheory/RingHom/FiniteType.lean
|
theorem finiteType_holdsForLocalizationAway : HoldsForLocalizationAway @FiniteType
|
case h.e'_5.h
R S : Type u_1
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : IsLocalization.Away r S
this : Algebra.FiniteType R S
r✝ : R
x✝ : S
⊢ (let_fun I := (algebraMap R S).toAlgebra;
r✝ • x✝) =
r✝ • x✝
|
rw [Algebra.smul_def]
|
case h.e'_5.h
R S : Type u_1
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : IsLocalization.Away r S
this : Algebra.FiniteType R S
r✝ : R
x✝ : S
⊢ (let_fun I := (algebraMap R S).toAlgebra;
r✝ • x✝) =
(algebraMap R S) r✝ * x✝
|
97309f76efa63e45
|
Int.le_ceil_iff
|
Mathlib/Algebra/Order/Floor.lean
|
lemma le_ceil_iff : z ≤ ⌈a⌉ ↔ z - 1 < a
|
α : Type u_2
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ z ≤ ⌈a⌉ ↔ ↑z - 1 < a
|
rw [← sub_one_lt_iff, lt_ceil]
|
α : Type u_2
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ↑(z - 1) < a ↔ ↑z - 1 < a
|
a0620efd241d7464
|
MeasureTheory.aemeasurable_withDensity_ennreal_iff'
|
Mathlib/MeasureTheory/Measure/WithDensity.lean
|
theorem aemeasurable_withDensity_ennreal_iff' {f : α → ℝ≥0}
(hf : AEMeasurable f μ) {g : α → ℝ≥0∞} :
AEMeasurable g (μ.withDensity fun x => (f x : ℝ≥0∞)) ↔
AEMeasurable (fun x => (f x : ℝ≥0∞) * g x) μ
|
case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
f' : α → ℝ≥0
hf'_m : Measurable f'
hf'_ae : f =ᶠ[ae μ] f'
g' : α → ℝ≥0∞
g'meas : Measurable g'
hg' : ∀ᵐ (x : α) ∂μ, ↑(f x) ≠ 0 → g x = g' x
A : MeasurableSet {x | f' x ≠ 0}
a : α
ha : ↑(f a) ≠ 0 → g a = g' a
h'a : f a = f' a
h_a_nonneg : f' a ≠ 0
⊢ ↑(f a) * g a = ↑(f' a) * g' a
|
have : (f' a : ℝ≥0∞) ≠ 0 := by simpa only [Ne, ENNReal.coe_eq_zero] using h_a_nonneg
|
case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
f' : α → ℝ≥0
hf'_m : Measurable f'
hf'_ae : f =ᶠ[ae μ] f'
g' : α → ℝ≥0∞
g'meas : Measurable g'
hg' : ∀ᵐ (x : α) ∂μ, ↑(f x) ≠ 0 → g x = g' x
A : MeasurableSet {x | f' x ≠ 0}
a : α
ha : ↑(f a) ≠ 0 → g a = g' a
h'a : f a = f' a
h_a_nonneg : f' a ≠ 0
this : ↑(f' a) ≠ 0
⊢ ↑(f a) * g a = ↑(f' a) * g' a
|
8b1f28ad3ee0d17a
|
bernsteinPolynomial.iterate_derivative_at_0
|
Mathlib/RingTheory/Polynomial/Bernstein.lean
|
theorem iterate_derivative_at_0 (n ν : ℕ) :
(Polynomial.derivative^[ν] (bernsteinPolynomial R n ν)).eval 0 =
(ascPochhammer R ν).eval ((n - (ν - 1) : ℕ) : R)
|
case pos.succ.inr
R : Type u_1
inst✝ : CommRing R
ν : ℕ
ih :
∀ (n : ℕ), ν ≤ n → eval 0 ((⇑derivative)^[ν] (bernsteinPolynomial R n ν)) = eval (↑(n - (ν - 1))) (ascPochhammer R ν)
n : ℕ
h : ν + 1 ≤ n
h' : ν ≤ n - 1
h'' : ν > 0
⊢ ↑n * eval (↑(n - 1 - (ν - 1))) (ascPochhammer R ν) = ↑(n - ν) * eval (↑(n - ν) + 1) (ascPochhammer R ν)
|
have : n - 1 - (ν - 1) = n - ν := by omega
|
case pos.succ.inr
R : Type u_1
inst✝ : CommRing R
ν : ℕ
ih :
∀ (n : ℕ), ν ≤ n → eval 0 ((⇑derivative)^[ν] (bernsteinPolynomial R n ν)) = eval (↑(n - (ν - 1))) (ascPochhammer R ν)
n : ℕ
h : ν + 1 ≤ n
h' : ν ≤ n - 1
h'' : ν > 0
this : n - 1 - (ν - 1) = n - ν
⊢ ↑n * eval (↑(n - 1 - (ν - 1))) (ascPochhammer R ν) = ↑(n - ν) * eval (↑(n - ν) + 1) (ascPochhammer R ν)
|
2869d2a115228592
|
Ordinal.principal_mul_iff_mul_left_eq
|
Mathlib/SetTheory/Ordinal/Principal.lean
|
theorem principal_mul_iff_mul_left_eq : Principal (· * ·) o ↔ ∀ a, 0 < a → a < o → a * o = o
|
case h.e'_2.h.e'_5.a
o : Ordinal.{u}
h : Principal (fun x1 x2 => x1 * x2) o
a : Ordinal.{u}
ha₀ : 0 < a
hao : a < o
ho : o ≤ 2
⊢ a < 2
|
exact hao.trans_le ho
|
no goals
|
5ae376ccba37fa39
|
MeasurableSet.iUnion_of_monotone_of_frequently
|
Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
|
theorem iUnion_of_monotone_of_frequently
{ι : Type*} [Preorder ι] [(atTop : Filter ι).IsCountablyGenerated] {s : ι → Set α}
(hsm : Monotone s) (hs : ∃ᶠ i in atTop, MeasurableSet (s i)) : MeasurableSet (⋃ i, s i)
|
case intro.intro
α : Type u_1
inst✝² : MeasurableSpace α
ι : Type u_6
inst✝¹ : Preorder ι
inst✝ : atTop.IsCountablyGenerated
s : ι → Set α
hsm : Monotone s
hs : ∃ᶠ (i : ι) in atTop, MeasurableSet (s i)
x : ℕ → ι
hx : Tendsto x atTop atTop
hxm : ∀ (n : ℕ), MeasurableSet (s (x n))
⊢ MeasurableSet (⋃ i, s i)
|
rw [← hsm.iUnion_comp_tendsto_atTop hx]
|
case intro.intro
α : Type u_1
inst✝² : MeasurableSpace α
ι : Type u_6
inst✝¹ : Preorder ι
inst✝ : atTop.IsCountablyGenerated
s : ι → Set α
hsm : Monotone s
hs : ∃ᶠ (i : ι) in atTop, MeasurableSet (s i)
x : ℕ → ι
hx : Tendsto x atTop atTop
hxm : ∀ (n : ℕ), MeasurableSet (s (x n))
⊢ MeasurableSet (⋃ a, s (x a))
|
eaf9c9d5846defea
|
AdicCompletion.ofTensorProduct_iso
|
Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
|
private lemma ofTensorProduct_iso [Fintype ι] [IsNoetherianRing R] :
IsIso (ModuleCat.ofHom (ofTensorProduct I M))
|
case refine_4
R : Type u
inst✝⁴ : CommRing R
I : Ideal R
M : Type u
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type
f : (ι → R) →ₗ[R] M
hf : Function.Surjective ⇑f
inst✝¹ : Fintype ι
inst✝ : IsNoetherianRing R
⊢ Mono (ComposableArrows.app' (AdicCompletion.firstRowToSecondRow I M f) 4 ⋯)
|
apply ConcreteCategory.mono_of_injective
|
case refine_4.i
R : Type u
inst✝⁴ : CommRing R
I : Ideal R
M : Type u
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type
f : (ι → R) →ₗ[R] M
hf : Function.Surjective ⇑f
inst✝¹ : Fintype ι
inst✝ : IsNoetherianRing R
⊢ Function.Injective ⇑(ConcreteCategory.hom (ComposableArrows.app' (AdicCompletion.firstRowToSecondRow I M f) 4 ⋯))
|
76224af4d5a35f57
|
PreTilt.valAux_eq
|
Mathlib/RingTheory/Perfection.lean
|
theorem valAux_eq {f : PreTilt O p} {n : ℕ} (hfn : coeff _ _ n f ≠ 0) :
valAux K v O p f = ModP.preVal K v O p (coeff _ _ n f) ^ p ^ n
|
case intro.succ.intro
K : Type u₁
inst✝⁴ : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝³ : CommRing O
inst✝² : Algebra O K
hv : v.Integers O
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact ¬IsUnit ↑p
f : PreTilt O p
h : ∃ n, (coeff (ModP O p) p n) f ≠ 0
k : ℕ
ih :
(coeff (ModP O p) p (Nat.find h + k)) f ≠ 0 →
ModP.preVal K v O p ((coeff (ModP O p) p (Nat.find h)) f) ^ p ^ Nat.find h =
ModP.preVal K v O p ((coeff (ModP O p) p (Nat.find h + k)) f) ^ p ^ (Nat.find h + k)
hfn : (coeff (ModP O p) p (Nat.find h + (k + 1))) f ≠ 0
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x = (coeff (ModP O p) p (Nat.find h + k + 1)) f
h1 : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
⊢ ModP.preVal K v O p ((coeff (ModP O p) p (Nat.find h)) f) ^ p ^ Nat.find h =
ModP.preVal K v O p ((coeff (ModP O p) p (Nat.find h + (k + 1))) f) ^ p ^ (Nat.find h + (k + 1))
|
have h2 : (Ideal.Quotient.mk _ (x ^ p) : ModP O p) ≠ 0 := by
erw [RingHom.map_pow, hx, ← RingHom.map_pow, coeff_pow_p]
exact coeff_nat_find_add_ne_zero k
|
case intro.succ.intro
K : Type u₁
inst✝⁴ : Field K
v : Valuation K ℝ≥0
O : Type u₂
inst✝³ : CommRing O
inst✝² : Algebra O K
hv : v.Integers O
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact ¬IsUnit ↑p
f : PreTilt O p
h : ∃ n, (coeff (ModP O p) p n) f ≠ 0
k : ℕ
ih :
(coeff (ModP O p) p (Nat.find h + k)) f ≠ 0 →
ModP.preVal K v O p ((coeff (ModP O p) p (Nat.find h)) f) ^ p ^ Nat.find h =
ModP.preVal K v O p ((coeff (ModP O p) p (Nat.find h + k)) f) ^ p ^ (Nat.find h + k)
hfn : (coeff (ModP O p) p (Nat.find h + (k + 1))) f ≠ 0
x : O
hx : (Ideal.Quotient.mk (Ideal.span {↑p})) x = (coeff (ModP O p) p (Nat.find h + k + 1)) f
h1 : (Ideal.Quotient.mk (Ideal.span {↑p})) x ≠ 0
h2 : (Ideal.Quotient.mk (Ideal.span {↑p})) (x ^ p) ≠ 0
⊢ ModP.preVal K v O p ((coeff (ModP O p) p (Nat.find h)) f) ^ p ^ Nat.find h =
ModP.preVal K v O p ((coeff (ModP O p) p (Nat.find h + (k + 1))) f) ^ p ^ (Nat.find h + (k + 1))
|
821b0935f5925da0
|
TrivSqZeroExt.norm_inl
|
Mathlib/Analysis/Normed/Algebra/TrivSqZeroExt.lean
|
theorem norm_inl (r : R) : ‖(inl r : tsze R M)‖ = ‖r‖
|
R : Type u_3
M : Type u_4
inst✝¹ : SeminormedRing R
inst✝ : SeminormedAddCommGroup M
r : R
⊢ ‖inl r‖ = ‖r‖
|
simp [norm_def]
|
no goals
|
47694de979f8454e
|
PrimeSpectrum.isCompact_basicOpen
|
Mathlib/RingTheory/Spectrum/Prime/Topology.lean
|
theorem isCompact_basicOpen (f : R) : IsCompact (basicOpen f : Set (PrimeSpectrum R))
|
R : Type u
inst✝ : CommSemiring R
f : R
⊢ IsCompact ↑(basicOpen f)
|
rw [← localization_away_comap_range (Localization (Submonoid.powers f))]
|
R : Type u
inst✝ : CommSemiring R
f : R
⊢ IsCompact (Set.range ⇑(comap (algebraMap R (Localization (Submonoid.powers f)))))
|
5fb4b47b3c5996fe
|
UpperSet.mem_iInf_iff
|
Mathlib/Order/UpperLower/Basic.lean
|
theorem mem_iInf_iff {f : ι → UpperSet α} : (a ∈ ⨅ i, f i) ↔ ∃ i, a ∈ f i
|
α : Type u_1
ι : Sort u_4
inst✝ : LE α
a : α
f : ι → UpperSet α
⊢ a ∈ ⨅ i, f i ↔ ∃ i, a ∈ f i
|
rw [← SetLike.mem_coe, coe_iInf]
|
α : Type u_1
ι : Sort u_4
inst✝ : LE α
a : α
f : ι → UpperSet α
⊢ a ∈ ⋃ i, ↑(f i) ↔ ∃ i, a ∈ f i
|
6c69d7bdb2398f7e
|
AffineIndependent.convexHull_inter
|
Mathlib/Analysis/Convex/Combination.lean
|
/-- Two simplices glue nicely if the union of their vertices is affine independent. -/
lemma AffineIndependent.convexHull_inter (hs : AffineIndependent R ((↑) : s → E))
(ht₁ : t₁ ⊆ s) (ht₂ : t₂ ⊆ s) :
convexHull R (t₁ ∩ t₂ : Set E) = convexHull R t₁ ∩ convexHull R t₂
|
R : Type u_1
E : Type u_3
inst✝² : LinearOrderedField R
inst✝¹ : AddCommGroup E
inst✝ : Module R E
s t₁ t₂ : Finset E
hs : AffineIndependent R Subtype.val
ht₁ : t₁ ⊆ s
ht₂ : t₂ ⊆ s
x : E
w₁ : E → R
h₁w₁ : ∀ y ∈ t₁, 0 ≤ w₁ y
h₂w₁ : ∑ y ∈ t₁, w₁ y = 1
h₃w₁ : ∑ y ∈ t₁, w₁ y • y = x
w₂ : E → R
h₂w₂ : ∑ y ∈ t₂, w₂ y = 1
h₃w₂ : ∑ y ∈ t₂, w₂ y • y = x
w : E → R := fun x => (if x ∈ t₁ then w₁ x else 0) - if x ∈ t₂ then w₂ x else 0
h₁w : ∑ i ∈ s, w i = 0
⊢ ∑ x ∈ s, w x • x = 0
|
simp only [w, sub_smul, zero_smul, ite_smul, Finset.sum_sub_distrib, ← Finset.sum_filter, h₃w₁,
Finset.filter_mem_eq_inter, Finset.inter_eq_right.2 ht₁, Finset.inter_eq_right.2 ht₂, h₃w₂,
sub_self]
|
no goals
|
c5414b8b46240fda
|
ascending_central_series_le_upper
|
Mathlib/GroupTheory/Nilpotent.lean
|
theorem ascending_central_series_le_upper (H : ℕ → Subgroup G) (hH : IsAscendingCentralSeries H) :
∀ n : ℕ, H n ≤ upperCentralSeries G n
| 0 => hH.1.symm ▸ le_refl ⊥
| n + 1 => by
intro x hx
rw [mem_upperCentralSeries_succ_iff]
exact fun y => ascending_central_series_le_upper H hH n (hH.2 x n hx y)
|
G : Type u_1
inst✝ : Group G
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
n : ℕ
x : G
hx : x ∈ H (n + 1)
⊢ x ∈ upperCentralSeries G (n + 1)
|
rw [mem_upperCentralSeries_succ_iff]
|
G : Type u_1
inst✝ : Group G
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
n : ℕ
x : G
hx : x ∈ H (n + 1)
⊢ ∀ (y : G), x * y * x⁻¹ * y⁻¹ ∈ upperCentralSeries G n
|
67368f32a22ec98a
|
integral_mul_rpow_one_add_sq
|
Mathlib/Analysis/SpecialFunctions/Integrals.lean
|
theorem integral_mul_rpow_one_add_sq {t : ℝ} (ht : t ≠ -1) :
(∫ x : ℝ in a..b, x * (↑1 + x ^ 2) ^ t) =
(↑1 + b ^ 2) ^ (t + 1) / (↑2 * (t + ↑1)) - (↑1 + a ^ 2) ^ (t + 1) / (↑2 * (t + ↑1))
|
case h.e'_2
a b t : ℝ
ht : t ≠ -1
this : ∀ (x s : ℝ), ↑((1 + x ^ 2) ^ s) = (1 + ↑x ^ 2) ^ ↑s
⊢ ∫ (x : ℝ) in a..b, ↑(x * (1 + x ^ 2) ^ t) = ∫ (x : ℝ) in ?convert_1..?convert_2, ↑x * (1 + ↑x ^ 2) ^ ↑t
|
congr with x : 1
|
case h.e'_2.e_f.h
a b t : ℝ
ht : t ≠ -1
this : ∀ (x s : ℝ), ↑((1 + x ^ 2) ^ s) = (1 + ↑x ^ 2) ^ ↑s
x : ℝ
⊢ ↑(x * (1 + x ^ 2) ^ t) = ↑x * (1 + ↑x ^ 2) ^ ↑t
|
06efdbf5b78963b9
|
Real.tan_zero
|
Mathlib/Data/Complex/Trigonometric.lean
|
theorem tan_zero : tan 0 = 0
|
⊢ tan 0 = 0
|
simp [tan]
|
no goals
|
6b0d08623a116e2f
|
Real.pi_lt_sqrtTwoAddSeries
|
Mathlib/Data/Real/Pi/Bounds.lean
|
theorem pi_lt_sqrtTwoAddSeries (n : ℕ) :
π < 2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / 4 ^ n
|
n : ℕ
⊢ 0 ≤ 2 ^ (n + 2)
|
positivity
|
no goals
|
02d82b689d50a592
|
Pell.Solution₁.eq_zero_of_d_neg
|
Mathlib/NumberTheory/Pell.lean
|
theorem eq_zero_of_d_neg (h₀ : d < 0) (a : Solution₁ d) : a.x = 0 ∨ a.y = 0
|
d : ℤ
h₀ : d < 0
a : Solution₁ d
h : a.x ≠ 0 ∧ a.y ≠ 0
h1 : 0 < a.x ^ 2
⊢ a.x ^ 2 - d * a.y ^ 2 ≠ 1
|
have h2 := sq_pos_of_ne_zero h.2
|
d : ℤ
h₀ : d < 0
a : Solution₁ d
h : a.x ≠ 0 ∧ a.y ≠ 0
h1 : 0 < a.x ^ 2
h2 : 0 < a.y ^ 2
⊢ a.x ^ 2 - d * a.y ^ 2 ≠ 1
|
50a8ed2852157cdb
|
ComplexShape.not_mem_range_embeddingUpIntGE_iff
|
Mathlib/Algebra/Homology/Embedding/Basic.lean
|
lemma not_mem_range_embeddingUpIntGE_iff (n : ℤ) :
(∀ (i : ℕ), (embeddingUpIntGE p).f i ≠ n) ↔ n < p
|
p n : ℤ
⊢ (∀ (i : ℕ), (embeddingUpIntGE p).f i ≠ n) ↔ n < p
|
constructor
|
case mp
p n : ℤ
⊢ (∀ (i : ℕ), (embeddingUpIntGE p).f i ≠ n) → n < p
case mpr
p n : ℤ
⊢ n < p → ∀ (i : ℕ), (embeddingUpIntGE p).f i ≠ n
|
7d00f879499fc2b7
|
Prod.map_surjective
|
Mathlib/Data/Prod/Basic.lean
|
theorem map_surjective [Nonempty γ] [Nonempty δ] {f : α → γ} {g : β → δ} :
Surjective (map f g) ↔ Surjective f ∧ Surjective g :=
⟨fun h =>
⟨fun c => by
inhabit δ
obtain ⟨⟨a, b⟩, h⟩ := h (c, default)
exact ⟨a, congr_arg Prod.fst h⟩,
fun d => by
inhabit γ
obtain ⟨⟨a, b⟩, h⟩ := h (default, d)
exact ⟨b, congr_arg Prod.snd h⟩⟩,
fun h => h.1.prodMap h.2⟩
|
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty γ
inst✝ : Nonempty δ
f : α → γ
g : β → δ
h : Surjective (map f g)
d : δ
⊢ ∃ a, g a = d
|
inhabit γ
|
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty γ
inst✝ : Nonempty δ
f : α → γ
g : β → δ
h : Surjective (map f g)
d : δ
inhabited_h : Inhabited γ
⊢ ∃ a, g a = d
|
7bc55de06597f56e
|
Surreal.Multiplication.P3.trans
|
Mathlib/SetTheory/Surreal/Multiplication.lean
|
lemma P3.trans (h₁ : P3 x₁ x₂ y₁ y₂) (h₂ : P3 x₂ x₃ y₁ y₂) : P3 x₁ x₃ y₁ y₂
|
x₁ x₂ x₃ y₁ y₂ : PGame
h₁ : P3 x₁ x₂ y₁ y₂
h₂ : P3 x₂ x₃ y₁ y₂
⊢ P3 x₁ x₃ y₁ y₂
|
rw [P3] at h₁ h₂
|
x₁ x₂ x₃ y₁ y₂ : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ P3 x₁ x₃ y₁ y₂
|
86ed7f5d4e0f46c8
|
Finset.sq_sum_div_le_sum_sq_div
|
Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
|
theorem sq_sum_div_le_sum_sq_div [LinearOrderedSemifield R] [ExistsAddOfLE R] (s : Finset ι)
(f : ι → R) {g : ι → R} (hg : ∀ i ∈ s, 0 < g i) :
(∑ i ∈ s, f i) ^ 2 / ∑ i ∈ s, g i ≤ ∑ i ∈ s, f i ^ 2 / g i
|
ι : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedSemifield R
inst✝ : ExistsAddOfLE R
s : Finset ι
f g : ι → R
hg : ∀ i ∈ s, 0 < g i
hg' : ∀ i ∈ s, 0 ≤ g i
⊢ (∑ i ∈ s, f i) ^ 2 / ∑ i ∈ s, g i ≤ ∑ i ∈ s, f i ^ 2 / g i
|
have H : ∀ i ∈ s, 0 ≤ f i ^ 2 / g i := fun i hi ↦ div_nonneg (sq_nonneg _) (hg' i hi)
|
ι : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedSemifield R
inst✝ : ExistsAddOfLE R
s : Finset ι
f g : ι → R
hg : ∀ i ∈ s, 0 < g i
hg' : ∀ i ∈ s, 0 ≤ g i
H : ∀ i ∈ s, 0 ≤ f i ^ 2 / g i
⊢ (∑ i ∈ s, f i) ^ 2 / ∑ i ∈ s, g i ≤ ∑ i ∈ s, f i ^ 2 / g i
|
b364a97d5e265cff
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.