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
|
|---|---|---|---|---|---|---|
Pell.exists_of_not_isSquare
|
Mathlib/NumberTheory/Pell.lean
|
theorem exists_of_not_isSquare (h₀ : 0 < d) (hd : ¬IsSquare d) :
∃ x y : ℤ, x ^ 2 - d * y ^ 2 = 1 ∧ y ≠ 0
|
case intro.intro.intro.intro.intro.intro.intro.intro.refine_1
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
ξ : ℝ := √↑d
hξ : Irrational ξ
M : ℤ
hM₁ : 2 * |ξ| + 1 < ↑M
hM : {q | |q.num ^ 2 - d * ↑q.den ^ 2| < M}.Infinite
m : ℤ
hm : {q | q.num ^ 2 - d * ↑q.den ^ 2 = m}.Infinite
this : NeZero m.natAbs
f : ℚ → ZMod m.natAbs × ZMod m.natAbs := fun q => (↑q.num, ↑q.den)
q₁ : ℚ
h₁ : q₁.num ^ 2 - d * ↑q₁.den ^ 2 = m
q₂ : ℚ
h₂ : q₂.num ^ 2 - d * ↑q₂.den ^ 2 = m
hne : q₁ ≠ q₂
hqf : f q₁ = f q₂
hq1 : ↑q₁.num = ↑q₂.num
hq2 : ↑q₁.den = ↑q₂.den
hd₁ : m ∣ q₁.num * q₂.num - d * (↑q₁.den * ↑q₂.den)
hd₂ : m ∣ q₁.num * ↑q₂.den - q₂.num * ↑q₁.den
hm₀ : ↑m ≠ 0
⊢ ((↑q₁.num * ↑q₂.num - ↑d * (↑q₁.den * ↑q₂.den)) / ↑m) ^ 2 - ↑d * ((↑q₁.num * ↑q₂.den - ↑q₂.num * ↑q₁.den) / ↑m) ^ 2 =
1
|
field_simp [hm₀]
|
case intro.intro.intro.intro.intro.intro.intro.intro.refine_1
d : ℤ
h₀ : 0 < d
hd : ¬IsSquare d
ξ : ℝ := √↑d
hξ : Irrational ξ
M : ℤ
hM₁ : 2 * |ξ| + 1 < ↑M
hM : {q | |q.num ^ 2 - d * ↑q.den ^ 2| < M}.Infinite
m : ℤ
hm : {q | q.num ^ 2 - d * ↑q.den ^ 2 = m}.Infinite
this : NeZero m.natAbs
f : ℚ → ZMod m.natAbs × ZMod m.natAbs := fun q => (↑q.num, ↑q.den)
q₁ : ℚ
h₁ : q₁.num ^ 2 - d * ↑q₁.den ^ 2 = m
q₂ : ℚ
h₂ : q₂.num ^ 2 - d * ↑q₂.den ^ 2 = m
hne : q₁ ≠ q₂
hqf : f q₁ = f q₂
hq1 : ↑q₁.num = ↑q₂.num
hq2 : ↑q₁.den = ↑q₂.den
hd₁ : m ∣ q₁.num * q₂.num - d * (↑q₁.den * ↑q₂.den)
hd₂ : m ∣ q₁.num * ↑q₂.den - q₂.num * ↑q₁.den
hm₀ : ↑m ≠ 0
⊢ (↑q₁.num * ↑q₂.num - ↑d * (↑q₁.den * ↑q₂.den)) ^ 2 - ↑d * (↑q₁.num * ↑q₂.den - ↑q₂.num * ↑q₁.den) ^ 2 = ↑m ^ 2
|
e113d5ba2b34ead4
|
MeasureTheory.integral_norm_eq_pos_sub_neg
|
Mathlib/MeasureTheory/Integral/SetIntegral.lean
|
theorem integral_norm_eq_pos_sub_neg {f : X → ℝ} (hfi : Integrable f μ) :
∫ x, ‖f x‖ ∂μ = ∫ x in {x | 0 ≤ f x}, f x ∂μ - ∫ x in {x | f x ≤ 0}, f x ∂μ :=
have h_meas : NullMeasurableSet {x | 0 ≤ f x} μ :=
aestronglyMeasurable_const.nullMeasurableSet_le hfi.1
calc
∫ x, ‖f x‖ ∂μ = ∫ x in {x | 0 ≤ f x}, ‖f x‖ ∂μ + ∫ x in {x | 0 ≤ f x}ᶜ, ‖f x‖ ∂μ
|
X : Type u_1
mX : MeasurableSpace X
μ : Measure X
f : X → ℝ
hfi : Integrable f μ
h_meas : NullMeasurableSet {x | 0 ≤ f x} μ
⊢ ∫ (x : X) in {x | 0 ≤ f x}, f x ∂μ - ∫ (x : X) in {x | 0 ≤ f x}ᶜ, f x ∂μ =
∫ (x : X) in {x | 0 ≤ f x}, f x ∂μ - ∫ (x : X) in {x | f x ≤ 0}, f x ∂μ
|
rw [← setIntegral_neg_eq_setIntegral_nonpos hfi.1, compl_setOf]
|
X : Type u_1
mX : MeasurableSpace X
μ : Measure X
f : X → ℝ
hfi : Integrable f μ
h_meas : NullMeasurableSet {x | 0 ≤ f x} μ
⊢ ∫ (x : X) in {x | 0 ≤ f x}, f x ∂μ - ∫ (x : X) in {a | ¬0 ≤ f a}, f x ∂μ =
∫ (x : X) in {x | 0 ≤ f x}, f x ∂μ - ∫ (x : X) in {x | f x < 0}, f x ∂μ
|
f2b7c21cff431d30
|
Dioph.DiophList.forall
|
Mathlib/NumberTheory/Dioph.lean
|
theorem DiophList.forall (l : List (Set <| α → ℕ)) (d : l.Forall Dioph) :
Dioph {v | l.Forall fun S : Set (α → ℕ) => v ∈ S}
|
α : Type u
S : Set (α → ℕ)
l : List (Set (α → ℕ))
IH :
List.Forall Dioph l →
∃ β pl, ∀ (v : α → ℕ), List.Forall (fun S => S v) l ↔ ∃ t, List.Forall (fun p => p (v ⊗ t) = 0) pl
d : Dioph S ∧ List.Forall Dioph l
β : Type u
p : Poly (α ⊕ β)
pe : ∀ (v : α → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
dl : List.Forall Dioph l
γ : Type u
pl : List (Poly (α ⊕ γ))
ple : ∀ (v : α → ℕ), List.Forall (fun S => S v) l ↔ ∃ t, List.Forall (fun p => p (v ⊗ t) = 0) pl
v : α → ℕ
x✝ :
∃ t,
p ((v ⊗ t) ∘ (inl ⊗ inr ∘ inl)) = 0 ∧
List.Forall ((fun p => p (v ⊗ t) = 0) ∘ fun q => Poly.map (inl ⊗ inr ∘ inr) q) pl
t : β ⊕ γ → ℕ
hl : p ((v ⊗ t) ∘ (inl ⊗ inr ∘ inl)) = 0
hr : List.Forall ((fun p => p (v ⊗ t) = 0) ∘ fun q => Poly.map (inl ⊗ inr ∘ inr) q) pl
s : α ⊕ β
⊢ ((v ⊗ t) ∘ (inl ⊗ inr ∘ inl)) s = (v ⊗ t ∘ inl) s
|
rcases s with a | b <;> rfl
|
no goals
|
a9cad34cc59a8de2
|
Function.Injective.swap_apply
|
Mathlib/Logic/Equiv/Basic.lean
|
theorem Function.Injective.swap_apply
[DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (x y z : α) :
Equiv.swap (f x) (f y) (f z) = f (Equiv.swap x y z)
|
case pos
α : Sort u_1
β : Sort u_4
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
hx : ¬z = x
hy : z = y
⊢ (Equiv.swap (f x) (f y)) (f z) = f ((Equiv.swap x y) z)
|
simp [hy]
|
no goals
|
5a77f0c1662562ff
|
IsRightRegular.pow_iff
|
Mathlib/Algebra/Regular/Basic.lean
|
/-- An element `a` is right-regular if and only if a positive power of `a` is right-regular. -/
lemma IsRightRegular.pow_iff (n0 : 0 < n) : IsRightRegular (a ^ n) ↔ IsRightRegular a where
mp
|
R : Type u_1
inst✝ : Monoid R
a : R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a ^ n) → IsRightRegular a
|
rw [← Nat.succ_pred_eq_of_pos n0, pow_succ']
|
R : Type u_1
inst✝ : Monoid R
a : R
n : ℕ
n0 : 0 < n
⊢ IsRightRegular (a * a ^ n.pred) → IsRightRegular a
|
056429850e79d74b
|
Algebra.norm_algebraMap
|
Mathlib/RingTheory/Norm/Defs.lean
|
theorem norm_algebraMap {L : Type*} [Ring L] [Algebra K L] (x : K) :
norm K (algebraMap K L x) = x ^ finrank K L
|
case pos
K : Type u_3
inst✝² : Field K
L : Type u_4
inst✝¹ : Ring L
inst✝ : Algebra K L
x : K
H : ∃ s, Nonempty (Basis { x // x ∈ s } K L)
⊢ (norm K) ((algebraMap K L) x) = x ^ finrank K L
|
rw [norm_algebraMap_of_basis H.choose_spec.some, finrank_eq_card_basis H.choose_spec.some]
|
no goals
|
3f209e0d016f1813
|
Std.Tactic.BVDecide.Normalize.BitVec.add_not
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Normalize/BitVec.lean
|
theorem BitVec.add_not (a : BitVec w) : a + ~~~a = (-1#w)
|
case pred
w : Nat
a : BitVec w
i✝ : Nat
a✝ : i✝ < w
⊢ (a + ~~~a).getLsbD i✝ = (-1#w).getLsbD i✝
|
simp [BitVec.negOne_eq_allOnes]
|
no goals
|
b9c543678fe88492
|
hasFDerivAt_integral_of_dominated_loc_of_lip'
|
Mathlib/Analysis/Calculus/ParametricIntegral.lean
|
theorem hasFDerivAt_integral_of_dominated_loc_of_lip' {F' : α → H →L[𝕜] E} (ε_pos : 0 < ε)
(hF_meas : ∀ x ∈ ball x₀ ε, AEStronglyMeasurable (F x) μ) (hF_int : Integrable (F x₀) μ)
(hF'_meas : AEStronglyMeasurable F' μ)
(h_lipsch : ∀ᵐ a ∂μ, ∀ x ∈ ball x₀ ε, ‖F x a - F x₀ a‖ ≤ bound a * ‖x - x₀‖)
(bound_integrable : Integrable (bound : α → ℝ) μ)
(h_diff : ∀ᵐ a ∂μ, HasFDerivAt (F · a) (F' a) x₀) :
Integrable F' μ ∧ HasFDerivAt (fun x ↦ ∫ a, F x a ∂μ) (∫ a, F' a ∂μ) x₀
|
α : Type u_1
inst✝⁶ : MeasurableSpace α
μ : Measure α
𝕜 : Type u_2
inst✝⁵ : RCLike 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedSpace 𝕜 E
H : Type u_4
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
F : H → α → E
x₀ : H
bound : α → ℝ
ε : ℝ
F' : α → H →L[𝕜] E
ε_pos : 0 < ε
hF_meas : ∀ x ∈ ball x₀ ε, AEStronglyMeasurable (F x) μ
hF_int : Integrable (F x₀) μ
hF'_meas : AEStronglyMeasurable F' μ
bound_integrable : Integrable bound μ
h_diff : ∀ᵐ (a : α) ∂μ, HasFDerivAt (fun x => F x a) (F' a) x₀
x₀_in : x₀ ∈ ball x₀ ε
nneg : ∀ (x : H), 0 ≤ ‖x - x₀‖⁻¹
b : α → ℝ := fun a => |bound a|
b_int : Integrable b μ
b_nonneg : ∀ (a : α), 0 ≤ b a
h_lipsch : ∀ᵐ (a : α) ∂μ, ∀ x ∈ ball x₀ ε, ‖F x a - F x₀ a‖ ≤ b a * ‖x - x₀‖
x : H
x_in : x ∈ ball x₀ ε
⊢ ∀ᵐ (a : α) ∂μ, ‖F x₀ a - F x a‖ ≤ ε * b a
|
simp only [norm_sub_rev (F x₀ _)]
|
α : Type u_1
inst✝⁶ : MeasurableSpace α
μ : Measure α
𝕜 : Type u_2
inst✝⁵ : RCLike 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedSpace 𝕜 E
H : Type u_4
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
F : H → α → E
x₀ : H
bound : α → ℝ
ε : ℝ
F' : α → H →L[𝕜] E
ε_pos : 0 < ε
hF_meas : ∀ x ∈ ball x₀ ε, AEStronglyMeasurable (F x) μ
hF_int : Integrable (F x₀) μ
hF'_meas : AEStronglyMeasurable F' μ
bound_integrable : Integrable bound μ
h_diff : ∀ᵐ (a : α) ∂μ, HasFDerivAt (fun x => F x a) (F' a) x₀
x₀_in : x₀ ∈ ball x₀ ε
nneg : ∀ (x : H), 0 ≤ ‖x - x₀‖⁻¹
b : α → ℝ := fun a => |bound a|
b_int : Integrable b μ
b_nonneg : ∀ (a : α), 0 ≤ b a
h_lipsch : ∀ᵐ (a : α) ∂μ, ∀ x ∈ ball x₀ ε, ‖F x a - F x₀ a‖ ≤ b a * ‖x - x₀‖
x : H
x_in : x ∈ ball x₀ ε
⊢ ∀ᵐ (a : α) ∂μ, ‖F x a - F x₀ a‖ ≤ ε * b a
|
a8f4bcb6e23b7fde
|
Set.iUnionLift_unary
|
Mathlib/Data/Set/UnionLift.lean
|
theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
(hui :
∀ (i) (x : S i),
u (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) x) =
Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) (ui i x))
(uβ : β → β) (h : ∀ (i) (x : S i), f i (ui i x) = uβ (f i x)) (x : T) :
iUnionLift S f hf T (le_of_eq hT') (u x) = uβ (iUnionLift S f hf T (le_of_eq hT') x)
|
α : Type u_1
ι : Sort u_2
β : Sort u_3
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
ui : (i : ι) → ↑(S i) → ↑(S i)
uβ : β → β
h : ∀ (i : ι) (x : ↑(S i)), f i (ui i x) = uβ (f i x)
u : ↑(iUnion S) → ↑(iUnion S)
hui : ∀ (i : ι) (x : ↑(S i)), u (inclusion ⋯ x) = inclusion ⋯ (ui i x)
x : ↑(iUnion S)
i : ι
hi : ↑x ∈ S i
⊢ x = inclusion ⋯ ⟨↑x, hi⟩
|
cases x
|
case mk
α : Type u_1
ι : Sort u_2
β : Sort u_3
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
ui : (i : ι) → ↑(S i) → ↑(S i)
uβ : β → β
h : ∀ (i : ι) (x : ↑(S i)), f i (ui i x) = uβ (f i x)
u : ↑(iUnion S) → ↑(iUnion S)
hui : ∀ (i : ι) (x : ↑(S i)), u (inclusion ⋯ x) = inclusion ⋯ (ui i x)
i : ι
val✝ : α
property✝ : val✝ ∈ iUnion S
hi : ↑⟨val✝, property✝⟩ ∈ S i
⊢ ⟨val✝, property✝⟩ = inclusion ⋯ ⟨↑⟨val✝, property✝⟩, hi⟩
|
8bebe07162d0a4b8
|
Matrix.proj_comp_diagLinearMap
|
Mathlib/Data/Matrix/Basic.lean
|
@[simp] lemma proj_comp_diagLinearMap (i : m) :
LinearMap.proj i ∘ₗ diagLinearMap m R α = entryLinearMap R α i i
|
m : Type u_2
R : Type u_7
α : Type v
inst✝² : Semiring R
inst✝¹ : AddCommMonoid α
inst✝ : Module R α
i : m
⊢ LinearMap.proj i ∘ₗ diagLinearMap m R α = entryLinearMap R α i i
|
simp [LinearMap.ext_iff]
|
no goals
|
c5dcd6fc14c46d62
|
Fintype.card_lt_of_injective_of_not_mem
|
Mathlib/Data/Fintype/Card.lean
|
theorem card_lt_of_injective_of_not_mem (f : α → β) (h : Function.Injective f) {b : β}
(w : b ∉ Set.range f) : card α < card β :=
calc
card α = (univ.map ⟨f, h⟩).card := (card_map _).symm
_ < card β :=
Finset.card_lt_univ_of_not_mem (x := b) <| by
rwa [← mem_coe, coe_map, coe_univ, Set.image_univ]
|
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : α → β
h : Injective f
b : β
w : b ∉ Set.range f
⊢ b ∉ map { toFun := f, inj' := h } univ
|
rwa [← mem_coe, coe_map, coe_univ, Set.image_univ]
|
no goals
|
e18650c5b90d203a
|
Vector.mapFinIdx_eq_ofFn
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/MapIdx.lean
|
theorem mapFinIdx_eq_ofFn {as : Vector α n} {f : (i : Nat) → α → (h : i < n) → β} :
as.mapFinIdx f = Vector.ofFn fun i : Fin n => f i as[i] i.2
|
α : Type u_1
n : Nat
β : Type u_2
as : Vector α n
f : (i : Nat) → α → i < n → β
⊢ as.mapFinIdx f = ofFn fun i => f (↑i) as[i] ⋯
|
rcases as with ⟨as, rfl⟩
|
case mk
α : Type u_1
β : Type u_2
as : Array α
f : (i : Nat) → α → i < as.size → β
⊢ { toArray := as, size_toArray := ⋯ }.mapFinIdx f = ofFn fun i => f ↑i { toArray := as, size_toArray := ⋯ }[i] ⋯
|
933ba1cd9752d8b1
|
ZetaAsymptotics.tendsto_riemannZeta_sub_one_div_nhds_right
|
Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean
|
/-- First version of the limit formula, with a limit over real numbers tending to 1 from above. -/
lemma tendsto_riemannZeta_sub_one_div_nhds_right :
Tendsto (fun s : ℝ ↦ riemannZeta s - 1 / (s - 1)) (𝓝[>] 1) (𝓝 γ)
|
aux2 : Tendsto (fun s => ∑' (n : ℕ), 1 / (↑n + 1) ^ s - 1 / (s - 1)) (𝓝[>] 1) (𝓝 (1 - term_tsum 1))
this : ∑' (b : ℕ), term (b + 1) 1 = 1 - γ
⊢ Tendsto (fun s => ∑' (n : ℕ), 1 / (↑n + 1) ^ s - 1 / (s - 1)) (𝓝[>] 1) (𝓝 γ)
|
rw [← term_tsum, eq_sub_iff_add_eq, ← eq_sub_iff_add_eq'] at this
|
aux2 : Tendsto (fun s => ∑' (n : ℕ), 1 / (↑n + 1) ^ s - 1 / (s - 1)) (𝓝[>] 1) (𝓝 (1 - term_tsum 1))
this : γ = 1 - term_tsum 1
⊢ Tendsto (fun s => ∑' (n : ℕ), 1 / (↑n + 1) ^ s - 1 / (s - 1)) (𝓝[>] 1) (𝓝 γ)
|
ceaf7d9b7ead9630
|
CoxeterSystem.prod_leftInvSeq
|
Mathlib/GroupTheory/Coxeter/Inversion.lean
|
theorem prod_leftInvSeq (ω : List B) : prod (lis ω) = (π ω)⁻¹
|
case h
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ ∀ a ∈ cs.rightInvSeq ω.reverse, a⁻¹ = id a
|
intro t ht
|
case h
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
t : W
ht : t ∈ cs.rightInvSeq ω.reverse
⊢ t⁻¹ = id t
|
761854a10de60b7d
|
HomologicalComplex.cycles_left_exact
|
Mathlib/Algebra/Homology/HomologySequence.lean
|
/-- If `0 ⟶ X₁ ⟶ X₂ ⟶ X₃` is an exact sequence of homological complex, then
`0 ⟶ X₁.cycles i ⟶ X₂.cycles i ⟶ X₃.cycles i` is exact. This lemma states
the exactness at `X₂.cycles i`, while the fact that `X₁.cycles i ⟶ X₂.cycles i`
is a mono is an instance. -/
lemma cycles_left_exact (S : ShortComplex (HomologicalComplex C c)) (hS : S.Exact) [Mono S.f]
(i : ι) [S.X₁.HasHomology i] [S.X₂.HasHomology i] [S.X₃.HasHomology i] :
(ShortComplex.mk (cyclesMap S.f i) (cyclesMap S.g i)
(by rw [← cyclesMap_comp, S.zero, cyclesMap_zero])).Exact
|
C : Type u_1
ι : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Abelian C
c : ComplexShape ι
S : ShortComplex (HomologicalComplex C c)
hS : S.Exact
inst✝³ : Mono S.f
i : ι
inst✝² : S.X₁.HasHomology i
inst✝¹ : S.X₂.HasHomology i
inst✝ : S.X₃.HasHomology i
this : Mono (S.map (eval C c i)).f
hi : IsLimit (KernelFork.ofι (S.map (eval C c i)).f ⋯)
A : C
k : A ⟶ (ShortComplex.mk (cyclesMap S.f i) (cyclesMap S.g i) ⋯).X₂
hk : k ≫ (ShortComplex.mk (cyclesMap S.f i) (cyclesMap S.g i) ⋯).g = 0
⊢ { l // l ≫ (ShortComplex.mk (cyclesMap S.f i) (cyclesMap S.g i) ⋯).f = k }
|
dsimp at k hk ⊢
|
C : Type u_1
ι : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Abelian C
c : ComplexShape ι
S : ShortComplex (HomologicalComplex C c)
hS : S.Exact
inst✝³ : Mono S.f
i : ι
inst✝² : S.X₁.HasHomology i
inst✝¹ : S.X₂.HasHomology i
inst✝ : S.X₃.HasHomology i
this : Mono (S.map (eval C c i)).f
hi : IsLimit (KernelFork.ofι (S.map (eval C c i)).f ⋯)
A : C
k : A ⟶ S.X₂.cycles i
hk : k ≫ cyclesMap S.g i = 0
⊢ { l // l ≫ cyclesMap S.f i = k }
|
bd33f56af82f3219
|
IntervalIntegrable.comp_mul_left
|
Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
|
theorem comp_mul_left (hf : IntervalIntegrable f volume a b) (c : ℝ) :
IntervalIntegrable (fun x => f (c * x)) volume (a / c) (b / c)
|
case h.e'_6
E : Type u_3
inst✝ : NormedAddCommGroup E
f : ℝ → E
a b : ℝ
hf : IntegrableOn f [[a, b]] volume
c : ℝ
hc : c ≠ 0
A : MeasurableEmbedding fun x => x * c⁻¹
⊢ ((fun x => f (c * x)) ∘ fun x => x * c⁻¹) = f
|
ext
|
case h.e'_6.h
E : Type u_3
inst✝ : NormedAddCommGroup E
f : ℝ → E
a b : ℝ
hf : IntegrableOn f [[a, b]] volume
c : ℝ
hc : c ≠ 0
A : MeasurableEmbedding fun x => x * c⁻¹
x✝ : ℝ
⊢ ((fun x => f (c * x)) ∘ fun x => x * c⁻¹) x✝ = f x✝
|
9cd6ab038c92d131
|
EuclideanDomain.divRadical_ne_zero
|
Mathlib/RingTheory/Radical.lean
|
theorem divRadical_ne_zero {a : E} (ha : a ≠ 0) : divRadical a ≠ 0
|
E : Type u_1
inst✝² : EuclideanDomain E
inst✝¹ : NormalizationMonoid E
inst✝ : UniqueFactorizationMonoid E
a : E
ha : a ≠ 0
⊢ divRadical a ≠ 0
|
rw [← radical_mul_divRadical a] at ha
|
E : Type u_1
inst✝² : EuclideanDomain E
inst✝¹ : NormalizationMonoid E
inst✝ : UniqueFactorizationMonoid E
a : E
ha : radical a * divRadical a ≠ 0
⊢ divRadical a ≠ 0
|
eb7a079e52705035
|
CompleteLattice.ωScottContinuous.bot
|
Mathlib/Order/OmegaCompletePartialOrder.lean
|
lemma ωScottContinuous.bot : ωScottContinuous (⊥ : α → β)
|
α : Type u_2
β : Type u_3
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ ωScottContinuous ⊥
|
rw [← sSup_empty]
|
α : Type u_2
β : Type u_3
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ ωScottContinuous (SupSet.sSup ∅)
|
05f864cd5a6804ed
|
mem_affineSpan_iff_eq_weightedVSubOfPoint_vadd
|
Mathlib/LinearAlgebra/AffineSpace/Combination.lean
|
theorem mem_affineSpan_iff_eq_weightedVSubOfPoint_vadd [Nontrivial k] (p : ι → P) (j : ι) (q : P) :
q ∈ affineSpan k (Set.range p) ↔
∃ (s : Finset ι) (w : ι → k), q = s.weightedVSubOfPoint p (p j) w +ᵥ p j
|
case mpr.intro.intro
ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
p : ι → P
j : ι
s : Finset ι
w : ι → k
w' : ι → k := Function.update w j (1 - (s \ {j}).sum w)
h₁ : (insert j s).sum w' = 1
hww : ∀ (i : ι), i ≠ j → w i = w' i
⊢ (Finset.affineCombination k (insert j s) p) w' ∈ affineSpan k (Set.range p)
|
exact affineCombination_mem_affineSpan h₁ p
|
no goals
|
40a3291069dee08b
|
MeasureTheory.Measure.snd_map_swap
|
Mathlib/MeasureTheory/Measure/Prod.lean
|
@[simp] lemma snd_map_swap : (ρ.map Prod.swap).snd = ρ.fst
|
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
ρ : Measure (α × β)
⊢ map (Prod.snd ∘ Prod.swap) ρ = ρ.fst
|
rfl
|
no goals
|
1a31f8bcea60747e
|
MvPolynomial.totalDegree_list_prod
|
Mathlib/Algebra/MvPolynomial/Degrees.lean
|
theorem totalDegree_list_prod :
∀ s : List (MvPolynomial σ R), s.prod.totalDegree ≤ (s.map MvPolynomial.totalDegree).sum
| [] => by rw [List.prod_nil, totalDegree_one, List.map_nil, List.sum_nil]
| p::ps => by
rw [List.prod_cons, List.map, List.sum_cons]
exact le_trans (totalDegree_mul _ _) (add_le_add_left (totalDegree_list_prod ps) _)
|
R : Type u
σ : Type u_1
inst✝ : CommSemiring R
p : MvPolynomial σ R
ps : List (MvPolynomial σ R)
⊢ (p * ps.prod).totalDegree ≤ p.totalDegree + (List.map totalDegree ps).sum
|
exact le_trans (totalDegree_mul _ _) (add_le_add_left (totalDegree_list_prod ps) _)
|
no goals
|
78300a0977ad5ffe
|
CategoryTheory.mono_iff_isIso_fst
|
Mathlib/CategoryTheory/Limits/EpiMono.lean
|
lemma mono_iff_isIso_fst (hc : IsLimit c) : Mono f ↔ IsIso c.fst
|
case mpr.mk.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PullbackCone f f
hc : IsLimit c
a✝ : IsIso c.fst
φ : X ⟶ c.pt
hφ₁ : φ ≫ c.fst = 𝟙 X
hφ₂ : φ ≫ c.snd = 𝟙 X
this : IsSplitEpi φ
⊢ c.fst = c.snd
|
rw [← cancel_epi φ, hφ₁, hφ₂]
|
no goals
|
1598d09ec371f088
|
FractionalIdeal.count_well_defined
|
Mathlib/RingTheory/DedekindDomain/Factorization.lean
|
theorem count_well_defined {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R}
{J : Ideal R} (h_aJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) :
count K v I = ((Associates.mk v.asIdeal).count (Associates.mk J).factors -
(Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors : ℤ)
|
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
hI : I ≠ 0
a : R
J : Ideal R
h_aJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J
⊢ count K v I =
↑((Associates.mk v.asIdeal).count (Associates.mk J).factors) -
↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors)
|
set a₁ := choose (exists_eq_spanSingleton_mul I)
|
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
hI : I ≠ 0
a : R
J : Ideal R
h_aJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J
a₁ : R := choose ⋯
⊢ count K v I =
↑((Associates.mk v.asIdeal).count (Associates.mk J).factors) -
↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors)
|
59f81f9cebadacb0
|
isLocalStructomorphOn_contDiffGroupoid_iff
|
Mathlib/Geometry/Manifold/ContMDiff/Atlas.lean
|
theorem isLocalStructomorphOn_contDiffGroupoid_iff (f : PartialHomeomorph M M') :
LiftPropOn (contDiffGroupoid n I).IsLocalStructomorphWithinAt f f.source ↔
ContMDiffOn I I n f f.source ∧ ContMDiffOn I I n f.symm f.target
|
𝕜 : 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
n : WithTop ℕ∞
inst✝² : IsManifold I n M
M' : Type u_5
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H M'
IsM' : IsManifold I n M'
f : PartialHomeomorph M M'
h : LiftPropOn (contDiffGroupoid n I).IsLocalStructomorphWithinAt (↑f) f.source
X : M'
hX : X ∈ f.symm.source
x : M := ↑f.symm X
hx : x ∈ f.source
c : PartialHomeomorph M H := chartAt H x
c' : PartialHomeomorph M' H := chartAt H X
hxf :
(contDiffGroupoid n I).IsLocalStructomorphWithinAt (↑(chartAt H (↑f x)) ∘ ↑f ∘ ↑(chartAt H x).symm)
(↑(chartAt H x).symm ⁻¹' f.source) (↑(chartAt H x) x)
h2x : ↑(chartAt H X) X ∈ ↑(chartAt H X).symm ⁻¹' f.symm.source
e : PartialHomeomorph H H
he : e ∈ contDiffGroupoid n I
h2e : e.source ⊆ (c.symm ≫ₕ f ≫ₕ c').source
hef : EqOn (↑c' ∘ ↑f ∘ ↑c.symm) (↑e) e.source
hex : ↑c x ∈ e.source
⊢ ↑c' X = (↑c' ∘ ↑f ∘ ↑c.symm) (↑c x)
|
dsimp only [Function.comp_def]
|
𝕜 : 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
n : WithTop ℕ∞
inst✝² : IsManifold I n M
M' : Type u_5
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H M'
IsM' : IsManifold I n M'
f : PartialHomeomorph M M'
h : LiftPropOn (contDiffGroupoid n I).IsLocalStructomorphWithinAt (↑f) f.source
X : M'
hX : X ∈ f.symm.source
x : M := ↑f.symm X
hx : x ∈ f.source
c : PartialHomeomorph M H := chartAt H x
c' : PartialHomeomorph M' H := chartAt H X
hxf :
(contDiffGroupoid n I).IsLocalStructomorphWithinAt (↑(chartAt H (↑f x)) ∘ ↑f ∘ ↑(chartAt H x).symm)
(↑(chartAt H x).symm ⁻¹' f.source) (↑(chartAt H x) x)
h2x : ↑(chartAt H X) X ∈ ↑(chartAt H X).symm ⁻¹' f.symm.source
e : PartialHomeomorph H H
he : e ∈ contDiffGroupoid n I
h2e : e.source ⊆ (c.symm ≫ₕ f ≫ₕ c').source
hef : EqOn (↑c' ∘ ↑f ∘ ↑c.symm) (↑e) e.source
hex : ↑c x ∈ e.source
⊢ ↑c' X = ↑c' (↑f (↑c.symm (↑c x)))
|
52ce8090c899c270
|
Real.Gamma_ne_zero
|
Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
|
theorem Gamma_ne_zero {s : ℝ} (hs : ∀ m : ℕ, s ≠ -m) : Gamma s ≠ 0
|
case a
n✝ : ℕ
n_ih : ∀ {s : ℝ}, (∀ (m : ℕ), s ≠ -↑m) → -↑n✝ < s → Gamma s ≠ 0
s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
hs' : -↑n✝ + -1 < s
⊢ -↑n✝ < s + 1
|
linarith
|
no goals
|
b27fef48da598597
|
Matroid.IsCircuit.closure_diff_singleton_eq
|
Mathlib/Data/Matroid/Circuit.lean
|
lemma IsCircuit.closure_diff_singleton_eq (hC : M.IsCircuit C) (e : α) :
M.closure (C \ {e}) = M.closure C :=
(em (e ∈ C)).elim
(fun he ↦ by rw [(hC.diff_singleton_isBasis he).closure_eq_closure])
(fun he ↦ by rw [diff_singleton_eq_self he])
|
α : Type u_1
M : Matroid α
C : Set α
hC : M.IsCircuit C
e : α
he : e ∉ C
⊢ M.closure (C \ {e}) = M.closure C
|
rw [diff_singleton_eq_self he]
|
no goals
|
ec6cad5f47f1b6a7
|
LieModule.coe_lowerCentralSeries_ideal_le
|
Mathlib/Algebra/Lie/Nilpotent.lean
|
theorem LieModule.coe_lowerCentralSeries_ideal_le {I : LieIdeal R L} (k : ℕ) :
LieSubmodule.toSubmodule (lowerCentralSeries R I I k) ≤ lowerCentralSeries R L I k
|
case succ.h
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
I : LieIdeal R L
k : ℕ
ih : ↑(lowerCentralSeries R (↥I) (↥I) k) ≤ ↑(lowerCentralSeries R L (↥I) k)
⊢ {x | ∃ x_1 n, ⁅↑x_1, ↑n⁆ = x} ⊆ {x | ∃ x_1 n, ⁅↑x_1, ↑n⁆ = x}
|
rintro x ⟨⟨y, -⟩, ⟨z, hz⟩, rfl : ⁅y, z⁆ = x⟩
|
case succ.h.intro.mk.intro.mk
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
I : LieIdeal R L
k : ℕ
ih : ↑(lowerCentralSeries R (↥I) (↥I) k) ≤ ↑(lowerCentralSeries R L (↥I) k)
y z : ↥I
hz : z ∈ lowerCentralSeries R (↥I) (↥I) k
⊢ ⁅y, z⁆ ∈ {x | ∃ x_1 n, ⁅↑x_1, ↑n⁆ = x}
|
e5e433f33f1be4b1
|
faaDiBruno_aux2
|
Mathlib/Analysis/Calculus/ContDiff/FaaDiBruno.lean
|
/-- Composing a formal multilinear series with an ordered partition extended by adding a left point
to an already existing atom of index `i` corresponds to updating the `i`th block,
using `p (c.partSize i + 1)` instead of `p (c.partSize i)` there.
This is one of the terms that appears when differentiating in the Faa di Bruno
formula, going from step `m` to step `m + 1`. -/
private lemma faaDiBruno_aux2 {m : ℕ} (q : FormalMultilinearSeries 𝕜 F G)
(p : FormalMultilinearSeries 𝕜 E F) (c : OrderedFinpartition m) (i : Fin c.length) :
(q.compAlongOrderedFinpartition p (c.extend (some i))).curryLeft =
((c.compAlongOrderedFinpartitionL 𝕜 E F G (q c.length)).toContinuousLinearMap
(fun i ↦ p (c.partSize i)) i).comp (p (c.partSize i + 1)).curryLeft
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
m : ℕ
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
c : OrderedFinpartition m
e : E
v : Fin m → E
j : Fin c.length
a✝ a : ℕ
ha : a + 1 < update c.partSize j (c.partSize j + 1) j
h'a : a + 1 < c.partSize j + 1
⊢ (cons e v ∘ (fun i => cases 0 (succ ∘ c.emb j) i) ∘ Fin.cast ⋯) ⟨a + 1, ha⟩ = cons e (v ∘ c.emb j) ⟨a + 1, h'a⟩
|
simp [cons]
|
no goals
|
0043cf301ba04e46
|
OrderedFinpartition.range_emb_extendMiddle_ne_singleton_zero
|
Mathlib/Analysis/Calculus/ContDiff/FaaDiBruno.lean
|
lemma range_emb_extendMiddle_ne_singleton_zero (c : OrderedFinpartition n) (i j : Fin c.length) :
range ((c.extendMiddle i).emb j) ≠ {0}
|
case inl
n : ℕ
c : OrderedFinpartition n
j : Fin c.length
h : range ((c.extendMiddle j).emb j) = {0}
⊢ False
|
have : Fin.succ (c.emb j 0) ∈ ({0} : Set (Fin n.succ)) := by
rw [← h]
simp only [Nat.succ_eq_add_one, mem_range]
have A : (c.extendMiddle j).partSize j = c.partSize j + 1 := by simp [extendMiddle]
refine ⟨Fin.cast A.symm (succ 0), ?_⟩
simp only [extendMiddle, ↓reduceDIte, comp_apply, cast_trans, cast_eq_self, cases_succ]
|
case inl
n : ℕ
c : OrderedFinpartition n
j : Fin c.length
h : range ((c.extendMiddle j).emb j) = {0}
this : (c.emb j 0).succ ∈ {0}
⊢ False
|
e99d02d12c396e6f
|
Stream'.Seq.mem_rec_on
|
Mathlib/Data/Seq/Seq.lean
|
theorem mem_rec_on {C : Seq α → Prop} {a s} (M : a ∈ s)
(h1 : ∀ b s', a = b ∨ C s' → C (cons b s')) : C s
|
case intro.succ
α : Type u
C : Seq α → Prop
a : α
h1 : ∀ (b : α) (s' : Seq α), a = b ∨ C s' → C (cons b s')
k : ℕ
IH : ∀ {s : Seq α}, some a = ↑s k → C s
s : Seq α
e : some a = ↑s (k + 1)
⊢ C s
|
cases s with
| nil => injection e
| cons b s' =>
have h_eq : (cons b s').val (Nat.succ k) = s'.val k := by cases s' using Subtype.recOn; rfl
rw [h_eq] at e
apply h1 _ _ (Or.inr (IH e))
|
no goals
|
6a5946c9fe3560f9
|
ContinuousMap.Homotopy.trans_apply
|
Mathlib/Topology/Homotopy/Basic.lean
|
theorem trans_apply {f₀ f₁ f₂ : C(X, Y)} (F : Homotopy f₀ f₁) (G : Homotopy f₁ f₂) (x : I × X) :
(F.trans G) x =
if h : (x.1 : ℝ) ≤ 1 / 2 then
F (⟨2 * x.1, (unitInterval.mul_pos_mem_iff zero_lt_two).2 ⟨x.1.2.1, h⟩⟩, x.2)
else
G (⟨2 * x.1 - 1, unitInterval.two_mul_sub_one_mem_iff.2 ⟨(not_le.1 h).le, x.1.2.2⟩⟩, x.2) :=
show ite _ _ _ = _ by
split_ifs <;>
· rw [extend, ContinuousMap.coe_IccExtend, Set.IccExtend_of_mem]
rfl
|
case neg
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f₀ f₁ f₂ : C(X, Y)
F : f₀.Homotopy f₁
G : f₁.Homotopy f₂
x : ↑I × X
h✝ : ¬↑x.1 ≤ 1 / 2
⊢ (G.curry ⟨2 * ↑x.1 - 1, ?neg.hx✝⟩) x.2 = G (⟨2 * ↑x.1 - 1, ⋯⟩, x.2)
case neg.hx
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f₀ f₁ f₂ : C(X, Y)
F : f₀.Homotopy f₁
G : f₁.Homotopy f₂
x : ↑I × X
h✝ : ¬↑x.1 ≤ 1 / 2
⊢ 2 * ↑x.1 - 1 ∈ Set.Icc 0 1
|
rfl
|
no goals
|
97c86c1acd08df78
|
Nat.max_min_distrib_left
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
|
theorem max_min_distrib_left : ∀ (a b c : Nat), max a (min b c) = min (max a b) (max a c)
| 0, _, _ => by simp only [Nat.zero_max]
| _, 0, _ => by
rw [Nat.zero_min, Nat.max_zero]
exact Nat.min_eq_left (Nat.le_max_left ..) |>.symm
| _, _, 0 => by
rw [Nat.min_zero, Nat.max_zero]
exact Nat.min_eq_right (Nat.le_max_left ..) |>.symm
| _+1, _+1, _+1 => by
simp only [Nat.succ_max_succ, Nat.succ_min_succ]
exact congrArg succ <| Nat.max_min_distrib_left ..
|
n✝² n✝¹ n✝ : Nat
⊢ max (n✝² + 1) (min (n✝¹ + 1) (n✝ + 1)) = min (max (n✝² + 1) (n✝¹ + 1)) (max (n✝² + 1) (n✝ + 1))
|
simp only [Nat.succ_max_succ, Nat.succ_min_succ]
|
n✝² n✝¹ n✝ : Nat
⊢ (max n✝² (min n✝¹ n✝)).succ = (min (max n✝² n✝¹) (max n✝² n✝)).succ
|
5babdaa82bb6e3ee
|
List.foldr_filter
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
|
theorem foldr_filter (p : α → Bool) (f : α → β → β) (l : List α) (init : β) :
(l.filter p).foldr f init = l.foldr (fun x y => if p x then f x y else y) init
|
case cons
α : Type u_1
β : Type u_2
p : α → Bool
f : α → β → β
a : α
l : List α
ih : ∀ (init : β), foldr f init (filter p l) = foldr (fun x y => if p x = true then f x y else y) init l
init : β
⊢ foldr f init (if p a = true then a :: filter p l else filter p l) =
if p a = true then f a (foldr (fun x y => if p x = true then f x y else y) init l)
else foldr (fun x y => if p x = true then f x y else y) init l
|
split <;> simp [ih]
|
no goals
|
643547fd2eee8a3a
|
Cardinal.mk_of_countable_eventually_mem
|
Mathlib/SetTheory/Cardinal/CountableCover.lean
|
/-- If a space is eventually covered by a countable family of sets, all with cardinality `a`,
then the cardinality of the space is also `a`. -/
lemma mk_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
[Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l] (ht : ∀ x, ∀ᶠ i in l, x ∈ f i)
(h'f : ∀ i, #(f i) = a) : #α = a
|
case a.intro
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : l.NeBot
ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) = a
i : ι
⊢ #↑(f i) ≤ #α
|
exact mk_set_le (f i)
|
no goals
|
d9e0f5ddad582230
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go_denote_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.lean
|
theorem go_denote_eq {w : Nat} (aig : AIG BVBit) (curr : Nat) (hcurr : curr + 1 ≤ w)
(acc : AIG.RefVec aig w) (lhs rhs : AIG.RefVec aig w) (lexpr rexpr : BitVec w) (assign : Assignment)
(hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, lhs.get idx hidx, assign.toAIGAssignment⟧ = lexpr.getLsbD idx)
(hright : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, rhs.get idx hidx, assign.toAIGAssignment⟧ = rexpr.getLsbD idx)
(hacc : ∀ (idx : Nat) (hidx : idx < w),
⟦aig, acc.get idx hidx, assign.toAIGAssignment⟧
=
(BitVec.mulRec lexpr rexpr curr).getLsbD idx) :
∀ (idx : Nat) (hidx : idx < w),
⟦
(go aig lhs rhs (curr + 1) acc).aig,
(go aig lhs rhs (curr + 1) acc).vec.get idx hidx,
assign.toAIGAssignment
⟧
=
(BitVec.mulRec lexpr rexpr w).getLsbD idx
|
case hright.isFalse
w : Nat
aig : AIG BVBit
curr : Nat
hcurr : curr + 1 ≤ w
acc lhs rhs : aig.RefVec w
lexpr rexpr : BitVec w
assign : Assignment
hleft :
∀ (idx : Nat) (hidx : idx < w), ⟦assign.toAIGAssignment, { aig := aig, ref := lhs.get idx hidx }⟧ = lexpr.getLsbD idx
hright :
∀ (idx : Nat) (hidx : idx < w), ⟦assign.toAIGAssignment, { aig := aig, ref := rhs.get idx hidx }⟧ = rexpr.getLsbD idx
hacc :
∀ (idx : Nat) (hidx : idx < w),
⟦assign.toAIGAssignment, { aig := aig, ref := acc.get idx hidx }⟧ = (lexpr.mulRec rexpr curr).getLsbD idx
idx✝¹ : Nat
hidx✝¹ : idx✝¹ < w
res : RefVecEntry BVBit w
h✝² : curr + 1 < w
h✝¹ : ¬aig.isConstant (rhs.get (curr + 1) h✝²) false = true
hgo :
go
(RefVec.ite
(blastAdd (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).aig
{ lhs := acc.cast ⋯, rhs := (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).vec }).aig
{ discr := ((rhs.cast ⋯).cast ⋯).get (curr + 1) h✝²,
lhs :=
(blastAdd (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).aig
{ lhs := acc.cast ⋯, rhs := (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).vec }).vec,
rhs := (acc.cast ⋯).cast ⋯ }).aig
(((lhs.cast ⋯).cast ⋯).cast ⋯) (((rhs.cast ⋯).cast ⋯).cast ⋯) (curr + 1 + 1)
(RefVec.ite
(blastAdd (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).aig
{ lhs := acc.cast ⋯, rhs := (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).vec }).aig
{ discr := ((rhs.cast ⋯).cast ⋯).get (curr + 1) h✝²,
lhs :=
(blastAdd (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).aig
{ lhs := acc.cast ⋯, rhs := (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).vec }).vec,
rhs := (acc.cast ⋯).cast ⋯ }).vec =
res
idx : Nat
hidx : idx < w
hdiscr :
⟦assign.toAIGAssignment,
{
aig :=
(blastAdd (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).aig
{ lhs := acc.cast ⋯, rhs := (blastShiftLeftConst aig { vec := lhs, distance := curr + 1 }).vec }).aig,
ref := { gate := (rhs.get (curr + 1) h✝²).gate, hgate := ⋯ } }⟧ =
true
this : rexpr.getLsbD (curr + 1) = true
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : ¬idx✝ < curr + 1
⊢ ⟦assign.toAIGAssignment, { aig := aig, ref := lhs.get (idx✝ - (curr + 1)) ⋯ }⟧ =
(decide (idx✝ < w) && !decide (idx✝ < curr + 1) && lexpr.getLsbD (idx✝ - (curr + 1)))
|
next hidx hdiscr =>
rw [hleft]
simp [hdiscr, hidx]
|
no goals
|
45666f07d8b1c2e0
|
Std.Tactic.BVDecide.Normalize.BitVec.zero_ult'
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Normalize/BitVec.lean
|
theorem BitVec.zero_ult' (a : BitVec w) : (BitVec.ult 0#w a) = (!a == 0#w)
|
w : Nat
a : BitVec w
this : (0#w).ult a = true ↔ a ≠ 0#w
h : (0#w).ult a = false
⊢ false = !a == 0#w
|
simp_all
|
no goals
|
c4d8492ddce2ea3b
|
List.prod_hom
|
Mathlib/Algebra/BigOperators/Group/List/Basic.lean
|
theorem prod_hom (l : List M) {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) :
(l.map f).prod = f l.prod
|
M : Type u_4
N : Type u_5
inst✝³ : Monoid M
inst✝² : Monoid N
l : List M
F : Type u_8
inst✝¹ : FunLike F M N
inst✝ : MonoidHomClass F M N
f : F
⊢ (map (⇑f) l).prod = f l.prod
|
simp only [prod, foldr_map, ← map_one f]
|
M : Type u_4
N : Type u_5
inst✝³ : Monoid M
inst✝² : Monoid N
l : List M
F : Type u_8
inst✝¹ : FunLike F M N
inst✝ : MonoidHomClass F M N
f : F
⊢ foldr (fun x y => f x * y) (f 1) l = f (foldr (fun x1 x2 => x1 * x2) 1 l)
|
590c41e34fac98c3
|
PicardLindelof.FunSpace.dist_next_apply_le_of_le
|
Mathlib/Analysis/ODE/PicardLindelof.lean
|
theorem dist_next_apply_le_of_le {f₁ f₂ : FunSpace v} {n : ℕ} {d : ℝ}
(h : ∀ t, dist (f₁ t) (f₂ t) ≤ (v.L * |t.1 - v.t₀|) ^ n / n ! * d) (t : Icc v.tMin v.tMax) :
dist (next f₁ t) (next f₂ t) ≤ (v.L * |t.1 - v.t₀|) ^ (n + 1) / (n + 1)! * d
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f₁ f₂ : v.FunSpace
n : ℕ
d : ℝ
t : ↑(Icc v.tMin v.tMax)
h : ∀ (t : ↑(Icc v.tMin v.tMax)), ‖f₁.toFun t - f₂.toFun t‖ ≤ (↑v.L * |↑t - ↑v.t₀|) ^ n / ↑n ! * d
τ : ℝ
hτ : τ ∈ Ioc (↑v.t₀ ⊓ ↑t) (↑v.t₀ ⊔ ↑t)
⊢ ‖f₁.vComp τ - f₂.vComp τ‖ ≤ ↑v.L * ((↑v.L * |τ - ↑v.t₀|) ^ n / ↑n ! * d)
|
refine (v.lipschitzOnWith (v.proj τ).2).norm_sub_le_of_le (f₁.mem_closedBall _)
(f₂.mem_closedBall _) ((h _).trans_eq ?_)
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f₁ f₂ : v.FunSpace
n : ℕ
d : ℝ
t : ↑(Icc v.tMin v.tMax)
h : ∀ (t : ↑(Icc v.tMin v.tMax)), ‖f₁.toFun t - f₂.toFun t‖ ≤ (↑v.L * |↑t - ↑v.t₀|) ^ n / ↑n ! * d
τ : ℝ
hτ : τ ∈ Ioc (↑v.t₀ ⊓ ↑t) (↑v.t₀ ⊔ ↑t)
⊢ (↑v.L * |↑(v.proj τ) - ↑v.t₀|) ^ n / ↑n ! * d = (↑v.L * |τ - ↑v.t₀|) ^ n / ↑n ! * d
|
9f96a1fd526331f6
|
with_gaugeSeminormFamily
|
Mathlib/Analysis/LocallyConvex/AbsConvexOpen.lean
|
theorem with_gaugeSeminormFamily : WithSeminorms (gaugeSeminormFamily 𝕜 E)
|
case refine_2
𝕜 : Type u_1
E : Type u_2
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : AddCommGroup E
inst✝⁸ : TopologicalSpace E
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module ℝ E
inst✝⁵ : IsScalarTower ℝ 𝕜 E
inst✝⁴ : ContinuousSMul ℝ E
inst✝³ : IsTopologicalAddGroup E
inst✝² : ContinuousSMul 𝕜 E
inst✝¹ : SMulCommClass ℝ 𝕜 E
inst✝ : LocallyConvexSpace ℝ E
s : Set E
hs : ∃ i r, 0 < r ∧ s = (i.sup (gaugeSeminormFamily 𝕜 E)).ball 0 r
⊢ 0 ∈ s ∧ IsOpen s ∧ AbsConvex 𝕜 s
|
rcases hs with ⟨t, r, hr, rfl⟩
|
case refine_2.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : AddCommGroup E
inst✝⁸ : TopologicalSpace E
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module ℝ E
inst✝⁵ : IsScalarTower ℝ 𝕜 E
inst✝⁴ : ContinuousSMul ℝ E
inst✝³ : IsTopologicalAddGroup E
inst✝² : ContinuousSMul 𝕜 E
inst✝¹ : SMulCommClass ℝ 𝕜 E
inst✝ : LocallyConvexSpace ℝ E
t : Finset (AbsConvexOpenSets 𝕜 E)
r : ℝ
hr : 0 < r
⊢ 0 ∈ (t.sup (gaugeSeminormFamily 𝕜 E)).ball 0 r ∧
IsOpen ((t.sup (gaugeSeminormFamily 𝕜 E)).ball 0 r) ∧ AbsConvex 𝕜 ((t.sup (gaugeSeminormFamily 𝕜 E)).ball 0 r)
|
e22eb7b3cab52675
|
AddMonoidHom.exact_iff_of_surjective_of_bijective_of_injective
|
Mathlib/Algebra/Exact.lean
|
/-- When we have a commutative diagram from a sequence of two maps to another,
such that the left vertical map is surjective, the middle vertical map is bijective and the right
vertical map is injective, then the upper row is exact iff the lower row is.
See `ShortComplex.exact_iff_of_epi_of_isIso_of_mono` in the file
`Algebra.Homology.ShortComplex.Exact` for the categorical version of this result. -/
lemma exact_iff_of_surjective_of_bijective_of_injective
{M₁ M₂ M₃ N₁ N₂ N₃ : Type*} [AddCommMonoid M₁] [AddCommMonoid M₂] [AddCommMonoid M₃]
[AddCommMonoid N₁] [AddCommMonoid N₂] [AddCommMonoid N₃]
(f : M₁ →+ M₂) (g : M₂ →+ M₃) (f' : N₁ →+ N₂) (g' : N₂ →+ N₃)
(τ₁ : M₁ →+ N₁) (τ₂ : M₂ →+ N₂) (τ₃ : M₃ →+ N₃)
(comm₁₂ : f'.comp τ₁ = τ₂.comp f)
(comm₂₃ : g'.comp τ₂ = τ₃.comp g)
(h₁ : Function.Surjective τ₁) (h₂ : Function.Bijective τ₂) (h₃ : Function.Injective τ₃) :
Exact f g ↔ Exact f' g'
|
M₁ : Type u_8
M₂ : Type u_9
M₃ : Type u_10
N₁ : Type u_11
N₂ : Type u_12
N₃ : Type u_13
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : AddCommMonoid M₃
inst✝² : AddCommMonoid N₁
inst✝¹ : AddCommMonoid N₂
inst✝ : AddCommMonoid N₃
f : M₁ →+ M₂
g : M₂ →+ M₃
f' : N₁ →+ N₂
g' : N₂ →+ N₃
τ₁ : M₁ →+ N₁
τ₂ : M₂ →+ N₂
τ₃ : M₃ →+ N₃
h₁ : Surjective ⇑τ₁
h₂ : Bijective ⇑τ₂
h₃ : Injective ⇑τ₃
comm₁₂ : ∀ (x : M₁), f' (τ₁ x) = τ₂ (f x)
comm₂₃ : ∀ (x : M₂), g' (τ₂ x) = τ₃ (g x)
h : Exact ⇑f ⇑g
x₂ : M₂
x₁ : M₁
hy₁ : f' (τ₁ x₁) = τ₂ x₂
⊢ τ₂ (f x₁) = τ₂ x₂
|
simpa only [comm₁₂] using hy₁
|
no goals
|
ba6ec98108593bea
|
MeasureTheory.integral_divergence_prod_Icc_of_hasFDerivWithinAt_off_countable_of_le
|
Mathlib/MeasureTheory/Integral/DivergenceTheorem.lean
|
theorem integral_divergence_prod_Icc_of_hasFDerivWithinAt_off_countable_of_le (f g : ℝ × ℝ → E)
(f' g' : ℝ × ℝ → ℝ × ℝ →L[ℝ] E) (a b : ℝ × ℝ) (hle : a ≤ b) (s : Set (ℝ × ℝ)) (hs : s.Countable)
(Hcf : ContinuousOn f (Icc a b)) (Hcg : ContinuousOn g (Icc a b))
(Hdf : ∀ x ∈ Ioo a.1 b.1 ×ˢ Ioo a.2 b.2 \ s, HasFDerivAt f (f' x) x)
(Hdg : ∀ x ∈ Ioo a.1 b.1 ×ˢ Ioo a.2 b.2 \ s, HasFDerivAt g (g' x) x)
(Hi : IntegrableOn (fun x => f' x (1, 0) + g' x (0, 1)) (Icc a b)) :
(∫ x in Icc a b, f' x (1, 0) + g' x (0, 1)) =
(((∫ x in a.1..b.1, g (x, b.2)) - ∫ x in a.1..b.1, g (x, a.2)) +
∫ y in a.2..b.2, f (b.1, y)) -
∫ y in a.2..b.2, f (a.1, y) :=
let e : (ℝ × ℝ) ≃L[ℝ] ℝ² := (ContinuousLinearEquiv.finTwoArrow ℝ ℝ).symm
calc
(∫ x in Icc a b, f' x (1, 0) + g' x (0, 1)) =
∑ i : Fin 2,
((∫ x in Icc (e a ∘ i.succAbove) (e b ∘ i.succAbove),
![f, g] i (e.symm <| i.insertNth (e b i) x)) -
∫ x in Icc (e a ∘ i.succAbove) (e b ∘ i.succAbove),
![f, g] i (e.symm <| i.insertNth (e a i) x))
|
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : ℝ × ℝ → E
f' g' : ℝ × ℝ → ℝ × ℝ →L[ℝ] E
a b : ℝ × ℝ
hle : a ≤ b
s : Set (ℝ × ℝ)
hs : s.Countable
Hcf : ContinuousOn f (Set.Icc a b)
Hcg : ContinuousOn g (Set.Icc a b)
Hdf : ∀ x ∈ Set.Ioo a.1 b.1 ×ˢ Set.Ioo a.2 b.2 \ s, HasFDerivAt f (f' x) x
Hdg : ∀ x ∈ Set.Ioo a.1 b.1 ×ˢ Set.Ioo a.2 b.2 \ s, HasFDerivAt g (g' x) x
Hi : IntegrableOn (fun x => (f' x) (1, 0) + (g' x) (0, 1)) (Set.Icc a b) volume
e : (ℝ × ℝ) ≃L[ℝ] Fin 2 → ℝ := (ContinuousLinearEquiv.finTwoArrow ℝ ℝ).symm
⊢ ((∫ (y : ℝ) in Set.Icc a.2 b.2, f (b.1, y)) - ∫ (y : ℝ) in Set.Icc a.2 b.2, f (a.1, y)) +
((∫ (x : ℝ) in Set.Icc a.1 b.1, g (x, b.2)) - ∫ (x : ℝ) in Set.Icc a.1 b.1, g (x, a.2)) =
(((∫ (x : ℝ) in Set.Icc a.1 b.1, g (x, b.2)) - ∫ (x : ℝ) in Set.Icc a.1 b.1, g (x, a.2)) +
∫ (y : ℝ) in Set.Icc a.2 b.2, f (b.1, y)) -
∫ (y : ℝ) in Set.Icc a.2 b.2, f (a.1, y)
|
abel
|
no goals
|
8e922847faa040ee
|
EulerProduct.one_sub_inv_eq_geometric_of_summable_norm
|
Mathlib/NumberTheory/EulerProduct/Basic.lean
|
lemma one_sub_inv_eq_geometric_of_summable_norm {f : ℕ →*₀ F} {p : ℕ} (hp : p.Prime)
(hsum : Summable fun x ↦ ‖f x‖) :
(1 - f p)⁻¹ = ∑' (e : ℕ), f (p ^ e)
|
F : Type u_1
inst✝¹ : NormedField F
inst✝ : CompleteSpace F
f : ℕ →*₀ F
p : ℕ
hp : Nat.Prime p
hsum : Summable fun x => ‖f x‖
⊢ (1 - f p)⁻¹ = ∑' (e : ℕ), f p ^ e
|
refine (tsum_geometric_of_norm_lt_one <| summable_geometric_iff_norm_lt_one.mp ?_).symm
|
F : Type u_1
inst✝¹ : NormedField F
inst✝ : CompleteSpace F
f : ℕ →*₀ F
p : ℕ
hp : Nat.Prime p
hsum : Summable fun x => ‖f x‖
⊢ Summable fun n => f p ^ n
|
bde940928d778afb
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.mem_of_insertRatUnits
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.lean
|
theorem mem_of_insertRatUnits {n : Nat} (f : DefaultFormula n) (units : CNF.Clause (PosFin n))
(c : DefaultClause n) :
c ∈ toList (insertRatUnits f units).1 → c ∈ units.map Clause.unit ∨ c ∈ toList f
|
case isFalse.inr
n : Nat
f : DefaultFormula n
units : CNF.Clause (PosFin n)
c : DefaultClause n
h :
some c ∈ f.clauses.toList ∨
(∃ a,
(a, false) ∈ f.rupUnits.toList ∧ Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, false) = c ∨
(a, true) ∈ f.rupUnits.toList ∧ Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, true) = c) ∨
∃ a,
(a, false) ∈ (List.foldl insertUnit (f.ratUnits, f.assignments, false) units).fst.toList ∧
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, false) = c ∨
(a, true) ∈ (List.foldl insertUnit (f.ratUnits, f.assignments, false) units).fst.toList ∧
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, true) = c
hb : ∀ (l : Literal (PosFin n)), l ∈ (f.ratUnits, f.assignments, false).fst.toList → l ∈ f.ratUnits.toList ∨ l ∈ units
acc : Array (Literal (PosFin n)) × Array Assignment × Bool
ih : ∀ (l : Literal (PosFin n)), l ∈ acc.fst.toList → l ∈ f.ratUnits.toList ∨ l ∈ units
unit : Literal (PosFin n)
unit_in_units : unit ∈ units
l : Literal (PosFin n)
h✝ : ¬hasAssignment unit.snd acc.2.fst[unit.fst.val]! = true
l_eq_unit : l = (unit.fst, unit.snd)
⊢ l ∈ f.ratUnits.toList ∨ l ∈ units
|
rw [l_eq_unit]
|
case isFalse.inr
n : Nat
f : DefaultFormula n
units : CNF.Clause (PosFin n)
c : DefaultClause n
h :
some c ∈ f.clauses.toList ∨
(∃ a,
(a, false) ∈ f.rupUnits.toList ∧ Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, false) = c ∨
(a, true) ∈ f.rupUnits.toList ∧ Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, true) = c) ∨
∃ a,
(a, false) ∈ (List.foldl insertUnit (f.ratUnits, f.assignments, false) units).fst.toList ∧
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, false) = c ∨
(a, true) ∈ (List.foldl insertUnit (f.ratUnits, f.assignments, false) units).fst.toList ∧
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.unit (a, true) = c
hb : ∀ (l : Literal (PosFin n)), l ∈ (f.ratUnits, f.assignments, false).fst.toList → l ∈ f.ratUnits.toList ∨ l ∈ units
acc : Array (Literal (PosFin n)) × Array Assignment × Bool
ih : ∀ (l : Literal (PosFin n)), l ∈ acc.fst.toList → l ∈ f.ratUnits.toList ∨ l ∈ units
unit : Literal (PosFin n)
unit_in_units : unit ∈ units
l : Literal (PosFin n)
h✝ : ¬hasAssignment unit.snd acc.2.fst[unit.fst.val]! = true
l_eq_unit : l = (unit.fst, unit.snd)
⊢ (unit.fst, unit.snd) ∈ f.ratUnits.toList ∨ (unit.fst, unit.snd) ∈ units
|
5c2f0ea4a0a97aee
|
WithSeminorms.partial_sups
|
Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
|
theorem partial_sups [Preorder ι] [LocallyFiniteOrderBot ι] {p : SeminormFamily 𝕜 E ι}
[TopologicalSpace E] (hp : WithSeminorms p) : WithSeminorms (fun i ↦ (Finset.Iic i).sup p)
|
case refine_2
𝕜 : Type u_1
E : Type u_5
ι : Type u_8
inst✝⁶ : Nonempty ι
inst✝⁵ : NormedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Preorder ι
inst✝¹ : LocallyFiniteOrderBot ι
p : SeminormFamily 𝕜 E ι
inst✝ : TopologicalSpace E
hp : WithSeminorms p
⊢ Seminorm.IsBounded (fun i => (Finset.Iic i).sup p) p LinearMap.id
|
intro i
|
case refine_2
𝕜 : Type u_1
E : Type u_5
ι : Type u_8
inst✝⁶ : Nonempty ι
inst✝⁵ : NormedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Preorder ι
inst✝¹ : LocallyFiniteOrderBot ι
p : SeminormFamily 𝕜 E ι
inst✝ : TopologicalSpace E
hp : WithSeminorms p
i : ι
⊢ ∃ s C, (p i).comp LinearMap.id ≤ C • s.sup fun i => (Finset.Iic i).sup p
|
ce17cfd18290d498
|
SimpleGraph.cliqueFree_bot
|
Mathlib/Combinatorics/SimpleGraph/Clique.lean
|
theorem cliqueFree_bot (h : 2 ≤ n) : (⊥ : SimpleGraph α).CliqueFree n
|
α : Type u_1
n : ℕ
h : 2 ≤ n
⊢ ⊥.CliqueFree n
|
intro t ht
|
α : Type u_1
n : ℕ
h : 2 ≤ n
t : Finset α
ht : ⊥.IsNClique n t
⊢ False
|
88c43026a060bfb8
|
Finsupp.ext_iff'
|
Mathlib/Data/Finsupp/Defs.lean
|
theorem ext_iff' {f g : α →₀ M} : f = g ↔ f.support = g.support ∧ ∀ x ∈ f.support, f x = g x :=
⟨fun h => h ▸ ⟨rfl, fun _ _ => rfl⟩, fun ⟨h₁, h₂⟩ =>
ext fun a => by
classical
exact if h : a ∈ f.support then h₂ a h else by
have hf : f a = 0 := not_mem_support_iff.1 h
have hg : g a = 0
|
α : Type u_1
M : Type u_5
inst✝ : Zero M
f g : α →₀ M
x✝ : f.support = g.support ∧ ∀ x ∈ f.support, f x = g x
h₁ : f.support = g.support
h₂ : ∀ x ∈ f.support, f x = g x
a : α
⊢ f a = g a
|
exact if h : a ∈ f.support then h₂ a h else by
have hf : f a = 0 := not_mem_support_iff.1 h
have hg : g a = 0 := by rwa [h₁, not_mem_support_iff] at h
rw [hf, hg]
|
no goals
|
932fff80e8bf85f1
|
Polynomial.supDegree_eq_natDegree
|
Mathlib/Algebra/Polynomial/Degree/Support.lean
|
theorem supDegree_eq_natDegree (p : R[X]) : p.toFinsupp.supDegree id = p.natDegree
|
case inr
R : Type u
inst✝ : Semiring R
p : R[X]
h : p ≠ 0
⊢ AddMonoidAlgebra.supDegree id p.toFinsupp = p.natDegree
|
apply WithBot.coe_injective
|
case inr.a
R : Type u
inst✝ : Semiring R
p : R[X]
h : p ≠ 0
⊢ ↑(AddMonoidAlgebra.supDegree id p.toFinsupp) = ↑p.natDegree
|
03091986e76bfab5
|
Finset.prod_eq_prod_iff_of_le
|
Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
|
theorem prod_eq_prod_iff_of_le {f g : ι → M} (h : ∀ i ∈ s, f i ≤ g i) :
((∏ i ∈ s, f i) = ∏ i ∈ s, g i) ↔ ∀ i ∈ s, f i = g i
|
ι : Type u_1
M : Type u_4
inst✝ : OrderedCancelCommMonoid M
s : Finset ι
f g : ι → M
h : ∀ i ∈ s, f i ≤ g i
⊢ ∏ i ∈ s, f i = ∏ i ∈ s, g i ↔ ∀ i ∈ s, f i = g i
|
classical
revert h
refine Finset.induction_on s (fun _ ↦ ⟨fun _ _ h ↦ False.elim (Finset.not_mem_empty _ h),
fun _ ↦ rfl⟩) fun a s ha ih H ↦ ?_
specialize ih fun i ↦ H i ∘ Finset.mem_insert_of_mem
rw [Finset.prod_insert ha, Finset.prod_insert ha, Finset.forall_mem_insert, ← ih]
exact
mul_eq_mul_iff_eq_and_eq (H a (s.mem_insert_self a))
(Finset.prod_le_prod' fun i ↦ H i ∘ Finset.mem_insert_of_mem)
|
no goals
|
a26b5c2a23f9ab34
|
LinearMap.continuous_of_isClosed_graph
|
Mathlib/Analysis/Normed/Operator/Banach.lean
|
theorem LinearMap.continuous_of_isClosed_graph (hg : IsClosed (g.graph : Set <| E × F)) :
Continuous g
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_5
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
g : E →ₗ[𝕜] F
hg : IsClosed ↑g.graph
this✝ : CompleteSpace ↥g.graph := completeSpace_coe_iff_isComplete.mpr (IsClosed.isComplete hg)
φ₀ : E →ₗ[𝕜] E × F := id.prod g
this : LeftInverse Prod.fst ⇑φ₀
⊢ Continuous ⇑g
|
let φ : E ≃ₗ[𝕜] g.graph :=
(LinearEquiv.ofLeftInverse this).trans (LinearEquiv.ofEq _ _ g.graph_eq_range_prod.symm)
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_5
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
g : E →ₗ[𝕜] F
hg : IsClosed ↑g.graph
this✝ : CompleteSpace ↥g.graph := completeSpace_coe_iff_isComplete.mpr (IsClosed.isComplete hg)
φ₀ : E →ₗ[𝕜] E × F := id.prod g
this : LeftInverse Prod.fst ⇑φ₀
φ : E ≃ₗ[𝕜] ↥g.graph := LinearEquiv.ofLeftInverse this ≪≫ₗ LinearEquiv.ofEq (range φ₀) g.graph ⋯
⊢ Continuous ⇑g
|
fb516bea31e9047b
|
Lake.BuildKey.eq_of_quickCmp
|
Mathlib/.lake/packages/lean4/src/lean/lake/Lake/Build/Key.lean
|
theorem eq_of_quickCmp {k k' : BuildKey} :
quickCmp k k' = Ordering.eq → k = k'
|
m f m' f' : Name
x✝ : Ordering
m_eq : m.quickCmp m' = Ordering.eq
⊢ f.quickCmp f' = Ordering.eq → moduleFacet m f = moduleFacet m' f'
|
intro f_eq
|
m f m' f' : Name
x✝ : Ordering
m_eq : m.quickCmp m' = Ordering.eq
f_eq : f.quickCmp f' = Ordering.eq
⊢ moduleFacet m f = moduleFacet m' f'
|
6e2940eeabc7d427
|
Turing.ListBlank.map_modifyNth
|
Mathlib/Computability/Tape.lean
|
theorem ListBlank.map_modifyNth {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (F : PointedMap Γ Γ')
(f : Γ → Γ) (f' : Γ' → Γ') (H : ∀ x, F (f x) = f' (F x)) (n) (L : ListBlank Γ) :
(L.modifyNth f n).map F = (L.map F).modifyNth f' n
|
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
F : PointedMap Γ Γ'
f : Γ → Γ
f' : Γ' → Γ'
H : ∀ (x : Γ), F.f (f x) = f' (F.f x)
n : ℕ
L : ListBlank Γ
⊢ map F (modifyNth f n L) = modifyNth f' n (map F L)
|
induction' n with n IH generalizing L <;>
simp only [*, ListBlank.head_map, ListBlank.modifyNth, ListBlank.map_cons, ListBlank.tail_map]
|
no goals
|
b9a1b989ab4f3864
|
UniformSpace.metrizable_uniformity
|
Mathlib/Topology/Metrizable/Uniformity.lean
|
theorem UniformSpace.metrizable_uniformity (X : Type*) [UniformSpace X]
[IsCountablyGenerated (𝓤 X)] : ∃ I : PseudoMetricSpace X, I.toUniformSpace = ‹_›
|
X : Type u_2
inst✝¹ : UniformSpace X
inst✝ : (𝓤 X).IsCountablyGenerated
U : ℕ → Set (X × X)
hU_symm : ∀ (n : ℕ), SymmetricRel (U n)
hU_comp : ∀ ⦃m n : ℕ⦄, m < n → U n ○ (U n ○ U n) ⊆ U m
hB : (𝓤 X).HasAntitoneBasis U
d : X → X → ℝ≥0 := fun x y => if h : ∃ n, (x, y) ∉ U n then (1 / 2) ^ Nat.find h else 0
x y : X
⊢ d x y = 0 ↔ Inseparable x y
|
refine Iff.trans ?_ hB.inseparable_iff_uniformity.symm
|
X : Type u_2
inst✝¹ : UniformSpace X
inst✝ : (𝓤 X).IsCountablyGenerated
U : ℕ → Set (X × X)
hU_symm : ∀ (n : ℕ), SymmetricRel (U n)
hU_comp : ∀ ⦃m n : ℕ⦄, m < n → U n ○ (U n ○ U n) ⊆ U m
hB : (𝓤 X).HasAntitoneBasis U
d : X → X → ℝ≥0 := fun x y => if h : ∃ n, (x, y) ∉ U n then (1 / 2) ^ Nat.find h else 0
x y : X
⊢ d x y = 0 ↔ ∀ (i : ℕ), True → (x, y) ∈ U i
|
6b4b13aa9c62ee27
|
Matroid.comapOn_dual_eq_of_bijOn
|
Mathlib/Data/Matroid/Map.lean
|
lemma comapOn_dual_eq_of_bijOn (h : BijOn f E N.E) :
(N.comapOn E f)✶ = N✶.comapOn E f
|
α : Type u_1
β : Type u_2
f : α → β
N : Matroid β
E : Set α
h : BijOn f E N.E
B : Set α
hB : B ⊆ (N.comapOn E f)✶.E
⊢ (N.comapOn E f)✶.IsBase B ↔ (N✶.comapOn E f).IsBase B
|
rw [comapOn_isBase_iff_of_bijOn (by simpa), dual_isBase_iff, comapOn_isBase_iff_of_bijOn h,
dual_isBase_iff _, comapOn_ground_eq, and_iff_left diff_subset, and_iff_left (by simpa),
h.injOn.image_diff_subset (by simpa), h.image_eq]
|
α : Type u_1
β : Type u_2
f : α → β
N : Matroid β
E : Set α
h : BijOn f E N.E
B : Set α
hB : B ⊆ (N.comapOn E f)✶.E
⊢ f '' B ⊆ N.E
|
c484423ed0aeb005
|
List.Sorted.orderedInsert
|
Mathlib/Data/List/Sort.lean
|
theorem Sorted.orderedInsert (a : α) : ∀ l, Sorted r l → Sorted r (orderedInsert r a l)
| [], _ => sorted_singleton a
| b :: l, h => by
by_cases h' : a ≼ b
· -- Porting note: was
-- `simpa [orderedInsert, h', h] using fun b' bm => trans h' (rel_of_sorted_cons h _ bm)`
rw [List.orderedInsert, if_pos h', sorted_cons]
exact ⟨forall_mem_cons.2 ⟨h', fun c hc => _root_.trans h' (rel_of_sorted_cons h _ hc)⟩, h⟩
· suffices ∀ b' : α, b' ∈ List.orderedInsert r a l → r b b' by
simpa [orderedInsert, h', h.of_cons.orderedInsert a l]
intro b' bm
rcases (mem_orderedInsert r).mp bm with be | bm
· subst b'
exact (total_of r _ _).resolve_left h'
· exact rel_of_sorted_cons h _ bm
|
case neg.inr
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l : List α
h : Sorted r (b :: l)
h' : ¬r a b
b' : α
bm✝ : b' ∈ List.orderedInsert r a l
bm : b' ∈ l
⊢ r b b'
|
exact rel_of_sorted_cons h _ bm
|
no goals
|
da6a875b540ed7f6
|
lp.norm_apply_le_norm
|
Mathlib/Analysis/Normed/Lp/lpSpace.lean
|
theorem norm_apply_le_norm (hp : p ≠ 0) (f : lp E p) (i : α) : ‖f i‖ ≤ ‖f‖
|
case inr
α : Type u_3
E : α → Type u_4
p : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
hp : p ≠ 0
f : ↥(lp E p)
i : α
hp' : p ≠ ⊤
hp'' : 0 < p.toReal
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ p.toReal
⊢ ‖↑f i‖ ^ p.toReal ≤ ‖f‖ ^ p.toReal
|
convert le_hasSum (hasSum_norm hp'' f) i fun i _ => this i
|
no goals
|
f154c1ebf1cb56a2
|
MeasureTheory.L1.SimpleFunc.integral_eq_norm_posPart_sub
|
Mathlib/MeasureTheory/Integral/BochnerL1.lean
|
theorem integral_eq_norm_posPart_sub (f : α →₁ₛ[μ] ℝ) : integral f = ‖posPart f‖ - ‖negPart f‖
|
case h
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : ↥(simpleFunc ℝ 1 μ)
a✝ : α
h : (toSimpleFunc (posPart f)) a✝ = (toSimpleFunc f).posPart a✝
⊢ (toSimpleFunc f).posPart a✝ = (SimpleFunc.map norm (toSimpleFunc (posPart f))) a✝
|
rw [SimpleFunc.map_apply, h]
|
case h
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : ↥(simpleFunc ℝ 1 μ)
a✝ : α
h : (toSimpleFunc (posPart f)) a✝ = (toSimpleFunc f).posPart a✝
⊢ (toSimpleFunc f).posPart a✝ = ‖(toSimpleFunc f).posPart a✝‖
|
464e4ba9ec3511ad
|
ContinuousLinearEquiv.nhds
|
Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
|
theorem nhds [CompleteSpace E] (e : E ≃L[𝕜] F) :
range ((↑) : (E ≃L[𝕜] F) → E →L[𝕜] F) ∈ 𝓝 (e : E →L[𝕜] F) :=
IsOpen.mem_nhds ContinuousLinearEquiv.isOpen (by simp)
|
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type u_3
inst✝² : SeminormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace E
e : E ≃L[𝕜] F
⊢ ↑e ∈ range toContinuousLinearMap
|
simp
|
no goals
|
6d20ce5806ff1981
|
CategoryTheory.Abelian.Ext.homEquiv_chgUniv
|
Mathlib/Algebra/Homology/DerivedCategory/Ext/Basic.lean
|
lemma homEquiv_chgUniv [HasDerivedCategory.{w''} C] (e : Ext.{w} X Y n) :
homEquiv.{w'', w'} (chgUniv.{w'} e) = homEquiv.{w'', w} e
|
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Abelian C
inst✝² : HasExt C
inst✝¹ : HasExt C
X Y : C
n : ℕ
inst✝ : HasDerivedCategory C
e : Ext X Y n
⊢ homEquiv (chgUniv e) = homEquiv e
|
apply SmallShiftedHom.equiv_chgUniv
|
no goals
|
870e345d0e5022f1
|
List.set_getElem_succ_eraseIdx_succ
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Nat/Erase.lean
|
theorem set_getElem_succ_eraseIdx_succ
{l : List α} {i : Nat} (h : i + 1 < l.length) :
(l.eraseIdx (i + 1)).set i l[i + 1] = l.eraseIdx i
|
case h.isTrue.isFalse
α : Type u_1
l : List α
i : Nat
h : i + 1 < l.length
n : Nat
h₁ : n < ((l.eraseIdx (i + 1)).set i l[i + 1]).length
h₂ : n < (l.eraseIdx i).length
h✝¹ : i = n
h✝ : ¬n < i
⊢ l[i + 1] = l[n + 1]
|
simp_all
|
no goals
|
31983ea669fb242b
|
Compactum.str_eq_of_le_nhds
|
Mathlib/Topology/Category/Compactum.lean
|
theorem str_eq_of_le_nhds {X : Compactum} (F : Ultrafilter X) (x : X) : ↑F ≤ 𝓝 x → X.str F = x
|
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A ∈ F, S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := X.str ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ A ∈ F, x ∈ Compactum.cl A
claim3 : ∀ S1 ∈ T0, ∀ S2 ∈ T0, S1 ∩ S2 ∈ T0
claim4 : ∀ S ∈ T0, (AA ∩ S).Nonempty
claim5 : ∀ S ∈ T0, S.Nonempty
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ S ∈ T0 ∨ ∃ Q ∈ T0, S = AA ∩ Q
|
apply finiteInterClosure_insert
|
case cond
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A ∈ F, S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := X.str ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ A ∈ F, x ∈ Compactum.cl A
claim3 : ∀ S1 ∈ T0, ∀ S2 ∈ T0, S1 ∩ S2 ∈ T0
claim4 : ∀ S ∈ T0, (AA ∩ S).Nonempty
claim5 : ∀ S ∈ T0, S.Nonempty
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ FiniteInter T0
case H
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A ∈ F, S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := X.str ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ A ∈ F, x ∈ Compactum.cl A
claim3 : ∀ S1 ∈ T0, ∀ S2 ∈ T0, S1 ∩ S2 ∈ T0
claim4 : ∀ S ∈ T0, (AA ∩ S).Nonempty
claim5 : ∀ S ∈ T0, S.Nonempty
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ S ∈ finiteInterClosure (insert AA T0)
|
2b00909734780390
|
Prod.mk.inj_left
|
Mathlib/Data/Prod/Basic.lean
|
theorem mk.inj_left {α β : Type*} (a : α) : Function.Injective (Prod.mk a : β → α × β)
|
α : Type u_5
β : Type u_6
a : α
b₁ b₂ : β
h : (a, b₁) = (a, b₂)
⊢ b₁ = b₂
|
simpa only [true_and, Prod.mk.inj_iff, eq_self_iff_true] using h
|
no goals
|
f560d3394cfb1c97
|
continuousWithinAt_iff_lower_upperSemicontinuousWithinAt
|
Mathlib/Topology/Semicontinuous.lean
|
theorem continuousWithinAt_iff_lower_upperSemicontinuousWithinAt {f : α → γ} :
ContinuousWithinAt f s x ↔
LowerSemicontinuousWithinAt f s x ∧ UpperSemicontinuousWithinAt f s x
|
case pos
α : Type u_1
inst✝³ : TopologicalSpace α
x : α
s : Set α
γ : Type u_3
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
h₁ : LowerSemicontinuousWithinAt f s x
h₂ : UpperSemicontinuousWithinAt f s x
v : Set γ
hv : v ∈ 𝓝 (f x)
Hl : ∃ l, l < f x
l : γ
lfx : l < f x
hl : Ioc l (f x) ⊆ v
Hu : ∃ u, f x < u
⊢ f ⁻¹' v ∈ 𝓝[s] x
|
rcases exists_Ico_subset_of_mem_nhds hv Hu with ⟨u, fxu, hu⟩
|
case pos.intro.intro
α : Type u_1
inst✝³ : TopologicalSpace α
x : α
s : Set α
γ : Type u_3
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
h₁ : LowerSemicontinuousWithinAt f s x
h₂ : UpperSemicontinuousWithinAt f s x
v : Set γ
hv : v ∈ 𝓝 (f x)
Hl : ∃ l, l < f x
l : γ
lfx : l < f x
hl : Ioc l (f x) ⊆ v
Hu : ∃ u, f x < u
u : γ
fxu : f x < u
hu : Ico (f x) u ⊆ v
⊢ f ⁻¹' v ∈ 𝓝[s] x
|
78adc466397c2988
|
ENNReal.mul_inv
|
Mathlib/Data/ENNReal/Inv.lean
|
theorem mul_inv {a b : ℝ≥0∞} (ha : a ≠ 0 ∨ b ≠ ∞) (hb : a ≠ ∞ ∨ b ≠ 0) :
(a * b)⁻¹ = a⁻¹ * b⁻¹
|
case neg
b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : ¬a = 0
h'b : ¬b = 0
⊢ a * b ≠ 0
|
simp [h'a, h'b]
|
no goals
|
ec641d52dcabe2dc
|
intervalIntegral.integral_unitInterval_deriv_eq_sub
|
Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
|
/-- A variant of `intervalIntegral.integral_deriv_eq_sub`, the Fundamental theorem
of calculus, involving integrating over the unit interval. -/
lemma integral_unitInterval_deriv_eq_sub [RCLike 𝕜] [NormedSpace 𝕜 E] [IsScalarTower ℝ 𝕜 E]
{f f' : 𝕜 → E} {z₀ z₁ : 𝕜}
(hcont : ContinuousOn (fun t : ℝ ↦ f' (z₀ + t • z₁)) (Set.Icc 0 1))
(hderiv : ∀ t ∈ Set.Icc (0 : ℝ) 1, HasDerivAt f (f' (z₀ + t • z₁)) (z₀ + t • z₁)) :
z₁ • ∫ t in (0 : ℝ)..1, f' (z₀ + t • z₁) = f (z₀ + z₁) - f z₀
|
case h.e'_9
𝕜 : Type u_2
E : Type u_3
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : RCLike 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
f f' : 𝕜 → E
z₀ z₁ : 𝕜
hcont : ContinuousOn (fun t => f' (z₀ + t • z₁)) (Icc 0 1)
hderiv : ∀ t ∈ Icc 0 1, HasDerivAt f (f' (z₀ + t • z₁)) (z₀ + t • z₁)
γ : ℝ → 𝕜 := fun t => z₀ + t • z₁
hint : IntervalIntegrable (z₁ • f' ∘ γ) volume 0 1
t : ℝ
ht : t ∈ [[0, 1]]
⊢ z₁ = 1 • z₁
|
simp only [one_smul]
|
no goals
|
33b334f9c09cf4b0
|
Std.DHashMap.Internal.List.containsKey_of_perm
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem containsKey_of_perm [BEq α] [PartialEquivBEq α] {l l' : List ((a : α) × β a)} {k : α}
(h : Perm l l') : containsKey k l = containsKey k l'
|
case nil
α : Type u
β : α → Type v
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
l l' : List ((a : α) × β a)
k : α
⊢ containsKey k [] = containsKey k []
|
simp
|
no goals
|
70651f11be1009a2
|
CategoryTheory.compatiblePreservingOfFlat
|
Mathlib/CategoryTheory/Sites/CoverPreserving.lean
|
theorem compatiblePreservingOfFlat {C : Type u₁} [Category.{v₁} C] {D : Type u₁} [Category.{v₁} D]
(K : GrothendieckTopology D) (G : C ⥤ D) [RepresentablyFlat G] : CompatiblePreserving K G
|
case compatible.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₁
inst✝¹ : Category.{v₁, u₁} D
K : GrothendieckTopology D
G : C ⥤ D
inst✝ : RepresentablyFlat G
ℱ : Sheaf K (Type u_1)
Z : C
T : Presieve Z
x : FamilyOfElements (G.op ⋙ ℱ.val) T
hx : x.Compatible
Y₁ Y₂ : C
X : D
f₁ : X ⟶ G.obj Y₁
f₂ : X ⟶ G.obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
e : f₁ ≫ G.map g₁ = f₂ ≫ G.map g₂
c : Cone (cospan g₁ g₂ ⋙ G) :=
(Cones.postcompose (diagramIsoCospan (cospan g₁ g₂ ⋙ G)).inv).obj (PullbackCone.mk f₁ f₂ e)
c' : Cone (c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G) :=
IsCofiltered.cone (c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G)
eq₁ : f₁ = (c'.pt.hom ≫ G.map (c'.π.app left).right) ≫ eqToHom ⋯
eq₂ : f₂ = (c'.pt.hom ≫ G.map (c'.π.app right).right) ≫ eqToHom ⋯
left_eq✝¹ :
(((Functor.const WalkingCospan).obj c'.pt).map Hom.inl).left ≫ (c'.π.app one).left =
(c'.π.app left).left ≫ ((c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G).map Hom.inl).left
e₁ :
(((Functor.const WalkingCospan).obj c'.pt).map Hom.inl).right ≫ (c'.π.app one).right =
(c'.π.app left).right ≫ ((c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G).map Hom.inl).right
left_eq✝ :
(((Functor.const WalkingCospan).obj c'.pt).map Hom.inr).left ≫ (c'.π.app one).left =
(c'.π.app right).left ≫ ((c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G).map Hom.inr).left
e₂ :
(((Functor.const WalkingCospan).obj c'.pt).map Hom.inr).right ≫ (c'.π.app one).right =
(c'.π.app right).right ≫ ((c.toStructuredArrow ⋙ StructuredArrow.pre c.pt (cospan g₁ g₂) G).map Hom.inr).right
⊢ ℱ.val.map (G.map (c'.π.app left).right).op (eqToHom ⋯ (x g₁ hg₁)) =
ℱ.val.map (G.map (c'.π.app right).right).op (eqToHom ⋯ (x g₂ hg₂))
|
exact hx (c'.π.app left).right (c'.π.app right).right hg₁ hg₂ (e₁.symm.trans e₂)
|
no goals
|
8ad53d89c26ce87e
|
MeasureTheory.upcrossingStrat_le_one
|
Mathlib/Probability/Martingale/Upcrossing.lean
|
theorem upcrossingStrat_le_one : upcrossingStrat a b f N n ω ≤ 1
|
case h.inr
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
N n : ℕ
ω : Ω
i : ℕ
a✝¹ : i ∈ ↑(Finset.range N)
j : ℕ
a✝ : j ∈ ↑(Finset.range N)
hij : i ≠ j
hij' : i > j
⊢ upperCrossingTime a b f N (i + 1) ω ⊓ upperCrossingTime a b f N (j + 1) ω ≤
lowerCrossingTime a b f N i ω ⊔ lowerCrossingTime a b f N j ω
|
rw [gt_iff_lt] at hij'
|
case h.inr
Ω : Type u_1
a b : ℝ
f : ℕ → Ω → ℝ
N n : ℕ
ω : Ω
i : ℕ
a✝¹ : i ∈ ↑(Finset.range N)
j : ℕ
a✝ : j ∈ ↑(Finset.range N)
hij : i ≠ j
hij' : j < i
⊢ upperCrossingTime a b f N (i + 1) ω ⊓ upperCrossingTime a b f N (j + 1) ω ≤
lowerCrossingTime a b f N i ω ⊔ lowerCrossingTime a b f N j ω
|
754b6de81a111619
|
Ideal.iSup_iInf_eq_top_iff_pairwise
|
Mathlib/RingTheory/Coprime/Ideal.lean
|
theorem iSup_iInf_eq_top_iff_pairwise {t : Finset ι} (h : t.Nonempty) (I : ι → Ideal R) :
(⨆ i ∈ t, ⨅ (j) (_ : j ∈ t) (_ : j ≠ i), I j) = ⊤ ↔
(t : Set ι).Pairwise fun i j => I i ⊔ I j = ⊤
|
case refine_1.refine_2
ι : Type u_1
R : Type u_2
inst✝ : CommSemiring R
I : ι → Ideal R
this : DecidableEq ι
a : ι
⊢ ↑((fun i => if h : i = a then ⟨1, ⋯⟩ else 0) a) = 1
|
simp only [dif_pos, Submodule.coe_mk, eq_self_iff_true]
|
no goals
|
814176ce92e42d47
|
AlgebraicGeometry.Scheme.PartialMap.equiv_of_fromSpecStalkOfMem_eq
|
Mathlib/AlgebraicGeometry/RationalMap.lean
|
lemma equiv_of_fromSpecStalkOfMem_eq [IrreducibleSpace X]
{x : X} [X.IsGermInjectiveAt x] (f g : X.PartialMap Y)
(hxf : x ∈ f.domain) (hxg : x ∈ g.domain)
(H : f.fromSpecStalkOfMem hxf = g.fromSpecStalkOfMem hxg) : f.equiv g
|
case refine_2.intro.intro
X Y : Scheme
inst✝¹ : IrreducibleSpace ↑↑X.toPresheafedSpace
x : ↑↑X.toPresheafedSpace
inst✝ : X.IsGermInjectiveAt x
f g : X.PartialMap Y
hxf : x ∈ f.domain
hxg : x ∈ g.domain
H : f.fromSpecStalkOfMem hxf = g.fromSpecStalkOfMem hxg
hdense : Dense (↑f.domain ⊓ ↑g.domain)
this : (↑(f.domain ⊓ g.domain)).IsGermInjectiveAt ⟨x, ⋯⟩
U : (↑(f.domain ⊓ g.domain)).Opens
hxU : ⟨x, ⋯⟩ ∈ U
e : U.ι ≫ X.homOfLE ⋯ ≫ f.hom = U.ι ≫ X.homOfLE ⋯ ≫ g.hom
⊢ (f.restrict ((f.domain ⊓ g.domain).ι ''ᵁ U) ⋯ ⋯).hom = (g.restrict ((f.domain ⊓ g.domain).ι ''ᵁ U) ⋯ ⋯).hom
|
rw [← cancel_epi (Scheme.Hom.isoImage _ _).hom]
|
case refine_2.intro.intro
X Y : Scheme
inst✝¹ : IrreducibleSpace ↑↑X.toPresheafedSpace
x : ↑↑X.toPresheafedSpace
inst✝ : X.IsGermInjectiveAt x
f g : X.PartialMap Y
hxf : x ∈ f.domain
hxg : x ∈ g.domain
H : f.fromSpecStalkOfMem hxf = g.fromSpecStalkOfMem hxg
hdense : Dense (↑f.domain ⊓ ↑g.domain)
this : (↑(f.domain ⊓ g.domain)).IsGermInjectiveAt ⟨x, ⋯⟩
U : (↑(f.domain ⊓ g.domain)).Opens
hxU : ⟨x, ⋯⟩ ∈ U
e : U.ι ≫ X.homOfLE ⋯ ≫ f.hom = U.ι ≫ X.homOfLE ⋯ ≫ g.hom
⊢ (Hom.isoImage (f.domain ⊓ g.domain).ι U).hom ≫ (f.restrict ((f.domain ⊓ g.domain).ι ''ᵁ U) ⋯ ⋯).hom =
(Hom.isoImage (f.domain ⊓ g.domain).ι U).hom ≫ (g.restrict ((f.domain ⊓ g.domain).ι ''ᵁ U) ⋯ ⋯).hom
|
72b5375ab01aa1fb
|
AffineSubspace.direction_smul
|
Mathlib/LinearAlgebra/AffineSpace/Pointwise.lean
|
@[simp]
lemma direction_smul (ha : a ≠ 0) (s : AffineSubspace k V) : (a • s).direction = s.direction
|
case h
k : Type u_2
V : Type u_3
inst✝² : Field k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
a : k
ha : a ≠ 0
s : AffineSubspace k V
x✝ : V
⊢ (DistribMulAction.toLinearMap k V a) x✝ = (a • LinearMap.id) x✝
|
simp
|
no goals
|
5d1a1f476ddefbbc
|
Lean.Order.Array.monotone_forIn
|
Mathlib/.lake/packages/lean4/src/lean/Init/Internal/Order/Lemmas.lean
|
theorem monotone_forIn {α : Type uu}
(as : Array α) (init : β) (f : γ → (a : α) → β → m (ForInStep β)) (hmono : monotone f) :
monotone (fun x => forIn as init (f x))
|
m : Type u → Type v
inst✝³ : Monad m
inst✝² : (α : Type u) → PartialOrder (m α)
inst✝¹ : MonoBind m
β : Type u
γ : Type w
inst✝ : PartialOrder γ
α : Type uu
as : Array α
init : β
f : γ → α → β → m (ForInStep β)
hmono : monotone f
⊢ monotone fun x => forIn as init (f x)
|
apply monotone_forIn' as init _
|
m : Type u → Type v
inst✝³ : Monad m
inst✝² : (α : Type u) → PartialOrder (m α)
inst✝¹ : MonoBind m
β : Type u
γ : Type w
inst✝ : PartialOrder γ
α : Type uu
as : Array α
init : β
f : γ → α → β → m (ForInStep β)
hmono : monotone f
⊢ monotone fun x a x_1 => f x a
|
32bac149386f206c
|
IsLocalization.iff_map_piEvalRingHom
|
Mathlib/RingTheory/Localization/Pi.lean
|
theorem iff_map_piEvalRingHom [Finite ι] :
IsLocalization M S' ↔ IsLocalization (.pi .univ fun i ↦ M.map (Pi.evalRingHom R i)) S' :=
iff_of_le_of_exists_dvd M _ (fun m hm i _ ↦ ⟨m, hm, rfl⟩) fun n hn ↦ by
choose m mem eq using hn
have := Fintype.ofFinite ι
refine ⟨∏ i, m i ⟨⟩, prod_mem fun i _ ↦ mem i _, pi_dvd_iff.mpr fun i ↦ ?_⟩
rw [Fintype.prod_apply]
exact (eq i ⟨⟩).symm.dvd.trans (Finset.dvd_prod_of_mem _ <| Finset.mem_univ _)
|
ι : Type u_1
R : ι → Type u_2
inst✝³ : (i : ι) → CommSemiring (R i)
S' : Type u_4
inst✝² : CommSemiring S'
inst✝¹ : Algebra ((i : ι) → R i) S'
M : Submonoid ((i : ι) → R i)
inst✝ : Finite ι
n : (i : ι) → R i
m : (i : ι) → i ∈ Set.univ → (i : ι) → R i
mem : ∀ (i : ι) (a : i ∈ Set.univ), m i a ∈ ↑M
eq : ∀ (i : ι) (a : i ∈ Set.univ), (Pi.evalRingHom R i) (m i a) = n i
⊢ ∃ m ∈ M, n ∣ m
|
have := Fintype.ofFinite ι
|
ι : Type u_1
R : ι → Type u_2
inst✝³ : (i : ι) → CommSemiring (R i)
S' : Type u_4
inst✝² : CommSemiring S'
inst✝¹ : Algebra ((i : ι) → R i) S'
M : Submonoid ((i : ι) → R i)
inst✝ : Finite ι
n : (i : ι) → R i
m : (i : ι) → i ∈ Set.univ → (i : ι) → R i
mem : ∀ (i : ι) (a : i ∈ Set.univ), m i a ∈ ↑M
eq : ∀ (i : ι) (a : i ∈ Set.univ), (Pi.evalRingHom R i) (m i a) = n i
this : Fintype ι
⊢ ∃ m ∈ M, n ∣ m
|
94563de1ce9fcebf
|
LucasLehmer.norm_num_ext.testTrueHelper
|
Mathlib/NumberTheory/LucasLehmer.lean
|
lemma testTrueHelper (p : ℕ) (hp : Nat.blt 1 p = true) (h : sModNatTR (2 ^ p - 1) (p - 2) = 0) :
LucasLehmerTest p
|
p : ℕ
hp : 1 < p
h : sModNatTR (2 ^ p - 1) (p - 2) = 0
⊢ LucasLehmerTest p
|
rw [LucasLehmerTest, LucasLehmer.residue_eq_zero_iff_sMod_eq_zero p hp, ← sModNat_eq_sMod p _ hp,
← sModNatTR_eq_sModNat, h]
|
p : ℕ
hp : 1 < p
h : sModNatTR (2 ^ p - 1) (p - 2) = 0
⊢ ↑0 = 0
|
eaa9103b95197009
|
ContinuousMap.setOfIdeal_ofSet_eq_interior
|
Mathlib/Topology/ContinuousMap/Ideals.lean
|
theorem setOfIdeal_ofSet_eq_interior (s : Set X) : setOfIdeal (idealOfSet 𝕜 s) = interior s
|
X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
s : Set X
x : X
hx : x ∈ (closure sᶜ)ᶜ
g : C(X, ℝ)
hgs : Set.EqOn (⇑g) 0 (closure sᶜ)
hgx : Set.EqOn (⇑g) 1 {x}
⊢ ∀ ⦃x : X⦄, x ∈ sᶜ → { toFun := fun x => ↑(g x), continuous_toFun := ⋯ } x = 0
|
simpa only [coe_mk, ofReal_eq_zero] using fun x hx => hgs (subset_closure hx)
|
no goals
|
a35c4c838ab5318e
|
Part.ne_none_iff
|
Mathlib/Data/Part.lean
|
theorem ne_none_iff {o : Part α} : o ≠ none ↔ ∃ x, o = some x
|
case mp
α : Type u_1
o : Part α
⊢ o ≠ none → ∃ x, o = some x
|
rw [Ne, eq_none_iff', not_not]
|
case mp
α : Type u_1
o : Part α
⊢ o.Dom → ∃ x, o = some x
|
8b4d3dd1ed4af4f0
|
mellin_inversion
|
Mathlib/Analysis/MellinInversion.lean
|
theorem mellin_inversion (σ : ℝ) (f : ℝ → E) {x : ℝ} (hx : 0 < x) (hf : MellinConvergent f σ)
(hFf : VerticalIntegrable (mellin f) σ) (hfx : ContinuousAt f x) :
mellinInv σ (mellin f) x = f x
|
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
σ : ℝ
f : ℝ → E
x : ℝ
hx : 0 < x
hFf : VerticalIntegrable (mellin f) σ volume
hfx : ContinuousAt f x
g : ℝ → E := fun u => rexp (-σ * u) • f (rexp (-u))
hf : Integrable g volume
⊢ Integrable (𝓕 g) volume
|
have h2π : 2 * π ≠ 0 := by norm_num; exact pi_ne_zero
|
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
σ : ℝ
f : ℝ → E
x : ℝ
hx : 0 < x
hFf : VerticalIntegrable (mellin f) σ volume
hfx : ContinuousAt f x
g : ℝ → E := fun u => rexp (-σ * u) • f (rexp (-u))
hf : Integrable g volume
h2π : 2 * π ≠ 0
⊢ Integrable (𝓕 g) volume
|
eb76f337444b2548
|
Finsupp.lmapDomain_supported
|
Mathlib/LinearAlgebra/Finsupp/Supported.lean
|
theorem lmapDomain_supported (f : α → α') (s : Set α) :
(supported M R s).map (lmapDomain M R f) = supported M R (f '' s)
|
case inr
α : Type u_1
M : Type u_2
R : Type u_5
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
α' : Type u_7
f : α → α'
s : Set α
h✝ : Nonempty α
⊢ map (lmapDomain M R f) (supported M R s) = supported M R (f '' s)
|
refine
le_antisymm
(map_le_iff_le_comap.2 <|
le_trans (supported_mono <| Set.subset_preimage_image _ _)
(supported_comap_lmapDomain M R _ _))
?_
|
case inr
α : Type u_1
M : Type u_2
R : Type u_5
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
α' : Type u_7
f : α → α'
s : Set α
h✝ : Nonempty α
⊢ supported M R (f '' s) ≤ map (lmapDomain M R f) (supported M R s)
|
b5dabd5eeb5a8ed9
|
MeasurableSpace.measurableSet_injective
|
Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
|
theorem MeasurableSpace.measurableSet_injective : Injective (@MeasurableSet α)
| ⟨_, _, _, _⟩, ⟨_, _, _, _⟩, _ => by congr
|
α : Type u_1
MeasurableSet'✝¹ : Set α → Prop
measurableSet_empty✝¹ : MeasurableSet'✝¹ ∅
measurableSet_compl✝¹ : ∀ (s : Set α), MeasurableSet'✝¹ s → MeasurableSet'✝¹ sᶜ
measurableSet_iUnion✝¹ : ∀ (f : ℕ → Set α), (∀ (i : ℕ), MeasurableSet'✝¹ (f i)) → MeasurableSet'✝¹ (⋃ i, f i)
MeasurableSet'✝ : Set α → Prop
measurableSet_empty✝ : MeasurableSet'✝ ∅
measurableSet_compl✝ : ∀ (s : Set α), MeasurableSet'✝ s → MeasurableSet'✝ sᶜ
measurableSet_iUnion✝ : ∀ (f : ℕ → Set α), (∀ (i : ℕ), MeasurableSet'✝ (f i)) → MeasurableSet'✝ (⋃ i, f i)
x✝ : MeasurableSet = MeasurableSet
⊢ { MeasurableSet' := MeasurableSet'✝¹, measurableSet_empty := measurableSet_empty✝¹,
measurableSet_compl := measurableSet_compl✝¹, measurableSet_iUnion := measurableSet_iUnion✝¹ } =
{ MeasurableSet' := MeasurableSet'✝, measurableSet_empty := measurableSet_empty✝,
measurableSet_compl := measurableSet_compl✝, measurableSet_iUnion := measurableSet_iUnion✝ }
|
congr
|
no goals
|
7bfabe7d36364237
|
Polynomial.comap_C_surjective
|
Mathlib/RingTheory/Spectrum/Prime/Polynomial.lean
|
lemma comap_C_surjective : Function.Surjective (comap (R := R) C)
|
R : Type u_1
inst✝ : CommRing R
x : PrimeSpectrum R
⊢ ∃ a, (comap C) a = x
|
refine ⟨comap (evalRingHom 0) x, ?_⟩
|
R : Type u_1
inst✝ : CommRing R
x : PrimeSpectrum R
⊢ (comap C) ((comap (evalRingHom 0)) x) = x
|
a38f7d5d2f40ea08
|
SetTheory.PGame.subsingleton_short_example
|
Mathlib/SetTheory/Game/Short.lean
|
theorem subsingleton_short_example : ∀ x : PGame, Subsingleton (Short x)
| mk xl xr xL xR =>
⟨fun a b => by
cases a; cases b
congr!
· funext x
apply @Subsingleton.elim _ (subsingleton_short_example (xL x))
-- Decreasing goal in Lean 4 is `Subsequent (xL x) (mk α β L R)`
-- where `α`, `β`, `L`, and `R` are fresh hypotheses only propositionally
-- equal to `xl`, `xr`, `xL`, and `xR`.
-- (In Lean 3 it was `(mk xl xr xL xR)` instead.)
· funext x
apply @Subsingleton.elim _ (subsingleton_short_example (xR x))⟩
termination_by x => x
-- We need to unify a bunch of hypotheses before `pgame_wf_tac` can work.
decreasing_by all_goals {
subst_vars
simp only [mk.injEq, heq_eq_eq, true_and] at *
casesm* _ ∧ _
subst_vars
pgame_wf_tac
}
|
α✝ β✝ : Type u_1
L✝ : α✝ → PGame
R✝ : β✝ → PGame
L xL : α✝ → PGame
inst✝³ : Fintype α✝
x✝⁵ : (i : α✝) → (xL i).Short
inst✝² : Fintype α✝
x✝⁴ : (i : α✝) → (xL i).Short
R xR : β✝ → PGame
inst✝¹ : Fintype β✝
x✝³ : (j : β✝) → (xR j).Short
inst✝ : Fintype β✝
x✝² : (j : β✝) → (xR j).Short
x : β✝
x✝¹ : ∀ (y : PGame), (invImage (fun x => x) instWellFoundedRelation).1 y (mk α✝ β✝ L R) → Subsingleton y.Short
x✝ : ∀ (y : PGame), (invImage (fun x => x) instWellFoundedRelation).1 y (mk α✝ β✝ xL xR) → Subsingleton y.Short
h✝¹ : mk α✝ β✝ xL xR = mk α✝ β✝ L R
h✝ : mk α✝ β✝ xL xR = mk α✝ β✝ L✝ R✝
⊢ (xR x).Subsequent (mk α✝ β✝ L R)
|
simp only [mk.injEq, heq_eq_eq, true_and] at *
|
α✝ β✝ : Type u_1
L✝ : α✝ → PGame
R✝ : β✝ → PGame
L xL : α✝ → PGame
inst✝³ : Fintype α✝
x✝⁵ : (i : α✝) → (xL i).Short
inst✝² : Fintype α✝
x✝⁴ : (i : α✝) → (xL i).Short
R xR : β✝ → PGame
inst✝¹ : Fintype β✝
x✝³ : (j : β✝) → (xR j).Short
inst✝ : Fintype β✝
x✝² : (j : β✝) → (xR j).Short
x : β✝
x✝¹ : ∀ (y : PGame), InvImage WellFoundedRelation.rel (fun x => x) y (mk α✝ β✝ L R) → Subsingleton y.Short
x✝ : ∀ (y : PGame), InvImage WellFoundedRelation.rel (fun x => x) y (mk α✝ β✝ xL xR) → Subsingleton y.Short
h✝¹ : xL = L ∧ xR = R
h✝ : xL = L✝ ∧ xR = R✝
⊢ (xR x).Subsequent (mk α✝ β✝ L R)
|
6d51ac4df0c8eec6
|
SimplexCategory.eq_id_of_epi
|
Mathlib/AlgebraicTopology/SimplexCategory/Basic.lean
|
theorem eq_id_of_epi {x : SimplexCategory} (i : x ⟶ x) [Epi i] : i = 𝟙 _
|
case hf
x : SimplexCategory
i : x ⟶ x
inst✝ : Epi i
⊢ Function.Bijective ⇑(Hom.toOrderHom i)
|
rw [Fintype.bijective_iff_surjective_and_card i.toOrderHom, ← epi_iff_surjective,
eq_self_iff_true, and_true]
|
case hf
x : SimplexCategory
i : x ⟶ x
inst✝ : Epi i
⊢ Epi i
|
235eb9dd9a765d3a
|
Std.DHashMap.Internal.Raw₀.getKey_erase
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/RawLemmas.lean
|
theorem getKey_erase [EquivBEq α] [LawfulHashable α] (h : m.1.WF) {k a : α} {h'} :
(m.erase k).getKey a h' = m.getKey a (contains_of_contains_erase _ h h')
|
α : Type u
β : α → Type v
m : Raw₀ α β
inst✝³ : BEq α
inst✝² : Hashable α
inst✝¹ : EquivBEq α
inst✝ : LawfulHashable α
h : m.val.WF
k a : α
h' : (m.erase k).contains a = true
⊢ (m.erase k).getKey a h' = m.getKey a ⋯
|
simp_to_model [erase] using List.getKey_eraseKey
|
no goals
|
688c5bcf80adbc8f
|
CStarAlgebra.nnnorm_sub_mul_self_le
|
Mathlib/Analysis/CStarAlgebra/ApproximateUnit.lean
|
/-- This is a common reasoning sequence in C⋆-algebra theory. If `0 ≤ x ≤ y ≤ 1`, then the norm of
`z - y * z` is controlled by the norm of `star z * (1 - x) * z`, which is advantageous because the
latter is nonnegative. This is a key step in establishing the existence of an increasing approximate
unit in general C⋆-algebras. -/
lemma nnnorm_sub_mul_self_le {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
{x y : A} (z : A) (hx₀ : 0 ≤ x) (hy : y ∈ Set.Icc x 1) {c : ℝ≥0}
(h : ‖star z * (1 - x) * z‖₊ ≤ c ^ 2) :
‖z - y * z‖₊ ≤ c
|
A : Type u_2
inst✝² : CStarAlgebra A
inst✝¹ : PartialOrder A
inst✝ : StarOrderedRing A
x y z : A
hx₀ : 0 ≤ x
hy : y ∈ Set.Icc x 1
c : ℝ≥0
h : ‖star z * (1 - x) * z‖₊ ≤ c ^ 2
⊢ ‖star z * (1 - star y) * ((1 - y) * z)‖₊ ≤ c ^ 2
|
have hy₀ : y ∈ Set.Icc 0 1 := ⟨hx₀.trans hy.1, hy.2⟩
|
A : Type u_2
inst✝² : CStarAlgebra A
inst✝¹ : PartialOrder A
inst✝ : StarOrderedRing A
x y z : A
hx₀ : 0 ≤ x
hy : y ∈ Set.Icc x 1
c : ℝ≥0
h : ‖star z * (1 - x) * z‖₊ ≤ c ^ 2
hy₀ : y ∈ Set.Icc 0 1
⊢ ‖star z * (1 - star y) * ((1 - y) * z)‖₊ ≤ c ^ 2
|
15d297d9f0844bcb
|
List.of_findIdx?_eq_none
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Find.lean
|
theorem of_findIdx?_eq_none {xs : List α} {p : α → Bool} (w : xs.findIdx? p = none) :
∀ i : Nat, match xs[i]? with | some a => ¬ p a | none => true
|
case cons
α : Type u_1
p : α → Bool
x : α
xs : List α
i : Nat
ih :
findIdx? p xs = none →
∀ (i : Nat),
match xs[i]? with
| some a => p a = false
| none => True
w : (if p x = true then some 0 else Option.map (fun i => i + 1) (findIdx? p xs)) = none
⊢ match (x :: xs)[i]? with
| some a => p a = false
| none => True
|
cases i with
| zero =>
split at w <;> simp_all
| succ i =>
simp only [getElem?_cons_succ]
apply ih
split at w <;> simp_all
|
no goals
|
d56cb53d2789be3d
|
Substring.ValidFor.nextn
|
Mathlib/.lake/packages/batteries/Batteries/Data/String/Lemmas.lean
|
theorem nextn : ∀ {s}, ValidFor l (m₁ ++ m₂) r s →
∀ n, s.nextn n ⟨utf8Len m₁⟩ = ⟨utf8Len m₁ + utf8Len (m₂.take n)⟩
| _, _, 0 => by simp [Substring.nextn]
| s, h, n+1 => by
simp only [Substring.nextn]
match m₂ with
| [] => simp at h; simp [h.next_stop, h.nextn_stop]
| c::m₂ =>
rw [h.next]
have := @nextn l (m₁ ++ [c]) m₂ r s (by simp [h]) n
simp at this; rw [this]; simp [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm]
|
l m₁ m₂✝ r : List Char
s : Substring
n : Nat
c : Char
m₂ : List Char
h : ValidFor l (m₁ ++ c :: m₂) r s
this :
s.nextn n { byteIdx := utf8Len m₁ + c.utf8Size } = { byteIdx := utf8Len m₁ + c.utf8Size + utf8Len (List.take n m₂) }
⊢ { byteIdx := utf8Len m₁ + c.utf8Size + utf8Len (List.take n m₂) } =
{ byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) (c :: m₂)) }
|
simp [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm]
|
no goals
|
52154dc030661365
|
Real.exists_natCast_add_one_lt_pow_of_one_lt
|
Mathlib/Data/Real/Archimedean.lean
|
/-- Exponentiation is eventually larger than linear growth. -/
lemma exists_natCast_add_one_lt_pow_of_one_lt (ha : 1 < a) : ∃ m : ℕ, (m + 1 : ℝ) < a ^ m
|
a : ℝ
ha : 1 < a
⊢ ∃ m, ↑m + 1 < a ^ m
|
obtain ⟨k, posk, hk⟩ : ∃ k : ℕ, 0 < k ∧ 1 / k + 1 < a := by
contrapose! ha
refine le_of_forall_lt_rat_imp_le ?_
intro q hq
refine (ha q.den (by positivity)).trans ?_
rw [← le_sub_iff_add_le, div_le_iff₀ (by positivity), sub_mul, one_mul]
norm_cast at hq ⊢
rw [← q.num_div_den, one_lt_div (by positivity)] at hq
rw [q.mul_den_eq_num]
norm_cast at hq ⊢
omega
|
case intro.intro
a : ℝ
ha : 1 < a
k : ℕ
posk : 0 < k
hk : 1 / ↑k + 1 < a
⊢ ∃ m, ↑m + 1 < a ^ m
|
62482ea338b44352
|
CliffordAlgebraComplex.ofComplex_comp_toComplex
|
Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
|
theorem ofComplex_comp_toComplex : ofComplex.comp toComplex = AlgHom.id ℝ (CliffordAlgebra Q)
|
case a.h
⊢ ((ofComplex.comp toComplex).toLinearMap ∘ₗ ι Q) 1 = ((AlgHom.id ℝ (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q) 1
|
dsimp only [LinearMap.comp_apply, Subtype.coe_mk, AlgHom.id_apply, AlgHom.toLinearMap_apply,
AlgHom.comp_apply]
|
case a.h
⊢ ofComplex (toComplex ((ι Q) 1)) = (ι Q) 1
|
6e16e9494689a2d6
|
Submodule.span_induction₂
|
Mathlib/LinearAlgebra/Span/Defs.lean
|
theorem span_induction₂ {N : Type*} [AddCommMonoid N] [Module R N] {t : Set N}
{p : (x : M) → (y : N) → x ∈ span R s → y ∈ span R t → Prop}
(mem_mem : ∀ (x) (y) (hx : x ∈ s) (hy : y ∈ t), p x y (subset_span hx) (subset_span hy))
(zero_left : ∀ y hy, p 0 y (zero_mem _) hy) (zero_right : ∀ x hx, p x 0 hx (zero_mem _))
(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))
(smul_left : ∀ (r : R) x y hx hy, p x y hx hy → p (r • x) y (smul_mem _ r hx) hy)
(smul_right : ∀ (r : R) x y hx hy, p x y hx hy → p x (r • y) hx (smul_mem _ r hy))
{a : M} {b : N} (ha : a ∈ Submodule.span R s)
(hb : b ∈ Submodule.span R t) : p a b ha hb
|
case add
R : Type u_1
M : Type u_4
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
s : Set M
N : Type u_9
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
t : Set N
p : (x : M) → (y : N) → x ∈ span R s → y ∈ span R t → Prop
mem_mem : ∀ (x : M) (y : N) (hx : x ∈ s) (hy : y ∈ t), p x y ⋯ ⋯
zero_left : ∀ (y : N) (hy : y ∈ span R t), p 0 y ⋯ hy
zero_right : ∀ (x : M) (hx : x ∈ span R s), p x 0 hx ⋯
add_left :
∀ (x y : M) (z : N) (hx : x ∈ span R s) (hy : y ∈ span R s) (hz : z ∈ span R t),
p x z hx hz → p y z hy hz → p (x + y) z ⋯ hz
add_right :
∀ (x : M) (y z : N) (hx : x ∈ span R s) (hy : y ∈ span R t) (hz : z ∈ span R t),
p x y hx hy → p x z hx hz → p x (y + z) hx ⋯
smul_left : ∀ (r : R) (x : M) (y : N) (hx : x ∈ span R s) (hy : y ∈ span R t), p x y hx hy → p (r • x) y ⋯ hy
smul_right : ∀ (r : R) (x : M) (y : N) (hx : x ∈ span R s) (hy : y ∈ span R t), p x y hx hy → p x (r • y) hx ⋯
a : M
b : N
ha : a ∈ span R s
x✝ y✝ : N
hx✝ : x✝ ∈ span R t
hy✝ : y✝ ∈ span R t
h₁ : p a x✝ ha hx✝
h₂ : p a y✝ ha hy✝
⊢ p a (x✝ + y✝) ha ⋯
|
exact add_right _ _ _ _ _ _ h₁ h₂
|
no goals
|
01464e356200a5dc
|
MeasureTheory.OuterMeasure.le_boundedBy
|
Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
|
theorem le_boundedBy {μ : OuterMeasure α} : μ ≤ boundedBy m ↔ ∀ s, μ s ≤ m s
|
α : Type u_1
m : Set α → ℝ≥0∞
μ : OuterMeasure α
s : Set α
⊢ μ s ≤ ⨆ (_ : s.Nonempty), m s ↔ μ s ≤ m s
|
rcases s.eq_empty_or_nonempty with h | h <;> simp [h, Set.not_nonempty_empty]
|
no goals
|
183b093e01d98013
|
ProbabilityTheory.strong_law_aux5
|
Mathlib/Probability/StrongLaw.lean
|
theorem strong_law_aux5 :
∀ᵐ ω, (fun n : ℕ => ∑ i ∈ range n, truncation (X i) i ω - ∑ i ∈ range n, X i ω) =o[atTop]
fun n : ℕ => (n : ℝ)
|
Ω : Type u_1
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : ℕ → Ω → ℝ
hint : Integrable (X 0) ℙ
hident : ∀ (i : ℕ), IdentDistrib (X i) (X 0) ℙ ℙ
hnonneg : ∀ (i : ℕ) (ω : Ω), 0 ≤ X i ω
A : ∑' (j : ℕ), ℙ {ω | X j ω ∈ Set.Ioi ↑j} < ⊤
ω : Ω
hω : ∀ᶠ (n : ℕ) in atTop, X n ω ∉ Set.Ioi ↑n
n : ℕ
hn : X n ω ∉ Set.Ioi ↑n
npos : n ∈ Set.Ioi 0
h : ¬(-↑n < X n ω ∧ X n ω ≤ ↑n)
⊢ -↑n < X n ω
|
apply lt_of_lt_of_le _ (hnonneg n ω)
|
Ω : Type u_1
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : ℕ → Ω → ℝ
hint : Integrable (X 0) ℙ
hident : ∀ (i : ℕ), IdentDistrib (X i) (X 0) ℙ ℙ
hnonneg : ∀ (i : ℕ) (ω : Ω), 0 ≤ X i ω
A : ∑' (j : ℕ), ℙ {ω | X j ω ∈ Set.Ioi ↑j} < ⊤
ω : Ω
hω : ∀ᶠ (n : ℕ) in atTop, X n ω ∉ Set.Ioi ↑n
n : ℕ
hn : X n ω ∉ Set.Ioi ↑n
npos : n ∈ Set.Ioi 0
h : ¬(-↑n < X n ω ∧ X n ω ≤ ↑n)
⊢ -↑n < 0
|
89dd352ac6ec4b05
|
Ordinal.le_of_dvd
|
Mathlib/SetTheory/Ordinal/Arithmetic.lean
|
theorem le_of_dvd : ∀ {a b : Ordinal}, b ≠ 0 → a ∣ b → a ≤ b
-- Porting note: `⟨b, rfl⟩ => by` → `⟨b, e⟩ => by subst e`
| a, _, b0, ⟨b, e⟩ => by
subst e
-- Porting note: `Ne` is required.
simpa only [mul_one] using
mul_le_mul_left'
(one_le_iff_ne_zero.2 fun h : b = 0 => by
simp only [h, mul_zero, Ne, not_true_eq_false] at b0) a
|
a b : Ordinal.{u_4}
b0 : a * b ≠ 0
h : b = 0
⊢ False
|
simp only [h, mul_zero, Ne, not_true_eq_false] at b0
|
no goals
|
0fe35c6d81df8019
|
starConvex_iff_forall_ne_pos
|
Mathlib/Analysis/Convex/Star.lean
|
theorem starConvex_iff_forall_ne_pos (hx : x ∈ s) :
StarConvex 𝕜 x s ↔
∀ ⦃y⦄, y ∈ s → x ≠ y → ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s
|
case inl
𝕜 : Type u_1
E : Type u_2
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
x : E
s : Set E
hx : x ∈ s
h : ∀ ⦃y : E⦄, y ∈ s → x ≠ y → ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s
y : E
hy : y ∈ s
b : 𝕜
hb : 0 ≤ b
ha : 0 ≤ 0
hab : 0 + b = 1
⊢ 0 • x + b • y ∈ s
|
rw [zero_add] at hab
|
case inl
𝕜 : Type u_1
E : Type u_2
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
x : E
s : Set E
hx : x ∈ s
h : ∀ ⦃y : E⦄, y ∈ s → x ≠ y → ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s
y : E
hy : y ∈ s
b : 𝕜
hb : 0 ≤ b
ha : 0 ≤ 0
hab : b = 1
⊢ 0 • x + b • y ∈ s
|
23990e0ad8bbd28b
|
List.mem_eraseIdx_iff_getElem?
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Nat/Basic.lean
|
theorem mem_eraseIdx_iff_getElem? {x : α} {l} {k} : x ∈ eraseIdx l k ↔ ∃ i ≠ k, l[i]? = some x
|
case mpr.intro
α : Type u_1
x : α
l : List α
k i : Nat
h : l[i]? = some x
h' : i < l.length
⊢ ∃ x_1, l[i]? = some x
|
exact ⟨h', h⟩
|
no goals
|
b696caa5872e7aba
|
PrincipalSeg.eq
|
Mathlib/Order/InitialSeg.lean
|
theorem eq [IsWellOrder β s] (f g : r ≺i s) (a) : f a = g a
|
α : Type u_1
β : Type u_2
r : α → α → Prop
s : β → β → Prop
inst✝ : IsWellOrder β s
f g : r ≺i s
a : α
⊢ f.toRelEmbedding a = g.toRelEmbedding a
|
rw [Subsingleton.elim f g]
|
no goals
|
ba22f4fac7e87dc5
|
ProbabilityTheory.Kernel.indepSets_piiUnionInter_of_disjoint
|
Mathlib/Probability/Independence/Kernel.lean
|
theorem indepSets_piiUnionInter_of_disjoint {s : ι → Set (Set Ω)}
{S T : Set ι} (h_indep : iIndepSets s κ μ) (hST : Disjoint S T) :
IndepSets (piiUnionInter s S) (piiUnionInter s T) κ μ
|
case inr
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
s : ι → Set (Set Ω)
S T : Set ι
h_indep : iIndepSets s κ μ
hST : Disjoint S T
t1 t2 : Set Ω
p1 : Finset ι
hp1 : ↑p1 ⊆ S
f1 : ι → Set Ω
ht1_m : ∀ x ∈ p1, f1 x ∈ s x
ht1_eq : t1 = ⋂ x ∈ p1, f1 x
p2 : Finset ι
hp2 : ↑p2 ⊆ T
f2 : ι → Set Ω
ht2_m : ∀ x ∈ p2, f2 x ∈ s x
ht2_eq : t2 = ⋂ x ∈ p2, f2 x
g : ι → Set Ω := fun i => (if i ∈ p1 then f1 i else univ) ∩ if i ∈ p2 then f2 i else univ
i : ι
hi2 : i ∈ p2
⊢ g i ∈ s i
|
have hi1 : i ∉ p1 := fun hip1 => Set.disjoint_right.mp hST (hp2 hi2) (hp1 hip1)
|
case inr
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
s : ι → Set (Set Ω)
S T : Set ι
h_indep : iIndepSets s κ μ
hST : Disjoint S T
t1 t2 : Set Ω
p1 : Finset ι
hp1 : ↑p1 ⊆ S
f1 : ι → Set Ω
ht1_m : ∀ x ∈ p1, f1 x ∈ s x
ht1_eq : t1 = ⋂ x ∈ p1, f1 x
p2 : Finset ι
hp2 : ↑p2 ⊆ T
f2 : ι → Set Ω
ht2_m : ∀ x ∈ p2, f2 x ∈ s x
ht2_eq : t2 = ⋂ x ∈ p2, f2 x
g : ι → Set Ω := fun i => (if i ∈ p1 then f1 i else univ) ∩ if i ∈ p2 then f2 i else univ
i : ι
hi2 : i ∈ p2
hi1 : i ∉ p1
⊢ g i ∈ s i
|
139cefbe3a1213c8
|
MeasureTheory.LevyProkhorov.continuous_equiv_probabilityMeasure
|
Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
|
/-- The identity map `LevyProkhorov (ProbabilityMeasure Ω) → ProbabilityMeasure Ω` is continuous. -/
lemma LevyProkhorov.continuous_equiv_probabilityMeasure :
Continuous (LevyProkhorov.equiv (α := ProbabilityMeasure Ω))
|
case h.refine_4.bc
Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : PseudoMetricSpace Ω
inst✝ : OpensMeasurableSpace Ω
μs : ℕ → LevyProkhorov (ProbabilityMeasure Ω)
ν : LevyProkhorov (ProbabilityMeasure Ω)
hμs : Tendsto μs atTop (𝓝 ν)
P : ProbabilityMeasure Ω := (equiv (ProbabilityMeasure Ω)) ν
Ps : ℕ → ProbabilityMeasure Ω := fun n => (equiv (ProbabilityMeasure Ω)) (μs n)
f✝ f : Ω →ᵇ ℝ
f_nn : 0 ≤ f
f_zero : ¬‖f‖ = 0
norm_f_pos : 0 < ‖f‖
δ : ℝ
δ_pos : 0 < δ
εs : ℕ → ℝ
left✝ : StrictAnti εs
εs_lim : Tendsto εs atTop (𝓝 0)
ε_of_room : Tendsto (fun x => dist (μs x) ν + εs x) atTop (𝓝 0)
ε_of_room' : Tendsto (fun n => dist (μs n) ν + εs n) atTop (𝓝[>] 0)
key :
Tendsto
((fun ε => ∫ (t : ℝ) in Ioc 0 ‖f‖, (↑(P (thickening ε {a | t ≤ f a}))).toReal) ∘ fun n => dist (μs n) ν + εs n)
atTop (𝓝 (∫ (t : ℝ) in Ioc 0 ‖f‖, (↑(P {a | t ≤ f a})).toReal))
aux : ∀ (z : ℝ), Iio (z + δ / 2) ∈ 𝓝 z
n : ℕ
hn :
((fun ε => ∫ (t : ℝ) in Ioc 0 ‖f‖, (↑(P (thickening ε {a | t ≤ f a}))).toReal) ∘ fun n => dist (μs n) ν + εs n) n <
(∫ (t : ℝ) in Ioc 0 ‖f‖, (↑(P {a | t ≤ f a})).toReal) + δ / 2
hn' : dist (μs n) ν + εs n < ‖f‖⁻¹ * δ / 2
εs_pos : 0 < εs n
bound :
∫ (ω : Ω), f ω ∂↑(Ps n) ≤
(∫ (t : ℝ) in Ioc 0 ‖f‖, (↑P (thickening (dist (μs n) ν + εs n) {a | t ≤ f a})).toReal) +
(dist (μs n) ν + εs n) * ‖f‖
⊢ δ / 2 + ‖f‖ * (dist (μs n) ν + εs n) ≤ δ
|
calc
δ / 2 + ‖f‖ * (dist (μs n) ν + εs n)
_ ≤ δ / 2 + ‖f‖ * (‖f‖⁻¹ * δ / 2) := by gcongr
_ = δ := by field_simp; ring
|
no goals
|
e3f8df53302ac07c
|
MeasureTheory.L1.setToL1_zero_left'
|
Mathlib/MeasureTheory/Integral/SetToL1.lean
|
theorem setToL1_zero_left' (hT : DominatedFinMeasAdditive μ T C)
(h_zero : ∀ s, MeasurableSet s → μ s < ∞ → T s = 0) (f : α →₁[μ] E) : setToL1 hT f = 0
|
case h
α : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T : Set α → E →L[ℝ] F
C : ℝ
hT : DominatedFinMeasAdditive μ T C
h_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → T s = 0
f✝ : ↥(Lp E 1 μ)
f : ↥(simpleFunc E 1 μ)
⊢ (ContinuousLinearMap.comp 0 (coeToLp α E ℝ)) f = (setToL1SCLM α E μ hT) f
|
rw [setToL1SCLM_zero_left' hT h_zero f, ContinuousLinearMap.zero_comp,
ContinuousLinearMap.zero_apply]
|
no goals
|
245a78bf3c494998
|
LindemannWeierstrass.exp_polynomial_approx_aux
|
Mathlib/NumberTheory/Transcendental/Lindemann/Init/AnalyticalPart.lean
|
theorem exp_polynomial_approx_aux (f : ℤ[X]) (s : ℂ) :
∃ c ≥ 0,
∀ p ≠ 0, ‖P (map (algebraMap ℤ ℂ) (X ^ (p - 1) * f ^ p)) s‖ ≤ c ^ p
|
case intro
f : ℤ[X]
s : ℂ
this : Bornology.IsBounded ((fun x => (x * ‖s‖ ⊔ 1) * ‖(aeval (↑x * s)) f‖) '' Set.Ioc 0 1)
c : ℝ
p : ℕ
x : ℝ
hx : x ∈ Set.Ioc 0 1
h : |(x * ‖s‖ ⊔ 1) * ‖(aeval (↑x * s)) f‖| ≤ c
⊢ ‖eval (x • s) (map (algebraMap ℤ ℂ) (X ^ (p - 1) * f ^ p))‖ ≤ c ^ p
|
refine le_trans ?_ (pow_le_pow_left₀ (abs_nonneg _) h _)
|
case intro
f : ℤ[X]
s : ℂ
this : Bornology.IsBounded ((fun x => (x * ‖s‖ ⊔ 1) * ‖(aeval (↑x * s)) f‖) '' Set.Ioc 0 1)
c : ℝ
p : ℕ
x : ℝ
hx : x ∈ Set.Ioc 0 1
h : |(x * ‖s‖ ⊔ 1) * ‖(aeval (↑x * s)) f‖| ≤ c
⊢ ‖eval (x • s) (map (algebraMap ℤ ℂ) (X ^ (p - 1) * f ^ p))‖ ≤ |(x * ‖s‖ ⊔ 1) * ‖(aeval (↑x * s)) f‖| ^ p
|
0670d5e568c4c9db
|
MeasureTheory.IsStoppingTime.measurableSet_lt
|
Mathlib/Probability/Process/Stopping.lean
|
theorem IsStoppingTime.measurableSet_lt (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | τ ω < i}
|
case intro.inr
Ω : Type u_1
ι : Type u_3
m : MeasurableSpace Ω
inst✝³ : LinearOrder ι
f : Filtration ι m
τ : Ω → ι
inst✝² : TopologicalSpace ι
inst✝¹ : OrderTopology ι
inst✝ : FirstCountableTopology ι
hτ : IsStoppingTime f τ
i i' : ι
hi'_lub : IsLUB (Set.Iio i) i'
h_Iio_eq_Iic : Set.Iio i = Set.Iic i'
h_lt_eq_preimage : {ω | τ ω < i} = τ ⁻¹' Set.Iio i
⊢ MeasurableSet (τ ⁻¹' Set.Iic i')
|
exact f.mono (lub_Iio_le i hi'_lub) _ (hτ.measurableSet_le i')
|
no goals
|
426cbd39a96c6c6e
|
Nat.primeFactorsPiBij_surj
|
Mathlib/Algebra/Order/Antidiag/Nat.lean
|
theorem primeFactorsPiBij_surj (d n : ℕ) (hn : Squarefree n)
(t : Fin d → ℕ) (ht : t ∈ finMulAntidiag d n) : ∃ (g : _)
(hg : g ∈ pi n.primeFactors fun _ => univ), Nat.primeFactorsPiBij d n g hg = t
|
d n : ℕ
hn : Squarefree n
t : Fin d → ℕ
ht : t ∈ d.finMulAntidiag n
f : (p : ℕ) → p ∈ n.primeFactors → Fin d
hf : ∀ (p : ℕ) (hp : p ∈ n.primeFactors), (fun i => p ∣ t i) (f p hp)
hf_unique : ∀ (p : ℕ) (hp : p ∈ n.primeFactors) (y : Fin d), (fun i => p ∣ t i) y → y = f p hp
i : Fin d
this : t i ∣ n
⊢ ∏ a ∈ (t i).primeFactors, a = t i
|
exact prod_primeFactors_of_squarefree <| hn.squarefree_of_dvd this
|
no goals
|
2aabf1c65448b553
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.