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
|
|---|---|---|---|---|---|---|
Vector.range'_eq_append_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Range.lean
|
theorem range'_eq_append_iff : range' s (n + m) = xs ++ ys ↔ xs = range' s n ∧ ys = range' (s + n) m
|
case mp
s n m : Nat
xs : Vector Nat n
ys : Vector Nat m
⊢ (∃ k, k ≤ n + m ∧ xs.toArray = Array.range' s k ∧ ys.toArray = Array.range' (s + k) (n + m - k)) →
xs.toArray = Array.range' s n ∧ ys.toArray = Array.range' (s + n) m
|
rintro ⟨k, hk, h₁, h₂⟩
|
case mp.intro.intro.intro
s n m : Nat
xs : Vector Nat n
ys : Vector Nat m
k : Nat
hk : k ≤ n + m
h₁ : xs.toArray = Array.range' s k
h₂ : ys.toArray = Array.range' (s + k) (n + m - k)
⊢ xs.toArray = Array.range' s n ∧ ys.toArray = Array.range' (s + n) m
|
fe298cc85f386ffd
|
Dynamics.coverEntropy_eq_iSup_basis
|
Mathlib/Dynamics/TopologicalEntropy/CoverEntropy.lean
|
lemma coverEntropy_eq_iSup_basis {ι : Sort*} {p : ι → Prop} {s : ι → Set (X × X)}
(h : (𝓤 X).HasBasis p s) (T : X → X) (F : Set X) :
coverEntropy T F = ⨆ (i : ι) (_ : p i), coverEntropyEntourage T F (s i)
|
case intro.intro
X : Type u_1
inst✝ : UniformSpace X
ι : Sort u_2
p : ι → Prop
s : ι → Set (X × X)
h : (𝓤 X).HasBasis p s
T : X → X
F : Set X
U : Set (X × X)
U_uni : U ∈ 𝓤 X
i : ι
h_i : p i
si_U : s i ⊆ U
⊢ coverEntropyEntourage T F U ≤ ⨆ i, ⨆ (_ : p i), coverEntropyEntourage T F (s i)
|
exact (coverEntropyEntourage_antitone T F si_U).trans
(le_iSup₂ (f := fun (i : ι) (_ : p i) ↦ coverEntropyEntourage T F (s i)) i h_i)
|
no goals
|
62ab95ca01179b11
|
Finset.inductive_claim_mul
|
Mathlib/Combinatorics/Additive/SmallTripling.lean
|
@[to_additive]
private lemma inductive_claim_mul (hm : 3 ≤ m)
(h : ∀ ε : Fin 3 → ℤ, (∀ i, |ε i| = 1) → #((finRange 3).map fun i ↦ A ^ ε i).prod ≤ k * #A)
(ε : Fin m → ℤ) (hε : ∀ i, |ε i| = 1) :
#((finRange m).map fun i ↦ A ^ ε i).prod ≤ k ^ (m - 2) * #A
|
case succ.zero
G : Type u_1
inst✝¹ : DecidableEq G
inst✝ : Group G
A : Finset G
k : ℝ
m : ℕ
h : ∀ (ε : Fin 3 → ℤ), (∀ (i : Fin 3), |ε i| = 1) → ↑(#(List.map (fun i => A ^ ε i) (finRange 3)).prod) ≤ k * ↑(#A)
hm : 3 ≤ 0
ih :
∀ (ε : Fin 0 → ℤ),
(∀ (i : Fin 0), |ε i| = 1) → ↑(#(List.map (fun i => A ^ ε i) (finRange 0)).prod) ≤ k ^ (0 - 2) * ↑(#A)
ε : Fin (0 + 1) → ℤ
hε : ∀ (i : Fin (0 + 1)), |ε i| = 1
⊢ ↑(#(List.map (fun i => A ^ ε i) (finRange (0 + 1))).prod) ≤ k ^ (0 + 1 - 2) * ↑(#A)
|
simp at hm
|
no goals
|
75599e5c7cd8b516
|
Finset.inductive_claim_mul
|
Mathlib/Combinatorics/Additive/SmallTripling.lean
|
@[to_additive]
private lemma inductive_claim_mul (hm : 3 ≤ m)
(h : ∀ ε : Fin 3 → ℤ, (∀ i, |ε i| = 1) → #((finRange 3).map fun i ↦ A ^ ε i).prod ≤ k * #A)
(ε : Fin m → ℤ) (hε : ∀ i, |ε i| = 1) :
#((finRange m).map fun i ↦ A ^ ε i).prod ≤ k ^ (m - 2) * #A
|
G : Type u_1
inst✝¹ : DecidableEq G
inst✝ : Group G
A : Finset G
k : ℝ
m✝ : ℕ
h : ∀ (ε : Fin 3 → ℤ), (∀ (i : Fin 3), |ε i| = 1) → ↑(#(List.map (fun i => A ^ ε i) (finRange 3)).prod) ≤ k * ↑(#A)
m : ℕ
hm : 3 ≤ m + 1
ih :
∀ (ε : Fin (m + 1) → ℤ),
(∀ (i : Fin (m + 1)), |ε i| = 1) →
↑(#(List.map (fun i => A ^ ε i) (finRange (m + 1))).prod) ≤ k ^ (m + 1 - 2) * ↑(#A)
ε : Fin (m + 1 + 1) → ℤ
hε : ∀ (i : Fin (m + 1 + 1)), |ε i| = 1
hm₀ : m ≠ 0
hε₀ : ∀ (i : Fin (m + 1 + 1)), ε i ≠ 0
hA : A.Nonempty
hk : 0 ≤ k
π : {n : ℕ} → (Fin n → ℤ) → Finset G := fun {n} δ => (List.map (fun i => A ^ δ i) (finRange n)).prod
V : Finset G := π ![-ε 1, -ε 0]
W : Finset G := π (tail (tail ε))
⊢ k * ↑(#A) * (k ^ (m - 1) * ↑(#A)) = ↑(#A) * (k ^ (m - 1) * k * ↑(#A))
|
ring
|
no goals
|
75599e5c7cd8b516
|
ENNReal.lintegral_mul_eq_zero_of_lintegral_rpow_eq_zero
|
Mathlib/MeasureTheory/Integral/MeanInequalities.lean
|
theorem lintegral_mul_eq_zero_of_lintegral_rpow_eq_zero {p : ℝ} (hp0 : 0 ≤ p) {f g : α → ℝ≥0∞}
(hf : AEMeasurable f μ) (hf_zero : ∫⁻ a, f a ^ p ∂μ = 0) : (∫⁻ a, (f * g) a ∂μ) = 0
|
α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hf_zero : ∫⁻ (a : α), f a ^ p ∂μ = 0
hf_eq_zero : f =ᶠ[ae μ] 0
⊢ f * g =ᶠ[ae μ] 0 * g
|
exact hf_eq_zero.mul (ae_eq_refl g)
|
no goals
|
1c7b734166a127cf
|
ContinuousLinearMap.norm_iteratedFDerivWithin_le_of_bilinear
|
Mathlib/Analysis/Calculus/ContDiff/Bounds.lean
|
theorem ContinuousLinearMap.norm_iteratedFDerivWithin_le_of_bilinear (B : E →L[𝕜] F →L[𝕜] G)
{f : D → E} {g : D → F} {N : WithTop ℕ∞} {s : Set D} {x : D} (hf : ContDiffOn 𝕜 N f s)
(hg : ContDiffOn 𝕜 N g s) (hs : UniqueDiffOn 𝕜 s) (hx : x ∈ s) {n : ℕ} (hn : n ≤ N) :
‖iteratedFDerivWithin 𝕜 n (fun y => B (f y) (g y)) s x‖ ≤
‖B‖ * ∑ i ∈ Finset.range (n + 1), (n.choose i : ℝ) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
|
case hx
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁷ : NormedAddCommGroup D
inst✝⁶ : NormedSpace 𝕜 D
E : Type uE
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type uF
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type uG
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : WithTop ℕ∞
s : Set D
x : D
hf : ContDiffOn 𝕜 N f s
hg : ContDiffOn 𝕜 N g s
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
n : ℕ
hn : ↑n ≤ N
Du : Type (max uD uE uF uG) := ULift.{max uE uF uG, uD} D
Eu : Type (max uD uE uF uG) := ULift.{max uD uF uG, uE} E
Fu : Type (max uD uE uF uG) := ULift.{max uD uE uG, uF} F
Gu : Type (max uD uE uF uG) := ULift.{max uD uE uF, uG} G
isoD : Du ≃ₗᵢ[𝕜] D
isoE : Eu ≃ₗᵢ[𝕜] E
isoF : Fu ≃ₗᵢ[𝕜] F
isoG : Gu ≃ₗᵢ[𝕜] G
fu : Du → Eu := ⇑isoE.symm ∘ f ∘ ⇑isoD
gu : Du → Fu := ⇑isoF.symm ∘ g ∘ ⇑isoD
Bu₀ : Eu →L[𝕜] Fu →L[𝕜] G :=
((B.comp ↑{ toLinearEquiv := isoE.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }).flip.comp
↑{ toLinearEquiv := isoF.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }).flip
Bu : Eu →L[𝕜] Fu →L[𝕜] Gu :=
((compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
((compL 𝕜 Fu G Gu) ↑{ toLinearEquiv := isoG.symm.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }))
Bu₀
hBu :
Bu =
((compL 𝕜 Eu (Fu →L[𝕜] G) (Fu →L[𝕜] Gu))
((compL 𝕜 Fu G Gu)
↑{ toLinearEquiv := isoG.symm.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }))
Bu₀
Bu_eq : (fun y => (Bu (fu y)) (gu y)) = ⇑isoG.symm ∘ (fun y => (B (f y)) (g y)) ∘ ⇑isoD
Bu_le : ‖Bu‖ ≤ ‖B‖
su : Set Du := ⇑isoD ⁻¹' s
hsu : UniqueDiffOn 𝕜 su
xu : Du := isoD.symm x
hxu : xu ∈ su
xu_x : isoD xu = x
hfu : ContDiffOn 𝕜 (↑n) fu su
hgu : ContDiffOn 𝕜 (↑n) gu su
Nfu : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 i fu su xu‖ = ‖iteratedFDerivWithin 𝕜 i f s x‖
i : ℕ
⊢ isoD xu ∈ s
|
rwa [← xu_x] at hx
|
no goals
|
c6fa542bdff00851
|
Cardinal.mul_eq_self
|
Mathlib/SetTheory/Cardinal/Arithmetic.lean
|
theorem mul_eq_self {c : Cardinal} (h : ℵ₀ ≤ c) : c * c = c
|
case intro.intro.intro.refine_2.inr
c✝ : Cardinal.{u_1}
h✝ : ℵ₀ ≤ c✝
c : Cardinal.{u_1}
x✝ : ∀ y < c, Acc (fun x1 x2 => x1 < x2) y
α : Type u_1
IH : ∀ y < #α, ℵ₀ ≤ y → y * y ≤ y
ol : ℵ₀ ≤ #α
r : α → α → Prop
wo : IsWellOrder α r
e : (#α).ord = type r
this✝¹ : LinearOrder α := linearOrderOfSTO r
this✝ : IsWellOrder α fun x1 x2 => x1 < x2
g : α × α → α := fun p => p.1 ⊔ p.2
f : α × α ↪ Ordinal.{u_1} × α × α :=
{ toFun := fun p => ((typein fun x1 x2 => x1 < x2).toRelEmbedding (g p), p), inj' := ⋯ }
s : α × α → α × α → Prop :=
⇑f ⁻¹'o Prod.Lex (fun x1 x2 => x1 < x2) (Prod.Lex (fun x1 x2 => x1 < x2) fun x1 x2 => x1 < x2)
this : IsWellOrder (α × α) s
p : α × α
h : (typein s).toRelEmbedding p < type s
qo : ℵ₀ ≤ (succ ((typein fun x1 x2 => x1 < x2).toRelEmbedding (g p))).card
⊢ (typein LT.lt).toRelEmbedding (g p) < type r
|
apply typein_lt_type
|
no goals
|
2b4cf21a89b59c38
|
CategoryTheory.Subobject.factorThru_add_sub_factorThru_left
|
Mathlib/CategoryTheory/Subobject/FactorThru.lean
|
theorem factorThru_add_sub_factorThru_left {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
(w : P.Factors (f + g)) (wf : P.Factors f) :
P.factorThru (f + g) w - P.factorThru f wf =
P.factorThru g (factors_right_of_factors_add f g w wf)
|
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : P.Factors (f + g)
wf : P.Factors f
⊢ P.factorThru (f + g) w - P.factorThru f wf = P.factorThru g ⋯
|
ext
|
case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : P.Factors (f + g)
wf : P.Factors f
⊢ (P.factorThru (f + g) w - P.factorThru f wf) ≫ P.arrow = P.factorThru g ⋯ ≫ P.arrow
|
6fdfbb9ccec603d1
|
CategoryTheory.Pretriangulated.exists_iso_of_arrow_iso
|
Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
|
lemma exists_iso_of_arrow_iso (T₁ T₂ : Triangle C) (hT₁ : T₁ ∈ distTriang C)
(hT₂ : T₂ ∈ distTriang C) (e : Arrow.mk T₁.mor₁ ≅ Arrow.mk T₂.mor₁) :
∃ (e' : T₁ ≅ T₂), e'.hom.hom₁ = e.hom.left ∧ e'.hom.hom₂ = e.hom.right
|
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e : Arrow.mk T₁.mor₁ ≅ Arrow.mk T₂.mor₁
φ : T₁ ⟶ T₂ := completeDistinguishedTriangleMorphism T₁ T₂ hT₁ hT₂ e.hom.left e.hom.right ⋯
this✝² : IsIso φ.hom₁
this✝¹ : IsIso φ.hom₂
this✝ : IsIso φ.hom₃
this : IsIso φ
⊢ (asIso φ).hom.hom₁ = e.hom.left
|
simp [φ]
|
no goals
|
9637a6fb8661e804
|
Finpartition.equitabilise_aux
|
Mathlib/Combinatorics/SimpleGraph/Regularity/Equitabilise.lean
|
theorem equitabilise_aux (hs : a * m + b * (m + 1) = #s) :
∃ Q : Finpartition s,
(∀ x : Finset α, x ∈ Q.parts → #x = m ∨ #x = m + 1) ∧
(∀ x, x ∈ P.parts → #(x \ {y ∈ Q.parts | y ⊆ x}.biUnion id) ≤ m) ∧
#{i ∈ Q.parts | #i = m + 1} = b
|
case neg
α : Type u_1
inst✝ : DecidableEq α
m : ℕ
m_pos : m > 0
s : Finset α
ih :
∀ t ⊂ s,
∀ {a b : ℕ} {P : Finpartition t},
a * m + b * (m + 1) = #t →
∃ Q,
(∀ x ∈ Q.parts, #x = m ∨ #x = m + 1) ∧
(∀ x ∈ P.parts, #(x \ (filter (fun y => y ⊆ x) Q.parts).biUnion id) ≤ m) ∧
#(filter (fun i => #i = m + 1) Q.parts) = b
a b : ℕ
P : Finpartition s
hs : a * m + b * (m + 1) = #s
hab : 0 < a ∨ 0 < b
⊢ ∃ Q,
(∀ x ∈ Q.parts, #x = m ∨ #x = m + 1) ∧
(∀ x ∈ P.parts, #(x \ (filter (fun y => y ⊆ x) Q.parts).biUnion id) ≤ m) ∧
#(filter (fun i => #i = m + 1) Q.parts) = b
|
set n := if 0 < a then m else m + 1 with hn
|
case neg
α : Type u_1
inst✝ : DecidableEq α
m : ℕ
m_pos : m > 0
s : Finset α
ih :
∀ t ⊂ s,
∀ {a b : ℕ} {P : Finpartition t},
a * m + b * (m + 1) = #t →
∃ Q,
(∀ x ∈ Q.parts, #x = m ∨ #x = m + 1) ∧
(∀ x ∈ P.parts, #(x \ (filter (fun y => y ⊆ x) Q.parts).biUnion id) ≤ m) ∧
#(filter (fun i => #i = m + 1) Q.parts) = b
a b : ℕ
P : Finpartition s
hs : a * m + b * (m + 1) = #s
hab : 0 < a ∨ 0 < b
n : ℕ := if 0 < a then m else m + 1
hn : n = if 0 < a then m else m + 1
⊢ ∃ Q,
(∀ x ∈ Q.parts, #x = m ∨ #x = m + 1) ∧
(∀ x ∈ P.parts, #(x \ (filter (fun y => y ⊆ x) Q.parts).biUnion id) ≤ m) ∧
#(filter (fun i => #i = m + 1) Q.parts) = b
|
d46caaad6f3368e3
|
MvPowerSeries.coeff_eq_zero_of_constantCoeff_nilpotent
|
Mathlib/RingTheory/MvPowerSeries/Basic.lean
|
theorem coeff_eq_zero_of_constantCoeff_nilpotent
{f : MvPowerSeries σ R} {m : ℕ} (hf : constantCoeff σ R f ^ m = 0)
{d : σ →₀ ℕ} {n : ℕ} (hn : m + degree d ≤ n) : coeff R d (f ^ n) = 0
|
case h.h
σ : Type u_1
R : Type u_3
inst✝ : CommSemiring R
f : MvPowerSeries σ R
m : ℕ
hf : (constantCoeff σ R) f ^ m = 0
d : σ →₀ ℕ
n : ℕ
hn : m + d.degree ≤ n
k : ℕ →₀ σ →₀ ℕ
hk : (range n).sum ⇑k = d ∧ k.support ⊆ range n
s : Finset ℕ := Finset.filter (fun i => k i = 0) (range n)
hs_def : s = Finset.filter (fun i => k i = 0) (range n)
hs : s ⊆ range n
hs' : ∀ i ∈ s, (coeff R (k i)) f = (constantCoeff σ R) f
hs'' : ∀ i ∈ s, k i = 0
⊢ ∏ x ∈ s, (coeff R (k x)) f = 0
|
rw [prod_congr rfl hs', prod_const]
|
case h.h
σ : Type u_1
R : Type u_3
inst✝ : CommSemiring R
f : MvPowerSeries σ R
m : ℕ
hf : (constantCoeff σ R) f ^ m = 0
d : σ →₀ ℕ
n : ℕ
hn : m + d.degree ≤ n
k : ℕ →₀ σ →₀ ℕ
hk : (range n).sum ⇑k = d ∧ k.support ⊆ range n
s : Finset ℕ := Finset.filter (fun i => k i = 0) (range n)
hs_def : s = Finset.filter (fun i => k i = 0) (range n)
hs : s ⊆ range n
hs' : ∀ i ∈ s, (coeff R (k i)) f = (constantCoeff σ R) f
hs'' : ∀ i ∈ s, k i = 0
⊢ (constantCoeff σ R) f ^ #s = 0
|
cf9ab574f0bd652b
|
ENNReal.Ioo_zero_top_eq_iUnion_Ico_zpow
|
Mathlib/Data/ENNReal/Inv.lean
|
theorem Ioo_zero_top_eq_iUnion_Ico_zpow {y : ℝ≥0∞} (hy : 1 < y) (h'y : y ≠ ⊤) :
Ioo (0 : ℝ≥0∞) (∞ : ℝ≥0∞) = ⋃ n : ℤ, Ico (y ^ n) (y ^ (n + 1))
|
case h
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0∞
⊢ x ∈ Ioo 0 ⊤ ↔ x ∈ ⋃ n, Ico (y ^ n) (y ^ (n + 1))
|
simp only [mem_iUnion, mem_Ioo, mem_Ico]
|
case h
y : ℝ≥0∞
hy : 1 < y
h'y : y ≠ ⊤
x : ℝ≥0∞
⊢ 0 < x ∧ x < ⊤ ↔ ∃ i, y ^ i ≤ x ∧ x < y ^ (i + 1)
|
ad0e350e2128c607
|
Fin.Iio_last_eq_map
|
Mathlib/Data/Fintype/Fin.lean
|
theorem Iio_last_eq_map : Iio (Fin.last n) = Finset.univ.map Fin.castSuccEmb :=
coe_injective <| by ext; simp [lt_def]
|
case h
n : ℕ
x✝ : Fin (n + 1)
⊢ x✝ ∈ ↑(Iio (last n)) ↔ x✝ ∈ ↑(map castSuccEmb univ)
|
simp [lt_def]
|
no goals
|
5a0290270028545b
|
Vector.lex_toArray
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lex.lean
|
theorem lex_toArray [BEq α] (lt : α → α → Bool) (l₁ l₂ : Vector α n) :
l₁.toArray.lex l₂.toArray lt = l₁.lex l₂ lt
|
α : Type u_1
n : Nat
inst✝ : BEq α
lt : α → α → Bool
l₁ l₂ : Vector α n
⊢ l₁.lex l₂.toArray lt = l₁.lex l₂ lt
|
cases l₁
|
case mk
α : Type u_1
n : Nat
inst✝ : BEq α
lt : α → α → Bool
l₂ : Vector α n
toArray✝ : Array α
size_toArray✝ : toArray✝.size = n
⊢ { toArray := toArray✝, size_toArray := size_toArray✝ }.lex l₂.toArray lt =
{ toArray := toArray✝, size_toArray := size_toArray✝ }.lex l₂ lt
|
520bcebfaeec0320
|
String.Iterator.ValidFor.toEnd
|
Mathlib/.lake/packages/batteries/Batteries/Data/String/Lemmas.lean
|
theorem toEnd (h : ValidFor l r it) : ValidFor (r.reverse ++ l) [] it.toEnd
|
l r : List Char
it : Iterator
h : ValidFor l r it
⊢ { s := { data := l.reverseAux r }, i := { byteIdx := utf8Len l + utf8Len r } }.i.byteIdx = utf8Len (r.reverse ++ l)
|
simp [Nat.add_comm]
|
no goals
|
488307e720c4178d
|
Composition.eq_ones_iff_length
|
Mathlib/Combinatorics/Enumerative/Composition.lean
|
theorem eq_ones_iff_length {c : Composition n} : c = ones n ↔ c.length = n
|
case intro.intro
n : ℕ
c : Composition n
H : ¬c = ones n
length_n : c.length = n
i : ℕ
hi : i ∈ c.blocks
i_blocks : 1 < i
⊢ ∑ i : Fin c.length, 1 < ∑ i : Fin c.length, c.blocksFun i
|
rw [← ofFn_blocksFun, mem_ofFn' c.blocksFun, Set.mem_range] at hi
|
case intro.intro
n : ℕ
c : Composition n
H : ¬c = ones n
length_n : c.length = n
i : ℕ
hi : ∃ y, c.blocksFun y = i
i_blocks : 1 < i
⊢ ∑ i : Fin c.length, 1 < ∑ i : Fin c.length, c.blocksFun i
|
c4bb0bd15cee3f52
|
Localization.add_mk_self
|
Mathlib/RingTheory/Localization/Defs.lean
|
theorem add_mk_self (a b c) : (mk a b : Localization M) + mk c b = mk (a + c) b
|
R : Type u_1
inst✝ : CommSemiring R
M : Submonoid R
a : R
b : ↥M
c : R
⊢ ↑1 * (↑(↑b * c + ↑b * a, b * b).2 * (a + c, b).1) = ↑1 * (↑(a + c, b).2 * (↑b * c + ↑b * a, b * b).1)
|
simp only [Submonoid.coe_one, Submonoid.coe_mul]
|
R : Type u_1
inst✝ : CommSemiring R
M : Submonoid R
a : R
b : ↥M
c : R
⊢ 1 * (↑b * ↑b * (a + c)) = 1 * (↑b * (↑b * c + ↑b * a))
|
40fb5fea9adce157
|
RingHom.OfLocalizationSpanTarget.ofLocalizationSpan
|
Mathlib/RingTheory/LocalProperties/Basic.lean
|
theorem RingHom.OfLocalizationSpanTarget.ofLocalizationSpan
(hP : RingHom.OfLocalizationSpanTarget @P)
(hP' : RingHom.StableUnderCompositionWithLocalizationAwaySource @P) :
RingHom.OfLocalizationSpan @P
|
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : OfLocalizationSpanTarget P
hP' : StableUnderCompositionWithLocalizationAwaySource P
⊢ OfLocalizationSpan P
|
introv R hs hs'
|
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : OfLocalizationSpanTarget P
hP' : StableUnderCompositionWithLocalizationAwaySource P
R S : Type u
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
s : Set R
hs : Ideal.span s = ⊤
hs' : ∀ (r : ↑s), P (Localization.awayMap f ↑r)
⊢ P f
|
4181d293dd91340a
|
List.eraseIdx_ne_nil_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Erase.lean
|
theorem eraseIdx_ne_nil_iff {l : List α} {i : Nat} : eraseIdx l i ≠ [] ↔ 2 ≤ l.length ∨ (l.length = 1 ∧ i ≠ 0)
|
α : Type u_1
l : List α
i : Nat
⊢ l.eraseIdx i ≠ [] ↔ 2 ≤ l.length ∨ l.length = 1 ∧ i ≠ 0
|
match l with
| []
| [a]
| a::b::l => simp [Nat.succ_inj']
|
no goals
|
754019398fff23c9
|
List.set_getElem_self
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
|
theorem set_getElem_self {as : List α} {i : Nat} (h : i < as.length) :
as.set i as[i] = as
|
case h
α : Type u_1
as : List α
i : Nat
h : i < as.length
n : Nat
h₁ : n < (as.set i as[i]).length
h₂ : n < as.length
⊢ (if i = n then as[i] else as[n]) = as[n]
|
split <;> simp_all
|
no goals
|
a48e8c1addedf8f5
|
Ideal.exists_le_prime_nmem_of_isIdempotentElem
|
Mathlib/RingTheory/Ideal/Maximal.lean
|
theorem exists_le_prime_nmem_of_isIdempotentElem (a : α) (ha : IsIdempotentElem a) (haI : a ∉ I) :
∃ p : Ideal α, p.IsPrime ∧ I ≤ p ∧ a ∉ p :=
have : Disjoint (I : Set α) (Submonoid.powers a) := Set.disjoint_right.mpr <| by
rw [ha.coe_powers]
rintro _ (rfl|rfl)
exacts [I.ne_top_iff_one.mp (ne_of_mem_of_not_mem' Submodule.mem_top haI).symm, haI]
have ⟨p, h1, h2, h3⟩ := exists_le_prime_disjoint _ _ this
⟨p, h1, h2, Set.disjoint_right.mp h3 (Submonoid.mem_powers a)⟩
|
α : Type u
inst✝ : CommSemiring α
I : Ideal α
a : α
ha : IsIdempotentElem a
haI : a ∉ I
⊢ ∀ ⦃a_1 : α⦄, a_1 ∈ {1, a} → a_1 ∉ ↑I
|
rintro _ (rfl|rfl)
|
case inl
α : Type u
inst✝ : CommSemiring α
I : Ideal α
a : α
ha : IsIdempotentElem a
haI : a ∉ I
⊢ 1 ∉ ↑I
case inr
α : Type u
inst✝ : CommSemiring α
I : Ideal α
a✝ : α
ha : IsIdempotentElem a✝
haI : a✝ ∉ I
⊢ a✝ ∉ ↑I
|
da5240270130848b
|
AffineSubspace.setOf_sOppSide_eq_image2
|
Mathlib/Analysis/Convex/Side.lean
|
theorem setOf_sOppSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
{ y | s.SOppSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Iio 0) s
|
case h.mp.intro.intro.intro.intro.inr.inl
R : Type u_1
V : Type u_2
P : Type u_4
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
hy : y ∉ s
p₂ : P
hp₂ : p₂ ∈ s
h : p₂ = y
⊢ ∃ a < 0, ∃ b ∈ ↑s, a • (x -ᵥ p) +ᵥ b = y
|
exact False.elim (hy (h ▸ hp₂))
|
no goals
|
839d674f40d68f94
|
Nat.divisors_filter_squarefree
|
Mathlib/Data/Nat/Squarefree.lean
|
theorem divisors_filter_squarefree {n : ℕ} (h0 : n ≠ 0) :
{d ∈ n.divisors | Squarefree d}.val =
(UniqueFactorizationMonoid.normalizedFactors n).toFinset.powerset.val.map fun x =>
x.val.prod
|
n : ℕ
h0 : n ≠ 0
⊢ ∀ (a : ℕ),
a ∈ (filter (fun d => Squarefree d) n.divisors).val ↔
a ∈ Multiset.map (fun x => x.val.prod) (normalizedFactors n).toFinset.powerset.val
|
intro a
|
n : ℕ
h0 : n ≠ 0
a : ℕ
⊢ a ∈ (filter (fun d => Squarefree d) n.divisors).val ↔
a ∈ Multiset.map (fun x => x.val.prod) (normalizedFactors n).toFinset.powerset.val
|
4b75722f8636dcf2
|
SimplexCategory.eq_comp_δ_of_not_surjective'
|
Mathlib/AlgebraicTopology/SimplexCategory/Basic.lean
|
theorem eq_comp_δ_of_not_surjective' {n : ℕ} {Δ : SimplexCategory} (θ : Δ ⟶ mk (n + 1))
(i : Fin (n + 2)) (hi : ∀ x, θ.toOrderHom x ≠ i) : ∃ θ' : Δ ⟶ mk n, θ = θ' ≫ δ i
|
case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ ⦋n + 1⦌
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = (((Hom.toOrderHom θ) x).pred ⋯).succ
|
rw [Fin.succ_pred]
|
no goals
|
4424d07c1d7e8eb1
|
MeasureTheory.crossing_pos_eq
|
Mathlib/Probability/Martingale/Upcrossing.lean
|
theorem crossing_pos_eq (hab : a < b) :
upperCrossingTime 0 (b - a) (fun n ω => (f n ω - a)⁺) N n = upperCrossingTime a b f N n ∧
lowerCrossingTime 0 (b - a) (fun n ω => (f n ω - a)⁺) N n = lowerCrossingTime a b f N n
|
case pos
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
N n : ℕ
hab : a < b
hab' : 0 < b - a
hf : ∀ (ω : Ω) (i : ℕ), b - a ≤ (f i ω - a)⁺ ↔ b ≤ f i ω
hf' : ∀ (ω : Ω) (i : ℕ), (f i ω - a)⁺ ≤ 0 ↔ f i ω ≤ a
ω : Ω
h₁ : ∃ j ∈ Set.Icc ⊥ N, (f j ω - a)⁺ ∈ Set.Iic 0
h₂ : ∃ j ∈ Set.Icc ⊥ N, f j ω ∈ Set.Iic a
⊢ sInf (Set.Icc ⊥ N ∩ {i | (f i ω - a)⁺ ≤ 0}) = sInf (Set.Icc ⊥ N ∩ {i | f i ω ≤ a})
|
simp_rw [hf']
|
no goals
|
3016c9a152ee0783
|
Subring.closure_induction₂
|
Mathlib/Algebra/Ring/Subring/Basic.lean
|
theorem closure_induction₂ {s : Set R} {p : (x y : R) → x ∈ closure s → y ∈ closure s → Prop}
(mem_mem : ∀ (x) (y) (hx : x ∈ s) (hy : y ∈ s), p x y (subset_closure hx) (subset_closure hy))
(zero_left : ∀ x hx, p 0 x (zero_mem _) hx) (zero_right : ∀ x hx, p x 0 hx (zero_mem _))
(one_left : ∀ x hx, p 1 x (one_mem _) hx) (one_right : ∀ x hx, p x 1 hx (one_mem _))
(neg_left : ∀ x y hx hy, p x y hx hy → p (-x) y (neg_mem hx) hy)
(neg_right : ∀ x y hx hy, p x y hx hy → p x (-y) hx (neg_mem hy))
(add_left : ∀ x y z hx hy hz, p x z hx hz → p y z hy hz → p (x + y) z (add_mem hx hy) hz)
(add_right : ∀ x y z hx hy hz, p x y hx hy → p x z hx hz → p x (y + z) hx (add_mem hy hz))
(mul_left : ∀ x y z hx hy hz, p x z hx hz → p y z hy hz → p (x * y) z (mul_mem hx hy) hz)
(mul_right : ∀ x y z hx hy hz, p x y hx hy → p x z hx hz → p x (y * z) hx (mul_mem hy hz))
{x y : R} (hx : x ∈ closure s) (hy : y ∈ closure s) :
p x y hx hy
|
case mem
R : Type u
inst✝ : Ring R
s : Set R
p : (x y : R) → x ∈ closure s → y ∈ closure s → Prop
mem_mem : ∀ (x y : R) (hx : x ∈ s) (hy : y ∈ s), p x y ⋯ ⋯
zero_left : ∀ (x : R) (hx : x ∈ closure s), p 0 x ⋯ hx
zero_right : ∀ (x : R) (hx : x ∈ closure s), p x 0 hx ⋯
one_left : ∀ (x : R) (hx : x ∈ closure s), p 1 x ⋯ hx
one_right : ∀ (x : R) (hx : x ∈ closure s), p x 1 hx ⋯
neg_left : ∀ (x y : R) (hx : x ∈ closure s) (hy : y ∈ closure s), p x y hx hy → p (-x) y ⋯ hy
neg_right : ∀ (x y : R) (hx : x ∈ closure s) (hy : y ∈ closure s), p x y hx hy → p x (-y) hx ⋯
add_left :
∀ (x y z : R) (hx : x ∈ closure s) (hy : y ∈ closure s) (hz : z ∈ closure s),
p x z hx hz → p y z hy hz → p (x + y) z ⋯ hz
add_right :
∀ (x y z : R) (hx : x ∈ closure s) (hy : y ∈ closure s) (hz : z ∈ closure s),
p x y hx hy → p x z hx hz → p x (y + z) hx ⋯
mul_left :
∀ (x y z : R) (hx : x ∈ closure s) (hy : y ∈ closure s) (hz : z ∈ closure s),
p x z hx hz → p y z hy hz → p (x * y) z ⋯ hz
mul_right :
∀ (x y z : R) (hx : x ∈ closure s) (hy : y ∈ closure s) (hz : z ∈ closure s),
p x y hx hy → p x z hx hz → p x (y * z) hx ⋯
x y : R
hx : x ∈ closure s
z : R
hz : z ∈ s
⊢ p x z hx ⋯
|
induction hx using closure_induction with
| mem _ h => exact mem_mem _ _ h hz
| zero => exact zero_left _ _
| one => exact one_left _ _
| mul _ _ _ _ h₁ h₂ => exact mul_left _ _ _ _ _ _ h₁ h₂
| add _ _ _ _ h₁ h₂ => exact add_left _ _ _ _ _ _ h₁ h₂
| neg _ _ h => exact neg_left _ _ _ _ h
|
no goals
|
52e4f74d3c55783d
|
Cubic.degree_of_a_eq_zero
|
Mathlib/Algebra/CubicDiscriminant.lean
|
theorem degree_of_a_eq_zero (ha : P.a = 0) : P.toPoly.degree ≤ 2
|
R : Type u_1
P : Cubic R
inst✝ : Semiring R
ha : P.a = 0
⊢ P.toPoly.degree ≤ 2
|
simpa only [of_a_eq_zero ha] using degree_quadratic_le
|
no goals
|
0fbe731777f869bb
|
Polynomial.irreducible_iff_roots_eq_zero_of_degree_le_three
|
Mathlib/Algebra/Polynomial/SpecificDegree.lean
|
theorem irreducible_iff_roots_eq_zero_of_degree_le_three
{p : K[X]} (hp2 : 2 ≤ p.natDegree) (hp3 : p.natDegree ≤ 3) : Irreducible p ↔ p.roots = 0
|
K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
⊢ p ≠ 0
|
rintro rfl
|
K : Type u_1
inst✝ : Field K
hp2 : 2 ≤ natDegree 0
hp3 : natDegree 0 ≤ 3
⊢ False
|
2d87ab08172091ac
|
Real.exp_pos
|
Mathlib/Data/Complex/Exponential.lean
|
theorem exp_pos (x : ℝ) : 0 < exp x :=
(le_total 0 x).elim (lt_of_lt_of_le zero_lt_one ∘ one_le_exp) fun h => by
rw [← neg_neg x, Real.exp_neg]
exact inv_pos.2 (lt_of_lt_of_le zero_lt_one (one_le_exp (neg_nonneg.2 h)))
|
x : ℝ
h : x ≤ 0
⊢ 0 < rexp x
|
rw [← neg_neg x, Real.exp_neg]
|
x : ℝ
h : x ≤ 0
⊢ 0 < (rexp (-x))⁻¹
|
949bf308b7d9f797
|
Polynomial.natTrailingDegree_intCast
|
Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
|
theorem natTrailingDegree_intCast (n : ℤ) : natTrailingDegree (n : R[X]) = 0
|
R : Type u
inst✝ : Ring R
n : ℤ
⊢ (↑n).natTrailingDegree = 0
|
simp only [← C_eq_intCast, natTrailingDegree_C]
|
no goals
|
ddd799dec85b3000
|
TopCat.Sheaf.objSupIsoProdEqLocus_inv_eq_iff
|
Mathlib/Topology/Sheaves/CommRingCat.lean
|
theorem objSupIsoProdEqLocus_inv_eq_iff {X : TopCat.{u}} (F : X.Sheaf CommRingCat.{u})
{U V W UW VW : Opens X} (e : W ≤ U ⊔ V) (x) (y : F.1.obj (op W))
(h₁ : UW = U ⊓ W) (h₂ : VW = V ⊓ W) :
F.1.map (homOfLE e).op ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
F.1.map (homOfLE (h₁ ▸ inf_le_left : UW ≤ U)).op x.1.1 =
F.1.map (homOfLE <| h₁ ▸ inf_le_right).op y ∧
F.1.map (homOfLE (h₂ ▸ inf_le_left : VW ≤ V)).op x.1.2 =
F.1.map (homOfLE <| h₂ ▸ inf_le_right).op y
|
case mpr.intro.refine_1
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
↑(CommRingCat.of
↥(((CommRingCat.Hom.hom (F.val.map (homOfLE ⋯).op)).comp
(RingHom.fst ↑(F.val.obj (op U)) ↑(F.val.obj (op V)))).eqLocus
((CommRingCat.Hom.hom (F.val.map (homOfLE ⋯).op)).comp
(RingHom.snd ↑(F.val.obj (op U)) ↑(F.val.obj (op V))))))
y : ↑(F.val.obj (op W))
e₁ : (ConcreteCategory.hom (F.val.map (homOfLE ⋯).op)) (↑x).1 = (ConcreteCategory.hom (F.val.map (homOfLE ⋯).op)) y
e₂ : (ConcreteCategory.hom (F.val.map (homOfLE ⋯).op)) (↑x).2 = (ConcreteCategory.hom (F.val.map (homOfLE ⋯).op)) y
⊢ W ≤ U ⊓ W ⊔ V ⊓ W
|
rw [← inf_sup_right]
|
case mpr.intro.refine_1
X : TopCat
F : Sheaf CommRingCat X
U V W : Opens ↑X
e : W ≤ U ⊔ V
x :
↑(CommRingCat.of
↥(((CommRingCat.Hom.hom (F.val.map (homOfLE ⋯).op)).comp
(RingHom.fst ↑(F.val.obj (op U)) ↑(F.val.obj (op V)))).eqLocus
((CommRingCat.Hom.hom (F.val.map (homOfLE ⋯).op)).comp
(RingHom.snd ↑(F.val.obj (op U)) ↑(F.val.obj (op V))))))
y : ↑(F.val.obj (op W))
e₁ : (ConcreteCategory.hom (F.val.map (homOfLE ⋯).op)) (↑x).1 = (ConcreteCategory.hom (F.val.map (homOfLE ⋯).op)) y
e₂ : (ConcreteCategory.hom (F.val.map (homOfLE ⋯).op)) (↑x).2 = (ConcreteCategory.hom (F.val.map (homOfLE ⋯).op)) y
⊢ W ≤ (U ⊔ V) ⊓ W
|
fda8563349ccb2ed
|
CategoryTheory.Presieve.isSheaf_coverage
|
Mathlib/CategoryTheory/Sites/Coverage.lean
|
theorem isSheaf_coverage (K : Coverage C) (P : Cᵒᵖ ⥤ Type*) :
Presieve.IsSheaf (toGrothendieck _ K) P ↔
(∀ {X : C} (R : Presieve X), R ∈ K X → Presieve.IsSheafFor P R)
|
case mpr.top
C : Type u_2
inst✝ : Category.{u_3, u_2} C
K : Coverage C
P : Cᵒᵖ ⥤ Type u_1
H : ∀ {X : C}, ∀ R ∈ K.covering X, IsSheafFor P R
X : C
S : Sieve X
X✝ Y✝ : C
f✝ : Y✝ ⟶ X✝
⊢ IsSheafFor P (Sieve.pullback f✝ ⊤).arrows
|
simpa using Presieve.isSheafFor_top_sieve _
|
no goals
|
b0ee5f44dbe2a8c4
|
CanonicallyOrderedAdd.multiset_prod_pos
|
Mathlib/Algebra/Order/BigOperators/Ring/Multiset.lean
|
@[simp]
lemma CanonicallyOrderedAdd.multiset_prod_pos {R : Type*}
[CommSemiring R] [PartialOrder R] [CanonicallyOrderedAdd R] [NoZeroDivisors R] [Nontrivial R]
{m : Multiset R} : 0 < m.prod ↔ ∀ x ∈ m, 0 < x
|
case mk
R : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : PartialOrder R
inst✝² : CanonicallyOrderedAdd R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
m : Multiset R
l : List R
⊢ 0 < l.prod ↔ ∀ x ∈ ↑l, 0 < x
|
exact CanonicallyOrderedAdd.list_prod_pos
|
no goals
|
7f13f37d937206bf
|
Set.Definable.inter
|
Mathlib/ModelTheory/Definability.lean
|
theorem Definable.inter {f g : Set (α → M)} (hf : A.Definable L f) (hg : A.Definable L g) :
A.Definable L (f ∩ g)
|
case intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
g : Set (α → M)
hg : A.Definable L g
φ : L[[↑A]].Formula α
⊢ A.Definable L (setOf φ.Realize ∩ g)
|
rcases hg with ⟨θ, rfl⟩
|
case intro.intro
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
φ θ : L[[↑A]].Formula α
⊢ A.Definable L (setOf φ.Realize ∩ setOf θ.Realize)
|
f6c5351870975076
|
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms_rlp
|
Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean
|
lemma generatingMonomorphisms_rlp [IsGrothendieckAbelian.{w} C] (hG : IsSeparator G) :
(generatingMonomorphisms G).rlp = (monomorphisms C).rlp
|
case a
C : Type u
inst✝² : Category.{v, u} C
G : C
inst✝¹ : Abelian C
inst✝ : IsGrothendieckAbelian.{w, v, u} C
hG : IsSeparator G
⊢ (generatingMonomorphisms G).rlp ≤ (monomorphisms C).rlp
|
intro X Y p hp A B i (_ : Mono i)
|
case a
C : Type u
inst✝² : Category.{v, u} C
G : C
inst✝¹ : Abelian C
inst✝ : IsGrothendieckAbelian.{w, v, u} C
hG : IsSeparator G
X Y : C
p : X ⟶ Y
hp : (generatingMonomorphisms G).rlp p
A B : C
i : A ⟶ B
x✝ : Mono i
⊢ HasLiftingProperty i p
|
f4387f1ab4475cee
|
IsOpen.exists_between_affineIndependent_span_eq_top
|
Mathlib/Analysis/Normed/Affine/AddTorsorBases.lean
|
theorem IsOpen.exists_between_affineIndependent_span_eq_top {s u : Set P} (hu : IsOpen u)
(hsu : s ⊆ u) (hne : s.Nonempty) (h : AffineIndependent ℝ ((↑) : s → P)) :
∃ t : Set P, s ⊆ t ∧ t ⊆ u ∧ AffineIndependent ℝ ((↑) : t → P) ∧ affineSpan ℝ t = ⊤
|
case intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s u : Set P
hu : IsOpen u
hsu : s ⊆ u
h : AffineIndependent ℝ Subtype.val
q : P
hq : q ∈ s
ε : ℝ
ε0 : 0 < ε
hεu : Metric.closedBall q ε ⊆ u
t : Set P
ht₁ : s ⊆ t
ht₂ : AffineIndependent ℝ fun p => ↑p
ht₃ : affineSpan ℝ t = ⊤
f : P → P := fun y => (lineMap q y) (ε / dist y q)
hf : ∀ (y : P), f y ∈ u
⊢ ∃ t, s ⊆ t ∧ t ⊆ u ∧ AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ t = ⊤
|
have hεyq : ∀ y ∉ s, ε / dist y q ≠ 0 := fun y hy =>
div_ne_zero ε0.ne' (dist_ne_zero.2 (ne_of_mem_of_not_mem hq hy).symm)
|
case intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s u : Set P
hu : IsOpen u
hsu : s ⊆ u
h : AffineIndependent ℝ Subtype.val
q : P
hq : q ∈ s
ε : ℝ
ε0 : 0 < ε
hεu : Metric.closedBall q ε ⊆ u
t : Set P
ht₁ : s ⊆ t
ht₂ : AffineIndependent ℝ fun p => ↑p
ht₃ : affineSpan ℝ t = ⊤
f : P → P := fun y => (lineMap q y) (ε / dist y q)
hf : ∀ (y : P), f y ∈ u
hεyq : ∀ y ∉ s, ε / dist y q ≠ 0
⊢ ∃ t, s ⊆ t ∧ t ⊆ u ∧ AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ t = ⊤
|
9c25b7b430e74f74
|
IsUniformInducing.equicontinuousAt_iff
|
Mathlib/Topology/UniformSpace/Equicontinuity.lean
|
theorem IsUniformInducing.equicontinuousAt_iff {F : ι → X → α} {x₀ : X} {u : α → β}
(hu : IsUniformInducing u) : EquicontinuousAt F x₀ ↔ EquicontinuousAt ((u ∘ ·) ∘ F) x₀
|
ι : Type u_1
X : Type u_3
α : Type u_6
β : Type u_8
tX : TopologicalSpace X
uα : UniformSpace α
uβ : UniformSpace β
F : ι → X → α
x₀ : X
u : α → β
hu : IsUniformInducing u
⊢ EquicontinuousAt F x₀ ↔ EquicontinuousAt ((fun x => u ∘ x) ∘ F) x₀
|
have := (UniformFun.postcomp_isUniformInducing (α := ι) hu).isInducing
|
ι : Type u_1
X : Type u_3
α : Type u_6
β : Type u_8
tX : TopologicalSpace X
uα : UniformSpace α
uβ : UniformSpace β
F : ι → X → α
x₀ : X
u : α → β
hu : IsUniformInducing u
this : IsInducing (⇑ofFun ∘ (fun x => u ∘ x) ∘ ⇑toFun)
⊢ EquicontinuousAt F x₀ ↔ EquicontinuousAt ((fun x => u ∘ x) ∘ F) x₀
|
7642583c4dad8f53
|
Matroid.IsRestriction.base_iff
|
Mathlib/Data/Matroid/Restrict.lean
|
theorem IsRestriction.base_iff (hMN : N ≤r M) {B : Set α} : N.IsBase B ↔ M.IsBasis B N.E :=
⟨fun h ↦ IsBase.isBasis_of_isRestriction h hMN,
fun h ↦ by simpa [hMN.eq_restrict] using h.restrict_isBase⟩
|
α : Type u_1
M N : Matroid α
hMN : N ≤r M
B : Set α
h : M.IsBasis B N.E
⊢ N.IsBase B
|
simpa [hMN.eq_restrict] using h.restrict_isBase
|
no goals
|
244eca4bb448c196
|
HasDerivAt.lhopital_zero_atBot_on_Iio
|
Mathlib/Analysis/Calculus/LHopital.lean
|
theorem lhopital_zero_atBot_on_Iio (hff' : ∀ x ∈ Iio a, HasDerivAt f (f' x) x)
(hgg' : ∀ x ∈ Iio a, HasDerivAt g (g' x) x) (hg' : ∀ x ∈ Iio a, g' x ≠ 0)
(hfbot : Tendsto f atBot (𝓝 0)) (hgbot : Tendsto g atBot (𝓝 0))
(hdiv : Tendsto (fun x => f' x / g' x) atBot l) : Tendsto (fun x => f x / g x) atBot l
|
a : ℝ
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ x ∈ Iio a, HasDerivAt f (f' x) x
hgg' : ∀ x ∈ Iio a, HasDerivAt g (g' x) x
hg' : ∀ x ∈ Iio a, g' x ≠ 0
hfbot : Tendsto f atBot (𝓝 0)
hgbot : Tendsto g atBot (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) atBot l
hdnf : ∀ x ∈ Ioi (-a), HasDerivAt (f ∘ Neg.neg) (f' (-x) * -1) x
hdng : ∀ x ∈ Ioi (-a), HasDerivAt (g ∘ Neg.neg) (g' (-x) * -1) x
⊢ Tendsto (fun x => f x / g x) atBot l
|
have := lhopital_zero_atTop_on_Ioi hdnf hdng
(by
intro x hx h
apply hg' _ (by rw [← neg_Iio] at hx; exact hx)
rwa [mul_comm, ← neg_eq_neg_one_mul, neg_eq_zero] at h)
(hfbot.comp tendsto_neg_atTop_atBot) (hgbot.comp tendsto_neg_atTop_atBot)
(by
simp only [mul_one, mul_neg, neg_div_neg_eq]
exact (tendsto_congr fun x => rfl).mp (hdiv.comp tendsto_neg_atTop_atBot))
|
a : ℝ
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ x ∈ Iio a, HasDerivAt f (f' x) x
hgg' : ∀ x ∈ Iio a, HasDerivAt g (g' x) x
hg' : ∀ x ∈ Iio a, g' x ≠ 0
hfbot : Tendsto f atBot (𝓝 0)
hgbot : Tendsto g atBot (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) atBot l
hdnf : ∀ x ∈ Ioi (-a), HasDerivAt (f ∘ Neg.neg) (f' (-x) * -1) x
hdng : ∀ x ∈ Ioi (-a), HasDerivAt (g ∘ Neg.neg) (g' (-x) * -1) x
this : Tendsto (fun x => (f ∘ Neg.neg) x / (g ∘ Neg.neg) x) atTop l
⊢ Tendsto (fun x => f x / g x) atBot l
|
bfae29b4a3f3d519
|
getElem_congr_idx
|
Mathlib/.lake/packages/lean4/src/lean/Init/GetElem.lean
|
theorem getElem_congr_idx [GetElem coll idx elem valid] {c : coll} {i j : idx} {w : valid c i}
(h' : i = j) : c[i] = c[j]'(h' ▸ w)
|
coll : Type u_1
idx : Type u_2
elem : Type u_3
valid : coll → idx → Prop
inst✝ : GetElem coll idx elem valid
c : coll
i j : idx
w : valid c i
h' : i = j
⊢ getElem c i w = getElem c j ⋯
|
cases h'
|
case refl
coll : Type u_1
idx : Type u_2
elem : Type u_3
valid : coll → idx → Prop
inst✝ : GetElem coll idx elem valid
c : coll
i : idx
w : valid c i
⊢ getElem c i w = getElem c i ⋯
|
a9b5f0846516a702
|
Equiv.traverse_eq_map_id
|
Mathlib/Control/Traversable/Equiv.lean
|
theorem traverse_eq_map_id (f : α → β) (x : t' α) :
Equiv.traverse eqv ((pure : β → Id β) ∘ f) x = pure (Equiv.map eqv f x)
|
t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
α β : Type u
f : α → β
x : t' α
⊢ (eqv β) (id.mk (f <$> (eqv α).symm x)) = Equiv.map eqv f x
|
rfl
|
no goals
|
42d05ed5206def1a
|
Finsupp.erase_zero
|
Mathlib/Data/Finsupp/Single.lean
|
theorem erase_zero (a : α) : erase a (0 : α →₀ M) = 0
|
α : Type u_1
M : Type u_5
inst✝ : Zero M
a : α
⊢ erase a 0 = 0
|
simp
|
no goals
|
7a4c9027ee9a9fd3
|
Rat.inv_intCast_den
|
Mathlib/Data/Rat/Lemmas.lean
|
theorem inv_intCast_den (a : ℤ) : (a : ℚ)⁻¹.den = if a = 0 then 1 else a.natAbs
|
case inl.intro
a : ℤ
lt : 0 < a
⊢ ↑(↑(-a))⁻¹.den = ↑(-a).natAbs
|
simp only [Int.cast_neg, Rat.inv_neg, neg_den, inv_intCast_den_of_pos lt, Int.natAbs_neg]
|
case inl.intro
a : ℤ
lt : 0 < a
⊢ a = ↑a.natAbs
|
d9f5d1fcf285c31d
|
NNReal.coe_sSup
|
Mathlib/Data/NNReal/Defs.lean
|
theorem coe_sSup (s : Set ℝ≥0) : (↑(sSup s) : ℝ) = sSup (((↑) : ℝ≥0 → ℝ) '' s)
|
case hs.intro.intro
s : Set ℝ≥0
hs : s.Nonempty
H : BddAbove s
y : { r // 0 ≤ r }
⊢ 0 ≤ ↑y
|
exact y.2
|
no goals
|
d35908ad2b094ce8
|
CategoryTheory.Functor.final_of_final_costructuredArrowToOver_small
|
Mathlib/CategoryTheory/Comma/StructuredArrow/Final.lean
|
/-- The version of `final_of_final_costructuredArrowToOver` on small categories used to prove the
full statement. -/
private lemma final_of_final_costructuredArrowToOver_small (L : A ⥤ T) (R : B ⥤ T) [Final R]
[∀ b : B, Final (CostructuredArrow.toOver L (R.obj b))] : Final L
|
case h.e'_5
A : Type u₁
inst✝⁴ : SmallCategory A
B : Type u₁
inst✝³ : SmallCategory B
T : Type u₁
inst✝² : SmallCategory T
L : A ⥤ T
R : B ⥤ T
inst✝¹ : R.Final
inst✝ : ∀ (b : B), (CostructuredArrow.toOver L (R.obj b)).Final
G : T ⥤ Type u₁
this : ∀ (b : B), Final ((whiskerLeft R (preFunctor L (𝟭 T))).app b)
i : colimit (L ⋙ G) ≅ colimit G :=
Trans.trans
(Trans.trans
(Trans.trans
(Trans.trans
(Trans.trans
(Trans.trans (L.colimitIsoColimitGrothendieck (L ⋙ G))
(Final.colimitIso (Grothendieck.pre (functor L) R) (grothendieckProj L ⋙ L ⋙ G)).symm)
(HasColimit.isoOfNatIso
(NatIso.ofComponents
(fun x => Iso.refl ((Grothendieck.pre (functor L) R ⋙ grothendieckProj L ⋙ L ⋙ G).obj x)) ⋯)))
(Final.colimitIso (Grothendieck.map (whiskerLeft R (preFunctor L (𝟭 T))))
(grothendieckPrecompFunctorToComma (𝟭 T) R ⋙ Comma.fst (𝟭 T) R ⋙ G)))
(HasColimit.isoOfNatIso (Iso.refl (grothendieckPrecompFunctorToComma (𝟭 T) R ⋙ Comma.fst (𝟭 T) R ⋙ G))))
(Final.colimitIso (Grothendieck.pre (functor (𝟭 T)) R) (grothendieckProj (𝟭 T) ⋙ G)))
((𝟭 T).colimitIsoColimitGrothendieck G).symm
⊢ colimit.pre G L =
(L.colimitIsoColimitGrothendieck (L ⋙ G)).hom ≫
(Final.colimitIso (Grothendieck.pre (functor L) R) (grothendieckProj L ⋙ L ⋙ G)).inv ≫
(HasColimit.isoOfNatIso (NatIso.ofComponents (fun x => Iso.refl (G.obj (L.obj x.fiber.left))) ⋯)).hom ≫
(Final.colimitIso (Grothendieck.map (whiskerLeft R (preFunctor L (𝟭 T))))
(grothendieckPrecompFunctorToComma (𝟭 T) R ⋙ Comma.fst (𝟭 T) R ⋙ G)).hom ≫
(HasColimit.isoOfNatIso
(Iso.refl (grothendieckPrecompFunctorToComma (𝟭 T) R ⋙ Comma.fst (𝟭 T) R ⋙ G))).hom ≫
(Final.colimitIso (Grothendieck.pre (functor (𝟭 T)) R) (grothendieckProj (𝟭 T) ⋙ G)).hom ≫
((𝟭 T).colimitIsoColimitGrothendieck G).inv
|
rw [← Iso.inv_comp_eq, Iso.eq_inv_comp]
|
case h.e'_5
A : Type u₁
inst✝⁴ : SmallCategory A
B : Type u₁
inst✝³ : SmallCategory B
T : Type u₁
inst✝² : SmallCategory T
L : A ⥤ T
R : B ⥤ T
inst✝¹ : R.Final
inst✝ : ∀ (b : B), (CostructuredArrow.toOver L (R.obj b)).Final
G : T ⥤ Type u₁
this : ∀ (b : B), Final ((whiskerLeft R (preFunctor L (𝟭 T))).app b)
i : colimit (L ⋙ G) ≅ colimit G :=
Trans.trans
(Trans.trans
(Trans.trans
(Trans.trans
(Trans.trans
(Trans.trans (L.colimitIsoColimitGrothendieck (L ⋙ G))
(Final.colimitIso (Grothendieck.pre (functor L) R) (grothendieckProj L ⋙ L ⋙ G)).symm)
(HasColimit.isoOfNatIso
(NatIso.ofComponents
(fun x => Iso.refl ((Grothendieck.pre (functor L) R ⋙ grothendieckProj L ⋙ L ⋙ G).obj x)) ⋯)))
(Final.colimitIso (Grothendieck.map (whiskerLeft R (preFunctor L (𝟭 T))))
(grothendieckPrecompFunctorToComma (𝟭 T) R ⋙ Comma.fst (𝟭 T) R ⋙ G)))
(HasColimit.isoOfNatIso (Iso.refl (grothendieckPrecompFunctorToComma (𝟭 T) R ⋙ Comma.fst (𝟭 T) R ⋙ G))))
(Final.colimitIso (Grothendieck.pre (functor (𝟭 T)) R) (grothendieckProj (𝟭 T) ⋙ G)))
((𝟭 T).colimitIsoColimitGrothendieck G).symm
⊢ (Final.colimitIso (Grothendieck.pre (functor L) R) (grothendieckProj L ⋙ L ⋙ G)).hom ≫
(L.colimitIsoColimitGrothendieck (L ⋙ G)).inv ≫ colimit.pre G L =
(HasColimit.isoOfNatIso (NatIso.ofComponents (fun x => Iso.refl (G.obj (L.obj x.fiber.left))) ⋯)).hom ≫
(Final.colimitIso (Grothendieck.map (whiskerLeft R (preFunctor L (𝟭 T))))
(grothendieckPrecompFunctorToComma (𝟭 T) R ⋙ Comma.fst (𝟭 T) R ⋙ G)).hom ≫
(HasColimit.isoOfNatIso (Iso.refl (grothendieckPrecompFunctorToComma (𝟭 T) R ⋙ Comma.fst (𝟭 T) R ⋙ G))).hom ≫
(Final.colimitIso (Grothendieck.pre (functor (𝟭 T)) R) (grothendieckProj (𝟭 T) ⋙ G)).hom ≫
((𝟭 T).colimitIsoColimitGrothendieck G).inv
|
5b21f5fd15909d2e
|
Std.Sat.AIG.mkConstCached_decl_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Sat/AIG/CachedLemmas.lean
|
theorem mkConstCached_decl_eq (aig : AIG α) (val : Bool) (idx : Nat) {h : idx < aig.decls.size}
{hbound} :
(aig.mkConstCached val).aig.decls[idx]'hbound = aig.decls[idx]
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
val : Bool
idx : Nat
h : idx < aig.decls.size
hbound : idx < (aig.mkConstCached val).aig.decls.size
gate : CacheHit aig.decls (Decl.const val)
hcache : aig.cache.get? (Decl.const val) = some gate
⊢ (aig.mkConstCached val).aig.decls[idx] = aig.decls[idx]
|
have := mkConstCached_hit_aig aig hcache
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
val : Bool
idx : Nat
h : idx < aig.decls.size
hbound : idx < (aig.mkConstCached val).aig.decls.size
gate : CacheHit aig.decls (Decl.const val)
hcache : aig.cache.get? (Decl.const val) = some gate
this : (aig.mkConstCached val).aig = aig
⊢ (aig.mkConstCached val).aig.decls[idx] = aig.decls[idx]
|
36b90051913996fa
|
MeasureTheory.convolution_assoc
|
Mathlib/Analysis/Convolution.lean
|
theorem convolution_assoc (hL : ∀ (x : E) (y : E') (z : E''), L₂ (L x y) z = L₃ x (L₄ y z)) {x₀ : G}
(hf : AEStronglyMeasurable f ν) (hg : AEStronglyMeasurable g μ) (hk : AEStronglyMeasurable k μ)
(hfg : ∀ᵐ y ∂μ, ConvolutionExistsAt f g y L ν)
(hgk : ∀ᵐ x ∂ν, ConvolutionExistsAt (fun x => ‖g x‖) (fun x => ‖k x‖) x (mul ℝ ℝ) μ)
(hfgk :
ConvolutionExistsAt (fun x => ‖f x‖) ((fun x => ‖g x‖) ⋆[mul ℝ ℝ, μ] fun x => ‖k x‖) x₀
(mul ℝ ℝ) ν) :
((f ⋆[L, ν] g) ⋆[L₂, μ] k) x₀ = (f ⋆[L₃, ν] g ⋆[L₄, μ] k) x₀
|
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
inst✝²⁶ : NormedAddCommGroup E
inst✝²⁵ : NormedAddCommGroup E'
inst✝²⁴ : NormedAddCommGroup E''
inst✝²³ : NormedAddCommGroup F
f : G → E
g : G → E'
inst✝²² : RCLike 𝕜
inst✝²¹ : NormedSpace 𝕜 E
inst✝²⁰ : NormedSpace 𝕜 E'
inst✝¹⁹ : NormedSpace 𝕜 E''
inst✝¹⁸ : NormedSpace ℝ F
inst✝¹⁷ : NormedSpace 𝕜 F
inst✝¹⁶ : MeasurableSpace G
μ ν : Measure G
L : E →L[𝕜] E' →L[𝕜] F
inst✝¹⁵ : CompleteSpace F
inst✝¹⁴ : NormedAddCommGroup F'
inst✝¹³ : NormedSpace ℝ F'
inst✝¹² : NormedSpace 𝕜 F'
inst✝¹¹ : CompleteSpace F'
inst✝¹⁰ : NormedAddCommGroup F''
inst✝⁹ : NormedSpace ℝ F''
inst✝⁸ : NormedSpace 𝕜 F''
inst✝⁷ : CompleteSpace F''
k : G → E''
L₂ : F →L[𝕜] E'' →L[𝕜] F'
L₃ : E →L[𝕜] F'' →L[𝕜] F'
L₄ : E' →L[𝕜] E'' →L[𝕜] F''
inst✝⁶ : AddGroup G
inst✝⁵ : SFinite μ
inst✝⁴ : SFinite ν
inst✝³ : μ.IsAddRightInvariant
inst✝² : MeasurableAdd₂ G
inst✝¹ : ν.IsAddRightInvariant
inst✝ : MeasurableNeg G
hL : ∀ (x : E) (y : E') (z : E''), (L₂ ((L x) y)) z = (L₃ x) ((L₄ y) z)
x₀ : G
hf : AEStronglyMeasurable f ν
hg : AEStronglyMeasurable g μ
hk : AEStronglyMeasurable k μ
hfg : ∀ᵐ (y : G) ∂μ, ConvolutionExistsAt f g y L ν
hgk : ∀ᵐ (x : G) ∂ν, ConvolutionExistsAt (fun x => ‖g x‖) (fun x => ‖k x‖) x (mul ℝ ℝ) μ
hfgk : ConvolutionExistsAt (fun x => ‖f x‖) ((fun x => ‖g x‖) ⋆[mul ℝ ℝ, μ] fun x => ‖k x‖) x₀ (mul ℝ ℝ) ν
h_meas : AEStronglyMeasurable (uncurry fun x y => (L₃ (f y)) ((L₄ (g x)) (k (x₀ - y - x)))) (μ.prod ν)
h2_meas : AEStronglyMeasurable (fun y => ∫ (x : G), ‖(L₃ (f y)) ((L₄ (g x)) (k (x₀ - y - x)))‖ ∂μ) ν
h3 : Measure.map (fun z => (z.1 - z.2, z.2)) (μ.prod ν) = μ.prod ν
⊢ Integrable (uncurry fun x y => (L₃ (f y)) ((L₄ (g (x - y))) (k (x₀ - x)))) (μ.prod ν)
|
suffices Integrable (uncurry fun x y => L₃ (f y) (L₄ (g x) (k (x₀ - y - x)))) (μ.prod ν) by
rw [← h3] at this
convert this.comp_measurable (measurable_sub.prod_mk measurable_snd)
ext ⟨x, y⟩
simp (config := { unfoldPartialApp := true }) only [uncurry, Function.comp_apply,
sub_sub_sub_cancel_right]
|
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
inst✝²⁶ : NormedAddCommGroup E
inst✝²⁵ : NormedAddCommGroup E'
inst✝²⁴ : NormedAddCommGroup E''
inst✝²³ : NormedAddCommGroup F
f : G → E
g : G → E'
inst✝²² : RCLike 𝕜
inst✝²¹ : NormedSpace 𝕜 E
inst✝²⁰ : NormedSpace 𝕜 E'
inst✝¹⁹ : NormedSpace 𝕜 E''
inst✝¹⁸ : NormedSpace ℝ F
inst✝¹⁷ : NormedSpace 𝕜 F
inst✝¹⁶ : MeasurableSpace G
μ ν : Measure G
L : E →L[𝕜] E' →L[𝕜] F
inst✝¹⁵ : CompleteSpace F
inst✝¹⁴ : NormedAddCommGroup F'
inst✝¹³ : NormedSpace ℝ F'
inst✝¹² : NormedSpace 𝕜 F'
inst✝¹¹ : CompleteSpace F'
inst✝¹⁰ : NormedAddCommGroup F''
inst✝⁹ : NormedSpace ℝ F''
inst✝⁸ : NormedSpace 𝕜 F''
inst✝⁷ : CompleteSpace F''
k : G → E''
L₂ : F →L[𝕜] E'' →L[𝕜] F'
L₃ : E →L[𝕜] F'' →L[𝕜] F'
L₄ : E' →L[𝕜] E'' →L[𝕜] F''
inst✝⁶ : AddGroup G
inst✝⁵ : SFinite μ
inst✝⁴ : SFinite ν
inst✝³ : μ.IsAddRightInvariant
inst✝² : MeasurableAdd₂ G
inst✝¹ : ν.IsAddRightInvariant
inst✝ : MeasurableNeg G
hL : ∀ (x : E) (y : E') (z : E''), (L₂ ((L x) y)) z = (L₃ x) ((L₄ y) z)
x₀ : G
hf : AEStronglyMeasurable f ν
hg : AEStronglyMeasurable g μ
hk : AEStronglyMeasurable k μ
hfg : ∀ᵐ (y : G) ∂μ, ConvolutionExistsAt f g y L ν
hgk : ∀ᵐ (x : G) ∂ν, ConvolutionExistsAt (fun x => ‖g x‖) (fun x => ‖k x‖) x (mul ℝ ℝ) μ
hfgk : ConvolutionExistsAt (fun x => ‖f x‖) ((fun x => ‖g x‖) ⋆[mul ℝ ℝ, μ] fun x => ‖k x‖) x₀ (mul ℝ ℝ) ν
h_meas : AEStronglyMeasurable (uncurry fun x y => (L₃ (f y)) ((L₄ (g x)) (k (x₀ - y - x)))) (μ.prod ν)
h2_meas : AEStronglyMeasurable (fun y => ∫ (x : G), ‖(L₃ (f y)) ((L₄ (g x)) (k (x₀ - y - x)))‖ ∂μ) ν
h3 : Measure.map (fun z => (z.1 - z.2, z.2)) (μ.prod ν) = μ.prod ν
⊢ Integrable (uncurry fun x y => (L₃ (f y)) ((L₄ (g x)) (k (x₀ - y - x)))) (μ.prod ν)
|
f21dcf6a44458531
|
MulAction.stabilizer_inf_stabilizer_le_stabilizer_apply₂
|
Mathlib/Algebra/Pointwise/Stabilizer.lean
|
@[to_additive]
lemma stabilizer_inf_stabilizer_le_stabilizer_apply₂ {f : Set α → Set α → Set α}
(hf : ∀ a : G, a • f s t = f (a • s) (a • t)) :
stabilizer G s ⊓ stabilizer G t ≤ stabilizer G (f s t)
|
G : Type u_1
α : Type u_3
inst✝¹ : Group G
inst✝ : MulAction G α
s t : Set α
f : Set α → Set α → Set α
hf : ∀ (a : G), a • f s t = f (a • s) (a • t)
⊢ stabilizer G s ⊓ stabilizer G t ≤ stabilizer G (f s t)
|
aesop (add simp [SetLike.le_def])
|
no goals
|
fe563d9fe94341ce
|
Antitone.map_limsSup_of_continuousAt
|
Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
|
theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
(f_decr : Antitone f) (f_cont : ContinuousAt f F.limsSup)
(bdd_above : F.IsBounded (· ≤ ·)
|
case a
R : Type u_4
S : Type u_5
inst✝⁶ : ConditionallyCompleteLinearOrder R
inst✝⁵ : TopologicalSpace R
inst✝⁴ : OrderTopology R
inst✝³ : ConditionallyCompleteLinearOrder S
inst✝² : TopologicalSpace S
inst✝¹ : OrderTopology S
F : Filter R
inst✝ : F.NeBot
f : R → S
f_decr : Antitone f
f_cont : ContinuousAt f F.limsSup
bdd_above : autoParam (IsBounded (fun x1 x2 => x1 ≤ x2) F) _auto✝
cobdd : autoParam (IsCobounded (fun x1 x2 => x1 ≤ x2) F) _auto✝
⊢ liminf f F ≤ f F.limsSup
|
by_cases h' : ∃ c, c < F.limsSup ∧ Set.Ioo c F.limsSup = ∅
|
case pos
R : Type u_4
S : Type u_5
inst✝⁶ : ConditionallyCompleteLinearOrder R
inst✝⁵ : TopologicalSpace R
inst✝⁴ : OrderTopology R
inst✝³ : ConditionallyCompleteLinearOrder S
inst✝² : TopologicalSpace S
inst✝¹ : OrderTopology S
F : Filter R
inst✝ : F.NeBot
f : R → S
f_decr : Antitone f
f_cont : ContinuousAt f F.limsSup
bdd_above : autoParam (IsBounded (fun x1 x2 => x1 ≤ x2) F) _auto✝
cobdd : autoParam (IsCobounded (fun x1 x2 => x1 ≤ x2) F) _auto✝
h' : ∃ c < F.limsSup, Set.Ioo c F.limsSup = ∅
⊢ liminf f F ≤ f F.limsSup
case neg
R : Type u_4
S : Type u_5
inst✝⁶ : ConditionallyCompleteLinearOrder R
inst✝⁵ : TopologicalSpace R
inst✝⁴ : OrderTopology R
inst✝³ : ConditionallyCompleteLinearOrder S
inst✝² : TopologicalSpace S
inst✝¹ : OrderTopology S
F : Filter R
inst✝ : F.NeBot
f : R → S
f_decr : Antitone f
f_cont : ContinuousAt f F.limsSup
bdd_above : autoParam (IsBounded (fun x1 x2 => x1 ≤ x2) F) _auto✝
cobdd : autoParam (IsCobounded (fun x1 x2 => x1 ≤ x2) F) _auto✝
h' : ¬∃ c < F.limsSup, Set.Ioo c F.limsSup = ∅
⊢ liminf f F ≤ f F.limsSup
|
3b8bbb0ba829f542
|
CategoryTheory.Localization.essSurj_mapArrow
|
Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
|
lemma Localization.essSurj_mapArrow :
L.mapArrow.EssSurj where
mem_essImage f
|
case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
f : Arrow D
this : L.EssSurj
X : C
eX : L.obj X ≅ f.left
Y : C
eY : L.obj Y ≅ f.right
φ : W.LeftFraction X Y
hφ : eX.hom ≫ f.hom ≫ eY.inv = φ.map L ⋯
⊢ L.mapArrow.essImage f
|
refine ⟨Arrow.mk φ.f, ⟨Iso.symm ?_⟩⟩
|
case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
f : Arrow D
this : L.EssSurj
X : C
eX : L.obj X ≅ f.left
Y : C
eY : L.obj Y ≅ f.right
φ : W.LeftFraction X Y
hφ : eX.hom ≫ f.hom ≫ eY.inv = φ.map L ⋯
⊢ f ≅ L.mapArrow.obj (Arrow.mk φ.f)
|
164023e816364abf
|
LSeries.positive
|
Mathlib/NumberTheory/LSeries/Positivity.lean
|
/-- If all values of `a : ℕ → ℂ` are nonnegative reals and `a 1` is positive,
then `L a x` is positive real for all real `x` larger than `abscissaOfAbsConv a`. -/
lemma positive {a : ℕ → ℂ} (ha₀ : 0 ≤ a) (ha₁ : 0 < a 1) {x : ℝ} (hx : abscissaOfAbsConv a < x) :
0 < LSeries a x
|
a : ℕ → ℂ
ha₀ : 0 ≤ a
ha₁ : 0 < a 1
x : ℝ
hx : abscissaOfAbsConv a < ↑x
⊢ 0 < LSeries a ↑x
|
rw [LSeries]
|
a : ℕ → ℂ
ha₀ : 0 ≤ a
ha₁ : 0 < a 1
x : ℝ
hx : abscissaOfAbsConv a < ↑x
⊢ 0 < ∑' (n : ℕ), term a (↑x) n
|
e902be672425c326
|
Primrec.list_get?
|
Mathlib/Computability/Primrec.lean
|
theorem list_get? : Primrec₂ (@List.get? α) :=
let F (l : List α) (n : ℕ) :=
l.foldl
(fun (s : ℕ ⊕ α) (a : α) =>
Sum.casesOn s (@Nat.casesOn (fun _ => ℕ ⊕ α) · (Sum.inr a) Sum.inl) Sum.inr)
(Sum.inl n)
have hF : Primrec₂ F :=
(list_foldl fst (sumInl.comp snd)
((sumCasesOn fst (nat_casesOn snd (sumInr.comp <| snd.comp fst) (sumInl.comp snd).to₂).to₂
(sumInr.comp snd).to₂).comp
snd).to₂).to₂
have :
@Primrec _ (Option α) _ _ fun p : List α × ℕ => Sum.casesOn (F p.1 p.2) (fun _ => none) some :=
sumCasesOn hF (const none).to₂ (option_some.comp snd).to₂
this.to₂.of_eq fun l n => by
dsimp; symm
induction' l with a l IH generalizing n; · rfl
rcases n with - | n
· dsimp [F]
clear IH
induction' l with _ l IH <;> simp [*]
· apply IH
|
case cons.zero
α : Type u_1
inst✝ : Primcodable α
F : List α → ℕ → ℕ ⊕ α :=
fun l n => List.foldl (fun s a => Sum.casesOn s (fun x => Nat.casesOn x (Sum.inr a) Sum.inl) Sum.inr) (Sum.inl n) l
hF : Primrec₂ F
this : Primrec fun p => Sum.casesOn (F p.1 p.2) (fun x => none) some
a : α
l : List α
IH : ∀ (n : ℕ), l.get? n = Sum.rec (fun val => none) (fun val => some val) (F l n)
⊢ some a =
Sum.rec (fun val => none) (fun val => some val)
(List.foldl
(fun s a => Sum.rec (fun val => Nat.rec (Sum.inr a) (fun n n_ih => Sum.inl n) val) (fun val => Sum.inr val) s)
(Sum.inr a) l)
|
clear IH
|
case cons.zero
α : Type u_1
inst✝ : Primcodable α
F : List α → ℕ → ℕ ⊕ α :=
fun l n => List.foldl (fun s a => Sum.casesOn s (fun x => Nat.casesOn x (Sum.inr a) Sum.inl) Sum.inr) (Sum.inl n) l
hF : Primrec₂ F
this : Primrec fun p => Sum.casesOn (F p.1 p.2) (fun x => none) some
a : α
l : List α
⊢ some a =
Sum.rec (fun val => none) (fun val => some val)
(List.foldl
(fun s a => Sum.rec (fun val => Nat.rec (Sum.inr a) (fun n n_ih => Sum.inl n) val) (fun val => Sum.inr val) s)
(Sum.inr a) l)
|
b84fae2f2ee71bbf
|
IsCompact.uniform_oscillationWithin
|
Mathlib/Analysis/Oscillation.lean
|
theorem uniform_oscillationWithin (comp : IsCompact K) (hK : ∀ x ∈ K, oscillationWithin f D x < ε) :
∃ δ > 0, ∀ x ∈ K, diam (f '' (ball x (ENNReal.ofReal δ) ∩ D)) ≤ ε
|
case right.intro
E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : PseudoEMetricSpace E
K : Set E
f : E → F
D : Set E
ε : ℝ≥0∞
comp : IsCompact K
hK : ∀ x ∈ K, oscillationWithin f D x < ε
S : ℝ → Set E := fun r => {x | ∃ a > r, diam (f '' (ball x (ENNReal.ofReal a) ∩ D)) ≤ ε}
S_open : ∀ r > 0, IsOpen (S r)
S_cover : K ⊆ ⋃ r, ⋃ (_ : r > 0), S r
S_antitone : ∀ (r₁ r₂ : ℝ), r₁ ≤ r₂ → S r₂ ⊆ S r₁
T : Set ℝ
Tb : T ⊆ Real.lt✝ 0
Tfin : T.Finite
hT : K ⊆ ⋃ i ∈ T, S i
T_nonempty : T.Nonempty
x : E
hx : x ∈ K
r : ℝ
hr : x ∈ ⋃ (_ : r ∈ T), S r
⊢ x ∈ S (⋯.min T_nonempty)
|
simp only [mem_iUnion, exists_prop] at hr
|
case right.intro
E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : PseudoEMetricSpace E
K : Set E
f : E → F
D : Set E
ε : ℝ≥0∞
comp : IsCompact K
hK : ∀ x ∈ K, oscillationWithin f D x < ε
S : ℝ → Set E := fun r => {x | ∃ a > r, diam (f '' (ball x (ENNReal.ofReal a) ∩ D)) ≤ ε}
S_open : ∀ r > 0, IsOpen (S r)
S_cover : K ⊆ ⋃ r, ⋃ (_ : r > 0), S r
S_antitone : ∀ (r₁ r₂ : ℝ), r₁ ≤ r₂ → S r₂ ⊆ S r₁
T : Set ℝ
Tb : T ⊆ Real.lt✝ 0
Tfin : T.Finite
hT : K ⊆ ⋃ i ∈ T, S i
T_nonempty : T.Nonempty
x : E
hx : x ∈ K
r : ℝ
hr : r ∈ T ∧ x ∈ S r
⊢ x ∈ S (⋯.min T_nonempty)
|
94dd135f2a970b86
|
LocallyFinite.nhdsWithin_iUnion
|
Mathlib/Topology/LocallyFinite.lean
|
theorem nhdsWithin_iUnion (hf : LocallyFinite f) (a : X) :
𝓝[⋃ i, f i] a = ⨆ i, 𝓝[f i] a
|
case intro.intro
ι : Type u_1
X : Type u_4
inst✝ : TopologicalSpace X
f : ι → Set X
hf : LocallyFinite f
a : X
U : Set X
haU : U ∈ 𝓝 a
hfin : {i | (f i ∩ U).Nonempty}.Finite
⊢ 𝓝[⋃ i, f i] a = ⨆ i, 𝓝[f i] a
|
refine le_antisymm ?_ (Monotone.le_map_iSup fun _ _ ↦ nhdsWithin_mono _)
|
case intro.intro
ι : Type u_1
X : Type u_4
inst✝ : TopologicalSpace X
f : ι → Set X
hf : LocallyFinite f
a : X
U : Set X
haU : U ∈ 𝓝 a
hfin : {i | (f i ∩ U).Nonempty}.Finite
⊢ 𝓝[⋃ i, f i] a ≤ ⨆ i, 𝓝[f i] a
|
6a6117d01789edf6
|
Real.deriv2_mul_log
|
Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean
|
lemma deriv2_mul_log (x : ℝ) : deriv^[2] (fun x ↦ x * log x) x = x⁻¹
|
case pos
x : ℝ
hx : x = 0
⊢ deriv (deriv fun x => x * log x) 0 = 0
|
exact deriv_zero_of_not_differentiableAt
(fun h ↦ not_continuousAt_deriv_mul_log_zero h.continuousAt)
|
no goals
|
8a74dc0c380975af
|
VitaliFamily.withDensity_limRatioMeas_eq
|
Mathlib/MeasureTheory/Covering/Differentiation.lean
|
theorem withDensity_limRatioMeas_eq : μ.withDensity (v.limRatioMeas hρ) = ρ
|
case h.refine_1
α : Type u_1
inst✝⁴ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
s : Set α
hs : MeasurableSet s
this : Tendsto (fun t => ↑t ^ 2 * ρ s) (𝓝[>] 1) (𝓝 (1 ^ 2 * ρ s))
⊢ (μ.withDensity (v.limRatioMeas hρ)) s ≤ ρ s
|
simp only [one_pow, one_mul, ENNReal.coe_one] at this
|
case h.refine_1
α : Type u_1
inst✝⁴ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
s : Set α
hs : MeasurableSet s
this : Tendsto (fun t => ↑t ^ 2 * ρ s) (𝓝[>] 1) (𝓝 (ρ s))
⊢ (μ.withDensity (v.limRatioMeas hρ)) s ≤ ρ s
|
c98b00e271c474ed
|
InformationTheory.klDiv_eq_lintegral_klFun
|
Mathlib/InformationTheory/KullbackLeibler/Basic.lean
|
lemma klDiv_eq_lintegral_klFun :
klDiv μ ν = if μ ≪ ν then ∫⁻ x, ENNReal.ofReal (klFun (μ.rnDeriv ν x).toReal) ∂ν else ∞
|
case neg
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
hμν : μ ≪ ν
h_int_iff :
∫⁻ (a : α), ENNReal.ofReal (klFun (μ.rnDeriv ν a).toReal) ∂ν ≠ ⊤ ↔
Integrable (fun x => klFun (μ.rnDeriv ν x).toReal) ν
h_int : ¬Integrable (llr μ ν) μ
⊢ (if μ ≪ ν ∧ Integrable (llr μ ν) μ then ENNReal.ofReal (∫ (x : α), klFun (μ.rnDeriv ν x).toReal ∂ν) else ⊤) =
if μ ≪ ν then ∫⁻ (x : α), ENNReal.ofReal (klFun (μ.rnDeriv ν x).toReal) ∂ν else ⊤
|
rw [← not_iff_not, ne_eq, Decidable.not_not] at h_int_iff
|
case neg
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
hμν : μ ≪ ν
h_int_iff :
∫⁻ (a : α), ENNReal.ofReal (klFun (μ.rnDeriv ν a).toReal) ∂ν = ⊤ ↔
¬Integrable (fun x => klFun (μ.rnDeriv ν x).toReal) ν
h_int : ¬Integrable (llr μ ν) μ
⊢ (if μ ≪ ν ∧ Integrable (llr μ ν) μ then ENNReal.ofReal (∫ (x : α), klFun (μ.rnDeriv ν x).toReal ∂ν) else ⊤) =
if μ ≪ ν then ∫⁻ (x : α), ENNReal.ofReal (klFun (μ.rnDeriv ν x).toReal) ∂ν else ⊤
|
2592d1db22568a7f
|
MeasureTheory.lintegral_iSup
|
Mathlib/MeasureTheory/Integral/Lebesgue.lean
|
theorem lintegral_iSup {f : ℕ → α → ℝ≥0∞} (hf : ∀ n, Measurable (f n)) (h_mono : Monotone f) :
∫⁻ a, ⨆ n, f n a ∂μ = ⨆ n, ∫⁻ a, f n a ∂μ
|
case intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ofNNReal
F : α → ℝ≥0∞ := fun a => ⨆ n, f n a
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(s x) ≤ ⨆ n, f n x
r : ℝ≥0
right✝ : ↑r < 1
ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : SimpleFunc.map c rs = const α ↑r * SimpleFunc.map c s
eq : ∀ (p : ℝ≥0∞), ⇑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ n, ⇑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ⇑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
⊢ ↑r * (SimpleFunc.map ofNNReal s).lintegral μ ≤ ⨆ n, ∫⁻ (a : α), f n a ∂μ
|
have h_meas : ∀ n, MeasurableSet {a : α | map c rs a ≤ f n a} := fun n =>
measurableSet_le (SimpleFunc.measurable _) (hf n)
|
case intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), Measurable (f n)
h_mono : Monotone f
c : ℝ≥0 → ℝ≥0∞ := ofNNReal
F : α → ℝ≥0∞ := fun a => ⨆ n, f n a
s : α →ₛ ℝ≥0
hsf : ∀ (x : α), ↑(s x) ≤ ⨆ n, f n x
r : ℝ≥0
right✝ : ↑r < 1
ha✝ : ↑r < 1
ha : r < 1
rs : α →ₛ ℝ≥0 := SimpleFunc.map (fun a => r * a) s
eq_rs : SimpleFunc.map c rs = const α ↑r * SimpleFunc.map c s
eq : ∀ (p : ℝ≥0∞), ⇑(SimpleFunc.map c rs) ⁻¹' {p} = ⋃ n, ⇑(SimpleFunc.map c rs) ⁻¹' {p} ∩ {a | p ≤ f n a}
mono : ∀ (r : ℝ≥0∞), Monotone fun n => ⇑(SimpleFunc.map c rs) ⁻¹' {r} ∩ {a | r ≤ f n a}
h_meas : ∀ (n : ℕ), MeasurableSet {a | (SimpleFunc.map c rs) a ≤ f n a}
⊢ ↑r * (SimpleFunc.map ofNNReal s).lintegral μ ≤ ⨆ n, ∫⁻ (a : α), f n a ∂μ
|
e37d047cd3bb7874
|
CategoryTheory.TwoSquare.GuitartExact.whiskerVertical
|
Mathlib/CategoryTheory/GuitartExact/VerticalComposition.lean
|
/-- A 2-square stays Guitart exact if we replace the left and right functors
by isomorphic functors. See also `whiskerVertical_iff`. -/
lemma whiskerVertical [w.GuitartExact] (α : L ≅ L') (β : R ≅ R') :
(w.whiskerVertical α.hom β.inv).GuitartExact
|
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_4
D₂ : Type u_5
inst✝⁴ : Category.{u_7, u_1} C₁
inst✝³ : Category.{u_9, u_2} C₂
inst✝² : Category.{u_8, u_4} D₁
inst✝¹ : Category.{u_10, u_5} D₂
T : C₁ ⥤ D₁
L : C₁ ⥤ C₂
R : D₁ ⥤ D₂
B : C₂ ⥤ D₂
w : TwoSquare T L R B
L' : C₁ ⥤ C₂
R' : D₁ ⥤ D₂
inst✝ : w.GuitartExact
α : L ≅ L'
β : R ≅ R'
⊢ ∀ (X₂ : D₁), ((w.whiskerVertical α.hom β.inv).structuredArrowDownwards X₂).Initial
|
intro X₂
|
C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_4
D₂ : Type u_5
inst✝⁴ : Category.{u_7, u_1} C₁
inst✝³ : Category.{u_9, u_2} C₂
inst✝² : Category.{u_8, u_4} D₁
inst✝¹ : Category.{u_10, u_5} D₂
T : C₁ ⥤ D₁
L : C₁ ⥤ C₂
R : D₁ ⥤ D₂
B : C₂ ⥤ D₂
w : TwoSquare T L R B
L' : C₁ ⥤ C₂
R' : D₁ ⥤ D₂
inst✝ : w.GuitartExact
α : L ≅ L'
β : R ≅ R'
X₂ : D₁
⊢ ((w.whiskerVertical α.hom β.inv).structuredArrowDownwards X₂).Initial
|
f2a5c6dddf567542
|
IsArtinianRing.setOf_isMaximal_finite
|
Mathlib/RingTheory/Artinian/Module.lean
|
@[stacks 00J7]
lemma setOf_isMaximal_finite : {I : Ideal R | I.IsMaximal}.Finite
|
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : IsArtinianRing R
s : Finset { I // I.IsMaximal }
H : ∀ (a : { I // I.IsMaximal }), s.inf Subtype.val ≤ ↑a
p : ↑{I | I.IsMaximal}
⊢ p ∈ s
|
have ⟨q, hq1, hq2⟩ := p.2.isPrime.inf_le'.mp (H p)
|
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : IsArtinianRing R
s : Finset { I // I.IsMaximal }
H : ∀ (a : { I // I.IsMaximal }), s.inf Subtype.val ≤ ↑a
p : ↑{I | I.IsMaximal}
q : { I // I.IsMaximal }
hq1 : q ∈ s
hq2 : ↑q ≤ ↑p
⊢ p ∈ s
|
2f3781a7cf048e7b
|
exists_isIdempotentElem_mul_eq_zero_of_ker_isNilpotent_aux
|
Mathlib/RingTheory/Idempotents.lean
|
theorem exists_isIdempotentElem_mul_eq_zero_of_ker_isNilpotent_aux
(h : ∀ x ∈ RingHom.ker f, IsNilpotent x)
(e₁ : S) (he : e₁ ∈ f.range) (he₁ : IsIdempotentElem e₁)
(e₂ : R) (he₂ : IsIdempotentElem e₂) (he₁e₂ : e₁ * f e₂ = 0) :
∃ e' : R, IsIdempotentElem e' ∧ f e' = e₁ ∧ e' * e₂ = 0
|
case intro.inr.intro.refine_1.succ
R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
e₂ : R
he₂ : IsIdempotentElem e₂
e₁ : R
he₁ : IsIdempotentElem (f e₁)
he₁e₂ : f e₁ * f e₂ = 0
h✝ : Nontrivial R
a : R := e₁ - e₁ * e₂
ha : f a = f e₁
ha' : a * e₂ = 0
hx' : a - a ^ 2 ∈ RingHom.ker f
n : ℕ
hn : (a - a ^ 2) ^ (n + 1) = 0
⊢ f (1 - (1 - a ^ (n + 1)) ^ (n + 1)) = f e₁
|
simp only [map_sub, map_one, map_pow, ha, he₁.pow_succ_eq,
he₁.one_sub.pow_succ_eq, sub_sub_cancel]
|
no goals
|
58add8d013086a2a
|
MeasureTheory.Measure.haveLebesgueDecomposition_of_finiteMeasure
|
Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
|
theorem haveLebesgueDecomposition_of_finiteMeasure [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
HaveLebesgueDecomposition μ ν where
lebesgue_decomposition
|
α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
g : ℕ → ℝ≥0∞
h✝ : Monotone g
hg₂ : Filter.Tendsto g Filter.atTop (nhds (sSup (measurableLEEval ν μ)))
f : ℕ → α → ℝ≥0∞
hf₁ : ∀ (n : ℕ), f n ∈ measurableLE ν μ
hf₂ : ∀ (n : ℕ), (fun f => ∫⁻ (x : α), f x ∂ν) (f n) = g n
ξ : α → ℝ≥0∞ := ⨆ n, ⨆ k, ⨆ (_ : k ≤ n), f k
hξ : ξ = ⨆ n, ⨆ k, ⨆ (_ : k ≤ n), f k
hξ₁ : sSup (measurableLEEval ν μ) = ∫⁻ (a : α), ξ a ∂ν
hξm : Measurable ξ
hξle : ∀ (A : Set α), MeasurableSet A → ∫⁻ (a : α) in A, ξ a ∂ν ≤ μ A
hle : ν.withDensity ξ ≤ μ
hle' : (ν.withDensity ξ) univ ≤ μ univ
⊢ ∫⁻ (a : α), ξ a ∂ν ≠ ⊤
|
rw [withDensity_apply _ MeasurableSet.univ, Measure.restrict_univ] at hle'
|
α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
g : ℕ → ℝ≥0∞
h✝ : Monotone g
hg₂ : Filter.Tendsto g Filter.atTop (nhds (sSup (measurableLEEval ν μ)))
f : ℕ → α → ℝ≥0∞
hf₁ : ∀ (n : ℕ), f n ∈ measurableLE ν μ
hf₂ : ∀ (n : ℕ), (fun f => ∫⁻ (x : α), f x ∂ν) (f n) = g n
ξ : α → ℝ≥0∞ := ⨆ n, ⨆ k, ⨆ (_ : k ≤ n), f k
hξ : ξ = ⨆ n, ⨆ k, ⨆ (_ : k ≤ n), f k
hξ₁ : sSup (measurableLEEval ν μ) = ∫⁻ (a : α), ξ a ∂ν
hξm : Measurable ξ
hξle : ∀ (A : Set α), MeasurableSet A → ∫⁻ (a : α) in A, ξ a ∂ν ≤ μ A
hle : ν.withDensity ξ ≤ μ
hle' : ∫⁻ (a : α), ξ a ∂ν ≤ μ univ
⊢ ∫⁻ (a : α), ξ a ∂ν ≠ ⊤
|
0e340e69a0abebdf
|
PrimeSpectrum.isMaximal_of_toPiLocalization_surjective
|
Mathlib/RingTheory/Spectrum/Maximal/Localization.lean
|
theorem isMaximal_of_toPiLocalization_surjective (surj : Function.Surjective (toPiLocalization R))
(I : PrimeSpectrum R) : I.1.IsMaximal
|
case intro
R : Type u_1
inst✝ : CommSemiring R
surj : Function.Surjective ⇑(toPiLocalization R)
I : PrimeSpectrum R
J : Ideal R
max : J.IsMaximal
le : I.asIdeal ≤ J
r : R
hr : (toPiLocalization R) r = Function.update 0 { asIdeal := J, isPrime := ⋯ } 1
h : ¬I.asIdeal.IsMaximal
⊢ False
|
have hJ : algebraMap _ _ r = _ := (congr_fun hr _).trans (Function.update_self ..)
|
case intro
R : Type u_1
inst✝ : CommSemiring R
surj : Function.Surjective ⇑(toPiLocalization R)
I : PrimeSpectrum R
J : Ideal R
max : J.IsMaximal
le : I.asIdeal ≤ J
r : R
hr : (toPiLocalization R) r = Function.update 0 { asIdeal := J, isPrime := ⋯ } 1
h : ¬I.asIdeal.IsMaximal
hJ : (algebraMap R (Localization { asIdeal := J, isPrime := ⋯ }.asIdeal.primeCompl)) r = 1
⊢ False
|
9a9de007cef5767e
|
Set.nonempty_biUnion
|
Mathlib/Data/Set/Lattice.lean
|
theorem nonempty_biUnion {t : Set α} {s : α → Set β} :
(⋃ i ∈ t, s i).Nonempty ↔ ∃ i ∈ t, (s i).Nonempty
|
α : Type u_1
β : Type u_2
t : Set α
s : α → Set β
⊢ (⋃ i ∈ t, s i).Nonempty ↔ ∃ i ∈ t, (s i).Nonempty
|
simp
|
no goals
|
3e8d027103f4d344
|
CategoryTheory.IsUniversalColimit.whiskerEquivalence_iff
|
Mathlib/CategoryTheory/Limits/VanKampen.lean
|
theorem IsUniversalColimit.whiskerEquivalence_iff {K : Type*} [Category K] (e : J ≌ K)
{F : K ⥤ C} {c : Cocone F} :
IsUniversalColimit (c.whisker e.functor) ↔ IsUniversalColimit c :=
⟨fun hc ↦ ((hc.whiskerEquivalence e.symm).precompose_isIso (e.invFunIdAssoc F).inv).of_iso
(Cocones.ext (Iso.refl _) (by simp)), IsUniversalColimit.whiskerEquivalence e⟩
|
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
K : Type u_3
inst✝ : Category.{u_4, u_3} K
e : J ≌ K
F : K ⥤ C
c : Cocone F
hc : IsUniversalColimit (Cocone.whisker e.functor c)
⊢ ∀ (j : K),
((Cocones.precompose (e.invFunIdAssoc F).inv).obj
(Cocone.whisker e.symm.functor (Cocone.whisker e.functor c))).ι.app
j ≫
(Iso.refl
((Cocones.precompose (e.invFunIdAssoc F).inv).obj
(Cocone.whisker e.symm.functor (Cocone.whisker e.functor c))).pt).hom =
c.ι.app j
|
simp
|
no goals
|
5ec2c60fb96b32b9
|
MeasureTheory.tendsto_lintegral_norm_of_dominated_convergence
|
Mathlib/MeasureTheory/Function/L1Space/HasFiniteIntegral.lean
|
theorem tendsto_lintegral_norm_of_dominated_convergence {F : ℕ → α → β} {f : α → β} {bound : α → ℝ}
(F_measurable : ∀ n, AEStronglyMeasurable (F n) μ)
(bound_hasFiniteIntegral : HasFiniteIntegral bound μ)
(h_bound : ∀ n, ∀ᵐ a ∂μ, ‖F n a‖ ≤ bound a)
(h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))) :
Tendsto (fun n => ∫⁻ a, ENNReal.ofReal ‖F n a - f a‖ ∂μ) atTop (𝓝 0)
|
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
F : ℕ → α → β
f : α → β
bound : α → ℝ
F_measurable : ∀ (n : ℕ), AEStronglyMeasurable (F n) μ
bound_hasFiniteIntegral : HasFiniteIntegral bound μ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
f_measurable : AEStronglyMeasurable f μ
b : α → ℝ≥0∞ := fun a => 2 * ENNReal.ofReal (bound a)
n : ℕ
a : α
h₁ : ENNReal.ofReal ‖F n a‖ ≤ ENNReal.ofReal (bound a)
h₂ : ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)
⊢ ENNReal.ofReal ‖F n a - f a‖ ≤ ENNReal.ofReal ‖F n a‖ + ENNReal.ofReal ‖f a‖
|
rw [← ENNReal.ofReal_add]
|
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
F : ℕ → α → β
f : α → β
bound : α → ℝ
F_measurable : ∀ (n : ℕ), AEStronglyMeasurable (F n) μ
bound_hasFiniteIntegral : HasFiniteIntegral bound μ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
f_measurable : AEStronglyMeasurable f μ
b : α → ℝ≥0∞ := fun a => 2 * ENNReal.ofReal (bound a)
n : ℕ
a : α
h₁ : ENNReal.ofReal ‖F n a‖ ≤ ENNReal.ofReal (bound a)
h₂ : ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)
⊢ ENNReal.ofReal ‖F n a - f a‖ ≤ ENNReal.ofReal (‖F n a‖ + ‖f a‖)
case hp
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
F : ℕ → α → β
f : α → β
bound : α → ℝ
F_measurable : ∀ (n : ℕ), AEStronglyMeasurable (F n) μ
bound_hasFiniteIntegral : HasFiniteIntegral bound μ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
f_measurable : AEStronglyMeasurable f μ
b : α → ℝ≥0∞ := fun a => 2 * ENNReal.ofReal (bound a)
n : ℕ
a : α
h₁ : ENNReal.ofReal ‖F n a‖ ≤ ENNReal.ofReal (bound a)
h₂ : ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)
⊢ 0 ≤ ‖F n a‖
case hq
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
F : ℕ → α → β
f : α → β
bound : α → ℝ
F_measurable : ∀ (n : ℕ), AEStronglyMeasurable (F n) μ
bound_hasFiniteIntegral : HasFiniteIntegral bound μ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
f_measurable : AEStronglyMeasurable f μ
b : α → ℝ≥0∞ := fun a => 2 * ENNReal.ofReal (bound a)
n : ℕ
a : α
h₁ : ENNReal.ofReal ‖F n a‖ ≤ ENNReal.ofReal (bound a)
h₂ : ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)
⊢ 0 ≤ ‖f a‖
|
08c35611a6e7531a
|
Batteries.RBNode.balance1_All
|
Mathlib/.lake/packages/batteries/Batteries/Data/RBMap/WF.lean
|
theorem balance1_All {l : RBNode α} {v : α} {r : RBNode α} :
(balance1 l v r).All p ↔ p v ∧ l.All p ∧ r.All p
|
α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p (l.balance1 v r) ↔ p v ∧ All p l ∧ All p r
|
unfold balance1
|
α : Type u_1
p : α → Prop
l : RBNode α
v : α
r : RBNode α
⊢ All p
(match l, v, r with
| node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
| node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
| a, x, b => node black a x b) ↔
p v ∧ All p l ∧ All p r
|
61ac165bee48764b
|
Int.Matrix.image_T_subset_S
|
Mathlib/NumberTheory/SiegelsLemma.lean
|
private lemma image_T_subset_S [DecidableEq α] [DecidableEq β] (v) (hv : v ∈ T) : A *ᵥ v ∈ S
|
case refine_1.h.inr
α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
v : β → ℤ
hv : 0 ≤ v ∧ v ≤ B'
mulVec_def : A *ᵥ v = fun i => ∑ j : β, A i j * v j
i : α
j : β
a✝ : j ∈ univ
hsign : A i j ≤ 0
⊢ -(↑B * -A i j) ≤ v j * A i j
|
simp only [mul_neg, neg_neg]
|
case refine_1.h.inr
α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
v : β → ℤ
hv : 0 ≤ v ∧ v ≤ B'
mulVec_def : A *ᵥ v = fun i => ∑ j : β, A i j * v j
i : α
j : β
a✝ : j ∈ univ
hsign : A i j ≤ 0
⊢ ↑B * A i j ≤ v j * A i j
|
f9a7e5b087c18f50
|
balancedCoreAux_balanced
|
Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
|
theorem balancedCoreAux_balanced (h0 : (0 : E) ∈ balancedCoreAux 𝕜 s) :
Balanced 𝕜 (balancedCoreAux 𝕜 s)
|
case intro.intro.inr
𝕜 : Type u_1
E : Type u_2
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
h0 : 0 ∈ balancedCoreAux 𝕜 s
a : 𝕜
ha : ‖a‖ ≤ 1
y : E
hy : ∀ (r : 𝕜), 1 ≤ ‖r‖ → y ∈ r • s
h : a ≠ 0
r : 𝕜
hr : 1 ≤ ‖r‖
h'' : 1 ≤ ‖a⁻¹ • r‖
h' : y ∈ (a⁻¹ • r) • s
⊢ (fun x => a • x) y ∈ r • s
|
rwa [smul_assoc, mem_inv_smul_set_iff₀ h] at h'
|
no goals
|
d8dfb328ccf0ac15
|
CategoryTheory.Functor.shiftIso_hom_app_comp_shiftMap_of_add_eq_zero
|
Mathlib/CategoryTheory/Shift/ShiftSequence.lean
|
/--
If `f : X ⟶ Y⟦m⟧`, `n + m = 0` and `ha' : m + a = a'`, this lemma relates the two
morphisms `F.shiftMap f a a' ha'` and `(F.shift a').map (f⟦n⟧')`. Indeed,
via canonical isomorphisms, they both identify to morphisms
`(F.shift a).obj X ⟶ (F.shift a').obj Y`.
-/
lemma shiftIso_hom_app_comp_shiftMap_of_add_eq_zero [F.ShiftSequence G]
{X Y : C} {m : G} (f : X ⟶ Y⟦m⟧)
(n : G) (hnm : n + m = 0) (a a' : G) (ha' : m + a = a') :
(F.shiftIso n a' a (by rw [← ha', ← add_assoc, hnm, zero_add])).hom.app X ≫
F.shiftMap f a a' ha' =
(F.shift a').map (f⟦n⟧' ≫ (shiftFunctorCompIsoId C m n
(by rw [← add_left_inj m, add_assoc, hnm, zero_add, add_zero])).hom.app Y)
|
C : Type u_1
A : Type u_2
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{u_6, u_2} A
F : C ⥤ A
G : Type u_4
inst✝² : AddGroup G
inst✝¹ : HasShift C G
inst✝ : F.ShiftSequence G
X Y : C
m : G
f : X ⟶ (shiftFunctor C m).obj Y
n : G
hnm : n + m = 0
a a' : G
ha' : m + a = a'
hnm' : m + n = 0
⊢ (F.shiftIso n a' a ⋯).hom.app X ≫ F.shiftMap f a a' ha' =
(F.shift a').map ((shiftFunctor C n).map f ≫ (shiftFunctorCompIsoId C m n ⋯).hom.app Y)
|
simp [F.shiftIso_hom_app_comp_shiftMap f n 0 hnm' a' a, shiftIso_zero_hom_app,
shiftFunctorCompIsoId]
|
no goals
|
bffaf8c52e2aa69d
|
Antitone.cauchySeq_series_mul_of_tendsto_zero_of_bounded
|
Mathlib/Analysis/SpecificLimits/Normed.lean
|
theorem Antitone.cauchySeq_series_mul_of_tendsto_zero_of_bounded (hfa : Antitone f)
(hf0 : Tendsto f atTop (𝓝 0)) (hzb : ∀ n, ‖∑ i ∈ range n, z i‖ ≤ b) :
CauchySeq fun n ↦ ∑ i ∈ range n, f i • z i
|
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
b : ℝ
f : ℕ → ℝ
z : ℕ → E
hfa : Antitone f
hf0 : Tendsto f atTop (𝓝 0)
hzb : ∀ (n : ℕ), ‖∑ i ∈ Finset.range n, z i‖ ≤ b
hfa' : Monotone fun n => -f n
⊢ CauchySeq fun n => ∑ i ∈ Finset.range n, f i • z i
|
have hf0' : Tendsto (fun n ↦ -f n) atTop (𝓝 0) := by
convert hf0.neg
norm_num
|
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
b : ℝ
f : ℕ → ℝ
z : ℕ → E
hfa : Antitone f
hf0 : Tendsto f atTop (𝓝 0)
hzb : ∀ (n : ℕ), ‖∑ i ∈ Finset.range n, z i‖ ≤ b
hfa' : Monotone fun n => -f n
hf0' : Tendsto (fun n => -f n) atTop (𝓝 0)
⊢ CauchySeq fun n => ∑ i ∈ Finset.range n, f i • z i
|
6435d9d96a9e6e86
|
Nat.multinomial_two_mul_le_mul_multinomial
|
Mathlib/Data/Nat/Choose/Multinomial.lean
|
lemma multinomial_two_mul_le_mul_multinomial :
multinomial s (fun i ↦ 2 * f i) ≤ ((∑ i ∈ s, f i) ^ ∑ i ∈ s, f i) * multinomial s f
|
ι : Type u_1
s : Finset ι
f : ι → ℕ
⊢ (2 * ∑ i ∈ s, f i)! / ∏ i ∈ s, (2 * f i)! ≤ ((∑ i ∈ s, f i) ^ ∑ i ∈ s, f i) * (∑ i ∈ s, f i)! / ∏ i ∈ s, (f i)!
|
refine Nat.div_le_div_of_mul_le_mul (by positivity)
((prod_factorial_dvd_factorial_sum ..).trans (Nat.dvd_mul_left ..)) ?_
|
ι : Type u_1
s : Finset ι
f : ι → ℕ
⊢ (2 * ∑ i ∈ s, f i)! * ∏ i ∈ s, (f i)! ≤ ((∑ i ∈ s, f i) ^ ∑ i ∈ s, f i) * (∑ i ∈ s, f i)! * ∏ i ∈ s, (2 * f i)!
|
f44b98bbd43a1101
|
MeasureTheory.DominatedFinMeasAdditive.of_measure_le
|
Mathlib/MeasureTheory/Integral/SetToL1.lean
|
theorem of_measure_le {μ' : Measure α} (h : μ ≤ μ') (hT : DominatedFinMeasAdditive μ T C)
(hC : 0 ≤ C) : DominatedFinMeasAdditive μ' T C
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
β : Type u_7
inst✝ : SeminormedAddCommGroup β
T : Set α → β
C : ℝ
μ' : Measure α
h : μ ≤ μ'
hT : DominatedFinMeasAdditive μ T C
hC : 0 ≤ C
h' : ∀ (s : Set α), μ s = ⊤ → μ' s = ⊤
s : Set α
hs : MeasurableSet s
hμ's : μ' s < ⊤
hμs : μ s < ⊤
⊢ ‖T s‖ ≤ C * (μ' s).toReal
|
calc
‖T s‖ ≤ C * (μ s).toReal := hT.2 s hs hμs
_ ≤ C * (μ' s).toReal := by gcongr; exacts [hμ's.ne, h _]
|
no goals
|
6e7946b9810c2855
|
WeakFEPair.f_modif_aux1
|
Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean
|
lemma f_modif_aux1 : EqOn (fun x ↦ P.f_modif x - P.f x + P.f₀)
((Ioo 0 1).indicator (fun x : ℝ ↦ P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀)
+ ({1} : Set ℝ).indicator (fun _ ↦ P.f₀ - P.f 1)) (Ioi 0)
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
P : WeakFEPair E
⊢ EqOn (fun x => P.f_modif x - P.f x + P.f₀)
(((Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1) (Ioi 0)
|
intro x (hx : 0 < x)
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ (fun x => P.f_modif x - P.f x + P.f₀) x =
(((Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1) x
|
e228f7d66be0dcb7
|
CategoryTheory.Limits.limit_π_isIso_of_is_strict_terminal
|
Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
|
theorem limit_π_isIso_of_is_strict_terminal (F : J ⥤ C) [HasLimit F] (i : J)
(H : ∀ (j) (_ : j ≠ i), IsTerminal (F.obj j)) [Subsingleton (i ⟶ i)] : IsIso (limit.π F i)
|
case pos.refl.refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasStrictTerminalObjects C
J : Type v
inst✝² : SmallCategory J
F : J ⥤ C
inst✝¹ : HasLimit F
i : J
H : (j : J) → j ≠ i → IsTerminal (F.obj j)
inst✝ : Subsingleton (i ⟶ i)
⊢ ((Functor.const J).obj (F.toPrefunctor.1 i)).map (𝟙 i) ≫ eqToHom ⋯ = eqToHom ⋯ ≫ F.map (𝟙 i)
|
simp
|
no goals
|
464f78ec21e1a3ee
|
linearIndependent_of_ne_zero_of_inner_eq_zero
|
Mathlib/Analysis/InnerProductSpace/Basic.lean
|
theorem linearIndependent_of_ne_zero_of_inner_eq_zero {ι : Type*} {v : ι → E} (hz : ∀ i, v i ≠ 0)
(ho : Pairwise fun i j => ⟪v i, v j⟫ = 0) : LinearIndependent 𝕜 v
|
case convert_3
𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_4
v : ι → E
hz : ∀ (i : ι), v i ≠ 0
ho : Pairwise fun i j => inner (v i) (v j) = 0
s : Finset ι
g : ι → 𝕜
hg : ∑ i ∈ s, g i • v i = 0
i : ι
hi : i ∈ s
⊢ ∀ b ∈ s, b ≠ i → inner (v i) (g b • v b) = 0
|
intro j _hj hji
|
case convert_3
𝕜 : Type u_1
E : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
ι : Type u_4
v : ι → E
hz : ∀ (i : ι), v i ≠ 0
ho : Pairwise fun i j => inner (v i) (v j) = 0
s : Finset ι
g : ι → 𝕜
hg : ∑ i ∈ s, g i • v i = 0
i : ι
hi : i ∈ s
j : ι
_hj : j ∈ s
hji : j ≠ i
⊢ inner (v i) (g j • v j) = 0
|
8e5b7920a8b38e39
|
Batteries.RBNode.Balanced.insert
|
Mathlib/.lake/packages/batteries/Batteries/Data/RBMap/WF.lean
|
theorem Balanced.insert {t : RBNode α} (h : t.Balanced c n) :
∃ c' n', (insert cmp t v).Balanced c' n'
|
α : Type u_1
c : RBColor
n : Nat
cmp : α → α → Ordering
v : α
t a✝¹ : RBNode α
c₁✝ : RBColor
b✝ : RBNode α
c₂✝ : RBColor
x✝ : α
ha : a✝¹.Balanced c₁✝ n
hb : b✝.Balanced c₂✝ n
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
h : (node red l✝ v✝ r✝).Balanced c n
a✝ : (node red l✝ v✝ r✝).isRed = red
⊢ ∃ c' n',
(match (node red l✝ v✝ r✝).isRed with
| red => (node red a✝¹ x✝ b✝).setBlack
| black => node red a✝¹ x✝ b✝).Balanced
c' n'
|
exact ⟨_, _, .black ha hb⟩
|
no goals
|
7df205259925d80b
|
Set.encard_eq_add_one_iff
|
Mathlib/Data/Set/Card.lean
|
theorem encard_eq_add_one_iff {k : ℕ∞} :
s.encard = k + 1 ↔ (∃ a t, ¬a ∈ t ∧ insert a t = s ∧ t.encard = k)
|
case refine_2
α : Type u_1
s : Set α
k : ℕ∞
⊢ (∃ a t, a ∉ t ∧ insert a t = s ∧ t.encard = k) → s.encard = k + 1
|
rintro ⟨a, t, h, rfl, rfl⟩
|
case refine_2.intro.intro.intro.intro
α : Type u_1
a : α
t : Set α
h : a ∉ t
⊢ (insert a t).encard = t.encard + 1
|
5a5667cf41f5375f
|
PresheafOfModules.hom_ext
|
Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
|
@[ext]
lemma hom_ext {f g : M₁ ⟶ M₂} (h : ∀ (X : Cᵒᵖ), f.app X = g.app X) :
f = g := Hom.ext (by ext1; apply h)
|
C : Type u₁
inst✝ : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
M₁ M₂ : PresheafOfModules R
f g : M₁ ⟶ M₂
h : ∀ (X : Cᵒᵖ), f.app X = g.app X
⊢ f.app = g.app
|
ext1
|
case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
M₁ M₂ : PresheafOfModules R
f g : M₁ ⟶ M₂
h : ∀ (X : Cᵒᵖ), f.app X = g.app X
x✝ : Cᵒᵖ
⊢ f.app x✝ = g.app x✝
|
f5e4e91e10457734
|
Cardinal.prime_of_aleph0_le
|
Mathlib/SetTheory/Cardinal/Divisibility.lean
|
theorem prime_of_aleph0_le (ha : ℵ₀ ≤ a) : Prime a
|
case refine_2.inr.inr.inr.hz
a : Cardinal.{u}
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → ∀ (b c : Cardinal.{u}), a ∣ b * c → b * c ≠ 0 → c ≤ b → a ∣ b ∨ a ∣ c
h : ¬c ≤ b
h✝ : b ≤ c
⊢ c * b ≠ 0
|
rwa [mul_comm]
|
no goals
|
05a70ed30972affc
|
Prod.map_leftInverse
|
Mathlib/Data/Prod/Basic.lean
|
theorem map_leftInverse [Nonempty β] [Nonempty δ] {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α}
{g₂ : δ → γ} : LeftInverse (map f₁ g₁) (map f₂ g₂) ↔ LeftInverse f₁ f₂ ∧ LeftInverse g₁ g₂ :=
⟨fun h =>
⟨fun b => by
inhabit δ
exact congr_arg Prod.fst (h (b, default)),
fun d => by
inhabit β
exact congr_arg Prod.snd (h (default, d))⟩,
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₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
b : β
inhabited_h : Inhabited δ
⊢ f₁ (f₂ b) = b
|
exact congr_arg Prod.fst (h (b, default))
|
no goals
|
e56139999ef6092b
|
CategoryTheory.Functor.uncurry_obj_curry_obj_flip_flip'
|
Mathlib/CategoryTheory/Functor/Currying.lean
|
lemma uncurry_obj_curry_obj_flip_flip' (F₁ : B ⥤ C) (F₂ : D ⥤ E) (G : C × E ⥤ H) :
uncurry.obj (F₁ ⋙ (F₂ ⋙ (curry.obj G).flip).flip) = (F₁.prod F₂) ⋙ G :=
Functor.ext (by simp) (fun ⟨x₁, x₂⟩ ⟨y₁, y₂⟩ ⟨f₁, f₂⟩ => by
dsimp
simp only [Category.id_comp, Category.comp_id, ← G.map_comp, prod_comp])
|
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
⊢ ∀ (X : B × D), (uncurry.obj (F₁ ⋙ (F₂ ⋙ (curry.obj G).flip).flip)).obj X = (F₁.prod F₂ ⋙ G).obj X
|
simp
|
no goals
|
24b3f8808a4e0b85
|
Ideal.isPrime_of_prime
|
Mathlib/RingTheory/DedekindDomain/Ideal.lean
|
theorem Ideal.isPrime_of_prime {P : Ideal A} (h : Prime P) : IsPrime P
|
case refine_2
A : Type u_2
inst✝¹ : CommRing A
inst✝ : IsDedekindDomain A
P : Ideal A
h : Prime P
x✝ y✝ : A
hxy : x✝ * y✝ ∈ P
⊢ x✝ ∈ P ∨ y✝ ∈ P
|
simp only [← Ideal.dvd_span_singleton, ← Ideal.span_singleton_mul_span_singleton] at hxy ⊢
|
case refine_2
A : Type u_2
inst✝¹ : CommRing A
inst✝ : IsDedekindDomain A
P : Ideal A
h : Prime P
x✝ y✝ : A
hxy : P ∣ span {x✝} * span {y✝}
⊢ P ∣ span {x✝} ∨ P ∣ span {y✝}
|
53a6e4534a408bba
|
ContMDiff.inr
|
Mathlib/Geometry/Manifold/ContMDiff/Constructions.lean
|
lemma ContMDiff.inr : ContMDiff I I n (@Sum.inr M M')
|
case h₁
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u_16
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H M'
n : WithTop ℕ∞
x : M'
⊢ ↑(extChartAt I (Sum.inr x)) ∘ Sum.inr ∘ ↑(extChartAt I x).symm =ᶠ[𝓝[range ↑I] ↑(extChartAt I x) x] id
|
set C := chartAt H x with hC
|
case h₁
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
M' : Type u_16
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H M'
n : WithTop ℕ∞
x : M'
C : PartialHomeomorph M' H := chartAt H x
hC : C = chartAt H x
⊢ ↑(extChartAt I (Sum.inr x)) ∘ Sum.inr ∘ ↑(extChartAt I x).symm =ᶠ[𝓝[range ↑I] ↑(extChartAt I x) x] id
|
3b205cc4e6e6c88f
|
exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt
|
Mathlib/MeasureTheory/Function/Jacobian.lean
|
theorem exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt [SecondCountableTopology F]
(f : E → F) (s : Set E) (f' : E → E →L[ℝ] F) (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x)
(r : (E →L[ℝ] F) → ℝ≥0) (rpos : ∀ A, r A ≠ 0) :
∃ (t : ℕ → Set E) (A : ℕ → E →L[ℝ] F),
(∀ n, IsClosed (t n)) ∧
(s ⊆ ⋃ n, t n) ∧
(∀ n, ApproximatesLinearOn f (A n) (s ∩ t n) (r (A n))) ∧
(s.Nonempty → ∀ n, ∃ y ∈ s, A n = f' y)
|
E : Type u_1
F : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : SecondCountableTopology F
f : E → F
s : Set E
f' : E → E →L[ℝ] F
hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x
r : (E →L[ℝ] F) → ℝ≥0
rpos : ∀ (A : E →L[ℝ] F), r A ≠ 0
hs : s.Nonempty
T : Set ↑s
T_count : T.Countable
hT : ⋃ x ∈ T, ball (f' ↑x) ↑(r (f' ↑x)) = ⋃ x, ball (f' ↑x) ↑(r (f' ↑x))
u : ℕ → ℝ
left✝ : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
M : ℕ → ↑T → Set E :=
fun n z => {x | x ∈ s ∧ ∀ y ∈ s ∩ ball x (u n), ‖f y - f x - (f' ↑↑z) (y - x)‖ ≤ ↑(r (f' ↑↑z)) * ‖y - x‖}
x : E
xs : x ∈ s
z : ↑s
zT : z ∈ T
hz : f' x ∈ ball (f' ↑z) ↑(r (f' ↑z))
ε : ℝ
εpos : 0 < ε
hε : ‖f' x - f' ↑z‖ + ε ≤ ↑(r (f' ↑z))
δ : ℝ
δpos : 0 < δ
hδ : ball x δ ∩ s ⊆ {y | ‖f y - f x - (f' x) (y - x)‖ ≤ ε * ‖y - x‖}
n : ℕ
hn : u n < δ
y : E
hy : y ∈ s ∩ ball x (u n)
⊢ ‖f y - f x - (f' ↑z) (y - x)‖ = ‖f y - f x - (f' x) (y - x) + (f' x - f' ↑z) (y - x)‖
|
congr 1
|
case e_a
E : Type u_1
F : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : SecondCountableTopology F
f : E → F
s : Set E
f' : E → E →L[ℝ] F
hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x
r : (E →L[ℝ] F) → ℝ≥0
rpos : ∀ (A : E →L[ℝ] F), r A ≠ 0
hs : s.Nonempty
T : Set ↑s
T_count : T.Countable
hT : ⋃ x ∈ T, ball (f' ↑x) ↑(r (f' ↑x)) = ⋃ x, ball (f' ↑x) ↑(r (f' ↑x))
u : ℕ → ℝ
left✝ : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
M : ℕ → ↑T → Set E :=
fun n z => {x | x ∈ s ∧ ∀ y ∈ s ∩ ball x (u n), ‖f y - f x - (f' ↑↑z) (y - x)‖ ≤ ↑(r (f' ↑↑z)) * ‖y - x‖}
x : E
xs : x ∈ s
z : ↑s
zT : z ∈ T
hz : f' x ∈ ball (f' ↑z) ↑(r (f' ↑z))
ε : ℝ
εpos : 0 < ε
hε : ‖f' x - f' ↑z‖ + ε ≤ ↑(r (f' ↑z))
δ : ℝ
δpos : 0 < δ
hδ : ball x δ ∩ s ⊆ {y | ‖f y - f x - (f' x) (y - x)‖ ≤ ε * ‖y - x‖}
n : ℕ
hn : u n < δ
y : E
hy : y ∈ s ∩ ball x (u n)
⊢ f y - f x - (f' ↑z) (y - x) = f y - f x - (f' x) (y - x) + (f' x - f' ↑z) (y - x)
|
6721258aaeea8779
|
Complex.sinh_three_mul
|
Mathlib/Data/Complex/Trigonometric.lean
|
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x
|
x : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * (2 * sinh x * cosh x) = 2 * sinh x * cosh x ^ 2
|
ring
|
no goals
|
737e6f979e70c403
|
Std.DHashMap.Internal.List.getEntry?_replaceEntry_of_true
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem getEntry?_replaceEntry_of_true [BEq α] [PartialEquivBEq α] {l : List ((a : α) × β a)}
{a k : α} {v : β k} (hl : containsKey k l = true) (h : k == a) :
getEntry? a (replaceEntry k v l) = some ⟨k, v⟩
|
α : Type u
β : α → Type v
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
a k : α
v : β k
h : (k == a) = true
k' : α
v' : β k'
l : List ((a : α) × β a)
ih : containsKey k l = true → getEntry? a (replaceEntry k v l) = some ⟨k, v⟩
hl : containsKey k (⟨k', v'⟩ :: l) = true
⊢ getEntry? a (replaceEntry k v (⟨k', v'⟩ :: l)) = some ⟨k, v⟩
|
cases hk'a : k' == k
|
case false
α : Type u
β : α → Type v
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
a k : α
v : β k
h : (k == a) = true
k' : α
v' : β k'
l : List ((a : α) × β a)
ih : containsKey k l = true → getEntry? a (replaceEntry k v l) = some ⟨k, v⟩
hl : containsKey k (⟨k', v'⟩ :: l) = true
hk'a : (k' == k) = false
⊢ getEntry? a (replaceEntry k v (⟨k', v'⟩ :: l)) = some ⟨k, v⟩
case true
α : Type u
β : α → Type v
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
a k : α
v : β k
h : (k == a) = true
k' : α
v' : β k'
l : List ((a : α) × β a)
ih : containsKey k l = true → getEntry? a (replaceEntry k v l) = some ⟨k, v⟩
hl : containsKey k (⟨k', v'⟩ :: l) = true
hk'a : (k' == k) = true
⊢ getEntry? a (replaceEntry k v (⟨k', v'⟩ :: l)) = some ⟨k, v⟩
|
1c2ff6f966c7019e
|
Nat.Linear.ExprCnstr.denote_toNormPoly
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
|
theorem ExprCnstr.denote_toNormPoly (ctx : Context) (c : ExprCnstr) : c.toNormPoly.denote ctx = c.denote ctx
|
ctx : Context
c : ExprCnstr
⊢ PolyCnstr.denote ctx c.toNormPoly = denote ctx c
|
cases c
|
case mk
ctx : Context
eq✝ : Bool
lhs✝ rhs✝ : Expr
⊢ PolyCnstr.denote ctx { eq := eq✝, lhs := lhs✝, rhs := rhs✝ }.toNormPoly =
denote ctx { eq := eq✝, lhs := lhs✝, rhs := rhs✝ }
|
46ed2d5790151cf9
|
Std.Tactic.BVDecide.LRAT.check_sound
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Checker.lean
|
theorem check_sound (lratProof : Array IntAction) (cnf : CNF Nat) :
check lratProof cnf → cnf.Unsat
|
case a
lratProof : Array IntAction
cnf : CNF Nat
h1 :
lratChecker (CNF.convertLRAT cnf)
(List.filterMap
(fun actOpt =>
match actOpt with
| none => none
| some (Action.addEmpty id rupHints) => some (Action.addEmpty id rupHints)
| some (Action.addRup id c rupHints) => some (Action.addRup id c rupHints)
| some (Action.del ids) => some (Action.del ids)
| some (Action.addRat id c pivot rupHints ratHints) =>
if pivot ∈ Clause.toList c then some (Action.addRat id c pivot rupHints ratHints) else none)
(List.map (intActionToDefaultClauseAction (cnf.numLiterals + 1)) lratProof.toList)) =
Result.success
h2 : Unsatisfiable (PosFin (cnf.numLiterals + 1)) (CNF.convertLRAT cnf)
⊢ Unsatisfiable (PosFin (cnf.numLiterals + 1)) (CNF.convertLRAT cnf)
|
assumption
|
no goals
|
c30c2b987b29eb3d
|
convexOn_zpow
|
Mathlib/Analysis/Convex/Mul.lean
|
/-- `x^m`, `m : ℤ` is convex on `(0, +∞)` for all `m`. -/
lemma convexOn_zpow : ∀ n : ℤ, ConvexOn 𝕜 (Ioi 0) fun x : 𝕜 ↦ x ^ n
| (n : ℕ) => by
simp_rw [zpow_natCast]
exact (convexOn_pow n).subset Ioi_subset_Ici_self (convex_Ioi _)
| -[n+1] => by
simp_rw [zpow_negSucc, ← inv_pow]
refine (convexOn_iff_forall_pos.2 ⟨convex_Ioi _, ?_⟩).pow (fun x (hx : 0 < x) ↦ by positivity) _
rintro x (hx : 0 < x) y (hy : 0 < y) a b ha hb hab
field_simp
rw [div_le_div_iff₀, ← sub_nonneg]
· calc
0 ≤ a * b * (x - y) ^ 2
|
case hd
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
n : ℕ
x : 𝕜
hx : 0 < x
y : 𝕜
hy : 0 < y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < x * y
|
positivity
|
no goals
|
b154fb3321707078
|
Multiset.coe_count
|
Mathlib/Data/Multiset/Count.lean
|
theorem coe_count (a : α) (l : List α) : count a (ofList l) = l.count a
|
α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
⊢ List.countP (fun b => decide (b = a)) l = List.countP (fun x => x == a) l
|
rfl
|
no goals
|
75d288c7e77c5dde
|
HahnSeries.map_sub
|
Mathlib/RingTheory/HahnSeries/Addition.lean
|
@[simp]
protected lemma map_sub [AddGroup S] (f : R →+ S) {x y : HahnSeries Γ R} :
((x - y).map f : HahnSeries Γ S) = x.map f - y.map f
|
case coeff.h
Γ : Type u_1
R : Type u_3
S : Type u_4
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : AddGroup S
f : R →+ S
x y : HahnSeries Γ R
x✝ : Γ
⊢ ((x - y).map f).coeff x✝ = (x.map f - y.map f).coeff x✝
|
simp
|
no goals
|
01281b1d860baaef
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go_denote_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.lean
|
theorem go_denote_eq (aig : AIG α) (distance : Nat) (input : AIG.RefVec aig w)
(assign : α → Bool) (curr : Nat) (hcurr : curr ≤ w) (s : AIG.RefVec aig curr) :
∀ (idx : Nat) (hidx1 : idx < w),
curr ≤ idx
→
⟦
(go aig input distance curr hcurr s).aig,
(go aig input distance curr hcurr s).vec.get idx hidx1,
assign
⟧
=
if hidx : idx < distance then
false
else
⟦aig, input.get (idx - distance) (by omega), assign⟧
|
case isTrue.inl.isTrue.isTrue
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
distance : Nat
input : aig.RefVec w
assign : α → Bool
curr : Nat
hcurr : curr ≤ w
s : aig.RefVec curr
idx : Nat
hidx1 : idx < w
hidx2 : curr ≤ idx
res : RefVecEntry α w
h✝² : curr < w
heq : curr = idx
h✝¹ : curr < distance
hgo :
go (aig.mkConstCached false).aig (input.cast ⋯) distance (curr + 1) ⋯
((s.cast ⋯).push (aig.mkConstCached false).ref) =
res
h✝ : idx < distance
⊢ ⟦assign,
{
aig :=
(go (aig.mkConstCached false).aig (input.cast ⋯) distance (curr + 1) ⋯
((s.cast ⋯).push (aig.mkConstCached false).ref)).aig,
ref := (((s.cast ⋯).push (aig.mkConstCached false).ref).get idx ?isTrue.inl.isTrue.isTrue.hidx).cast ⋯ }⟧ =
false
case isTrue.inl.isTrue.isTrue.hidx
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
distance : Nat
input : aig.RefVec w
assign : α → Bool
curr : Nat
hcurr : curr ≤ w
s : aig.RefVec curr
idx : Nat
hidx1 : idx < w
hidx2 : curr ≤ idx
res : RefVecEntry α w
h✝² : curr < w
heq : curr = idx
h✝¹ : curr < distance
hgo :
go (aig.mkConstCached false).aig (input.cast ⋯) distance (curr + 1) ⋯
((s.cast ⋯).push (aig.mkConstCached false).ref) =
res
h✝ : idx < distance
⊢ idx < curr + 1
|
rw [AIG.RefVec.get_push_ref_eq']
|
case isTrue.inl.isTrue.isTrue
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
distance : Nat
input : aig.RefVec w
assign : α → Bool
curr : Nat
hcurr : curr ≤ w
s : aig.RefVec curr
idx : Nat
hidx1 : idx < w
hidx2 : curr ≤ idx
res : RefVecEntry α w
h✝² : curr < w
heq : curr = idx
h✝¹ : curr < distance
hgo :
go (aig.mkConstCached false).aig (input.cast ⋯) distance (curr + 1) ⋯
((s.cast ⋯).push (aig.mkConstCached false).ref) =
res
h✝ : idx < distance
⊢ ⟦assign,
{
aig :=
(go (aig.mkConstCached false).aig (input.cast ⋯) distance (curr + 1) ⋯
((s.cast ⋯).push (aig.mkConstCached false).ref)).aig,
ref := (aig.mkConstCached false).ref.cast ⋯ }⟧ =
false
case isTrue.inl.isTrue.isTrue.hidx
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
distance : Nat
input : aig.RefVec w
assign : α → Bool
curr : Nat
hcurr : curr ≤ w
s : aig.RefVec curr
idx : Nat
hidx1 : idx < w
hidx2 : curr ≤ idx
res : RefVecEntry α w
h✝² : curr < w
heq : curr = idx
h✝¹ : curr < distance
hgo :
go (aig.mkConstCached false).aig (input.cast ⋯) distance (curr + 1) ⋯
((s.cast ⋯).push (aig.mkConstCached false).ref) =
res
h✝ : idx < distance
⊢ idx = curr
|
625f9e09be737d85
|
SetTheory.PGame.insertLeft_numeric
|
Mathlib/SetTheory/Surreal/Basic.lean
|
theorem insertLeft_numeric {x x' : PGame} (x_num : x.Numeric) (x'_num : x'.Numeric)
(h : x' ≤ x) : (insertLeft x x').Numeric
|
x x' : PGame
x'_num : x'.Numeric
h : (∀ (i : x'.LeftMoves), x'.moveLeft i < x) ∧ ∀ (j : x.RightMoves), x' < x.moveRight j
x_num :
match x with
| mk α β L R => (∀ (i : α) (j : β), L i < R j) ∧ (∀ (i : α), (L i).Numeric) ∧ ∀ (j : β), (R j).Numeric
⊢ match x.insertLeft x' with
| mk α β L R => (∀ (i : α) (j : β), L i < R j) ∧ (∀ (i : α), (L i).Numeric) ∧ ∀ (j : β), (R j).Numeric
|
rcases x with ⟨xl, xr, xL, xR⟩
|
case mk
x' : PGame
x'_num : x'.Numeric
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
h :
(∀ (i : x'.LeftMoves), x'.moveLeft i < mk xl xr xL xR) ∧
∀ (j : (mk xl xr xL xR).RightMoves), x' < (mk xl xr xL xR).moveRight j
x_num :
match mk xl xr xL xR with
| mk α β L R => (∀ (i : α) (j : β), L i < R j) ∧ (∀ (i : α), (L i).Numeric) ∧ ∀ (j : β), (R j).Numeric
⊢ match (mk xl xr xL xR).insertLeft x' with
| mk α β L R => (∀ (i : α) (j : β), L i < R j) ∧ (∀ (i : α), (L i).Numeric) ∧ ∀ (j : β), (R j).Numeric
|
9cd580433e4e5761
|
IsZGroup.exponent_eq_card
|
Mathlib/GroupTheory/SpecificGroups/ZGroup.lean
|
theorem exponent_eq_card [Finite G] [IsZGroup G] : Monoid.exponent G = Nat.card G
|
G : Type u_1
inst✝² : Group G
inst✝¹ : Finite G
inst✝ : IsZGroup G
p : ℕ
hp : Nat.Prime p
this : Fact (Nat.Prime p)
P : Sylow p G := default
⊢ (Nat.card G).factorization p ≤ (Monoid.exponent G).factorization p
|
rw [← hp.pow_dvd_iff_le_factorization Monoid.exponent_ne_zero_of_finite,
← P.card_eq_multiplicity, ← (isZGroup p hp P).exponent_eq_card]
|
G : Type u_1
inst✝² : Group G
inst✝¹ : Finite G
inst✝ : IsZGroup G
p : ℕ
hp : Nat.Prime p
this : Fact (Nat.Prime p)
P : Sylow p G := default
⊢ Monoid.exponent ↥↑P ∣ Monoid.exponent G
|
1378a781d9dd8b12
|
Mathlib.Tactic.Ring.add_pf_add_overlap
|
Mathlib/Tactic/Ring/Basic.lean
|
theorem add_pf_add_overlap
(_ : a₁ + b₁ = c₁) (_ : a₂ + b₂ = c₂) : (a₁ + a₂ : R) + (b₁ + b₂) = c₁ + c₂
|
R : Type u_1
inst✝ : CommSemiring R
a₁ a₂ b₁ b₂ c₁ c₂ : R
x✝¹ : a₁ + b₁ = c₁
x✝ : a₂ + b₂ = c₂
⊢ a₁ + a₂ + (b₁ + b₂) = c₁ + c₂
|
subst_vars
|
R : Type u_1
inst✝ : CommSemiring R
a₁ a₂ b₁ b₂ : R
⊢ a₁ + a₂ + (b₁ + b₂) = a₁ + b₁ + (a₂ + b₂)
|
b1e9873612add3ee
|
Polynomial.opRingEquiv_op_monomial
|
Mathlib/RingTheory/Polynomial/Opposites.lean
|
theorem opRingEquiv_op_monomial (n : ℕ) (r : R) :
opRingEquiv R (op (monomial n r : R[X])) = monomial n (op r)
|
R : Type u_1
inst✝ : Semiring R
n : ℕ
r : R
⊢ (opRingEquiv R) (op ((monomial n) r)) = (monomial n) (op r)
|
simp only [opRingEquiv, RingEquiv.coe_trans, Function.comp_apply,
AddMonoidAlgebra.opRingEquiv_apply, RingEquiv.op_apply_apply, toFinsuppIso_apply, unop_op,
toFinsupp_monomial, Finsupp.mapRange_single, toFinsuppIso_symm_apply, ofFinsupp_single]
|
no goals
|
29025b0c05af9289
|
MeasureTheory.eLpNorm_smul_measure_of_ne_zero_of_ne_top
|
Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
|
theorem eLpNorm_smul_measure_of_ne_zero_of_ne_top {p : ℝ≥0∞} (hp_ne_zero : p ≠ 0)
(hp_ne_top : p ≠ ∞) {f : α → ε} (c : ℝ≥0∞) :
eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ
|
case e_a.e_a
α : Type u_1
ε : Type u_2
m0 : MeasurableSpace α
μ : Measure α
inst✝ : ENorm ε
p : ℝ≥0∞
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → ε
c : ℝ≥0∞
⊢ p.toReal⁻¹ = p⁻¹.toReal
|
rw [ENNReal.toReal_inv]
|
no goals
|
29a17d4553f41dd2
|
Fin.accumulate_rec
|
Mathlib/RingTheory/MvPolynomial/Symmetric/FundamentalTheorem.lean
|
lemma accumulate_rec {i n m : ℕ} (hin : i < n) (him : i + 1 < m) (t : Fin n → ℕ) :
accumulate n m t ⟨i, Nat.lt_of_succ_lt him⟩ = t ⟨i, hin⟩ + accumulate n m t ⟨i + 1, him⟩
|
case h.e'_3.h.e'_6.h.h
i n m : ℕ
hin : i < n
him : i + 1 < m
t : Fin n → ℕ
a✝ : Fin n
⊢ a✝ ∈ filter (fun i_1 => i + 1 ≤ ↑i_1) univ ↔ a✝ ≠ ⟨i, hin⟩ ∧ a✝ ∈ filter (fun i_1 => i ≤ ↑i_1) univ
|
simp_rw [mem_filter, mem_univ, true_and, i.succ_le_iff, lt_iff_le_and_ne]
|
case h.e'_3.h.e'_6.h.h
i n m : ℕ
hin : i < n
him : i + 1 < m
t : Fin n → ℕ
a✝ : Fin n
⊢ i ≤ ↑a✝ ∧ i ≠ ↑a✝ ↔ a✝ ≠ ⟨i, hin⟩ ∧ i ≤ ↑a✝
|
3bde688e16503a13
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.reduce_fold_fn_preserves_induction_motive
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.lean
|
theorem reduce_fold_fn_preserves_induction_motive {c_arr : Array (Literal (PosFin n))}
{assignment : Array Assignment}
(idx : Fin c_arr.size) (res : ReduceResult (PosFin n))
(ih : ReducePostconditionInductionMotive c_arr assignment idx.1 res) :
ReducePostconditionInductionMotive c_arr assignment (idx.1 + 1) (reduce_fold_fn assignment res c_arr[idx])
|
case h_3
n : Nat
c_arr : Array (Literal (PosFin n))
assignment : Array Assignment
idx : Fin c_arr.size
p : PosFin n → Bool
acc✝ : ReduceResult (PosFin n)
l : Literal (PosFin n)
ih : ReducePostconditionInductionMotive c_arr assignment (↑idx) (reducedToUnit l)
x✝ : Assignment
heq✝ : assignment[c_arr[↑idx].fst.val]! = both
h : encounteredBoth = reducedToEmpty
⊢ (∀ (i : Fin c_arr.size), ↑i < ↑idx + 1 → ¬(p ⊨ c_arr[↑i])) ∨ ¬(p ⊨ assignment)
|
simp at h
|
no goals
|
681a60500ce41fce
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.