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
|
|---|---|---|---|---|---|---|
LinearMap.commute_pow_left_of_commute
|
Mathlib/Algebra/Module/LinearMap/End.lean
|
theorem commute_pow_left_of_commute
[Semiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {σ₁₂ : R →+* R₂}
{f : M →ₛₗ[σ₁₂] M₂} {g : Module.End R M} {g₂ : Module.End R₂ M₂}
(h : g₂.comp f = f.comp g) (k : ℕ) : (g₂ ^ k).comp f = f.comp (g ^ k)
|
R : Type u_1
R₂ : Type u_2
M : Type u_4
M₂ : Type u_6
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Semiring R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
σ₁₂ : R →+* R₂
f : M →ₛₗ[σ₁₂] M₂
g : Module.End R M
g₂ : Module.End R₂ M₂
h : comp g₂ f = f.comp g
k : ℕ
⊢ comp (g₂ ^ k) f = f.comp (g ^ k)
|
induction k with
| zero => simp only [pow_zero, one_eq_id, id_comp, comp_id]
| succ k ih => rw [pow_succ', pow_succ', LinearMap.mul_eq_comp, LinearMap.comp_assoc, ih,
← LinearMap.comp_assoc, h, LinearMap.comp_assoc, LinearMap.mul_eq_comp]
|
no goals
|
b5769a82a32d21d9
|
BoundedContinuousFunction.nnnorm_eq_iSup_nnnorm
|
Mathlib/Topology/ContinuousMap/Bounded/Basic.lean
|
theorem nnnorm_eq_iSup_nnnorm : ‖f‖₊ = ⨆ x : α, ‖f x‖₊ :=
Subtype.ext <| (norm_eq_iSup_norm f).trans <| by simp_rw [val_eq_coe, NNReal.coe_iSup, coe_nnnorm]
|
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f : α →ᵇ β
⊢ ⨆ x, ‖f x‖ = ↑(⨆ x, ‖f x‖₊)
|
simp_rw [val_eq_coe, NNReal.coe_iSup, coe_nnnorm]
|
no goals
|
441fc6e8ef1fb666
|
List.rdropWhile_prefix
|
Mathlib/Data/List/DropRight.lean
|
theorem rdropWhile_prefix : l.rdropWhile p <+: l
|
α : Type u_1
p : α → Bool
l : List α
⊢ dropWhile p l.reverse <:+ l.reverse
|
exact dropWhile_suffix _
|
no goals
|
76c8126580e6ade9
|
Nat.zero_shiftLeft
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
|
theorem zero_shiftLeft : ∀ n, 0 <<< n = 0
| 0 => by simp [shiftLeft]
| n + 1 => by simp [shiftLeft, zero_shiftLeft n, shiftLeft_succ]
|
n : Nat
⊢ 0 <<< (n + 1) = 0
|
simp [shiftLeft, zero_shiftLeft n, shiftLeft_succ]
|
no goals
|
918057f1ae6c6cc6
|
Nat.bitIndices_twoPowsum
|
Mathlib/Data/Nat/BitIndices.lean
|
theorem bitIndices_twoPowsum {L : List ℕ} (hL : List.Sorted (· < ·) L) :
(L.map (fun i ↦ 2^i)).sum.bitIndices = L
|
case refine_1
a : ℕ
L : List ℕ
hL✝ : Sorted (fun x1 x2 => x1 < x2) (a :: L)
hL : Sorted (fun x1 x2 => x1 < x2) L
haL : ∀ b ∈ L, a + 1 ≤ b
⊢ Sorted (fun x1 x2 => x1 < x2) (map (fun x => x - (a + 1)) L)
|
rwa [Sorted, pairwise_map, Pairwise.and_mem,
Pairwise.iff (S := fun x y ↦ x ∈ L ∧ y ∈ L ∧ x < y), ← Pairwise.and_mem]
|
case refine_1.H
a : ℕ
L : List ℕ
hL✝ : Sorted (fun x1 x2 => x1 < x2) (a :: L)
hL : Sorted (fun x1 x2 => x1 < x2) L
haL : ∀ b ∈ L, a + 1 ≤ b
⊢ ∀ (a_1 b : ℕ), a_1 ∈ L ∧ b ∈ L ∧ a_1 - (a + 1) < b - (a + 1) ↔ a_1 ∈ L ∧ b ∈ L ∧ a_1 < b
|
aa09887952bda01a
|
cauchy_comap_uniformSpace
|
Mathlib/Topology/UniformSpace/Cauchy.lean
|
lemma cauchy_comap_uniformSpace {u : UniformSpace β} {α} {f : α → β} {l : Filter α} :
Cauchy (uniformSpace := comap f u) l ↔ Cauchy (map f l)
|
β : Type v
u : UniformSpace β
α : Type u_1
f : α → β
l : Filter α
⊢ l.NeBot ∧ l ×ˢ l ≤ 𝓤 α ↔ l.NeBot ∧ l ×ˢ l ≤ Filter.comap (fun p => (f p.1, f p.2)) (𝓤 β)
|
rfl
|
no goals
|
55f7837fd4c2f391
|
Finset.prod_mul_eq_prod_mul_of_exists
|
Mathlib/Algebra/BigOperators/Group/Finset/Basic.lean
|
@[to_additive]
lemma prod_mul_eq_prod_mul_of_exists {s : Finset α} {f : α → β} {b₁ b₂ : β}
(a : α) (ha : a ∈ s) (h : f a * b₁ = f a * b₂) :
(∏ a ∈ s, f a) * b₁ = (∏ a ∈ s, f a) * b₂
|
α : Type u_3
β : Type u_4
inst✝ : CommMonoid β
s : Finset α
f : α → β
b₁ b₂ : β
a : α
ha : a ∈ s
h : f a * b₁ = f a * b₂
⊢ (∏ a ∈ insert a (s.erase a), f a) * b₁ = (∏ a ∈ insert a (s.erase a), f a) * b₂
|
simp only [mem_erase, ne_eq, not_true_eq_false, false_and, not_false_eq_true, prod_insert]
|
α : Type u_3
β : Type u_4
inst✝ : CommMonoid β
s : Finset α
f : α → β
b₁ b₂ : β
a : α
ha : a ∈ s
h : f a * b₁ = f a * b₂
⊢ (f a * ∏ a ∈ s.erase a, f a) * b₁ = (f a * ∏ a ∈ s.erase a, f a) * b₂
|
a3aed55c11bc4378
|
CategoryTheory.Pseudofunctor.Grothendieck.Hom.ext
|
Mathlib/CategoryTheory/Bicategory/Grothendieck.lean
|
@[ext (iff := false)]
lemma Hom.ext (f g : a ⟶ b) (hfg₁ : f.base = g.base)
(hfg₂ : f.fiber = g.fiber ≫ eqToHom (hfg₁ ▸ rfl)) : f = g
|
case mk.mk.h.e_7
𝒮 : Type u₁
inst✝ : Category.{v₁, u₁} 𝒮
F : Pseudofunctor (LocallyDiscrete 𝒮ᵒᵖ) Cat
a b : ∫ F
base✝¹ : a.base ⟶ b.base
fiber✝¹ : a.fiber ⟶ (F.map base✝¹.op.toLoc).obj b.fiber
base✝ : a.base ⟶ b.base
fiber✝ : a.fiber ⟶ (F.map base✝.op.toLoc).obj b.fiber
hfg₁ : base✝¹ = base✝
hfg₂ : { base := base✝¹, fiber := fiber✝¹ }.fiber = { base := base✝, fiber := fiber✝ }.fiber ≫ eqToHom ⋯
⊢ HEq fiber✝¹ fiber✝
|
rw [← conj_eqToHom_iff_heq _ _ rfl (hfg₁ ▸ rfl)]
|
case mk.mk.h.e_7
𝒮 : Type u₁
inst✝ : Category.{v₁, u₁} 𝒮
F : Pseudofunctor (LocallyDiscrete 𝒮ᵒᵖ) Cat
a b : ∫ F
base✝¹ : a.base ⟶ b.base
fiber✝¹ : a.fiber ⟶ (F.map base✝¹.op.toLoc).obj b.fiber
base✝ : a.base ⟶ b.base
fiber✝ : a.fiber ⟶ (F.map base✝.op.toLoc).obj b.fiber
hfg₁ : base✝¹ = base✝
hfg₂ : { base := base✝¹, fiber := fiber✝¹ }.fiber = { base := base✝, fiber := fiber✝ }.fiber ≫ eqToHom ⋯
⊢ fiber✝¹ = eqToHom ⋯ ≫ fiber✝ ≫ eqToHom ⋯
|
103bfbb7b575eef6
|
List.getLast?_attachWith
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Attach.lean
|
theorem getLast?_attachWith {P : α → Prop} {xs : List α}
{H : ∀ (a : α), a ∈ xs → P a} :
(xs.attachWith P H).getLast? = xs.getLast?.pbind (fun a h => some ⟨a, H _ (mem_of_getLast? h)⟩)
|
α : Type u_1
P : α → Prop
xs : List α
H : ∀ (a : α), a ∈ xs → P a
⊢ (xs.attachWith P H).getLast? = xs.getLast?.pbind fun a h => some ⟨a, ⋯⟩
|
rw [getLast?_eq_head?_reverse, reverse_attachWith, head?_attachWith]
|
α : Type u_1
P : α → Prop
xs : List α
H : ∀ (a : α), a ∈ xs → P a
⊢ (xs.reverse.head?.pbind fun a h => some ⟨a, ⋯⟩) = xs.getLast?.pbind fun a h => some ⟨a, ⋯⟩
|
056955597a0f4250
|
IsLocalization.isNoetherianRing
|
Mathlib/RingTheory/Localization/Submodule.lean
|
theorem isNoetherianRing (h : IsNoetherianRing R) : IsNoetherianRing S
|
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
h : WellFounded fun x1 x2 => x1 > x2
⊢ WellFounded fun x1 x2 => x1 > x2
|
exact OrderEmbedding.wellFounded (IsLocalization.orderEmbedding M S).dual h
|
no goals
|
92d014786be6866b
|
Turing.PartrecToTM2.codeSupp'_supports
|
Mathlib/Computability/TMToPartrec.lean
|
theorem codeSupp'_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp' c k) S
|
case fix
S : Finset Λ'
f : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S
k : Cont'
H : codeSupp f.fix k ⊆ S
H' : trStmts₁ (trNormal f.fix k) ⊆ S ∧ codeSupp f (Cont'.fix f k) ⊆ S
⊢ Supports (codeSupp' f.fix k) S
|
refine trStmts₁_supports' (trNormal_supports H) (Finset.union_subset_left H) fun h => ?_
|
case fix
S : Finset Λ'
f : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S
k : Cont'
H : codeSupp f.fix k ⊆ S
H' : trStmts₁ (trNormal f.fix k) ⊆ S ∧ codeSupp f (Cont'.fix f k) ⊆ S
h : codeSupp' f (Cont'.fix f k) ∪ (trStmts₁ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k))) ∪ {Λ'.ret k}) ⊆ S
⊢ Supports (codeSupp' f (Cont'.fix f k) ∪ (trStmts₁ (Λ'.clear natEnd main (trNormal f (Cont'.fix f k))) ∪ {Λ'.ret k})) S
|
5fb2278c84599fe0
|
Std.Sat.AIG.denote_mkConst
|
Mathlib/.lake/packages/lean4/src/lean/Std/Sat/AIG/Lemmas.lean
|
theorem denote_mkConst {aig : AIG α} : ⟦(aig.mkConst val), assign⟧ = val
|
case h_2
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
assign : α → Bool
val : Bool
aig : AIG α
idx✝ : α
heq✝ : (aig.mkConst val).aig.decls[(aig.mkConst val).ref.gate] = Decl.atom idx✝
⊢ assign idx✝ = val
|
next heq =>
rw [mkConst, Array.getElem_push_eq] at heq
contradiction
|
no goals
|
d9e8c97541c0a83f
|
Finset.image_subset_image
|
Mathlib/Data/Finset/Image.lean
|
theorem image_subset_image {s₁ s₂ : Finset α} (h : s₁ ⊆ s₂) : s₁.image f ⊆ s₂.image f
|
α : Type u_1
β : Type u_2
inst✝ : DecidableEq β
f : α → β
s₁ s₂ : Finset α
h : s₁ ⊆ s₂
⊢ image f s₁ ⊆ image f s₂
|
simp only [subset_def, image_val, subset_dedup', dedup_subset', Multiset.map_subset_map h]
|
no goals
|
c14dad4cf638562a
|
MeromorphicOn.isClopen_setOf_order_eq_top
|
Mathlib/Analysis/Meromorphic/Order.lean
|
theorem isClopen_setOf_order_eq_top : IsClopen { u : U | (hf u.1 u.2).order = ⊤ }
|
case pos
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
U : Set 𝕜
hf : MeromorphicOn f U
z : ↑U
t' : Set 𝕜
h₁t' : ∀ y ∈ t', y ∈ {↑z}ᶜ → f y = 0
h₂t' : IsOpen t'
h₃t' : ↑z ∈ t'
w : ↑U
hw : w ∈ Subtype.val ⁻¹' t'
h₁w : w = z
⊢ ∃ t, (∀ y ∈ t, ¬y = ↑w → f y = 0) ∧ IsOpen t ∧ ↑w ∈ t
|
rw [h₁w]
|
case pos
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
U : Set 𝕜
hf : MeromorphicOn f U
z : ↑U
t' : Set 𝕜
h₁t' : ∀ y ∈ t', y ∈ {↑z}ᶜ → f y = 0
h₂t' : IsOpen t'
h₃t' : ↑z ∈ t'
w : ↑U
hw : w ∈ Subtype.val ⁻¹' t'
h₁w : w = z
⊢ ∃ t, (∀ y ∈ t, ¬y = ↑z → f y = 0) ∧ IsOpen t ∧ ↑z ∈ t
|
7349d8844a909f0d
|
Complex.circleIntegral_eq_zero_of_differentiable_on_off_countable
|
Mathlib/Analysis/Complex/CauchyIntegral.lean
|
theorem circleIntegral_eq_zero_of_differentiable_on_off_countable {R : ℝ} (h0 : 0 ≤ R) {f : ℂ → E}
{c : ℂ} {s : Set ℂ} (hs : s.Countable) (hc : ContinuousOn f (closedBall c R))
(hd : ∀ z ∈ ball c R \ s, DifferentiableAt ℂ f z) : (∮ z in C(c, R), f z) = 0
|
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
h0 : 0 ≤ R
f : ℂ → E
c : ℂ
s : Set ℂ
hs : s.Countable
hc : ContinuousOn f (closedBall c R)
hd : ∀ z ∈ ball c R \ s, DifferentiableAt ℂ f z
⊢ (∮ (z : ℂ) in C(c, R), f z) = 0
|
rcases h0.eq_or_lt with (rfl | h0)
|
case inl
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
s : Set ℂ
hs : s.Countable
h0 : 0 ≤ 0
hc : ContinuousOn f (closedBall c 0)
hd : ∀ z ∈ ball c 0 \ s, DifferentiableAt ℂ f z
⊢ (∮ (z : ℂ) in C(c, 0), f z) = 0
case inr
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
h0✝ : 0 ≤ R
f : ℂ → E
c : ℂ
s : Set ℂ
hs : s.Countable
hc : ContinuousOn f (closedBall c R)
hd : ∀ z ∈ ball c R \ s, DifferentiableAt ℂ f z
h0 : 0 < R
⊢ (∮ (z : ℂ) in C(c, R), f z) = 0
|
f3ece393078c11db
|
mul_gauge_le_norm
|
Mathlib/Analysis/Convex/Gauge.lean
|
theorem mul_gauge_le_norm (hs : Metric.ball (0 : E) r ⊆ s) : r * gauge s x ≤ ‖x‖
|
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
⊢ r * gauge s x ≤ ‖x‖
|
obtain hr | hr := le_or_lt r 0
|
case inl
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
hr : r ≤ 0
⊢ r * gauge s x ≤ ‖x‖
case inr
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : ball 0 r ⊆ s
hr : 0 < r
⊢ r * gauge s x ≤ ‖x‖
|
a8c9db9a8bb59ee6
|
CategoryTheory.MorphismProperty.pullback_map
|
Mathlib/CategoryTheory/MorphismProperty/Limits.lean
|
theorem pullback_map [HasPullbacks C]
[IsStableUnderBaseChange P] [P.IsStableUnderComposition] {S X X' Y Y' : C} {f : X ⟶ S}
{g : Y ⟶ S} {f' : X' ⟶ S} {g' : Y' ⟶ S} {i₁ : X ⟶ X'} {i₂ : Y ⟶ Y'} (h₁ : P i₁) (h₂ : P i₂)
(e₁ : f = i₁ ≫ f') (e₂ : g = i₂ ≫ g') :
P (pullback.map f g f' g' i₁ i₂ (𝟙 _) ((Category.comp_id _).trans e₁)
((Category.comp_id _).trans e₂))
|
case hf
C : Type u
inst✝³ : Category.{v, u} C
P : MorphismProperty C
inst✝² : HasPullbacks C
inst✝¹ : P.IsStableUnderBaseChange
inst✝ : P.IsStableUnderComposition
S X X' Y Y' : C
f : X ⟶ S
g : Y ⟶ S
f' : X' ⟶ S
g' : Y' ⟶ S
i₁ : X ⟶ X'
i₂ : Y ⟶ Y'
h₁ : P i₁
h₂ : P i₂
e₁ : f = i₁ ≫ f'
e₂ : g = i₂ ≫ g'
this :
pullback.map f g f' g' i₁ i₂ (𝟙 S) ⋯ ⋯ =
((pullbackSymmetry (Over.mk f).hom (Over.mk g).hom).hom ≫
((Over.pullback (Over.mk f).hom).map (Over.homMk i₂ ⋯)).left) ≫
(pullbackSymmetry (Over.mk g').hom (Over.mk f).hom).hom ≫ ((Over.pullback g').map (Over.homMk i₁ ⋯)).left
⊢ P ((Over.pullback (Over.mk f).hom).map (Over.homMk i₂ ⋯)).left
case hg
C : Type u
inst✝³ : Category.{v, u} C
P : MorphismProperty C
inst✝² : HasPullbacks C
inst✝¹ : P.IsStableUnderBaseChange
inst✝ : P.IsStableUnderComposition
S X X' Y Y' : C
f : X ⟶ S
g : Y ⟶ S
f' : X' ⟶ S
g' : Y' ⟶ S
i₁ : X ⟶ X'
i₂ : Y ⟶ Y'
h₁ : P i₁
h₂ : P i₂
e₁ : f = i₁ ≫ f'
e₂ : g = i₂ ≫ g'
this :
pullback.map f g f' g' i₁ i₂ (𝟙 S) ⋯ ⋯ =
((pullbackSymmetry (Over.mk f).hom (Over.mk g).hom).hom ≫
((Over.pullback (Over.mk f).hom).map (Over.homMk i₂ ⋯)).left) ≫
(pullbackSymmetry (Over.mk g').hom (Over.mk f).hom).hom ≫ ((Over.pullback g').map (Over.homMk i₁ ⋯)).left
⊢ P ((Over.pullback g').map (Over.homMk i₁ ⋯)).left
|
exacts [baseChange_map _ (Over.homMk _ e₂.symm : Over.mk g ⟶ Over.mk g') h₂,
baseChange_map _ (Over.homMk _ e₁.symm : Over.mk f ⟶ Over.mk f') h₁]
|
no goals
|
25efcf6d428e3aaa
|
Localization.localRingHom_comp
|
Mathlib/RingTheory/Localization/AtPrime.lean
|
theorem localRingHom_comp {S : Type*} [CommSemiring S] (J : Ideal S) [hJ : J.IsPrime] (K : Ideal P)
[hK : K.IsPrime] (f : R →+* S) (hIJ : I = J.comap f) (g : S →+* P) (hJK : J = K.comap g) :
localRingHom I K (g.comp f) (by rw [hIJ, hJK, Ideal.comap_comap f g]) =
(localRingHom J K g hJK).comp (localRingHom I J f hIJ) :=
localRingHom_unique _ _ _ _ fun r => by
simp only [Function.comp_apply, RingHom.coe_comp, localRingHom_to_map]
|
R : Type u_1
inst✝² : CommSemiring R
P : Type u_3
inst✝¹ : CommSemiring P
I : Ideal R
hI : I.IsPrime
S : Type u_4
inst✝ : CommSemiring S
J : Ideal S
hJ : J.IsPrime
K : Ideal P
hK : K.IsPrime
f : R →+* S
hIJ : I = Ideal.comap f J
g : S →+* P
hJK : J = Ideal.comap g K
r : R
⊢ ((localRingHom J K g hJK).comp (localRingHom I J f hIJ)) ((algebraMap R (Localization.AtPrime I)) r) =
(algebraMap P (Localization.AtPrime K)) ((g.comp f) r)
|
simp only [Function.comp_apply, RingHom.coe_comp, localRingHom_to_map]
|
no goals
|
e31563396387eb68
|
NNReal.exists_pos_sum_of_countable
|
Mathlib/Analysis/SpecificLimits/Basic.lean
|
theorem exists_pos_sum_of_countable {ε : ℝ≥0} (hε : ε ≠ 0) (ι) [Countable ι] :
∃ ε' : ι → ℝ≥0, (∀ i, 0 < ε' i) ∧ ∃ c, HasSum ε' c ∧ c < ε
|
case intro.intro.intro
ε : ℝ≥0
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
val✝ : Encodable ι
a : ℝ≥0
a0 : 0 < a
aε : a < ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∃ c, HasSum ε' c ∧ c < ε
|
obtain ⟨ε', hε', c, hc, hcε⟩ := posSumOfEncodable a0 ι
|
case intro.intro.intro.mk.intro.intro.intro
ε : ℝ≥0
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
val✝ : Encodable ι
a : ℝ≥0
a0 : 0 < a
aε : a < ε
ε' : ι → ℝ
hε' : ∀ (i : ι), 0 < ε' i
c : ℝ
hc : HasSum ε' c
hcε : c ≤ (fun a => ↑a) a
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∃ c, HasSum ε' c ∧ c < ε
|
108a495dfe8666a5
|
Complex.norm_log_one_add_half_le_self
|
Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean
|
/-- For `‖z‖ ≤ 1/2`, the complex logarithm is bounded by `(3/2) * ‖z‖`. -/
lemma norm_log_one_add_half_le_self {z : ℂ} (hz : ‖z‖ ≤ 1/2) : ‖(log (1 + z))‖ ≤ (3/2) * ‖z‖
|
z : ℂ
hz : ‖z‖ ≤ 1 / 2
hz3 : (1 - ‖z‖)⁻¹ ≤ 2
hz4 : ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2 ≤ ‖z‖ / 2 * 2 / 2
⊢ ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2 + ‖z‖ ≤ 3 / 2 * ‖z‖
|
simp only [isUnit_iff_ne_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true,
IsUnit.div_mul_cancel] at hz4
|
z : ℂ
hz : ‖z‖ ≤ 1 / 2
hz3 : (1 - ‖z‖)⁻¹ ≤ 2
hz4 : ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2 ≤ ‖z‖ / 2
⊢ ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2 + ‖z‖ ≤ 3 / 2 * ‖z‖
|
f3a688a3bed721f7
|
CompleteLattice.isStronglyAtomic
|
Mathlib/Order/Atoms.lean
|
theorem CompleteLattice.isStronglyAtomic [IsUpperModularLattice α] [IsAtomistic α] :
IsStronglyAtomic α where
exists_covBy_le_of_lt a b hab
|
case intro.intro.inr
α : Type u_2
inst✝² : CompleteLattice α
inst✝¹ : IsUpperModularLattice α
inst✝ : IsAtomistic α
a : α
s : Set α
h : ∀ a ∈ s, IsAtom a
hab : a < sSup s
x : α
hx : x ∈ s
hcon : ¬a ⋖ x ⊔ a
h_inf : x ⊓ a = x
⊢ x ≤ a
|
rwa [inf_eq_left] at h_inf
|
no goals
|
f38a963c485d9a59
|
IsCompact.closure_subset_measurableSet
|
Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
|
theorem IsCompact.closure_subset_measurableSet [R1Space γ] {K s : Set γ} (hK : IsCompact K)
(hs : MeasurableSet s) (hKs : K ⊆ s) : closure K ⊆ s
|
γ : Type u_3
inst✝³ : TopologicalSpace γ
inst✝² : MeasurableSpace γ
inst✝¹ : BorelSpace γ
inst✝ : R1Space γ
K s : Set γ
hK : IsCompact K
hs : MeasurableSet s
hKs : K ⊆ s
⊢ closure K ⊆ s
|
rw [hK.closure_eq_biUnion_inseparable, iUnion₂_subset_iff]
|
γ : Type u_3
inst✝³ : TopologicalSpace γ
inst✝² : MeasurableSpace γ
inst✝¹ : BorelSpace γ
inst✝ : R1Space γ
K s : Set γ
hK : IsCompact K
hs : MeasurableSet s
hKs : K ⊆ s
⊢ ∀ i ∈ K, {y | Inseparable i y} ⊆ s
|
a5ffbea07edba0de
|
CategoryTheory.strongEpi_of_strongEpi
|
Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean
|
theorem strongEpi_of_strongEpi [StrongEpi (f ≫ g)] : StrongEpi g :=
{ epi := epi_of_epi f g
llp := fun {X Y} z _ => by
constructor
intro u v sq
have h₀ : (f ≫ u) ≫ z = (f ≫ g) ≫ v
|
case sq_hasLift
C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝ : StrongEpi (f ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
⊢ ∀ {f : Q ⟶ X} {g_1 : R ⟶ Y} (sq : CommSq f g z g_1), sq.HasLift
|
intro u v sq
|
case sq_hasLift
C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝ : StrongEpi (f ≫ g)
X Y : C
z : X ⟶ Y
x✝ : Mono z
u : Q ⟶ X
v : R ⟶ Y
sq : CommSq u g z v
⊢ sq.HasLift
|
9c6107457dbbc63b
|
Substring.ValidFor.prevn
|
Mathlib/.lake/packages/batteries/Batteries/Data/String/Lemmas.lean
|
theorem prevn : ∀ {s}, ValidFor l (m₁.reverse ++ m₂) r s →
∀ n, s.prevn n ⟨utf8Len m₁⟩ = ⟨utf8Len (m₁.drop n)⟩
| _, _, 0 => by simp [Substring.prevn]
| s, h, n+1 => by
simp only [Substring.prevn]
match m₁ with
| [] => simp
| c::m₁ =>
rw [List.reverse_cons, List.append_assoc] at h
have := h.prev; simp at this; simp [this, h.prevn n]
|
l m₂ r m₁ : List Char
s : Substring
h : ValidFor l (m₁.reverse ++ m₂) r s
n : Nat
⊢ s.prevn (n + 1) { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop (n + 1) m₁) }
|
simp only [Substring.prevn]
|
l m₂ r m₁ : List Char
s : Substring
h : ValidFor l (m₁.reverse ++ m₂) r s
n : Nat
⊢ s.prevn n (s.prev { byteIdx := utf8Len m₁ }) = { byteIdx := utf8Len (List.drop (n + 1) m₁) }
|
335aa626418f50e2
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.insertRatUnits_postcondition
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.lean
|
theorem insertRatUnits_postcondition {n : Nat} (f : DefaultFormula n)
(hf : f.ratUnits = #[] ∧ f.assignments.size = n)
(units : CNF.Clause (PosFin n)) :
let assignments := (insertRatUnits f units).fst.assignments
have hsize : assignments.size = n
|
case h
n : Nat
f : DefaultFormula n
hf : f.ratUnits = #[] ∧ f.assignments.size = n
units : CNF.Clause (PosFin n)
hsize : f.assignments.size = n
i : Fin n
⊢ f.assignments[↑i] = f.assignments[↑i] ∧ ∀ (j : Fin f.ratUnits.size), f.ratUnits[j].fst.val ≠ ↑i
|
simp only [Fin.getElem_fin, ne_eq, true_and, Bool.not_eq_true, exists_and_right]
|
case h
n : Nat
f : DefaultFormula n
hf : f.ratUnits = #[] ∧ f.assignments.size = n
units : CNF.Clause (PosFin n)
hsize : f.assignments.size = n
i : Fin n
⊢ ∀ (j : Fin f.ratUnits.size), ¬f.ratUnits[↑j].fst.val = ↑i
|
ea6eb4c6355fd3da
|
BoxIntegral.Box.mk'_eq_coe
|
Mathlib/Analysis/BoxIntegral/Box/Basic.lean
|
theorem mk'_eq_coe {l u : ι → ℝ} : mk' l u = I ↔ l = I.lower ∧ u = I.upper
|
case mk
ι : Type u_1
l u lI uI : ι → ℝ
hI : ∀ (i : ι), lI i < uI i
⊢ mk' l u = ↑{ lower := lI, upper := uI, lower_lt_upper := hI } ↔
l = { lower := lI, upper := uI, lower_lt_upper := hI }.lower ∧
u = { lower := lI, upper := uI, lower_lt_upper := hI }.upper
|
rw [mk']
|
case mk
ι : Type u_1
l u lI uI : ι → ℝ
hI : ∀ (i : ι), lI i < uI i
⊢ (if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) =
↑{ lower := lI, upper := uI, lower_lt_upper := hI } ↔
l = { lower := lI, upper := uI, lower_lt_upper := hI }.lower ∧
u = { lower := lI, upper := uI, lower_lt_upper := hI }.upper
|
5a138799670a8b97
|
Set.range_comp_subset_range
|
Mathlib/Data/Set/Image.lean
|
theorem range_comp_subset_range (f : α → β) (g : β → γ) : range (g ∘ f) ⊆ range g
|
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
g : β → γ
⊢ range (g ∘ f) ⊆ range g
|
rw [range_comp]
|
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
g : β → γ
⊢ g '' range f ⊆ range g
|
bb913eede991123d
|
ProbabilityTheory.eqOn_complexMGF_of_mgf'
|
Mathlib/Probability/Moments/ComplexMGF.lean
|
/-- If two random variables have the same moment generating function then they have
the same `complexMGF` on the vertical strip `{z | z.re ∈ interior (integrableExpSet X μ)}`.
TODO: once we know that equal `mgf` implies equal distributions, we will be able to show that
the `complexMGF` are equal everywhere, not only on the strip.
This lemma will be used in the proof of the equality of distributions. -/
lemma eqOn_complexMGF_of_mgf' (hXY : mgf X μ = mgf Y μ') (hμμ' : μ = 0 ↔ μ' = 0) :
Set.EqOn (complexMGF X μ) (complexMGF Y μ') {z | z.re ∈ interior (integrableExpSet X μ)}
|
case neg
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
Ω' : Type u_3
mΩ' : MeasurableSpace Ω'
Y : Ω' → ℝ
μ' : Measure Ω'
hXY : mgf X μ = mgf Y μ'
hμμ' : μ = 0 ↔ μ' = 0
h_empty : (interior (integrableExpSet X μ)).Nonempty
⊢ Set.EqOn (complexMGF X μ) (complexMGF Y μ') {z | z.re ∈ interior (integrableExpSet X μ)}
|
obtain ⟨t, ht⟩ := h_empty
|
case neg.intro
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
Ω' : Type u_3
mΩ' : MeasurableSpace Ω'
Y : Ω' → ℝ
μ' : Measure Ω'
hXY : mgf X μ = mgf Y μ'
hμμ' : μ = 0 ↔ μ' = 0
t : ℝ
ht : t ∈ interior (integrableExpSet X μ)
⊢ Set.EqOn (complexMGF X μ) (complexMGF Y μ') {z | z.re ∈ interior (integrableExpSet X μ)}
|
a1be17aeb598938f
|
Polynomial.contract_mul_expand
|
Mathlib/Algebra/Polynomial/Expand.lean
|
theorem contract_mul_expand {p : ℕ} (hp : p ≠ 0) (f g : R[X]) :
contract p (f * expand R p g) = contract p f * g
|
case pos
R : Type u
inst✝ : CommSemiring R
p : ℕ
hp : p ≠ 0
f g : R[X]
n x y : ℕ
eq : (x, y).1 + (x, y).2 = n * p
nex : ¬∃ a, a.1 + a.2 = n ∧ (a.1 * p, a.2 * p) = (x, y)
h : p ∣ y
⊢ f.coeff (x, y).1 * ((expand R p) g).coeff (x, y).2 = 0
|
obtain ⟨x, rfl⟩ : p ∣ x := (Nat.dvd_add_iff_left h).mpr (eq ▸ dvd_mul_left p n)
|
case pos.intro
R : Type u
inst✝ : CommSemiring R
p : ℕ
hp : p ≠ 0
f g : R[X]
n y : ℕ
h : p ∣ y
x : ℕ
eq : (p * x, y).1 + (p * x, y).2 = n * p
nex : ¬∃ a, a.1 + a.2 = n ∧ (a.1 * p, a.2 * p) = (p * x, y)
⊢ f.coeff (p * x, y).1 * ((expand R p) g).coeff (p * x, y).2 = 0
|
c12f546c03101c96
|
MeasureTheory.ae_bdd_liminf_atTop_of_eLpNorm_bdd
|
Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
|
theorem ae_bdd_liminf_atTop_of_eLpNorm_bdd {p : ℝ≥0∞} (hp : p ≠ 0) {f : ℕ → α → E}
(hfmeas : ∀ n, Measurable (f n)) (hbdd : ∀ n, eLpNorm (f n) p μ ≤ R) :
∀ᵐ x ∂μ, liminf (fun n => (‖f n x‖ₑ)) atTop < ∞
|
α : Type u_1
E : Type u_3
m0 : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : MeasurableSpace E
inst✝ : OpensMeasurableSpace E
R : ℝ≥0
p : ℝ≥0∞
hp : p ≠ 0
f : ℕ → α → E
hfmeas : ∀ (n : ℕ), Measurable (f n)
hbdd : ∀ (n : ℕ), eLpNorm (f n) p μ ≤ ↑R
⊢ ∀ᵐ (x : α) ∂μ, liminf (fun n => ‖f n x‖ₑ) atTop < ⊤
|
by_cases hp' : p = ∞
|
case pos
α : Type u_1
E : Type u_3
m0 : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : MeasurableSpace E
inst✝ : OpensMeasurableSpace E
R : ℝ≥0
p : ℝ≥0∞
hp : p ≠ 0
f : ℕ → α → E
hfmeas : ∀ (n : ℕ), Measurable (f n)
hbdd : ∀ (n : ℕ), eLpNorm (f n) p μ ≤ ↑R
hp' : p = ⊤
⊢ ∀ᵐ (x : α) ∂μ, liminf (fun n => ‖f n x‖ₑ) atTop < ⊤
case neg
α : Type u_1
E : Type u_3
m0 : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : MeasurableSpace E
inst✝ : OpensMeasurableSpace E
R : ℝ≥0
p : ℝ≥0∞
hp : p ≠ 0
f : ℕ → α → E
hfmeas : ∀ (n : ℕ), Measurable (f n)
hbdd : ∀ (n : ℕ), eLpNorm (f n) p μ ≤ ↑R
hp' : ¬p = ⊤
⊢ ∀ᵐ (x : α) ∂μ, liminf (fun n => ‖f n x‖ₑ) atTop < ⊤
|
56256701164a29db
|
Algebra.FinitePresentation.ker_fg_of_mvPolynomial
|
Mathlib/RingTheory/FinitePresentation.lean
|
theorem ker_fg_of_mvPolynomial {n : ℕ} (f : MvPolynomial (Fin n) R →ₐ[R] A)
(hf : Function.Surjective f) [FinitePresentation R A] : f.toRingHom.ker.FG
|
case intro.intro.intro.intro
R : Type w₁
A : Type w₂
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ⇑f
inst✝ : FinitePresentation R A
m : ℕ
f' : MvPolynomial (Fin m) R →ₐ[R] A
hf' : Surjective ⇑f'
s : Finset (MvPolynomial (Fin m) R)
hs : Ideal.span ↑s = RingHom.ker f'.toRingHom
RXn : Type (max 0 w₁) := MvPolynomial (Fin n) R
RXm : Type (max 0 w₁) := MvPolynomial (Fin m) R
g : Fin n → MvPolynomial (Fin m) R
hg : ∀ (i : Fin n), f' (g i) = f (MvPolynomial.X i)
h : Fin m → MvPolynomial (Fin n) R
hh : ∀ (i : Fin m), f (h i) = f' (MvPolynomial.X i)
aeval_h : RXm →ₐ[R] RXn := MvPolynomial.aeval h
g' : Fin n → RXn := fun i => MvPolynomial.X i - aeval_h (g i)
⊢ Ideal.span ↑(Finset.image g' Finset.univ ∪ Finset.image (⇑aeval_h) s) = RingHom.ker f.toRingHom
|
simp only [Finset.coe_image, Finset.coe_union, Finset.coe_univ, Set.image_univ]
|
case intro.intro.intro.intro
R : Type w₁
A : Type w₂
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ⇑f
inst✝ : FinitePresentation R A
m : ℕ
f' : MvPolynomial (Fin m) R →ₐ[R] A
hf' : Surjective ⇑f'
s : Finset (MvPolynomial (Fin m) R)
hs : Ideal.span ↑s = RingHom.ker f'.toRingHom
RXn : Type (max 0 w₁) := MvPolynomial (Fin n) R
RXm : Type (max 0 w₁) := MvPolynomial (Fin m) R
g : Fin n → MvPolynomial (Fin m) R
hg : ∀ (i : Fin n), f' (g i) = f (MvPolynomial.X i)
h : Fin m → MvPolynomial (Fin n) R
hh : ∀ (i : Fin m), f (h i) = f' (MvPolynomial.X i)
aeval_h : RXm →ₐ[R] RXn := MvPolynomial.aeval h
g' : Fin n → RXn := fun i => MvPolynomial.X i - aeval_h (g i)
⊢ Ideal.span (Set.range g' ∪ ⇑aeval_h '' ↑s) = RingHom.ker f.toRingHom
|
37c27acde7e67205
|
Nat.diag_induction
|
Mathlib/Data/Nat/Init.lean
|
theorem diag_induction (P : ℕ → ℕ → Prop) (ha : ∀ a, P (a + 1) (a + 1)) (hb : ∀ b, P 0 (b + 1))
(hd : ∀ a b, a < b → P (a + 1) b → P a (b + 1) → P (a + 1) (b + 1)) : ∀ a b, a < b → P a b
| 0, _ + 1, _ => hb _
| a + 1, b + 1, h => by
apply hd _ _ (Nat.add_lt_add_iff_right.1 h)
· have this : a + 1 = b ∨ a + 1 < b
|
P : ℕ → ℕ → Prop
ha : ∀ (a : ℕ), P (a + 1) (a + 1)
hb : ∀ (b : ℕ), P 0 (b + 1)
hd : ∀ (a b : ℕ), a < b → P (a + 1) b → P a (b + 1) → P (a + 1) (b + 1)
a b : ℕ
h : a + 1 < b + 1
⊢ P (a + 1) (b + 1)
|
apply hd _ _ (Nat.add_lt_add_iff_right.1 h)
|
case a
P : ℕ → ℕ → Prop
ha : ∀ (a : ℕ), P (a + 1) (a + 1)
hb : ∀ (b : ℕ), P 0 (b + 1)
hd : ∀ (a b : ℕ), a < b → P (a + 1) b → P a (b + 1) → P (a + 1) (b + 1)
a b : ℕ
h : a + 1 < b + 1
⊢ P (a + 1) b
case a
P : ℕ → ℕ → Prop
ha : ∀ (a : ℕ), P (a + 1) (a + 1)
hb : ∀ (b : ℕ), P 0 (b + 1)
hd : ∀ (a b : ℕ), a < b → P (a + 1) b → P a (b + 1) → P (a + 1) (b + 1)
a b : ℕ
h : a + 1 < b + 1
⊢ P a (b + 1)
|
42f141b2edc38622
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.sat_of_confirmRupHint_insertRup_fold
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.lean
|
theorem sat_of_confirmRupHint_insertRup_fold {n : Nat} (f : DefaultFormula n)
(f_readyForRupAdd : ReadyForRupAdd f) (c : DefaultClause n) (rupHints : Array Nat)
(p : PosFin n → Bool) (pf : p ⊨ f) :
let fc := insertRupUnits f (negate c)
let confirmRupHint_fold_res := rupHints.foldl (confirmRupHint fc.1.clauses) (fc.1.assignments, [], false, false) 0 rupHints.size
confirmRupHint_fold_res.2.2.1 = true → p ⊨ c
|
case neg.intro.intro
n : Nat
f : DefaultFormula n
f_readyForRupAdd : f.ReadyForRupAdd
c : DefaultClause n
rupHints : Array Nat
p : PosFin n → Bool
pf : p ⊨ f
fc : DefaultFormula n × Bool := f.insertRupUnits c.negate
confirmRupHint_fold_res : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool :=
Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints
confirmRupHint_success : confirmRupHint_fold_res.snd.snd.fst = true
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := fc.fst.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (fc.fst.assignments, [], false, false)
h_inductive :
∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
motive (↑idx) acc →
fc.fst.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint fc.fst.clauses acc rupHints[idx])
left✝ : (Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst.size = n
h1 :
Limplies (PosFin n) fc.fst
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst
h2 :
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).snd.snd.fst = true →
Incompatible (PosFin n)
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst fc.fst
fc_incompatible_confirmRupHint_fold_res :
Incompatible (PosFin n) fc.fst
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst
pc :
∀ (x : PosFin n),
((x, false) ∈ Clause.toList c → decide (p x = false) = false) ∧
((x, true) ∈ Clause.toList c → decide (p x = true) = false)
unsat_c : DefaultClause n
unsat_c_in_fc : unsat_c ∈ fc.fst.toList
p_unsat_c : ¬(p ⊨ unsat_c)
⊢ False
|
have unsat_c_in_fc := mem_of_insertRupUnits f (negate c) unsat_c unsat_c_in_fc
|
case neg.intro.intro
n : Nat
f : DefaultFormula n
f_readyForRupAdd : f.ReadyForRupAdd
c : DefaultClause n
rupHints : Array Nat
p : PosFin n → Bool
pf : p ⊨ f
fc : DefaultFormula n × Bool := f.insertRupUnits c.negate
confirmRupHint_fold_res : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool :=
Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints
confirmRupHint_success : confirmRupHint_fold_res.snd.snd.fst = true
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := fc.fst.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (fc.fst.assignments, [], false, false)
h_inductive :
∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
motive (↑idx) acc →
fc.fst.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint fc.fst.clauses acc rupHints[idx])
left✝ : (Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst.size = n
h1 :
Limplies (PosFin n) fc.fst
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst
h2 :
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).snd.snd.fst = true →
Incompatible (PosFin n)
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst fc.fst
fc_incompatible_confirmRupHint_fold_res :
Incompatible (PosFin n) fc.fst
(Array.foldl (confirmRupHint fc.fst.clauses) (fc.fst.assignments, [], false, false) rupHints).fst
pc :
∀ (x : PosFin n),
((x, false) ∈ Clause.toList c → decide (p x = false) = false) ∧
((x, true) ∈ Clause.toList c → decide (p x = true) = false)
unsat_c : DefaultClause n
unsat_c_in_fc✝ : unsat_c ∈ fc.fst.toList
p_unsat_c : ¬(p ⊨ unsat_c)
unsat_c_in_fc : unsat_c ∈ List.map Clause.unit c.negate ∨ unsat_c ∈ f.toList
⊢ False
|
5ee4e43f082bad4a
|
torusMap_sub_center
|
Mathlib/MeasureTheory/Integral/TorusIntegral.lean
|
theorem torusMap_sub_center (c : ℂⁿ) (R : ℝⁿ) (θ : ℝⁿ) : torusMap c R θ - c = torusMap 0 R θ
|
case h
n : ℕ
c : Fin n → ℂ
R θ : Fin n → ℝ
i : Fin n
⊢ (torusMap c R θ - c) i = torusMap 0 R θ i
|
simp [torusMap]
|
no goals
|
bacd7c5510414d1d
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_invariant_helper
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean
|
theorem confirmRupHint_preserves_invariant_helper {n : Nat} (f : DefaultFormula n)
(f_assignments_size : f.assignments.size = n)
(acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool) (hsize : acc.1.size = n)
(l : Literal (PosFin n)) (ih : DerivedLitsInvariant f f_assignments_size acc.1 hsize acc.2.1)
(h : ¬hasAssignment l.snd acc.fst[l.fst.val]! = true) :
have hsize' : (Array.modify acc.1 l.1.1 (addAssignment l.snd)).size = n
|
case intro
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool
hsize : acc.fst.size = n
l : Literal (PosFin n)
ih : f.DerivedLitsInvariant f_assignments_size acc.fst hsize acc.snd.fst
h : ¬hasAssignment l.snd acc.fst[l.fst.val]! = true
hsize'✝ : (acc.fst.modify l.fst.val (addAssignment l.snd)).size = n :=
Eq.mpr (id (congrArg (fun _a => _a = n) (Array.size_modify acc.fst l.fst.val (addAssignment l.snd)))) hsize
i : Fin n
i_in_bounds : ↑i < acc.fst.size
l_in_bounds : l.fst.val < acc.fst.size
j1 j2 : Fin (List.length acc.snd.fst)
j1_eq_i : (List.get acc.snd.fst j1).fst.val = ↑i
j2_eq_i : (List.get acc.snd.fst j2).fst.val = ↑i
j1_eq_true : (List.get acc.snd.fst j1).snd = true
j2_eq_false : (List.get acc.snd.fst j2).snd = false
h1 : acc.fst[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin (List.length acc.snd.fst)), k ≠ j1 → k ≠ j2 → (List.get acc.snd.fst k).fst.val ≠ ↑i
j1_succ_in_bounds : ↑j1 + 1 < (l :: acc.snd.fst).length
j2_succ_in_bounds : ↑j2 + 1 < (l :: acc.snd.fst).length
j1_succ : Fin (l :: acc.snd.fst).length := ⟨↑j1 + 1, j1_succ_in_bounds⟩
j2_succ : Fin (l :: acc.snd.fst).length := ⟨↑j2 + 1, j2_succ_in_bounds⟩
l_ne_i : l.fst.val ≠ ↑i
k : Fin (List.length acc.snd.fst + 1)
k_ne_j1_succ : ¬k = j1_succ
k_ne_j2_succ : ¬k = j2_succ
zero_in_bounds : 0 < (l :: acc.snd.fst).length
k_ne_zero : ¬k = ⟨0, zero_in_bounds⟩
k_val_ne_zero : ↑k ≠ 0
k' : Nat
k_eq_k'_succ : ↑k = k' + 1
k'_succ_in_bounds : k' + 1 < (l :: acc.snd.fst).length
⊢ ∃ k' k'_succ_in_bounds, k = ⟨k' + 1, k'_succ_in_bounds⟩
|
apply Exists.intro k' ∘ Exists.intro k'_succ_in_bounds
|
case intro
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool
hsize : acc.fst.size = n
l : Literal (PosFin n)
ih : f.DerivedLitsInvariant f_assignments_size acc.fst hsize acc.snd.fst
h : ¬hasAssignment l.snd acc.fst[l.fst.val]! = true
hsize'✝ : (acc.fst.modify l.fst.val (addAssignment l.snd)).size = n :=
Eq.mpr (id (congrArg (fun _a => _a = n) (Array.size_modify acc.fst l.fst.val (addAssignment l.snd)))) hsize
i : Fin n
i_in_bounds : ↑i < acc.fst.size
l_in_bounds : l.fst.val < acc.fst.size
j1 j2 : Fin (List.length acc.snd.fst)
j1_eq_i : (List.get acc.snd.fst j1).fst.val = ↑i
j2_eq_i : (List.get acc.snd.fst j2).fst.val = ↑i
j1_eq_true : (List.get acc.snd.fst j1).snd = true
j2_eq_false : (List.get acc.snd.fst j2).snd = false
h1 : acc.fst[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin (List.length acc.snd.fst)), k ≠ j1 → k ≠ j2 → (List.get acc.snd.fst k).fst.val ≠ ↑i
j1_succ_in_bounds : ↑j1 + 1 < (l :: acc.snd.fst).length
j2_succ_in_bounds : ↑j2 + 1 < (l :: acc.snd.fst).length
j1_succ : Fin (l :: acc.snd.fst).length := ⟨↑j1 + 1, j1_succ_in_bounds⟩
j2_succ : Fin (l :: acc.snd.fst).length := ⟨↑j2 + 1, j2_succ_in_bounds⟩
l_ne_i : l.fst.val ≠ ↑i
k : Fin (List.length acc.snd.fst + 1)
k_ne_j1_succ : ¬k = j1_succ
k_ne_j2_succ : ¬k = j2_succ
zero_in_bounds : 0 < (l :: acc.snd.fst).length
k_ne_zero : ¬k = ⟨0, zero_in_bounds⟩
k_val_ne_zero : ↑k ≠ 0
k' : Nat
k_eq_k'_succ : ↑k = k' + 1
k'_succ_in_bounds : k' + 1 < (l :: acc.snd.fst).length
⊢ k = ⟨k' + 1, k'_succ_in_bounds⟩
|
02ca1706b397b254
|
Vector.mem_mkVector
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lemmas.lean
|
theorem mem_mkVector {a b : α} {n} : b ∈ mkVector n a ↔ n ≠ 0 ∧ b = a
|
α : Type u_1
a b : α
n : Nat
⊢ b ∈ mkVector n a ↔ n ≠ 0 ∧ b = a
|
unfold mkVector
|
α : Type u_1
a b : α
n : Nat
⊢ b ∈ { toArray := mkArray n a, size_toArray := ⋯ } ↔ n ≠ 0 ∧ b = a
|
1fa18089178a4584
|
CategoryTheory.PreGaloisCategory.exists_set_ker_evaluation_subset_of_isOpen
|
Mathlib/CategoryTheory/Galois/Topology.lean
|
/--
If `H` is an open subset of `Aut F` such that `1 ∈ H`, there exists a finite
set `I` of connected objects of `C` such that every `σ : Aut F` that induces the identity
on `F.obj X` for all `X ∈ I` is contained in `H`. In other words: The kernel
of the evaluation map `Aut F →* ∏ X : I ↦ Aut (F.obj X)` is contained in `H`.
-/
lemma exists_set_ker_evaluation_subset_of_isOpen
{H : Set (Aut F)} (h1 : 1 ∈ H) (h : IsOpen H) :
∃ (I : Set C) (_ : Fintype I), (∀ X ∈ I, IsConnected X) ∧
(∀ σ : Aut F, (∀ X : I, σ.hom.app X = 𝟙 (F.obj X)) → σ ∈ H)
|
case intro.intro.intro.intro.intro.refine_2
C : Type u₁
inst✝² : Category.{u₂, u₁} C
F : C ⥤ FintypeCat
inst✝¹ : GaloisCategory C
inst✝ : FiberFunctor F
U : Set ((X : C) → Aut (F.obj X))
hUopen : IsOpen U
h1 : 1 ∈ ⇑(autEmbedding F) ⁻¹' U
h : IsOpen (⇑(autEmbedding F) ⁻¹' U)
I : Finset C
u : (a : C) → Set (Aut (F.obj a))
ho : ∀ a ∈ I, IsOpen (u a) ∧ 1 a ∈ u a
ha : (↑I).pi u ⊆ U
fι : { x // x ∈ I } → Type
ff : (X : { x // x ∈ I }) → fι X → C
fc : (X : { x // x ∈ I }) → (i : fι X) → ff X i ⟶ ↑X
h4 : (X : { x // x ∈ I }) → Limits.IsColimit (Limits.Cofan.mk (↑X) (fc X))
h5 : ∀ (X : { x // x ∈ I }) (i : fι X), IsConnected (ff X i)
h6 : ∀ (X : { x // x ∈ I }), Finite (fι X)
⊢ ∀ (σ : Aut F), (∀ (X : ↑(⋃ X, Set.range (ff X))), σ.hom.app ↑X = 𝟙 (F.obj ↑X)) → σ ∈ ⇑(autEmbedding F) ⁻¹' U
|
refine fun σ h ↦ ha (fun X XinI ↦ ?_)
|
case intro.intro.intro.intro.intro.refine_2
C : Type u₁
inst✝² : Category.{u₂, u₁} C
F : C ⥤ FintypeCat
inst✝¹ : GaloisCategory C
inst✝ : FiberFunctor F
U : Set ((X : C) → Aut (F.obj X))
hUopen : IsOpen U
h1 : 1 ∈ ⇑(autEmbedding F) ⁻¹' U
h✝ : IsOpen (⇑(autEmbedding F) ⁻¹' U)
I : Finset C
u : (a : C) → Set (Aut (F.obj a))
ho : ∀ a ∈ I, IsOpen (u a) ∧ 1 a ∈ u a
ha : (↑I).pi u ⊆ U
fι : { x // x ∈ I } → Type
ff : (X : { x // x ∈ I }) → fι X → C
fc : (X : { x // x ∈ I }) → (i : fι X) → ff X i ⟶ ↑X
h4 : (X : { x // x ∈ I }) → Limits.IsColimit (Limits.Cofan.mk (↑X) (fc X))
h5 : ∀ (X : { x // x ∈ I }) (i : fι X), IsConnected (ff X i)
h6 : ∀ (X : { x // x ∈ I }), Finite (fι X)
σ : Aut F
h : ∀ (X : ↑(⋃ X, Set.range (ff X))), σ.hom.app ↑X = 𝟙 (F.obj ↑X)
X : C
XinI : X ∈ ↑I
⊢ (autEmbedding F) σ X ∈ u X
|
de843c96b0bb42c2
|
Polynomial.dickson_one_one_eq_chebyshev_C
|
Mathlib/RingTheory/Polynomial/Dickson.lean
|
theorem dickson_one_one_eq_chebyshev_C : ∀ n, dickson 1 (1 : R) n = Chebyshev.C R n
| 0 => by
simp only [Chebyshev.C_zero, mul_one, one_comp, dickson_zero]
norm_num
| 1 => by
rw [dickson_one, Nat.cast_one, Chebyshev.C_one]
| n + 2 => by
rw [dickson_add_two, C_1, Nat.cast_add, Nat.cast_two, Chebyshev.C_add_two,
dickson_one_one_eq_chebyshev_C (n + 1), dickson_one_one_eq_chebyshev_C n]
push_cast
ring
|
R : Type u_1
inst✝ : CommRing R
n : ℕ
⊢ X * Chebyshev.C R (↑n + 1) - 1 * Chebyshev.C R ↑n = X * Chebyshev.C R (↑n + 1) - Chebyshev.C R ↑n
|
ring
|
no goals
|
b6460d95bc6e9fea
|
ZNum.bit1_of_bit1
|
Mathlib/Data/Num/Lemmas.lean
|
theorem bit1_of_bit1 : ∀ n : ZNum, n + n + 1 = n.bit1
| 0 => rfl
| pos a => congr_arg pos a.bit1_of_bit1
| neg a => show PosNum.sub' 1 (a + a) = _ by rw [PosNum.one_sub', a.bit0_of_bit0]; rfl
|
a : PosNum
⊢ a.bit0.pred'.toZNumNeg = (neg a).bit1
|
rfl
|
no goals
|
4d88b544d8176352
|
MeasureTheory.generateFrom_measurableCylinders
|
Mathlib/MeasureTheory/Constructions/Cylinders.lean
|
theorem generateFrom_measurableCylinders :
MeasurableSpace.generateFrom (measurableCylinders α) = MeasurableSpace.pi
|
case a
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
S : Set ((i : ι) → α i)
hS : S ∈ measurableCylinders α
⊢ MeasurableSet S
|
obtain ⟨s, S, hSm, rfl⟩ := (mem_measurableCylinders _).mp hS
|
case a.intro.intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
hSm : MeasurableSet S
hS : cylinder s S ∈ measurableCylinders α
⊢ MeasurableSet (cylinder s S)
|
ec147fd1a1925118
|
hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt
|
Mathlib/Analysis/Analytic/Within.lean
|
/-- `f` has power series `p` at `x` iff some local extension of `f` has that series -/
lemma hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt [CompleteSpace F] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {s : Set E} {x : E} :
HasFPowerSeriesWithinAt f p s x ↔
∃ g, f =ᶠ[𝓝[insert x s] x] g ∧ HasFPowerSeriesAt g p x
|
case mp
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u_2
F : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
p : FormalMultilinearSeries 𝕜 E F
s : Set E
x : E
r : ℝ≥0∞
h : HasFPowerSeriesWithinOnBall f p s x r
⊢ ∃ g, f =ᶠ[𝓝[insert x s] x] g ∧ HasFPowerSeriesAt g p x
|
rcases hasFPowerSeriesWithinOnBall_iff_exists_hasFPowerSeriesOnBall.mp h with ⟨g, e, h⟩
|
case mp.intro.intro
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u_2
F : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
p : FormalMultilinearSeries 𝕜 E F
s : Set E
x : E
r : ℝ≥0∞
h✝ : HasFPowerSeriesWithinOnBall f p s x r
g : E → F
e : EqOn f g (insert x s ∩ EMetric.ball x r)
h : HasFPowerSeriesOnBall g p x r
⊢ ∃ g, f =ᶠ[𝓝[insert x s] x] g ∧ HasFPowerSeriesAt g p x
|
7d75f453304e4e39
|
HomologicalComplex.liftCycles_homologyπ_eq_zero_of_boundary
|
Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
|
@[reassoc]
lemma liftCycles_homologyπ_eq_zero_of_boundary {A : C} (k : A ⟶ K.X i) (j : ι)
(hj : c.next i = j) {i' : ι} (x : A ⟶ K.X i') (hx : k = x ≫ K.d i' i) :
K.liftCycles k j hj (by rw [hx, assoc, K.d_comp_d, comp_zero]) ≫ K.homologyπ i = 0
|
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i : ι
inst✝ : K.HasHomology i
A : C
k : A ⟶ K.X i
j : ι
hj : c.next i = j
i' : ι
x : A ⟶ K.X i'
hx : k = x ≫ K.d i' i
h : ¬c.Rel i' i
⊢ K.liftCycles k j hj ⋯ = 0
|
rw [K.shape _ _ h, comp_zero] at hx
|
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i : ι
inst✝ : K.HasHomology i
A : C
k : A ⟶ K.X i
j : ι
hj : c.next i = j
i' : ι
x : A ⟶ K.X i'
hx✝ : k = x ≫ K.d i' i
hx : k = 0
h : ¬c.Rel i' i
⊢ K.liftCycles k j hj ⋯ = 0
|
5f8a23e175db7b00
|
PMF.bindOnSupport_eq_bind
|
Mathlib/Probability/ProbabilityMassFunction/Monad.lean
|
theorem bindOnSupport_eq_bind (p : PMF α) (f : α → PMF β) :
(p.bindOnSupport fun a _ => f a) = p.bind f
|
case h
α : Type u_1
β : Type u_2
p : PMF α
f : α → PMF β
b : β
⊢ (p.bindOnSupport fun a x => f a) b = (p.bind f) b
|
have : ∀ a, ite (p a = 0) 0 (p a * f a b) = p a * f a b :=
fun a => ite_eq_right_iff.2 fun h => h.symm ▸ symm (zero_mul <| f a b)
|
case h
α : Type u_1
β : Type u_2
p : PMF α
f : α → PMF β
b : β
this : ∀ (a : α), (if p a = 0 then 0 else p a * (f a) b) = p a * (f a) b
⊢ (p.bindOnSupport fun a x => f a) b = (p.bind f) b
|
73d900efddd30ac9
|
List.Sublist.find?_isSome
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Find.lean
|
theorem Sublist.find?_isSome {l₁ l₂ : List α} (h : l₁ <+ l₂) : (l₁.find? p).isSome → (l₂.find? p).isSome
|
case cons₂.h_1
α : Type u_1
p : α → Bool
l₁ l₂ l₁✝ l₂✝ : List α
a : α
h : l₁✝ <+ l₂✝
ih : (find? p l₁✝).isSome = true → (find? p l₂✝).isSome = true
x✝ : Bool
heq✝ : p a = true
⊢ (some a).isSome = true → (some a).isSome = true
|
simp
|
no goals
|
2274f4ca6e276067
|
List.sublist_of_orderEmbedding_getElem?_eq
|
Mathlib/Data/List/NodupEquivFin.lean
|
theorem sublist_of_orderEmbedding_getElem?_eq {l l' : List α} (f : ℕ ↪o ℕ)
(hf : ∀ ix : ℕ, l[ix]? = l'[f ix]?) : l <+ l'
|
α : Type u_1
hd : α
tl : List α
IH : ∀ {l' : List α} (f : ℕ ↪o ℕ), (∀ (ix : ℕ), tl[ix]? = l'[f ix]?) → tl <+ l'
l' : List α
f : ℕ ↪o ℕ
hf : ∀ (ix : ℕ), (hd :: tl)[ix]? = l'[f ix]?
w : f 0 < l'.length
h : l'[f 0] = hd
f' : ℕ ↪o ℕ := OrderEmbedding.ofMapLEIff (fun i => f (i + 1) - (f 0 + 1)) ⋯
this : ∀ (ix : ℕ), tl[ix]? = (drop (f 0 + 1) l')[f' ix]?
⊢ [hd] <+ take (f 0 + 1) l'
|
rw [List.singleton_sublist, ← h, l'.getElem_take' _ (Nat.lt_succ_self _)]
|
α : Type u_1
hd : α
tl : List α
IH : ∀ {l' : List α} (f : ℕ ↪o ℕ), (∀ (ix : ℕ), tl[ix]? = l'[f ix]?) → tl <+ l'
l' : List α
f : ℕ ↪o ℕ
hf : ∀ (ix : ℕ), (hd :: tl)[ix]? = l'[f ix]?
w : f 0 < l'.length
h : l'[f 0] = hd
f' : ℕ ↪o ℕ := OrderEmbedding.ofMapLEIff (fun i => f (i + 1) - (f 0 + 1)) ⋯
this : ∀ (ix : ℕ), tl[ix]? = (drop (f 0 + 1) l')[f' ix]?
⊢ (take (f 0).succ l')[f 0] ∈ take (f 0 + 1) l'
|
1ef7e5e229e83d6a
|
ordinaryHypergeometricSeries_eq_zero_iff
|
Mathlib/Analysis/SpecialFunctions/OrdinaryHypergeometric.lean
|
/-- An iff variation on `ordinaryHypergeometricSeries_eq_zero_of_nonpos_int` for `[RCLike 𝕂]`. -/
lemma ordinaryHypergeometricSeries_eq_zero_iff (n : ℕ) :
ordinaryHypergeometricSeries 𝔸 a b c n = 0 ↔ ∃ k < n, k = -a ∨ k = -b ∨ k = -c
|
𝕂 : Type u_1
𝔸 : Type u_2
inst✝² : RCLike 𝕂
inst✝¹ : NormedDivisionRing 𝔸
inst✝ : NormedAlgebra 𝕂 𝔸
a b c : 𝕂
n : ℕ
⊢ ordinaryHypergeometricSeries 𝔸 a b c n = 0 ↔ ∃ k < n, ↑k = -a ∨ ↑k = -b ∨ ↑k = -c
|
refine ⟨fun h ↦ ?_, fun zero ↦ ?_⟩
|
case refine_1
𝕂 : Type u_1
𝔸 : Type u_2
inst✝² : RCLike 𝕂
inst✝¹ : NormedDivisionRing 𝔸
inst✝ : NormedAlgebra 𝕂 𝔸
a b c : 𝕂
n : ℕ
h : ordinaryHypergeometricSeries 𝔸 a b c n = 0
⊢ ∃ k < n, ↑k = -a ∨ ↑k = -b ∨ ↑k = -c
case refine_2
𝕂 : Type u_1
𝔸 : Type u_2
inst✝² : RCLike 𝕂
inst✝¹ : NormedDivisionRing 𝔸
inst✝ : NormedAlgebra 𝕂 𝔸
a b c : 𝕂
n : ℕ
zero : ∃ k < n, ↑k = -a ∨ ↑k = -b ∨ ↑k = -c
⊢ ordinaryHypergeometricSeries 𝔸 a b c n = 0
|
a493be1d40c674b2
|
Matroid.IsBase.compl_closure_diff_singleton_isCocircuit
|
Mathlib/Data/Matroid/Circuit.lean
|
/-- For an element `e` of a base `B`, the complement of the closure of `B \ {e}` is a cocircuit. -/
lemma IsBase.compl_closure_diff_singleton_isCocircuit (hB : M.IsBase B) (he : e ∈ B) :
M.IsCocircuit (M.E \ M.closure (B \ {e}))
|
α : Type u_1
M : Matroid α
e : α
B : Set α
hB : M.IsBase B
he : e ∈ B
hB' : Minimal M.Spanning B
X : Set α
hX : ¬M.Spanning (M.E \ X)
hXss : X ⊆ M.E ∧ Disjoint X (M.closure (B \ {e}))
f : α
hf : f ∈ M.E \ X
fcl : f ∉ M.closure (B \ {e})
⊢ M.Spanning (M.E \ X)
|
suffices hsp : M.IsBase (insert f (B \ {e})) by
refine hsp.spanning.superset <| insert_subset hf <|
(M.subset_closure _ (diff_subset.trans hB.subset_ground)).trans ?_
rw [subset_diff, and_iff_left hXss.2.symm]
apply closure_subset_ground
|
α : Type u_1
M : Matroid α
e : α
B : Set α
hB : M.IsBase B
he : e ∈ B
hB' : Minimal M.Spanning B
X : Set α
hX : ¬M.Spanning (M.E \ X)
hXss : X ⊆ M.E ∧ Disjoint X (M.closure (B \ {e}))
f : α
hf : f ∈ M.E \ X
fcl : f ∉ M.closure (B \ {e})
⊢ M.IsBase (insert f (B \ {e}))
|
2fdba0a4d6c9650b
|
ENNReal.one_lt_rpow_of_pos_of_lt_one_of_neg
|
Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
|
theorem one_lt_rpow_of_pos_of_lt_one_of_neg {x : ℝ≥0∞} {z : ℝ} (hx1 : 0 < x) (hx2 : x < 1)
(hz : z < 0) : 1 < x ^ z
|
case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < x
hx2 : x < 1
⊢ 1 < ↑x ^ z
|
simp [← coe_rpow_of_ne_zero (ne_of_gt hx1), NNReal.one_lt_rpow_of_pos_of_lt_one_of_neg hx1 hx2 hz]
|
no goals
|
791f2a51a4cfdc09
|
Polynomial.coeff_multiset_prod_of_natDegree_le
|
Mathlib/Algebra/Polynomial/BigOperators.lean
|
theorem coeff_multiset_prod_of_natDegree_le (n : ℕ) (hl : ∀ p ∈ t, natDegree p ≤ n) :
coeff t.prod ((Multiset.card t) * n) = (t.map fun p => coeff p n).prod
|
case h
R : Type u
inst✝ : CommSemiring R
t : Multiset R[X]
n : ℕ
a✝ : List R[X]
hl : ∀ p ∈ ⟦a✝⟧, p.natDegree ≤ n
⊢ (prod ⟦a✝⟧).coeff (Multiset.card ⟦a✝⟧ * n) = (Multiset.map (fun p => p.coeff n) ⟦a✝⟧).prod
|
simpa using coeff_list_prod_of_natDegree_le _ _ hl
|
no goals
|
0c4bdb6b8810b577
|
Finsupp.support_sum_eq_biUnion
|
Mathlib/Algebra/BigOperators/Finsupp.lean
|
theorem support_sum_eq_biUnion {α : Type*} {ι : Type*} {M : Type*} [DecidableEq α]
[AddCommMonoid M] {g : ι → α →₀ M} (s : Finset ι)
(h : ∀ i₁ i₂, i₁ ≠ i₂ → Disjoint (g i₁).support (g i₂).support) :
(∑ i ∈ s, g i).support = s.biUnion fun i => (g i).support
|
case refine_2
α : Type u_16
ι : Type u_17
M : Type u_18
inst✝¹ : DecidableEq α
inst✝ : AddCommMonoid M
g : ι → α →₀ M
s✝ : Finset ι
h : ∀ (i₁ i₂ : ι), i₁ ≠ i₂ → Disjoint (g i₁).support (g i₂).support
i : ι
s : Finset ι
hi : i ∉ s
⊢ ((∑ i ∈ s, g i).support = s.biUnion fun i => (g i).support) →
(∑ i ∈ insert i s, g i).support = (insert i s).biUnion fun i => (g i).support
|
simp only [hi, sum_insert, not_false_iff, biUnion_insert]
|
case refine_2
α : Type u_16
ι : Type u_17
M : Type u_18
inst✝¹ : DecidableEq α
inst✝ : AddCommMonoid M
g : ι → α →₀ M
s✝ : Finset ι
h : ∀ (i₁ i₂ : ι), i₁ ≠ i₂ → Disjoint (g i₁).support (g i₂).support
i : ι
s : Finset ι
hi : i ∉ s
⊢ ((∑ i ∈ s, g i).support = s.biUnion fun i => (g i).support) →
(g i + ∑ i ∈ s, g i).support = (g i).support ∪ s.biUnion fun i => (g i).support
|
a2dd55934f7fcee5
|
Polynomial.finiteMultiplicity_of_degree_pos_of_monic
|
Mathlib/Algebra/Polynomial/Div.lean
|
theorem finiteMultiplicity_of_degree_pos_of_monic (hp : (0 : WithBot ℕ) < degree p) (hmp : Monic p)
(hq : q ≠ 0) : FiniteMultiplicity p q :=
have zn0 : (0 : R) ≠ 1 :=
haveI := Nontrivial.of_polynomial_ne hq
zero_ne_one
⟨natDegree q, fun ⟨r, hr⟩ => by
have hp0 : p ≠ 0 := fun hp0 => by simp [hp0] at hp
have hr0 : r ≠ 0 := fun hr0 => by subst hr0; simp [hq] at hr
have hpn1 : leadingCoeff p ^ (natDegree q + 1) = 1
|
R : Type u
inst✝ : Semiring R
p q : R[X]
hp : 0 < p.degree
hmp : p.Monic
hq : q ≠ 0
zn0 : 0 ≠ 1
x✝ : p ^ (q.natDegree + 1) ∣ q
r : R[X]
hr : q = p ^ (q.natDegree + 1) * r
hp0 : p ≠ 0
hr0 : r ≠ 0
⊢ p.leadingCoeff ^ (q.natDegree + 1) = 1
|
simp [show _ = _ from hmp]
|
no goals
|
e99ce1288ab09150
|
Real.summable_nat_rpow_inv
|
Mathlib/Analysis/PSeries.lean
|
theorem summable_nat_rpow_inv {p : ℝ} :
Summable (fun n => ((n : ℝ) ^ p)⁻¹ : ℕ → ℝ) ↔ 1 < p
|
p : ℝ
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p
|
rcases le_or_lt 0 p with hp | hp
|
case inl
p : ℝ
hp : 0 ≤ p
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p
case inr
p : ℝ
hp : p < 0
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p
|
3c89ea3843e56182
|
ZMod.Ico_map_valMinAbs_natAbs_eq_Ico_map_id
|
Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean
|
theorem Ico_map_valMinAbs_natAbs_eq_Ico_map_id (p : ℕ) [hp : Fact p.Prime] (a : ZMod p)
(hap : a ≠ 0) : ((Ico 1 (p / 2).succ).1.map fun (x : ℕ) => (a * x).valMinAbs.natAbs) =
(Ico 1 (p / 2).succ).1.map fun a => a
|
case refine_3
p : ℕ
hp : Fact (Nat.Prime p)
a : ZMod p
hap : a ≠ 0
he : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → x ≠ 0 ∧ x ≤ p / 2
hep : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → x < p
hpe : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → ¬p ∣ x
hmem : ∀ x ∈ Ico 1 (p / 2).succ, (a * ↑x).valMinAbs.natAbs ∈ Ico 1 (p / 2).succ
b : ℕ
hb : b ∈ Ico 1 (p / 2).succ
⊢ (a * ↑(↑b / a).valMinAbs.natAbs).valMinAbs.natAbs = b
|
rw [natCast_natAbs_valMinAbs]
|
case refine_3
p : ℕ
hp : Fact (Nat.Prime p)
a : ZMod p
hap : a ≠ 0
he : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → x ≠ 0 ∧ x ≤ p / 2
hep : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → x < p
hpe : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → ¬p ∣ x
hmem : ∀ x ∈ Ico 1 (p / 2).succ, (a * ↑x).valMinAbs.natAbs ∈ Ico 1 (p / 2).succ
b : ℕ
hb : b ∈ Ico 1 (p / 2).succ
⊢ (a * if (↑b / a).val ≤ p / 2 then ↑b / a else -(↑b / a)).valMinAbs.natAbs = b
|
e252720ce4f19196
|
Submodule.exists_of_finrank_lt
|
Mathlib/LinearAlgebra/Dimension/RankNullity.lean
|
lemma Submodule.exists_of_finrank_lt (N : Submodule R M) (h : finrank R N < finrank R M) :
∃ m : M, ∀ r : R, r ≠ 0 → r • m ∉ N
|
R : Type u_1
M : Type u
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : HasRankNullity.{u, u_1} R
inst✝¹ : StrongRankCondition R
inst✝ : Module.Finite R M
N : Submodule R M
h : finrank R ↥N < finrank R M
⊢ ∃ m, ∀ (r : R), r ≠ 0 → r • m ∉ N
|
obtain ⟨s, hs, hs'⟩ :=
exists_finset_linearIndependent_of_le_finrank (R := R) (M := M ⧸ N) le_rfl
|
case intro.intro
R : Type u_1
M : Type u
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : HasRankNullity.{u, u_1} R
inst✝¹ : StrongRankCondition R
inst✝ : Module.Finite R M
N : Submodule R M
h : finrank R ↥N < finrank R M
s : Finset (M ⧸ N)
hs : s.card = finrank R (M ⧸ N)
hs' : LinearIndependent R Subtype.val
⊢ ∃ m, ∀ (r : R), r ≠ 0 → r • m ∉ N
|
d0deb43894149df2
|
Mon_.Mon_tensor_mul_one
|
Mathlib/CategoryTheory/Monoidal/Mon_.lean
|
theorem Mon_tensor_mul_one (M N : Mon_ C) :
(M.X ⊗ N.X) ◁ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ≫
tensorμ M.X N.X M.X N.X ≫ (M.mul ⊗ N.mul) =
(ρ_ (M.X ⊗ N.X)).hom
|
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ≫ tensorμ M.X N.X M.X N.X ≫ (M.mul ⊗ N.mul) = (ρ_ (M.X ⊗ N.X)).hom
|
simp only [MonoidalCategory.whiskerLeft_comp_assoc]
|
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ (M.X ⊗ N.X) ◁ (M.one ⊗ N.one) ≫ tensorμ M.X N.X M.X N.X ≫ (M.mul ⊗ N.mul) =
(ρ_ (M.X ⊗ N.X)).hom
|
ab2c59919df5e976
|
nullMeasurableSet_eq_fun
|
Mathlib/MeasureTheory/Group/Arithmetic.lean
|
theorem nullMeasurableSet_eq_fun {E} [MeasurableSpace E] [AddGroup E] [MeasurableSingletonClass E]
[MeasurableSub₂ E] {f g : α → E} (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
NullMeasurableSet { x | f x = g x } μ
|
α : Type u_3
m : MeasurableSpace α
μ : Measure α
E : Type u_5
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : AEMeasurable f μ
hg : AEMeasurable g μ
⊢ NullMeasurableSet {x | f x = g x} μ
|
apply (measurableSet_eq_fun hf.measurable_mk hg.measurable_mk).nullMeasurableSet.congr
|
α : Type u_3
m : MeasurableSpace α
μ : Measure α
E : Type u_5
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : AEMeasurable f μ
hg : AEMeasurable g μ
⊢ {x | AEMeasurable.mk f hf x = AEMeasurable.mk g hg x} =ᶠ[ae μ] {x | f x = g x}
|
61e903ad7d72f47f
|
MeasureTheory.Measure.MeasureDense.nonempty'
|
Mathlib/MeasureTheory/Measure/SeparableMeasure.lean
|
theorem Measure.MeasureDense.nonempty' (h𝒜 : μ.MeasureDense 𝒜) :
{s | s ∈ 𝒜 ∧ μ s ≠ ∞}.Nonempty
|
X : Type u_1
m : MeasurableSpace X
μ : Measure X
𝒜 : Set (Set X)
h𝒜 : μ.MeasureDense 𝒜
⊢ μ ∅ ≠ ⊤
|
simp
|
no goals
|
ee3a4f6befa99af8
|
MeasureTheory.Measure.exists_null_set_measure_lt_of_disjoint
|
Mathlib/MeasureTheory/Measure/MutuallySingular.lean
|
lemma exists_null_set_measure_lt_of_disjoint (h : Disjoint μ ν) {ε : ℝ≥0} (hε : 0 < ε) :
∃ s, μ s = 0 ∧ ν sᶜ ≤ 2 * ε
|
α : Type u_1
m0 : MeasurableSpace α
μ ν : Measure α
h : Disjoint μ ν
ε : ℝ≥0
hε : 0 < ε
h₁ : sInf {m | ∃ t, m = μ t + ν tᶜ} = 0
n : ℕ
⊢ ∃ x ∈ {m | ∃ t, m = μ t + ν tᶜ}, x < ↑ε * (1 / 2) ^ n
|
refine exists_lt_of_csInf_lt ⟨ν univ, ∅, by simp⟩ <| h₁ ▸ ENNReal.mul_pos ?_ (by simp)
|
α : Type u_1
m0 : MeasurableSpace α
μ ν : Measure α
h : Disjoint μ ν
ε : ℝ≥0
hε : 0 < ε
h₁ : sInf {m | ∃ t, m = μ t + ν tᶜ} = 0
n : ℕ
⊢ ↑ε ≠ 0
|
46dcd329efc0e15f
|
mdifferentiableWithinAt_iff_target_inter
|
Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
|
theorem mdifferentiableWithinAt_iff_target_inter {f : M → M'} {s : Set M} {x : M} :
MDifferentiableWithinAt I I' f s x ↔
ContinuousWithinAt f s x ∧
DifferentiableWithinAt 𝕜 (writtenInExtChartAt I I' x f)
((extChartAt I x).target ∩ (extChartAt I x).symm ⁻¹' s) ((extChartAt I x) x)
|
𝕜 : 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
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝² : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
f : M → M'
s : Set M
x : M
f' : E →L[𝕜] E'
⊢ HasFDerivWithinAt (writtenInExtChartAt I I' x f) f' (↑(extChartAt I x).symm ⁻¹' s ∩ range ↑I) (↑(extChartAt I x) x) ↔
HasFDerivWithinAt (writtenInExtChartAt I I' x f) f' ((extChartAt I x).target ∩ ↑(extChartAt I x).symm ⁻¹' s)
(↑(extChartAt I x) x)
|
rw [inter_comm]
|
𝕜 : 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
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝² : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
f : M → M'
s : Set M
x : M
f' : E →L[𝕜] E'
⊢ HasFDerivWithinAt (writtenInExtChartAt I I' x f) f' (range ↑I ∩ ↑(extChartAt I x).symm ⁻¹' s) (↑(extChartAt I x) x) ↔
HasFDerivWithinAt (writtenInExtChartAt I I' x f) f' ((extChartAt I x).target ∩ ↑(extChartAt I x).symm ⁻¹' s)
(↑(extChartAt I x) x)
|
a64a17f87a4a2dee
|
Asymptotics.isBigO_mul_iff_isBigO_div
|
Mathlib/Analysis/Asymptotics/Lemmas.lean
|
lemma isBigO_mul_iff_isBigO_div {f g h : α → 𝕜} (hf : ∀ᶠ x in l, f x ≠ 0) :
(fun x ↦ f x * g x) =O[l] h ↔ g =O[l] (fun x ↦ h x / f x)
|
case refine_2
α : Type u_1
𝕜 : Type u_15
inst✝ : NormedDivisionRing 𝕜
l : Filter α
f g h : α → 𝕜
hf : ∀ᶠ (x : α) in l, f x ≠ 0
x✝ : ∃ c > 0, ∀ᶠ (x : α) in l, ‖g x‖ ≤ c * ‖h x / f x‖
c : ℝ
hc : c > 0
H : ∀ᶠ (x : α) in l, ‖g x‖ ≤ c * ‖h x / f x‖
x : α
hx : f x ≠ 0
⊢ ‖g x‖ ≤ c * ‖h x / f x‖ ↔ ‖f x * g x‖ ≤ c * ‖h x‖
|
rw [norm_mul, norm_div, ← mul_div_assoc, le_div_iff₀' (norm_pos_iff.mpr hx)]
|
no goals
|
219d5b36b9b4d2b9
|
MeasureTheory.integral_condExpL2_eq
|
Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
|
theorem integral_condExpL2_eq (hm : m ≤ m0) (f : Lp E' 2 μ) (hs : MeasurableSet[m] s)
(hμs : μ s ≠ ∞) : ∫ x in s, (condExpL2 E' 𝕜 hm f : α → E') x ∂μ = ∫ x in s, f x ∂μ
|
α : Type u_1
E' : Type u_3
𝕜 : Type u_7
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
f : ↥(Lp E' 2 μ)
hs : MeasurableSet s
hμs : μ s ≠ ⊤
⊢ ∫ (x : α) in s, ↑↑↑((condExpL2 E' 𝕜 hm) f) x ∂μ = ∫ (x : α) in s, ↑↑f x ∂μ
|
rw [← sub_eq_zero, ←
integral_sub' (integrableOn_Lp_of_measure_ne_top _ fact_one_le_two_ennreal.elim hμs)
(integrableOn_Lp_of_measure_ne_top _ fact_one_le_two_ennreal.elim hμs)]
|
α : Type u_1
E' : Type u_3
𝕜 : Type u_7
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
f : ↥(Lp E' 2 μ)
hs : MeasurableSet s
hμs : μ s ≠ ⊤
⊢ ∫ (a : α) in s, (↑↑↑((condExpL2 E' 𝕜 hm) f) - ↑↑f) a ∂μ = 0
|
f34acd4f2cd16da9
|
Basis.SmithNormalForm.toAddSubgroup_index_eq_pow_mul_prod
|
Mathlib/LinearAlgebra/FreeModule/Int.lean
|
/-- Given a submodule `N` in Smith normal form of a free `R`-module, its index as an additive
subgroup is an appropriate power of the cardinality of `R` multiplied by the product of the
indexes of the ideals generated by each basis vector. -/
lemma toAddSubgroup_index_eq_pow_mul_prod [Module R M] {N : Submodule R M}
(snf : Basis.SmithNormalForm N ι n) :
N.toAddSubgroup.index = Nat.card R ^ (Fintype.card ι - n) *
∏ i : Fin n, (Ideal.span {snf.a i}).toAddSubgroup.index
|
case h.intro
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Fintype ι
inst✝ : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf : ∀ (i : Fin n), ↑(bN i) = a i • bM (f i)
N' : Submodule R (ι → R) := Submodule.map bM.equivFun N
hN'✝ : N' = Submodule.map bM.equivFun N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' : ∀ (i : Fin n), ↑(bN' i) = Pi.single (f i) (a i)
hNN' : N.toAddSubgroup.index = N'.toAddSubgroup.index
hN' :
N'.toAddSubgroup =
AddSubgroup.pi Set.univ fun i => Submodule.toAddSubgroup (Ideal.span {if h : ∃ j, f j = i then a h.choose else 0})
f' : Fin n → { x // x ∈ Finset.filter (fun x => ∃ j, f j = x) Finset.univ } := fun i => ⟨f i, ⋯⟩
hf' : Function.Injective f'
f'' : Fin n ↪ { x // x ∈ Finset.filter (fun x => ∃ j, f j = x) Finset.univ } := { toFun := f', inj' := hf' }
x : { x // x ∈ Finset.filter (fun x => ∃ j, f j = x) Finset.univ }
i : Fin n
hi : f i = ↑x
⊢ ∃ a, f'' a = x
|
refine ⟨i, ?_⟩
|
case h.intro
ι : Type u_1
R : Type u_2
M : Type u_3
n : ℕ
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Fintype ι
inst✝ : Module R M
N : Submodule R M
bM : Basis ι R M
bN : Basis (Fin n) R ↥N
f : Fin n ↪ ι
a : Fin n → R
snf : ∀ (i : Fin n), ↑(bN i) = a i • bM (f i)
N' : Submodule R (ι → R) := Submodule.map bM.equivFun N
hN'✝ : N' = Submodule.map bM.equivFun N
bN' : Basis (Fin n) R ↥N' := bN.map (bM.equivFun.submoduleMap N)
snf' : ∀ (i : Fin n), ↑(bN' i) = Pi.single (f i) (a i)
hNN' : N.toAddSubgroup.index = N'.toAddSubgroup.index
hN' :
N'.toAddSubgroup =
AddSubgroup.pi Set.univ fun i => Submodule.toAddSubgroup (Ideal.span {if h : ∃ j, f j = i then a h.choose else 0})
f' : Fin n → { x // x ∈ Finset.filter (fun x => ∃ j, f j = x) Finset.univ } := fun i => ⟨f i, ⋯⟩
hf' : Function.Injective f'
f'' : Fin n ↪ { x // x ∈ Finset.filter (fun x => ∃ j, f j = x) Finset.univ } := { toFun := f', inj' := hf' }
x : { x // x ∈ Finset.filter (fun x => ∃ j, f j = x) Finset.univ }
i : Fin n
hi : f i = ↑x
⊢ f'' i = x
|
3d7a9cb7455a5c0f
|
RelEmbedding.wellFounded_iff_no_descending_seq
|
Mathlib/Order/OrderIsoNat.lean
|
theorem wellFounded_iff_no_descending_seq :
WellFounded r ↔ IsEmpty (((· > ·) : ℕ → ℕ → Prop) ↪r r)
|
α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
⊢ WellFounded r ↔ IsEmpty ((fun x1 x2 => x1 > x2) ↪r r)
|
constructor
|
case mp
α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
⊢ WellFounded r → IsEmpty ((fun x1 x2 => x1 > x2) ↪r r)
case mpr
α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
⊢ IsEmpty ((fun x1 x2 => x1 > x2) ↪r r) → WellFounded r
|
a6580d144ed4d55c
|
Finsupp.toMultiset_inf
|
Mathlib/Data/Finsupp/Multiset.lean
|
theorem toMultiset_inf [DecidableEq α] (f g : α →₀ ℕ) :
toMultiset (f ⊓ g) = toMultiset f ∩ toMultiset g
|
case a
α : Type u_1
inst✝ : DecidableEq α
f g : α →₀ ℕ
a✝ : α
⊢ Multiset.count a✝ (toMultiset (f ⊓ g)) = Multiset.count a✝ (toMultiset f ∩ toMultiset g)
|
simp_rw [Multiset.count_inter, Finsupp.count_toMultiset, Finsupp.inf_apply]
|
no goals
|
8dc92bc5d42502cf
|
compl_beattySeq'
|
Mathlib/NumberTheory/Rayleigh.lean
|
theorem compl_beattySeq' {r s : ℝ} (hrs : r.IsConjExponent s) :
{beattySeq' r k | k}ᶜ = {beattySeq s k | k}
|
r s : ℝ
hrs : r.IsConjExponent s
⊢ {x | ∃ k, beattySeq' r k = x}ᶜ = {x | ∃ k, beattySeq s k = x}
|
rw [← compl_beattySeq hrs.symm, compl_compl]
|
no goals
|
9d55751ae3eab88e
|
Real.cos_one_le
|
Mathlib/Data/Complex/Trigonometric.lean
|
theorem cos_one_le : cos 1 ≤ 2 / 3 :=
calc
cos 1 ≤ |(1 : ℝ)| ^ 4 * (5 / 96) + (1 - 1 ^ 2 / 2) :=
sub_le_iff_le_add.1 (abs_sub_le_iff.1 (cos_bound (by simp))).1
_ ≤ 2 / 3
|
⊢ |1| ≤ 1
|
simp
|
no goals
|
48c3779b08bee2a9
|
CategoryTheory.Equalizer.FirstObj.ext
|
Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean
|
@[ext]
lemma FirstObj.ext (z₁ z₂ : FirstObj P R) (h : ∀ (Y : C) (f : Y ⟶ X)
(hf : R f), (Pi.π _ ⟨Y, f, hf⟩ : FirstObj P R ⟶ _) z₁ =
(Pi.π _ ⟨Y, f, hf⟩ : FirstObj P R ⟶ _) z₂) : z₁ = z₂
|
case w.mk.mk.mk
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
z₁ z₂ : FirstObj P R
h :
∀ (Y : C) (f : Y ⟶ X) (hf : R f),
Pi.π (fun f => P.obj (op f.fst)) ⟨Y, ⟨f, hf⟩⟩ z₁ = Pi.π (fun f => P.obj (op f.fst)) ⟨Y, ⟨f, hf⟩⟩ z₂
Y : C
f : Y ⟶ X
hf : R f
⊢ limit.π (Discrete.functor fun f => P.obj (op f.fst)) { as := ⟨Y, ⟨f, hf⟩⟩ } z₁ =
limit.π (Discrete.functor fun f => P.obj (op f.fst)) { as := ⟨Y, ⟨f, hf⟩⟩ } z₂
|
exact h Y f hf
|
no goals
|
8938781a772e1fb2
|
Finset.filter_eq
|
Mathlib/Data/Finset/Basic.lean
|
theorem filter_eq [DecidableEq β] (s : Finset β) (b : β) :
s.filter (Eq b) = ite (b ∈ s) {b} ∅
|
β : Type u_2
inst✝ : DecidableEq β
s : Finset β
b : β
⊢ filter (Eq b) s = if b ∈ s then {b} else ∅
|
split_ifs with h
|
case pos
β : Type u_2
inst✝ : DecidableEq β
s : Finset β
b : β
h : b ∈ s
⊢ filter (Eq b) s = {b}
case neg
β : Type u_2
inst✝ : DecidableEq β
s : Finset β
b : β
h : b ∉ s
⊢ filter (Eq b) s = ∅
|
9fc7f62c5981b89a
|
Fintype.existsUnique_iff_card_one
|
Mathlib/Data/Fintype/Card.lean
|
theorem existsUnique_iff_card_one {α} [Fintype α] (p : α → Prop) [DecidablePred p] :
(∃! a : α, p a) ↔ #{x | p x} = 1
|
α : Type u_4
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
x : α
⊢ ((fun a => p a) x ∧ ∀ (y : α), (fun a => p a) y → y = x) ↔ filter (fun x => p x) univ = {x}
|
simp only [forall_true_left, Subset.antisymm_iff, subset_singleton_iff', singleton_subset_iff,
true_and, and_comm, mem_univ, mem_filter]
|
no goals
|
4e1554b432de7ff6
|
two_nsmul_lie_lmul_lmul_add_add_eq_zero
|
Mathlib/Algebra/Jordan/Basic.lean
|
theorem two_nsmul_lie_lmul_lmul_add_add_eq_zero (a b c : A) :
2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆) = 0
|
A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆) = 0
|
symm
|
A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆)
|
fbf41adf7c29b267
|
Complex.norm_cpow_of_imp
|
Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
|
theorem norm_cpow_of_imp {z w : ℂ} (h : z = 0 → w.re = 0 → w = 0) :
‖z ^ w‖ = ‖z‖ ^ w.re / Real.exp (arg z * im w)
|
case inr.inr
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
hw : w.re ≠ 0
⊢ ‖0 ^ w‖ = 0 ^ w.re / rexp (arg 0 * w.im)
|
rw [Real.zero_rpow hw, zero_div, zero_cpow, norm_zero]
|
case inr.inr
w : ℂ
h : 0 = 0 → w.re = 0 → w = 0
hw : w.re ≠ 0
⊢ w ≠ 0
|
f0a8ca76acd54989
|
accPt_iff_frequently
|
Mathlib/Topology/Basic.lean
|
theorem accPt_iff_frequently (x : X) (C : Set X) : AccPt x (𝓟 C) ↔ ∃ᶠ y in 𝓝 x, y ≠ x ∧ y ∈ C
|
X : Type u
inst✝ : TopologicalSpace X
x : X
C : Set X
⊢ AccPt x (𝓟 C) ↔ ∃ᶠ (y : X) in 𝓝 x, y ≠ x ∧ y ∈ C
|
simp [acc_principal_iff_cluster, clusterPt_principal_iff_frequently, and_comm]
|
no goals
|
0d9cb88735e1fe10
|
VitaliFamily.ae_tendsto_rnDeriv_of_absolutelyContinuous
|
Mathlib/MeasureTheory/Covering/Differentiation.lean
|
theorem ae_tendsto_rnDeriv_of_absolutelyContinuous :
∀ᵐ x ∂μ, Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (ρ.rnDeriv μ x))
|
α : Type u_1
inst✝⁴ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
A : (μ.withDensity (v.limRatioMeas hρ)).rnDeriv μ =ᶠ[ae μ] v.limRatioMeas hρ
⊢ ∀ᵐ (x : α) ∂μ, Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (ρ.rnDeriv μ x))
|
rw [v.withDensity_limRatioMeas_eq hρ] at A
|
α : Type u_1
inst✝⁴ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
A : ρ.rnDeriv μ =ᶠ[ae μ] v.limRatioMeas hρ
⊢ ∀ᵐ (x : α) ∂μ, Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (ρ.rnDeriv μ x))
|
e1b9b24b7141c8ab
|
ZFSet.sUnion_lem
|
Mathlib/SetTheory/ZFC/Basic.lean
|
theorem sUnion_lem {α β : Type u} (A : α → PSet) (B : β → PSet) (αβ : ∀ a, ∃ b, Equiv (A a) (B b)) :
∀ a, ∃ b, Equiv ((sUnion ⟨α, A⟩).Func a) ((sUnion ⟨β, B⟩).Func b)
| ⟨a, c⟩ => by
let ⟨b, hb⟩ := αβ a
induction' ea : A a with γ Γ
induction' eb : B b with δ Δ
rw [ea, eb] at hb
obtain ⟨γδ, δγ⟩ := hb
let c : (A a).Type := c
let ⟨d, hd⟩ := γδ (by rwa [ea] at c)
use ⟨b, Eq.ndrec d (Eq.symm eb)⟩
change PSet.Equiv ((A a).Func c) ((B b).Func (Eq.ndrec d eb.symm))
match A a, B b, ea, eb, c, d, hd with
| _, _, rfl, rfl, _, _, hd => exact hd
|
case mk.mk.intro
α β : Type u
A : α → PSet.{u}
B : β → PSet.{u}
αβ : ∀ (a : α), ∃ b, (A a).Equiv (B b)
a : (PSet.mk α A).Type
c : ((PSet.mk α A).Func a).Type
b : β
γ : Type u
Γ : γ → PSet.{u}
A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, ((⋃₀ PSet.mk α A).Func ⟨a, c⟩).Equiv ((⋃₀ PSet.mk β B).Func b)
ea : A a = PSet.mk γ Γ
δ : Type u
Δ : δ → PSet.{u}
A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, ((⋃₀ PSet.mk α A).Func ⟨a, c⟩).Equiv ((⋃₀ PSet.mk β B).Func b)
eb : B b = PSet.mk δ Δ
γδ : ∀ (a : γ), ∃ b, (Γ a).Equiv (Δ b)
δγ : ∀ (b : δ), ∃ a, (Γ a).Equiv (Δ b)
⊢ ∃ b, ((⋃₀ PSet.mk α A).Func ⟨a, c⟩).Equiv ((⋃₀ PSet.mk β B).Func b)
|
let c : (A a).Type := c
|
case mk.mk.intro
α β : Type u
A : α → PSet.{u}
B : β → PSet.{u}
αβ : ∀ (a : α), ∃ b, (A a).Equiv (B b)
a : (PSet.mk α A).Type
c✝ : ((PSet.mk α A).Func a).Type
b : β
γ : Type u
Γ : γ → PSet.{u}
A_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, ((⋃₀ PSet.mk α A).Func ⟨a, c✝⟩).Equiv ((⋃₀ PSet.mk β B).Func b)
ea : A a = PSet.mk γ Γ
δ : Type u
Δ : δ → PSet.{u}
A_ih✝ : ∀ (a_1 : δ), B b = Δ a_1 → ∃ b, ((⋃₀ PSet.mk α A).Func ⟨a, c✝⟩).Equiv ((⋃₀ PSet.mk β B).Func b)
eb : B b = PSet.mk δ Δ
γδ : ∀ (a : γ), ∃ b, (Γ a).Equiv (Δ b)
δγ : ∀ (b : δ), ∃ a, (Γ a).Equiv (Δ b)
c : (A a).Type := c✝
⊢ ∃ b, ((⋃₀ PSet.mk α A).Func ⟨a, c✝⟩).Equiv ((⋃₀ PSet.mk β B).Func b)
|
45858e0f18942367
|
CategoryTheory.ShortComplex.exact_iff_epi_imageToKernel
|
Mathlib/CategoryTheory/Abelian/Exact.lean
|
theorem exact_iff_epi_imageToKernel : S.Exact ↔ Epi (imageToKernel S.f S.g S.zero)
|
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
S : ShortComplex C
⊢ S.Exact ↔ Epi (imageToKernel S.f S.g ⋯)
|
rw [S.exact_iff_epi_imageToKernel']
|
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
S : ShortComplex C
⊢ Epi (imageToKernel' S.f S.g ⋯) ↔ Epi (imageToKernel S.f S.g ⋯)
|
ea672dc3f1e3da8c
|
SemiNormedGrp.explicitCokernelDesc_unique
|
Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean
|
theorem explicitCokernelDesc_unique {X Y Z : SemiNormedGrp.{u}} {f : X ⟶ Y} {g : Y ⟶ Z}
(w : f ≫ g = 0) (e : explicitCokernel f ⟶ Z) (he : explicitCokernelπ f ≫ e = g) :
e = explicitCokernelDesc w
|
X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
e : explicitCokernel f ⟶ Z
he : explicitCokernelπ f ≫ e = g
⊢ e = explicitCokernelDesc w
|
apply (isColimitCokernelCocone f).uniq (Cofork.ofπ g (by simp [w]))
|
case x
X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
e : explicitCokernel f ⟶ Z
he : explicitCokernelπ f ≫ e = g
⊢ ∀ (j : WalkingParallelPair), (cokernelCocone f).ι.app j ≫ e = (Cofork.ofπ g ⋯).ι.app j
|
d83ba6fbc8e92dee
|
Polynomial.exists_approx_polynomial_aux
|
Mathlib/NumberTheory/ClassNumber/AdmissibleCardPowDegree.lean
|
theorem exists_approx_polynomial_aux [Ring Fq] {d : ℕ} {m : ℕ} (hm : Fintype.card Fq ^ d ≤ m)
(b : Fq[X]) (A : Fin m.succ → Fq[X]) (hA : ∀ i, degree (A i) < degree b) :
∃ i₀ i₁, i₀ ≠ i₁ ∧ degree (A i₁ - A i₀) < ↑(natDegree b - d)
|
case right
Fq : Type u_1
inst✝¹ : Fintype Fq
inst✝ : Ring Fq
d m : ℕ
hm : Fintype.card Fq ^ d ≤ m
b : Fq[X]
A : Fin m.succ → Fq[X]
hA : ∀ (i : Fin m.succ), (A i).degree < b.degree
hb : b ≠ 0
f : Fin m.succ → Fin d → Fq := fun i j => (A i).coeff (b.natDegree - ↑j.succ)
this : Fintype.card (Fin d → Fq) < Fintype.card (Fin m.succ)
i₀ i₁ : Fin m.succ
i_ne : i₀ ≠ i₁
i_eq : f i₀ = f i₁
⊢ (A i₁ - A i₀).degree < ↑(b.natDegree - d)
|
refine (degree_lt_iff_coeff_zero _ _).mpr fun j hj => ?_
|
case right
Fq : Type u_1
inst✝¹ : Fintype Fq
inst✝ : Ring Fq
d m : ℕ
hm : Fintype.card Fq ^ d ≤ m
b : Fq[X]
A : Fin m.succ → Fq[X]
hA : ∀ (i : Fin m.succ), (A i).degree < b.degree
hb : b ≠ 0
f : Fin m.succ → Fin d → Fq := fun i j => (A i).coeff (b.natDegree - ↑j.succ)
this : Fintype.card (Fin d → Fq) < Fintype.card (Fin m.succ)
i₀ i₁ : Fin m.succ
i_ne : i₀ ≠ i₁
i_eq : f i₀ = f i₁
j : ℕ
hj : b.natDegree - d ≤ j
⊢ (A i₁ - A i₀).coeff j = 0
|
98b1c3c064e383ea
|
Valued.continuous_extension
|
Mathlib/Topology/Algebra/Valued/ValuedField.lean
|
theorem continuous_extension : Continuous (Valued.extension : hat K → Γ₀)
|
case a
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ⇑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑x ∈ V → v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : 0 ∉ V'
hV' : ∀ x ∈ V', ∀ y ∈ V', x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑a = (fun x => x * x₀) y
this : ↑z₀⁻¹ = (↑z₀)⁻¹
⊢ y * y₀⁻¹ ∈ V
|
solve_by_elim
|
no goals
|
af62a79ad478b7b6
|
RingHom.OfLocalizationSpan.ofIsLocalization
|
Mathlib/RingTheory/LocalProperties/Basic.lean
|
lemma RingHom.OfLocalizationSpan.ofIsLocalization
(hP : RingHom.OfLocalizationSpan P) (hPi : RingHom.RespectsIso P)
{R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) (s : Set R) (hs : Ideal.span s = ⊤)
(hT : ∀ r : s, ∃ (Rᵣ Sᵣ : Type u) (_ : CommRing Rᵣ) (_ : CommRing Sᵣ)
(_ : Algebra R Rᵣ) (_ : Algebra S Sᵣ) (_ : IsLocalization.Away r.val Rᵣ)
(_ : IsLocalization.Away (f r.val) Sᵣ) (fᵣ : Rᵣ →+* Sᵣ)
(_ : fᵣ.comp (algebraMap R Rᵣ) = (algebraMap S Sᵣ).comp f),
P fᵣ) : P f
|
case h.a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : OfLocalizationSpan fun {R S} [CommRing R] [CommRing S] => P
hPi : RespectsIso fun {R S} [CommRing R] [CommRing S] => P
R S : Type u
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
s : Set R
hs : Ideal.span s = ⊤
hT :
∀ (r : ↑s),
∃ Rᵣ Sᵣ x x_1 x_2 x_3,
∃ (_ : IsLocalization.Away (↑r) Rᵣ) (_ : IsLocalization.Away (f ↑r) Sᵣ),
∃ fᵣ, ∃ (_ : fᵣ.comp (algebraMap R Rᵣ) = (algebraMap S Sᵣ).comp f), P fᵣ
r : ↑s
Rᵣ Sᵣ : Type u
w✝⁵ : CommRing Rᵣ
w✝⁴ : CommRing Sᵣ
w✝³ : Algebra R Rᵣ
w✝² : Algebra S Sᵣ
w✝¹ : IsLocalization.Away (↑r) Rᵣ
w✝ : IsLocalization.Away (f ↑r) Sᵣ
fᵣ : Rᵣ →+* Sᵣ
hfᵣ : fᵣ.comp (algebraMap R Rᵣ) = (algebraMap S Sᵣ).comp f
hf : P fᵣ
e₁ : Localization (Submonoid.powers ↑r) ≃+* Rᵣ := (Localization.algEquiv (Submonoid.powers ↑r) Rᵣ).toRingEquiv
e₂ : Sᵣ ≃+* Localization (Submonoid.powers (f ↑r)) :=
(IsLocalization.algEquiv (Submonoid.powers (f ↑r)) (Localization (Submonoid.powers (f ↑r))) Sᵣ).symm.toRingEquiv
x : R
this : fᵣ ((algebraMap R Rᵣ) x) = (algebraMap S Sᵣ) (f x)
⊢ ((Localization.awayMap f ↑r).comp (algebraMap R (Localization.Away ↑r))) x =
(((e₂.toRingHom.comp fᵣ).comp e₁.toRingHom).comp (algebraMap R (Localization.Away ↑r))) x
|
simp [-AlgEquiv.symm_toRingEquiv, e₂, e₁, Localization.awayMap, IsLocalization.Away.map, this]
|
no goals
|
57208d6eb9a6680e
|
Stream'.Seq.ofStream_cons
|
Mathlib/Data/Seq/Seq.lean
|
theorem ofStream_cons (a : α) (s) : ofStream (a::s) = cons a (ofStream s)
|
case a
α : Type u
a : α
s : Stream' α
⊢ ↑↑(a :: s) = ↑(cons a ↑s)
|
simp only [ofStream, cons]
|
case a
α : Type u
a : α
s : Stream' α
⊢ Stream'.map some (a :: s) = some a :: Stream'.map some s
|
83329d52b9e3fbd1
|
εNFA.mem_evalFrom_iff_exists_path
|
Mathlib/Computability/EpsilonNFA.lean
|
theorem mem_evalFrom_iff_exists_path {s₁ s₂ : σ} {x : List α} :
s₂ ∈ M.evalFrom {s₁} x ↔ ∃ x', x'.reduceOption = x ∧ M.IsPath s₁ s₂ x'
|
case h
α : Type u
σ : Type v
M : εNFA α σ
s₁ : σ
x : List α
a : α
ih : ∀ {s₂ : σ}, s₂ ∈ M.evalFrom {s₁} x ↔ ∃ x', x'.reduceOption = x ∧ M.IsPath s₁ s₂ x'
s₂ : σ
x' : List (Option α)
left✝¹ : x'.reduceOption = x
n : ℕ
t : σ
left✝ : M.IsPath s₁ t x'
u : σ
a✝¹ : u ∈ M.step t (some a)
a✝ : M.IsPath u s₂ (List.replicate n none)
⊢ (∃ x', x'.reduceOption = x ∧ M.IsPath s₁ t x') ∧ ∃ t_1 ∈ M.step t (some a), s₂ ∈ M.εClosure {t_1}
|
simp_rw [mem_εClosure_iff_exists_path]
|
case h
α : Type u
σ : Type v
M : εNFA α σ
s₁ : σ
x : List α
a : α
ih : ∀ {s₂ : σ}, s₂ ∈ M.evalFrom {s₁} x ↔ ∃ x', x'.reduceOption = x ∧ M.IsPath s₁ s₂ x'
s₂ : σ
x' : List (Option α)
left✝¹ : x'.reduceOption = x
n : ℕ
t : σ
left✝ : M.IsPath s₁ t x'
u : σ
a✝¹ : u ∈ M.step t (some a)
a✝ : M.IsPath u s₂ (List.replicate n none)
⊢ (∃ x', x'.reduceOption = x ∧ M.IsPath s₁ t x') ∧
∃ t_1 ∈ M.step t (some a), ∃ n, M.IsPath t_1 s₂ (List.replicate n none)
|
0cc554a961b550e6
|
NNReal.hasSum_lt
|
Mathlib/Topology/Instances/ENNReal/Lemmas.lean
|
theorem hasSum_lt {f g : α → ℝ≥0} {sf sg : ℝ≥0} {i : α} (h : ∀ a : α, f a ≤ g a)
(hi : f i < g i) (hf : HasSum f sf) (hg : HasSum g sg) : sf < sg
|
α : Type u_1
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
⊢ sf < sg
|
have A : ∀ a : α, (f a : ℝ) ≤ g a := fun a => NNReal.coe_le_coe.2 (h a)
|
α : Type u_1
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
A : ∀ (a : α), ↑(f a) ≤ ↑(g a)
⊢ sf < sg
|
20fbd3087b2d07f5
|
cfc_unitary_iff
|
Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Unitary.lean
|
lemma cfc_unitary_iff (f : R → R) (a : A) (ha : p a
|
R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommRing R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : IsTopologicalRing R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
⊢ Set.EqOn (fun x => star (f x) * f x) 1 (spectrum R a) ↔ ∀ x ∈ spectrum R a, star (f x) * f x = 1
|
exact Iff.rfl
|
no goals
|
15a1186830c6c735
|
iInf_nat_gt_zero_eq
|
Mathlib/Order/CompleteLattice.lean
|
theorem iInf_nat_gt_zero_eq (f : ℕ → α) : ⨅ i > 0, f i = ⨅ i, f (i + 1)
|
α : Type u_1
inst✝ : CompleteLattice α
f : ℕ → α
⊢ ⨅ i, ⨅ (_ : i > 0), f i = ⨅ b ∈ {i | 0 < i}, f b
|
simp
|
no goals
|
92650371ae8e0867
|
Int.neg_inj
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
|
theorem neg_inj {a b : Int} : -a = -b ↔ a = b :=
⟨fun h => by rw [← Int.neg_neg a, ← Int.neg_neg b, h], congrArg _⟩
|
a b : Int
h : -a = -b
⊢ a = b
|
rw [← Int.neg_neg a, ← Int.neg_neg b, h]
|
no goals
|
6b223a7d16cecaae
|
ProbabilityTheory.Kernel.measure_mutuallySingularSetSlice
|
Mathlib/Probability/Kernel/RadonNikodym.lean
|
lemma measure_mutuallySingularSetSlice (κ η : Kernel α γ) [IsFiniteKernel κ] [IsFiniteKernel η]
(a : α) :
η a (mutuallySingularSetSlice κ η a) = 0
|
α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ ∀ᵐ (x : γ) ∂(κ + η) a, x ∈ {x | 1 ≤ κ.rnDerivAux (κ + η) a x} → ENNReal.ofReal (1 - κ.rnDerivAux (κ + η) a x) = 0 x
|
refine ae_of_all _ (fun x hx ↦ ?_)
|
α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
x : γ
hx : x ∈ {x | 1 ≤ κ.rnDerivAux (κ + η) a x}
⊢ ENNReal.ofReal (1 - κ.rnDerivAux (κ + η) a x) = 0 x
|
638794919b061bb4
|
Fermat42.exists_pos_odd_minimal
|
Mathlib/NumberTheory/FLT/Four.lean
|
theorem exists_pos_odd_minimal {a b c : ℤ} (h : Fermat42 a b c) :
∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0
|
a b c : ℤ
h : Fermat42 a b c
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0
|
obtain ⟨a0, b0, c0, hf, hc⟩ := exists_odd_minimal h
|
case intro.intro.intro.intro
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0
|
40b8a5ec6f6e5769
|
Nat.div_add_mod
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Div/Basic.lean
|
theorem div_add_mod (m n : Nat) : n * (m / n) + m % n = m
|
case isTrue
m n : Nat
h : 0 < n ∧ n ≤ m
⊢ n * ite (0 < n ∧ n ≤ m) ((m - n) / n + 1) 0 + ite (0 < n ∧ n ≤ m) ((m - n) % n) m = m
|
simp [h]
|
case isTrue
m n : Nat
h : 0 < n ∧ n ≤ m
⊢ n * ((m - n) / n + 1) + (m - n) % n = m
|
df24cb9cf4f4c4c8
|
EquicontinuousWithinAt.closure'
|
Mathlib/Topology/UniformSpace/Equicontinuity.lean
|
theorem EquicontinuousWithinAt.closure' {A : Set Y} {u : Y → X → α} {S : Set X} {x₀ : X}
(hA : EquicontinuousWithinAt (u ∘ (↑) : A → X → α) S x₀) (hu₁ : Continuous (S.restrict ∘ u))
(hu₂ : Continuous (eval x₀ ∘ u)) :
EquicontinuousWithinAt (u ∘ (↑) : closure A → X → α) S x₀
|
case h
X : Type u_3
Y : Type u_5
α : Type u_6
tX : TopologicalSpace X
tY : TopologicalSpace Y
uα : UniformSpace α
A : Set Y
u : Y → X → α
S : Set X
x₀ : X
hA : EquicontinuousWithinAt (u ∘ Subtype.val) S x₀
hu₁ : Continuous (S.restrict ∘ u)
hu₂ : Continuous (eval x₀ ∘ u)
U : Set (α × α)
hU : U ∈ 𝓤 α
V : Set (α × α)
hV : V ∈ 𝓤 α
hVclosed : IsClosed V
hVU : V ⊆ U
x : X
hxS : x ∈ S
hx : A ⊆ (fun f => (u f x₀, u f x)) ⁻¹' V
⊢ ∀ (x_1 : Y) (h : x_1 ∈ closure A), ((u ∘ Subtype.val) ⟨x_1, h⟩ x₀, (u ∘ Subtype.val) ⟨x_1, h⟩ x) ∈ U
|
refine (closure_minimal hx <| hVclosed.preimage <| hu₂.prod_mk ?_).trans (preimage_mono hVU)
|
case h
X : Type u_3
Y : Type u_5
α : Type u_6
tX : TopologicalSpace X
tY : TopologicalSpace Y
uα : UniformSpace α
A : Set Y
u : Y → X → α
S : Set X
x₀ : X
hA : EquicontinuousWithinAt (u ∘ Subtype.val) S x₀
hu₁ : Continuous (S.restrict ∘ u)
hu₂ : Continuous (eval x₀ ∘ u)
U : Set (α × α)
hU : U ∈ 𝓤 α
V : Set (α × α)
hV : V ∈ 𝓤 α
hVclosed : IsClosed V
hVU : V ⊆ U
x : X
hxS : x ∈ S
hx : A ⊆ (fun f => (u f x₀, u f x)) ⁻¹' V
⊢ Continuous fun f => u f x
|
361f94e89ea73217
|
Submodule.pow_induction_on_left'
|
Mathlib/Algebra/Algebra/Operations.lean
|
theorem pow_induction_on_left' {C : ∀ (n : ℕ) (x), x ∈ M ^ n → Prop}
(algebraMap : ∀ r : R, C 0 (algebraMap _ _ r) (algebraMap_mem r))
(add : ∀ x y i hx hy, C i x hx → C i y hy → C i (x + y) (add_mem ‹_› ‹_›))
(mem_mul : ∀ m (hm : m ∈ M), ∀ (i x hx), C i x hx → C i.succ (m * x)
((pow_succ' M i).symm ▸ (mul_mem_mul hm hx)))
{n : ℕ} {x : A}
(hx : x ∈ M ^ n) : C n x hx
|
case succ
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
M : Submodule R A
C : (n : ℕ) → (x : A) → x ∈ M ^ n → Prop
algebraMap : ∀ (r : R), C 0 ((_root_.algebraMap R A) r) ⋯
add : ∀ (x y : A) (i : ℕ) (hx : x ∈ M ^ i) (hy : y ∈ M ^ i), C i x hx → C i y hy → C i (x + y) ⋯
mem_mul : ∀ (m : A) (hm : m ∈ M) (i : ℕ) (x : A) (hx : x ∈ M ^ i), C i x hx → C i.succ (m * x) ⋯
n : ℕ
n_ih : ∀ {x : A} (hx : x ∈ M ^ n), C n x hx
x : A
⊢ ∀ (hx : x ∈ M ^ (n + 1)), C (n + 1) x hx
|
simp_rw [pow_succ']
|
case succ
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
M : Submodule R A
C : (n : ℕ) → (x : A) → x ∈ M ^ n → Prop
algebraMap : ∀ (r : R), C 0 ((_root_.algebraMap R A) r) ⋯
add : ∀ (x y : A) (i : ℕ) (hx : x ∈ M ^ i) (hy : y ∈ M ^ i), C i x hx → C i y hy → C i (x + y) ⋯
mem_mul : ∀ (m : A) (hm : m ∈ M) (i : ℕ) (x : A) (hx : x ∈ M ^ i), C i x hx → C i.succ (m * x) ⋯
n : ℕ
n_ih : ∀ {x : A} (hx : x ∈ M ^ n), C n x hx
x : A
⊢ ∀ (hx : x ∈ M * M ^ n), C (n + 1) x ⋯
|
3b52ec55a98ce91f
|
totallyBounded_insert
|
Mathlib/Topology/UniformSpace/Cauchy.lean
|
@[simp]
lemma totallyBounded_insert (a : α) {s : Set α} :
TotallyBounded (insert a s) ↔ TotallyBounded s
|
α : Type u
uniformSpace : UniformSpace α
a : α
s : Set α
⊢ TotallyBounded (insert a s) ↔ TotallyBounded s
|
simp_rw [← singleton_union, totallyBounded_union, totallyBounded_singleton, true_and]
|
no goals
|
bdc41a3331cf846e
|
Orientation.measure_orthonormalBasis
|
Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean
|
theorem Orientation.measure_orthonormalBasis (o : Orientation ℝ F (Fin n))
(b : OrthonormalBasis ι ℝ F) : o.volumeForm.measure (parallelepiped b) = 1
|
ι : Type u_1
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
inst✝³ : MeasurableSpace F
inst✝² : BorelSpace F
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional ℝ F
n : ℕ
_i : Fact (finrank ℝ F = n)
o : Orientation ℝ F (Fin n)
b : OrthonormalBasis ι ℝ F
⊢ o.volumeForm.measure (parallelepiped ⇑b) = 1
|
have e : ι ≃ Fin n := by
refine Fintype.equivFinOfCardEq ?_
rw [← _i.out, finrank_eq_card_basis b.toBasis]
|
ι : Type u_1
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
inst✝³ : MeasurableSpace F
inst✝² : BorelSpace F
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional ℝ F
n : ℕ
_i : Fact (finrank ℝ F = n)
o : Orientation ℝ F (Fin n)
b : OrthonormalBasis ι ℝ F
e : ι ≃ Fin n
⊢ o.volumeForm.measure (parallelepiped ⇑b) = 1
|
77b4661ed8572b43
|
CategoryTheory.Functor.IsStronglyCartesian.isIso_of_base_isIso
|
Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean
|
/-- A strongly cartesian morphism lying over an isomorphism is an isomorphism. -/
lemma isIso_of_base_isIso (φ : a ⟶ b) [IsStronglyCartesian p f φ] [IsIso f] : IsIso φ
|
case map
𝒮 : Type u₁
𝒳 : Type u₂
inst✝³ : Category.{v₁, u₁} 𝒮
inst✝² : Category.{v₂, u₂} 𝒳
p : 𝒳 ⥤ 𝒮
a b : 𝒳
φ : a ⟶ b
inst✝¹ : p.IsStronglyCartesian (p.map φ) φ
inst✝ : IsIso (p.map φ)
φ' : b ⟶ a := map p (p.map φ) φ ⋯ (𝟙 b)
⊢ IsIso φ
|
use φ'
|
case h
𝒮 : Type u₁
𝒳 : Type u₂
inst✝³ : Category.{v₁, u₁} 𝒮
inst✝² : Category.{v₂, u₂} 𝒳
p : 𝒳 ⥤ 𝒮
a b : 𝒳
φ : a ⟶ b
inst✝¹ : p.IsStronglyCartesian (p.map φ) φ
inst✝ : IsIso (p.map φ)
φ' : b ⟶ a := map p (p.map φ) φ ⋯ (𝟙 b)
⊢ φ ≫ φ' = 𝟙 a ∧ φ' ≫ φ = 𝟙 b
|
13d70784d154b200
|
Batteries.HashMap.Imp.erase_size
|
Mathlib/.lake/packages/batteries/Batteries/Data/HashMap/WF.lean
|
theorem erase_size [BEq α] [Hashable α] {m : Imp α β} {k}
(h : m.size = m.buckets.size) :
(erase m k).size = (erase m k).buckets.size
|
α : Type u_1
β : Type u_2
inst✝¹ : BEq α
inst✝ : Hashable α
m : Imp α β
k : α
h : m.size = m.buckets.size
c✝ : Bool
H : AssocList.contains k m.buckets.val[(mkIdx ⋯ (hash k).toUSize).val.toNat] = true
w✝¹ w✝ : List (AssocList α β)
left✝ : w✝¹.length = (mkIdx ⋯ (hash k).toUSize).val.toNat
⊢ m.buckets.val[(mkIdx ⋯ (hash k).toUSize).val.toNat].toList.length =
(List.eraseP (fun x => x.fst == k) m.buckets.val[(mkIdx ⋯ (hash k).toUSize).val.toNat].toList).length + 1
|
simp only [AssocList.contains_eq, List.any_eq_true] at H
|
α : Type u_1
β : Type u_2
inst✝¹ : BEq α
inst✝ : Hashable α
m : Imp α β
k : α
h : m.size = m.buckets.size
c✝ : Bool
w✝¹ w✝ : List (AssocList α β)
left✝ : w✝¹.length = (mkIdx ⋯ (hash k).toUSize).val.toNat
H : ∃ x, x ∈ m.buckets.val[(mkIdx ⋯ (hash k).toUSize).val.toNat].toList ∧ (x.fst == k) = true
⊢ m.buckets.val[(mkIdx ⋯ (hash k).toUSize).val.toNat].toList.length =
(List.eraseP (fun x => x.fst == k) m.buckets.val[(mkIdx ⋯ (hash k).toUSize).val.toNat].toList).length + 1
|
d2f35150aae92845
|
BoxIntegral.IntegrationParams.MemBaseSet.filter
|
Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
|
theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι → Prop) :
l.MemBaseSet I c r (π.filter p)
|
case intro.intro.refine_1.h.mp
ι : Type u_1
inst✝ : Fintype ι
I : Box ι
c : ℝ≥0
l : IntegrationParams
π : TaggedPrepartition I
r : (ι → ℝ) → ↑(Set.Ioi 0)
hπ : l.MemBaseSet I c r π
p : Box ι → Prop
hD : l.bDistortion = true
π₁ : Prepartition I
hπ₁U : π₁.iUnion = ↑I \ π.iUnion
hc : π₁.distortion ≤ c
π₂ : TaggedPrepartition I := π.filter fun J => ¬p J
this : Disjoint π₁.iUnion π₂.iUnion
h : (π.filter p).iUnion ⊆ π.iUnion
x : ι → ℝ
⊢ x ∈ ↑I \ π.iUnion ∪ π.iUnion \ (π.filter p).iUnion → x ∈ ↑I \ (π.filter p).iUnion
|
rintro (⟨hxI, hxπ⟩ | ⟨hxπ, hxp⟩)
|
case intro.intro.refine_1.h.mp.inl.intro
ι : Type u_1
inst✝ : Fintype ι
I : Box ι
c : ℝ≥0
l : IntegrationParams
π : TaggedPrepartition I
r : (ι → ℝ) → ↑(Set.Ioi 0)
hπ : l.MemBaseSet I c r π
p : Box ι → Prop
hD : l.bDistortion = true
π₁ : Prepartition I
hπ₁U : π₁.iUnion = ↑I \ π.iUnion
hc : π₁.distortion ≤ c
π₂ : TaggedPrepartition I := π.filter fun J => ¬p J
this : Disjoint π₁.iUnion π₂.iUnion
h : (π.filter p).iUnion ⊆ π.iUnion
x : ι → ℝ
hxI : x ∈ ↑I
hxπ : x ∉ π.iUnion
⊢ x ∈ ↑I \ (π.filter p).iUnion
case intro.intro.refine_1.h.mp.inr.intro
ι : Type u_1
inst✝ : Fintype ι
I : Box ι
c : ℝ≥0
l : IntegrationParams
π : TaggedPrepartition I
r : (ι → ℝ) → ↑(Set.Ioi 0)
hπ : l.MemBaseSet I c r π
p : Box ι → Prop
hD : l.bDistortion = true
π₁ : Prepartition I
hπ₁U : π₁.iUnion = ↑I \ π.iUnion
hc : π₁.distortion ≤ c
π₂ : TaggedPrepartition I := π.filter fun J => ¬p J
this : Disjoint π₁.iUnion π₂.iUnion
h : (π.filter p).iUnion ⊆ π.iUnion
x : ι → ℝ
hxπ : x ∈ π.iUnion
hxp : x ∉ (π.filter p).iUnion
⊢ x ∈ ↑I \ (π.filter p).iUnion
|
0560a2437e9c3b72
|
List.Nat.nodup_antidiagonalTuple
|
Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean
|
theorem nodup_antidiagonalTuple (k n : ℕ) : List.Nodup (antidiagonalTuple k n)
|
case succ.right.succ.refine_1
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
n_ih :
Pairwise (Function.onFun Disjoint fun ni => map (fun x => Fin.cons ni.1 x) (antidiagonalTuple k ni.2))
(antidiagonal n)
a : ℕ × ℕ
ha : a ∈ map (Prod.map Nat.succ id) (antidiagonal n)
x : Fin (k + 1) → ℕ
hx₁ : x ∈ (fun ni => map (fun x => Fin.cons ni.1 x) (antidiagonalTuple k ni.2)) (0, n + 1)
hx₂ : x ∈ (fun ni => map (fun x => Fin.cons ni.1 x) (antidiagonalTuple k ni.2)) a
⊢ False
|
rw [List.mem_map] at hx₁ hx₂ ha
|
case succ.right.succ.refine_1
k : ℕ
ih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup
n : ℕ
n_ih :
Pairwise (Function.onFun Disjoint fun ni => map (fun x => Fin.cons ni.1 x) (antidiagonalTuple k ni.2))
(antidiagonal n)
a : ℕ × ℕ
ha : ∃ a_1 ∈ antidiagonal n, Prod.map Nat.succ id a_1 = a
x : Fin (k + 1) → ℕ
hx₁ : ∃ a ∈ antidiagonalTuple k (0, n + 1).2, Fin.cons (0, n + 1).1 a = x
hx₂ : ∃ a_1 ∈ antidiagonalTuple k a.2, Fin.cons a.1 a_1 = x
⊢ False
|
4c17a19ec5bf0ba2
|
Computation.terminates_parallel
|
Mathlib/Data/Seq/Parallel.lean
|
theorem terminates_parallel {S : WSeq (Computation α)} {c} (h : c ∈ S) [T : Terminates c] :
Terminates (parallel S)
|
case zero.inr.inl
α : Type u
S✝ : WSeq (Computation α)
c✝ : Computation α
h✝ : c✝ ∈ S✝
T✝ : c✝.Terminates
l : List (Computation α)
S : Stream'.Seq (Option (Computation α))
c : Computation α
T : c.Terminates
a✝ : some (some c) = S.get? 0
H : S.destruct = some (some c, S.tail)
a : α
h : parallel.aux2 l = Sum.inl a
C : corec parallel.aux1 (l, S) = pure a
⊢ (corec parallel.aux1 (l, S)).Terminates
|
rw [C]
|
case zero.inr.inl
α : Type u
S✝ : WSeq (Computation α)
c✝ : Computation α
h✝ : c✝ ∈ S✝
T✝ : c✝.Terminates
l : List (Computation α)
S : Stream'.Seq (Option (Computation α))
c : Computation α
T : c.Terminates
a✝ : some (some c) = S.get? 0
H : S.destruct = some (some c, S.tail)
a : α
h : parallel.aux2 l = Sum.inl a
C : corec parallel.aux1 (l, S) = pure a
⊢ (pure a).Terminates
|
b95c6ab968566afe
|
List.chain'_of_mem_splitByLoop
|
Mathlib/Data/List/SplitBy.lean
|
theorem chain'_of_mem_splitByLoop {r : α → α → Bool} {l : List α} {a : α} {g : List α}
(hga : ∀ b ∈ g.head?, r b a) (hg : g.Chain' fun y x ↦ r x y)
(h : m ∈ splitBy.loop r l a g []) : m.Chain' fun x y ↦ r x y
|
case cons.h_2.inl
α : Type u_1
r : α → α → Bool
b : α
l : List α
a : α
g : List α
hga : ∀ (b : α), b ∈ g.head? → r b a = true
hg : Chain' (fun y x => r x y = true) g
x✝ : Bool
heq✝ : r a b = false
IH :
∀ {a_1 : α} {g_1 : List α},
(∀ (b : α), b ∈ g_1.head? → r b a_1 = true) →
Chain' (fun y x => r x y = true) g_1 →
g.reverse ++ [a] ∈ splitBy.loop r l a_1 g_1 [] → Chain' (fun x y => r x y = true) (g.reverse ++ [a])
⊢ Chain' (fun y x => r x y = true) (g.reverse ++ [a]).reverse
|
rw [reverse_append, reverse_cons, reverse_nil, nil_append, reverse_reverse]
|
case cons.h_2.inl
α : Type u_1
r : α → α → Bool
b : α
l : List α
a : α
g : List α
hga : ∀ (b : α), b ∈ g.head? → r b a = true
hg : Chain' (fun y x => r x y = true) g
x✝ : Bool
heq✝ : r a b = false
IH :
∀ {a_1 : α} {g_1 : List α},
(∀ (b : α), b ∈ g_1.head? → r b a_1 = true) →
Chain' (fun y x => r x y = true) g_1 →
g.reverse ++ [a] ∈ splitBy.loop r l a_1 g_1 [] → Chain' (fun x y => r x y = true) (g.reverse ++ [a])
⊢ Chain' (fun y x => r x y = true) ([a] ++ g)
|
f1b83979d934bdc8
|
norm_iteratedFDerivWithin_comp_le_aux
|
Mathlib/Analysis/Calculus/ContDiff/Bounds.lean
|
theorem norm_iteratedFDerivWithin_comp_le_aux {Fu Gu : Type u} [NormedAddCommGroup Fu]
[NormedSpace 𝕜 Fu] [NormedAddCommGroup Gu] [NormedSpace 𝕜 Gu] {g : Fu → Gu} {f : E → Fu} {n : ℕ}
{s : Set E} {t : Set Fu} {x : E} (hg : ContDiffOn 𝕜 n g t) (hf : ContDiffOn 𝕜 n f s)
(ht : UniqueDiffOn 𝕜 t) (hs : UniqueDiffOn 𝕜 s) (hst : MapsTo f s t) (hx : x ∈ s) {C : ℝ}
{D : ℝ} (hC : ∀ i, i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C)
(hD : ∀ i, 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) :
‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ n ! * C * D ^ n
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
f : E → Fu
s : Set E
t : Set Fu
x : E
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
n : ℕ
IH :
∀ m ≤ n,
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ i ≤ m, ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(n + 1)) g t
hf : ContDiffOn 𝕜 (↑(n + 1)) f s
hC : ∀ i ≤ n + 1, ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n + 1 → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑n.succ
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ i ∈ Finset.range (n + 1), ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (g ∘ f) s y) s x‖ =
‖iteratedFDerivWithin 𝕜 n
(fun y => ((ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)) s x‖
|
have L : (1 : WithTop ℕ∞) ≤ n.succ := by
simpa only [ENat.coe_one, Nat.one_le_cast] using n.succ_pos
|
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
Fu : Type u
inst✝³ : NormedAddCommGroup Fu
inst✝² : NormedSpace 𝕜 Fu
f : E → Fu
s : Set E
t : Set Fu
x : E
ht : UniqueDiffOn 𝕜 t
hs : UniqueDiffOn 𝕜 s
hst : MapsTo f s t
hx : x ∈ s
C D : ℝ
n : ℕ
IH :
∀ m ≤ n,
∀ {Gu : Type u} [inst : NormedAddCommGroup Gu] [inst_1 : NormedSpace 𝕜 Gu] {g : Fu → Gu},
ContDiffOn 𝕜 (↑m) g t →
ContDiffOn 𝕜 (↑m) f s →
(∀ i ≤ m, ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C) →
(∀ (i : ℕ), 1 ≤ i → i ≤ m → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) →
‖iteratedFDerivWithin 𝕜 m (g ∘ f) s x‖ ≤ ↑m ! * C * D ^ m
Gu : Type u
inst✝¹ : NormedAddCommGroup Gu
inst✝ : NormedSpace 𝕜 Gu
g : Fu → Gu
hg : ContDiffOn 𝕜 (↑(n + 1)) g t
hf : ContDiffOn 𝕜 (↑(n + 1)) f s
hC : ∀ i ≤ n + 1, ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C
hD : ∀ (i : ℕ), 1 ≤ i → i ≤ n + 1 → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i
M : ↑n < ↑n.succ
Cnonneg : 0 ≤ C
Dnonneg : 0 ≤ D
I : ∀ i ∈ Finset.range (n + 1), ‖iteratedFDerivWithin 𝕜 i (fderivWithin 𝕜 g t ∘ f) s x‖ ≤ ↑i ! * C * D ^ i
J : ∀ (i : ℕ), ‖iteratedFDerivWithin 𝕜 (n - i) (fderivWithin 𝕜 f s) s x‖ ≤ D ^ (n - i + 1)
L : 1 ≤ ↑n.succ
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 (g ∘ f) s y) s x‖ =
‖iteratedFDerivWithin 𝕜 n
(fun y => ((ContinuousLinearMap.compL 𝕜 E Fu Gu) (fderivWithin 𝕜 g t (f y))) (fderivWithin 𝕜 f s y)) s x‖
|
59e1e58bb3dc8aba
|
rank_quotient_add_rank_le
|
Mathlib/LinearAlgebra/Dimension/Constructions.lean
|
theorem rank_quotient_add_rank_le [Nontrivial R] (M' : Submodule R M) :
Module.rank R (M ⧸ M') + Module.rank R M' ≤ Module.rank R M
|
R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : Nontrivial R
M' : Submodule R M
this : Nonempty { s // LinearIndepOn R id s }
⊢ (⨆ ι, #↑↑ι) + ⨆ ι, #↑↑ι ≤ Module.rank R M
|
have := nonempty_linearIndependent_set R M'
|
R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : Nontrivial R
M' : Submodule R M
this✝ : Nonempty { s // LinearIndepOn R id s }
this : Nonempty { s // LinearIndepOn R id s }
⊢ (⨆ ι, #↑↑ι) + ⨆ ι, #↑↑ι ≤ Module.rank R M
|
b200648a4815e8fa
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.