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
|
|---|---|---|---|---|---|---|
WittVector.irreducible
|
Mathlib/RingTheory/WittVector/DiscreteValuationRing.lean
|
theorem irreducible : Irreducible (p : 𝕎 k)
|
p : ℕ
hp✝ : Fact (Nat.Prime p)
k : Type u_1
inst✝¹ : Field k
inst✝ : CharP k p
hp : ¬IsUnit ↑p
a b : 𝕎 k
hab : ↑p = a * b
⊢ a ≠ 0 ∧ b ≠ 0
|
rw [← mul_ne_zero_iff]
|
p : ℕ
hp✝ : Fact (Nat.Prime p)
k : Type u_1
inst✝¹ : Field k
inst✝ : CharP k p
hp : ¬IsUnit ↑p
a b : 𝕎 k
hab : ↑p = a * b
⊢ a * b ≠ 0
|
bbcbb7f9941815f7
|
Multiset.lt_replicate_succ
|
Mathlib/Data/Multiset/Replicate.lean
|
theorem lt_replicate_succ {m : Multiset α} {x : α} {n : ℕ} :
m < replicate (n + 1) x ↔ m ≤ replicate n x
|
case mpr
α : Type u_1
m : Multiset α
x : α
n : ℕ
h : m ≤ replicate n x
⊢ ∃ a, a ::ₘ m ≤ replicate (n + 1) x
|
rw [replicate_succ]
|
case mpr
α : Type u_1
m : Multiset α
x : α
n : ℕ
h : m ≤ replicate n x
⊢ ∃ a, a ::ₘ m ≤ x ::ₘ replicate n x
|
c4daba5a64d21b93
|
Units.map_id
|
Mathlib/Algebra/Group/Units/Hom.lean
|
theorem map_id : map (MonoidHom.id M) = MonoidHom.id Mˣ
|
M : Type u
inst✝ : Monoid M
⊢ map (MonoidHom.id M) = MonoidHom.id Mˣ
|
ext
|
case h.a
M : Type u
inst✝ : Monoid M
x✝ : Mˣ
⊢ ↑((map (MonoidHom.id M)) x✝) = ↑((MonoidHom.id Mˣ) x✝)
|
1b22afc8edfce4c1
|
exists_associated_pow_of_associated_pow_mul
|
Mathlib/RingTheory/PrincipalIdealDomain.lean
|
theorem exists_associated_pow_of_associated_pow_mul {a b c : R} (hab : IsCoprime a b) {k : ℕ}
(h : Associated (c ^ k) (a * b)) : ∃ d : R, Associated (d ^ k) a
|
R : Type u
inst✝² : CommRing R
inst✝¹ : IsBezout R
inst✝ : IsDomain R
a b c : R
hab : IsCoprime a b
k : ℕ
h : Associated (c ^ k) (a * b)
⊢ ∃ d, Associated (d ^ k) a
|
obtain ⟨u, hu⟩ := h.symm
|
case intro
R : Type u
inst✝² : CommRing R
inst✝¹ : IsBezout R
inst✝ : IsDomain R
a b c : R
hab : IsCoprime a b
k : ℕ
h : Associated (c ^ k) (a * b)
u : Rˣ
hu : a * b * ↑u = c ^ k
⊢ ∃ d, Associated (d ^ k) a
|
bc8e53465e1fd9a4
|
Lean.Order.PProd.chain.chain_snd
|
Mathlib/.lake/packages/lean4/src/lean/Init/Internal/Order/Basic.lean
|
theorem PProd.chain.chain_snd [CCPO α] [CCPO β] {c : α ×' β → Prop} (hchain : chain c) :
chain (chain.snd c)
|
α : Sort u
β : Sort v
inst✝¹ : CCPO α
inst✝ : CCPO β
c : α ×' β → Prop
hchain : chain c
⊢ chain (snd c)
|
intro b₁ b₂ ⟨a₁, h₁⟩ ⟨a₂, h₂⟩
|
α : Sort u
β : Sort v
inst✝¹ : CCPO α
inst✝ : CCPO β
c : α ×' β → Prop
hchain : chain c
b₁ b₂ : β
a₁ : α
h₁ : c ⟨a₁, b₁⟩
a₂ : α
h₂ : c ⟨a₂, b₂⟩
⊢ b₁ ⊑ b₂ ∨ b₂ ⊑ b₁
|
2afa3a24950d92b0
|
wellQuasiOrdered_iff_exists_monotone_subseq
|
Mathlib/Order/WellQuasiOrder.lean
|
theorem wellQuasiOrdered_iff_exists_monotone_subseq [IsPreorder α r] :
WellQuasiOrdered r ↔ ∀ f : ℕ → α, ∃ g : ℕ ↪o ℕ, ∀ m n : ℕ, m ≤ n → r (f (g m)) (f (g n))
|
case mpr
α : Type u_1
r : α → α → Prop
inst✝ : IsPreorder α r
h : ∀ (f : ℕ → α), ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (g m)) (f (g n))
f : ℕ → α
⊢ ∃ m n, m < n ∧ r (f m) (f n)
|
obtain ⟨g, gmon⟩ := h f
|
case mpr.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsPreorder α r
h : ∀ (f : ℕ → α), ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (g m)) (f (g n))
f : ℕ → α
g : ℕ ↪o ℕ
gmon : ∀ (m n : ℕ), m ≤ n → r (f (g m)) (f (g n))
⊢ ∃ m n, m < n ∧ r (f m) (f n)
|
7dbc797b6874056a
|
MulAction.mem_stabilizer_set'
|
Mathlib/Algebra/Pointwise/Stabilizer.lean
|
@[to_additive]
lemma mem_stabilizer_set' {s : Set α} (hs : s.Finite) :
a ∈ stabilizer G s ↔ ∀ ⦃b⦄, b ∈ s → a • b ∈ s
|
case intro
G : Type u_1
α : Type u_3
inst✝¹ : Group G
inst✝ : MulAction G α
a : G
s : Finset α
⊢ a ∈ stabilizer G ↑s ↔ ∀ ⦃b : α⦄, b ∈ ↑s → a • b ∈ ↑s
|
classical simp [-mem_stabilizer_iff, mem_stabilizer_finset']
|
no goals
|
e7c951482f224830
|
MeasureTheory.le_iInf₂_lintegral
|
Mathlib/MeasureTheory/Integral/Lebesgue.lean
|
theorem le_iInf₂_lintegral {ι : Sort*} {ι' : ι → Sort*} (f : ∀ i, ι' i → α → ℝ≥0∞) :
∫⁻ a, ⨅ (i) (h : ι' i), f i h a ∂μ ≤ ⨅ (i) (h : ι' i), ∫⁻ a, f i h a ∂μ
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
ι : Sort u_5
ι' : ι → Sort u_6
f : (i : ι) → ι' i → α → ℝ≥0∞
⊢ ∫⁻ (a : α), ⨅ i, ⨅ h, f i h a ∂μ ≤ ⨅ i, ⨅ h, ∫⁻ (a : α), f i h a ∂μ
|
convert (monotone_lintegral μ).map_iInf₂_le f with a
|
case h.e'_3.h.e'_4.h
α : Type u_1
m : MeasurableSpace α
μ : Measure α
ι : Sort u_5
ι' : ι → Sort u_6
f : (i : ι) → ι' i → α → ℝ≥0∞
a : α
⊢ ⨅ i, ⨅ h, f i h a = (⨅ i, ⨅ j, f i j) a
|
7d117a4e84758191
|
Finset.card_Icc_finset
|
Mathlib/Data/Finset/Interval.lean
|
theorem card_Icc_finset (h : s ⊆ t) : (Icc s t).card = 2 ^ (t.card - s.card)
|
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
hu : u ∈ ↑(t \ s).powerset
v : Finset α
hv : v ∈ ↑(t \ s).powerset
huv : s ⊔ u = s ⊔ v
⊢ u = v
|
rw [mem_coe, mem_powerset] at hu hv
|
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
u : Finset α
hu : u ⊆ t \ s
v : Finset α
hv : v ⊆ t \ s
huv : s ⊔ u = s ⊔ v
⊢ u = v
|
0e69e1d78dcfe219
|
Std.DHashMap.Internal.Raw₀.Const.isHashSelf_updateBucket_alter
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/WF.lean
|
theorem isHashSelf_updateBucket_alter [BEq α] [EquivBEq α] [Hashable α] [LawfulHashable α]
{m : Raw₀ α (fun _ => β)} (h : Raw.WFImp m.1) {a : α} {f : Option β → Option β} :
IsHashSelf (updateBucket m.1.buckets m.2 a (AssocList.Const.alter a f))
|
α : Type u
β : Type v
inst✝³ : BEq α
inst✝² : EquivBEq α
inst✝¹ : Hashable α
inst✝ : LawfulHashable α
m : Raw₀ α fun x => β
h : Raw.WFImp m.val
a : α
f : Option β → Option β
l : AssocList α fun x => β
p : (_ : α) × β
hp : p ∈ (AssocList.Const.alter a f l).toList
⊢ containsKey p.fst l.toList = true ∨ hash p.fst = hash a
|
rw [AssocList.Const.toList_alter.mem_iff] at hp
|
α : Type u
β : Type v
inst✝³ : BEq α
inst✝² : EquivBEq α
inst✝¹ : Hashable α
inst✝ : LawfulHashable α
m : Raw₀ α fun x => β
h : Raw.WFImp m.val
a : α
f : Option β → Option β
l : AssocList α fun x => β
p : (_ : α) × β
hp : p ∈ Const.alterKey a f l.toList
⊢ containsKey p.fst l.toList = true ∨ hash p.fst = hash a
|
3a3a3bad02424c04
|
Finset.prod_filter_mul_prod_filter_not
|
Mathlib/Algebra/BigOperators/Group/Finset/Basic.lean
|
theorem prod_filter_mul_prod_filter_not
(s : Finset α) (p : α → Prop) [DecidablePred p] [∀ x, Decidable (¬p x)] (f : α → β) :
(∏ x ∈ s with p x, f x) * ∏ x ∈ s with ¬p x, f x = ∏ x ∈ s, f x
|
α : Type u_3
β : Type u_4
inst✝² : CommMonoid β
s : Finset α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : (x : α) → Decidable ¬p x
f : α → β
⊢ (∏ x ∈ filter (fun x => p x) s, f x) * ∏ x ∈ filter (fun x => ¬p x) s, f x = ∏ x ∈ s, f x
|
have := Classical.decEq α
|
α : Type u_3
β : Type u_4
inst✝² : CommMonoid β
s : Finset α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : (x : α) → Decidable ¬p x
f : α → β
this : DecidableEq α
⊢ (∏ x ∈ filter (fun x => p x) s, f x) * ∏ x ∈ filter (fun x => ¬p x) s, f x = ∏ x ∈ s, f x
|
cd0e75d5f61fce7d
|
IsDenseInducing.extend_Z_bilin_key
|
Mathlib/Topology/Algebra/UniformGroup/Basic.lean
|
theorem extend_Z_bilin_key (x₀ : α) (y₀ : γ) : ∃ U ∈ comap e (𝓝 x₀), ∃ V ∈ comap f (𝓝 y₀),
∀ x ∈ U, ∀ x' ∈ U, ∀ (y) (_ : y ∈ V) (y') (_ : y' ∈ V),
(fun p : β × δ => φ p.1 p.2) (x', y') - (fun p : β × δ => φ p.1 p.2) (x, y) ∈ W'
|
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝¹² : TopologicalSpace α
inst✝¹¹ : AddCommGroup α
inst✝¹⁰ : IsTopologicalAddGroup α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : AddCommGroup β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : AddCommGroup γ
inst✝⁵ : IsTopologicalAddGroup γ
inst✝⁴ : TopologicalSpace δ
inst✝³ : AddCommGroup δ
inst✝² : UniformSpace G
inst✝¹ : AddCommGroup G
e : β →+ α
de : IsDenseInducing ⇑e
f : δ →+ γ
df : IsDenseInducing ⇑f
φ : β →+ δ →+ G
hφ : Continuous fun p => (φ p.1) p.2
W' : Set G
W'_nhd : W' ∈ 𝓝 0
inst✝ : UniformAddGroup G
x₀ : α
y₀ : γ
ee : β × β → α × α := fun u => (e u.1, e u.2)
ff : δ × δ → γ × γ := fun u => (f u.1, f u.2)
lim_φ : Tendsto (fun p => (φ p.1) p.2) (𝓝 (0, 0)) (𝓝 0)
lim_sub_sub :
Tendsto (fun p => (p.1.2 - p.1.1, p.2.2 - p.2.1)) (comap ee (𝓝 (x₀, x₀)) ×ˢ comap ff (𝓝 (y₀, y₀))) (𝓝 0 ×ˢ 𝓝 0)
⊢ Tendsto (fun p => (fun p => (φ p.1) p.2) (p.1.2 - p.1.1, p.2.2 - p.2.1))
(comap ee (𝓝 (x₀, x₀)) ×ˢ comap ff (𝓝 (y₀, y₀))) (𝓝 0)
|
rw [← nhds_prod_eq] at lim_sub_sub
|
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝¹² : TopologicalSpace α
inst✝¹¹ : AddCommGroup α
inst✝¹⁰ : IsTopologicalAddGroup α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : AddCommGroup β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : AddCommGroup γ
inst✝⁵ : IsTopologicalAddGroup γ
inst✝⁴ : TopologicalSpace δ
inst✝³ : AddCommGroup δ
inst✝² : UniformSpace G
inst✝¹ : AddCommGroup G
e : β →+ α
de : IsDenseInducing ⇑e
f : δ →+ γ
df : IsDenseInducing ⇑f
φ : β →+ δ →+ G
hφ : Continuous fun p => (φ p.1) p.2
W' : Set G
W'_nhd : W' ∈ 𝓝 0
inst✝ : UniformAddGroup G
x₀ : α
y₀ : γ
ee : β × β → α × α := fun u => (e u.1, e u.2)
ff : δ × δ → γ × γ := fun u => (f u.1, f u.2)
lim_φ : Tendsto (fun p => (φ p.1) p.2) (𝓝 (0, 0)) (𝓝 0)
lim_sub_sub :
Tendsto (fun p => (p.1.2 - p.1.1, p.2.2 - p.2.1)) (comap ee (𝓝 (x₀, x₀)) ×ˢ comap ff (𝓝 (y₀, y₀))) (𝓝 (0, 0))
⊢ Tendsto (fun p => (fun p => (φ p.1) p.2) (p.1.2 - p.1.1, p.2.2 - p.2.1))
(comap ee (𝓝 (x₀, x₀)) ×ˢ comap ff (𝓝 (y₀, y₀))) (𝓝 0)
|
965b7a7f03c398d2
|
ApproximatesLinearOn.norm_fderiv_sub_le
|
Mathlib/MeasureTheory/Function/Jacobian.lean
|
theorem _root_.ApproximatesLinearOn.norm_fderiv_sub_le {A : E →L[ℝ] E} {δ : ℝ≥0}
(hf : ApproximatesLinearOn f A s δ) (hs : MeasurableSet s) (f' : E → E →L[ℝ] E)
(hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) : ∀ᵐ x ∂μ.restrict s, ‖f' x - A‖₊ ≤ δ
|
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
s : Set E
f : E → E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
A : E →L[ℝ] E
δ : ℝ≥0
hf : ApproximatesLinearOn f A s δ
hs : MeasurableSet s
f' : E → E →L[ℝ] E
hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x
x : E
hx : Tendsto (fun r => μ (s ∩ closedBall x r) / μ (closedBall x r)) (𝓝[>] 0) (𝓝 1)
xs : x ∈ s
z : E
H : ∀ (ε : ℝ), 0 < ε → ‖(f' x - A) z‖ ≤ (↑δ + ε) * (‖z‖ + ε) + ‖f' x - A‖ * ε
this : Tendsto (fun ε => (↑δ + ε) * (‖z‖ + ε) + ‖f' x - A‖ * ε) (𝓝[>] 0) (𝓝 ((↑δ + 0) * (‖z‖ + 0) + ‖f' x - A‖ * 0))
⊢ ‖(f' x - A) z‖ ≤ ↑δ * ‖z‖
|
simp only [add_zero, mul_zero] at this
|
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
s : Set E
f : E → E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
A : E →L[ℝ] E
δ : ℝ≥0
hf : ApproximatesLinearOn f A s δ
hs : MeasurableSet s
f' : E → E →L[ℝ] E
hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x
x : E
hx : Tendsto (fun r => μ (s ∩ closedBall x r) / μ (closedBall x r)) (𝓝[>] 0) (𝓝 1)
xs : x ∈ s
z : E
H : ∀ (ε : ℝ), 0 < ε → ‖(f' x - A) z‖ ≤ (↑δ + ε) * (‖z‖ + ε) + ‖f' x - A‖ * ε
this : Tendsto (fun ε => (↑δ + ε) * (‖z‖ + ε) + ‖f' x - A‖ * ε) (𝓝[>] 0) (𝓝 (↑δ * ‖z‖))
⊢ ‖(f' x - A) z‖ ≤ ↑δ * ‖z‖
|
99ae4fc7a76b96c9
|
MeasureTheory.IsStoppingTime.measurableSet_gt'
|
Mathlib/Probability/Process/Stopping.lean
|
theorem measurableSet_gt' (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | i < τ ω}
|
case h
Ω : Type u_1
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ : Ω → ι
hτ : IsStoppingTime f τ
i : ι
ω : Ω
⊢ ω ∈ {ω | i < τ ω} ↔ ω ∈ {ω | τ ω ≤ i}ᶜ
|
simp
|
no goals
|
5f50fd378320aa23
|
AlgebraicGeometry.universallyClosed_eq_universallySpecializing
|
Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean
|
lemma universallyClosed_eq_universallySpecializing :
@UniversallyClosed = (topologically @SpecializingMap).universally ⊓ @QuasiCompact
|
case a
⊢ (topologically @SpecializingMap ⊓ @QuasiCompact).universally ≤ (topologically @IsClosedMap).universally
|
exact universally_mono fun X Y f ⟨h₁, h₂⟩ ↦ (isClosedMap_iff_specializingMap _).mpr h₁
|
no goals
|
862e4b8e16a6249b
|
RightDerivMeasurableAux.differentiable_set_subset_D
|
Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
|
theorem differentiable_set_subset_D :
{ x | DifferentiableWithinAt ℝ f (Ici x) x ∧ derivWithin f (Ici x) x ∈ K } ⊆ D f K
|
case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
x : ℝ
hx : x ∈ {x | DifferentiableWithinAt ℝ f (Ici x) x ∧ derivWithin f (Ici x) x ∈ K}
e : ℕ
this : 0 < (1 / 2) ^ e
R : ℝ
R_pos : R > 0
hR : ∀ r ∈ Ioo 0 R, x ∈ A f (derivWithin f (Ici x) x) r ((1 / 2) ^ e)
⊢ x ∈ ⋃ n, ⋂ p, ⋂ (_ : p ≥ n), ⋂ q, ⋂ (_ : q ≥ n), B f K ((1 / 2) ^ p) ((1 / 2) ^ q) ((1 / 2) ^ e)
|
obtain ⟨n, hn⟩ : ∃ n : ℕ, (1 / 2) ^ n < R :=
exists_pow_lt_of_lt_one R_pos (by norm_num : (1 : ℝ) / 2 < 1)
|
case intro.intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
x : ℝ
hx : x ∈ {x | DifferentiableWithinAt ℝ f (Ici x) x ∧ derivWithin f (Ici x) x ∈ K}
e : ℕ
this : 0 < (1 / 2) ^ e
R : ℝ
R_pos : R > 0
hR : ∀ r ∈ Ioo 0 R, x ∈ A f (derivWithin f (Ici x) x) r ((1 / 2) ^ e)
n : ℕ
hn : (1 / 2) ^ n < R
⊢ x ∈ ⋃ n, ⋂ p, ⋂ (_ : p ≥ n), ⋂ q, ⋂ (_ : q ≥ n), B f K ((1 / 2) ^ p) ((1 / 2) ^ q) ((1 / 2) ^ e)
|
02ae9336af5f07d4
|
mem_nhds_induced
|
Mathlib/Topology/Order.lean
|
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s
|
α : Type u
β : Type v
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ s ∈ 𝓝 a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s
|
simp_rw [mem_nhds_iff, isOpen_induced_iff]
|
α : Type u
β : Type v
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t) ↔ ∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s
|
64abb6c0366449b9
|
AkraBazziRecurrence.smoothingFn_mul_asympBound_isBigO_T
|
Mathlib/Computability/AkraBazzi/AkraBazzi.lean
|
/-- The main proof of the lower bound part of the Akra-Bazzi theorem. The factor
`1 + ε n` does not change the asymptotic order, but is needed for the induction step to go
through. -/
lemma smoothingFn_mul_asympBound_isBigO_T :
(fun (n : ℕ) => (1 + ε n) * asympBound g a b n) =O[atTop] T
|
case bc.h.h.a0
α : Type u_1
inst✝¹ : Fintype α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
inst✝ : Nonempty α
R : AkraBazziRecurrence T g a b r
b' : ℝ := b (min_bi b) / 2
hb_pos : 0 < b'
c₁ : ℝ
hc₁ : c₁ > 0
h_sumTransform_aux : ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), sumTransform (p a b) g (r i n) n ≤ c₁ * g ↑n
n₀ : ℕ
n₀_ge_Rn₀ : R.n₀ ≤ n₀
h_b_floor : 0 < ⌊b' * ↑n₀⌋₊
h_smoothing_pos : ∀ (y : ℕ), n₀ ≤ y → 0 < 1 + ε ↑y
h_smoothing_pos' : ∀ (y : ℕ), ⌊b' * ↑n₀⌋₊ ≤ y → 0 < 1 + ε ↑y
h_asympBound_pos : ∀ (y : ℕ), n₀ ≤ y → 0 < asympBound g a b y
h_asympBound_r_pos : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), 0 < asympBound g a b (r i y)
h_asympBound_floor : ∀ (y : ℕ), ⌊b' * ↑n₀⌋₊ ≤ y → 0 < asympBound g a b y
n₀_pos : 0 < n₀
h_smoothing_r_pos : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), 0 < 1 + ε ↑(r i y)
bound2 : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), b i ^ p a b * ↑y ^ p a b * (1 + ε ↑y) ≤ ↑(r i y) ^ p a b * (1 + ε ↑(r i y))
h_smoothingFn_floor : ∀ (y : ℕ), ⌊b' * ↑n₀⌋₊ ≤ y → 0 < 1 + ε ↑y
h_sumTransform : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), sumTransform (p a b) g (r i y) y ≤ c₁ * g ↑y
h_bi_le_r : ∀ (y : ℕ), n₀ ≤ y → ∀ (i : α), b (min_bi b) / 2 * ↑y ≤ ↑(r i y)
h_exp : ∀ (y : ℕ), n₀ ≤ y → ⌈rexp 1⌉₊ ≤ y
h_base_nonempty : (Ico ⌊b (min_bi b) / 2 * ↑n₀⌋₊ n₀).Nonempty
base_min : ℝ := (Ico ⌊b' * ↑n₀⌋₊ n₀).inf' h_base_nonempty fun n => T n / ((1 + ε ↑n) * asympBound g a b n)
base_min_def : base_min = (Ico ⌊b' * ↑n₀⌋₊ n₀).inf' h_base_nonempty fun n => T n / ((1 + ε ↑n) * asympBound g a b n)
C : ℝ := (2 * c₁)⁻¹ ⊓ base_min
hC_pos : 0 < C
h_base : ∀ n ∈ Ico ⌊b' * ↑n₀⌋₊ n₀, C * ((1 + ε ↑n) * asympBound g a b n) ≤ T n
n : ℕ
h_ind : ∀ m < n, m ≥ n₀ → 0 < asympBound g a b m → 0 < 1 + ε ↑m → C * ((1 + ε ↑m) * asympBound g a b m) ≤ T m
hn : n ≥ n₀
h_asympBound_pos' : 0 < asympBound g a b n
h_one_sub_smoothingFn_pos' : 0 < 1 + ε ↑n
b_mul_n₀_le_ri : ∀ (i : α), ⌊b' * ↑n₀⌋₊ ≤ r i n
g_pos : 0 ≤ g ↑n
i : α
a✝ : i ∈ univ
j : ℕ
x✝ : j ∈ range (r i n)
⊢ 0 ≤ g ↑j ∧ 0 ≤ ↑j ^ (p a b + 1) ∨ g ↑j ≤ 0 ∧ ↑j ^ (p a b + 1) ≤ 0
|
exact Or.inl ⟨R.g_nonneg j (by positivity), by positivity⟩
|
no goals
|
82bb51116c3f899e
|
IsCyclotomicExtension.union_right
|
Mathlib/NumberTheory/Cyclotomic/Basic.lean
|
theorem union_right [h : IsCyclotomicExtension (S ∪ T) A B] :
IsCyclotomicExtension T (adjoin A {b : B | ∃ a : ℕ+, a ∈ S ∧ b ^ (a : ℕ) = 1}) B
|
S T : Set ℕ+
A : Type u
B : Type v
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : Algebra A B
h : IsCyclotomicExtension (S ∪ T) A B
this : {b | ∃ n ∈ S ∪ T, b ^ ↑n = 1} = {b | ∃ n ∈ S, b ^ ↑n = 1} ∪ {b | ∃ n ∈ T, b ^ ↑n = 1}
⊢ IsCyclotomicExtension T (↥(adjoin A {b | ∃ a ∈ S, b ^ ↑a = 1})) B
|
refine ⟨fun hn => ((isCyclotomicExtension_iff _ A _).1 h).1 (mem_union_right S hn), fun b => ?_⟩
|
S T : Set ℕ+
A : Type u
B : Type v
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : Algebra A B
h : IsCyclotomicExtension (S ∪ T) A B
this : {b | ∃ n ∈ S ∪ T, b ^ ↑n = 1} = {b | ∃ n ∈ S, b ^ ↑n = 1} ∪ {b | ∃ n ∈ T, b ^ ↑n = 1}
b : B
⊢ b ∈ adjoin ↥(adjoin A {b | ∃ a ∈ S, b ^ ↑a = 1}) {b | ∃ n ∈ T, b ^ ↑n = 1}
|
e81df93a8ce1e666
|
Batteries.RBSet.findP?_insert_of_ne
|
Mathlib/.lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean
|
theorem findP?_insert_of_ne [@TransCmp α cmp] [IsStrictCut cmp cut]
(t : RBSet α cmp) (h : cut v ≠ .eq) : (t.insert v).findP? cut = t.findP? cut
|
α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h : cut v ≠ Ordering.eq
u : α
h' : cut u = Ordering.eq
⊢ t.find? v ≠ some u
|
exact mt (fun h => by rwa [IsCut.congr (cut := cut) (find?_some_eq_eq h)]) h
|
no goals
|
885241d4721d2736
|
isJacobsonRing_localization
|
Mathlib/RingTheory/Jacobson/Ring.lean
|
theorem isJacobsonRing_localization [H : IsJacobsonRing R] : IsJacobsonRing S
|
case pos
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
y : R
inst✝¹ : Algebra R S
inst✝ : Away y S
H : IsJacobsonRing R
P' : Ideal S
hP'✝ : P'.IsPrime
hP' : (Ideal.comap (algebraMap R S) P').IsPrime
hPM : Disjoint ↑(powers y) ↑(Ideal.comap (algebraMap R S) P')
hP : (Ideal.comap (algebraMap R S) P').jacobson = Ideal.comap (algebraMap R S) P'
x : R
hx : x ∈ sInf {I | Ideal.comap (algebraMap R S) P' ≤ I ∧ I.IsMaximal ∧ y ∉ I}
J : Ideal R
hJ : J ∈ {J | Ideal.comap (algebraMap R S) P' ≤ J ∧ J.IsMaximal}
h : y ∈ J
⊢ x * y ∈ J
|
exact J.mul_mem_left x h
|
no goals
|
4266ea15949c3cae
|
Polynomial.IsPrimitive.dvd_of_fraction_map_dvd_fraction_map
|
Mathlib/RingTheory/Polynomial/GaussLemma.lean
|
theorem IsPrimitive.dvd_of_fraction_map_dvd_fraction_map {p q : R[X]} (hp : p.IsPrimitive)
(hq : q.IsPrimitive) (h_dvd : p.map (algebraMap R K) ∣ q.map (algebraMap R K)) : p ∣ q
|
case intro.intro.mk
R : Type u_1
inst✝⁵ : CommRing R
K : Type u_2
inst✝⁴ : Field K
inst✝³ : Algebra R K
inst✝² : IsFractionRing R K
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hp : p.IsPrimitive
hq : q.IsPrimitive
r : K[X]
hr : map (algebraMap R K) q = map (algebraMap R K) p * r
s : R
hs : map (algebraMap R K) (integerNormalization R⁰ r) = C ((algebraMap R K) s) * r
h : p ∣ q * C s
s0 : s = 0
⊢ s ∉ R⁰
|
simp [s0, mem_nonZeroDivisors_iff_ne_zero]
|
no goals
|
e016a9b0390ddacb
|
linearIndependent_sum
|
Mathlib/LinearAlgebra/LinearIndependent/Basic.lean
|
theorem linearIndependent_sum {v : ι ⊕ ι' → M} :
LinearIndependent R v ↔
LinearIndependent R (v ∘ Sum.inl) ∧
LinearIndependent R (v ∘ Sum.inr) ∧
Disjoint (Submodule.span R (range (v ∘ Sum.inl)))
(Submodule.span R (range (v ∘ Sum.inr)))
|
case refine_2.intro.intro.inl
ι : Type u'
ι' : Type u_1
R : Type u_2
M : Type u_4
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
v : ι ⊕ ι' → M
hl : ∀ (s : Finset ι) (g : ι → R), ∑ i ∈ s, g i • (v ∘ Sum.inl) i = 0 → ∀ i ∈ s, g i = 0
hr : ∀ (s : Finset ι') (g : ι' → R), ∑ i ∈ s, g i • (v ∘ Sum.inr) i = 0 → ∀ i ∈ s, g i = 0
hlr : ∀ x ∈ span R (v '' range Sum.inl), ∀ y ∈ span R (v '' range Sum.inr), x = y → x = 0
s : Finset (ι ⊕ ι')
g : ι ⊕ ι' → R
hg : ∑ i ∈ s, g i • v i = 0
this :
∑ i ∈ s.preimage Sum.inl ⋯, (fun x => g x • v x) (Sum.inl i) =
-∑ i ∈ s.preimage Sum.inr ⋯, (fun x => g x • v x) (Sum.inr i)
A : ∑ c ∈ s.preimage Sum.inl ⋯, (fun x => g x • v x) (Sum.inl c) = 0
i : ι
hi : Sum.inl i ∈ s
⊢ g (Sum.inl i) = 0
|
exact hl _ _ A i (Finset.mem_preimage.2 hi)
|
no goals
|
2518c65a54e13190
|
CategoryTheory.MorphismProperty.map_id_eq_isoClosure
|
Mathlib/CategoryTheory/MorphismProperty/Basic.lean
|
lemma map_id_eq_isoClosure (P : MorphismProperty C) :
P.map (𝟭 _) = P.isoClosure
|
case a
C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
⊢ P ≤ P.isoClosure.inverseImage (𝟭 C)
|
intro X Y f hf
|
case a
C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
X Y : C
f : X ⟶ Y
hf : P f
⊢ P.isoClosure.inverseImage (𝟭 C) f
|
be21352197170292
|
MeasureTheory.SimpleFunc.const_lintegral
|
Mathlib/MeasureTheory/Function/SimpleFunc.lean
|
theorem const_lintegral (c : ℝ≥0∞) : (const α c).lintegral μ = c * μ univ
|
case inr
α : Type u_1
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
h✝ : Nonempty α
⊢ c * μ ((fun x => c) ⁻¹' {c}) = c * μ univ
|
rw [preimage_const_of_mem (mem_singleton c)]
|
no goals
|
4222a64e67e68cc4
|
IsPrimePow.factorization_minFac_ne_zero
|
Mathlib/Data/Nat/Factorization/PrimePow.lean
|
lemma IsPrimePow.factorization_minFac_ne_zero {n : ℕ} (hn : IsPrimePow n) :
n.factorization n.minFac ≠ 0
|
n : ℕ
hn : IsPrimePow n
⊢ ¬(¬Nat.Prime n.minFac ∨ ¬n.minFac ∣ n ∨ n = 0)
|
push_neg
|
n : ℕ
hn : IsPrimePow n
⊢ Nat.Prime n.minFac ∧ n.minFac ∣ n ∧ n ≠ 0
|
f87a3b63f3edf769
|
HasDerivWithinAt.clm_apply
|
Mathlib/Analysis/Calculus/Deriv/Mul.lean
|
theorem HasDerivWithinAt.clm_apply (hc : HasDerivWithinAt c c' s x)
(hu : HasDerivWithinAt u u' s x) :
HasDerivWithinAt (fun y => (c y) (u y)) (c' (u x) + c x u') s x
|
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
x : 𝕜
s : Set 𝕜
G : Type u_2
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
u : 𝕜 → F
u' : F
hc : HasDerivWithinAt c c' s x
hu : HasDerivWithinAt u u' s x
this : HasDerivWithinAt (fun y => (c y) (u y)) (((c x).comp (smulRight 1 u') + (smulRight 1 c').flip (u x)) 1) s x
⊢ HasDerivWithinAt (fun y => (c y) (u y)) (c' (u x) + (c x) u') s x
|
rwa [add_apply, comp_apply, flip_apply, smulRight_apply, smulRight_apply, one_apply, one_smul,
one_smul, add_comm] at this
|
no goals
|
b2df66ae9b2ccd18
|
SupIrred.finset_sup_eq
|
Mathlib/Order/Irreducible.lean
|
theorem SupIrred.finset_sup_eq (ha : SupIrred a) (h : s.sup f = a) : ∃ i ∈ s, f i = a
|
case empty
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupIrred a
h : ∅.sup f = a
⊢ ∃ i ∈ ∅, f i = a
|
simpa [ha.ne_bot] using h.symm
|
no goals
|
4acb7029d3da247f
|
ConvexOn.continuousOn_tfae
|
Mathlib/Analysis/Convex/Continuous.lean
|
lemma ConvexOn.continuousOn_tfae (hC : IsOpen C) (hC' : C.Nonempty) (hf : ConvexOn ℝ C f) : TFAE [
LocallyLipschitzOn C f,
ContinuousOn f C,
∃ x₀ ∈ C, ContinuousAt f x₀,
∃ x₀ ∈ C, (𝓝 x₀).IsBoundedUnder (· ≤ ·) f,
∀ ⦃x₀⦄, x₀ ∈ C → (𝓝 x₀).IsBoundedUnder (· ≤ ·) f,
∀ ⦃x₀⦄, x₀ ∈ C → (𝓝 x₀).IsBoundedUnder (· ≤ ·) |f|]
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
C : Set E
f : E → ℝ
hC : IsOpen C
hC' : C.Nonempty
hf : ConvexOn ℝ C f
tfae_1_to_2 : LocallyLipschitzOn C f → ContinuousOn f C
tfae_2_to_3 : ContinuousOn f C → ∃ x₀ ∈ C, ContinuousAt f x₀
x₀ : E
hx₀ : x₀ ∈ C
h : ContinuousAt f x₀
⊢ f x₀ < f x₀ + 1
|
simp
|
no goals
|
d7a82928a7cc2bf5
|
IsMulFreimanHom.comp
|
Mathlib/Combinatorics/Additive/FreimanHom.lean
|
@[to_additive] lemma IsMulFreimanHom.comp (hg : IsMulFreimanHom n B C g)
(hf : IsMulFreimanHom n A B f) : IsMulFreimanHom n A C (g ∘ f) where
mapsTo := hg.mapsTo.comp hf.mapsTo
map_prod_eq_map_prod s t hsA htA hs ht h
|
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A : Set α
B : Set β
C : Set γ
f : α → β
g : β → γ
n : ℕ
hg : IsMulFreimanHom n B C g
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = n
ht : t.card = n
h : s.prod = t.prod
⊢ (map (g ∘ f) s).prod = (map (g ∘ f) t).prod
|
rw [← map_map, ← map_map]
|
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A : Set α
B : Set β
C : Set γ
f : α → β
g : β → γ
n : ℕ
hg : IsMulFreimanHom n B C g
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : s.card = n
ht : t.card = n
h : s.prod = t.prod
⊢ (map g (map f s)).prod = (map g (map f t)).prod
|
df817a6de52f5c2c
|
Wbtw.collinear
|
Mathlib/Analysis/Convex/Between.lean
|
theorem Wbtw.collinear {x y z : P} (h : Wbtw R x y z) : Collinear R ({x, y, z} : Set P)
|
case inr.inl.intro.intro
R : Type u_1
V : Type u_2
P : Type u_4
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x z : P
t : R
⊢ ∃ r, (lineMap x z) t = r • (z -ᵥ x) +ᵥ x
|
exact ⟨t, rfl⟩
|
no goals
|
d43d75b5cd5fb4e5
|
Fin.inv_partialProd_mul_eq_contractNth
|
Mathlib/Algebra/BigOperators/Fin.lean
|
theorem inv_partialProd_mul_eq_contractNth {G : Type*} [Group G] (g : Fin (n + 1) → G)
(j : Fin (n + 1)) (k : Fin n) :
(partialProd g (j.succ.succAbove (Fin.castSucc k)))⁻¹ * partialProd g (j.succAbove k).succ =
j.contractNth (· * ·) g k
|
case inr.inr.h
n : ℕ
G : Type u_3
inst✝ : Group G
g : Fin (n + 1) → G
j : Fin (n + 1)
k : Fin n
h : ↑j < ↑k
⊢ j.succ ≤ k.castSucc.castSucc
|
rw [le_iff_val_le_val, val_succ]
|
case inr.inr.h
n : ℕ
G : Type u_3
inst✝ : Group G
g : Fin (n + 1) → G
j : Fin (n + 1)
k : Fin n
h : ↑j < ↑k
⊢ ↑j + 1 ≤ ↑k.castSucc.castSucc
|
f84a17ef32860b19
|
zero_lt_one_add_norm_sq'
|
Mathlib/Analysis/Normed/Group/Basic.lean
|
theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2
|
E : Type u_5
inst✝ : SeminormedGroup E
x : E
⊢ 0 < 1 + ‖x‖ ^ 2
|
positivity
|
no goals
|
b35ff64791d12e79
|
MeasureTheory.lintegral_comp_eq_lintegral_meas_le_mul_of_measurable
|
Mathlib/MeasureTheory/Integral/Layercake.lean
|
theorem lintegral_comp_eq_lintegral_meas_le_mul_of_measurable (μ : Measure α)
(f_nn : 0 ≤ f) (f_mble : Measurable f)
(g_intble : ∀ t > 0, IntervalIntegrable g volume 0 t) (g_mble : Measurable g)
(g_nn : ∀ t > 0, 0 ≤ g t) :
∫⁻ ω, ENNReal.ofReal (∫ t in (0)..f ω, g t) ∂μ =
∫⁻ t in Ioi 0, μ {a : α | t ≤ f a} * ENNReal.ofReal (g t)
|
α : Type u_1
inst✝ : MeasurableSpace α
f : α → ℝ
g : ℝ → ℝ
μ : Measure α
f_nn : 0 ≤ f
f_mble : Measurable f
g_intble : ∀ t > 0, IntervalIntegrable g volume 0 t
g_mble : Measurable g
g_nn : ∀ t > 0, 0 ≤ g t
f_nonneg : ∀ (ω : α), 0 ≤ f ω
H1 : ¬g =ᶠ[ae (volume.restrict (Ioi 0))] 0
H2 : ∀ s > 0, 0 < ∫ (t : ℝ) in 0 ..s, g t → μ {a | s < f a} ≠ ⊤
M_bdd : BddAbove {s | g =ᶠ[ae (volume.restrict (Ioc 0 s))] 0}
M : ℝ := sSup {s | g =ᶠ[ae (volume.restrict (Ioc 0 s))] 0}
zero_mem : 0 ∈ {s | g =ᶠ[ae (volume.restrict (Ioc 0 s))] 0}
M_nonneg : 0 ≤ M
hgM : g =ᶠ[ae (volume.restrict (Ioc 0 M))] 0
ν : Measure α := μ.restrict {a | M < f a}
u : ℕ → ℝ
uM : ∀ (n : ℕ), M < u n
ulim : Tendsto u atTop (𝓝 M)
n : ℕ
⊢ μ ({a | f a ≤ M} ∩ {a | M < f a}) = 0
|
convert measure_empty (μ := μ)
|
case h.e'_2.h.e'_6
α : Type u_1
inst✝ : MeasurableSpace α
f : α → ℝ
g : ℝ → ℝ
μ : Measure α
f_nn : 0 ≤ f
f_mble : Measurable f
g_intble : ∀ t > 0, IntervalIntegrable g volume 0 t
g_mble : Measurable g
g_nn : ∀ t > 0, 0 ≤ g t
f_nonneg : ∀ (ω : α), 0 ≤ f ω
H1 : ¬g =ᶠ[ae (volume.restrict (Ioi 0))] 0
H2 : ∀ s > 0, 0 < ∫ (t : ℝ) in 0 ..s, g t → μ {a | s < f a} ≠ ⊤
M_bdd : BddAbove {s | g =ᶠ[ae (volume.restrict (Ioc 0 s))] 0}
M : ℝ := sSup {s | g =ᶠ[ae (volume.restrict (Ioc 0 s))] 0}
zero_mem : 0 ∈ {s | g =ᶠ[ae (volume.restrict (Ioc 0 s))] 0}
M_nonneg : 0 ≤ M
hgM : g =ᶠ[ae (volume.restrict (Ioc 0 M))] 0
ν : Measure α := μ.restrict {a | M < f a}
u : ℕ → ℝ
uM : ∀ (n : ℕ), M < u n
ulim : Tendsto u atTop (𝓝 M)
n : ℕ
⊢ {a | f a ≤ M} ∩ {a | M < f a} = ∅
|
6098eac6b53bede3
|
MultilinearMap.map_sum_finset_aux
|
Mathlib/LinearAlgebra/Multilinear/Basic.lean
|
theorem map_sum_finset_aux [DecidableEq ι] [Fintype ι] {n : ℕ} (h : (∑ i, #(A i)) = n) :
(f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ piFinset A, f fun i => g i (r i)
|
R : Type uR
ι : Type uι
M₁ : ι → Type v₁
M₂ : Type v₂
inst✝⁶ : Semiring R
inst✝⁵ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
f : MultilinearMap R M₁ M₂
α : ι → Type u_1
g : (i : ι) → α i → M₁ i
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
this : (i : ι) → DecidableEq (α i) := fun i => Classical.decEq (α i)
n : ℕ
IH :
∀ m < n,
∀ (A : (i : ι) → Finset (α i)),
∑ i : ι, #(A i) = m → (f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ piFinset A, f fun i => g i (r i)
A : (i : ι) → Finset (α i)
h : ∑ i : ι, #(A i) = n
Ai_empty : ∀ (i : ι), A i ≠ ∅
Ai_singleton : ∀ (i : ι), #(A i) ≤ 1
Ai_card : ∀ (i : ι), #(A i) = 1
r : (i : ι) → α i
hr : r ∈ piFinset A
⊢ (f fun i => g i (r i)) = f fun i => ∑ j ∈ A i, g i j
|
congr with i
|
case h.e_6.h.h
R : Type uR
ι : Type uι
M₁ : ι → Type v₁
M₂ : Type v₂
inst✝⁶ : Semiring R
inst✝⁵ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
f : MultilinearMap R M₁ M₂
α : ι → Type u_1
g : (i : ι) → α i → M₁ i
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
this : (i : ι) → DecidableEq (α i) := fun i => Classical.decEq (α i)
n : ℕ
IH :
∀ m < n,
∀ (A : (i : ι) → Finset (α i)),
∑ i : ι, #(A i) = m → (f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ piFinset A, f fun i => g i (r i)
A : (i : ι) → Finset (α i)
h : ∑ i : ι, #(A i) = n
Ai_empty : ∀ (i : ι), A i ≠ ∅
Ai_singleton : ∀ (i : ι), #(A i) ≤ 1
Ai_card : ∀ (i : ι), #(A i) = 1
r : (i : ι) → α i
hr : r ∈ piFinset A
i : ι
⊢ g i (r i) = ∑ j ∈ A i, g i j
|
981a316f387f732a
|
MeasureTheory.tendsto_lintegral_filter_of_dominated_convergence
|
Mathlib/MeasureTheory/Integral/Lebesgue.lean
|
theorem tendsto_lintegral_filter_of_dominated_convergence {ι} {l : Filter ι}
[l.IsCountablyGenerated] {F : ι → α → ℝ≥0∞} {f : α → ℝ≥0∞} (bound : α → ℝ≥0∞)
(hF_meas : ∀ᶠ n in l, Measurable (F n)) (h_bound : ∀ᶠ n in l, ∀ᵐ a ∂μ, F n a ≤ bound a)
(h_fin : ∫⁻ a, bound a ∂μ ≠ ∞) (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) l (𝓝 (f a))) :
Tendsto (fun n => ∫⁻ a, F n a ∂μ) l (𝓝 <| ∫⁻ a, f a ∂μ)
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
ι : Type u_5
l : Filter ι
inst✝ : l.IsCountablyGenerated
F : ι → α → ℝ≥0∞
f bound : α → ℝ≥0∞
hF_meas : ∀ᶠ (n : ι) in l, Measurable (F n)
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (a : α) ∂μ, F n a ≤ bound a
h_fin : ∫⁻ (a : α), bound a ∂μ ≠ ⊤
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) l (𝓝 (f a))
x : ℕ → ι
xl : Tendsto x atTop l
hxl : ∀ s ∈ l, ∃ a, ∀ b ≥ a, x b ∈ s
h : ∃ a, ∀ b ≥ a, x b ∈ {x | (fun n => Measurable (F n)) x} ∩ {x | (fun n => ∀ᵐ (a : α) ∂μ, F n a ≤ bound a) x}
⊢ Tendsto ((fun n => ∫⁻ (a : α), F n a ∂μ) ∘ x) atTop (𝓝 (∫⁻ (a : α), f a ∂μ))
|
rcases h with ⟨k, h⟩
|
case intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
ι : Type u_5
l : Filter ι
inst✝ : l.IsCountablyGenerated
F : ι → α → ℝ≥0∞
f bound : α → ℝ≥0∞
hF_meas : ∀ᶠ (n : ι) in l, Measurable (F n)
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (a : α) ∂μ, F n a ≤ bound a
h_fin : ∫⁻ (a : α), bound a ∂μ ≠ ⊤
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) l (𝓝 (f a))
x : ℕ → ι
xl : Tendsto x atTop l
hxl : ∀ s ∈ l, ∃ a, ∀ b ≥ a, x b ∈ s
k : ℕ
h : ∀ b ≥ k, x b ∈ {x | (fun n => Measurable (F n)) x} ∩ {x | (fun n => ∀ᵐ (a : α) ∂μ, F n a ≤ bound a) x}
⊢ Tendsto ((fun n => ∫⁻ (a : α), F n a ∂μ) ∘ x) atTop (𝓝 (∫⁻ (a : α), f a ∂μ))
|
879da8b2b29c96c4
|
Nat.primeFactorsList_prime
|
Mathlib/Data/Nat/Factors.lean
|
theorem primeFactorsList_prime {p : ℕ} (hp : Nat.Prime p) : p.primeFactorsList = [p]
|
p : ℕ
hp : Prime p
this✝ : p = p - 2 + 2
this : p.minFac = p
⊢ p.minFac :: (p / p.minFac).primeFactorsList = [p]
|
simp only [this, primeFactorsList, Nat.div_self (Nat.Prime.pos hp)]
|
no goals
|
671d32de56a629cc
|
Submodule.spanRank_toENat_eq_iInf_finset_card
|
Mathlib/Algebra/Module/SpanRank.lean
|
lemma spanRank_toENat_eq_iInf_finset_card (p : Submodule R M) :
p.spanRank.toENat =
⨅ (s : {s : Set M // s.Finite ∧ span R s = p}), (s.2.1.toFinset.card : ℕ∞)
|
case inr
R : Type u_1
M : Type u
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
h2 : ⨅ s, ⨅ (_ : span R s = p), s.encard ≠ ⊤
⊢ ⨅ s, ⨅ (_ : span R s = p), s.encard = ⨅ s, ↑⋯.toFinset.card
|
apply le_antisymm
|
case inr.a
R : Type u_1
M : Type u
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
h2 : ⨅ s, ⨅ (_ : span R s = p), s.encard ≠ ⊤
⊢ ⨅ s, ⨅ (_ : span R s = p), s.encard ≤ ⨅ s, ↑⋯.toFinset.card
case inr.a
R : Type u_1
M : Type u
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
h2 : ⨅ s, ⨅ (_ : span R s = p), s.encard ≠ ⊤
⊢ ⨅ s, ↑⋯.toFinset.card ≤ ⨅ s, ⨅ (_ : span R s = p), s.encard
|
f74636938a98e2b3
|
CategoryTheory.MorphismProperty.pullbacks_le
|
Mathlib/CategoryTheory/MorphismProperty/Limits.lean
|
lemma pullbacks_le [P.IsStableUnderBaseChange] : P.pullbacks ≤ P
|
C : Type u
inst✝¹ : Category.{v, u} C
P : MorphismProperty C
inst✝ : P.IsStableUnderBaseChange
⊢ P.pullbacks ≤ P
|
rwa [← isStableUnderBaseChange_iff_pullbacks_le]
|
no goals
|
15b19b1863dec296
|
MeasureTheory.UnifTight.aeeq
|
Mathlib/MeasureTheory/Function/UnifTight.lean
|
theorem aeeq (hf : UnifTight f p μ) (hfg : ∀ n, f n =ᵐ[μ] g n) :
UnifTight g p μ
|
case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifTight f p μ
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
ε : ℝ≥0
hε : 0 < ε
s : Set α
hμs : μ s ≠ ⊤
hfε : ∀ (i : ι), eLpNorm (sᶜ.indicator (f i)) p μ ≤ ↑ε
⊢ ∃ s, μ s ≠ ⊤ ∧ ∀ (i : ι), eLpNorm (sᶜ.indicator (g i)) p μ ≤ ↑ε
|
refine ⟨s, hμs, fun n => (le_of_eq <| eLpNorm_congr_ae ?_).trans (hfε n)⟩
|
case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifTight f p μ
hfg : ∀ (n : ι), f n =ᶠ[ae μ] g n
ε : ℝ≥0
hε : 0 < ε
s : Set α
hμs : μ s ≠ ⊤
hfε : ∀ (i : ι), eLpNorm (sᶜ.indicator (f i)) p μ ≤ ↑ε
n : ι
⊢ sᶜ.indicator (g n) =ᶠ[ae μ] sᶜ.indicator (f n)
|
453e4514d55787ac
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_go_eq_divRec_q
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.lean
|
theorem denote_go_eq_divRec_q (aig : AIG α) (assign : α → Bool) (curr : Nat) (lhs rhs rbv qbv : BitVec w)
(falseRef trueRef : AIG.Ref aig) (n d q r : AIG.RefVec aig w) (wn wr : Nat)
(hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, n.get idx hidx, assign⟧ = lhs.getLsbD idx)
(hright : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, d.get idx hidx, assign⟧ = rhs.getLsbD idx)
(hq : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, q.get idx hidx, assign⟧ = qbv.getLsbD idx)
(hr : ∀ (idx : Nat) (hidx : idx < w), ⟦aig, r.get idx hidx, assign⟧ = rbv.getLsbD idx)
(hfalse : ⟦aig, falseRef, assign⟧ = false)
(htrue : ⟦aig, trueRef, assign⟧ = true)
:
∀ (idx : Nat) (hidx : idx < w),
⟦
(go aig curr falseRef trueRef n d wn wr q r).aig,
(go aig curr falseRef trueRef n d wn wr q r).q.get idx hidx,
assign
⟧
=
(BitVec.divRec curr { n := lhs, d := rhs} { wn, wr, q := qbv, r := rbv }).q.getLsbD idx
|
case hq
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
assign : α → Bool
lhs rhs : BitVec w
curr : Nat
ih :
∀ (aig : AIG α) (rbv qbv : BitVec w) (falseRef trueRef : aig.Ref) (n d q r : aig.RefVec w) (wn wr : Nat),
(∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := n.get idx hidx }⟧ = lhs.getLsbD idx) →
(∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := d.get idx hidx }⟧ = rhs.getLsbD idx) →
(∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := q.get idx hidx }⟧ = qbv.getLsbD idx) →
(∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := r.get idx hidx }⟧ = rbv.getLsbD idx) →
⟦assign, { aig := aig, ref := falseRef }⟧ = false →
⟦assign, { aig := aig, ref := trueRef }⟧ = true →
∀ (idx : Nat) (hidx : idx < w),
⟦assign,
{ aig := (go aig curr falseRef trueRef n d wn wr q r).aig,
ref := (go aig curr falseRef trueRef n d wn wr q r).q.get idx hidx }⟧ =
(BitVec.divRec curr { n := lhs, d := rhs } { wn := wn, wr := wr, q := qbv, r := rbv }).q.getLsbD idx
aig : AIG α
rbv qbv : BitVec w
falseRef trueRef : aig.Ref
n d q r : aig.RefVec w
wn wr : Nat
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := n.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := d.get idx hidx }⟧ = rhs.getLsbD idx
hq : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := q.get idx hidx }⟧ = qbv.getLsbD idx
hr : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := r.get idx hidx }⟧ = rbv.getLsbD idx
hfalse : ⟦assign, { aig := aig, ref := falseRef }⟧ = false
htrue : ⟦assign, { aig := aig, ref := trueRef }⟧ = true
idx : Nat
hidx : idx < w
hdiscr :
{ wn := wn, wr := wr, q := qbv, r := rbv }.r.shiftConcat
(lhs.getLsbD ({ wn := wn, wr := wr, q := qbv, r := rbv }.wn - 1)) <
rhs
⊢ ∀ (idx : Nat) (hidx : idx < w),
⟦assign,
{ aig := (blastDivSubtractShift aig falseRef trueRef n d wn wr q r).aig,
ref := (blastDivSubtractShift aig falseRef trueRef n d wn wr q r).q.get idx hidx }⟧ =
({ wn := wn, wr := wr, q := qbv, r := rbv }.q.shiftConcat false).getLsbD idx
|
intro idx hidx
|
case hq
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
assign : α → Bool
lhs rhs : BitVec w
curr : Nat
ih :
∀ (aig : AIG α) (rbv qbv : BitVec w) (falseRef trueRef : aig.Ref) (n d q r : aig.RefVec w) (wn wr : Nat),
(∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := n.get idx hidx }⟧ = lhs.getLsbD idx) →
(∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := d.get idx hidx }⟧ = rhs.getLsbD idx) →
(∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := q.get idx hidx }⟧ = qbv.getLsbD idx) →
(∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := r.get idx hidx }⟧ = rbv.getLsbD idx) →
⟦assign, { aig := aig, ref := falseRef }⟧ = false →
⟦assign, { aig := aig, ref := trueRef }⟧ = true →
∀ (idx : Nat) (hidx : idx < w),
⟦assign,
{ aig := (go aig curr falseRef trueRef n d wn wr q r).aig,
ref := (go aig curr falseRef trueRef n d wn wr q r).q.get idx hidx }⟧ =
(BitVec.divRec curr { n := lhs, d := rhs } { wn := wn, wr := wr, q := qbv, r := rbv }).q.getLsbD idx
aig : AIG α
rbv qbv : BitVec w
falseRef trueRef : aig.Ref
n d q r : aig.RefVec w
wn wr : Nat
hleft : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := n.get idx hidx }⟧ = lhs.getLsbD idx
hright : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := d.get idx hidx }⟧ = rhs.getLsbD idx
hq : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := q.get idx hidx }⟧ = qbv.getLsbD idx
hr : ∀ (idx : Nat) (hidx : idx < w), ⟦assign, { aig := aig, ref := r.get idx hidx }⟧ = rbv.getLsbD idx
hfalse : ⟦assign, { aig := aig, ref := falseRef }⟧ = false
htrue : ⟦assign, { aig := aig, ref := trueRef }⟧ = true
idx✝ : Nat
hidx✝ : idx✝ < w
hdiscr :
{ wn := wn, wr := wr, q := qbv, r := rbv }.r.shiftConcat
(lhs.getLsbD ({ wn := wn, wr := wr, q := qbv, r := rbv }.wn - 1)) <
rhs
idx : Nat
hidx : idx < w
⊢ ⟦assign,
{ aig := (blastDivSubtractShift aig falseRef trueRef n d wn wr q r).aig,
ref := (blastDivSubtractShift aig falseRef trueRef n d wn wr q r).q.get idx hidx }⟧ =
({ wn := wn, wr := wr, q := qbv, r := rbv }.q.shiftConcat false).getLsbD idx
|
edb5936f3962e4a9
|
LieAlgebra.isEngelian_of_subsingleton
|
Mathlib/Algebra/Lie/Engel.lean
|
theorem LieAlgebra.isEngelian_of_subsingleton [Subsingleton L] : LieAlgebra.IsEngelian R L
|
case h
R : Type u₁
L : Type u₂
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : Subsingleton L
M : Type u_1
_i1 : AddCommGroup M
_i2 : Module R M
_i3 : LieRingModule L M
_i4 : LieModule R L M
_h : ∀ (x : L), IsNilpotent ((toEnd R L M) x)
⊢ lowerCentralSeries ℤ L M 1 = ⊥
|
simp
|
no goals
|
e1bc69c104947d71
|
SimpleGraph.IsCycles.exists_cycle_toSubgraph_verts_eq_connectedComponentSupp
|
Mathlib/Combinatorics/SimpleGraph/Matching.lean
|
lemma IsCycles.exists_cycle_toSubgraph_verts_eq_connectedComponentSupp [Finite V]
{c : G.ConnectedComponent} (h : G.IsCycles) (hv : v ∈ c.supp)
(hn : (G.neighborSet v).Nonempty) :
∃ (p : G.Walk v v), p.IsCycle ∧ p.toSubgraph.verts = c.supp
|
case intro.intro.intro
V : Type u_1
G : SimpleGraph V
v : V
inst✝ : Finite V
c : G.ConnectedComponent
h : G.IsCycles
hv : v ∈ c.supp
w : V
hw : w ∈ G.neighborSet v
u : V
p : G.Walk u u
hp : p.IsCycle ∧ s(v, w) ∈ p.edges
⊢ ∃ p, p.IsCycle ∧ p.toSubgraph.verts = c.supp
|
have hvp : v ∈ p.support := SimpleGraph.Walk.fst_mem_support_of_mem_edges _ hp.2
|
case intro.intro.intro
V : Type u_1
G : SimpleGraph V
v : V
inst✝ : Finite V
c : G.ConnectedComponent
h : G.IsCycles
hv : v ∈ c.supp
w : V
hw : w ∈ G.neighborSet v
u : V
p : G.Walk u u
hp : p.IsCycle ∧ s(v, w) ∈ p.edges
hvp : v ∈ p.support
⊢ ∃ p, p.IsCycle ∧ p.toSubgraph.verts = c.supp
|
449969e7dbb35e13
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne_preserves_strongAssignmentsInvariant
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.lean
|
theorem deleteOne_preserves_strongAssignmentsInvariant {n : Nat} (f : DefaultFormula n) (id : Nat) :
StrongAssignmentsInvariant f → StrongAssignmentsInvariant (deleteOne f id)
|
case inl.h
n : Nat
f : DefaultFormula n
id : Nat
hsize : f.assignments.size = n
hsize' : (f.deleteOne id).assignments.size = n
i : PosFin n
b : Bool
i_in_bounds : i.val < f.assignments.size
c : DefaultClause n
heq : f.clauses[id]! = some c
l : Literal (PosFin n)
hl : c = { clause := [l], nodupkey := ⋯, nodup := ⋯ }
l_eq_i : l.fst.val = i.val
l_ne_b : l.snd = !b
hb✝ : hasAssignment b (removeAssignment (!b) f.assignments[i.val]) = true
hb : hasAssignment b f.assignments[i.val] = true
hf : some (unit (i, b)) ∈ f.clauses.toList
⊢ some (unit (i, b)) ∈ (f.clauses.set! id none).toList
|
simp only [Array.set!, Array.setIfInBounds]
|
case inl.h
n : Nat
f : DefaultFormula n
id : Nat
hsize : f.assignments.size = n
hsize' : (f.deleteOne id).assignments.size = n
i : PosFin n
b : Bool
i_in_bounds : i.val < f.assignments.size
c : DefaultClause n
heq : f.clauses[id]! = some c
l : Literal (PosFin n)
hl : c = { clause := [l], nodupkey := ⋯, nodup := ⋯ }
l_eq_i : l.fst.val = i.val
l_ne_b : l.snd = !b
hb✝ : hasAssignment b (removeAssignment (!b) f.assignments[i.val]) = true
hb : hasAssignment b f.assignments[i.val] = true
hf : some (unit (i, b)) ∈ f.clauses.toList
⊢ some (unit (i, b)) ∈ (if h : id < f.clauses.size then f.clauses.set id none h else f.clauses).toList
|
0ab20a88767ce69e
|
IsLocalizedModule.mk_eq_mk'
|
Mathlib/Algebra/Module/LocalizedModule/Basic.lean
|
theorem mk_eq_mk' (s : S) (m : M) :
LocalizedModule.mk m s = mk' (LocalizedModule.mkLinearMap S M) m s
|
R : Type u_1
inst✝² : CommSemiring R
S : Submonoid R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : ↥S
m : M
⊢ LocalizedModule.mk m s = mk' (LocalizedModule.mkLinearMap S M) m s
|
rw [eq_comm, mk'_eq_iff, Submonoid.smul_def, LocalizedModule.smul'_mk, ← Submonoid.smul_def,
LocalizedModule.mk_cancel, LocalizedModule.mkLinearMap_apply]
|
no goals
|
a62df2ede51f1c8a
|
CliffordAlgebra.forall_mul_self_eq_iff
|
Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
|
theorem forall_mul_self_eq_iff {A : Type*} [Ring A] [Algebra R A] (h2 : IsUnit (2 : A))
(f : M →ₗ[R] A) :
(∀ x, f x * f x = algebraMap _ _ (Q x)) ↔
(LinearMap.mul R A).compl₂ f ∘ₗ f + (LinearMap.mul R A).flip.compl₂ f ∘ₗ f =
Q.polarBilin.compr₂ (Algebra.linearMap R A)
|
R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
Q : QuadraticForm R M
A : Type u_4
inst✝¹ : Ring A
inst✝ : Algebra R A
h2 : IsUnit 2
f : M →ₗ[R] A
x : M
h : ∀ (x y : M), f x * f y + f y * f x = (algebraMap R A) (QuadraticMap.polar (⇑Q) x y)
⊢ f x * f x = (algebraMap R A) (Q x)
|
apply h2.mul_left_cancel
|
R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
Q : QuadraticForm R M
A : Type u_4
inst✝¹ : Ring A
inst✝ : Algebra R A
h2 : IsUnit 2
f : M →ₗ[R] A
x : M
h : ∀ (x y : M), f x * f y + f y * f x = (algebraMap R A) (QuadraticMap.polar (⇑Q) x y)
⊢ 2 * (f x * f x) = 2 * (algebraMap R A) (Q x)
|
a627073501885bf0
|
NumberField.Units.dirichletUnitTheorem.exists_unit
|
Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
|
theorem exists_unit (w₁ : InfinitePlace K) :
∃ u : (𝓞 K)ˣ, ∀ w : InfinitePlace K, w ≠ w₁ → Real.log (w u) < 0
|
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
w₁ : InfinitePlace K
⊢ ∃ x, minkowskiBound K 1 < ↑x * ↑(convexBodyLTFactor K)
|
exact ENNReal.exists_nat_mul_gt (ENNReal.coe_ne_zero.mpr (convexBodyLTFactor_ne_zero K))
(ne_of_lt (minkowskiBound_lt_top K 1))
|
no goals
|
a5c11596a1c04e50
|
faaDiBruno_aux2
|
Mathlib/Analysis/Calculus/ContDiff/FaaDiBruno.lean
|
/-- Composing a formal multilinear series with an ordered partition extended by adding a left point
to an already existing atom of index `i` corresponds to updating the `i`th block,
using `p (c.partSize i + 1)` instead of `p (c.partSize i)` there.
This is one of the terms that appears when differentiating in the Faa di Bruno
formula, going from step `m` to step `m + 1`. -/
private lemma faaDiBruno_aux2 {m : ℕ} (q : FormalMultilinearSeries 𝕜 F G)
(p : FormalMultilinearSeries 𝕜 E F) (c : OrderedFinpartition m) (i : Fin c.length) :
(q.compAlongOrderedFinpartition p (c.extend (some i))).curryLeft =
((c.compAlongOrderedFinpartitionL 𝕜 E F G (q c.length)).toContinuousLinearMap
(fun i ↦ p (c.partSize i)) i).comp (p (c.partSize i + 1)).curryLeft
|
case h.H
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
m : ℕ
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
c : OrderedFinpartition m
i : Fin c.length
e : E
v : Fin m → E
⊢ ((q c.length) fun m_1 =>
(p (update c.partSize i (c.partSize i + 1) m_1))
(cons e v ∘
if h : m_1 = i then (fun i_1 => cases 0 (succ ∘ c.emb i) i_1) ∘ Fin.cast ⋯
else succ ∘ c.emb m_1 ∘ Fin.cast ⋯)) =
(q c.length) fun m_1 =>
(update (fun i => p (c.partSize i)) i ((p (c.partSize i + 1)).curryLeft e) m_1) (v ∘ c.emb m_1)
|
congr
|
case h.H.h.e_6.h
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
m : ℕ
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
c : OrderedFinpartition m
i : Fin c.length
e : E
v : Fin m → E
⊢ (fun m_1 =>
(p (update c.partSize i (c.partSize i + 1) m_1))
(cons e v ∘
if h : m_1 = i then (fun i_1 => cases 0 (succ ∘ c.emb i) i_1) ∘ Fin.cast ⋯
else succ ∘ c.emb m_1 ∘ Fin.cast ⋯)) =
fun m_1 => (update (fun i => p (c.partSize i)) i ((p (c.partSize i + 1)).curryLeft e) m_1) (v ∘ c.emb m_1)
|
0043cf301ba04e46
|
CategoryTheory.isVanKampenColimit_of_isEmpty
|
Mathlib/CategoryTheory/Limits/VanKampen.lean
|
theorem isVanKampenColimit_of_isEmpty [HasStrictInitialObjects C] [IsEmpty J] {F : J ⥤ C}
(c : Cocone F) (hc : IsColimit c) : IsVanKampenColimit c
|
J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasStrictInitialObjects C
inst✝ : IsEmpty J
F : J ⥤ C
c : Cocone F
hc : IsColimit c
this : IsVanKampenColimit (asEmptyCocone c.pt)
⊢ IsVanKampenColimit (Cocone.whisker (equivalenceOfIsEmpty (Discrete PEmpty.{1}) J).functor c)
|
exact (this.precompose_isIso (Functor.uniqueFromEmpty
((equivalenceOfIsEmpty (Discrete PEmpty.{1}) J).functor ⋙ F)).hom).of_iso
(Cocones.ext (Iso.refl _) (by simp))
|
no goals
|
eeac24dc087b2172
|
exists_squarefree_dvd_pow_of_ne_zero
|
Mathlib/Algebra/Squarefree/Basic.lean
|
lemma _root_.exists_squarefree_dvd_pow_of_ne_zero {x : R} (hx : x ≠ 0) :
∃ (y : R) (n : ℕ), Squarefree y ∧ y ∣ x ∧ x ∣ y ^ n
|
case pos
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
z p : R
hz : z ≠ 0
hp : Irreducible p
ih : z ≠ 0 → ∃ y n, Squarefree y ∧ y ∣ z ∧ z ∣ y ^ n
hx : p * z ≠ 0
y : R
n : ℕ
hy : Squarefree y
hyx : y ∣ z
hy' : z ∣ y ^ n
hn : n > 0
hp' : p ∣ y
⊢ ∃ y n, Squarefree y ∧ y ∣ p * z ∧ p * z ∣ y ^ n
|
exact ⟨y, n + 1, hy, dvd_mul_of_dvd_right hyx _,
mul_comm p z ▸ pow_succ y n ▸ mul_dvd_mul hy' hp'⟩
|
no goals
|
2f11f1533d70f050
|
Vector.attach_map
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Attach.lean
|
theorem attach_map {l : Vector α n} (f : α → β) :
(l.map f).attach = l.attach.map (fun ⟨x, h⟩ => ⟨f x, mem_map_of_mem f h⟩)
|
α : Type u_1
n : Nat
β : Type u_2
l : Vector α n
f : α → β
⊢ (map f l).attach =
map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨f x, ⋯⟩)
l.attach
|
cases l
|
case mk
α : Type u_1
n : Nat
β : Type u_2
f : α → β
toArray✝ : Array α
size_toArray✝ : toArray✝.size = n
⊢ (map f { toArray := toArray✝, size_toArray := size_toArray✝ }).attach =
map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨f x, ⋯⟩)
{ toArray := toArray✝, size_toArray := size_toArray✝ }.attach
|
136b979f9fc12efc
|
conformalAt_iff_isConformalMap_fderiv
|
Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean
|
theorem conformalAt_iff_isConformalMap_fderiv {f : X → Y} {x : X} :
ConformalAt f x ↔ IsConformalMap (fderiv ℝ f x)
|
case neg
X : Type u_1
Y : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : NormedAddCommGroup Y
inst✝¹ : NormedSpace ℝ X
inst✝ : NormedSpace ℝ Y
f : X → Y
x : X
H : IsConformalMap (fderiv ℝ f x)
h : ¬DifferentiableAt ℝ f x
⊢ ConformalAt f x
|
nontriviality X
|
X : Type u_1
Y : Type u_2
inst✝³ : NormedAddCommGroup X
inst✝² : NormedAddCommGroup Y
inst✝¹ : NormedSpace ℝ X
inst✝ : NormedSpace ℝ Y
f : X → Y
x : X
H : IsConformalMap (fderiv ℝ f x)
h : ¬DifferentiableAt ℝ f x
a✝ : Nontrivial X
⊢ ConformalAt f x
|
7b61d25756689bca
|
Nat.nth_lt_of_lt_count
|
Mathlib/Data/Nat/Nth.lean
|
theorem nth_lt_of_lt_count {n k : ℕ} (h : k < count p n) : nth p k < n
|
p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ nth p k < n
|
refine (count_monotone p).reflect_lt ?_
|
p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ count p (nth p k) < count p n
|
136d9032986f9438
|
ProbabilityTheory.evariance_mul
|
Mathlib/Probability/Variance.lean
|
theorem evariance_mul (c : ℝ) (X : Ω → ℝ) (μ : Measure Ω) :
evariance (fun ω => c * X ω) μ = ENNReal.ofReal (c ^ 2) * evariance X μ
|
case e_f.h
Ω : Type u_1
mΩ : MeasurableSpace Ω
c : ℝ
X : Ω → ℝ
μ : Measure Ω
ω : Ω
⊢ ‖c * X ω - ∫ (x : Ω), c * X x ∂μ‖ₑ ^ 2 = ENNReal.ofReal (c ^ 2) * ‖X ω - ∫ (x : Ω), X x ∂μ‖ₑ ^ 2
|
rw [integral_mul_left, ← mul_sub, enorm_mul, mul_pow, ← enorm_pow,
Real.enorm_of_nonneg (sq_nonneg _)]
|
no goals
|
87d7e9ed9d5e8329
|
HurwitzZeta.cosKernel_neg
|
Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
|
@[simp]
lemma cosKernel_neg (a : UnitAddCircle) (x : ℝ) : cosKernel (-a) x = cosKernel a x
|
case H
x z✝ : ℝ
⊢ cosKernel (-↑z✝) x = cosKernel (↑z✝) x
|
simp [← QuotientAddGroup.mk_neg, ← ofReal_inj, cosKernel_def]
|
no goals
|
d86ba7455a7df237
|
Finset.affineCombinationLineMapWeights_apply_of_ne
|
Mathlib/LinearAlgebra/AffineSpace/Combination.lean
|
theorem affineCombinationLineMapWeights_apply_of_ne [DecidableEq ι] {i j t : ι} (hi : t ≠ i)
(hj : t ≠ j) (c : k) : affineCombinationLineMapWeights i j c t = 0
|
k : Type u_1
inst✝¹ : Ring k
ι : Type u_4
inst✝ : DecidableEq ι
i j t : ι
hi : t ≠ i
hj : t ≠ j
c : k
⊢ affineCombinationLineMapWeights i j c t = 0
|
simp [affineCombinationLineMapWeights, hi, hj]
|
no goals
|
4ae27d481b521f8c
|
Finset.subset_union_elim
|
Mathlib/Data/Finset/Basic.lean
|
theorem subset_union_elim {s : Finset α} {t₁ t₂ : Set α} (h : ↑s ⊆ t₁ ∪ t₂) :
∃ s₁ s₂ : Finset α, s₁ ∪ s₂ = s ∧ ↑s₁ ⊆ t₁ ∧ ↑s₂ ⊆ t₂ \ t₁
|
case refine_3
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
x : α
⊢ x ∈ ↑(filter (fun x => x ∉ t₁) s) → x ∈ t₂ \ t₁
|
simp only [not_not, coe_filter, Set.mem_setOf_eq, Set.mem_diff, and_imp]
|
case refine_3
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
t₁ t₂ : Set α
h : ↑s ⊆ t₁ ∪ t₂
x : α
⊢ x ∈ s → x ∉ t₁ → x ∈ t₂ ∧ x ∉ t₁
|
124422836b3c4eb9
|
MeasureTheory.lpMeasSubgroupToLpTrim_right_inv
|
Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
|
theorem lpMeasSubgroupToLpTrim_right_inv (hm : m ≤ m0) :
Function.RightInverse (lpTrimToLpMeasSubgroup F p μ hm) (lpMeasSubgroupToLpTrim F p μ hm)
|
α : Type u_1
F : Type u_2
p : ℝ≥0∞
inst✝ : NormedAddCommGroup F
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : ↥(Lp F p (μ.trim hm))
⊢ lpMeasSubgroupToLpTrim F p μ hm (lpTrimToLpMeasSubgroup F p μ hm f) = f
|
ext1
|
case h
α : Type u_1
F : Type u_2
p : ℝ≥0∞
inst✝ : NormedAddCommGroup F
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f : ↥(Lp F p (μ.trim hm))
⊢ ↑↑(lpMeasSubgroupToLpTrim F p μ hm (lpTrimToLpMeasSubgroup F p μ hm f)) =ᶠ[ae (μ.trim hm)] ↑↑f
|
1f4f24d97edaec61
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft.go_get_aux
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.lean
|
theorem go_get_aux (aig : AIG α) (distance : Nat) (input : AIG.RefVec aig w)
(curr : Nat) (hcurr : curr ≤ w) (s : AIG.RefVec aig curr) :
∀ (idx : Nat) (hidx : idx < curr),
(go input distance curr hcurr s).get idx (by omega)
=
s.get idx hidx
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
distance : Nat
input : aig.RefVec w
curr : Nat
hcurr : curr ≤ w
s : aig.RefVec curr
idx : Nat
hidx : idx < curr
h✝ : ¬curr < w
⊢ curr = w
|
omega
|
no goals
|
e1ea21e0c26513f1
|
IsDedekindDomain.HeightOneSpectrum.adicCompletion.mul_nonZeroDivisor_mem_adicCompletionIntegers
|
Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
|
lemma adicCompletion.mul_nonZeroDivisor_mem_adicCompletionIntegers (v : HeightOneSpectrum R)
(a : v.adicCompletion K) : ∃ b ∈ R⁰, a * b ∈ v.adicCompletionIntegers K
|
case neg.intro.intro
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
a : adicCompletion K v
d : ℤ
ha : 0 < d
hd : Valued.v a = ↑(ofAdd d)
ϖ : R
hϖ : v.intValuationDef ϖ = ↑(ofAdd (-1))
hϖ0 : ϖ ≠ 0
⊢ d + d * -1 ≤ 0
|
omega
|
no goals
|
8327a4d56ea55b92
|
Set.diff_iInter
|
Mathlib/Data/Set/Lattice.lean
|
theorem diff_iInter (s : Set β) (t : ι → Set β) : (s \ ⋂ i, t i) = ⋃ i, s \ t i
|
β : Type u_2
ι : Sort u_5
s : Set β
t : ι → Set β
⊢ s \ ⋂ i, t i = ⋃ i, s \ t i
|
rw [diff_eq, compl_iInter, inter_iUnion]
|
β : Type u_2
ι : Sort u_5
s : Set β
t : ι → Set β
⊢ ⋃ i, s ∩ (t i)ᶜ = ⋃ i, s \ t i
|
2a5c736d07abb686
|
List.getElem?_eraseIdx_of_lt
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Nat/Erase.lean
|
theorem getElem?_eraseIdx_of_lt (l : List α) (i : Nat) (j : Nat) (h : j < i) :
(l.eraseIdx i)[j]? = l[j]?
|
α : Type u_1
l : List α
i j : Nat
h : j < i
⊢ (l.eraseIdx i)[j]? = l[j]?
|
rw [getElem?_eraseIdx]
|
α : Type u_1
l : List α
i j : Nat
h : j < i
⊢ (if j < i then l[j]? else l[j + 1]?) = l[j]?
|
01167548286c9ee6
|
PNat.XgcdType.reduce_a
|
Mathlib/Data/PNat/Xgcd.lean
|
theorem reduce_a {u : XgcdType} (h : u.r = 0) : u.reduce = u.finish
|
u : XgcdType
h : u.r = 0
⊢ u.reduce = u.finish
|
rw [reduce]
|
u : XgcdType
h : u.r = 0
⊢ (if x : u.r = 0 then u.finish else u.step.reduce.flip) = u.finish
|
6004cbbfaf421ae5
|
BoxIntegral.norm_volume_sub_integral_face_upper_sub_lower_smul_le
|
Mathlib/Analysis/BoxIntegral/DivergenceTheorem.lean
|
theorem norm_volume_sub_integral_face_upper_sub_lower_smul_le {f : (Fin (n + 1) → ℝ) → E}
{f' : (Fin (n + 1) → ℝ) →L[ℝ] E} (hfc : ContinuousOn f (Box.Icc I)) {x : Fin (n + 1) → ℝ}
(hxI : x ∈ (Box.Icc I)) {a : E} {ε : ℝ} (h0 : 0 < ε)
(hε : ∀ y ∈ (Box.Icc I), ‖f y - a - f' (y - x)‖ ≤ ε * ‖y - x‖) {c : ℝ≥0}
(hc : I.distortion ≤ c) :
‖(∏ j, (I.upper j - I.lower j)) • f' (Pi.single i 1) -
(integral (I.face i) ⊥ (f ∘ i.insertNth (α := fun _ ↦ ℝ) (I.upper i)) BoxAdditiveMap.volume -
integral (I.face i) ⊥ (f ∘ i.insertNth (α := fun _ ↦ ℝ) (I.lower i))
BoxAdditiveMap.volume)‖ ≤
2 * ε * c * ∏ j, (I.upper j - I.lower j)
|
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
n : ℕ
inst✝ : CompleteSpace E
I : Box (Fin (n + 1))
i : Fin (n + 1)
f : (Fin (n + 1) → ℝ) → E
f' : (Fin (n + 1) → ℝ) →L[ℝ] E
hfc : ContinuousOn f (Box.Icc I)
x : Fin (n + 1) → ℝ
hxI : x ∈ Box.Icc I
a : E
ε : ℝ
h0 : 0 < ε
hε : ∀ y ∈ Box.Icc I, ‖f y - a - f' (y - x)‖ ≤ ε * ‖y - x‖
c : ℝ≥0
hc : I.distortion ≤ c
e : ℝ → (Fin n → ℝ) → Fin (n + 1) → ℝ := i.insertNth
Hl : I.lower i ∈ Set.Icc (I.lower i) (I.upper i)
Hu : I.upper i ∈ Set.Icc (I.lower i) (I.upper i)
Hi : ∀ x ∈ Set.Icc (I.lower i) (I.upper i), Integrable (I.face i) ⊥ (f ∘ e x) BoxAdditiveMap.volume
this :
∀ y ∈ Box.Icc (I.face i),
‖f' (Pi.single i (I.upper i - I.lower i)) - (f (e (I.upper i) y) - f (e (I.lower i) y))‖ ≤ 2 * ε * diam (Box.Icc I)
⊢ ‖integral (I.face i) ⊥
(fun x => f' (Pi.single i (I.upper i - I.lower i)) - (f (e (I.upper i) x) - f (e (I.lower i) x)))
BoxAdditiveMap.volume‖ ≤
(volume ↑(I.face i)).toReal * (2 * ε * ↑c * (I.upper i - I.lower i))
|
refine norm_integral_le_of_le_const (fun y hy => (this y hy).trans ?_) volume
|
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
n : ℕ
inst✝ : CompleteSpace E
I : Box (Fin (n + 1))
i : Fin (n + 1)
f : (Fin (n + 1) → ℝ) → E
f' : (Fin (n + 1) → ℝ) →L[ℝ] E
hfc : ContinuousOn f (Box.Icc I)
x : Fin (n + 1) → ℝ
hxI : x ∈ Box.Icc I
a : E
ε : ℝ
h0 : 0 < ε
hε : ∀ y ∈ Box.Icc I, ‖f y - a - f' (y - x)‖ ≤ ε * ‖y - x‖
c : ℝ≥0
hc : I.distortion ≤ c
e : ℝ → (Fin n → ℝ) → Fin (n + 1) → ℝ := i.insertNth
Hl : I.lower i ∈ Set.Icc (I.lower i) (I.upper i)
Hu : I.upper i ∈ Set.Icc (I.lower i) (I.upper i)
Hi : ∀ x ∈ Set.Icc (I.lower i) (I.upper i), Integrable (I.face i) ⊥ (f ∘ e x) BoxAdditiveMap.volume
this :
∀ y ∈ Box.Icc (I.face i),
‖f' (Pi.single i (I.upper i - I.lower i)) - (f (e (I.upper i) y) - f (e (I.lower i) y))‖ ≤ 2 * ε * diam (Box.Icc I)
y : Fin n → ℝ
hy : y ∈ Box.Icc (I.face i)
⊢ 2 * ε * diam (Box.Icc I) ≤ 2 * ε * ↑c * (I.upper i - I.lower i)
|
6dcd75375355bac1
|
Matrix.SpecialLinearGroup.SL2_inv_expl_det
|
Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
|
theorem SL2_inv_expl_det (A : SL(2, R)) :
det ![![A.1 1 1, -A.1 0 1], ![-A.1 1 0, A.1 0 0]] = 1
|
R : Type v
inst✝ : CommRing R
A : SL(2, R)
⊢ ↑A 0 0 * ↑A 1 1 - ↑A 0 1 * ↑A 1 0 = 1
|
have := A.2
|
R : Type v
inst✝ : CommRing R
A : SL(2, R)
this : (↑A).det = 1
⊢ ↑A 0 0 * ↑A 1 1 - ↑A 0 1 * ↑A 1 0 = 1
|
54dbb0fb2273aa1b
|
WeierstrassCurve.Projective.negY_of_Z_ne_zero
|
Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
|
lemma negY_of_Z_ne_zero {P : Fin 3 → F} (hPz : P z ≠ 0) :
W.negY P / P z = W.toAffine.negY (P x / P z) (P y / P z)
|
case a.a
F : Type u
inst✝ : Field F
W : Projective F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.negY P / P z + -W.a₃ * 1 - ((toAffine W).negY (P x / P z) (P y / P z) + -W.a₃ * (P z / P z)) = 0
|
rw [negY, Affine.negY]
|
case a.a
F : Type u
inst✝ : Field F
W : Projective F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ (-P y - W.a₁ * P x - W.a₃ * P z) / P z + -W.a₃ * 1 -
(-(P y / P z) - (toAffine W).a₁ * (P x / P z) - (toAffine W).a₃ + -W.a₃ * (P z / P z)) =
0
|
bbf88f4f5524fe5a
|
CategoryTheory.BinaryCofan.isPullback_initial_to_of_isVanKampen
|
Mathlib/CategoryTheory/Limits/VanKampen.lean
|
theorem BinaryCofan.isPullback_initial_to_of_isVanKampen [HasInitial C] {c : BinaryCofan X Y}
(h : IsVanKampenColimit c) : IsPullback (initial.to _) (initial.to _) c.inl c.inr
|
case refine_1
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ mapPair (initial.to X) (𝟙 Y) ≫ c.ι =
(BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map c.inr
|
ext ⟨⟨⟩⟩ <;> dsimp
|
case refine_1.w.h.mk.left
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ initial.to X ≫ c.inl = initial.to Y ≫ c.inr
|
1d49a7be83228de8
|
AddMonoidWithOne.ext
|
Mathlib/Algebra/Ring/Ext.lean
|
theorem AddMonoidWithOne.ext ⦃inst₁ inst₂ : AddMonoidWithOne R⦄
(h_add : local_hAdd[R, inst₁] = local_hAdd[R, inst₂])
(h_one : (letI := inst₁; One.one : R) = (letI := inst₂; One.one : R)) :
inst₁ = inst₂
|
case mk.mk.mk.mk
R : Type u
toAddMonoid✝¹ : AddMonoid R
toOne✝¹ : One R
natCast✝¹ : ℕ → R
natCast_zero✝¹ : NatCast.natCast 0 = 0
natCast_succ✝¹ : ∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1
toAddMonoid✝ : AddMonoid R
toOne✝ : One R
natCast✝ : ℕ → R
natCast_zero✝ : NatCast.natCast 0 = 0
natCast_succ✝ : ∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1
h_add : HAdd.hAdd = HAdd.hAdd
h_one : One.one = One.one
h_monoid : toAddMonoid = toAddMonoid
h_zero' : AddMonoid.toZero = AddMonoid.toZero
h_one' : toOne = toOne
h_natCast : NatCast.natCast = NatCast.natCast
⊢ mk natCast_zero✝¹ natCast_succ✝¹ = mk natCast_zero✝ natCast_succ✝
|
congr
|
no goals
|
8c33f554d55741a3
|
ENNReal.tendsto_atTop_zero_iff_lt_of_antitone
|
Mathlib/Topology/Instances/ENNReal/Lemmas.lean
|
theorem tendsto_atTop_zero_iff_lt_of_antitone {β : Type*} [Nonempty β] [SemilatticeSup β]
{f : β → ℝ≥0∞} (hf : Antitone f) :
Filter.Tendsto f Filter.atTop (𝓝 0) ↔ ∀ ε, 0 < ε → ∃ n : β, f n < ε
|
case neg
β : Type u_4
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → ℝ≥0∞
hf : Antitone f
h : ∀ (ε : ℝ≥0∞), 0 < ε → ∃ n, f n ≤ ε
ε : ℝ≥0∞
hε : 0 < ε
n : β
hn : f n ≤ 1 ⊓ ε / 2
hε_top : ¬ε = ⊤
⊢ 1 < 2
|
norm_num
|
no goals
|
8491377f7bac7c56
|
Algebra.TensorProduct.includeLeft_map_center_le
|
Mathlib/Algebra/Central/TensorProduct.lean
|
lemma Algebra.TensorProduct.includeLeft_map_center_le :
(Subalgebra.center K B).map includeLeft ≤ Subalgebra.center K (B ⊗[K] C)
|
case intro.intro.add
K : Type u_1
B : Type u_2
C : Type u_3
inst✝⁴ : CommSemiring K
inst✝³ : Semiring B
inst✝² : Semiring C
inst✝¹ : Algebra K B
inst✝ : Algebra K C
b : B
hb0 : ∀ (b_1 : B), b_1 * b = b * b_1
x✝ y✝ : B ⊗[K] C
a✝¹ : x✝ * includeLeft b = includeLeft b * x✝
a✝ : y✝ * includeLeft b = includeLeft b * y✝
⊢ (x✝ + y✝) * includeLeft b = includeLeft b * (x✝ + y✝)
|
simp_all [add_mul, mul_add]
|
no goals
|
b5e2e4a224adead8
|
SetTheory.PGame.Impartial.exists_right_move_equiv_iff_fuzzy_zero
|
Mathlib/SetTheory/Game/Impartial.lean
|
theorem exists_right_move_equiv_iff_fuzzy_zero : (∃ j, G.moveRight j ≈ 0) ↔ G ‖ 0
|
G : PGame
inst✝ : G.Impartial
hn : ∃ j, G.moveRight j ≤ 0
⊢ ∃ j, G.moveRight j ≈ 0
|
obtain ⟨i, hi⟩ := hn
|
case intro
G : PGame
inst✝ : G.Impartial
i : G.RightMoves
hi : G.moveRight i ≤ 0
⊢ ∃ j, G.moveRight j ≈ 0
|
dab6002e73196c9e
|
LieAlgebra.hasCentralRadical_and_of_isIrreducible_of_isFaithful
|
Mathlib/Algebra/Lie/Semisimple/Lemmas.lean
|
lemma hasCentralRadical_and_of_isIrreducible_of_isFaithful :
HasCentralRadical k L ∧ (∀ x, x ∈ center k L ↔ toEnd k L M x ∈ k ∙ LinearMap.id)
|
case intro
k : Type u_1
L : Type u_2
M : Type u_3
inst✝¹² : Field k
inst✝¹¹ : CharZero k
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra k L
inst✝⁸ : Module.Finite k L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module k M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule k L M
inst✝³ : Module.Finite k M
inst✝² : LieModule.IsIrreducible k L M
inst✝¹ : IsFaithful k L M
inst✝ : IsTriangularizable k L M
_i : Nontrivial M
χ : Dual k ↥(radical k L)
N : LieSubmodule k L M := weightSpaceOfIsLieTower k M ⇑χ
hχ : N = ⊤
⊢ HasCentralRadical k L ∧ ∀ (x : L), x ∈ center k L ↔ (toEnd k L M) x ∈ Submodule.span k {LinearMap.id}
|
replace hχ (x : L) (hx : x ∈ radical k L) : toEnd k _ M x = χ ⟨x, hx⟩ • LinearMap.id := by
ext m
have hm : ∀ (y : L) (hy : y ∈ radical k L), ⁅y, m⁆ = χ ⟨y, hy⟩ • m := by
simpa [N, weightSpaceOfIsLieTower, mem_weightSpace] using (hχ ▸ mem_top _ : m ∈ N)
simpa using hm x hx
|
case intro
k : Type u_1
L : Type u_2
M : Type u_3
inst✝¹² : Field k
inst✝¹¹ : CharZero k
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra k L
inst✝⁸ : Module.Finite k L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module k M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule k L M
inst✝³ : Module.Finite k M
inst✝² : LieModule.IsIrreducible k L M
inst✝¹ : IsFaithful k L M
inst✝ : IsTriangularizable k L M
_i : Nontrivial M
χ : Dual k ↥(radical k L)
N : LieSubmodule k L M := weightSpaceOfIsLieTower k M ⇑χ
hχ : ∀ (x : L) (hx : x ∈ radical k L), (toEnd k L M) x = χ ⟨x, hx⟩ • LinearMap.id
⊢ HasCentralRadical k L ∧ ∀ (x : L), x ∈ center k L ↔ (toEnd k L M) x ∈ Submodule.span k {LinearMap.id}
|
92e7bead74bccd0a
|
CategoryTheory.MorphismProperty.universally_le
|
Mathlib/CategoryTheory/MorphismProperty/Limits.lean
|
theorem universally_le (P : MorphismProperty C) : P.universally ≤ P
|
C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
X Y : C
f : X ⟶ Y
hf : P.universally f
⊢ f ≫ 𝟙 Y = 𝟙 X ≫ f
|
rw [Category.comp_id, Category.id_comp]
|
no goals
|
155ec1c81c975a26
|
EuclideanGeometry.angle_lt_pi_div_two_of_angle_eq_pi_div_two
|
Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
|
theorem angle_lt_pi_div_two_of_angle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = π / 2)
(h0 : p₃ ≠ p₂) : ∠ p₂ p₃ p₁ < π / 2
|
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ < π / 2
|
rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
inner_neg_left, neg_vsub_eq_vsub_rev] at h
|
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ < π / 2
|
eb5d456a193260b4
|
IsUpperSet.div_right
|
Mathlib/Algebra/Order/UpperLower.lean
|
theorem IsUpperSet.div_right (hs : IsUpperSet s) : IsUpperSet (s / t)
|
α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
hs : IsUpperSet s
⊢ IsUpperSet (s * t⁻¹)
|
exact hs.mul_right
|
no goals
|
7bc864668d916ff9
|
tendsto_div_of_monotone_of_tendsto_div_floor_pow
|
Mathlib/Analysis/SpecificLimits/FloorPow.lean
|
theorem tendsto_div_of_monotone_of_tendsto_div_floor_pow (u : ℕ → ℝ) (l : ℝ) (hmono : Monotone u)
(c : ℕ → ℝ) (cone : ∀ k, 1 < c k) (clim : Tendsto c atTop (𝓝 1))
(hc : ∀ k, Tendsto (fun n : ℕ => u ⌊c k ^ n⌋₊ / ⌊c k ^ n⌋₊) atTop (𝓝 l)) :
Tendsto (fun n => u n / n) atTop (𝓝 l)
|
u : ℕ → ℝ
l : ℝ
hmono : Monotone u
c : ℕ → ℝ
cone : ∀ (k : ℕ), 1 < c k
clim : Tendsto c atTop (𝓝 1)
hc : ∀ (k : ℕ), Tendsto (fun n => u ⌊c k ^ n⌋₊ / ↑⌊c k ^ n⌋₊) atTop (𝓝 l)
a : ℝ
ha : 1 < a
k : ℕ
hk : c k < a
n : ℕ
⊢ 1 ≤ ↑⌊c k ^ n⌋₊
|
simp only [Real.rpow_natCast, Nat.one_le_cast, Nat.one_le_floor_iff, one_le_pow₀ (cone k).le]
|
no goals
|
39b6908bafcd74f7
|
LinearIndependent.iSupIndep_span_singleton
|
Mathlib/LinearAlgebra/LinearIndependent/Lemmas.lean
|
theorem LinearIndependent.iSupIndep_span_singleton (hv : LinearIndependent R v) :
iSupIndep fun i => R ∙ v i
|
ι : Type u'
R : Type u_2
M : Type u_4
v : ι → M
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
hv : LinearIndependent R v
i : ι
m : M
hm : m ∈ span R {v i} ⊓ ⨆ j, ⨆ (_ : j ≠ i), span R {v j}
⊢ m ∈ ⊥
|
simp only [mem_inf, mem_span_singleton, iSup_subtype'] at hm
|
ι : Type u'
R : Type u_2
M : Type u_4
v : ι → M
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
hv : LinearIndependent R v
i : ι
m : M
hm : (∃ a, a • v i = m) ∧ m ∈ ⨆ x, span R {v ↑x}
⊢ m ∈ ⊥
|
15c8499de3d7ad45
|
ZMod.subsingleton_iff
|
Mathlib/Data/ZMod/Basic.lean
|
lemma subsingleton_iff {n : ℕ} : Subsingleton (ZMod n) ↔ n = 1
|
n : ℕ
⊢ Subsingleton (ZMod n) ↔ n = 1
|
constructor
|
case mp
n : ℕ
⊢ Subsingleton (ZMod n) → n = 1
case mpr
n : ℕ
⊢ n = 1 → Subsingleton (ZMod n)
|
3a46eadf39430283
|
IsAtom.le_iff
|
Mathlib/Order/Atoms.lean
|
theorem IsAtom.le_iff (h : IsAtom a) : x ≤ a ↔ x = ⊥ ∨ x = a
|
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : OrderBot α
a x : α
h : IsAtom a
⊢ x ≤ a ↔ x = ⊥ ∨ x = a
|
rw [le_iff_lt_or_eq, h.lt_iff]
|
no goals
|
56462cd397d981f8
|
IsOpen.exists_subset_affineIndependent_span_eq_top
|
Mathlib/Analysis/Normed/Affine/AddTorsorBases.lean
|
theorem IsOpen.exists_subset_affineIndependent_span_eq_top {u : Set P} (hu : IsOpen u)
(hne : u.Nonempty) : ∃ s ⊆ u, AffineIndependent ℝ ((↑) : s → P) ∧ affineSpan ℝ s = ⊤
|
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
u : Set P
hu : IsOpen u
hne : u.Nonempty
⊢ ∃ s ⊆ u, AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
|
rcases hne with ⟨x, hx⟩
|
case intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
u : Set P
hu : IsOpen u
x : P
hx : x ∈ u
⊢ ∃ s ⊆ u, AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤
|
5ed0ed984803d56e
|
Set.Icc_union_Icc'
|
Mathlib/Order/Interval/Set/Basic.lean
|
theorem Icc_union_Icc' (h₁ : c ≤ b) (h₂ : a ≤ d) : Icc a b ∪ Icc c d = Icc (min a c) (max b d)
|
case pos
α : Type u_1
inst✝ : LinearOrder α
a b c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c ≤ x
hd : x ≤ d
⊢ a ≤ x ∧ x ≤ b ∨ c ≤ x ∧ x ≤ d ↔ (a ≤ x ∨ c ≤ x) ∧ (x ≤ b ∨ x ≤ d)
|
simp only [hc, hd, and_self, or_true]
|
no goals
|
75dfe9f0a698fa98
|
BitVec.signExtend_eq_not_setWidth_not_of_msb_true
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem signExtend_eq_not_setWidth_not_of_msb_true {x : BitVec w} {v : Nat} (hmsb : x.msb = true) :
x.signExtend v = ~~~((~~~x).setWidth v)
|
case a.a
w : Nat
x : BitVec w
v : Nat
hmsb : x.msb = true
⊢ (2 ^ w - 1 - x.toNat) % 2 ^ v + 1 ≤ ?a.m✝
|
apply Nat.succ_le_of_lt
|
case a.a.h
w : Nat
x : BitVec w
v : Nat
hmsb : x.msb = true
⊢ (2 ^ w - 1 - x.toNat) % 2 ^ v < ?a.m✝
|
f7344d955b079af2
|
LocallyBoundedVariationOn.ae_differentiableAt
|
Mathlib/Analysis/BoundedVariation.lean
|
theorem ae_differentiableAt {f : ℝ → V} (h : LocallyBoundedVariationOn f univ) :
∀ᵐ x, DifferentiableAt ℝ f x
|
case h
V : Type u_3
inst✝² : NormedAddCommGroup V
inst✝¹ : NormedSpace ℝ V
inst✝ : FiniteDimensional ℝ V
f : ℝ → V
h : LocallyBoundedVariationOn f univ
x : ℝ
hx : x ∈ univ → DifferentiableWithinAt ℝ f univ x
⊢ DifferentiableAt ℝ f x
|
rw [differentiableWithinAt_univ] at hx
|
case h
V : Type u_3
inst✝² : NormedAddCommGroup V
inst✝¹ : NormedSpace ℝ V
inst✝ : FiniteDimensional ℝ V
f : ℝ → V
h : LocallyBoundedVariationOn f univ
x : ℝ
hx : x ∈ univ → DifferentiableAt ℝ f x
⊢ DifferentiableAt ℝ f x
|
33a41388c6885a3e
|
NumberField.InfinitePlace.card_complex_embeddings
|
Mathlib/NumberTheory/NumberField/Embeddings.lean
|
theorem card_complex_embeddings :
card { φ : K →+* ℂ // ¬ComplexEmbedding.IsReal φ } = 2 * nrComplexPlaces K
|
K : Type u_2
inst✝¹ : Field K
inst✝ : NumberField K
w : InfinitePlace K
hw : w.IsComplex
x✝ : { x // mkComplex x = ⟨w, hw⟩ }
φ : { φ // ¬ComplexEmbedding.IsReal φ }
hφ : mkComplex φ = ⟨w, hw⟩
⊢ mk ↑φ = w
|
rwa [Subtype.ext_iff] at hφ
|
no goals
|
20c4978209cddac1
|
Matroid.cRk_mono
|
Mathlib/Data/Matroid/Rank/Cardinal.lean
|
theorem cRk_mono (M : Matroid α) : Monotone M.cRk
|
α : Type u
M : Matroid α
⊢ ∀ ⦃a b : Set α⦄, a ⊆ b → ∀ ⦃I : Set α⦄, M.IsBasis' I a → #↑I ≤ M.cRk b
|
intro X Y hXY I hIX
|
α : Type u
M : Matroid α
X Y : Set α
hXY : X ⊆ Y
I : Set α
hIX : M.IsBasis' I X
⊢ #↑I ≤ M.cRk Y
|
e3dc976a5390a380
|
UniqueFactorizationMonoid.radical_eq_of_associated
|
Mathlib/RingTheory/Radical.lean
|
theorem radical_eq_of_associated {a b : M} (h : Associated a b) : radical a = radical b
|
M : Type u_1
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : NormalizationMonoid M
inst✝ : UniqueFactorizationMonoid M
a b : M
h : Associated a b
⊢ (primeFactors a).prod id = (primeFactors b).prod id
|
rw [h.primeFactors_eq]
|
no goals
|
2fbd16dae46948ca
|
Nat.Prime.factorization_pos_of_dvd
|
Mathlib/Data/Nat/Factorization/Defs.lean
|
theorem Prime.factorization_pos_of_dvd {n p : ℕ} (hp : p.Prime) (hn : n ≠ 0) (h : p ∣ n) :
0 < n.factorization p
|
n p : ℕ
hp : Prime p
hn : n ≠ 0
h : p ∣ n
⊢ 0 < n.factorization p
|
rwa [← primeFactorsList_count_eq, count_pos_iff, mem_primeFactorsList_iff_dvd hn hp]
|
no goals
|
ea65c5f724cd4b24
|
CochainComplex.mappingCone.inl_snd_assoc
|
Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
|
@[simp]
lemma inl_snd_assoc {K : CochainComplex C ℤ} {d e f : ℤ} (γ : Cochain G K d)
(he : 0 + d = e) (hf : -1 + e = f) :
(inl φ).comp ((snd φ).comp γ he) hf = 0
|
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
d e f : ℤ
γ : Cochain G K d
he : 0 + d = e
hf : -1 + e = f
⊢ (inl φ).comp ((snd φ).comp γ he) hf = 0
|
obtain rfl : e = d := by omega
|
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
e f : ℤ
hf : -1 + e = f
γ : Cochain G K e
he : 0 + e = e
⊢ (inl φ).comp ((snd φ).comp γ he) hf = 0
|
91c568454ffe6b85
|
Sbtw.dist_lt_max_dist
|
Mathlib/Analysis/Convex/StrictConvexBetween.lean
|
theorem Sbtw.dist_lt_max_dist (p : P) {p₁ p₂ p₃ : P} (h : Sbtw ℝ p₁ p₂ p₃) :
dist p₂ p < max (dist p₁ p) (dist p₃ p)
|
case intro.inr.inl.intro
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
hp₁p₃ : p₁ -ᵥ p ≠ p₃ -ᵥ p
h : p₂ = p₃
hp₂p₁ : p₂ ≠ p₁
hp₂p₃ : p₂ ≠ p₃
⊢ dist p₂ p < dist p₁ p ⊔ dist p₃ p
|
exact False.elim (hp₂p₃ h)
|
no goals
|
9aa41ffc37e88f54
|
Order.exists_series_of_le_height
|
Mathlib/Order/KrullDimension.lean
|
/-- There exist a series ending in a element for any length up to the element’s height. -/
lemma exists_series_of_le_height (a : α) {n : ℕ} (h : n ≤ height a) :
∃ p : LTSeries α, p.last = a ∧ p.length = n
|
case h.left
α : Type u_1
inst✝ : Preorder α
a : α
n : ℕ
hne : Nonempty { p // RelSeries.last p = a }
m : ℕ
h : n ≤ m
ha : ⨆ x, ↑(↑x).length = ↑m
p : LTSeries α
hlast : RelSeries.last p = a
hlen : p.length = m
⊢ (RelSeries.drop p ⟨m - n, ⋯⟩).last = a
|
simp [hlast]
|
no goals
|
0e15cb2199a1ee03
|
CochainComplex.HomComplex.Cochain.comp_smul
|
Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
|
@[simp]
protected lemma comp_smul {n₁ n₂ n₁₂ : ℤ} (z₁ : Cochain F G n₁) (k : R) (z₂ : Cochain G K n₂)
(h : n₁ + n₂ = n₁₂ ) : z₁.comp (k • z₂) h = k • (z₁.comp z₂ h)
|
case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K : CochainComplex C ℤ
n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
k : R
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ (z₁.comp (k • z₂) h).v p q hpq = (k • z₁.comp z₂ h).v p q hpq
|
simp only [comp_v _ _ h p _ q rfl (by omega), smul_v, Linear.comp_smul]
|
no goals
|
e74ac95f7982b3df
|
WeierstrassCurve.Jacobian.nonsingular_add
|
Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
|
lemma nonsingular_add {P Q : Fin 3 → F} (hP : W.Nonsingular P) (hQ : W.Nonsingular Q) :
W.Nonsingular <| W.add P Q
|
case pos
F : Type u
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Nonsingular P
hQ : W.Nonsingular Q
hPz : ¬P z = 0
hQz : Q z = 0
⊢ W.Nonsingular (W.add P Q)
|
simpa only [add_of_Z_eq_zero_right hQ.left hPz hQz,
nonsingular_smul _ ((isUnit_X_of_Z_eq_zero hQ hQz).mul <| Ne.isUnit hPz).neg]
|
no goals
|
756dd04fce6f14ae
|
UniqueFactorizationMonoid.dvd_of_mem_normalizedFactors
|
Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean
|
theorem dvd_of_mem_normalizedFactors {a p : α} (H : p ∈ normalizedFactors a) : p ∣ a
|
case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
H : p ∈ normalizedFactors a
hcases : ¬a = 0
⊢ p ∣ a
|
exact dvd_trans (Multiset.dvd_prod H) (Associated.dvd (prod_normalizedFactors hcases))
|
no goals
|
bc3d62cbe119c393
|
ax_grothendieck_of_definable
|
Mathlib/FieldTheory/AxGrothendieck.lean
|
theorem ax_grothendieck_of_definable [CompatibleRing K] {c : Set K}
(S : Set (ι → K)) (hS : c.Definable Language.ring S)
(ps : ι → MvPolynomial ι K) :
S.MapsTo (fun v i => eval v (ps i)) S →
S.InjOn (fun v i => eval v (ps i)) →
S.SurjOn (fun v i => eval v (ps i)) S
|
K : Type u_1
ι : Type u_2
inst✝³ : Field K
inst✝² : IsAlgClosed K
inst✝¹ : Finite ι
inst✝ : CompatibleRing K
c : Set K
S : Set (ι → K)
hS : c.Definable ring S
ps : ι → MvPolynomial ι K
this : Fintype ι := Fintype.ofFinite ι
⊢ Set.MapsTo (fun v i => (eval v) (ps i)) S S →
Set.InjOn (fun v i => (eval v) (ps i)) S → Set.SurjOn (fun v i => (eval v) (ps i)) S S
|
let p : ℕ := ringChar K
|
K : Type u_1
ι : Type u_2
inst✝³ : Field K
inst✝² : IsAlgClosed K
inst✝¹ : Finite ι
inst✝ : CompatibleRing K
c : Set K
S : Set (ι → K)
hS : c.Definable ring S
ps : ι → MvPolynomial ι K
this : Fintype ι := Fintype.ofFinite ι
p : ℕ := ringChar K
⊢ Set.MapsTo (fun v i => (eval v) (ps i)) S S →
Set.InjOn (fun v i => (eval v) (ps i)) S → Set.SurjOn (fun v i => (eval v) (ps i)) S S
|
933d6add8d5d058a
|
Surreal.Multiplication.ih1_neg_left
|
Mathlib/SetTheory/Surreal/Multiplication.lean
|
lemma ih1_neg_left : IH1 x y → IH1 (-x) y :=
fun h x₁ x₂ y' h₁ h₂ hy ↦ by
rw [isOption_neg] at h₁ h₂
exact P24_neg_left.2 (h h₂ h₁ hy)
|
x y : PGame
h : IH1 x y
x₁ x₂ y' : PGame
h₁ : (-x₁).IsOption x
h₂ : (-x₂).IsOption x
hy : y' = y ∨ y'.IsOption y
⊢ P24 x₁ x₂ y'
|
exact P24_neg_left.2 (h h₂ h₁ hy)
|
no goals
|
cae1455068d0158a
|
AffineBasis.exists_affineBasis_of_finiteDimensional
|
Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
|
theorem exists_affineBasis_of_finiteDimensional [Fintype ι] [FiniteDimensional k V]
(h : Fintype.card ι = Module.finrank k V + 1) : Nonempty (AffineBasis ι k P)
|
case intro.intro
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = Module.finrank k V + 1
s : Set P
b : AffineBasis (↑s) k P
hb : ⇑b = Subtype.val
⊢ Nonempty (AffineBasis ι k P)
|
lift s to Finset P using b.finite_set
|
case intro.intro.intro
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = Module.finrank k V + 1
s : Finset P
b : AffineBasis (↑↑s) k P
hb : ⇑b = Subtype.val
⊢ Nonempty (AffineBasis ι k P)
|
e510723a41bc6600
|
CategoryTheory.finrank_hom_simple_simple_eq_zero_iff
|
Mathlib/CategoryTheory/Preadditive/Schur.lean
|
theorem finrank_hom_simple_simple_eq_zero_iff (X Y : C) [FiniteDimensional 𝕜 (X ⟶ X)]
[FiniteDimensional 𝕜 (X ⟶ Y)] [Simple X] [Simple Y] :
finrank 𝕜 (X ⟶ Y) = 0 ↔ IsEmpty (X ≅ Y)
|
C : Type u_1
inst✝⁹ : Category.{u_3, u_1} C
inst✝⁸ : Preadditive C
𝕜 : Type u_2
inst✝⁷ : Field 𝕜
inst✝⁶ : IsAlgClosed 𝕜
inst✝⁵ : Linear 𝕜 C
inst✝⁴ : HasKernels C
X Y : C
inst✝³ : FiniteDimensional 𝕜 (X ⟶ X)
inst✝² : FiniteDimensional 𝕜 (X ⟶ Y)
inst✝¹ : Simple X
inst✝ : Simple Y
this : finrank 𝕜 (X ⟶ Y) ≤ 1
⊢ finrank 𝕜 (X ⟶ Y) = 0 ↔ ¬finrank 𝕜 (X ⟶ Y) = 1
|
omega
|
no goals
|
36d01ca65cae1c3e
|
geom_sum_ne_zero
|
Mathlib/Algebra/GeomSum.lean
|
theorem geom_sum_ne_zero [LinearOrderedRing α] (hx : x ≠ -1) (hn : n ≠ 0) :
∑ i ∈ range n, x ^ i ≠ 0
|
case succ.succ
α : Type u
x : α
inst✝ : LinearOrderedRing α
hx : x ≠ -1
n : ℕ
hn : n + 1 + 1 ≠ 0
⊢ ∑ i ∈ range (n + 1 + 1), x ^ i ≠ 0
|
rw [Ne, eq_neg_iff_add_eq_zero, ← Ne] at hx
|
case succ.succ
α : Type u
x : α
inst✝ : LinearOrderedRing α
hx : x + 1 ≠ 0
n : ℕ
hn : n + 1 + 1 ≠ 0
⊢ ∑ i ∈ range (n + 1 + 1), x ^ i ≠ 0
|
276116b8a692415e
|
Batteries.UnionFind.setParentBump_rankD_lt
|
Mathlib/.lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean
|
theorem setParentBump_rankD_lt {arr : Array UFNode} {x y : Fin arr.size}
(hroot : arr[x.1].rank < arr[y.1].rank ∨ arr[y.1].parent = y)
(H : arr[x.1].rank ≤ arr[y.1].rank) {i : Nat}
(rankD_lt : parentD arr i ≠ i → rankD arr i < rankD arr (parentD arr i))
(hP : parentD arr' i = if x.1 = i then y.1 else parentD arr i)
(hR : ∀ {i}, rankD arr' i =
if y.1 = i ∧ arr[x.1].rank = arr[y.1].rank then
arr[y.1].rank + 1
else rankD arr i) :
¬parentD arr' i = i → rankD arr' i < rankD arr' (parentD arr' i)
|
case isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : arr[↑x].rank < arr[↑y].rank ∨ arr[↑y].parent = ↑y
H : arr[↑x].rank ≤ arr[↑y].rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
⊢ rankD arr i < if ↑y = parentD arr i ∧ arr[↑x].rank = arr[↑y].rank then arr[↑y].rank + 1 else rankD arr (parentD arr i)
|
split <;> rename_i h₃
|
case isFalse.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : arr[↑x].rank < arr[↑y].rank ∨ arr[↑y].parent = ↑y
H : arr[↑x].rank ≤ arr[↑y].rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ arr[↑x].rank = arr[↑y].rank
⊢ rankD arr i < arr[↑y].rank + 1
case isFalse.isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : arr[↑x].rank < arr[↑y].rank ∨ arr[↑y].parent = ↑y
H : arr[↑x].rank ≤ arr[↑y].rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ¬(↑y = parentD arr i ∧ arr[↑x].rank = arr[↑y].rank)
⊢ rankD arr i < rankD arr (parentD arr i)
|
9fe4c92bd6627be1
|
UV.le_of_mem_compression_of_not_mem
|
Mathlib/Combinatorics/SetFamily/Compression/UV.lean
|
theorem le_of_mem_compression_of_not_mem (h : a ∈ 𝓒 u v s) (ha : a ∉ s) : u ≤ a
|
case neg
α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x1 x2 => x1 ≤ x2
s : Finset α
u v a : α
inst✝ : DecidableEq α
ha : a ∉ s
b : α
hb : b ∈ s
h : ¬(Disjoint u b ∧ v ≤ b)
hba : b = a
⊢ u ≤ a
|
cases ne_of_mem_of_not_mem hb ha hba
|
no goals
|
2a4bf00f4796d46c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.