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
|
|---|---|---|---|---|---|---|
FractionalIdeal.count_well_defined
|
Mathlib/RingTheory/DedekindDomain/Factorization.lean
|
theorem count_well_defined {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R}
{J : Ideal R} (h_aJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) :
count K v I = ((Associates.mk v.asIdeal).count (Associates.mk J).factors -
(Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {a})).factors : ℤ)
|
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
hI : I ≠ 0
a : R
J : Ideal R
h_aJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J
a₁ : R := choose ⋯
J₁ : Ideal R := choose ⋯
h_a₁J₁ : I = spanSingleton R⁰ ((algebraMap R K) a₁)⁻¹ * ↑J₁
h_a₁_ne_zero : a₁ ≠ 0
h_J₁_ne_zero : J₁ ≠ 0
h_a_ne_zero : Ideal.span {a} ≠ 0
h_J_ne_zero : J ≠ 0
h_a₁' : spanSingleton R⁰ ((algebraMap R K) a₁) ≠ 0
⊢ spanSingleton R⁰ ((algebraMap R K) a) ≠ 0
|
rw [ne_eq, spanSingleton_eq_zero_iff, ← (algebraMap R K).map_zero,
Injective.eq_iff (IsLocalization.injective K (le_refl R⁰))]
|
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
hI : I ≠ 0
a : R
J : Ideal R
h_aJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J
a₁ : R := choose ⋯
J₁ : Ideal R := choose ⋯
h_a₁J₁ : I = spanSingleton R⁰ ((algebraMap R K) a₁)⁻¹ * ↑J₁
h_a₁_ne_zero : a₁ ≠ 0
h_J₁_ne_zero : J₁ ≠ 0
h_a_ne_zero : Ideal.span {a} ≠ 0
h_J_ne_zero : J ≠ 0
h_a₁' : spanSingleton R⁰ ((algebraMap R K) a₁) ≠ 0
⊢ ¬a = 0
|
59f81f9cebadacb0
|
ProbabilityTheory.hasFiniteIntegral_compProd_iff
|
Mathlib/Probability/Kernel/Composition/IntegralCompProd.lean
|
theorem hasFiniteIntegral_compProd_iff ⦃f : β × γ → E⦄ (h1f : StronglyMeasurable f) :
HasFiniteIntegral f ((κ ⊗ₖ η) a) ↔
(∀ᵐ x ∂κ a, HasFiniteIntegral (fun y => f (x, y)) (η (a, x))) ∧
HasFiniteIntegral (fun x => ∫ y, ‖f (x, y)‖ ∂η (a, x)) (κ a)
|
α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
a : α
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
f : β × γ → E
h1f : StronglyMeasurable f
⊢ ∫⁻ (b : β), ∫⁻ (c : γ), ‖f (b, c)‖ₑ ∂η (a, b) ∂κ a < ⊤ ↔
(∀ᵐ (x : β) ∂κ a, ∫⁻ (a : γ), ‖f (x, a)‖ₑ ∂η (a, x) < ⊤) ∧
∫⁻ (a_1 : β), ‖∫ (y : γ), ‖f (a_1, y)‖ ∂η (a, a_1)‖ₑ ∂κ a < ⊤
|
have : ∀ x, ∀ᵐ y ∂η (a, x), 0 ≤ ‖f (x, y)‖ := fun x => Eventually.of_forall fun y => norm_nonneg _
|
α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
a : α
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
f : β × γ → E
h1f : StronglyMeasurable f
this : ∀ (x : β), ∀ᵐ (y : γ) ∂η (a, x), 0 ≤ ‖f (x, y)‖
⊢ ∫⁻ (b : β), ∫⁻ (c : γ), ‖f (b, c)‖ₑ ∂η (a, b) ∂κ a < ⊤ ↔
(∀ᵐ (x : β) ∂κ a, ∫⁻ (a : γ), ‖f (x, a)‖ₑ ∂η (a, x) < ⊤) ∧
∫⁻ (a_1 : β), ‖∫ (y : γ), ‖f (a_1, y)‖ ∂η (a, a_1)‖ₑ ∂κ a < ⊤
|
09df794e8ec71c81
|
Polynomial.dickson_one_one_zmod_p
|
Mathlib/RingTheory/Polynomial/Dickson.lean
|
theorem dickson_one_one_zmod_p (p : ℕ) [Fact p.Prime] : dickson 1 (1 : ZMod p) p = X ^ p
|
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ ∃ K x, ∃ (_ : CharP K p), Infinite K
|
let K := FractionRing (Polynomial (ZMod p))
|
p : ℕ
inst✝ : Fact (Nat.Prime p)
K : Type := FractionRing (ZMod p)[X]
⊢ ∃ K x, ∃ (_ : CharP K p), Infinite K
|
84ee1673e653698a
|
contDiffGroupoid_le
|
Mathlib/Geometry/Manifold/IsManifold/Basic.lean
|
theorem contDiffGroupoid_le (h : m ≤ n) : contDiffGroupoid n I ≤ contDiffGroupoid m I
|
m n : WithTop ℕ∞
𝕜 : 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
h : m ≤ n
⊢ (contDiffPregroupoid n I).groupoid ≤ (contDiffPregroupoid m I).groupoid
|
apply groupoid_of_pregroupoid_le
|
case h
m n : WithTop ℕ∞
𝕜 : 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
h : m ≤ n
⊢ ∀ (f : H → H) (s : Set H), (contDiffPregroupoid n I).property f s → (contDiffPregroupoid m I).property f s
|
8c73166a142ed72c
|
AkraBazziRecurrence.base_nonempty
|
Mathlib/Computability/AkraBazzi/AkraBazzi.lean
|
lemma base_nonempty {n : ℕ} (hn : 0 < n) : (Finset.Ico (⌊b (min_bi b) / 2 * n⌋₊) n).Nonempty
|
α : Type u_1
inst✝¹ : Fintype α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
inst✝ : Nonempty α
R : AkraBazziRecurrence T g a b r
n : ℕ
hn : 0 < n
b' : ℝ := b (min_bi b)
hb_pos : 0 < b'
⊢ ↑⌊b' / 2 * ↑n⌋₊ ≤ b' / 2 * ↑n
|
exact Nat.floor_le (by positivity)
|
no goals
|
7e3cff39f102cb90
|
GaloisField.finrank
|
Mathlib/FieldTheory/Finite/GaloisField.lean
|
theorem finrank {n} (h : n ≠ 0) : Module.finrank (ZMod p) (GaloisField p n) = n
|
case succ.refine_5
n : ℕ
h : n ≠ 0
n✝ : ℕ
h_prime : Fact (Nat.Prime (n✝ + 1))
this : Fintype (GaloisField (n✝ + 1) n)
g_poly : (ZMod (n✝ + 1))[X] := X ^ (n✝ + 1) ^ n - X
hp : 1 < n✝ + 1
aux : X ^ (n✝ + 1) ^ n - X ≠ 0
key : Fintype.card ↑(g_poly.rootSet (GaloisField (n✝ + 1) n)) = (n✝ + 1) ^ n
nat_degree_eq : g_poly.natDegree = (n✝ + 1) ^ n
x✝ : GaloisField (n✝ + 1) n
hx✝¹ :
x✝ ∈
Subring.closure
(Set.range ⇑(algebraMap (ZMod (n✝ + 1)) (GaloisField (n✝ + 1) n)) ∪
(X ^ (n✝ + 1) ^ n - X).rootSet (X ^ (n✝ + 1) ^ n - X).SplittingField)
x : GaloisField (n✝ + 1) n
hx✝ :
x ∈
Subring.closure
(Set.range ⇑(algebraMap (ZMod (n✝ + 1)) (GaloisField (n✝ + 1) n)) ∪
(X ^ (n✝ + 1) ^ n - X).rootSet (X ^ (n✝ + 1) ^ n - X).SplittingField)
hx : (aeval x) (X ^ (n✝ + 1) ^ n - X) = 0
⊢ (aeval (-x)) (X ^ (n✝ + 1) ^ n - X) = 0
|
simp only [g_poly, sub_eq_zero, aeval_X_pow, aeval_X, map_sub, sub_neg_eq_add] at *
|
case succ.refine_5
n : ℕ
h : n ≠ 0
n✝ : ℕ
h_prime : Fact (Nat.Prime (n✝ + 1))
this : Fintype (GaloisField (n✝ + 1) n)
g_poly : (ZMod (n✝ + 1))[X] := X ^ (n✝ + 1) ^ n - X
hp : 1 < n✝ + 1
aux : X ^ (n✝ + 1) ^ n - X ≠ 0
key : Fintype.card ↑((X ^ (n✝ + 1) ^ n - X).rootSet (GaloisField (n✝ + 1) n)) = (n✝ + 1) ^ n
nat_degree_eq : (X ^ (n✝ + 1) ^ n - X).natDegree = (n✝ + 1) ^ n
x✝ : GaloisField (n✝ + 1) n
hx✝¹ :
x✝ ∈
Subring.closure
(Set.range ⇑(algebraMap (ZMod (n✝ + 1)) (GaloisField (n✝ + 1) n)) ∪
(X ^ (n✝ + 1) ^ n - X).rootSet (X ^ (n✝ + 1) ^ n - X).SplittingField)
x : GaloisField (n✝ + 1) n
hx✝ :
x ∈
Subring.closure
(Set.range ⇑(algebraMap (ZMod (n✝ + 1)) (GaloisField (n✝ + 1) n)) ∪
(X ^ (n✝ + 1) ^ n - X).rootSet (X ^ (n✝ + 1) ^ n - X).SplittingField)
hx : x ^ (n✝ + 1) ^ n = x
⊢ (-x) ^ (n✝ + 1) ^ n + x = 0
|
111b60fe849d791c
|
mul_zpow_neg_one
|
Mathlib/Algebra/Group/Basic.lean
|
@[to_additive neg_one_zsmul_add]
lemma mul_zpow_neg_one (a b : α) : (a * b) ^ (-1 : ℤ) = b ^ (-1 : ℤ) * a ^ (-1 : ℤ)
|
α : Type u_1
inst✝ : DivisionMonoid α
a b : α
⊢ (a * b) ^ (-1) = b ^ (-1) * a ^ (-1)
|
simp only [zpow_neg, zpow_one, mul_inv_rev]
|
no goals
|
0ee58090f0f23253
|
Nat.cast_div
|
Mathlib/Data/Nat/Cast/Field.lean
|
@[simp]
lemma cast_div (hnm : n ∣ m) (hn : (n : K) ≠ 0) : (↑(m / n) : K) = m / n
|
case intro
K : Type u_1
inst✝ : DivisionSemiring K
n : ℕ
hn : ↑n ≠ 0
k : ℕ
this : n ≠ 0
⊢ ↑(n * k / n) = ↑(n * k) / ↑n
|
rw [Nat.mul_div_cancel_left _ <| zero_lt_of_ne_zero this, mul_comm n,
cast_mul, mul_div_cancel_right₀ _ hn]
|
no goals
|
48215f7c253f50b8
|
UniformOnFun.nhds_eq_of_basis
|
Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
|
theorem nhds_eq_of_basis {ι : Sort*} {p : ι → Prop} {V : ι → Set (β × β)}
(h : (𝓤 β).HasBasis p V) (f : α →ᵤ[𝔖] β) :
𝓝 f = ⨅ s ∈ 𝔖, ⨅ (i) (_ : p i), 𝓟 {g | ∀ x ∈ s, (toFun 𝔖 f x, toFun 𝔖 g x) ∈ V i}
|
α : Type u_1
β : Type u_2
inst✝ : UniformSpace β
𝔖 : Set (Set α)
ι : Sort u_5
p : ι → Prop
V : ι → Set (β × β)
h : (𝓤 β).HasBasis p V
f : α →ᵤ[𝔖] β
⊢ 𝓝 f = ⨅ s ∈ 𝔖, ⨅ i, ⨅ (_ : p i), 𝓟 {g | ∀ x ∈ s, ((toFun 𝔖) f x, (toFun 𝔖) g x) ∈ V i}
|
simp_rw [nhds_eq_comap_uniformity, UniformOnFun.uniformity_eq_of_basis _ _ h, comap_iInf,
comap_principal, UniformOnFun.gen, preimage_setOf_eq]
|
no goals
|
b5b0addf48c7957c
|
MeasureTheory.hausdorffMeasure_pi_real
|
Mathlib/MeasureTheory/Measure/Hausdorff.lean
|
theorem hausdorffMeasure_pi_real {ι : Type*} [Fintype ι] :
(μH[Fintype.card ι] : Measure (ι → ℝ)) = volume
|
ι : Type u_4
inst✝ : Fintype ι
a b : ι → ℚ
H : ∀ (i : ι), a i < b i
i : ι
⊢ 0 ≤ ↑(b i) - ↑(a i)
|
simpa only [sub_nonneg, Rat.cast_le] using (H i).le
|
no goals
|
90212ad5e070d6f0
|
tendsto_div_of_monotone_of_exists_subseq_tendsto_div
|
Mathlib/Analysis/SpecificLimits/FloorPow.lean
|
theorem tendsto_div_of_monotone_of_exists_subseq_tendsto_div (u : ℕ → ℝ) (l : ℝ)
(hmono : Monotone u)
(hlim : ∀ a : ℝ, 1 < a → ∃ c : ℕ → ℕ, (∀ᶠ n in atTop, (c (n + 1) : ℝ) ≤ a * c n) ∧
Tendsto c atTop atTop ∧ Tendsto (fun n => u (c n) / c n) atTop (𝓝 l)) :
Tendsto (fun n => u n / n) atTop (𝓝 l)
|
u : ℕ → ℝ
l : ℝ
hmono : Monotone u
hlim :
∀ (a : ℝ),
1 < a →
∃ c,
(∀ᶠ (n : ℕ) in atTop, ↑(c (n + 1)) ≤ a * ↑(c n)) ∧
Tendsto c atTop atTop ∧ Tendsto (fun n => u (c n) / ↑(c n)) atTop (𝓝 l)
lnonneg : 0 ≤ l
A : ∀ (ε : ℝ), 0 < ε → ∀ᶠ (n : ℕ) in atTop, u n - ↑n * l ≤ ε * (1 + ε + l) * ↑n
ε : ℝ
εpos : 0 < ε
c : ℕ → ℕ
cgrowth : ∀ᶠ (n : ℕ) in atTop, ↑(c (n + 1)) ≤ (1 + ε) * ↑(c n)
ctop : Tendsto c atTop atTop
clim : Tendsto (fun n => u (c n) / ↑(c n)) atTop (𝓝 l)
L : ∀ᶠ (n : ℕ) in atTop, ↑(c n) * l - u (c n) ≤ ε * ↑(c n)
a : ℕ
ha : ∀ (b : ℕ), a ≤ b → ↑(c (b + 1)) ≤ (1 + ε) * ↑(c b) ∧ ↑(c b) * l - u (c b) ≤ ε * ↑(c b)
M : ℕ := (image (fun i => c i) (range (a + 1))).max' ⋯
n : ℕ
hn : n ∈ Set.Ici M
exN : ∃ N, n < c N
N : ℕ := Nat.find exN
ncN : n < c N
aN : a + 1 ≤ N
Npos : 0 < N
aN' : a ≤ N - 1
cNn : c (N - 1) ≤ n
⊢ (1 + ε) * ↑(c (N - 1)) * l - u (c (N - 1)) = ↑(c (N - 1)) * l - u (c (N - 1)) + ε * ↑(c (N - 1)) * l
|
ring
|
no goals
|
2aab76659c6dcba8
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.sat_of_insertRat
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.lean
|
theorem sat_of_insertRat {n : Nat} (f : DefaultFormula n)
(hf : f.ratUnits = #[] ∧ AssignmentsInvariant f) (c : DefaultClause n) (p : PosFin n → Bool)
(pf : p ⊨ f) :
(insertRatUnits f (negate c)).2 = true → p ⊨ c
|
n : Nat
f : DefaultFormula n
hf : f.ratUnits = #[] ∧ f.AssignmentsInvariant
c : DefaultClause n
p : PosFin n → Bool
pf : p ⊨ f
insertUnit_fold_success : (List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).2.snd = true
i : PosFin n
hboth : (List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).snd.fst[i.val] = both
i_in_bounds : i.val < f.assignments.size
h0 : InsertUnitInvariant f.assignments ⋯ f.ratUnits f.assignments ⋯
insertUnit_fold_satisfies_invariant :
let update_res := List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate;
let_fun update_res_size := ⋯;
InsertUnitInvariant f.assignments ⋯ update_res.fst update_res.snd.fst update_res_size
j : Fin (List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).fst.size
b : Bool
i_gt_zero : ↑⟨i.val, ⋯⟩ > 0
h1 : (List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).fst[j] = (⟨↑⟨i.val, ⋯⟩, ⋯⟩, b)
h2 :
(List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).snd.fst[↑⟨i.val, ⋯⟩] =
addAssignment b f.assignments[↑⟨i.val, ⋯⟩]
h3 : ¬hasAssignment b f.assignments[↑⟨i.val, ⋯⟩] = true
h4 :
∀ (k : Fin (List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).fst.size),
k ≠ j → (List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).fst[k].fst.val ≠ ↑⟨i.val, ⋯⟩
i_rw : i = ⟨i.val, ⋯⟩
⊢ (List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).fst[j] ∈
(List.foldl insertUnit (f.ratUnits, f.assignments, false) c.negate).fst.toList
|
apply List.get_mem
|
no goals
|
c0b439908684a182
|
VitaliFamily.ae_tendsto_lintegral_enorm_sub_div'_of_integrable
|
Mathlib/MeasureTheory/Covering/Differentiation.lean
|
theorem ae_tendsto_lintegral_enorm_sub_div'_of_integrable {f : α → E} (hf : Integrable f μ)
(h'f : StronglyMeasurable f) :
∀ᵐ x ∂μ, Tendsto (fun a => (∫⁻ y in a, ‖f y - f x‖ₑ ∂μ) / μ a) (v.filterAt x) (𝓝 0)
|
case intro
α : Type u_1
inst✝⁴ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
f : α → E
hf : Integrable f μ
h'f : StronglyMeasurable f
A : μ.FiniteSpanningSetsIn {K | IsOpen K} := μ.finiteSpanningSetsInOpen'
t : Set E
t_count : t.Countable
ht : range f ⊆ closure t
main :
∀ᵐ (x : α) ∂μ,
∀ (n : ℕ),
∀ c ∈ t,
Tendsto (fun a => (∫⁻ (y : α) in a, ‖f y - (A.set n).indicator (fun x => c) y‖ₑ ∂μ) / μ a) (v.filterAt x)
(𝓝 ‖f x - (A.set n).indicator (fun x => c) x‖ₑ)
x : α
h'x : ∀ᶠ (a : Set α) in v.filterAt x, 0 < μ a
c : E
hc : c ∈ t
n : ℕ
xn : x ∈ A.set n
hx :
Tendsto (fun a => (∫⁻ (y : α) in a, ‖f y - (A.set n).indicator (fun x => c) y‖ₑ ∂μ) / μ a) (v.filterAt x)
(𝓝 ‖f x - (A.set n).indicator (fun x => c) x‖ₑ)
⊢ Tendsto (fun a => (∫⁻ (y : α) in a, ‖f y - c‖ₑ ∂μ) / μ a) (v.filterAt x) (𝓝 ‖f x - c‖ₑ)
|
simp only [xn, indicator_of_mem] at hx
|
case intro
α : Type u_1
inst✝⁴ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
f : α → E
hf : Integrable f μ
h'f : StronglyMeasurable f
A : μ.FiniteSpanningSetsIn {K | IsOpen K} := μ.finiteSpanningSetsInOpen'
t : Set E
t_count : t.Countable
ht : range f ⊆ closure t
main :
∀ᵐ (x : α) ∂μ,
∀ (n : ℕ),
∀ c ∈ t,
Tendsto (fun a => (∫⁻ (y : α) in a, ‖f y - (A.set n).indicator (fun x => c) y‖ₑ ∂μ) / μ a) (v.filterAt x)
(𝓝 ‖f x - (A.set n).indicator (fun x => c) x‖ₑ)
x : α
h'x : ∀ᶠ (a : Set α) in v.filterAt x, 0 < μ a
c : E
hc : c ∈ t
n : ℕ
xn : x ∈ A.set n
hx :
Tendsto (fun a => (∫⁻ (y : α) in a, ‖f y - (A.set n).indicator (fun x => c) y‖ₑ ∂μ) / μ a) (v.filterAt x)
(𝓝 ‖f x - c‖ₑ)
⊢ Tendsto (fun a => (∫⁻ (y : α) in a, ‖f y - c‖ₑ ∂μ) / μ a) (v.filterAt x) (𝓝 ‖f x - c‖ₑ)
|
38b9ca590c2fbd74
|
centralBinom_factorization_small
|
Mathlib/NumberTheory/Bertrand.lean
|
theorem centralBinom_factorization_small (n : ℕ) (n_large : 2 < n)
(no_prime : ¬∃ p : ℕ, p.Prime ∧ n < p ∧ p ≤ 2 * n) :
centralBinom n = ∏ p ∈ Finset.range (2 * n / 3 + 1), p ^ (centralBinom n).factorization p
|
case h
n : ℕ
n_large : 2 < n
no_prime : ¬∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n
⊢ Finset.range (2 * n / 3 + 1) ⊆ Finset.range (2 * n + 1)
|
exact Finset.range_subset.2 (add_le_add_right (Nat.div_le_self _ _) _)
|
no goals
|
98816716a310ec27
|
Nat.clog_mono_right
|
Mathlib/Data/Nat/Log.lean
|
theorem clog_mono_right (b : ℕ) {n m : ℕ} (h : n ≤ m) : clog b n ≤ clog b m
|
b n m : ℕ
h : n ≤ m
⊢ clog b n ≤ clog b m
|
rcases le_or_lt b 1 with hb | hb
|
case inl
b n m : ℕ
h : n ≤ m
hb : b ≤ 1
⊢ clog b n ≤ clog b m
case inr
b n m : ℕ
h : n ≤ m
hb : 1 < b
⊢ clog b n ≤ clog b m
|
0d30e1a0e662f4b9
|
ContinuousLinearMap.isUnit_of_forall_le_norm_inner_map
|
Mathlib/Analysis/InnerProductSpace/Positive.lean
|
lemma isUnit_of_forall_le_norm_inner_map (f : E →L[𝕜] E) {c : ℝ≥0} (hc : 0 < c)
(h : ∀ x, ‖x‖ ^ 2 * c ≤ ‖⟪f x, x⟫_𝕜‖) : IsUnit f
|
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
f : E →L[𝕜] E
c : ℝ≥0
hc : 0 < c
h : ∀ (x : E), ‖x‖ ^ 2 * ↑c ≤ ‖⟪f x, x⟫_𝕜‖
h_anti : AntilipschitzWith c⁻¹ ⇑f
_inst : CompleteSpace ↥(LinearMap.range f)
⊢ ∀ x ∈ (LinearMap.range f)ᗮ, x = 0
|
intro x hx
|
𝕜 : Type u_1
E : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
f : E →L[𝕜] E
c : ℝ≥0
hc : 0 < c
h : ∀ (x : E), ‖x‖ ^ 2 * ↑c ≤ ‖⟪f x, x⟫_𝕜‖
h_anti : AntilipschitzWith c⁻¹ ⇑f
_inst : CompleteSpace ↥(LinearMap.range f)
x : E
hx : x ∈ (LinearMap.range f)ᗮ
⊢ x = 0
|
86f45fd4ee3ea972
|
Std.Sat.CNF.unsat_relabelFin
|
Mathlib/.lake/packages/lean4/src/lean/Std/Sat/CNF/RelabelFin.lean
|
theorem unsat_relabelFin {f : CNF Nat} : Unsat f.relabelFin ↔ Unsat f
|
case isTrue.hw.isTrue
f : CNF Nat
h : ∃ v, Mem v f
a b : Nat
ma : a < f.numLiterals
mb : b < f.numLiterals
a_lt : a < f.numLiterals
⊢ ⟨a, a_lt⟩ = ⟨b, mb⟩ → a = b
|
simp
|
no goals
|
253377bcdcffdbab
|
UniformSpace.compactSpace_iff_seqCompactSpace
|
Mathlib/Topology/Sequences.lean
|
theorem UniformSpace.compactSpace_iff_seqCompactSpace : CompactSpace X ↔ SeqCompactSpace X
|
X : Type u_1
inst✝¹ : UniformSpace X
inst✝ : (𝓤 X).IsCountablyGenerated
⊢ CompactSpace X ↔ SeqCompactSpace X
|
simp only [← isCompact_univ_iff, seqCompactSpace_iff, UniformSpace.isCompact_iff_isSeqCompact]
|
no goals
|
ad97f450c6082814
|
Set.mem_prod_list_ofFn
|
Mathlib/Algebra/Group/Pointwise/Set/ListOfFn.lean
|
theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i ↦ (f i : α)).prod = a
|
case zero
α : Type u_1
inst✝ : Monoid α
n : ℕ
a : α
s : Fin 0 → Set α
⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a
|
simp_rw [List.ofFn_zero, List.prod_nil, Fin.exists_fin_zero_pi, eq_comm, Set.mem_one]
|
no goals
|
a43de69c1f07753d
|
nilpotencyClass_eq_zero_of_subsingleton
|
Mathlib/RingTheory/Nilpotent/Defs.lean
|
@[simp] lemma nilpotencyClass_eq_zero_of_subsingleton [Subsingleton R] :
nilpotencyClass x = 0
|
R : Type u_1
x : R
inst✝² : Zero R
inst✝¹ : Pow R ℕ
inst✝ : Subsingleton R
s : Set ℕ := {k | x ^ k = 0}
this : s = univ
⊢ sInf {k | x ^ k = 0} = 0
|
simp [s] at this
|
R : Type u_1
x : R
inst✝² : Zero R
inst✝¹ : Pow R ℕ
inst✝ : Subsingleton R
s : Set ℕ := {k | x ^ k = 0}
this : {k | x ^ k = 0} = univ
⊢ sInf {k | x ^ k = 0} = 0
|
a12c1a51157c0cb3
|
ConjClasses.mk_bijOn
|
Mathlib/GroupTheory/Subgroup/Center.lean
|
theorem mk_bijOn (G : Type*) [Group G] :
Set.BijOn ConjClasses.mk (↑(Subgroup.center G)) (noncenter G)ᶜ
|
case refine_3.mk
G : Type u_2
inst✝ : Group G
a✝ : ConjClasses G
g : G
hg : (carrier (Quot.mk (⇑(IsConj.setoid G)) g)).Subsingleton
h : G
⊢ ∃ c, c * g * c⁻¹ = h * g * h⁻¹
|
exact ⟨h, rfl⟩
|
no goals
|
e98f5eec083003f7
|
CategoryTheory.TwoSquare.GuitartExact.vComp_iff_of_equivalences
|
Mathlib/CategoryTheory/GuitartExact/VerticalComposition.lean
|
lemma vComp_iff_of_equivalences (eL : C₂ ≌ C₃) (eR : D₂ ≌ D₃)
(w' : H₂ ⋙ eR.functor ≅ eL.functor ⋙ H₃) :
(w ≫ᵥ w'.hom).GuitartExact ↔ w.GuitartExact
|
case mp
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
D₁ : Type u_4
D₂ : Type u_5
D₃ : Type u_6
inst✝⁵ : Category.{u_11, u_1} C₁
inst✝⁴ : Category.{u_7, u_2} C₂
inst✝³ : Category.{u_8, u_3} C₃
inst✝² : Category.{u_12, u_4} D₁
inst✝¹ : Category.{u_9, u_5} D₂
inst✝ : Category.{u_10, u_6} D₃
H₁ : C₁ ⥤ D₁
L₁ : C₁ ⥤ C₂
R₁ : D₁ ⥤ D₂
H₂ : C₂ ⥤ D₂
w : TwoSquare H₁ L₁ R₁ H₂
H₃ : C₃ ⥤ D₃
eL : C₂ ≌ C₃
eR : D₂ ≌ D₃
w' : H₂ ⋙ eR.functor ≅ eL.functor ⋙ H₃
hww' : (w ≫ᵥ w'.hom).GuitartExact
this : CatCommSq H₂ eL.functor eR.functor H₃ := { iso' := w' }
⊢ w.GuitartExact
|
have hw' : CatCommSq.iso H₂ eL.functor eR.functor H₃ = w' := rfl
|
case mp
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
D₁ : Type u_4
D₂ : Type u_5
D₃ : Type u_6
inst✝⁵ : Category.{u_11, u_1} C₁
inst✝⁴ : Category.{u_7, u_2} C₂
inst✝³ : Category.{u_8, u_3} C₃
inst✝² : Category.{u_12, u_4} D₁
inst✝¹ : Category.{u_9, u_5} D₂
inst✝ : Category.{u_10, u_6} D₃
H₁ : C₁ ⥤ D₁
L₁ : C₁ ⥤ C₂
R₁ : D₁ ⥤ D₂
H₂ : C₂ ⥤ D₂
w : TwoSquare H₁ L₁ R₁ H₂
H₃ : C₃ ⥤ D₃
eL : C₂ ≌ C₃
eR : D₂ ≌ D₃
w' : H₂ ⋙ eR.functor ≅ eL.functor ⋙ H₃
hww' : (w ≫ᵥ w'.hom).GuitartExact
this : CatCommSq H₂ eL.functor eR.functor H₃ := { iso' := w' }
hw' : CatCommSq.iso H₂ eL.functor eR.functor H₃ = w'
⊢ w.GuitartExact
|
3c08a0c3ff12f8dc
|
Set.infinite_iff_tendsto_sum_indicator_atTop
|
Mathlib/Algebra/Order/Archimedean/IndicatorCard.lean
|
lemma infinite_iff_tendsto_sum_indicator_atTop {R : Type*} [OrderedAddCommMonoid R]
[AddLeftStrictMono R] [Archimedean R] {r : R} (h : 0 < r) {s : Set ℕ} :
s.Infinite ↔ atTop.Tendsto (fun n ↦ ∑ k ∈ Finset.range n, s.indicator (fun _ ↦ r) k) atTop
|
case mp.intro
R : Type u_1
inst✝² : OrderedAddCommMonoid R
inst✝¹ : AddLeftStrictMono R
inst✝ : Archimedean R
r : R
h : 0 < r
s : Set ℕ
h_mono : Monotone fun n => ∑ k ∈ Finset.range n, s.indicator (fun x => r) k
hs : s.Infinite
n : R
n' : ℕ
hn' : n < n' • r
⊢ ∃ a, n ≤ ∑ k ∈ Finset.range a, s.indicator (fun x => r) k
|
obtain ⟨t, t_s, t_card⟩ := hs.exists_subset_card_eq n'
|
case mp.intro.intro.intro
R : Type u_1
inst✝² : OrderedAddCommMonoid R
inst✝¹ : AddLeftStrictMono R
inst✝ : Archimedean R
r : R
h : 0 < r
s : Set ℕ
h_mono : Monotone fun n => ∑ k ∈ Finset.range n, s.indicator (fun x => r) k
hs : s.Infinite
n : R
n' : ℕ
hn' : n < n' • r
t : Finset ℕ
t_s : ↑t ⊆ s
t_card : #t = n'
⊢ ∃ a, n ≤ ∑ k ∈ Finset.range a, s.indicator (fun x => r) k
|
431e7584f4bd6fdf
|
PiToModule.fromEnd_apply_single_one
|
Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
|
theorem PiToModule.fromEnd_apply_single_one [DecidableEq ι] (f : Module.End R M) (i : ι) :
PiToModule.fromEnd R b f (Pi.single i 1) = f (b i)
|
ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_3
inst✝² : CommRing R
inst✝¹ : Module R M
b : ι → M
inst✝ : DecidableEq ι
f : Module.End R M
i : ι
⊢ ((fromEnd R b) f) (Pi.single i 1) = f (b i)
|
rw [PiToModule.fromEnd_apply]
|
ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_3
inst✝² : CommRing R
inst✝¹ : Module R M
b : ι → M
inst✝ : DecidableEq ι
f : Module.End R M
i : ι
⊢ f (((Fintype.linearCombination R R) b) (Pi.single i 1)) = f (b i)
|
c01aa1bfae675e55
|
Ideal.ideal_prod_eq
|
Mathlib/RingTheory/Ideal/Prod.lean
|
theorem ideal_prod_eq (I : Ideal (R × S)) :
I = Ideal.prod (map (RingHom.fst R S) I : Ideal R) (map (RingHom.snd R S) I)
|
case h.mk.intro.intro.mk.intro.intro.mk.intro
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I : Ideal (R × S)
r : R
s' : S
h₁ : (r, s') ∈ I
r' : R
s : S
h₂ : (r', s) ∈ I
⊢ ((RingHom.fst R S) (r, s'), (RingHom.snd R S) (r', s)) ∈ I
|
simpa using I.add_mem (I.mul_mem_left (1, 0) h₁) (I.mul_mem_left (0, 1) h₂)
|
no goals
|
01de65c949d940b4
|
ENNReal.rpow_lt_rpow_of_exponent_gt
|
Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
|
theorem rpow_lt_rpow_of_exponent_gt {x : ℝ≥0∞} {y z : ℝ} (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) :
x ^ y < x ^ z
|
x : ℝ≥0∞
y z : ℝ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ x ^ y < x ^ z
|
lift x to ℝ≥0 using ne_of_lt (lt_of_lt_of_le hx1 le_top)
|
case intro
y z : ℝ
hyz : z < y
x : ℝ≥0
hx0 : 0 < ↑x
hx1 : ↑x < 1
⊢ ↑x ^ y < ↑x ^ z
|
d32e37149ac5db61
|
SetTheory.Game.birthday_add_le
|
Mathlib/SetTheory/Game/Birthday.lean
|
theorem birthday_add_le (x y : Game) : (x + y).birthday ≤ x.birthday ♯ y.birthday
|
x y : Game
a : PGame
ha₁ : ⟦a⟧ = x
ha₂ : a.birthday = x.birthday
b : PGame
hb₁ : ⟦b⟧ = y
hb₂ : b.birthday = y.birthday
⊢ (⟦a⟧ + ⟦b⟧).birthday ≤ (a + b).birthday
|
exact birthday_quot_le_pGameBirthday _
|
no goals
|
d7c58819e137ff8d
|
IsPathConnected.exists_path_through_family
|
Mathlib/Topology/Connected/PathConnected.lean
|
theorem IsPathConnected.exists_path_through_family {n : ℕ}
{s : Set X} (h : IsPathConnected s) (p : Fin (n + 1) → X) (hp : ∀ i, p i ∈ s) :
∃ γ : Path (p 0) (p n), range γ ⊆ s ∧ ∀ i, p i ∈ range γ
|
case h.right
X : Type u_1
inst✝ : TopologicalSpace X
s : Set X
h : IsPathConnected s
p' : ℕ → X
hp' : ∀ i ≤ 0, p' i ∈ s
⊢ range ⇑(Path.refl (p' 0)) ⊆ s
|
rw [range_subset_iff]
|
case h.right
X : Type u_1
inst✝ : TopologicalSpace X
s : Set X
h : IsPathConnected s
p' : ℕ → X
hp' : ∀ i ≤ 0, p' i ∈ s
⊢ ∀ (y : ↑I), (Path.refl (p' 0)) y ∈ s
|
b08141240b56f283
|
Filter.sInter_comap_sets
|
Mathlib/Order/Filter/Map.lean
|
theorem sInter_comap_sets (f : α → β) (F : Filter β) : ⋂₀ (comap f F).sets = ⋂ U ∈ F, f ⁻¹' U
|
case h.mp
α : Type u_1
β : Type u_2
f : α → β
F : Filter β
x : α
h : ∀ (A : Set α), ∀ B ∈ F, f ⁻¹' B ⊆ A → x ∈ A
U : Set β
U_in : U ∈ F
⊢ f x ∈ U
|
simpa only [Subset.rfl, forall_prop_of_true, mem_preimage] using h (f ⁻¹' U) U U_in
|
no goals
|
bf2c20d986e732fa
|
StieltjesFunction.outer_trim
|
Mathlib/MeasureTheory/Measure/Stieltjes.lean
|
theorem outer_trim : f.outer.trim = f.outer
|
f : StieltjesFunction
s : Set ℝ
t : ℕ → Set ℝ
ht : s ⊆ ⋃ i, t i
ε : ℝ≥0
ε0 : 0 < ε
h : ∑' (i : ℕ), f.length (t i) < ⊤
ε' : ℕ → ℝ≥0
ε'0 : ∀ (i : ℕ), 0 < ε' i
hε : ∑' (i : ℕ), ↑(ε' i) < ↑ε
g : ℕ → Set ℝ
hg : ∀ (i : ℕ), t i ⊆ g i ∧ MeasurableSet (g i) ∧ f.outer (g i) ≤ f.length (t i) + ↑(ε' i)
⊢ f.outer (iUnion g) ≤ ∑' (a : ℕ), (f.length (t a) + ↑(ε' a))
|
exact le_trans (measure_iUnion_le _) (ENNReal.tsum_le_tsum fun i => (hg i).2.2)
|
no goals
|
f9dd01cdb673361c
|
PiTensorProduct.mapL_coe
|
Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
|
theorem mapL_coe : (mapL f).toLinearMap = map (fun i ↦ (f i).toLinearMap)
|
case H.H
ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
E' : ι → Type u_1
inst✝¹ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (E' i)
f : (i : ι) → E i →L[𝕜] E' i
x✝ : (i : ι) → E i
⊢ ((↑(mapL f)).compMultilinearMap (tprod 𝕜)) x✝ = ((map fun i => ↑(f i)).compMultilinearMap (tprod 𝕜)) x✝
|
simp only [mapL, LinearMap.compMultilinearMap_apply, ContinuousLinearMap.coe_coe,
liftIsometry_apply_apply, lift.tprod, ContinuousMultilinearMap.coe_coe,
ContinuousMultilinearMap.compContinuousLinearMap_apply, tprodL_toFun, map_tprod]
|
no goals
|
e1b9e9a534ca092b
|
LinearMap.BilinForm.iIsOrtho.nondegenerate_iff_not_isOrtho_basis_self
|
Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
|
theorem iIsOrtho.nondegenerate_iff_not_isOrtho_basis_self {n : Type w} [Nontrivial R]
[NoZeroDivisors R] (B : BilinForm R M) (v : Basis n R M) (hO : B.iIsOrtho v) :
B.Nondegenerate ↔ ∀ i, ¬B.IsOrtho (v i) (v i)
|
case intro.h.h₁
R : Type u_1
M : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
n : Type w
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
B : BilinForm R M
v : Basis n R M
hO : B.iIsOrtho ⇑v
ho : ∀ (i : n), ¬B.IsOrtho (v i) (v i)
vi : n →₀ R
i : n
hB : ∑ x ∈ vi.support, vi x * (B (v x)) (v i) = 0
hi : i ∉ vi.support
⊢ vi i * (B (v i)) (v i) = 0
|
convert zero_mul (M₀ := R) _ using 2
|
case h.e'_2.h.e'_5
R : Type u_1
M : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
n : Type w
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
B : BilinForm R M
v : Basis n R M
hO : B.iIsOrtho ⇑v
ho : ∀ (i : n), ¬B.IsOrtho (v i) (v i)
vi : n →₀ R
i : n
hB : ∑ x ∈ vi.support, vi x * (B (v x)) (v i) = 0
hi : i ∉ vi.support
⊢ vi i = 0
|
270c734da50eb6ed
|
Stream'.Seq.cons_append
|
Mathlib/Data/Seq/Seq.lean
|
theorem cons_append (a : α) (s t) : append (cons a s) t = cons a (append s t) :=
destruct_eq_cons <| by
dsimp [append]; rw [corec_eq]
dsimp [append]; rw [destruct_cons]
|
α : Type u
a : α
s t : Seq α
⊢ ((cons a s).append t).destruct = some (a, s.append t)
|
dsimp [append]
|
α : Type u
a : α
s t : Seq α
⊢ (corec
(fun x =>
match x.fst.destruct with
| none =>
match x.snd.destruct with
| none => none
| some (a, b) => some (a, nil, b)
| some (a, s₁') => some (a, s₁', x.snd))
(cons a s, t)).destruct =
some
(a,
corec
(fun x =>
match x.fst.destruct with
| none =>
match x.snd.destruct with
| none => none
| some (a, b) => some (a, nil, b)
| some (a, s₁') => some (a, s₁', x.snd))
(s, t))
|
df82e73275a060c3
|
List.erase_range'
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Nat/Range.lean
|
theorem erase_range' :
(range' s n).erase i =
range' s (min n (i - s)) ++ range' (max s (i + 1)) (min s (i + 1) + n - (i + 1))
|
case pos.intro.intro.intro
s n i : Nat
h : i ∈ range' s n
as bs : List Nat
h₁ : range' s n = as ++ i :: bs
h₂ : ¬i ∈ as
⊢ (range' s n).erase i = range' s (min n (i - s)) ++ range' (max s (i + 1)) (min s (i + 1) + n - (i + 1))
|
rw [h₁, erase_append_right _ h₂, erase_cons_head]
|
case pos.intro.intro.intro
s n i : Nat
h : i ∈ range' s n
as bs : List Nat
h₁ : range' s n = as ++ i :: bs
h₂ : ¬i ∈ as
⊢ as ++ bs = range' s (min n (i - s)) ++ range' (max s (i + 1)) (min s (i + 1) + n - (i + 1))
|
4481dd96f216c300
|
CategoryTheory.Functor.shiftIso_add'_hom_app
|
Mathlib/CategoryTheory/Shift/ShiftSequence.lean
|
lemma shiftIso_add'_hom_app (n m mn : M) (hnm : m + n = mn) (a a' a'' : M)
(ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
(F.shiftIso mn a a'' (by rw [← hnm, ← ha'', ← ha', add_assoc])).hom.app X =
(shift F a).map ((shiftFunctorAdd' C m n mn hnm).hom.app X) ≫
(shiftIso F n a a' ha').hom.app ((shiftFunctor C m).obj X) ≫
(shiftIso F m a' a'' ha'').hom.app X
|
C : Type u_1
A : Type u_2
inst✝⁶ : Category.{?u.56941, u_1} C
inst✝⁵ : Category.{?u.56945, u_2} A
F : C ⥤ A
M : Type u_3
inst✝⁴ : AddMonoid M
inst✝³ : HasShift C M
G : Type u_4
inst✝² : AddGroup G
inst✝¹ : HasShift C G
inst✝ : F.ShiftSequence M
n m mn : M
hnm : m + n = mn
a a' a'' : M
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ mn + a = a''
|
rw [← hnm, ← ha'', ← ha', add_assoc]
|
no goals
|
a6401748df147a76
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.contradiction_of_insertUnit_success
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.lean
|
theorem contradiction_of_insertUnit_success {n : Nat} (assignments : Array Assignment)
(assignments_size : assignments.size = n)
(units : Array (Literal (PosFin n))) (foundContradiction : Bool) (l : Literal (PosFin n)) :
let insertUnit_res := insertUnit (units, assignments, foundContradiction) l
(foundContradiction → ∃ i : PosFin n, assignments[i.1]'(by rw [assignments_size]; exact i.2.2) = both) → insertUnit_res.2.2 →
∃ j : PosFin n, insertUnit_res.2.1[j.1]'(by rw [size_insertUnit, assignments_size]; exact j.2.2) = both
|
case inr
n : Nat
assignments : Array Assignment
assignments_size : assignments.size = n
units : Array (Literal (PosFin n))
foundContradiction : Bool
l : Literal (PosFin n)
insertUnit_res : Array (Literal (PosFin n)) × Array Assignment × Bool :=
insertUnit (units, assignments, foundContradiction) l
h : foundContradiction = true → ∃ i, assignments[i.val] = both
l_in_bounds : l.fst.val < assignments.size
hl : ¬hasAssignment l.snd assignments[l.fst.val]! = true
assignments_l_ne_unassigned : (assignments[l.fst.val]! != unassigned) = true
⊢ (insertUnit (units, assignments, foundContradiction) l).snd.fst[l.fst.val] = both
|
simp only [insertUnit, hl, ite_false, Array.getElem_modify_self, reduceCtorEq]
|
case inr
n : Nat
assignments : Array Assignment
assignments_size : assignments.size = n
units : Array (Literal (PosFin n))
foundContradiction : Bool
l : Literal (PosFin n)
insertUnit_res : Array (Literal (PosFin n)) × Array Assignment × Bool :=
insertUnit (units, assignments, foundContradiction) l
h : foundContradiction = true → ∃ i, assignments[i.val] = both
l_in_bounds : l.fst.val < assignments.size
hl : ¬hasAssignment l.snd assignments[l.fst.val]! = true
assignments_l_ne_unassigned : (assignments[l.fst.val]! != unassigned) = true
⊢ addAssignment l.snd assignments[l.fst.val] = both
|
7d5ecc4c40b25bd1
|
MeasureTheory.lintegral_const_mul''
|
Mathlib/MeasureTheory/Integral/Lebesgue.lean
|
theorem lintegral_const_mul'' (r : ℝ≥0∞) {f : α → ℝ≥0∞} (hf : AEMeasurable f μ) :
∫⁻ a, r * f a ∂μ = r * ∫⁻ a, f a ∂μ
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f μ
A : ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), AEMeasurable.mk f hf a ∂μ
⊢ ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ
|
have B : ∫⁻ a, r * f a ∂μ = ∫⁻ a, r * hf.mk f a ∂μ :=
lintegral_congr_ae (EventuallyEq.fun_comp hf.ae_eq_mk _)
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f μ
A : ∫⁻ (a : α), f a ∂μ = ∫⁻ (a : α), AEMeasurable.mk f hf a ∂μ
B : ∫⁻ (a : α), r * f a ∂μ = ∫⁻ (a : α), r * AEMeasurable.mk f hf a ∂μ
⊢ ∫⁻ (a : α), r * f a ∂μ = r * ∫⁻ (a : α), f a ∂μ
|
cf82783884c5cc86
|
MeasureTheory.hahn_decomposition
|
Mathlib/MeasureTheory/Decomposition/UnsignedHahn.lean
|
theorem hahn_decomposition (μ ν : Measure α) [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
∃ s, MeasurableSet s ∧ (∀ t, MeasurableSet t → t ⊆ s → ν t ≤ μ t) ∧
∀ t, MeasurableSet t → t ⊆ sᶜ → μ t ≤ ν t
|
case refine_2
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
d : Set α → ℝ := fun s => ↑(μ s).toNNReal - ↑(ν s).toNNReal
c : Set ℝ := d '' {s | MeasurableSet s}
γ : ℝ := sSup c
hμ : ∀ (s : Set α), μ s ≠ ⊤
hν : ∀ (s : Set α), ν s ≠ ⊤
to_nnreal_μ : ∀ (s : Set α), ↑(μ s).toNNReal = μ s
to_nnreal_ν : ∀ (s : Set α), ↑(ν s).toNNReal = ν s
d_split : ∀ (s t : Set α), MeasurableSet t → d s = d (s \ t) + d (s ∩ t)
d_Union : ∀ (s : ℕ → Set α), Monotone s → Tendsto (fun n => d (s n)) atTop (𝓝 (d (⋃ n, s n)))
d_Inter :
∀ (s : ℕ → Set α),
(∀ (n : ℕ), MeasurableSet (s n)) →
(∀ (n m : ℕ), n ≤ m → s m ⊆ s n) → Tendsto (fun n => d (s n)) atTop (𝓝 (d (⋂ n, s n)))
bdd_c : BddAbove c
c_nonempty : c.Nonempty
d_le_γ : ∀ (s : Set α), MeasurableSet s → d s ≤ γ
this : ∀ (n : ℕ), ∃ s, MeasurableSet s ∧ γ - (1 / 2) ^ n < d s
e : ℕ → Set α
he : ∀ (x : ℕ), MeasurableSet (e x) ∧ γ - (1 / 2) ^ x < d (e x)
he₁ : ∀ (n : ℕ), MeasurableSet (e n)
he₂ : ∀ (n : ℕ), γ - (1 / 2) ^ n < d (e n)
f : ℕ → ℕ → Set α := fun n m => (Finset.Ico n (m + 1)).inf e
hf : ∀ (n m : ℕ), MeasurableSet (f n m)
f_subset_f : ∀ {a b c d : ℕ}, a ≤ b → c ≤ d → f a d ⊆ f b c
f_succ : ∀ (n m : ℕ), n ≤ m → f n (m + 1) = f n m ∩ e (m + 1)
n m : ℕ
h : m ≤ n
⊢ ∀ (n : ℕ),
m ≤ n → γ - 2 * (1 / 2) ^ m + (1 / 2) ^ n ≤ d (f m n) → γ - 2 * (1 / 2) ^ m + (1 / 2) ^ (n + 1) ≤ d (f m (n + 1))
|
intro n (hmn : m ≤ n) ih
|
case refine_2
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
d : Set α → ℝ := fun s => ↑(μ s).toNNReal - ↑(ν s).toNNReal
c : Set ℝ := d '' {s | MeasurableSet s}
γ : ℝ := sSup c
hμ : ∀ (s : Set α), μ s ≠ ⊤
hν : ∀ (s : Set α), ν s ≠ ⊤
to_nnreal_μ : ∀ (s : Set α), ↑(μ s).toNNReal = μ s
to_nnreal_ν : ∀ (s : Set α), ↑(ν s).toNNReal = ν s
d_split : ∀ (s t : Set α), MeasurableSet t → d s = d (s \ t) + d (s ∩ t)
d_Union : ∀ (s : ℕ → Set α), Monotone s → Tendsto (fun n => d (s n)) atTop (𝓝 (d (⋃ n, s n)))
d_Inter :
∀ (s : ℕ → Set α),
(∀ (n : ℕ), MeasurableSet (s n)) →
(∀ (n m : ℕ), n ≤ m → s m ⊆ s n) → Tendsto (fun n => d (s n)) atTop (𝓝 (d (⋂ n, s n)))
bdd_c : BddAbove c
c_nonempty : c.Nonempty
d_le_γ : ∀ (s : Set α), MeasurableSet s → d s ≤ γ
this : ∀ (n : ℕ), ∃ s, MeasurableSet s ∧ γ - (1 / 2) ^ n < d s
e : ℕ → Set α
he : ∀ (x : ℕ), MeasurableSet (e x) ∧ γ - (1 / 2) ^ x < d (e x)
he₁ : ∀ (n : ℕ), MeasurableSet (e n)
he₂ : ∀ (n : ℕ), γ - (1 / 2) ^ n < d (e n)
f : ℕ → ℕ → Set α := fun n m => (Finset.Ico n (m + 1)).inf e
hf : ∀ (n m : ℕ), MeasurableSet (f n m)
f_subset_f : ∀ {a b c d : ℕ}, a ≤ b → c ≤ d → f a d ⊆ f b c
f_succ : ∀ (n m : ℕ), n ≤ m → f n (m + 1) = f n m ∩ e (m + 1)
n✝ m : ℕ
h : m ≤ n✝
n : ℕ
hmn : m ≤ n
ih : γ - 2 * (1 / 2) ^ m + (1 / 2) ^ n ≤ d (f m n)
⊢ γ - 2 * (1 / 2) ^ m + (1 / 2) ^ (n + 1) ≤ d (f m (n + 1))
|
b74e26e9476d0e19
|
CategoryTheory.MorphismProperty.map_id_eq_isoClosure
|
Mathlib/CategoryTheory/MorphismProperty/Basic.lean
|
lemma map_id_eq_isoClosure (P : MorphismProperty C) :
P.map (𝟭 _) = P.isoClosure
|
C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
⊢ P.map (𝟭 C) = P.isoClosure
|
apply le_antisymm
|
case a
C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
⊢ P.map (𝟭 C) ≤ P.isoClosure
case a
C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
⊢ P.isoClosure ≤ P.map (𝟭 C)
|
be21352197170292
|
Real.cosh_sub_sinh
|
Mathlib/Data/Complex/Trigonometric.lean
|
theorem cosh_sub_sinh : cosh x - sinh x = exp (-x)
|
x : ℝ
⊢ cosh x - sinh x = rexp (-x)
|
rw [← ofReal_inj]
|
x : ℝ
⊢ ↑(cosh x - sinh x) = ↑(rexp (-x))
|
05d89db7fd280dae
|
LieAlgebra.isKilling_of_equiv
|
Mathlib/Algebra/Lie/Killing.lean
|
/-- Given a Killing Lie algebra `L`, if `L'` is isomorphic to `L`, then `L'` is Killing too. -/
lemma isKilling_of_equiv [IsKilling R L] (e : L ≃ₗ⁅R⁆ L') : IsKilling R L'
|
R : Type u_1
L : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LieRing L
inst✝³ : LieAlgebra R L
L' : Type u_4
inst✝² : LieRing L'
inst✝¹ : LieAlgebra R L'
inst✝ : IsKilling R L
e : L ≃ₗ⁅R⁆ L'
x' : L'
hx' : ∀ y ∈ ⊤, ((LieModule.traceForm R L' L') x') y = 0
y : L
⊢ ∀ (y' : L'), ((killingForm R L') x') y' = 0
|
simpa using hx'
|
no goals
|
edcf9b2ce3c479d9
|
Metric.diam_thickening_le
|
Mathlib/Topology/MetricSpace/Thickening.lean
|
theorem diam_thickening_le {α : Type*} [PseudoMetricSpace α] (s : Set α) (hε : 0 ≤ ε) :
diam (thickening ε s) ≤ diam s + 2 * ε
|
case neg
ε : ℝ
α : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
hε : 0 ≤ ε
hs : ¬Bornology.IsBounded s
⊢ diam (thickening ε s) ≤ diam s + 2 * ε
|
obtain rfl | hε := hε.eq_or_lt
|
case neg.inl
α : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
hs : ¬Bornology.IsBounded s
hε : 0 ≤ 0
⊢ diam (thickening 0 s) ≤ diam s + 2 * 0
case neg.inr
ε : ℝ
α : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
hε✝ : 0 ≤ ε
hs : ¬Bornology.IsBounded s
hε : 0 < ε
⊢ diam (thickening ε s) ≤ diam s + 2 * ε
|
d0b75f623e4efeae
|
ProbabilityTheory.setLIntegral_stieltjesOfMeasurableRat
|
Mathlib/Probability/Kernel/Disintegration/CDFToKernel.lean
|
lemma setLIntegral_stieltjesOfMeasurableRat [IsFiniteKernel κ] (hf : IsRatCondKernelCDF f κ ν)
(a : α) (x : ℝ) {s : Set β} (hs : MeasurableSet s) :
∫⁻ b in s, ENNReal.ofReal (stieltjesOfMeasurableRat f hf.measurable (a, b) x) ∂(ν a)
= κ a (s ×ˢ Iic x)
|
case neg.h_directed
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
inst✝ : IsFiniteKernel κ
hf : IsRatCondKernelCDF f κ ν
a : α
x : ℝ
s : Set β
hs : MeasurableSet s
hρ_zero : ¬(ν a).restrict s = 0
h :
∫⁻ (b : β) in s, ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) x) ∂ν a =
∫⁻ (b : β) in s, ⨅ r, ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) ↑↑r) ∂ν a
h_nonempty : Nonempty { r' // x < ↑r' }
⊢ Directed (fun x1 x2 => x1 ≥ x2) fun r b => ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) ↑↑r)
|
refine Monotone.directed_ge fun i j hij b ↦ ?_
|
case neg.h_directed
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
inst✝ : IsFiniteKernel κ
hf : IsRatCondKernelCDF f κ ν
a : α
x : ℝ
s : Set β
hs : MeasurableSet s
hρ_zero : ¬(ν a).restrict s = 0
h :
∫⁻ (b : β) in s, ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) x) ∂ν a =
∫⁻ (b : β) in s, ⨅ r, ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) ↑↑r) ∂ν a
h_nonempty : Nonempty { r' // x < ↑r' }
i j : { r' // x < ↑r' }
hij : i ≤ j
b : β
⊢ ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) ↑↑i) ≤
ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) ↑↑j)
|
2b5f63b20150553c
|
gaussSum_aux_of_mulShift
|
Mathlib/NumberTheory/DirichletCharacter/GaussSum.lean
|
lemma gaussSum_aux_of_mulShift (χ : DirichletCharacter R N) {d : ℕ}
(hd : d ∣ N) (he : e.mulShift d = 1) {u : (ZMod N)ˣ} (hu : ZMod.unitsMap hd u = 1) :
χ u * gaussSum χ e = gaussSum χ e
|
case intro
N : ℕ
inst✝¹ : NeZero N
R : Type u_1
inst✝ : CommRing R
e : AddChar (ZMod N) R
χ : DirichletCharacter R N
d : ℕ
hd : d ∣ N
he : e.mulShift ↑d = 1
u : (ZMod N)ˣ
hu : (ZMod.unitsMap hd) u = 1
a : ℤ
ha : ↑(↑u).val - 1 = ↑d * a
this : ↑u - 1 = ↑(↑(↑u).val - 1)
⊢ e.mulShift ↑(↑d * a) = 1
|
ext1 y
|
case intro.h
N : ℕ
inst✝¹ : NeZero N
R : Type u_1
inst✝ : CommRing R
e : AddChar (ZMod N) R
χ : DirichletCharacter R N
d : ℕ
hd : d ∣ N
he : e.mulShift ↑d = 1
u : (ZMod N)ˣ
hu : (ZMod.unitsMap hd) u = 1
a : ℤ
ha : ↑(↑u).val - 1 = ↑d * a
this : ↑u - 1 = ↑(↑(↑u).val - 1)
y : ZMod N
⊢ (e.mulShift ↑(↑d * a)) y = 1 y
|
4a9c5b831778ada1
|
Equicontinuous.tendsto_uniformFun_iff_pi
|
Mathlib/Topology/UniformSpace/Ascoli.lean
|
theorem Equicontinuous.tendsto_uniformFun_iff_pi [CompactSpace X]
(F_eqcont : Equicontinuous F) (ℱ : Filter ι) (f : X → α) :
Tendsto (UniformFun.ofFun ∘ F) ℱ (𝓝 <| UniformFun.ofFun f) ↔
Tendsto F ℱ (𝓝 f)
|
case inr.mpr
ι : Type u_1
X : Type u_2
α : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : UniformSpace α
F : ι → X → α
inst✝ : CompactSpace X
F_eqcont : Equicontinuous F
ℱ : Filter ι
f : X → α
ℱ_ne : ℱ.NeBot
H : Tendsto F ℱ (𝓝 f)
⊢ Tendsto (⇑UniformFun.ofFun ∘ F) ℱ (𝓝 (UniformFun.ofFun f))
|
set S : Set (X → α) := closure (range F)
|
case inr.mpr
ι : Type u_1
X : Type u_2
α : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : UniformSpace α
F : ι → X → α
inst✝ : CompactSpace X
F_eqcont : Equicontinuous F
ℱ : Filter ι
f : X → α
ℱ_ne : ℱ.NeBot
H : Tendsto F ℱ (𝓝 f)
S : Set (X → α) := closure (range F)
⊢ Tendsto (⇑UniformFun.ofFun ∘ F) ℱ (𝓝 (UniformFun.ofFun f))
|
f9a2abc711557ca2
|
quasiIsoAt_iff_isIso_homologyMap
|
Mathlib/Algebra/Homology/QuasiIso.lean
|
lemma quasiIsoAt_iff_isIso_homologyMap (f : K ⟶ L) (i : ι)
[K.HasHomology i] [L.HasHomology i] :
QuasiIsoAt f i ↔ IsIso (homologyMap f i)
|
ι : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
c : ComplexShape ι
K L : HomologicalComplex C c
f : K ⟶ L
i : ι
inst✝¹ : K.HasHomology i
inst✝ : L.HasHomology i
⊢ QuasiIsoAt f i ↔ IsIso (homologyMap f i)
|
rw [quasiIsoAt_iff, ShortComplex.quasiIso_iff]
|
ι : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
c : ComplexShape ι
K L : HomologicalComplex C c
f : K ⟶ L
i : ι
inst✝¹ : K.HasHomology i
inst✝ : L.HasHomology i
⊢ IsIso (ShortComplex.homologyMap ((shortComplexFunctor C c i).map f)) ↔ IsIso (homologyMap f i)
|
acf7f89a4a17afd0
|
ProbabilityTheory.Kernel.iIndepSets.iIndep
|
Mathlib/Probability/Independence/Kernel.lean
|
theorem iIndepSets.iIndep (m : ι → MeasurableSpace Ω)
(h_le : ∀ i, m i ≤ _mΩ) (π : ι → Set (Set Ω)) (h_pi : ∀ n, IsPiSystem (π n))
(h_generate : ∀ i, m i = generateFrom (π i)) (h_ind : iIndepSets π κ μ) :
iIndep m κ μ
|
case inr.intro.intro
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
m : ι → MeasurableSpace Ω
h_le : ∀ (i : ι), m i ≤ _mΩ
π : ι → Set (Set Ω)
h_pi : ∀ (n : ι), IsPiSystem (π n)
h_generate : ∀ (i : ι), m i = generateFrom (π i)
h_ind : iIndepSets π κ μ
hμ : μ ≠ 0
η : Kernel α Ω
η_eq : ⇑κ =ᶠ[ae μ] ⇑η
hη : IsMarkovKernel η
s : Finset ι
f : ι → Set Ω
⊢ (∀ i ∈ s, f i ∈ (fun x => {s | MeasurableSet s}) i) → ∀ᵐ (a : α) ∂μ, (η a) (⋂ i ∈ s, f i) = ∏ i ∈ s, (η a) (f i)
|
refine Finset.induction ?_ ?_ s
|
case inr.intro.intro.refine_1
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
m : ι → MeasurableSpace Ω
h_le : ∀ (i : ι), m i ≤ _mΩ
π : ι → Set (Set Ω)
h_pi : ∀ (n : ι), IsPiSystem (π n)
h_generate : ∀ (i : ι), m i = generateFrom (π i)
h_ind : iIndepSets π κ μ
hμ : μ ≠ 0
η : Kernel α Ω
η_eq : ⇑κ =ᶠ[ae μ] ⇑η
hη : IsMarkovKernel η
s : Finset ι
f : ι → Set Ω
⊢ (∀ i ∈ ∅, f i ∈ (fun x => {s | MeasurableSet s}) i) → ∀ᵐ (a : α) ∂μ, (η a) (⋂ i ∈ ∅, f i) = ∏ i ∈ ∅, (η a) (f i)
case inr.intro.intro.refine_2
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
m : ι → MeasurableSpace Ω
h_le : ∀ (i : ι), m i ≤ _mΩ
π : ι → Set (Set Ω)
h_pi : ∀ (n : ι), IsPiSystem (π n)
h_generate : ∀ (i : ι), m i = generateFrom (π i)
h_ind : iIndepSets π κ μ
hμ : μ ≠ 0
η : Kernel α Ω
η_eq : ⇑κ =ᶠ[ae μ] ⇑η
hη : IsMarkovKernel η
s : Finset ι
f : ι → Set Ω
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
a ∉ s →
((∀ i ∈ s, f i ∈ (fun x => {s | MeasurableSet s}) i) →
∀ᵐ (a : α) ∂μ, (η a) (⋂ i ∈ s, f i) = ∏ i ∈ s, (η a) (f i)) →
(∀ i ∈ insert a s, f i ∈ (fun x => {s | MeasurableSet s}) i) →
∀ᵐ (a_3 : α) ∂μ, (η a_3) (⋂ i ∈ insert a s, f i) = ∏ i ∈ insert a s, (η a_3) (f i)
|
839768f1641edae0
|
Collinear.wbtw_of_dist_eq_of_dist_le
|
Mathlib/Analysis/Convex/StrictConvexBetween.lean
|
theorem Collinear.wbtw_of_dist_eq_of_dist_le {p p₁ p₂ p₃ : P} {r : ℝ}
(h : Collinear ℝ ({p₁, p₂, p₃} : Set P)) (hp₁ : dist p₁ p = r) (hp₂ : dist p₂ p ≤ r)
(hp₃ : dist p₃ p = r) (hp₁p₃ : p₁ ≠ p₃) : Wbtw ℝ p₁ p₂ p₃
|
case neg
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
r : ℝ
h : Collinear ℝ {p₁, p₂, p₃}
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p ≤ r
hp₃ : dist p₃ p = r
hp₁p₃ : p₁ ≠ p₃
hw : Wbtw ℝ p₂ p₃ p₁
hp₃p₂ : ¬p₃ = p₂
hs : Sbtw ℝ p₂ p₃ p₁
hs' : r < dist p₂ p
⊢ Wbtw ℝ p₁ p₂ p₃
|
exact False.elim (hp₂.not_lt hs')
|
no goals
|
964124f3e10d07e0
|
OrthogonalFamily.summable_iff_norm_sq_summable
|
Mathlib/Analysis/InnerProductSpace/Subspace.lean
|
theorem OrthogonalFamily.summable_iff_norm_sq_summable [CompleteSpace E] (f : ∀ i, G i) :
(Summable fun i => V i (f i)) ↔ Summable fun i => ‖f i‖ ^ 2
|
case mpr.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_4
G : ι → Type u_5
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
inst✝ : CompleteSpace E
f : (i : ι) → G i
hf : ∀ ε > 0, ∃ N, ∀ (m : Finset ι), N ≤ m → ∀ (n : Finset ι), N ≤ n → |∑ i ∈ m, ‖f i‖ ^ 2 - ∑ i ∈ n, ‖f i‖ ^ 2| < ε
ε : ℝ
hε : ε > 0
hε' : 0 < ε ^ 2 / 2
a : Finset ι
H : ∀ (m : Finset ι), a ≤ m → ∀ (n : Finset ι), a ≤ n → |∑ i ∈ m, ‖f i‖ ^ 2 - ∑ i ∈ n, ‖f i‖ ^ 2| < ε ^ 2 / 2
⊢ ∃ N, ∀ (m : Finset ι), N ≤ m → ∀ (n : Finset ι), N ≤ n → ‖∑ i ∈ m, (V i) (f i) - ∑ i ∈ n, (V i) (f i)‖ < ε
|
use a
|
case h
𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_4
G : ι → Type u_5
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
inst✝ : CompleteSpace E
f : (i : ι) → G i
hf : ∀ ε > 0, ∃ N, ∀ (m : Finset ι), N ≤ m → ∀ (n : Finset ι), N ≤ n → |∑ i ∈ m, ‖f i‖ ^ 2 - ∑ i ∈ n, ‖f i‖ ^ 2| < ε
ε : ℝ
hε : ε > 0
hε' : 0 < ε ^ 2 / 2
a : Finset ι
H : ∀ (m : Finset ι), a ≤ m → ∀ (n : Finset ι), a ≤ n → |∑ i ∈ m, ‖f i‖ ^ 2 - ∑ i ∈ n, ‖f i‖ ^ 2| < ε ^ 2 / 2
⊢ ∀ (m : Finset ι), a ≤ m → ∀ (n : Finset ι), a ≤ n → ‖∑ i ∈ m, (V i) (f i) - ∑ i ∈ n, (V i) (f i)‖ < ε
|
ef6c5d8e8db28ff0
|
ProbabilityTheory.strong_law_aux2
|
Mathlib/Probability/StrongLaw.lean
|
theorem strong_law_aux2 {c : ℝ} (c_one : 1 < c) :
∀ᵐ ω, (fun n : ℕ => ∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) i ω -
𝔼[∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) i]) =o[atTop] fun n : ℕ => (⌊c ^ n⌋₊ : ℝ)
|
case intro
Ω : Type u_1
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : ℕ → Ω → ℝ
hint : Integrable (X 0) ℙ
hindep : Pairwise ((fun f g => IndepFun f g ℙ) on X)
hident : ∀ (i : ℕ), IdentDistrib (X i) (X 0) ℙ ℙ
hnonneg : ∀ (i : ℕ) (ω : Ω), 0 ≤ X i ω
c : ℝ
c_one : 1 < c
v : ℕ → ℝ
v_pos : ∀ (n : ℕ), 0 < v n
v_lim : Tendsto v atTop (𝓝 0)
this :
∀ (i : ℕ),
∀ᵐ (ω : Ω),
∀ᶠ (n : ℕ) in atTop,
|∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) (↑i) ω - ∫ (a : Ω), (∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) ↑i) a| <
v i * ↑⌊c ^ n⌋₊
ω : Ω
hω :
∀ (i : ℕ),
∀ᶠ (n : ℕ) in atTop,
|∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) (↑i) ω - ∫ (a : Ω), (∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) ↑i) a| <
v i * ↑⌊c ^ n⌋₊
ε : ℝ
εpos : 0 < ε
i : ℕ
hi : v i < ε
⊢ ∀ᶠ (x : ℕ) in atTop,
‖∑ i ∈ range ⌊c ^ x⌋₊, truncation (X i) (↑i) ω - ∫ (a : Ω), (∑ i ∈ range ⌊c ^ x⌋₊, truncation (X i) ↑i) a‖ ≤
ε * ‖↑⌊c ^ x⌋₊‖
|
filter_upwards [hω i] with n hn
|
case h
Ω : Type u_1
inst✝¹ : MeasureSpace Ω
inst✝ : IsProbabilityMeasure ℙ
X : ℕ → Ω → ℝ
hint : Integrable (X 0) ℙ
hindep : Pairwise ((fun f g => IndepFun f g ℙ) on X)
hident : ∀ (i : ℕ), IdentDistrib (X i) (X 0) ℙ ℙ
hnonneg : ∀ (i : ℕ) (ω : Ω), 0 ≤ X i ω
c : ℝ
c_one : 1 < c
v : ℕ → ℝ
v_pos : ∀ (n : ℕ), 0 < v n
v_lim : Tendsto v atTop (𝓝 0)
this :
∀ (i : ℕ),
∀ᵐ (ω : Ω),
∀ᶠ (n : ℕ) in atTop,
|∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) (↑i) ω - ∫ (a : Ω), (∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) ↑i) a| <
v i * ↑⌊c ^ n⌋₊
ω : Ω
hω :
∀ (i : ℕ),
∀ᶠ (n : ℕ) in atTop,
|∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) (↑i) ω - ∫ (a : Ω), (∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) ↑i) a| <
v i * ↑⌊c ^ n⌋₊
ε : ℝ
εpos : 0 < ε
i : ℕ
hi : v i < ε
n : ℕ
hn :
|∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) (↑i) ω - ∫ (a : Ω), (∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) ↑i) a| <
v i * ↑⌊c ^ n⌋₊
⊢ ‖∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) (↑i) ω - ∫ (a : Ω), (∑ i ∈ range ⌊c ^ n⌋₊, truncation (X i) ↑i) a‖ ≤
ε * ‖↑⌊c ^ n⌋₊‖
|
0a014d4dcbee42df
|
HurwitzZeta.hurwitzZetaEven_one_sub_two_mul_nat
|
Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean
|
theorem hurwitzZetaEven_one_sub_two_mul_nat (hk : k ≠ 0) (hx : x ∈ Icc (0 : ℝ) 1) :
hurwitzZetaEven x (1 - 2 * k) =
-1 / (2 * k) * ((Polynomial.bernoulli (2 * k)).map (algebraMap ℚ ℂ)).eval (x : ℂ)
|
k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
h1 : ∀ (n : ℕ), 2 * ↑k ≠ -↑n
⊢ 2 * ↑k ≠ 1
|
norm_cast
|
k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
h1 : ∀ (n : ℕ), 2 * ↑k ≠ -↑n
⊢ ¬2 * k = 1
|
2c88f7923e28da1c
|
WeierstrassCurve.coeff_preΨ
|
Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
|
@[simp]
lemma coeff_preΨ (n : ℤ) : (W.preΨ n).coeff ((n.natAbs ^ 2 - if Even n then 4 else 1) / 2) =
if Even n then n / 2 else n
|
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℤ
⊢ (W.preΨ n).coeff ((n.natAbs ^ 2 - if Even n then 4 else 1) / 2) = ↑(if Even n then n / 2 else n)
|
induction n using Int.negInduction with
| nat n => exact_mod_cast W.preΨ_ofNat n ▸ W.coeff_preΨ' n
| neg ih n =>
simp only [preΨ_neg, coeff_neg, Int.natAbs_neg, even_neg]
rcases ih n, n.even_or_odd' with ⟨ih, ⟨n, rfl | rfl⟩⟩ <;>
push_cast [even_two_mul, Int.not_even_two_mul_add_one, Int.neg_ediv_of_dvd ⟨n, rfl⟩] at * <;>
rw [ih]
|
no goals
|
4a18ee8f7b8f8975
|
Module.FinitePresentation.exists_free_localizedModule_powers
|
Mathlib/RingTheory/Localization/Free.lean
|
/--
If `M` is a finitely presented `R`-module
such that `Mₛ` is free over `Rₛ` for some `S : Submonoid R`,
then `Mᵣ` is already free over `Rᵣ` for some `r ∈ S`.
-/
lemma Module.FinitePresentation.exists_free_localizedModule_powers
(Rₛ) [CommRing Rₛ] [Algebra R Rₛ] [Module Rₛ M'] [IsScalarTower R Rₛ M'] [Nontrivial Rₛ]
[IsLocalization S Rₛ] [Module.FinitePresentation R M] [Module.Free Rₛ M'] :
∃ r, r ∈ S ∧
Module.Free (Localization (.powers r)) (LocalizedModule (.powers r) M) ∧
Module.finrank (Localization (.powers r)) (LocalizedModule (.powers r) M) =
Module.finrank Rₛ M'
|
case intro.intro.intro
R : Type u_4
M : Type u_5
inst✝¹³ : CommRing R
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
S : Submonoid R
M' : Type u_1
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : Module R M'
f : M →ₗ[R] M'
inst✝⁸ : IsLocalizedModule S f
Rₛ : Type u_3
inst✝⁷ : CommRing Rₛ
inst✝⁶ : Algebra R Rₛ
inst✝⁵ : Module Rₛ M'
inst✝⁴ : IsScalarTower R Rₛ M'
inst✝³ : Nontrivial Rₛ
inst✝² : IsLocalization S Rₛ
inst✝¹ : FinitePresentation R M
inst✝ : Free Rₛ M'
I : Type u_1 := Free.ChooseBasisIndex Rₛ M'
b : Basis I Rₛ M' := Free.chooseBasis Rₛ M'
this : Module.Finite Rₛ M'
r : R
hr : r ∈ S
b' : Basis I (Localization (Submonoid.powers r)) (LocalizedModule (Submonoid.powers r) M)
h✝ : ∀ (i : I), (LocalizedModule.lift (Submonoid.powers r) f ⋯) (b' i) = b i
⊢ ∃ r ∈ S,
Free (Localization (Submonoid.powers r)) (LocalizedModule (Submonoid.powers r) M) ∧
finrank (Localization (Submonoid.powers r)) (LocalizedModule (Submonoid.powers r) M) = finrank Rₛ M'
|
have := (show Localization (.powers r) →+* Rₛ from IsLocalization.map (M := .powers r) (T := S) _
(RingHom.id _) (Submonoid.powers_le.mpr hr)).domain_nontrivial
|
case intro.intro.intro
R : Type u_4
M : Type u_5
inst✝¹³ : CommRing R
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
S : Submonoid R
M' : Type u_1
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : Module R M'
f : M →ₗ[R] M'
inst✝⁸ : IsLocalizedModule S f
Rₛ : Type u_3
inst✝⁷ : CommRing Rₛ
inst✝⁶ : Algebra R Rₛ
inst✝⁵ : Module Rₛ M'
inst✝⁴ : IsScalarTower R Rₛ M'
inst✝³ : Nontrivial Rₛ
inst✝² : IsLocalization S Rₛ
inst✝¹ : FinitePresentation R M
inst✝ : Free Rₛ M'
I : Type u_1 := Free.ChooseBasisIndex Rₛ M'
b : Basis I Rₛ M' := Free.chooseBasis Rₛ M'
this✝ : Module.Finite Rₛ M'
r : R
hr : r ∈ S
b' : Basis I (Localization (Submonoid.powers r)) (LocalizedModule (Submonoid.powers r) M)
h✝ : ∀ (i : I), (LocalizedModule.lift (Submonoid.powers r) f ⋯) (b' i) = b i
this : Nontrivial (Localization (Submonoid.powers r))
⊢ ∃ r ∈ S,
Free (Localization (Submonoid.powers r)) (LocalizedModule (Submonoid.powers r) M) ∧
finrank (Localization (Submonoid.powers r)) (LocalizedModule (Submonoid.powers r) M) = finrank Rₛ M'
|
c12b2df14689aeb4
|
CharP.quotient'
|
Mathlib/Algebra/CharP/Quotient.lean
|
theorem quotient' {R : Type*} [CommRing R] (p : ℕ) [CharP R p] (I : Ideal R)
(h : ∀ x : ℕ, (x : R) ∈ I → (x : R) = 0) : CharP (R ⧸ I) p :=
⟨fun x => by
rw [← cast_eq_zero_iff R p x, ← map_natCast (Ideal.Quotient.mk I)]
refine Ideal.Quotient.eq.trans (?_ : ↑x - 0 ∈ I ↔ _)
rw [sub_zero]
exact ⟨h x, fun h' => h'.symm ▸ I.zero_mem⟩⟩
|
R : Type u_1
inst✝¹ : CommRing R
p : ℕ
inst✝ : CharP R p
I : Ideal R
h : ∀ (x : ℕ), ↑x ∈ I → ↑x = 0
x : ℕ
⊢ ↑x = 0 ↔ p ∣ x
|
rw [← cast_eq_zero_iff R p x, ← map_natCast (Ideal.Quotient.mk I)]
|
R : Type u_1
inst✝¹ : CommRing R
p : ℕ
inst✝ : CharP R p
I : Ideal R
h : ∀ (x : ℕ), ↑x ∈ I → ↑x = 0
x : ℕ
⊢ (Ideal.Quotient.mk I) ↑x = 0 ↔ ↑x = 0
|
b01577067e6efc09
|
CategoryTheory.Adjunction.map_μ_comp_counit_app_tensor
|
Mathlib/CategoryTheory/Monoidal/Functor.lean
|
@[reassoc]
lemma map_μ_comp_counit_app_tensor (X Y : D) :
F.map (μ G X Y) ≫ adj.counit.app (X ⊗ Y) =
δ F _ _ ≫ (adj.counit.app X ⊗ adj.counit.app Y)
|
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : MonoidalCategory C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : MonoidalCategory D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝² : F.OplaxMonoidal
inst✝¹ : G.LaxMonoidal
inst✝ : adj.IsMonoidal
X Y : D
⊢ F.map (μ G X Y) ≫ adj.counit.app (X ⊗ Y) = δ F (G.obj X) (G.obj Y) ≫ (adj.counit.app X ⊗ adj.counit.app Y)
|
rw [IsMonoidal.leftAdjoint_μ (adj := adj), homEquiv_unit]
|
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : MonoidalCategory C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : MonoidalCategory D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝² : F.OplaxMonoidal
inst✝¹ : G.LaxMonoidal
inst✝ : adj.IsMonoidal
X Y : D
⊢ F.map (adj.unit.app (G.obj X ⊗ G.obj Y) ≫ G.map (δ F (G.obj X) (G.obj Y) ≫ (adj.counit.app X ⊗ adj.counit.app Y))) ≫
adj.counit.app (X ⊗ Y) =
δ F (G.obj X) (G.obj Y) ≫ (adj.counit.app X ⊗ adj.counit.app Y)
|
278e3a0dbc956dd2
|
ModuleCat.Tilde.exists_const
|
Mathlib/AlgebraicGeometry/Modules/Tilde.lean
|
theorem exists_const (U) (s : (tildeInModuleCat M).obj (op U)) (x : PrimeSpectrum.Top R)
(hx : x ∈ U) :
∃ (V : Opens (PrimeSpectrum.Top R)) (_ : x ∈ V) (i : V ⟶ U) (f : M) (g : R) (hg : _),
const M f g V hg = (tildeInModuleCat M).map i.op s :=
let ⟨V, hxV, iVU, f, g, hfg⟩ := s.2 ⟨x, hx⟩
⟨V, hxV, iVU, f, g, fun y hyV => (hfg ⟨y, hyV⟩).1, Subtype.eq <| funext fun y => by
obtain ⟨h1, (h2 : g • s.1 ⟨y, _⟩ = LocalizedModule.mk f 1)⟩ := hfg y
exact show LocalizedModule.mk f ⟨g, by exact h1⟩ = s.1 (iVU y) by
set x := s.1 (iVU y); change g • x = _ at h2; clear_value x
induction x using LocalizedModule.induction_on with
| h a b =>
rw [LocalizedModule.smul'_mk, LocalizedModule.mk_eq] at h2
obtain ⟨c, hc⟩ := h2
exact LocalizedModule.mk_eq.mpr ⟨c, by simpa using hc.symm⟩⟩
|
R : Type u
inst✝ : CommRing R
M : ModuleCat R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑(M.tildeInModuleCat.obj (op U))
x✝ : ↑(PrimeSpectrum.Top R)
hx : x✝ ∈ U
V : Opens ↑(PrimeSpectrum.Top R)
hxV : ↑⟨x✝, hx⟩ ∈ V
iVU : V ⟶ unop (op U)
f : ↑M
g : R
hfg :
∀ (x : ↥V),
g ∉ (↑x).asIdeal ∧ g • (fun x => ↑s (iVU x)) x = (LocalizedModule.mkLinearMap (↑x).asIdeal.primeCompl ↑M) f
y : ↥(unop (op V))
h1 : g ∉ (↑y).asIdeal
x : Localizations M ↑(iVU y)
h2 : g • x = LocalizedModule.mk f 1
⊢ LocalizedModule.mk f ⟨g, h1⟩ = x
|
induction x using LocalizedModule.induction_on with
| h a b =>
rw [LocalizedModule.smul'_mk, LocalizedModule.mk_eq] at h2
obtain ⟨c, hc⟩ := h2
exact LocalizedModule.mk_eq.mpr ⟨c, by simpa using hc.symm⟩
|
no goals
|
c4a16fba34ea7eba
|
Fin.Iio_last_eq_map
|
Mathlib/Data/Fintype/Fin.lean
|
theorem Iio_last_eq_map : Iio (Fin.last n) = Finset.univ.map Fin.castSuccEmb :=
coe_injective <| by ext; simp [lt_def]
|
n : ℕ
⊢ ↑(Iio (last n)) = ↑(map castSuccEmb univ)
|
ext
|
case h
n : ℕ
x✝ : Fin (n + 1)
⊢ x✝ ∈ ↑(Iio (last n)) ↔ x✝ ∈ ↑(map castSuccEmb univ)
|
5a0290270028545b
|
CategoryTheory.Adjunction.CommShift.compatibilityUnit_right
|
Mathlib/CategoryTheory/Shift/Adjunction.lean
|
/-- Given an adjunction `adj : F ⊣ G`, `a` in `A` and commutation isomorphisms
`e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a` and
`e₂ : shiftFunctor D a ⋙ G ≅ G ⋙ shiftFunctor C a`, if `e₁` and `e₂` are compatible with the
unit of the adjunction `adj`, then we get a formula for `e₂.inv` in terms of `e₁`.
-/
lemma compatibilityUnit_right (h : CompatibilityUnit adj e₁ e₂) (Y : D) :
e₂.inv.app Y = adj.unit.app _ ≫ G.map (e₁.hom.app _) ≫ G.map ((adj.counit.app _)⟦a⟧')
|
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_5, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
A : Type u_3
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : HasShift D A
a : A
e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a
e₂ : shiftFunctor D a ⋙ G ≅ G ⋙ shiftFunctor C a
h : CompatibilityUnit adj e₁ e₂
Y : D
⊢ e₂.inv.app Y =
adj.unit.app ((shiftFunctor C a).obj (G.obj Y)) ≫
G.map (e₁.hom.app (G.obj Y)) ≫ G.map ((shiftFunctor D a).map (adj.counit.app Y))
|
have := h (G.obj Y)
|
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_5, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
A : Type u_3
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : HasShift D A
a : A
e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a
e₂ : shiftFunctor D a ⋙ G ≅ G ⋙ shiftFunctor C a
h : CompatibilityUnit adj e₁ e₂
Y : D
this :
(shiftFunctor C a).map (adj.unit.app (G.obj Y)) =
adj.unit.app ((shiftFunctor C a).obj (G.obj Y)) ≫ G.map (e₁.hom.app (G.obj Y)) ≫ e₂.hom.app (F.obj (G.obj Y))
⊢ e₂.inv.app Y =
adj.unit.app ((shiftFunctor C a).obj (G.obj Y)) ≫
G.map (e₁.hom.app (G.obj Y)) ≫ G.map ((shiftFunctor D a).map (adj.counit.app Y))
|
929e4c22cc2da90b
|
Topology.IsScott.scottHausdorff_le
|
Mathlib/Topology/Order/ScottTopology.lean
|
lemma IsScott.scottHausdorff_le [IsScott α univ] :
scottHausdorff α univ ≤ ‹TopologicalSpace α›
|
α : Type u_1
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α univ
⊢ scottHausdorff α univ ≤ inst✝¹
|
rw [IsScott.topology_eq α univ, scott]
|
α : Type u_1
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α univ
⊢ scottHausdorff α univ ≤ upperSet α ⊔ scottHausdorff α univ
|
737e480bc3aa8fec
|
SimpleGraph.ComponentCompl.infinite_iff_in_all_ranges
|
Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
|
theorem infinite_iff_in_all_ranges {K : Finset V} (C : G.ComponentCompl K) :
C.supp.Infinite ↔ ∀ (L) (h : K ⊆ L), ∃ D : G.ComponentCompl L, D.hom h = C
|
case mpr
V : Type u
G : SimpleGraph V
K : Finset V
C : G.ComponentCompl ↑K
h : ∀ (L : Finset V) (h : K ⊆ L), ∃ D, hom h D = C
Cfin : C.supp.Finite
⊢ False
|
obtain ⟨D, e⟩ := h (K ∪ Cfin.toFinset) Finset.subset_union_left
|
case mpr.intro
V : Type u
G : SimpleGraph V
K : Finset V
C : G.ComponentCompl ↑K
h : ∀ (L : Finset V) (h : K ⊆ L), ∃ D, hom h D = C
Cfin : C.supp.Finite
D : G.ComponentCompl ↑(K ∪ Cfin.toFinset)
e : hom ⋯ D = C
⊢ False
|
7750b531648eedbf
|
Subfield.relrank_eq_rank_of_le
|
Mathlib/FieldTheory/Relrank.lean
|
theorem relrank_eq_rank_of_le (h : A ≤ B) : relrank A B = Module.rank A (extendScalars h)
|
E : Type v
inst✝ : Field E
A B : Subfield E
h : A ≤ B
this : A ⊓ B = A
⊢ Module.rank ↥(A ⊓ B) ↥(extendScalars ⋯) = Module.rank ↥A ↥(extendScalars h)
|
congr!
|
no goals
|
0f38d756ef028952
|
List.head_attach
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Attach.lean
|
theorem head_attach {xs : List α} (h) :
xs.attach.head h = ⟨xs.head (by simpa using h), head_mem (by simpa using h)⟩
|
case nil
α : Type u_1
h : [].attach ≠ []
⊢ [].attach.head h = ⟨[].head ⋯, ⋯⟩
|
simp at h
|
no goals
|
51ffd11ee9e3ea75
|
finrank_span_singleton
|
Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
|
theorem finrank_span_singleton {v : V} (hv : v ≠ 0) : finrank K (K ∙ v) = 1
|
case h
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ ↑⟨v, ⋯⟩ ≠ ↑0
|
simp [hv]
|
no goals
|
48480f47f7aa4f58
|
ProbabilityTheory.integrable_rpow_abs_mul_exp_add_of_integrable_exp_mul
|
Mathlib/Probability/Moments/IntegrableExpMul.lean
|
/-- If `exp ((v + t) * X)` and `exp ((v - t) * X)` are integrable
then for nonnegative `p : ℝ` and any `x ∈ [0, |t|)`,
`|X| ^ p * exp (v * X + x * |X|)` is integrable. -/
lemma integrable_rpow_abs_mul_exp_add_of_integrable_exp_mul {x : ℝ}
(h_int_pos : Integrable (fun ω ↦ exp ((v + t) * X ω)) μ)
(h_int_neg : Integrable (fun ω ↦ exp ((v - t) * X ω)) μ) (h_nonneg : 0 ≤ x) (hx : x < |t|)
{p : ℝ} (hp : 0 ≤ p) :
Integrable (fun a ↦ |X a| ^ p * exp (v * X a + x * |X a|)) μ
|
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t v x : ℝ
h_int_pos : Integrable (fun ω => rexp ((v + t) * X ω)) μ
h_int_neg : Integrable (fun ω => rexp ((v - t) * X ω)) μ
h_nonneg : 0 ≤ x
hx : x < |t|
p : ℝ
hp : 0 ≤ p
ht : t ≠ 0
hX : AEMeasurable X μ
a : Ω
⊢ |X a| ^ p * rexp (v * X a + x * |X a|) ≤ (p / (|t| - x)) ^ p * rexp (v * X a + |t| * |X a|)
|
simp_rw [exp_add, mul_comm (exp (v * X a)), ← mul_assoc]
|
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
t v x : ℝ
h_int_pos : Integrable (fun ω => rexp ((v + t) * X ω)) μ
h_int_neg : Integrable (fun ω => rexp ((v - t) * X ω)) μ
h_nonneg : 0 ≤ x
hx : x < |t|
p : ℝ
hp : 0 ≤ p
ht : t ≠ 0
hX : AEMeasurable X μ
a : Ω
⊢ |X a| ^ p * rexp (x * |X a|) * rexp (v * X a) ≤ (p / (|t| - x)) ^ p * rexp (|t| * |X a|) * rexp (v * X a)
|
6d408f5eb4922de2
|
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.lt_largerSubobject
|
Mathlib/CategoryTheory/Abelian/GrothendieckCategory/EnoughInjectives.lean
|
lemma lt_largerSubobject (A : Subobject X) (hA : A ≠ ⊤) :
A < largerSubobject hG A
|
C : Type u
inst✝¹ : Category.{v, u} C
G : C
inst✝ : Abelian C
hG : IsSeparator G
X : C
A : Subobject X
hA : A ≠ ⊤
⊢ A < ⋯.choose
|
exact (exists_larger_subobject hG A hA).choose_spec.choose
|
no goals
|
c90847f45ced9dc3
|
BitVec.getMsbD_rotateRight_of_lt
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem getMsbD_rotateRight_of_lt {w n m : Nat} {x : BitVec w} (hr : m < w) :
(x.rotateRight m).getMsbD n = (decide (n < w) && (if (n < m % w)
then x.getMsbD ((w + n - m % w) % w) else x.getMsbD (n - m % w)))
|
case neg
n m w : Nat
x : BitVec (w + 1)
hr : m < w + 1
h : ¬n < m
⊢ (decide (n < w + 1) && x.getMsbD (n - m)) =
(decide (n < w + 1) &&
if n < m % (w + 1) then x.getMsbD ((w + 1 + n - m % (w + 1)) % (w + 1)) else x.getMsbD (n - m % (w + 1)))
|
by_cases h₁ : n < w + 1
|
case pos
n m w : Nat
x : BitVec (w + 1)
hr : m < w + 1
h : ¬n < m
h₁ : n < w + 1
⊢ (decide (n < w + 1) && x.getMsbD (n - m)) =
(decide (n < w + 1) &&
if n < m % (w + 1) then x.getMsbD ((w + 1 + n - m % (w + 1)) % (w + 1)) else x.getMsbD (n - m % (w + 1)))
case neg
n m w : Nat
x : BitVec (w + 1)
hr : m < w + 1
h : ¬n < m
h₁ : ¬n < w + 1
⊢ (decide (n < w + 1) && x.getMsbD (n - m)) =
(decide (n < w + 1) &&
if n < m % (w + 1) then x.getMsbD ((w + 1 + n - m % (w + 1)) % (w + 1)) else x.getMsbD (n - m % (w + 1)))
|
446d3dd4304c7f2b
|
le_mul_inv_iff_le
|
Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
|
theorem le_mul_inv_iff_le : 1 ≤ a * b⁻¹ ↔ b ≤ a
|
α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : MulRightMono α
a b : α
⊢ 1 ≤ a * b⁻¹ ↔ b ≤ a
|
rw [← mul_le_mul_iff_right b, one_mul, inv_mul_cancel_right]
|
no goals
|
a94cf124ea788b34
|
ContinuousLinearEquiv.comp_right_differentiable_iff
|
Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
|
theorem comp_right_differentiable_iff {f : F → G} :
Differentiable 𝕜 (f ∘ iso) ↔ Differentiable 𝕜 f
|
𝕜 : 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
iso : E ≃L[𝕜] F
f : F → G
⊢ Differentiable 𝕜 (f ∘ ⇑iso) ↔ Differentiable 𝕜 f
|
simp only [← differentiableOn_univ, ← iso.comp_right_differentiableOn_iff, preimage_univ]
|
no goals
|
d7f6712b744022bd
|
Std.DHashMap.Internal.Raw₀.Const.getD_insertMany_empty_list_of_contains_eq_false
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/RawLemmas.lean
|
theorem getD_insertMany_empty_list_of_contains_eq_false [LawfulBEq α]
{l : List (α × β)} {k : α} {fallback : β}
(contains_eq_false : (l.map Prod.fst).contains k = false) :
getD (insertMany (empty : Raw₀ α (fun _ => β)) l) k fallback = fallback
|
α : Type u
inst✝² : BEq α
inst✝¹ : Hashable α
β : Type v
inst✝ : LawfulBEq α
l : List (α × β)
k : α
fallback : β
contains_eq_false : (List.map Prod.fst l).contains k = false
⊢ getD (insertMany empty l).val k fallback = fallback
|
rw [getD_insertMany_list_of_contains_eq_false _ Raw.WF.empty₀ contains_eq_false]
|
α : Type u
inst✝² : BEq α
inst✝¹ : Hashable α
β : Type v
inst✝ : LawfulBEq α
l : List (α × β)
k : α
fallback : β
contains_eq_false : (List.map Prod.fst l).contains k = false
⊢ getD empty k fallback = fallback
|
6e80c75e01ccffe2
|
Nat.pos_of_lt_mul_right
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
|
theorem pos_of_lt_mul_right {a b c : Nat} (h : a < b * c) : 0 < b
|
a b c : Nat
h : 0 < b * c
⊢ 0 < b
|
exact Nat.pos_of_mul_pos_right h
|
no goals
|
d9ecb2226b6aa123
|
Finset.Ico_union_Ico
|
Mathlib/Order/Interval/Finset/Basic.lean
|
theorem Ico_union_Ico {a b c d : α} (h₁ : min a b ≤ max c d) (h₂ : min c d ≤ max a b) :
Ico a b ∪ Ico c d = Ico (min a c) (max b d)
|
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a b c d : α
h₁ : a ⊓ b ≤ c ⊔ d
h₂ : c ⊓ d ≤ a ⊔ b
⊢ Ico a b ∪ Ico c d = Ico (a ⊓ c) (b ⊔ d)
|
rw [← coe_inj, coe_union, coe_Ico, coe_Ico, coe_Ico, Set.Ico_union_Ico h₁ h₂]
|
no goals
|
e71eda4f9f3352cf
|
OrthonormalBasis.det_to_matrix_orthonormalBasis_of_same_orientation
|
Mathlib/Analysis/InnerProductSpace/Orientation.lean
|
theorem det_to_matrix_orthonormalBasis_of_same_orientation
(h : e.toBasis.orientation = f.toBasis.orientation) : e.toBasis.det f = 1
|
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e f : OrthonormalBasis ι ℝ E
h : e.toBasis.orientation = f.toBasis.orientation
⊢ e.toBasis.det ⇑f = 1
|
apply (e.det_to_matrix_orthonormalBasis_real f).resolve_right
|
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e f : OrthonormalBasis ι ℝ E
h : e.toBasis.orientation = f.toBasis.orientation
⊢ ¬e.toBasis.det ⇑f = -1
|
851823c3b25d5435
|
exists_subset_affineIndependent_affineSpan_eq_top
|
Mathlib/LinearAlgebra/AffineSpace/Independent.lean
|
theorem exists_subset_affineIndependent_affineSpan_eq_top {s : Set P}
(h : AffineIndependent k (fun p => p : s → P)) :
∃ t : Set P, s ⊆ t ∧ AffineIndependent k (fun p => p : t → P) ∧ affineSpan k t = ⊤
|
case inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p₁ : P
h✝ : LinearIndependent k fun (v : ↑((fun p => p -ᵥ p₁) '' (s \ {p₁}))) => ↑v
h : LinearIndepOn k id ((fun p => p -ᵥ p₁) '' (s \ {p₁}))
hp₁ : p₁ ∈ s
bsv : Basis (↑(LinearIndepOn.extend h✝ ⋯)) k V := Basis.extend h✝
hsvi : LinearIndepOn k id (LinearIndepOn.extend h✝ ⋯)
hsvt : Submodule.span k (Set.range Subtype.val) = ⊤
hsv : (fun p => p -ᵥ p₁) '' (s \ {p₁}) ⊆ h.extend ⋯
⊢ ∃ t, s ⊆ t ∧ (AffineIndependent k fun p => ↑p) ∧ affineSpan k t = ⊤
|
have h0 : ∀ v : V, v ∈ h.extend (Set.subset_univ _) → v ≠ 0 := by
intro v hv
simpa [bsv] using bsv.ne_zero ⟨v, hv⟩
|
case inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p₁ : P
h✝ : LinearIndependent k fun (v : ↑((fun p => p -ᵥ p₁) '' (s \ {p₁}))) => ↑v
h : LinearIndepOn k id ((fun p => p -ᵥ p₁) '' (s \ {p₁}))
hp₁ : p₁ ∈ s
bsv : Basis (↑(LinearIndepOn.extend h✝ ⋯)) k V := Basis.extend h✝
hsvi : LinearIndepOn k id (LinearIndepOn.extend h✝ ⋯)
hsvt : Submodule.span k (Set.range Subtype.val) = ⊤
hsv : (fun p => p -ᵥ p₁) '' (s \ {p₁}) ⊆ h.extend ⋯
h0 : ∀ v ∈ h.extend ⋯, v ≠ 0
⊢ ∃ t, s ⊆ t ∧ (AffineIndependent k fun p => ↑p) ∧ affineSpan k t = ⊤
|
122f1472a0ca940a
|
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastAppend
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.lean
|
theorem denote_blastAppend (aig : AIG α) (target : AppendTarget aig newWidth)
(assign : α → Bool) :
∀ (idx : Nat) (hidx : idx < newWidth),
⟦
(blastAppend aig target).aig,
(blastAppend aig target).vec.get idx hidx,
assign
⟧
=
if hr : idx < target.rw then
⟦aig, target.rhs.get idx hr, assign⟧
else
have := target.h
⟦aig, target.lhs.get (idx - target.rw) (by omega), assign⟧
|
case mk.refl
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
assign : α → Bool
idx✝ lw✝ rw✝ : Nat
lw : aig.RefVec lw✝
rw : aig.RefVec rw✝
hidx✝ : idx✝ < rw✝ + lw✝
⊢ ⟦assign, { aig := aig, ref := if h : idx✝ < rw✝ then rw.get idx✝ h else lw.get (idx✝ - rw✝) ⋯ }⟧ =
if hr : idx✝ < rw✝ then ⟦assign, { aig := aig, ref := rw.get idx✝ hr }⟧
else ⟦assign, { aig := aig, ref := lw.get (idx✝ - rw✝) ⋯ }⟧
|
split <;> rfl
|
no goals
|
6e9237775dc6efbb
|
Decidable.List.Lex.ne_iff
|
Mathlib/Data/List/Lex.lean
|
theorem _root_.Decidable.List.Lex.ne_iff [DecidableEq α] {l₁ l₂ : List α}
(H : length l₁ ≤ length l₂) : Lex (· ≠ ·) l₁ l₂ ↔ l₁ ≠ l₂ :=
⟨to_ne, fun h => by
induction' l₁ with a l₁ IH generalizing l₂ <;> rcases l₂ with - | ⟨b, l₂⟩
· contradiction
· apply nil
· exact (not_lt_of_ge H).elim (succ_pos _)
· by_cases ab : a = b
· subst b
apply cons
exact IH (le_of_succ_le_succ H) (mt (congr_arg _) h)
· exact rel ab ⟩
|
case pos
α : Type u
inst✝ : DecidableEq α
a : α
l₁ : List α
IH : ∀ {l₂ : List α}, l₁.length ≤ l₂.length → l₁ ≠ l₂ → Lex (fun x1 x2 => x1 ≠ x2) l₁ l₂
b : α
l₂ : List α
H : (a :: l₁).length ≤ (b :: l₂).length
h : a :: l₁ ≠ b :: l₂
ab : a = b
⊢ Lex (fun x1 x2 => x1 ≠ x2) (a :: l₁) (b :: l₂)
|
subst b
|
case pos
α : Type u
inst✝ : DecidableEq α
a : α
l₁ : List α
IH : ∀ {l₂ : List α}, l₁.length ≤ l₂.length → l₁ ≠ l₂ → Lex (fun x1 x2 => x1 ≠ x2) l₁ l₂
l₂ : List α
H : (a :: l₁).length ≤ (a :: l₂).length
h : a :: l₁ ≠ a :: l₂
⊢ Lex (fun x1 x2 => x1 ≠ x2) (a :: l₁) (a :: l₂)
|
a44d94936aa5dbcc
|
Matrix.BlockTriangular.toBlock_inverse_mul_toBlock_eq_one
|
Mathlib/LinearAlgebra/Matrix/Block.lean
|
theorem BlockTriangular.toBlock_inverse_mul_toBlock_eq_one [LinearOrder α] [Invertible M]
(hM : BlockTriangular M b) (k : α) :
((M⁻¹.toBlock (fun i => b i < k) fun i => b i < k) *
M.toBlock (fun i => b i < k) fun i => b i < k) =
1
|
case a
α : Type u_1
m : Type u_3
R : Type v
M : Matrix m m R
b : m → α
inst✝⁴ : CommRing R
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : LinearOrder α
inst✝ : Invertible M
hM : M.BlockTriangular b
k : α
p : m → Prop := fun i => b i < k
h_sum : M⁻¹.toBlock p p * M.toBlock p p + (M⁻¹.toBlock p fun i => ¬p i) * M.toBlock (fun i => ¬p i) p = 1
i : { a // ¬p a }
j : { a // p a }
⊢ M.toBlock (fun i => ¬p i) p i j = 0 i j
|
simpa using hM (lt_of_lt_of_le j.2 (le_of_not_lt i.2))
|
no goals
|
f05aada380a2baba
|
convex_segment
|
Mathlib/Analysis/Convex/Basic.lean
|
theorem convex_segment (x y : E) : Convex 𝕜 [x -[𝕜] y]
|
𝕜 : Type u_1
E : Type u_2
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
x y : E
⊢ Convex 𝕜 [x-[𝕜]y]
|
rintro p ⟨ap, bp, hap, hbp, habp, rfl⟩ q ⟨aq, bq, haq, hbq, habq, rfl⟩ a b ha hb hab
|
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
x y : E
ap bp : 𝕜
hap : 0 ≤ ap
hbp : 0 ≤ bp
habp : ap + bp = 1
aq bq : 𝕜
haq : 0 ≤ aq
hbq : 0 ≤ bq
habq : aq + bq = 1
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • (ap • x + bp • y) + b • (aq • x + bq • y) ∈ [x-[𝕜]y]
|
757d93ea383d1ef8
|
Nat.shiftLeft'_tt_eq_mul_pow
|
Mathlib/Data/Nat/Size.lean
|
theorem shiftLeft'_tt_eq_mul_pow (m) : ∀ n, shiftLeft' true m n + 1 = (m + 1) * 2 ^ n
| 0 => by simp [shiftLeft', pow_zero, Nat.one_mul]
| k + 1 => by
rw [shiftLeft', bit_val, Bool.toNat_true, add_assoc, ← Nat.mul_add_one,
shiftLeft'_tt_eq_mul_pow m k, mul_left_comm, mul_comm 2, pow_succ]
|
m : ℕ
⊢ shiftLeft' true m 0 + 1 = (m + 1) * 2 ^ 0
|
simp [shiftLeft', pow_zero, Nat.one_mul]
|
no goals
|
f4c329a32e4a1345
|
DifferentiableWithinAt.rpow
|
Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
|
theorem DifferentiableWithinAt.rpow (hf : DifferentiableWithinAt ℝ f s x)
(hg : DifferentiableWithinAt ℝ g s x) (h : f x ≠ 0) :
DifferentiableWithinAt ℝ (fun x => f x ^ g x) s x
|
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : E → ℝ
x : E
s : Set E
hf : DifferentiableWithinAt ℝ f s x
hg : DifferentiableWithinAt ℝ g s x
h : f x ≠ 0
⊢ DifferentiableWithinAt ℝ (fun x => f x ^ g x) s x
|
exact (differentiableAt_rpow_of_ne (f x, g x) h).comp_differentiableWithinAt x (hf.prod hg)
|
no goals
|
1ed5555add232720
|
not_isOfFinOrder_of_injective_pow
|
Mathlib/GroupTheory/OrderOfElement.lean
|
theorem not_isOfFinOrder_of_injective_pow {x : G} (h : Injective fun n : ℕ => x ^ n) :
¬IsOfFinOrder x
|
G : Type u_1
inst✝ : Monoid G
x : G
h : Injective fun n => x ^ n
n : ℕ
hn_pos : 0 < n
hnx : x ^ n = 1
⊢ False
|
rw [← pow_zero x] at hnx
|
G : Type u_1
inst✝ : Monoid G
x : G
h : Injective fun n => x ^ n
n : ℕ
hn_pos : 0 < n
hnx : x ^ n = x ^ 0
⊢ False
|
ef4bd2a52e1e4d05
|
SimpleGraph.Walk.IsCycle.snd_ne_penultimate
|
Mathlib/Combinatorics/SimpleGraph/Path.lean
|
lemma IsCycle.snd_ne_penultimate {p : G.Walk u u} (hp : p.IsCycle) : p.snd ≠ p.penultimate
|
V : Type u
G : SimpleGraph V
u : V
p : G.Walk u u
hp : p.IsCycle
h : p.snd = p.penultimate
⊢ False
|
have := hp.three_le_length
|
V : Type u
G : SimpleGraph V
u : V
p : G.Walk u u
hp : p.IsCycle
h : p.snd = p.penultimate
this : 3 ≤ p.length
⊢ False
|
0a5276b29b15aedb
|
Int.units_ne_iff_eq_neg
|
Mathlib/Algebra/Ring/Int/Units.lean
|
lemma units_ne_iff_eq_neg {u v : ℤˣ} : u ≠ v ↔ u = -v
|
u v : ℤˣ
⊢ u ≠ v ↔ u = -v
|
simpa only [Ne, Units.ext_iff] using isUnit_ne_iff_eq_neg u.isUnit v.isUnit
|
no goals
|
dcd8c3a043f9047e
|
Real.toNNReal_rpow_of_nonneg
|
Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
|
theorem _root_.Real.toNNReal_rpow_of_nonneg {x y : ℝ} (hx : 0 ≤ x) :
Real.toNNReal (x ^ y) = Real.toNNReal x ^ y
|
x y : ℝ
hx : 0 ≤ x
⊢ (↑x.toNNReal ^ y).toNNReal = x.toNNReal ^ y
|
rw [← NNReal.coe_rpow, Real.toNNReal_coe]
|
no goals
|
3a7adf9d465f234e
|
PartENat.pos_iff_one_le
|
Mathlib/Data/Nat/PartENat.lean
|
theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x :=
PartENat.casesOn x
(by simp only [le_top, natCast_lt_top, ← @Nat.cast_zero PartENat])
fun n => by
rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]
rfl
|
x : PartENat
n : ℕ
⊢ 0 < n ↔ 1 ≤ n
|
rfl
|
no goals
|
1ba41efab5b17963
|
Real.quadratic_root_cos_pi_div_five
|
Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
|
theorem quadratic_root_cos_pi_div_five :
letI c := cos (π / 5)
4 * c ^ 2 - 2 * c - 1 = 0
|
θ : ℝ := π / 5
hθ : θ = π / 5
c : ℝ := cos θ
s : ℝ := sin θ
⊢ ∀ (n : ℤ), ↑n * π ≠ π / 5
|
intro n hn
|
θ : ℝ := π / 5
hθ : θ = π / 5
c : ℝ := cos θ
s : ℝ := sin θ
n : ℤ
hn : ↑n * π = π / 5
⊢ False
|
9a015197b0eb09bb
|
CategoryTheory.Localization.Construction.morphismProperty_is_top
|
Mathlib/CategoryTheory/Localization/Construction.lean
|
theorem morphismProperty_is_top (P : MorphismProperty W.Localization)
[P.IsStableUnderComposition] (hP₁ : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f))
(hP₂ : ∀ ⦃X Y : C⦄ (w : X ⟶ Y) (hw : W w), P (wInv w hw)) :
P = ⊤
|
case h.h.h.a.mp
C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
P : MorphismProperty W.Localization
inst✝ : P.IsStableUnderComposition
hP₁ : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f)
hP₂ : ∀ ⦃X Y : C⦄ (w : X ⟶ Y) (hw : W w), P (wInv w hw)
X Y : W.Localization
f : X ⟶ Y
a✝ : P f
⊢ ⊤ f
|
apply MorphismProperty.top_apply
|
no goals
|
bfd1f03091fbe383
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.denote_blastDivSubtractShift_q
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.lean
|
theorem denote_blastDivSubtractShift_q (aig : AIG α) (assign : α → Bool) (lhs rhs : BitVec w)
(falseRef trueRef : AIG.Ref aig) (n d : AIG.RefVec aig w) (wn wr : Nat)
(q r : AIG.RefVec aig w) (qbv rbv : BitVec w)
(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),
⟦
(blastDivSubtractShift aig falseRef trueRef n d wn wr q r).aig,
(blastDivSubtractShift aig falseRef trueRef n d wn wr q r).q.get idx hidx,
assign
⟧
=
(BitVec.divSubtractShift { n := lhs, d := rhs } { wn := wn, wr := wr, q := qbv, r := rbv }).q.getLsbD idx
|
case hright
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
assign : α → Bool
lhs rhs : BitVec w
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
qbv rbv : BitVec w
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
idx : Nat
hidx : idx < w
⊢ ⟦assign,
{
aig :=
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig,
ref :=
{
gate :=
({
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }.rhs.get
idx hidx).gate,
hgate := ?hright } }⟧ =
rhs.getLsbD idx
case hright
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
assign : α → Bool
lhs rhs : BitVec w
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
qbv rbv : BitVec w
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
idx : Nat
hidx : idx < w
⊢ ({ lhs := (((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast ⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }.rhs.get
idx hidx).gate <
(blastShiftConcat (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig
{ lhs := q.cast ⋯, bit := falseRef.cast ⋯ }).aig.decls.size
|
rw [AIG.LawfulVecOperator.denote_mem_prefix (f := blastShiftConcat)]
|
case hright
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
assign : α → Bool
lhs rhs : BitVec w
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
qbv rbv : BitVec w
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
idx : Nat
hidx : idx < w
⊢ ⟦assign,
{ aig := (blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig,
ref :=
{
gate :=
({
lhs :=
(((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast
⋯).cast
⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }.rhs.get
idx hidx).gate,
hgate := ?hright } }⟧ =
rhs.getLsbD idx
case hright
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
assign : α → Bool
lhs rhs : BitVec w
falseRef trueRef : aig.Ref
n d : aig.RefVec w
wn wr : Nat
q r : aig.RefVec w
qbv rbv : BitVec w
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
idx : Nat
hidx : idx < w
⊢ ({ lhs := (((blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).vec.cast ⋯).cast ⋯).cast ⋯,
rhs := (((d.cast ⋯).cast ⋯).cast ⋯).cast ⋯ }.rhs.get
idx hidx).gate <
(blastShiftConcat aig { lhs := r, bit := n.getD (wn - 1) falseRef }).aig.decls.size
|
11112d18501f0fd9
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastZeroExtend.go_denote_mem_prefix
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.lean
|
theorem go_denote_mem_prefix (aig : AIG α) (w : Nat) (input : AIG.RefVec aig w) (newWidth curr : Nat)
(hcurr : curr ≤ newWidth) (s : AIG.RefVec aig curr) (start : Nat) (hstart) :
⟦
(go aig w input newWidth curr hcurr s).aig,
⟨start, by apply Nat.lt_of_lt_of_le; exact hstart; apply go_le_size⟩,
assign
⟧
=
⟦aig, ⟨start, hstart⟩, assign⟧
|
case hprefix.size_le
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
assign : α → Bool
aig : AIG α
w : Nat
input : aig.RefVec w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefVec curr
start : Nat
hstart : start < aig.decls.size
⊢ { aig := aig, ref := { gate := start, hgate := hstart } }.aig.decls.size ≤
(go aig w input newWidth curr hcurr s).aig.decls.size
|
apply go_le_size
|
no goals
|
1678e18958c48989
|
CategoryTheory.ShortComplex.exact_iff_surjective_abToCycles
|
Mathlib/Algebra/Homology/ShortComplex/Ab.lean
|
lemma exact_iff_surjective_abToCycles :
S.Exact ↔ Function.Surjective S.abToCycles
|
S : ShortComplex Ab
⊢ S.Exact ↔ Function.Surjective ⇑S.abToCycles
|
rw [S.abLeftHomologyData.exact_iff_epi_f', abLeftHomologyData_f',
AddCommGrp.epi_iff_surjective]
|
S : ShortComplex Ab
⊢ Function.Surjective ⇑(ConcreteCategory.hom (AddCommGrp.ofHom S.abToCycles)) ↔ Function.Surjective ⇑S.abToCycles
|
41fd2613a593a33d
|
Finset.noncommProd_induction
|
Mathlib/Data/Finset/NoncommProd.lean
|
@[to_additive]
lemma noncommProd_induction (s : Finset α) (f : α → β) (comm)
(p : β → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p (f x)) :
p (s.noncommProd f comm)
|
α : Type u_3
β : Type u_4
inst✝ : Monoid β
s : Finset α
f : α → β
comm : (↑s).Pairwise (Commute on f)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
⊢ p (s.noncommProd f comm)
|
refine Multiset.noncommProd_induction _ _ _ hom unit fun b hb ↦ ?_
|
α : Type u_3
β : Type u_4
inst✝ : Monoid β
s : Finset α
f : α → β
comm : (↑s).Pairwise (Commute on f)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
b : β
hb : b ∈ Multiset.map f s.val
⊢ p b
|
a8fc2db953f6e503
|
MeasureTheory.hitting_le_iff_of_exists
|
Mathlib/Probability/Process/HittingTime.lean
|
theorem hitting_le_iff_of_exists [WellFoundedLT ι] {m : ι}
(h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s
|
case mpr.intro.intro
Ω : Type u_1
β : Type u_2
ι : Type u_3
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : WellFoundedLT ι
m : ι
h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s
h' : ∃ j ∈ Set.Icc n i, u j ω ∈ s
k : ι
hk₁ : k ∈ Set.Icc n (m ⊓ i)
hk₂ : u k ω ∈ s
⊢ hitting u s n m ω ≤ i
|
refine le_trans ?_ (hk₁.2.trans (min_le_right _ _))
|
case mpr.intro.intro
Ω : Type u_1
β : Type u_2
ι : Type u_3
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : WellFoundedLT ι
m : ι
h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s
h' : ∃ j ∈ Set.Icc n i, u j ω ∈ s
k : ι
hk₁ : k ∈ Set.Icc n (m ⊓ i)
hk₂ : u k ω ∈ s
⊢ hitting u s n m ω ≤ k
|
6e57d46d60229728
|
PartialHomeomorph.contDiffAt_symm
|
Mathlib/Analysis/Calculus/ContDiff/Operations.lean
|
theorem PartialHomeomorph.contDiffAt_symm [CompleteSpace E] (f : PartialHomeomorph E F)
{f₀' : E ≃L[𝕜] F} {a : F} (ha : a ∈ f.target)
(hf₀' : HasFDerivAt f (f₀' : E →L[𝕜] F) (f.symm a)) (hf : ContDiffAt 𝕜 n f (f.symm a)) :
ContDiffAt 𝕜 n f.symm a
|
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type uF
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
n✝ : WithTop ℕ∞
inst✝ : CompleteSpace E
f : PartialHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑f.symm a)
n : ℕ
IH : ContDiffAt 𝕜 (↑↑n) (↑f) (↑f.symm a) → ContDiffAt 𝕜 (↑↑n) (↑f.symm) a
hf : ContDiffAt 𝕜 (↑↑n.succ) (↑f) (↑f.symm a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑f.symm a)
u : Set E
hu : u ∈ 𝓝 (↑f.symm a)
hff' : ∀ x ∈ u, HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑f.symm a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑f.symm a))
⊢ ContDiffAt 𝕜 (↑n) (↑f.symm) a
|
refine IH (hf.of_le ?_)
|
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type uF
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
n✝ : WithTop ℕ∞
inst✝ : CompleteSpace E
f : PartialHomeomorph E F
f₀' : E ≃L[𝕜] F
a : F
ha : a ∈ f.target
hf₀' : HasFDerivAt (↑f) (↑f₀') (↑f.symm a)
n : ℕ
IH : ContDiffAt 𝕜 (↑↑n) (↑f) (↑f.symm a) → ContDiffAt 𝕜 (↑↑n) (↑f.symm) a
hf : ContDiffAt 𝕜 (↑↑n.succ) (↑f) (↑f.symm a)
f' : E → E →L[𝕜] F
hf' : ContDiffAt 𝕜 (↑n) f' (↑f.symm a)
u : Set E
hu : u ∈ 𝓝 (↑f.symm a)
hff' : ∀ x ∈ u, HasFDerivAt (↑f) (f' x) x
eq_f₀' : f' (↑f.symm a) = ↑f₀'
h_deriv₁ : ContDiffAt 𝕜 (↑n) inverse (f' (↑f.symm a))
⊢ ↑↑n ≤ ↑↑n.succ
|
db52077be919f1af
|
Module.exists_nontrivial_relation_sum_zero_of_finrank_succ_lt_card
|
Mathlib/LinearAlgebra/Dimension/Finite.lean
|
theorem Module.exists_nontrivial_relation_sum_zero_of_finrank_succ_lt_card
{t : Finset M} (h : finrank R M + 1 < t.card) :
∃ f : M → R, ∑ e ∈ t, f e • e = 0 ∧ ∑ e ∈ t, f e = 0 ∧ ∃ x ∈ t, f x ≠ 0
|
case intro
R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module.Finite R M
inst✝ : StrongRankCondition R
t : Finset M
h : finrank R M + 1 < #t
x₀ : M
x₀_mem : x₀ ∈ t
shift : M ↪ M := { toFun := fun x => x - x₀, inj' := ⋯ }
t' : Finset M := Finset.map shift (t.erase x₀)
h' : finrank R M < #t'
⊢ ∃ f, ∑ e ∈ t, f e • e = 0 ∧ ∑ e ∈ t, f e = 0 ∧ ∃ x ∈ t, f x ≠ 0
|
obtain ⟨g, gsum, x₁, x₁_mem, nz⟩ := exists_nontrivial_relation_of_finrank_lt_card h'
|
case intro.intro.intro.intro.intro
R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module.Finite R M
inst✝ : StrongRankCondition R
t : Finset M
h : finrank R M + 1 < #t
x₀ : M
x₀_mem : x₀ ∈ t
shift : M ↪ M := { toFun := fun x => x - x₀, inj' := ⋯ }
t' : Finset M := Finset.map shift (t.erase x₀)
h' : finrank R M < #t'
g : M → R
gsum : ∑ e ∈ t', g e • e = 0
x₁ : M
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
⊢ ∃ f, ∑ e ∈ t, f e • e = 0 ∧ ∑ e ∈ t, f e = 0 ∧ ∃ x ∈ t, f x ≠ 0
|
9ccb45a24efab47f
|
List.length_sym
|
Mathlib/Data/List/Sym.lean
|
theorem length_sym {n : ℕ} {xs : List α} :
(xs.sym n).length = Nat.multichoose xs.length n :=
match n, xs with
| 0, _ => by rw [List.sym, Nat.multichoose]; rfl
| n + 1, [] => by simp [List.sym]
| n + 1, x :: xs => by
rw [List.sym, length_append, length_map, length_cons]
rw [@length_sym n (x :: xs), @length_sym (n + 1) xs]
rw [Nat.multichoose_succ_succ, length_cons, add_comm]
|
α : Type u_1
n : ℕ
xs x✝ : List α
⊢ [Sym.nil].length = 1
|
rfl
|
no goals
|
def3512bb619a560
|
ltTrichotomy_eq_iff
|
Mathlib/Order/Basic.lean
|
lemma ltTrichotomy_eq_iff : ltTrichotomy x y p q r = s ↔
(x < y ∧ p = s) ∨ (x = y ∧ q = s) ∨ (y < x ∧ r = s)
|
case refine_3
α : Type u_2
inst✝ : LinearOrder α
P : Sort u_5
x y : α
p q r s : P
h : y < x
⊢ ltTrichotomy x y p q r = s ↔ x < y ∧ p = s ∨ x = y ∧ q = s ∨ y < x ∧ r = s
|
simp only [ltTrichotomy_gt, false_and, true_and, false_or, h, h.not_lt, h.ne']
|
no goals
|
2bb4e93ee92100a9
|
RootPairing.rootForm_self_smul_coroot
|
Mathlib/LinearAlgebra/RootSystem/Finite/CanonicalBilinear.lean
|
/-- This is SGA3 XXI Lemma 1.2.1 (10), key for proving nondegeneracy and positivity. -/
lemma rootForm_self_smul_coroot (i : ι) :
(P.RootForm (P.root i) (P.root i)) • P.coroot i = 2 • P.Polarization (P.root i)
|
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
inst✝ : Fintype ι
i : ι
⊢ P.Polarization (P.root i) = ∑ j : ι, P.pairing i ((P.reflection_perm i) j) • P.coroot ((P.reflection_perm i) j)
|
simp_rw [Polarization_apply, root_coroot'_eq_pairing]
|
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
P : RootPairing ι R M N
inst✝ : Fintype ι
i : ι
⊢ ∑ x : ι, P.pairing i x • P.coroot x =
∑ j : ι, P.pairing i ((P.reflection_perm i) j) • P.coroot ((P.reflection_perm i) j)
|
b31518e23e6e08dd
|
LocallyBoundedMap.cancel_left
|
Mathlib/Topology/Bornology/Hom.lean
|
theorem cancel_left {g : LocallyBoundedMap β γ} {f₁ f₂ : LocallyBoundedMap α β} (hg : Injective g) :
g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ :=
⟨fun h => ext fun a => hg <| by rw [← comp_apply, h, comp_apply], congr_arg _⟩
|
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : Bornology γ
g : LocallyBoundedMap β γ
f₁ f₂ : LocallyBoundedMap α β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
|
rw [← comp_apply, h, comp_apply]
|
no goals
|
bf1a3367323999d8
|
Real.sin_bound
|
Mathlib/Data/Complex/Trigonometric.lean
|
theorem sin_bound {x : ℝ} (hx : |x| ≤ 1) : |sin x - (x - x ^ 3 / 6)| ≤ |x| ^ 4 * (5 / 96) :=
calc
|sin x - (x - x ^ 3 / 6)| = ‖Complex.sin x - (x - x ^ 3 / 6 : ℝ)‖
|
x : ℝ
hx : |x| ≤ 1
⊢ ‖(cexp (-↑x * I) - ∑ m ∈ range 4, (-↑x * I) ^ m / ↑m.factorial -
(cexp (↑x * I) - ∑ m ∈ range 4, (↑x * I) ^ m / ↑m.factorial)) *
I /
2‖ ≤
‖(cexp (-↑x * I) - ∑ m ∈ range 4, (-↑x * I) ^ m / ↑m.factorial) * I / 2‖ +
‖-((cexp (↑x * I) - ∑ m ∈ range 4, (↑x * I) ^ m / ↑m.factorial) * I) / 2‖
|
rw [sub_mul, sub_eq_add_neg, add_div]
|
x : ℝ
hx : |x| ≤ 1
⊢ ‖(cexp (-↑x * I) - ∑ m ∈ range 4, (-↑x * I) ^ m / ↑m.factorial) * I / 2 +
-((cexp (↑x * I) - ∑ m ∈ range 4, (↑x * I) ^ m / ↑m.factorial) * I) / 2‖ ≤
‖(cexp (-↑x * I) - ∑ m ∈ range 4, (-↑x * I) ^ m / ↑m.factorial) * I / 2‖ +
‖-((cexp (↑x * I) - ∑ m ∈ range 4, (↑x * I) ^ m / ↑m.factorial) * I) / 2‖
|
c2aa302ba94aae5a
|
OrderEmbedding.image_Ioi
|
Mathlib/Order/UpperLower/Basic.lean
|
theorem OrderEmbedding.image_Ioi (e : α ↪o β) (he : IsUpperSet (range e)) (a : α) :
e '' Ioi a = Ioi (e a)
|
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ↪o β
he : IsUpperSet (range ⇑e)
a : α
⊢ ⇑e '' Ioi a = Ioi (e a)
|
rw [← e.preimage_Ioi, image_preimage_eq_inter_range,
inter_eq_left.2 <| he.Ioi_subset (mem_range_self _)]
|
no goals
|
d05cf5b2d12bdba7
|
MvPolynomial.coeff_map
|
Mathlib/Algebra/MvPolynomial/Eval.lean
|
theorem coeff_map (p : MvPolynomial σ R) : ∀ m : σ →₀ ℕ, coeff m (map f p) = f (coeff m p)
|
case h_add
R : Type u
S₁ : Type v
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
f : R →+* S₁
p q : MvPolynomial σ R
hp : ∀ (m : σ →₀ ℕ), coeff m ((map f) p) = f (coeff m p)
hq : ∀ (m : σ →₀ ℕ), coeff m ((map f) q) = f (coeff m q)
m : σ →₀ ℕ
⊢ coeff m ((map f) (p + q)) = f (coeff m (p + q))
|
simp only [hp, hq, (map f).map_add, coeff_add]
|
case h_add
R : Type u
S₁ : Type v
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
f : R →+* S₁
p q : MvPolynomial σ R
hp : ∀ (m : σ →₀ ℕ), coeff m ((map f) p) = f (coeff m p)
hq : ∀ (m : σ →₀ ℕ), coeff m ((map f) q) = f (coeff m q)
m : σ →₀ ℕ
⊢ f (coeff m p) + f (coeff m q) = f (coeff m p + coeff m q)
|
4d9796f81242803c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.