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
|
|---|---|---|---|---|---|---|
PrimeSpectrum.zeroLocus_empty_of_one_mem
|
Mathlib/RingTheory/Spectrum/Prime/Basic.lean
|
theorem zeroLocus_empty_of_one_mem {s : Set R} (h : (1 : R) ∈ s) : zeroLocus s = ∅
|
R : Type u
inst✝ : CommSemiring R
s : Set R
h : 1 ∈ s
x : PrimeSpectrum R
hx : s ⊆ ↑x.asIdeal
x_prime : x.asIdeal.IsPrime
⊢ 1 ∈ x.asIdeal
|
exact hx h
|
no goals
|
5067e5311eeaeb23
|
Set.image_seq
|
Mathlib/Data/Set/Lattice.lean
|
theorem image_seq {f : β → γ} {s : Set (α → β)} {t : Set α} :
f '' seq s t = seq ((f ∘ ·) '' s) t
|
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → γ
s : Set (α → β)
t : Set α
⊢ f '' s.seq t = ((fun x => f ∘ x) '' s).seq t
|
simp only [seq, image_image2, image2_image_left, comp_apply]
|
no goals
|
f3a68a90ab8ae5d5
|
contMDiffWithinAt_iff_target
|
Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
|
theorem contMDiffWithinAt_iff_target :
ContMDiffWithinAt I I' n f s x ↔
ContinuousWithinAt f s x ∧ ContMDiffWithinAt I 𝓘(𝕜, E') n (extChartAt I' (f x) ∘ f) s x
|
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁷ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝² : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
f : M → M'
s : Set M
x : M
n : WithTop ℕ∞
⊢ ContinuousWithinAt f s x ∧
ContDiffWithinAtProp I I' n (↑(chartAt H' (f x)) ∘ f ∘ ↑(chartAt H x).symm) (↑(chartAt H x).symm ⁻¹' s)
(↑(chartAt H x) x) ↔
(ContinuousWithinAt f s x ∧ ContinuousWithinAt (↑(extChartAt I' (f x)) ∘ f) s x) ∧
ContDiffWithinAtProp I 𝓘(𝕜, E') n
(↑(chartAt E' ((↑(extChartAt I' (f x)) ∘ f) x)) ∘ (↑(extChartAt I' (f x)) ∘ f) ∘ ↑(chartAt H x).symm)
(↑(chartAt H x).symm ⁻¹' s) (↑(chartAt H x) x)
|
have cont :
ContinuousWithinAt f s x ∧ ContinuousWithinAt (extChartAt I' (f x) ∘ f) s x ↔
ContinuousWithinAt f s x :=
and_iff_left_of_imp <| (continuousAt_extChartAt _).comp_continuousWithinAt
|
𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁷ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace H M
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝² : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
f : M → M'
s : Set M
x : M
n : WithTop ℕ∞
cont : ContinuousWithinAt f s x ∧ ContinuousWithinAt (↑(extChartAt I' (f x)) ∘ f) s x ↔ ContinuousWithinAt f s x
⊢ ContinuousWithinAt f s x ∧
ContDiffWithinAtProp I I' n (↑(chartAt H' (f x)) ∘ f ∘ ↑(chartAt H x).symm) (↑(chartAt H x).symm ⁻¹' s)
(↑(chartAt H x) x) ↔
(ContinuousWithinAt f s x ∧ ContinuousWithinAt (↑(extChartAt I' (f x)) ∘ f) s x) ∧
ContDiffWithinAtProp I 𝓘(𝕜, E') n
(↑(chartAt E' ((↑(extChartAt I' (f x)) ∘ f) x)) ∘ (↑(extChartAt I' (f x)) ∘ f) ∘ ↑(chartAt H x).symm)
(↑(chartAt H x).symm ⁻¹' s) (↑(chartAt H x) x)
|
5708dc3777c22e45
|
Polynomial.quotient_mk_comp_C_isIntegral_of_isJacobsonRing
|
Mathlib/RingTheory/Jacobson/Ring.lean
|
theorem quotient_mk_comp_C_isIntegral_of_isJacobsonRing :
((Ideal.Quotient.mk P).comp C : R →+* R[X] ⧸ P).IsIntegral
|
R : Type u_1
inst✝¹ : CommRing R
P : Ideal R[X]
hP : P.IsMaximal
inst✝ : IsJacobsonRing R
P' : Ideal R := comap C P
this : P'.IsPrime
f : R[X] →+* (R ⧸ P')[X] := mapRingHom (Ideal.Quotient.mk P')
hf : Function.Surjective ⇑f
p : R[X]
hp : p ∈ comap f ⊥
n : ℕ
⊢ (Ideal.Quotient.mk (comap C P)) (p.coeff n) = 0
|
simpa only [f, coeff_map, coe_mapRingHom] using (Polynomial.ext_iff.mp hp) n
|
no goals
|
a0c73d64ce92331e
|
ENNReal.lt_iff_exists_rat_btwn
|
Mathlib/Data/ENNReal/Basic.lean
|
theorem lt_iff_exists_rat_btwn :
a < b ↔ ∃ q : ℚ, 0 ≤ q ∧ a < Real.toNNReal q ∧ (Real.toNNReal q : ℝ≥0∞) < b :=
⟨fun h => by
rcases lt_iff_exists_coe.1 h with ⟨p, rfl, _⟩
rcases exists_between h with ⟨c, pc, cb⟩
rcases lt_iff_exists_coe.1 cb with ⟨r, rfl, _⟩
rcases (NNReal.lt_iff_exists_rat_btwn _ _).1 (coe_lt_coe.1 pc) with ⟨q, hq0, pq, qr⟩
exact ⟨q, hq0, coe_lt_coe.2 pq, lt_trans (coe_lt_coe.2 qr) cb⟩,
fun ⟨_, _, qa, qb⟩ => lt_trans qa qb⟩
|
case intro.intro.intro.intro.intro.intro.intro.intro.intro
b : ℝ≥0∞
p : ℝ≥0
right✝¹ h : ↑p < b
r : ℝ≥0
right✝ : ↑r < b
pc : ↑p < ↑r
cb : ↑r < b
q : ℚ
hq0 : 0 ≤ q
pq : p < (↑q).toNNReal
qr : (↑q).toNNReal < r
⊢ ∃ q, 0 ≤ q ∧ ↑p < ↑(↑q).toNNReal ∧ ↑(↑q).toNNReal < b
|
exact ⟨q, hq0, coe_lt_coe.2 pq, lt_trans (coe_lt_coe.2 qr) cb⟩
|
no goals
|
aae9f40da5b98e1c
|
ProbabilityTheory.Kernel.comp_add_right
|
Mathlib/Probability/Kernel/Composition/Comp.lean
|
lemma comp_add_right (μ κ : Kernel α β) (η : Kernel β γ) :
η ∘ₖ (μ + κ) = η ∘ₖ μ + η ∘ₖ κ
|
case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
μ κ : Kernel α β
η : Kernel β γ
a✝ : α
s✝ : Set γ
hs : MeasurableSet s✝
⊢ ((η ∘ₖ (μ + κ)) a✝) s✝ = ((η ∘ₖ μ + η ∘ₖ κ) a✝) s✝
|
simp [comp_apply' _ _ _ hs]
|
no goals
|
79efe5ce49ef166d
|
BooleanRing.neg_eq
|
Mathlib/Algebra/Ring/BooleanRing.lean
|
theorem neg_eq : -a = a :=
calc
-a = -a + 0
|
α : Type u_1
inst✝ : BooleanRing α
a : α
⊢ -a + 0 = -a + -a + a
|
rw [← neg_add_cancel, add_assoc]
|
no goals
|
b77c191f3c8acf07
|
MeasureTheory.integral_eq_lintegral_of_nonneg_ae
|
Mathlib/MeasureTheory/Integral/Bochner.lean
|
theorem integral_eq_lintegral_of_nonneg_ae {f : α → ℝ} (hf : 0 ≤ᵐ[μ] f)
(hfm : AEStronglyMeasurable f μ) :
∫ a, f a ∂μ = ENNReal.toReal (∫⁻ a, ENNReal.ofReal (f a) ∂μ)
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : 0 ≤ᶠ[ae μ] f
hfm : AEStronglyMeasurable f μ
hfi : Integrable f μ
⊢ AEMeasurable (fun a => ENNReal.ofReal (-f a)) μ
|
exact measurable_ofReal.comp_aemeasurable hfm.aemeasurable.neg
|
no goals
|
d2ae86a5dd2a5d0c
|
BitVec.shiftLeft_ushiftRight
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem shiftLeft_ushiftRight {x : BitVec w} {n : Nat}:
x >>> n <<< n = x &&& BitVec.allOnes w <<< n
|
case neg
w n : Nat
ih : ∀ {x : BitVec w}, x >>> n <<< n = x &&& allOnes w <<< n
x : BitVec w
i : Nat
h : i < w
hw : ¬w = 0
⊢ (x >>> 1 <<< 1 &&& allOnes w <<< n <<< 1).getLsbD i = (x &&& allOnes w <<< n <<< 1).getLsbD i
|
by_cases hi₂ : i = 0
|
case pos
w n : Nat
ih : ∀ {x : BitVec w}, x >>> n <<< n = x &&& allOnes w <<< n
x : BitVec w
i : Nat
h : i < w
hw : ¬w = 0
hi₂ : i = 0
⊢ (x >>> 1 <<< 1 &&& allOnes w <<< n <<< 1).getLsbD i = (x &&& allOnes w <<< n <<< 1).getLsbD i
case neg
w n : Nat
ih : ∀ {x : BitVec w}, x >>> n <<< n = x &&& allOnes w <<< n
x : BitVec w
i : Nat
h : i < w
hw : ¬w = 0
hi₂ : ¬i = 0
⊢ (x >>> 1 <<< 1 &&& allOnes w <<< n <<< 1).getLsbD i = (x &&& allOnes w <<< n <<< 1).getLsbD i
|
d74277fca2e60b6a
|
norm_mahler_eq
|
Mathlib/NumberTheory/Padics/MahlerBasis.lean
|
/--
The uniform norm of the `k`-th Mahler basis function is 1, for every `k`.
-/
@[simp] lemma norm_mahler_eq (k : ℕ) : ‖(mahler k : C(ℤ_[p], ℚ_[p]))‖ = 1
|
p : ℕ
hp : Fact (Nat.Prime p)
k : ℕ
⊢ ‖mahler k‖ = 1
|
apply le_antisymm
|
case a
p : ℕ
hp : Fact (Nat.Prime p)
k : ℕ
⊢ ‖mahler k‖ ≤ 1
case a
p : ℕ
hp : Fact (Nat.Prime p)
k : ℕ
⊢ 1 ≤ ‖mahler k‖
|
bf8ddaaf139299df
|
ComplexShape.Embedding.r_eq_some
|
Mathlib/Algebra/Homology/Embedding/Basic.lean
|
lemma r_eq_some {i : ι} {i' : ι'} (hi : e.f i = i') :
e.r i' = some i
|
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
⊢ e.r i' = some i
|
have h : ∃ (i : ι), e.f i = i' := ⟨i, hi⟩
|
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
i : ι
i' : ι'
hi : e.f i = i'
h : ∃ i, e.f i = i'
⊢ e.r i' = some i
|
a68fee8f05e51fd2
|
Filter.exists_seq_monotone_tendsto_atTop_atTop
|
Mathlib/Order/Filter/AtTopBot/CountablyGenerated.lean
|
theorem exists_seq_monotone_tendsto_atTop_atTop (α : Type*) [Preorder α] [Nonempty α]
[IsDirected α (· ≤ ·)] [(atTop : Filter α).IsCountablyGenerated] :
∃ xs : ℕ → α, Monotone xs ∧ Tendsto xs atTop atTop
|
case intro.refine_2
α : Type u_3
inst✝³ : Preorder α
inst✝² : Nonempty α
inst✝¹ : IsDirected α fun x1 x2 => x1 ≤ x2
inst✝ : atTop.IsCountablyGenerated
ys : ℕ → α
h : Tendsto ys atTop atTop
c : α → α → α
hleft : ∀ (a b : α), a ≤ c a b
hright : ∀ (a b : α), b ≤ c a b
xs : ℕ → α := fun n => List.foldl (fun x n => c x (ys n)) (ys 0) (List.range n)
hsucc : ∀ (n : ℕ), xs (n + 1) = c (xs n) (ys n)
n : ℕ
⊢ ys n ≤ xs (n + 1)
|
rw [hsucc]
|
case intro.refine_2
α : Type u_3
inst✝³ : Preorder α
inst✝² : Nonempty α
inst✝¹ : IsDirected α fun x1 x2 => x1 ≤ x2
inst✝ : atTop.IsCountablyGenerated
ys : ℕ → α
h : Tendsto ys atTop atTop
c : α → α → α
hleft : ∀ (a b : α), a ≤ c a b
hright : ∀ (a b : α), b ≤ c a b
xs : ℕ → α := fun n => List.foldl (fun x n => c x (ys n)) (ys 0) (List.range n)
hsucc : ∀ (n : ℕ), xs (n + 1) = c (xs n) (ys n)
n : ℕ
⊢ ys n ≤ c (xs n) (ys n)
|
cfd85fba236c098c
|
ZMod.Ico_map_valMinAbs_natAbs_eq_Ico_map_id
|
Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean
|
theorem Ico_map_valMinAbs_natAbs_eq_Ico_map_id (p : ℕ) [hp : Fact p.Prime] (a : ZMod p)
(hap : a ≠ 0) : ((Ico 1 (p / 2).succ).1.map fun (x : ℕ) => (a * x).valMinAbs.natAbs) =
(Ico 1 (p / 2).succ).1.map fun a => a
|
p : ℕ
hp : Fact (Nat.Prime p)
a : ZMod p
hap : a ≠ 0
he : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → x ≠ 0 ∧ x ≤ p / 2
hep : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → x < p
hpe : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → ¬p ∣ x
⊢ ∀ x ∈ Ico 1 (p / 2).succ, (a * ↑x).valMinAbs.natAbs ∈ Ico 1 (p / 2).succ
|
intro x hx
|
p : ℕ
hp : Fact (Nat.Prime p)
a : ZMod p
hap : a ≠ 0
he : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → x ≠ 0 ∧ x ≤ p / 2
hep : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → x < p
hpe : ∀ {x : ℕ}, x ∈ Ico 1 (p / 2).succ → ¬p ∣ x
x : ℕ
hx : x ∈ Ico 1 (p / 2).succ
⊢ (a * ↑x).valMinAbs.natAbs ∈ Ico 1 (p / 2).succ
|
e252720ce4f19196
|
Monoid.Coprod.snd_toProd
|
Mathlib/GroupTheory/Coprod/Basic.lean
|
theorem snd_toProd (x : M ∗ N) : (toProd x).2 = snd x
|
M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
x : M ∗ N
⊢ (toProd x).2 = snd x
|
rw [← snd_comp_toProd]
|
M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
x : M ∗ N
⊢ (toProd x).2 = ((MonoidHom.snd M N).comp toProd) x
|
2fb06f44b53bed66
|
ContinuousLinearMap.coprod_add
|
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
@[simp] lemma coprod_add (f₁ g₁ : M₁ →L[R] M) (f₂ g₂ : M₂ →L[R] M) :
(f₁ + g₁).coprod (f₂ + g₂) = f₁.coprod f₂ + g₁.coprod g₂
|
R : Type u_1
M : Type u_3
M₁ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : Semiring R
inst✝⁹ : TopologicalSpace M
inst✝⁸ : TopologicalSpace M₁
inst✝⁷ : TopologicalSpace M₂
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : ContinuousAdd M
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f₁ g₁ : M₁ →L[R] M
f₂ g₂ : M₂ →L[R] M
⊢ (f₁ + g₁).coprod (f₂ + g₂) = f₁.coprod f₂ + g₁.coprod g₂
|
ext <;> simp
|
no goals
|
f7b4e0746d10c1b9
|
ProbabilityTheory.gaussianReal_map_const_mul
|
Mathlib/Probability/Distributions/Gaussian.lean
|
/-- The map of a Gaussian distribution by multiplication by a constant is a Gaussian. -/
lemma gaussianReal_map_const_mul (c : ℝ) :
(gaussianReal μ v).map (c * ·) = gaussianReal (c * μ) (⟨c^2, sq_nonneg _⟩ * v)
|
case pos
μ : ℝ
v : ℝ≥0
c : ℝ
hv : ¬v = 0
hc : c = 0
⊢ Measure.dirac 0 = gaussianReal 0 (⟨0 ^ 2, ⋯⟩ * v)
|
convert (gaussianReal_zero_var 0).symm
|
case h.e'_3.h.e'_2
μ : ℝ
v : ℝ≥0
c : ℝ
hv : ¬v = 0
hc : c = 0
⊢ ⟨0 ^ 2, ⋯⟩ * v = 0
|
1ceed6d297abcf77
|
Stream'.Seq.terminatedAt_zero_iff
|
Mathlib/Data/Seq/Seq.lean
|
theorem terminatedAt_zero_iff {s : Seq α} : s.TerminatedAt 0 ↔ s = nil
|
case refine_2
α : Type u
⊢ nil.TerminatedAt 0
|
simp [TerminatedAt]
|
no goals
|
10aa63b0fda6161a
|
IsGLB.mul_left
|
Mathlib/Algebra/Order/Field/Basic.lean
|
theorem IsGLB.mul_left {s : Set α} (ha : 0 ≤ a) (hs : IsGLB s b) :
IsGLB ((fun b => a * b) '' s) (a * b)
|
α : Type u_2
inst✝ : LinearOrderedSemifield α
a b : α
s : Set α
ha : 0 ≤ a
hs : IsGLB s b
⊢ IsGLB ((fun b => a * b) '' s) (a * b)
|
rcases lt_or_eq_of_le ha with (ha | rfl)
|
case inl
α : Type u_2
inst✝ : LinearOrderedSemifield α
a b : α
s : Set α
ha✝ : 0 ≤ a
hs : IsGLB s b
ha : 0 < a
⊢ IsGLB ((fun b => a * b) '' s) (a * b)
case inr
α : Type u_2
inst✝ : LinearOrderedSemifield α
b : α
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB ((fun b => 0 * b) '' s) (0 * b)
|
88bccf1fd81bb4e6
|
roth_3ap_theorem_nat
|
Mathlib/Combinatorics/Additive/Corner/Roth.lean
|
theorem roth_3ap_theorem_nat (ε : ℝ) (hε : 0 < ε) (hG : cornersTheoremBound (ε / 3) ≤ n)
(A : Finset ℕ) (hAn : A ⊆ range n) (hAε : ε * n ≤ #A) : ¬ ThreeAPFree (A : Set ℕ)
|
n : ℕ
ε : ℝ
hε : 0 < ε
hG : cornersTheoremBound (ε / 3) ≤ n
A : Finset ℕ
hAn : ↑A ⊆ Set.Iio n
hAε : ε * ↑n ≤ ↑(#A)
hA : ThreeAPFree (Fin.val '' (Nat.cast '' ↑A))
this✝¹ : ↑A = Fin.val '' (Nat.cast '' ↑A)
this✝ : IsAddFreimanIso 2 (Set.Iio ↑n) (Set.Iio n) Fin.val
this : ThreeAPFree ↑(image (fun x => ↑x) A)
⊢ ε / 3 * ↑(Fintype.card (Fin (2 * n + 1))) ≤ ↑(#(image (fun x => ↑x) A))
|
calc
_ = ε / 3 * (2 * n + 1) := by simp
_ ≤ ε / 3 * (2 * n + n) := by gcongr; simp; unfold cornersTheoremBound at hG; omega
_ = ε * n := by ring
_ ≤ #A := hAε
_ = _ := by
rw [card_image_of_injOn]
exact (CharP.natCast_injOn_Iio (Fin (2 * n).succ) (2 * n).succ).mono <| hAn.trans <| by
simp; omega
|
no goals
|
c707b5b13a459d8d
|
Sum.lex_inl_inl
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Sum/Basic.lean
|
theorem lex_inl_inl : Lex r s (inl a₁) (inl a₂) ↔ r a₁ a₂ :=
⟨fun h => by cases h; assumption, Lex.inl⟩
|
α✝ : Type u_1
r : α✝ → α✝ → Prop
β✝ : Type u_2
s : β✝ → β✝ → Prop
a₁ a₂ : α✝
h : Lex r s (inl a₁) (inl a₂)
⊢ r a₁ a₂
|
cases h
|
case inl
α✝ : Type u_1
r : α✝ → α✝ → Prop
β✝ : Type u_2
s : β✝ → β✝ → Prop
a₁ a₂ : α✝
h✝ : r a₁ a₂
⊢ r a₁ a₂
|
d3aae9eca3e3cd38
|
Besicovitch.exists_goodδ
|
Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean
|
theorem exists_goodδ :
∃ δ : ℝ, 0 < δ ∧ δ < 1 ∧ ∀ s : Finset E, (∀ c ∈ s, ‖c‖ ≤ 2) →
(∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 - δ ≤ ‖c - d‖) → s.card ≤ multiplicity E
|
case intro.intro.intro.intro.intro.intro.intro.refine_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
h :
∀ (δ : ℝ),
0 < δ → δ < 1 → ∃ s, (∀ c ∈ s, ‖c‖ ≤ 2) ∧ (∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 - δ ≤ ‖c - d‖) ∧ multiplicity E < s.card
N : ℕ := multiplicity E + 1
hN : N = multiplicity E + 1
F : ℝ → Fin N → E
hF : ∀ (δ : ℝ), 0 < δ → (∀ (i : Fin N), ‖F δ i‖ ≤ 2) ∧ Pairwise fun i j => 1 - δ ≤ ‖F δ i - F δ j‖
u : ℕ → ℝ
left✝ : ∀ (m n : ℕ), m < n → u n < u m
zero_lt_u : ∀ (n : ℕ), 0 < u n
hu : Tendsto u atTop (𝓝 0)
A : ∀ (n : ℕ), F (u n) ∈ closedBall 0 2
f : Fin N → E
φ : ℕ → ℕ
φ_mono : StrictMono φ
hf : Tendsto ((F ∘ u) ∘ φ) atTop (𝓝 f)
i : Fin N
fmem : ∀ (i : Fin N), ‖f i‖ ≤ 2
⊢ ‖f i‖ ≤ 2
|
exact fmem i
|
no goals
|
7c59972754532a8d
|
Module.Flat.exists_factorization_of_apply_eq_zero_of_free
|
Mathlib/RingTheory/Flat/EquationalCriterion.lean
|
theorem exists_factorization_of_apply_eq_zero_of_free [Flat R M] {N : Type*} [AddCommGroup N]
[Module R N] [Free R N] [Module.Finite R N] {f : N} {x : N →ₗ[R] M} (h : x f = 0) :
∃ (k : ℕ) (a : N →ₗ[R] (Fin k →₀ R)) (y : (Fin k →₀ R) →ₗ[R] M), x = y ∘ₗ a ∧ a f = 0 :=
have e := ((Module.Free.chooseBasis R N).reindex (Fintype.equivFin _)).repr.symm
have ⟨k, a, y, hya, haf⟩ := iff_forall_exists_factorization.mp ‹Flat R M›
(f := e.symm f) (x := x ∘ₗ e) (by simpa using h)
⟨k, a ∘ₗ e.symm, y, by rwa [← comp_assoc, LinearEquiv.eq_comp_toLinearMap_symm], haf⟩
|
R : Type u_1
M : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : Flat R M
N : Type u_3
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : Free R N
inst✝ : Module.Finite R N
f : N
x : N →ₗ[R] M
h : x f = 0
e : (Fin (Fintype.card (Free.ChooseBasisIndex R N)) →₀ R) ≃ₗ[R] N
k : ℕ
a : (Fin (Fintype.card (Free.ChooseBasisIndex R N)) →₀ R) →ₗ[R] Fin k →₀ R
y : (Fin k →₀ R) →ₗ[R] M
hya : x ∘ₗ ↑e = y ∘ₗ a
haf : a (e.symm f) = 0
⊢ x = y ∘ₗ a ∘ₗ ↑e.symm
|
rwa [← comp_assoc, LinearEquiv.eq_comp_toLinearMap_symm]
|
no goals
|
c0d139cfd91c1db8
|
LeftOrdContinuous.iterate
|
Mathlib/Order/OrdContinuous.lean
|
theorem iterate {f : α → α} (hf : LeftOrdContinuous f) (n : ℕ) :
LeftOrdContinuous f^[n]
|
case succ
α : Type u
inst✝ : Preorder α
f : α → α
hf : LeftOrdContinuous f
n : ℕ
ihn : LeftOrdContinuous f^[n]
⊢ LeftOrdContinuous f^[n + 1]
|
exact ihn.comp hf
|
no goals
|
3ce387ee4ba6ee92
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_get
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.lean
|
theorem go_get (aig : AIG α) (curr : Nat) (hcurr : curr ≤ w) (cin : Ref aig)
(s : AIG.RefVec aig curr) (lhs rhs : AIG.RefVec aig w) :
∀ (idx : Nat) (hidx : idx < curr),
(go aig lhs rhs curr hcurr cin s).vec.get idx (by omega)
=
(s.get idx hidx).cast (by apply go_le_size)
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
curr : Nat
hcurr : curr ≤ w
cin : aig.Ref
s : aig.RefVec curr
lhs rhs : aig.RefVec w
idx✝ : Nat
hidx✝ : idx✝ < curr
⊢ (go aig lhs rhs curr hcurr cin s).vec.get idx✝ ⋯ = (s.get idx✝ hidx✝).cast ⋯
|
apply go_get_aux
|
no goals
|
a0b97a99a40e7a7a
|
CoxeterSystem.getElem_succ_leftInvSeq_alternatingWord
|
Mathlib/GroupTheory/Coxeter/Inversion.lean
|
lemma getElem_succ_leftInvSeq_alternatingWord
(i j : B) (p k : ℕ) (h : k + 1 < 2 * p) :
(lis (alternatingWord i j (2 * p)))[k + 1]'(by simp; exact h) =
MulAut.conj (s i) ((lis (alternatingWord j i (2 * p)))[k]'(by simp; omega))
|
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i j : B
p k : ℕ
h : k + 1 < 2 * p
⊢ k < (alternatingWord j i (2 * p)).length
|
simp[h]
|
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i j : B
p k : ℕ
h : k + 1 < 2 * p
⊢ k < 2 * p
|
92714ccf6a2cfd6b
|
RingQuot.smul_quot
|
Mathlib/Algebra/RingQuot.lean
|
theorem smul_quot [Algebra S R] {n : S} {a : R} :
(n • ⟨Quot.mk _ a⟩ : RingQuot r) = ⟨Quot.mk _ (n • a)⟩
|
R : Type uR
inst✝² : Semiring R
S : Type uS
inst✝¹ : CommSemiring S
r : R → R → Prop
inst✝ : Algebra S R
n : S
a : R
⊢ n • { toQuot := Quot.mk (Rel r) a } = { toQuot := Quot.mk (Rel r) (n • a) }
|
show smul r _ _ = _
|
R : Type uR
inst✝² : Semiring R
S : Type uS
inst✝¹ : CommSemiring S
r : R → R → Prop
inst✝ : Algebra S R
n : S
a : R
⊢ RingQuot.smul r n { toQuot := Quot.mk (Rel r) a } = { toQuot := Quot.mk (Rel r) (n • a) }
|
1998ee7c35e5105c
|
LieAlgebra.derivedSeries_baseChange
|
Mathlib/Algebra/Lie/Solvable.lean
|
theorem derivedSeries_baseChange {A : Type*} [CommRing A] [Algebra R A] (k : ℕ) :
derivedSeries A (A ⊗[R] L) k = (derivedSeries R L k).baseChange A
|
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra R A
k : ℕ
⊢ derivedSeries A (A ⊗[R] L) k = LieSubmodule.baseChange A (derivedSeries R L k)
|
rw [derivedSeries_def, derivedSeries_def, ← derivedSeriesOfIdeal_baseChange,
LieSubmodule.baseChange_top]
|
no goals
|
2cd3c7adb791e646
|
LieDerivation.iterate_apply_lie'
|
Mathlib/Algebra/Lie/Derivation/Basic.lean
|
theorem iterate_apply_lie' (D : LieDerivation R L L) (n : ℕ) (a b : L) :
D^[n] ⁅a, b⁆ = ∑ i ∈ range (n + 1), n.choose i • ⁅D^[i] a, D^[n - i] b⁆
|
R : Type u_1
L : Type u_2
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
D : LieDerivation R L L
n : ℕ
a b : L
⊢ (⇑D)^[n] ⁅a, b⁆ = ∑ i ∈ range (n + 1), n.choose i • ⁅(⇑D)^[i] a, (⇑D)^[n - i] b⁆
|
rw [iterate_apply_lie D n a b]
|
R : Type u_1
L : Type u_2
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
D : LieDerivation R L L
n : ℕ
a b : L
⊢ ∑ ij ∈ antidiagonal n, n.choose ij.1 • ⁅(⇑D)^[ij.1] a, (⇑D)^[ij.2] b⁆ =
∑ i ∈ range (n + 1), n.choose i • ⁅(⇑D)^[i] a, (⇑D)^[n - i] b⁆
|
47286e6ec979c5c1
|
Doset.union_quotToDoset
|
Mathlib/GroupTheory/DoubleCoset.lean
|
theorem union_quotToDoset (H K : Subgroup G) : ⋃ q, quotToDoset H K q = Set.univ
|
case h.intro.intro.intro.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
x h k : G
h3 : h ∈ H
h4 : k ∈ K
h5 : Quotient.out (mk H K x) = h * x * k
⊢ x = h⁻¹ * Quotient.out (mk H K x) * k⁻¹
|
simp only [h5, Subgroup.coe_mk, ← mul_assoc, one_mul, inv_mul_cancel, mul_inv_cancel_right]
|
no goals
|
8ff825a8e63bc4d6
|
MeasureTheory.continuousOn_convolution_right_with_param
|
Mathlib/Analysis/Convolution.lean
|
theorem continuousOn_convolution_right_with_param {g : P → G → E'} {s : Set P} {k : Set G}
(hk : IsCompact k) (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0)
(hf : LocallyIntegrable f μ) (hg : ContinuousOn (↿g) (s ×ˢ univ)) :
ContinuousOn (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ)
|
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
F : Type uF
P : Type uP
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup E'
inst✝¹¹ : NormedAddCommGroup F
f : G → E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁶ : MeasurableSpace G
μ : Measure G
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : AddGroup G
inst✝³ : TopologicalSpace G
inst✝² : IsTopologicalAddGroup G
inst✝¹ : BorelSpace G
inst✝ : TopologicalSpace P
g : P → G → E'
s : Set P
k : Set G
hk : IsCompact k
hgs : ∀ (p : P) (x : G), p ∈ s → x ∉ k → g p x = 0
hf : LocallyIntegrable f μ
hg : ContinuousOn (↿g) (s ×ˢ univ)
H : ¬∀ p ∈ s, ∀ (x : G), g p x = 0
⊢ LocallyCompactSpace G
|
push_neg at H
|
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
F : Type uF
P : Type uP
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup E'
inst✝¹¹ : NormedAddCommGroup F
f : G → E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 E'
inst✝⁷ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝⁶ : MeasurableSpace G
μ : Measure G
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : AddGroup G
inst✝³ : TopologicalSpace G
inst✝² : IsTopologicalAddGroup G
inst✝¹ : BorelSpace G
inst✝ : TopologicalSpace P
g : P → G → E'
s : Set P
k : Set G
hk : IsCompact k
hgs : ∀ (p : P) (x : G), p ∈ s → x ∉ k → g p x = 0
hf : LocallyIntegrable f μ
hg : ContinuousOn (↿g) (s ×ˢ univ)
H : ∃ p ∈ s, ∃ x, g p x ≠ 0
⊢ LocallyCompactSpace G
|
a579c7593509cfe8
|
Fin.dfoldrM_loop
|
Mathlib/.lake/packages/batteries/Batteries/Data/Fin/Fold.lean
|
theorem dfoldrM_loop [Monad m] [LawfulMonad m] (f : (i : Fin (n+1)) → α i.succ → m (α i.castSucc))
(x) : dfoldrM.loop (n+1) α f (i+1) h x =
dfoldrM.loop n (α ∘ succ) (f ·.succ) i (by omega) x >>= f 0
|
case zero
m : Type u_1 → Type u_2
n : Nat
α : Fin (n + 1 + 1) → Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : (i : Fin (n + 1)) → α i.succ → m (α i.castSucc)
h : 0 + 1 < n + 1 + 1
x : α ⟨0 + 1, h⟩
⊢ dfoldrM.loop (n + 1) α f (0 + 1) h x = dfoldrM.loop n (α ∘ succ) (fun x => f x.succ) 0 ⋯ x >>= f 0
|
rw [dfoldrM_loop_zero, dfoldrM_loop_succ, pure_bind]
|
case zero
m : Type u_1 → Type u_2
n : Nat
α : Fin (n + 1 + 1) → Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : (i : Fin (n + 1)) → α i.succ → m (α i.castSucc)
h : 0 + 1 < n + 1 + 1
x : α ⟨0 + 1, h⟩
⊢ f ⟨0, ⋯⟩ x >>= dfoldrM.loop (n + 1) α f 0 ⋯ = f 0 x
|
b74a59ce684ddcb3
|
Basis.smulTower'_apply
|
Mathlib/RingTheory/AlgebraTower.lean
|
theorem Basis.smulTower'_apply (ij) : b.smulTower' c ij = b ij.2 • c ij.1
|
R : Type u_1
S : Type u_2
A : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
ι : Type u_5
ι' : Type u_6
b : Basis ι R S
c : Basis ι' S A
ij : ι' × ι
⊢ b ((Equiv.prodComm ι ι').symm ij).1 • c ((Equiv.prodComm ι ι').symm ij).2 = b ij.2 • c ij.1
|
rfl
|
no goals
|
31e03fdbd5cbb2f1
|
Std.DHashMap.Internal.List.getValueCast!_insertList_of_contains_eq_false
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem getValueCast!_insertList_of_contains_eq_false [BEq α] [LawfulBEq α]
{l toInsert : List ((a : α) × β a)} {k : α} [Inhabited (β k)]
(not_contains : (toInsert.map Sigma.fst).contains k = false) :
getValueCast! k (insertList l toInsert) = getValueCast! k l
|
α : Type u
β : α → Type v
inst✝² : BEq α
inst✝¹ : LawfulBEq α
l toInsert : List ((a : α) × β a)
k : α
inst✝ : Inhabited (β k)
not_contains : (List.map Sigma.fst toInsert).contains k = false
⊢ getValueCast! k (insertList l toInsert) = getValueCast! k l
|
rw [getValueCast!_eq_getValueCast?, getValueCast!_eq_getValueCast?,
getValueCast?_insertList_of_contains_eq_false not_contains]
|
no goals
|
5142a0bf7137e2ba
|
Matrix.add_mul_mul_invOf_mul_eq_one
|
Mathlib/Data/Matrix/Invertible.lean
|
lemma add_mul_mul_invOf_mul_eq_one :
(A + U*C*V)*(⅟A - ⅟A*U*⅟(⅟C + V*⅟A*U)*V*⅟A) = 1
|
m : Type u_1
n : Type u_2
α : Type u_3
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq m
inst✝³ : Ring α
A : Matrix n n α
U : Matrix n m α
C : Matrix m m α
V : Matrix m n α
inst✝² : Invertible A
inst✝¹ : Invertible C
inst✝ : Invertible (⅟C + V * ⅟A * U)
⊢ 1 - U * ⅟(⅟C + V * ⅟A * U) * V * ⅟A + U * C * V * ⅟A - U * C * V * ⅟A * U * ⅟(⅟C + V * ⅟A * U) * V * ⅟A =
1 + U * C * V * ⅟A - (U * ⅟(⅟C + V * ⅟A * U) * V * ⅟A + U * C * V * ⅟A * U * ⅟(⅟C + V * ⅟A * U) * V * ⅟A)
|
abel
|
no goals
|
d620666c2f32684f
|
ModularFormClass.differentiableAt_cuspFunction
|
Mathlib/NumberTheory/ModularForms/QExpansion.lean
|
theorem differentiableAt_cuspFunction [NeZero n] [ModularFormClass F Γ(n) k]
{q : ℂ} (hq : ‖q‖ < 1) :
DifferentiableAt ℂ (cuspFunction n f) q
|
k : ℤ
F : Type u_1
inst✝² : FunLike F ℍ ℂ
n : ℕ
f : F
inst✝¹ : NeZero n
inst✝ : ModularFormClass F Γ(n) k
q : ℂ
hq : ‖q‖ < 1
npos : 0 < ↑n
⊢ DifferentiableAt ℂ (cuspFunction n f) q
|
rcases eq_or_ne q 0 with rfl | hq'
|
case inl
k : ℤ
F : Type u_1
inst✝² : FunLike F ℍ ℂ
n : ℕ
f : F
inst✝¹ : NeZero n
inst✝ : ModularFormClass F Γ(n) k
npos : 0 < ↑n
hq : ‖0‖ < 1
⊢ DifferentiableAt ℂ (cuspFunction n f) 0
case inr
k : ℤ
F : Type u_1
inst✝² : FunLike F ℍ ℂ
n : ℕ
f : F
inst✝¹ : NeZero n
inst✝ : ModularFormClass F Γ(n) k
q : ℂ
hq : ‖q‖ < 1
npos : 0 < ↑n
hq' : q ≠ 0
⊢ DifferentiableAt ℂ (cuspFunction n f) q
|
f6e94b618ea55836
|
dualTensorHomEquivOfBasis_symm_cancel_right
|
Mathlib/LinearAlgebra/Contraction.lean
|
theorem dualTensorHomEquivOfBasis_symm_cancel_right (x : M →ₗ[R] N) :
dualTensorHom R M N ((dualTensorHomEquivOfBasis b).symm x) = x
|
ι : Type w
R : Type u
M : Type v₁
N : Type v₂
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R M
inst✝² : Module R N
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
x : M →ₗ[R] N
⊢ (dualTensorHom R M N) ((dualTensorHomEquivOfBasis b).symm x) = x
|
rw [← dualTensorHomEquivOfBasis_apply b, LinearEquiv.apply_symm_apply]
|
no goals
|
98ad7dc13e73a05f
|
GenContFract.dens_recurrence
|
Mathlib/Algebra/ContinuedFractions/ContinuantsRecurrence.lean
|
theorem dens_recurrence {gp : Pair K} {ppredB predB : K}
(succ_nth_s_eq : g.s.get? (n + 1) = some gp) (nth_den_eq : g.dens n = ppredB)
(succ_nth_den_eq : g.dens (n + 1) = predB) :
g.dens (n + 2) = gp.b * predB + gp.a * ppredB
|
K : Type u_1
g : GenContFract K
n : ℕ
inst✝ : DivisionRing K
gp : Pair K
ppredB predB : K
succ_nth_s_eq : g.s.get? (n + 1) = some gp
nth_den_eq : g.dens n = ppredB
succ_nth_den_eq : g.dens (n + 1) = predB
⊢ g.dens (n + 2) = gp.b * predB + gp.a * ppredB
|
obtain ⟨ppredConts, nth_conts_eq, ⟨rfl⟩⟩ : ∃ conts, g.conts n = conts ∧ conts.b = ppredB :=
exists_conts_b_of_den nth_den_eq
|
case intro.intro.refl
K : Type u_1
g : GenContFract K
n : ℕ
inst✝ : DivisionRing K
gp : Pair K
predB : K
succ_nth_s_eq : g.s.get? (n + 1) = some gp
succ_nth_den_eq : g.dens (n + 1) = predB
ppredConts : Pair K
nth_conts_eq : g.conts n = ppredConts
nth_den_eq : g.dens n = ppredConts.b
⊢ g.dens (n + 2) = gp.b * predB + gp.a * ppredConts.b
|
a1e5e5f64bf27d45
|
totallyBounded_iff_filter
|
Mathlib/Topology/UniformSpace/Cauchy.lean
|
theorem totallyBounded_iff_filter {s : Set α} :
TotallyBounded s ↔ ∀ f, NeBot f → f ≤ 𝓟 s → ∃ c ≤ f, Cauchy c
|
case mpr.intro.intro.intro.intro.intro.intro
α : Type u
uniformSpace : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), t.Finite → ¬s ⊆ ⋃ y ∈ t, {x | (x, y) ∈ d}
f : Filter α := ⨅ t, 𝓟 (s \ ⋃ y ∈ t, {x | (x, y) ∈ d})
hb : f.HasAntitoneBasis fun t => s \ ⋃ y ∈ t, {x | (x, y) ∈ d}
this✝¹ : f.NeBot
this✝ : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
m : Set α
hm : m ∈ c
hmd : m ×ˢ m ⊆ d
y : α
hym : y ∈ m
this : s \ {x | (x, y) ∈ d} ∈ c
z : α
hzm : z ∈ m
hyz : z ∉ {x | (x, y) ∈ d}
⊢ False
|
exact hyz (hmd ⟨hzm, hym⟩)
|
no goals
|
8d4389700a78bd05
|
Batteries.UnionFind.rootD_eq_self
|
Mathlib/.lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean
|
theorem rootD_eq_self {self : UnionFind} {x : Nat} : self.rootD x = x ↔ self.parent x = x
|
self : UnionFind
x : Nat
h : self.parent x = x
⊢ (if h : x < self.size then ↑(self.root ⟨x, h⟩) else x) = x
|
split <;> [rw [root, dif_pos (by rwa [parent, parentD_eq ‹_›] at h)]; rfl]
|
no goals
|
0c883697e4e0ccdf
|
Sum.bnot_isLeft
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Sum/Lemmas.lean
|
theorem bnot_isLeft (x : α ⊕ β) : !x.isLeft = x.isRight
|
α : Type u_1
β : Type u_2
x : α ⊕ β
⊢ (!decide (x.isLeft = x.isRight)) = true
|
cases x <;> rfl
|
no goals
|
e4b00d71627b8aa9
|
Turing.TM1to0.tr_supports
|
Mathlib/Computability/PostTuringMachine.lean
|
theorem tr_supports {S : Finset Λ} (ss : TM1.Supports M S) :
TM0.Supports (tr M) ↑(trStmts M S)
|
case right.mk.some
Γ : Type u_1
Λ : Type u_2
inst✝² : Inhabited Λ
σ : Type u_3
inst✝¹ : Inhabited σ
M : Λ → TM1.Stmt Γ Λ σ
inst✝ : Fintype σ
S : Finset Λ
ss : TM1.Supports M S
a : Γ
q' : Λ' M
s : TM0.Stmt Γ
v : σ
q : TM1.Stmt Γ Λ σ
h₁ : (q', s) ∈ tr M (some q, v) a
h₂ : (some q, v) ∈ ↑(trStmts M S)
⊢ q' ∈ ↑(trStmts M S)
|
obtain ⟨q', v'⟩ := q'
|
case right.mk.some.mk
Γ : Type u_1
Λ : Type u_2
inst✝² : Inhabited Λ
σ : Type u_3
inst✝¹ : Inhabited σ
M : Λ → TM1.Stmt Γ Λ σ
inst✝ : Fintype σ
S : Finset Λ
ss : TM1.Supports M S
a : Γ
s : TM0.Stmt Γ
v : σ
q : TM1.Stmt Γ Λ σ
h₂ : (some q, v) ∈ ↑(trStmts M S)
q' : Option (TM1.Stmt Γ Λ σ)
v' : σ
h₁ : ((q', v'), s) ∈ tr M (some q, v) a
⊢ (q', v') ∈ ↑(trStmts M S)
|
c5e09604fd205550
|
MvPolynomial.eval₂_mem
|
Mathlib/Algebra/MvPolynomial/Eval.lean
|
theorem eval₂_mem {f : R →+* S} {p : MvPolynomial σ R} {s : subS}
(hs : ∀ i ∈ p.support, f (p.coeff i) ∈ s) {v : σ → S} (hv : ∀ i, v i ∈ s) :
MvPolynomial.eval₂ f v p ∈ s
|
R : Type u
σ : Type u_1
inst✝³ : CommSemiring R
S : Type u_2
subS : Type u_3
inst✝² : CommSemiring S
inst✝¹ : SetLike subS S
inst✝ : SubsemiringClass subS S
f : R →+* S
p : MvPolynomial σ R
s : subS
v : σ → S
hv : ∀ (i : σ), v i ∈ s
hs : ∀ (i : σ →₀ ℕ), f (coeff i p) ∈ s
⊢ eval₂ f v p ∈ s
|
induction' p using MvPolynomial.induction_on''' with a a b f ha _ ih
|
case h_C
R : Type u
σ : Type u_1
inst✝³ : CommSemiring R
S : Type u_2
subS : Type u_3
inst✝² : CommSemiring S
inst✝¹ : SetLike subS S
inst✝ : SubsemiringClass subS S
f : R →+* S
s : subS
v : σ → S
hv : ∀ (i : σ), v i ∈ s
a : R
hs : ∀ (i : σ →₀ ℕ), f (coeff i (C a)) ∈ s
⊢ eval₂ f v (C a) ∈ s
case h_add_weak
R : Type u
σ : Type u_1
inst✝³ : CommSemiring R
S : Type u_2
subS : Type u_3
inst✝² : CommSemiring S
inst✝¹ : SetLike subS S
inst✝ : SubsemiringClass subS S
f✝ : R →+* S
s : subS
v : σ → S
hv : ∀ (i : σ), v i ∈ s
a : σ →₀ ℕ
b : R
f : (σ →₀ ℕ) →₀ R
ha : a ∉ f.support
a✝ : b ≠ 0
ih : (∀ (i : σ →₀ ℕ), f✝ (coeff i f) ∈ s) → eval₂ f✝ v f ∈ s
hs :
∀ (i : σ →₀ ℕ),
f✝
(coeff i
((let_fun this := (monomial a) b;
this) +
f)) ∈
s
⊢ eval₂ f✝ v
((let_fun this := (monomial a) b;
this) +
f) ∈
s
|
84ed2e64912182c9
|
Ordnode.Sized.rotateL
|
Mathlib/Data/Ordmap/Ordset.lean
|
theorem Sized.rotateL {l x r} (hl : @Sized α l) (hr : Sized r) : Sized (rotateL l x r)
|
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
⊢ (l.rotateL x r).Sized
|
cases r
|
case nil
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
hr : nil.Sized
⊢ (l.rotateL x nil).Sized
case node
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : (node size✝ l✝ x✝ r✝).Sized
⊢ (l.rotateL x (node size✝ l✝ x✝ r✝)).Sized
|
485e683ec0a48852
|
CategoryTheory.Abelian.Ext.preadditiveCoyoneda_homologySequenceδ_singleTriangle_apply
|
Mathlib/Algebra/Homology/DerivedCategory/Ext/ExactSequences.lean
|
lemma preadditiveCoyoneda_homologySequenceδ_singleTriangle_apply
[HasDerivedCategory.{w'} C] {X : C} {n₀ : ℕ} (x : Ext X S.X₃ n₀)
{n₁ : ℕ} (h : n₀ + 1 = n₁) :
(preadditiveCoyoneda.obj (op ((singleFunctor C 0).obj X))).homologySequenceδ
hS.singleTriangle n₀ n₁ (by omega) x.hom =
(x.comp hS.extClass h).hom
|
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasExt C
S : ShortComplex C
hS : S.ShortExact
inst✝ : HasDerivedCategory C
X : C
n₀ : ℕ
x : Ext X S.X₃ n₀
n₁ : ℕ
h : n₀ + 1 = n₁
⊢ x.hom ≫
(shiftFunctor (DerivedCategory C) ↑n₀).map hS.singleTriangle.mor₃ ≫
(shiftFunctorAdd' (DerivedCategory C) 1 ↑n₀ ↑n₁ ⋯).inv.app hS.singleTriangle.obj₁ =
x.hom ≫
(shiftFunctor (DerivedCategory C) ↑n₀).map hS.singleδ ≫
(shiftFunctorAdd' (DerivedCategory C) ↑1 ↑n₀ ↑n₁ ⋯).inv.app ((singleFunctor C 0).obj S.X₁)
|
rfl
|
no goals
|
e57479311dc43218
|
MeasureTheory.eLpNorm_smul_measure_of_ne_zero_of_ne_top
|
Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
|
theorem eLpNorm_smul_measure_of_ne_zero_of_ne_top {p : ℝ≥0∞} (hp_ne_zero : p ≠ 0)
(hp_ne_top : p ≠ ∞) {f : α → ε} (c : ℝ≥0∞) :
eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ
|
α : Type u_1
ε : Type u_2
m0 : MeasurableSpace α
μ : Measure α
inst✝ : ENorm ε
p : ℝ≥0∞
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → ε
c : ℝ≥0∞
⊢ c ^ (1 / p.toReal) * eLpNorm' f p.toReal μ = c ^ (1 / p).toReal • eLpNorm' f p.toReal μ
|
congr
|
case e_a.e_a
α : Type u_1
ε : Type u_2
m0 : MeasurableSpace α
μ : Measure α
inst✝ : ENorm ε
p : ℝ≥0∞
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → ε
c : ℝ≥0∞
⊢ 1 / p.toReal = (1 / p).toReal
|
29a17d4553f41dd2
|
Finset.Colex.shadow_initSeg
|
Mathlib/Combinatorics/SetFamily/KruskalKatona.lean
|
/-- This is important for iterating Kruskal-Katona: the shadow of an initial segment is also an
initial segment. -/
lemma shadow_initSeg [Fintype α] (hs : s.Nonempty) :
∂ (initSeg s) = initSeg (erase s <| min' s hs)
|
case h.mpr.inr.intro.intro.intro.inr.inr.inr.h
α : Type u_1
inst✝¹ : LinearOrder α
s : Finset α
inst✝ : Fintype α
hs : s.Nonempty
t : Finset α
cards' : #(s.erase (s.min' hs)) = #t
k : α
hks : k ∈ s.erase (s.min' hs)
hkt : k ∉ t
z : ∀ ⦃a : α⦄, k < a → (a ∈ t ↔ a ∈ s.erase (s.min' hs))
j : α := tᶜ.min' ⋯
hjk : j ≤ k
this : j ∉ t
hcard : #s = #(insert j t)
r₁ : j = k
a : α
ha : a ∈ s
gt : a < j
x✝ : a ∉ t
⊢ False
|
apply (min'_le tᶜ _ _).not_lt gt
|
α : Type u_1
inst✝¹ : LinearOrder α
s : Finset α
inst✝ : Fintype α
hs : s.Nonempty
t : Finset α
cards' : #(s.erase (s.min' hs)) = #t
k : α
hks : k ∈ s.erase (s.min' hs)
hkt : k ∉ t
z : ∀ ⦃a : α⦄, k < a → (a ∈ t ↔ a ∈ s.erase (s.min' hs))
j : α := tᶜ.min' ⋯
hjk : j ≤ k
this : j ∉ t
hcard : #s = #(insert j t)
r₁ : j = k
a : α
ha : a ∈ s
gt : a < j
x✝ : a ∉ t
⊢ a ∈ tᶜ
|
a9c55e64e04a6093
|
Batteries.RBNode.Balanced.append
|
Mathlib/.lake/packages/batteries/Batteries/Data/RBMap/WF.lean
|
theorem Balanced.append {l r : RBNode α}
(hl : l.Balanced c₁ n) (hr : r.Balanced c₂ n) :
(l.append r).RedRed (c₁ = black → c₂ ≠ black) n
|
α : Type u_1
c₁ : RBColor
n : Nat
c₂ : RBColor
x✝³ x✝² a✝¹ : RBNode α
x✝¹ : α
b c : RBNode α
y✝ : α
d✝ : RBNode α
hl : (node red a✝¹ x✝¹ b).Balanced c₁ n
hr : (node red c y✝ d✝).Balanced c₂ n
ha : a✝¹.Balanced black n
hb : b.Balanced black n
hc : c.Balanced black n
hd : d✝.Balanced black n
l✝ a✝ : RBNode α
x✝ : α
b✝ : RBNode α
e : b.append c = node red a✝ x✝ b✝
hb' : a✝.Balanced black n
hc' : b✝.Balanced black n
IH : (b.append c).Balanced red n
⊢ RedRed (red = black → red ≠ black) (node red (node red a✝¹ x✝¹ a✝) x✝ (node red b✝ y✝ d✝)) n
|
exact .redred nofun (.red ha hb') (.red hc' hd)
|
no goals
|
b3ecc8a07b6c9ec6
|
CategoryTheory.Functor.CommShift.ofIso_compatibility
|
Mathlib/CategoryTheory/Shift/CommShift.lean
|
lemma ofIso_compatibility :
letI := ofIso e A
NatTrans.CommShift e.hom A
|
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_5, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
F G : C ⥤ D
e : F ≅ G
A : Type u_4
inst✝³ : AddMonoid A
inst✝² : HasShift C A
inst✝¹ : HasShift D A
inst✝ : F.CommShift A
⊢ NatTrans.CommShift e.hom A
|
letI := ofIso e A
|
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_5, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
F G : C ⥤ D
e : F ≅ G
A : Type u_4
inst✝³ : AddMonoid A
inst✝² : HasShift C A
inst✝¹ : HasShift D A
inst✝ : F.CommShift A
this : G.CommShift A := ofIso e A
⊢ NatTrans.CommShift e.hom A
|
c2c10f3a9e743026
|
HasFPowerSeriesWithinOnBall.tendstoUniformlyOn'
|
Mathlib/Analysis/Analytic/Basic.lean
|
theorem HasFPowerSeriesWithinOnBall.tendstoUniformlyOn' {r' : ℝ≥0}
(hf : HasFPowerSeriesWithinOnBall f p s x r) (h : (r' : ℝ≥0∞) < r) :
TendstoUniformlyOn (fun n y => p.partialSum n (y - x)) f atTop
(insert x s ∩ Metric.ball (x : E) r')
|
case h.e'_8.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
p : FormalMultilinearSeries 𝕜 E F
s : Set E
x : E
r : ℝ≥0∞
r' : ℝ≥0
hf : HasFPowerSeriesWithinOnBall f p s x r
h : ↑r' < r
z : E
⊢ z ∈ insert x s ∩ Metric.ball x ↑r' ↔
z ∈ (fun y => y - x) ⁻¹' ((fun x_1 => x + x_1) ⁻¹' insert x s ∩ Metric.ball 0 ↑r')
|
simp [dist_eq_norm]
|
no goals
|
3f74d4280602b239
|
AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.carrier.add_mem
|
Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
|
theorem carrier.add_mem (q : Spec.T A⁰_ f) {a b : A} (ha : a ∈ carrier f_deg q)
(hb : b ∈ carrier f_deg q) : a + b ∈ carrier f_deg q
|
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
q : ↑↑(Spec A⁰_ f).toPresheafedSpace
a b : A
ha : a ∈ carrier f_deg q
hb : b ∈ carrier f_deg q
i j : ℕ
h2 : ¬m + m < j
h1 : ¬j ≤ m
⊢ (proj 𝒜 i) a ^ m ∈ 𝒜 (m • i)
|
mem_tac
|
no goals
|
e11b14794a0cd9b6
|
Nat.and_lt_two_pow
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
|
theorem and_lt_two_pow (x : Nat) {y n : Nat} (right : y < 2^n) : (x &&& y) < 2^n
|
case lt
x y n : Nat
right : y < 2 ^ n
i : Nat
i_ge_n : i ≥ n
⊢ 2 ^ n ≤ 2 ^ i
|
exact pow_le_pow_of_le_right Nat.zero_lt_two i_ge_n
|
no goals
|
c45ccfe28fec8d46
|
Set.zero_mem_smul_iff
|
Mathlib/Data/Set/Pointwise/SMul.lean
|
theorem zero_mem_smul_iff :
(0 : β) ∈ s • t ↔ (0 : α) ∈ s ∧ t.Nonempty ∨ (0 : β) ∈ t ∧ s.Nonempty
|
case mpr
α : Type u_2
β : Type u_3
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
⊢ 0 ∈ s ∧ t.Nonempty ∨ 0 ∈ t ∧ s.Nonempty → 0 ∈ s • t
|
rintro (⟨hs, b, hb⟩ | ⟨ht, a, ha⟩)
|
case mpr.inl.intro.intro
α : Type u_2
β : Type u_3
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
hs : 0 ∈ s
b : β
hb : b ∈ t
⊢ 0 ∈ s • t
case mpr.inr.intro.intro
α : Type u_2
β : Type u_3
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
s : Set α
t : Set β
inst✝ : NoZeroSMulDivisors α β
ht : 0 ∈ t
a : α
ha : a ∈ s
⊢ 0 ∈ s • t
|
2eb057cfa2edc7c8
|
Monotone.seq_lt_seq_of_lt_of_le
|
Mathlib/Order/Iterate.lean
|
theorem seq_lt_seq_of_lt_of_le (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
(hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n
|
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
n : ℕ
h₀ : x 0 < y 0
hx : ∀ (k : ℕ), k < n → x (k + 1) < f (x k)
hy : ∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)
⊢ x n < y n
|
cases n
|
case zero
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 < y 0
hx : ∀ (k : ℕ), k < 0 → x (k + 1) < f (x k)
hy : ∀ (k : ℕ), k < 0 → f (y k) ≤ y (k + 1)
⊢ x 0 < y 0
case succ
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 < y 0
n✝ : ℕ
hx : ∀ (k : ℕ), k < n✝ + 1 → x (k + 1) < f (x k)
hy : ∀ (k : ℕ), k < n✝ + 1 → f (y k) ≤ y (k + 1)
⊢ x (n✝ + 1) < y (n✝ + 1)
|
1752fa5e2b1ecc88
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_ofArray
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.lean
|
theorem readyForRupAdd_ofArray {n : Nat} (arr : Array (Option (DefaultClause n))) :
ReadyForRupAdd (ofArray arr)
|
case right.intro
n : Nat
arr : Array (Option (DefaultClause n))
hsize : (ofArray arr).assignments.size = n
ModifiedAssignmentsInvariant : Array Assignment → Prop :=
fun assignments =>
∃ hsize, ∀ (i : PosFin n) (b : Bool), hasAssignment b assignments[i.val] = true → unit (i, b) ∈ (ofArray arr).toList
hb : ModifiedAssignmentsInvariant (mkArray n unassigned)
hl :
∀ (acc : Array Assignment),
ModifiedAssignmentsInvariant acc →
∀ (cOpt : Option (DefaultClause n)), cOpt ∈ arr.toList → ModifiedAssignmentsInvariant (ofArray_fold_fn acc cOpt)
_h_size : (List.foldl ofArray_fold_fn (mkArray n unassigned) arr.toList).size = n
h' :
∀ (i : PosFin n) (b : Bool),
hasAssignment b (List.foldl ofArray_fold_fn (mkArray n unassigned) arr.toList)[i.val] = true →
unit (i, b) ∈ (ofArray arr).toList
i : PosFin n
b : Bool
h : hasAssignment b (ofArray arr).assignments[i.val] = true
⊢ unit (i, b) ∈ (ofArray arr).toList
|
simp only [ofArray, ← Array.foldl_toList] at h
|
case right.intro
n : Nat
arr : Array (Option (DefaultClause n))
hsize : (ofArray arr).assignments.size = n
ModifiedAssignmentsInvariant : Array Assignment → Prop :=
fun assignments =>
∃ hsize, ∀ (i : PosFin n) (b : Bool), hasAssignment b assignments[i.val] = true → unit (i, b) ∈ (ofArray arr).toList
hb : ModifiedAssignmentsInvariant (mkArray n unassigned)
hl :
∀ (acc : Array Assignment),
ModifiedAssignmentsInvariant acc →
∀ (cOpt : Option (DefaultClause n)), cOpt ∈ arr.toList → ModifiedAssignmentsInvariant (ofArray_fold_fn acc cOpt)
_h_size : (List.foldl ofArray_fold_fn (mkArray n unassigned) arr.toList).size = n
h' :
∀ (i : PosFin n) (b : Bool),
hasAssignment b (List.foldl ofArray_fold_fn (mkArray n unassigned) arr.toList)[i.val] = true →
unit (i, b) ∈ (ofArray arr).toList
i : PosFin n
b : Bool
h : hasAssignment b (List.foldl ofArray_fold_fn (mkArray n unassigned) arr.toList)[i.val] = true
⊢ unit (i, b) ∈ (ofArray arr).toList
|
0a237b5f7a9a7c15
|
CategoryTheory.Limits.reflectsLimit_of_reflectsIsomorphisms
|
Mathlib/CategoryTheory/Limits/Preserves/Basic.lean
|
/-- If the limit of `F` exists and `G` preserves it, then if `G` reflects isomorphisms then it
reflects the limit of `F`.
-/ -- Porting note: previous behavior of apply pushed instance holes into hypotheses, this errors
lemma reflectsLimit_of_reflectsIsomorphisms (F : J ⥤ C) (G : C ⥤ D) [G.ReflectsIsomorphisms]
[HasLimit F] [PreservesLimit F G] : ReflectsLimit F G where
reflects {c} t
|
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
J : Type w
inst✝³ : Category.{w', w} J
F : J ⥤ C
G : C ⥤ D
inst✝² : G.ReflectsIsomorphisms
inst✝¹ : HasLimit F
inst✝ : PreservesLimit F G
c : Cone F
t : IsLimit (G.mapCone c)
this : IsIso ((limit.isLimit F).lift c)
⊢ IsLimit c
|
apply IsLimit.ofPointIso (limit.isLimit F)
|
no goals
|
ff0c8193ee19bd81
|
WithTop.untopD_zero_mul
|
Mathlib/Algebra/Order/Ring/WithTop.lean
|
@[simp]
lemma untopD_zero_mul (a b : WithTop α) : (a * b).untopD 0 = a.untopD 0 * b.untopD 0
|
case neg.top
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
b : WithTop α
hb : ¬b = 0
ha : ¬⊤ = 0
⊢ untopD 0 (⊤ * b) = untopD 0 ⊤ * untopD 0 b
|
rw [top_mul hb, untopD_top, zero_mul]
|
no goals
|
ebaa5001124c917e
|
Basis.mk_eq_rank''
|
Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
|
theorem Basis.mk_eq_rank'' {ι : Type v} (v : Basis ι R M) : #ι = Module.rank R M
|
R : Type u
M : Type v
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
this : Nontrivial R
⊢ LinearIndepOn R id (range ⇑v)
|
rw [LinearIndepOn]
|
R : Type u
M : Type v
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
this : Nontrivial R
⊢ LinearIndependent R fun (x : ↑(range ⇑v)) => id ↑x
|
60944ed5994f83df
|
Preorder.toLE_injective
|
Mathlib/Order/Basic.lean
|
theorem Preorder.toLE_injective : Function.Injective (@Preorder.toLE α) :=
fun A B h ↦ match A, B with
| { lt := A_lt, lt_iff_le_not_le := A_iff, .. },
{ lt := B_lt, lt_iff_le_not_le := B_iff, .. } => by
cases h
have : A_lt = B_lt
|
case h.h
α : Type u_2
A B : Preorder α
le✝ A_lt : α → α → Prop
le_refl✝¹ : ∀ (a : α), a ≤ a
le_trans✝¹ : ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c
A_iff : ∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a
B_lt : α → α → Prop
le_refl✝ : ∀ (a : α), a ≤ a
le_trans✝ : ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c
B_iff : ∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a
a b : α
⊢ (a < b) = (a < b)
|
rw [A_iff, B_iff]
|
no goals
|
4bb5c6c429e2e7ed
|
AlgebraicGeometry.IsLocalAtTarget.of_range_subset_iSup
|
Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
|
lemma of_range_subset_iSup [P.RespectsRight @IsOpenImmersion] {ι : Type*} (U : ι → Y.Opens)
(H : Set.range f.base ⊆ (⨆ i, U i : Y.Opens)) (hf : ∀ i, P (f ∣_ U i)) : P f
|
P : MorphismProperty Scheme
hP : IsLocalAtTarget P
X Y : Scheme
f : X ⟶ Y
inst✝ : P.RespectsRight @IsOpenImmersion
ι : Type u_1
U : ι → Y.Opens
H : Set.range ⇑(ConcreteCategory.hom f.base) ⊆ ↑(⨆ i, U i)
hf : ∀ (i : ι), P (f ∣_ U i)
⊢ P f
|
let g : X ⟶ (⨆ i, U i : Y.Opens) := IsOpenImmersion.lift (Scheme.Opens.ι _) f (by simpa using H)
|
P : MorphismProperty Scheme
hP : IsLocalAtTarget P
X Y : Scheme
f : X ⟶ Y
inst✝ : P.RespectsRight @IsOpenImmersion
ι : Type u_1
U : ι → Y.Opens
H : Set.range ⇑(ConcreteCategory.hom f.base) ⊆ ↑(⨆ i, U i)
hf : ∀ (i : ι), P (f ∣_ U i)
g : X ⟶ ↑(⨆ i, U i) := IsOpenImmersion.lift (⨆ i, U i).ι f ⋯
⊢ P f
|
ee63d9b5b19cceb5
|
Array.pmap_push
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Attach.lean
|
theorem pmap_push {P : α → Prop} (f : ∀ a, P a → β) (a : α) (l : Array α) (h : ∀ b ∈ l.push a, P b) :
pmap f (l.push a) h =
(pmap f l (fun a m => by simp at h; exact h a (.inl m))).push (f a (h a (by simp)))
|
α : Type u_1
β : Type u_2
P : α → Prop
f : (a : α) → P a → β
a : α
l : Array α
h : ∀ (b : α), b ∈ l.push a → P b
⊢ pmap f (l.push a) h = (pmap f l ⋯).push (f a ⋯)
|
simp [pmap]
|
no goals
|
ac6f1dbcf2d15765
|
PadicInt.isCauSeq_nthHom
|
Mathlib/NumberTheory/Padics/RingHoms.lean
|
theorem isCauSeq_nthHom (r : R) : IsCauSeq (padicNorm p) fun n => nthHom f r n
|
R : Type u_1
inst✝ : NonAssocSemiring R
p : ℕ
f : (k : ℕ) → R →+* ZMod (p ^ k)
hp_prime : Fact (Nat.Prime p)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), (ZMod.castHom ⋯ (ZMod (p ^ k1))).comp (f k2) = f k1
r : R
⊢ IsCauSeq (padicNorm p) fun n => ↑(nthHom f r n)
|
intro ε hε
|
R : Type u_1
inst✝ : NonAssocSemiring R
p : ℕ
f : (k : ℕ) → R →+* ZMod (p ^ k)
hp_prime : Fact (Nat.Prime p)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), (ZMod.castHom ⋯ (ZMod (p ^ k1))).comp (f k2) = f k1
r : R
ε : ℚ
hε : ε > 0
⊢ ∃ i, ∀ j ≥ i, padicNorm p ((fun n => ↑(nthHom f r n)) j - (fun n => ↑(nthHom f r n)) i) < ε
|
3ca072d517dfdd09
|
MeasureTheory.integral_mul_norm_le_Lp_mul_Lq
|
Mathlib/MeasureTheory/Integral/Bochner.lean
|
theorem integral_mul_norm_le_Lp_mul_Lq {E} [NormedAddCommGroup E] {f g : α → E} {p q : ℝ}
(hpq : p.IsConjExponent q) (hf : MemLp f (ENNReal.ofReal p) μ)
(hg : MemLp g (ENNReal.ofReal q) μ) :
∫ a, ‖f a‖ * ‖g a‖ ∂μ ≤ (∫ a, ‖f a‖ ^ p ∂μ) ^ (1 / p) * (∫ a, ‖g a‖ ^ q ∂μ) ^ (1 / q)
|
α : Type u_1
m : MeasurableSpace α
μ : Measure α
E : Type u_7
inst✝ : NormedAddCommGroup E
f g : α → E
p q : ℝ
hpq : p.IsConjExponent q
hf : MemLp f (ENNReal.ofReal p) μ
hg : MemLp g (ENNReal.ofReal q) μ
h_left : ∫⁻ (a : α), ENNReal.ofReal (‖f a‖ * ‖g a‖) ∂μ = ∫⁻ (a : α), ((fun x => ‖f x‖ₑ) * fun x => ‖g x‖ₑ) a ∂μ
h_right_f : ∫⁻ (a : α), ENNReal.ofReal (‖f a‖ ^ p) ∂μ = ∫⁻ (a : α), ‖f a‖ₑ ^ p ∂μ
h_right_g : ∫⁻ (a : α), ENNReal.ofReal (‖g a‖ ^ q) ∂μ = ∫⁻ (a : α), ‖g a‖ₑ ^ q ∂μ
⊢ (∫⁻ (a : α), ((fun x => ‖f x‖ₑ) * fun x => ‖g x‖ₑ) a ∂μ).toReal ≤
((∫⁻ (a : α), ‖f a‖ₑ ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), ‖g a‖ₑ ^ q ∂μ) ^ (1 / q)).toReal
|
refine ENNReal.toReal_mono ?_ ?_
|
case refine_1
α : Type u_1
m : MeasurableSpace α
μ : Measure α
E : Type u_7
inst✝ : NormedAddCommGroup E
f g : α → E
p q : ℝ
hpq : p.IsConjExponent q
hf : MemLp f (ENNReal.ofReal p) μ
hg : MemLp g (ENNReal.ofReal q) μ
h_left : ∫⁻ (a : α), ENNReal.ofReal (‖f a‖ * ‖g a‖) ∂μ = ∫⁻ (a : α), ((fun x => ‖f x‖ₑ) * fun x => ‖g x‖ₑ) a ∂μ
h_right_f : ∫⁻ (a : α), ENNReal.ofReal (‖f a‖ ^ p) ∂μ = ∫⁻ (a : α), ‖f a‖ₑ ^ p ∂μ
h_right_g : ∫⁻ (a : α), ENNReal.ofReal (‖g a‖ ^ q) ∂μ = ∫⁻ (a : α), ‖g a‖ₑ ^ q ∂μ
⊢ (∫⁻ (a : α), ‖f a‖ₑ ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), ‖g a‖ₑ ^ q ∂μ) ^ (1 / q) ≠ ⊤
case refine_2
α : Type u_1
m : MeasurableSpace α
μ : Measure α
E : Type u_7
inst✝ : NormedAddCommGroup E
f g : α → E
p q : ℝ
hpq : p.IsConjExponent q
hf : MemLp f (ENNReal.ofReal p) μ
hg : MemLp g (ENNReal.ofReal q) μ
h_left : ∫⁻ (a : α), ENNReal.ofReal (‖f a‖ * ‖g a‖) ∂μ = ∫⁻ (a : α), ((fun x => ‖f x‖ₑ) * fun x => ‖g x‖ₑ) a ∂μ
h_right_f : ∫⁻ (a : α), ENNReal.ofReal (‖f a‖ ^ p) ∂μ = ∫⁻ (a : α), ‖f a‖ₑ ^ p ∂μ
h_right_g : ∫⁻ (a : α), ENNReal.ofReal (‖g a‖ ^ q) ∂μ = ∫⁻ (a : α), ‖g a‖ₑ ^ q ∂μ
⊢ ∫⁻ (a : α), ((fun x => ‖f x‖ₑ) * fun x => ‖g x‖ₑ) a ∂μ ≤
(∫⁻ (a : α), ‖f a‖ₑ ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), ‖g a‖ₑ ^ q ∂μ) ^ (1 / q)
|
539c08192e88a140
|
ENNReal.eq_zero_of_le_mul_pow
|
Mathlib/Analysis/SpecificLimits/Basic.lean
|
lemma ENNReal.eq_zero_of_le_mul_pow {x r : ℝ≥0∞} {ε : ℝ≥0} (hr : r < 1)
(h : ∀ n : ℕ, x ≤ ε * r ^ n) : x = 0
|
x r : ℝ≥0∞
ε : ℝ≥0
hr : r < 1
h : ∀ (n : ℕ), x ≤ ↑ε * r ^ n
⊢ x = 0
|
rw [← nonpos_iff_eq_zero]
|
x r : ℝ≥0∞
ε : ℝ≥0
hr : r < 1
h : ∀ (n : ℕ), x ≤ ↑ε * r ^ n
⊢ x ≤ 0
|
f0c4433f60379c13
|
Multiset.countP_map
|
Mathlib/Data/Multiset/Filter.lean
|
theorem countP_map (f : α → β) (s : Multiset α) (p : β → Prop) [DecidablePred p] :
countP p (map f s) = card (s.filter fun a => p (f a))
|
α : Type u_1
β : Type v
f : α → β
s : Multiset α
p : β → Prop
inst✝ : DecidablePred p
⊢ countP p (map f s) = (filter (fun a => p (f a)) s).card
|
refine Multiset.induction_on s ?_ fun a t IH => ?_
|
case refine_1
α : Type u_1
β : Type v
f : α → β
s : Multiset α
p : β → Prop
inst✝ : DecidablePred p
⊢ countP p (map f 0) = (filter (fun a => p (f a)) 0).card
case refine_2
α : Type u_1
β : Type v
f : α → β
s : Multiset α
p : β → Prop
inst✝ : DecidablePred p
a : α
t : Multiset α
IH : countP p (map f t) = (filter (fun a => p (f a)) t).card
⊢ countP p (map f (a ::ₘ t)) = (filter (fun a => p (f a)) (a ::ₘ t)).card
|
d40fb82936487e92
|
mem_affineSpan_iff_eq_weightedVSubOfPoint_vadd
|
Mathlib/LinearAlgebra/AffineSpace/Combination.lean
|
theorem mem_affineSpan_iff_eq_weightedVSubOfPoint_vadd [Nontrivial k] (p : ι → P) (j : ι) (q : P) :
q ∈ affineSpan k (Set.range p) ↔
∃ (s : Finset ι) (w : ι → k), q = s.weightedVSubOfPoint p (p j) w +ᵥ p j
|
ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
p : ι → P
j : ι
s : Finset ι
w : ι → k
w' : ι → k := Function.update w j (1 - (s \ {j}).sum w)
⊢ (insert j s).sum w' = 1
|
by_cases hj : j ∈ s
|
case pos
ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
p : ι → P
j : ι
s : Finset ι
w : ι → k
w' : ι → k := Function.update w j (1 - (s \ {j}).sum w)
hj : j ∈ s
⊢ (insert j s).sum w' = 1
case neg
ι : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
p : ι → P
j : ι
s : Finset ι
w : ι → k
w' : ι → k := Function.update w j (1 - (s \ {j}).sum w)
hj : j ∉ s
⊢ (insert j s).sum w' = 1
|
40a3291069dee08b
|
CategoryTheory.Idempotents.isIdempotentComplete_of_isIdempotentComplete_opposite
|
Mathlib/CategoryTheory/Idempotents/Basic.lean
|
theorem isIdempotentComplete_of_isIdempotentComplete_opposite (h : IsIdempotentComplete Cᵒᵖ) :
IsIdempotentComplete C
|
case h.right
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : Cᵒᵖ
i : Y ⟶ op X
e : op X ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p.op
⊢ i.unop ≫ e.unop = p
|
simp only [← unop_comp, h₂]
|
case h.right
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : Cᵒᵖ
i : Y ⟶ op X
e : op X ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p.op
⊢ p.op.unop = p
|
4c640b5c10f1f344
|
CliffordAlgebraComplex.reverse_apply
|
Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
|
theorem reverse_apply (x : CliffordAlgebra Q) : reverse (R := ℝ) x = x
|
case mul
x₁ x₂ : CliffordAlgebra Q
hx₁ : reverse x₁ = x₁
hx₂ : reverse x₂ = x₂
⊢ reverse (x₁ * x₂) = x₁ * x₂
|
rw [reverse.map_mul, mul_comm, hx₁, hx₂]
|
no goals
|
57b6b0031cb9b658
|
Vitali.exists_disjoint_covering_ae
|
Mathlib/MeasureTheory/Covering/Vitali.lean
|
theorem exists_disjoint_covering_ae
[PseudoMetricSpace α] [MeasurableSpace α] [OpensMeasurableSpace α]
[SecondCountableTopology α] (μ : Measure α) [IsLocallyFiniteMeasure μ] (s : Set α) (t : Set ι)
(C : ℝ≥0) (r : ι → ℝ) (c : ι → α) (B : ι → Set α) (hB : ∀ a ∈ t, B a ⊆ closedBall (c a) (r a))
(μB : ∀ a ∈ t, μ (closedBall (c a) (3 * r a)) ≤ C * μ (B a))
(ht : ∀ a ∈ t, (interior (B a)).Nonempty) (h't : ∀ a ∈ t, IsClosed (B a))
(hf : ∀ x ∈ s, ∀ ε > (0 : ℝ), ∃ a ∈ t, r a ≤ ε ∧ c a = x) :
∃ u ⊆ t, u.Countable ∧ u.PairwiseDisjoint B ∧ μ (s \ ⋃ a ∈ u, B a) = 0
|
case intro.intro
α : Type u_1
ι : Type u_2
inst✝⁴ : PseudoMetricSpace α
inst✝³ : MeasurableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : SecondCountableTopology α
μ : Measure α
inst✝ : IsLocallyFiniteMeasure μ
s : Set α
t : Set ι
C : ℝ≥0
r : ι → ℝ
c : ι → α
B : ι → Set α
hB : ∀ a ∈ t, B a ⊆ closedBall (c a) (r a)
μB : ∀ a ∈ t, μ (closedBall (c a) (3 * r a)) ≤ ↑C * μ (B a)
ht : ∀ a ∈ t, (interior (B a)).Nonempty
h't : ∀ a ∈ t, IsClosed (B a)
hf : ∀ x ∈ s, ∀ ε > 0, ∃ a ∈ t, r a ≤ ε ∧ c a = x
R : α → ℝ
hR0 : ∀ (x : α), 0 < R x
hR1 : ∀ (x : α), R x ≤ 1
hRμ : ∀ (x : α), μ (closedBall x (20 * R x)) < ⊤
t' : Set ι := {a | a ∈ t ∧ r a ≤ R (c a)}
u : Set ι
ut' : u ⊆ t'
u_disj : u.PairwiseDisjoint B
hu : ∀ a ∈ t', ∃ b ∈ u, (B a ∩ B b).Nonempty ∧ r a ≤ 2 * r b
ut : u ⊆ t
u_count : u.Countable
x : α
x✝ : x ∈ s \ ⋃ a ∈ u, B a
v : Set ι := {a | a ∈ u ∧ (B a ∩ ball x (R x)).Nonempty}
vu : v ⊆ u
Idist_v : ∀ a ∈ v, dist (c a) x ≤ r a + R x
R0 : ℝ := sSup (r '' v)
R0_def : R0 = sSup (r '' v)
b : ι
hb : b ∈ v
hr' : r b ∈ r '' v
⊢ r b ≤ 1
|
exact le_trans (ut' (vu hb)).2 (hR1 (c b))
|
no goals
|
4466d2fc3e80cb3f
|
Submodule.span_insert_zero
|
Mathlib/LinearAlgebra/Span/Defs.lean
|
theorem span_insert_zero : span R (insert (0 : M) s) = span R s
|
R : Type u_1
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set M
⊢ span R (insert 0 s) ≤ span R s
|
rw [span_le, Set.insert_subset_iff]
|
R : Type u_1
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set M
⊢ 0 ∈ ↑(span R s) ∧ s ⊆ ↑(span R s)
|
0379c410c2f6e1de
|
Ideal.Filtration.submodule_fg_iff_stable
|
Mathlib/RingTheory/Filtration.lean
|
theorem submodule_fg_iff_stable (hF' : ∀ i, (F.N i).FG) : F.submodule.FG ↔ F.Stable
|
case mpr.intro.h.mk.intro
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F : I.Filtration M
hF' : ∀ (i : ℕ), (F.N i).FG
n : ℕ
hn : F.submodule = Submodule.span (↥(reesAlgebra I)) (⋃ i, ⋃ (_ : i ≤ n), ⇑(single R i) '' ↑(F.N i))
i : ℕ
hi : i ∈ Finset.range n.succ
s : Finset M
hs : Submodule.span R ↑s = F.N i
this :
Submodule.span ↥(reesAlgebra I) ↑(Finset.image (⇑(lsingle R i)) s) =
Submodule.span (↥(reesAlgebra I)) (⇑(single R i) '' ↑(F.N i))
⊢ (Submodule.span ↥(reesAlgebra I) ↑(Finset.image (⇑(lsingle R i)) s)).FG
|
exact ⟨_, rfl⟩
|
no goals
|
7d72d199901d100d
|
MeasureTheory.eLpNorm_map_measure
|
Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
|
theorem eLpNorm_map_measure (hg : AEStronglyMeasurable g (Measure.map f μ))
(hf : AEMeasurable f μ) : eLpNorm g p (Measure.map f μ) = eLpNorm (g ∘ f) p μ
|
case neg
α : Type u_1
E : Type u_3
m0 : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
inst✝ : NormedAddCommGroup E
β : Type u_6
mβ : MeasurableSpace β
f : α → β
g : β → E
hg : AEStronglyMeasurable g (Measure.map f μ)
hf : AEMeasurable f μ
hp_zero : ¬p = 0
hp_top : ¬p = ⊤
⊢ (∫⁻ (x : β), ‖g x‖ₑ ^ p.toReal ∂Measure.map f μ) ^ (1 / p.toReal) =
(∫⁻ (x : α), ‖(g ∘ f) x‖ₑ ^ p.toReal ∂μ) ^ (1 / p.toReal)
|
rw [lintegral_map' (hg.enorm.pow_const p.toReal) hf]
|
case neg
α : Type u_1
E : Type u_3
m0 : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
inst✝ : NormedAddCommGroup E
β : Type u_6
mβ : MeasurableSpace β
f : α → β
g : β → E
hg : AEStronglyMeasurable g (Measure.map f μ)
hf : AEMeasurable f μ
hp_zero : ¬p = 0
hp_top : ¬p = ⊤
⊢ (∫⁻ (a : α), ‖g (f a)‖ₑ ^ p.toReal ∂μ) ^ (1 / p.toReal) = (∫⁻ (x : α), ‖(g ∘ f) x‖ₑ ^ p.toReal ∂μ) ^ (1 / p.toReal)
|
4caee505b835d28d
|
CategoryTheory.Functor.distTriang_iff
|
Mathlib/CategoryTheory/Localization/Triangulated.lean
|
lemma distTriang_iff (T : Triangle D) :
(T ∈ distTriang D) ↔ T ∈ L.essImageDistTriang
|
C : Type u_1
D : Type u_2
inst✝¹⁴ : Category.{u_4, u_1} C
inst✝¹³ : Category.{u_3, u_2} D
L : C ⥤ D
inst✝¹² : HasShift C ℤ
inst✝¹¹ : Preadditive C
inst✝¹⁰ : HasZeroObject C
inst✝⁹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝⁸ : Pretriangulated C
inst✝⁷ : HasShift D ℤ
inst✝⁶ : L.CommShift ℤ
inst✝⁵ : HasZeroObject D
inst✝⁴ : Preadditive D
inst✝³ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝² : Pretriangulated D
inst✝¹ : L.mapArrow.EssSurj
inst✝ : L.IsTriangulated
T : Triangle D
⊢ T ∈ distinguishedTriangles ↔ T ∈ L.essImageDistTriang
|
constructor
|
case mp
C : Type u_1
D : Type u_2
inst✝¹⁴ : Category.{u_4, u_1} C
inst✝¹³ : Category.{u_3, u_2} D
L : C ⥤ D
inst✝¹² : HasShift C ℤ
inst✝¹¹ : Preadditive C
inst✝¹⁰ : HasZeroObject C
inst✝⁹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝⁸ : Pretriangulated C
inst✝⁷ : HasShift D ℤ
inst✝⁶ : L.CommShift ℤ
inst✝⁵ : HasZeroObject D
inst✝⁴ : Preadditive D
inst✝³ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝² : Pretriangulated D
inst✝¹ : L.mapArrow.EssSurj
inst✝ : L.IsTriangulated
T : Triangle D
⊢ T ∈ distinguishedTriangles → T ∈ L.essImageDistTriang
case mpr
C : Type u_1
D : Type u_2
inst✝¹⁴ : Category.{u_4, u_1} C
inst✝¹³ : Category.{u_3, u_2} D
L : C ⥤ D
inst✝¹² : HasShift C ℤ
inst✝¹¹ : Preadditive C
inst✝¹⁰ : HasZeroObject C
inst✝⁹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝⁸ : Pretriangulated C
inst✝⁷ : HasShift D ℤ
inst✝⁶ : L.CommShift ℤ
inst✝⁵ : HasZeroObject D
inst✝⁴ : Preadditive D
inst✝³ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝² : Pretriangulated D
inst✝¹ : L.mapArrow.EssSurj
inst✝ : L.IsTriangulated
T : Triangle D
⊢ T ∈ L.essImageDistTriang → T ∈ distinguishedTriangles
|
274f43afcadc904a
|
EuclideanGeometry.cospherical_iff_exists_mem_of_complete
|
Mathlib/Geometry/Euclidean/Circumcenter.lean
|
theorem cospherical_iff_exists_mem_of_complete {s : AffineSubspace ℝ P} {ps : Set P} (h : ps ⊆ s)
[Nonempty s] [HasOrthogonalProjection s.direction] :
Cospherical ps ↔ ∃ center ∈ s, ∃ radius : ℝ, ∀ p ∈ ps, dist p center = radius
|
case mp
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
⊢ Cospherical ps → ∃ center ∈ s, ∃ radius, ∀ p ∈ ps, dist p center = radius
|
rintro ⟨c, hcr⟩
|
case mp.intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
c : P
hcr : ∃ radius, ∀ p ∈ ps, dist p c = radius
⊢ ∃ center ∈ s, ∃ radius, ∀ p ∈ ps, dist p center = radius
|
53e93c5b7b48c976
|
DFinsupp.mapRange.addMonoidHom_comp
|
Mathlib/Data/DFinsupp/Defs.lean
|
theorem mapRange.addMonoidHom_comp (f : ∀ i, β₁ i →+ β₂ i) (f₂ : ∀ i, β i →+ β₁ i) :
(mapRange.addMonoidHom fun i => (f i).comp (f₂ i)) =
(mapRange.addMonoidHom f).comp (mapRange.addMonoidHom f₂)
|
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i →+ β₂ i
f₂ : (i : ι) → β i →+ β₁ i
⊢ (addMonoidHom fun i => (f i).comp (f₂ i)) = (addMonoidHom f).comp (addMonoidHom f₂)
|
refine AddMonoidHom.ext <| mapRange_comp (fun i x => f i x) (fun i x => f₂ i x) ?_ ?_ ?_
|
case refine_1
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i →+ β₂ i
f₂ : (i : ι) → β i →+ β₁ i
⊢ ∀ (i : ι), (fun i x => (f i) x) i 0 = 0
case refine_2
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i →+ β₂ i
f₂ : (i : ι) → β i →+ β₁ i
⊢ ∀ (i : ι), (fun i x => (f₂ i) x) i 0 = 0
case refine_3
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i →+ β₂ i
f₂ : (i : ι) → β i →+ β₁ i
⊢ ∀ (i : ι), ((fun i x => (f i) x) i ∘ (fun i x => (f₂ i) x) i) 0 = 0
|
f5b74fc335cfe878
|
VitaliFamily.measure_limRatioMeas_zero
|
Mathlib/MeasureTheory/Covering/Differentiation.lean
|
theorem measure_limRatioMeas_zero : ρ {x | v.limRatioMeas hρ x = 0} = 0
|
α : Type u_1
inst✝⁴ : PseudoMetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
x : α
x✝ : x ∈ {x | v.limRatioMeas hρ x = 0}
o : Set α
xo : x ∈ o
o_open : IsOpen o
μo : μ o < ⊤
s : Set α := {x | v.limRatioMeas hρ x = 0} ∩ o
μs : μ s ≠ ⊤
q : ℝ≥0
hq : 0 < q
y : α
hy : y ∈ s
this : v.limRatioMeas hρ y = 0
⊢ y ∈ {x | v.limRatioMeas hρ x < ↑q}
|
simp only [this, mem_setOf_eq, hq, ENNReal.coe_pos]
|
no goals
|
1ff6cbb082b8eb59
|
SetTheory.PGame.Numeric.add
|
Mathlib/SetTheory/Surreal/Basic.lean
|
theorem add : ∀ {x y : PGame} (_ : Numeric x) (_ : Numeric y), Numeric (x + y)
| ⟨xl, xr, xL, xR⟩, ⟨yl, yr, yL, yR⟩, ox, oy =>
⟨by
rintro (ix | iy) (jx | jy)
· exact add_lt_add_right (ox.1 ix jx) _
· exact (add_lf_add_of_lf_of_le (lf_mk _ _ ix) (oy.le_moveRight jy)).lt
((ox.moveLeft ix).add oy) (ox.add (oy.moveRight jy))
· exact (add_lf_add_of_lf_of_le (mk_lf _ _ jx) (oy.moveLeft_le iy)).lt
(ox.add (oy.moveLeft iy)) ((ox.moveRight jx).add oy)
· exact add_lt_add_left (oy.1 iy jy) ⟨xl, xr, xL, xR⟩, by
constructor
· rintro (ix | iy)
· exact (ox.moveLeft ix).add oy
· exact ox.add (oy.moveLeft iy)
· rintro (jx | jy)
· apply (ox.moveRight jx).add oy
· apply ox.add (oy.moveRight jy)⟩
termination_by x y => (x, y)
|
case left
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
ox : (PGame.mk xl xr xL xR).Numeric
oy : (PGame.mk yl yr yL yR).Numeric
⊢ ∀ (i : xl ⊕ yl),
((fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xL a))
i (PGame.mk yl yr yL yR))
(fun a =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr)
(fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t)
fun t => Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xL a))
i y)
IHyl t)
fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xR a))
i y)
IHyr t)
(yL a))
t)
i).Numeric
|
rintro (ix | iy)
|
case left.inl
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
ox : (PGame.mk xl xr xL xR).Numeric
oy : (PGame.mk yl yr yL yR).Numeric
ix : xl
⊢ ((fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xL a))
i (PGame.mk yl yr yL yR))
(fun a =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr)
(fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xL a))
i y)
IHyl t)
fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xR a))
i y)
IHyr t)
(yL a))
t)
(Sum.inl ix)).Numeric
case left.inr
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
ox : (PGame.mk xl xr xL xR).Numeric
oy : (PGame.mk yl yr yL yR).Numeric
iy : yl
⊢ ((fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xL a))
i (PGame.mk yl yr yL yR))
(fun a =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr)
(fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xL a))
i y)
IHyl t)
fun t =>
Sum.rec
(fun i =>
(fun a =>
rec (motive := fun x => PGame → PGame)
(fun xl xr a a IHxl IHxr y =>
rec
(fun yl yr yL yR IHyl IHyr =>
let_fun y := PGame.mk yl yr yL yR;
PGame.mk (xl ⊕ yl) (xr ⊕ yr) (fun t => Sum.rec (fun i => IHxl i y) IHyl t) fun t =>
Sum.rec (fun i => IHxr i y) IHyr t)
y)
(xR a))
i y)
IHyr t)
(yL a))
t)
(Sum.inr iy)).Numeric
|
fb960894a76bd8f8
|
MonomialOrder.Monic.prod
|
Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean
|
theorem Monic.prod {ι : Type*} {P : ι → MvPolynomial σ R} {s : Finset ι}
(H : ∀ i ∈ s, m.Monic (P i)) :
m.Monic (∏ i ∈ s, P i)
|
σ : Type u_1
m : MonomialOrder σ
R : Type u_2
inst✝ : CommSemiring R
ι : Type u_3
P : ι → MvPolynomial σ R
s : Finset ι
H : ∀ i ∈ s, m.Monic (P i)
⊢ ∀ i ∈ s, IsRegular (m.leadingCoeff (P i))
|
intro i hi
|
σ : Type u_1
m : MonomialOrder σ
R : Type u_2
inst✝ : CommSemiring R
ι : Type u_3
P : ι → MvPolynomial σ R
s : Finset ι
H : ∀ i ∈ s, m.Monic (P i)
i : ι
hi : i ∈ s
⊢ IsRegular (m.leadingCoeff (P i))
|
b6dfccd4b783abc5
|
CategoryTheory.IsCofilteredOrEmpty.of_left_adjoint
|
Mathlib/CategoryTheory/Filtered/Basic.lean
|
theorem of_left_adjoint {L : C ⥤ D} {R : D ⥤ C} (h : L ⊣ R) : IsCofilteredOrEmpty D :=
{ cone_objs := fun X Y =>
⟨L.obj (min (R.obj X) (R.obj Y)), (h.homEquiv _ X).symm (minToLeft _ _),
(h.homEquiv _ Y).symm (minToRight _ _), ⟨⟩⟩
cone_maps := fun X Y f g =>
⟨L.obj (eq (R.map f) (R.map g)), (h.homEquiv _ _).symm (eqHom _ _), by
rw [← h.homEquiv_naturality_right_symm, ← h.homEquiv_naturality_right_symm, eq_condition]⟩ }
|
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : IsCofilteredOrEmpty C
D : Type u₁
inst✝ : Category.{v₁, u₁} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X Y : D
f g : X ⟶ Y
⊢ (h.homEquiv (eq (R.map f) (R.map g)) X).symm (eqHom (R.map f) (R.map g)) ≫ f =
(h.homEquiv (eq (R.map f) (R.map g)) X).symm (eqHom (R.map f) (R.map g)) ≫ g
|
rw [← h.homEquiv_naturality_right_symm, ← h.homEquiv_naturality_right_symm, eq_condition]
|
no goals
|
15cbf31b2fe278bb
|
IsDenseInducing.extend_Z_bilin_key
|
Mathlib/Topology/Algebra/UniformGroup/Defs.lean
|
theorem extend_Z_bilin_key (x₀ : α) (y₀ : γ) : ∃ U ∈ comap e (𝓝 x₀), ∃ V ∈ comap f (𝓝 y₀),
∀ x ∈ U, ∀ x' ∈ U, ∀ (y) (_ : y ∈ V) (y') (_ : y' ∈ V),
(fun p : β × δ => φ p.1 p.2) (x', y') - (fun p : β × δ => φ p.1 p.2) (x, y) ∈ W'
|
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝¹² : TopologicalSpace α
inst✝¹¹ : AddCommGroup α
inst✝¹⁰ : IsTopologicalAddGroup α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : AddCommGroup β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : AddCommGroup γ
inst✝⁵ : IsTopologicalAddGroup γ
inst✝⁴ : TopologicalSpace δ
inst✝³ : AddCommGroup δ
inst✝² : UniformSpace G
inst✝¹ : AddCommGroup G
e : β →+ α
de : IsDenseInducing ⇑e
f : δ →+ γ
df : IsDenseInducing ⇑f
φ : β →+ δ →+ G
hφ : Continuous fun p => (φ p.1) p.2
W' : Set G
W'_nhd : W' ∈ 𝓝 0
inst✝ : UniformAddGroup G
x₀ : α
y₀ : γ
ee : β × β → α × α := fun u => (e u.1, e u.2)
ff : δ × δ → γ × γ := fun u => (f u.1, f u.2)
lim_φ : Tendsto (fun p => (φ p.1) p.2) (𝓝 (0, 0)) (𝓝 0)
lim_φ_sub_sub :
Tendsto (fun p => (fun p => (φ p.1) p.2) (p.1.2 - p.1.1, p.2.2 - p.2.1))
(comap ee (𝓝 (x₀, x₀)) ×ˢ comap ff (𝓝 (y₀, y₀))) (𝓝 0)
W : Set G
W_nhd : W ∈ 𝓝 0
W4 : ∀ {v w s t : G}, v ∈ W → w ∈ W → s ∈ W → t ∈ W → v + w + s + t ∈ W'
U₁ : Set β
U₁_nhd : U₁ ∈ comap (⇑e) (𝓝 x₀)
V₁ : Set δ
V₁_nhd : V₁ ∈ comap (⇑f) (𝓝 y₀)
H : ∀ x ∈ U₁, ∀ x' ∈ U₁, ∀ y ∈ V₁, ∀ y' ∈ V₁, (fun p => (φ p.1) p.2) (x' - x, y' - y) ∈ W
x₁ : β
x₁_in : x₁ ∈ U₁
y₁ : δ
y₁_in : y₁ ∈ V₁
⊢ Continuous ((fun p => (φ p.1) p.2) ∘ Prod.swap)
|
exact hφ.comp continuous_swap
|
no goals
|
7e13666b5fc1d57e
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_invariant_helper
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean
|
theorem confirmRupHint_preserves_invariant_helper {n : Nat} (f : DefaultFormula n)
(f_assignments_size : f.assignments.size = n)
(acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool) (hsize : acc.1.size = n)
(l : Literal (PosFin n)) (ih : DerivedLitsInvariant f f_assignments_size acc.1 hsize acc.2.1)
(h : ¬hasAssignment l.snd acc.fst[l.fst.val]! = true) :
have hsize' : (Array.modify acc.1 l.1.1 (addAssignment l.snd)).size = n
|
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool
hsize : acc.fst.size = n
l : Literal (PosFin n)
ih : f.DerivedLitsInvariant f_assignments_size acc.fst hsize acc.snd.fst
h : ¬hasAssignment l.snd acc.fst[l.fst.val]! = true
hsize'✝ : (acc.fst.modify l.fst.val (addAssignment l.snd)).size = n :=
Eq.mpr (id (congrArg (fun _a => _a = n) (Array.size_modify acc.fst l.fst.val (addAssignment l.snd)))) hsize
i : Fin n
i_in_bounds : ↑i < acc.fst.size
l_in_bounds : l.fst.val < acc.fst.size
j1 j2 : Fin (List.length acc.snd.fst)
j1_eq_i : (List.get acc.snd.fst j1).fst.val = ↑i
j2_eq_i : (List.get acc.snd.fst j2).fst.val = ↑i
j1_eq_true : (List.get acc.snd.fst j1).snd = true
j2_eq_false : (List.get acc.snd.fst j2).snd = false
h1 : acc.fst[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin (List.length acc.snd.fst)), k ≠ j1 → k ≠ j2 → (List.get acc.snd.fst k).fst.val ≠ ↑i
j1_succ_in_bounds : ↑j1 + 1 < (l :: acc.snd.fst).length
j2_succ_in_bounds : ↑j2 + 1 < (l :: acc.snd.fst).length
j1_succ : Fin (l :: acc.snd.fst).length := ⟨↑j1 + 1, j1_succ_in_bounds⟩
j2_succ : Fin (l :: acc.snd.fst).length := ⟨↑j2 + 1, j2_succ_in_bounds⟩
l_ne_i : l.fst.val ≠ ↑i
k : Fin (List.length acc.snd.fst + 1)
k_ne_j1_succ : ¬k = j1_succ
k_ne_j2_succ : ¬k = j2_succ
zero_in_bounds : 0 < (l :: acc.snd.fst).length
k_ne_zero : ¬k = ⟨0, zero_in_bounds⟩
⊢ ∃ k' k'_succ_in_bounds, k = ⟨k' + 1, k'_succ_in_bounds⟩
|
have k_val_ne_zero : k.1 ≠ 0 := by
intro k_eq_zero
simp only [List.length_cons, ← k_eq_zero, ne_eq, not_true] at k_ne_zero
|
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool
hsize : acc.fst.size = n
l : Literal (PosFin n)
ih : f.DerivedLitsInvariant f_assignments_size acc.fst hsize acc.snd.fst
h : ¬hasAssignment l.snd acc.fst[l.fst.val]! = true
hsize'✝ : (acc.fst.modify l.fst.val (addAssignment l.snd)).size = n :=
Eq.mpr (id (congrArg (fun _a => _a = n) (Array.size_modify acc.fst l.fst.val (addAssignment l.snd)))) hsize
i : Fin n
i_in_bounds : ↑i < acc.fst.size
l_in_bounds : l.fst.val < acc.fst.size
j1 j2 : Fin (List.length acc.snd.fst)
j1_eq_i : (List.get acc.snd.fst j1).fst.val = ↑i
j2_eq_i : (List.get acc.snd.fst j2).fst.val = ↑i
j1_eq_true : (List.get acc.snd.fst j1).snd = true
j2_eq_false : (List.get acc.snd.fst j2).snd = false
h1 : acc.fst[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin (List.length acc.snd.fst)), k ≠ j1 → k ≠ j2 → (List.get acc.snd.fst k).fst.val ≠ ↑i
j1_succ_in_bounds : ↑j1 + 1 < (l :: acc.snd.fst).length
j2_succ_in_bounds : ↑j2 + 1 < (l :: acc.snd.fst).length
j1_succ : Fin (l :: acc.snd.fst).length := ⟨↑j1 + 1, j1_succ_in_bounds⟩
j2_succ : Fin (l :: acc.snd.fst).length := ⟨↑j2 + 1, j2_succ_in_bounds⟩
l_ne_i : l.fst.val ≠ ↑i
k : Fin (List.length acc.snd.fst + 1)
k_ne_j1_succ : ¬k = j1_succ
k_ne_j2_succ : ¬k = j2_succ
zero_in_bounds : 0 < (l :: acc.snd.fst).length
k_ne_zero : ¬k = ⟨0, zero_in_bounds⟩
k_val_ne_zero : ↑k ≠ 0
⊢ ∃ k' k'_succ_in_bounds, k = ⟨k' + 1, k'_succ_in_bounds⟩
|
02ca1706b397b254
|
isAlgebraic_of_isFractionRing
|
Mathlib/RingTheory/Localization/Integral.lean
|
lemma isAlgebraic_of_isFractionRing {R S} (K L) [CommRing R] [CommRing S] [Field K] [CommRing L]
[Algebra R S] [Algebra R K] [Algebra R L] [Algebra S L] [Algebra K L] [IsScalarTower R S L]
[IsScalarTower R K L] [IsFractionRing S L]
[Algebra.IsIntegral R S] : Algebra.IsAlgebraic K L
|
case isAlgebraic.intro.intro.a.hy
R : Type u_5
S : Type u_6
K : Type u_7
L : Type u_8
inst✝¹² : CommRing R
inst✝¹¹ : CommRing S
inst✝¹⁰ : Field K
inst✝⁹ : CommRing L
inst✝⁸ : Algebra R S
inst✝⁷ : Algebra R K
inst✝⁶ : Algebra R L
inst✝⁵ : Algebra S L
inst✝⁴ : Algebra K L
inst✝³ : IsScalarTower R S L
inst✝² : IsScalarTower R K L
inst✝¹ : IsFractionRing S L
inst✝ : Algebra.IsIntegral R S
x : S
s : ↥S⁰
⊢ (algebraMap K L).IsIntegralElem (mk' L 1 s)
|
show IsIntegral _ _
|
case isAlgebraic.intro.intro.a.hy
R : Type u_5
S : Type u_6
K : Type u_7
L : Type u_8
inst✝¹² : CommRing R
inst✝¹¹ : CommRing S
inst✝¹⁰ : Field K
inst✝⁹ : CommRing L
inst✝⁸ : Algebra R S
inst✝⁷ : Algebra R K
inst✝⁶ : Algebra R L
inst✝⁵ : Algebra S L
inst✝⁴ : Algebra K L
inst✝³ : IsScalarTower R S L
inst✝² : IsScalarTower R K L
inst✝¹ : IsFractionRing S L
inst✝ : Algebra.IsIntegral R S
x : S
s : ↥S⁰
⊢ IsIntegral K (mk' L 1 s)
|
ae4f70dc8f48707d
|
Submodule.spanRank_toENat_eq_iInf_finset_card
|
Mathlib/Algebra/Module/SpanRank.lean
|
lemma spanRank_toENat_eq_iInf_finset_card (p : Submodule R M) :
p.spanRank.toENat =
⨅ (s : {s : Set M // s.Finite ∧ span R s = p}), (s.2.1.toFinset.card : ℕ∞)
|
case inl
R : Type u_1
M : Type u
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
h1 : ⨅ s, ⨅ (_ : span R s = p), s.encard = ⊤
⊢ ⨅ s, ↑⋯.toFinset.card = ⊤
|
simp_rw [iInf_eq_top] at h1 ⊢
|
case inl
R : Type u_1
M : Type u
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
h1 : ∀ (i : Set M), span R i = p → i.encard = ⊤
⊢ ∀ (i : { s // s.Finite ∧ span R s = p }), ↑⋯.toFinset.card = ⊤
|
f74636938a98e2b3
|
Finsupp.filter_pos_add_filter_neg
|
Mathlib/Data/Finsupp/Basic.lean
|
theorem filter_pos_add_filter_neg [AddZeroClass M] (f : α →₀ M) (p : α → Prop) [DecidablePred p] :
(f.filter p + f.filter fun a => ¬p a) = f :=
DFunLike.coe_injective <| by
simp only [coe_add, filter_eq_indicator]
exact Set.indicator_self_add_compl { x | p x } f
|
α : Type u_1
M : Type u_5
inst✝¹ : AddZeroClass M
f : α →₀ M
p : α → Prop
inst✝ : DecidablePred p
⊢ (fun f => ⇑f) (filter p f + filter (fun a => ¬p a) f) = (fun f => ⇑f) f
|
simp only [coe_add, filter_eq_indicator]
|
α : Type u_1
M : Type u_5
inst✝¹ : AddZeroClass M
f : α →₀ M
p : α → Prop
inst✝ : DecidablePred p
⊢ {x | p x}.indicator ⇑f + {a | ¬p a}.indicator ⇑f = ⇑f
|
08c2ba5abccc381f
|
Nimber.add_eq_zero
|
Mathlib/SetTheory/Nimber/Basic.lean
|
theorem add_eq_zero {a b : Nimber} : a + b = 0 ↔ a = b
|
case mp.inr.inl
a : Nimber
hab : a + a = 0
⊢ a = a
|
rfl
|
no goals
|
0d57b0f83f981add
|
AlgebraicGeometry.pointsPi_surjective
|
Mathlib/AlgebraicGeometry/PointsPi.lean
|
lemma pointsPi_surjective [CompactSpace X] [∀ i, IsLocalRing (R i)] :
Function.Surjective (pointsPi R X)
|
ι : Type u
R : ι → CommRingCat
X : Scheme
inst✝¹ : CompactSpace ↑↑X.toPresheafedSpace
inst✝ : ∀ (i : ι), IsLocalRing ↑(R i)
f : (i : ι) → Spec (R i) ⟶ X
𝒰 : X.OpenCover := X.affineCover.finiteSubcover
this : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
j : ι → 𝒰.J
hj : ∀ (i : ι), Set.range ⇑(ConcreteCategory.hom (f i).base) ⊆ ↑(Scheme.Hom.opensRange (𝒰.map (j i)))
g : (j₀ : 𝒰.J) → Spec (CommRingCat.of ((i : { i // j i = j₀ }) → ↑(R ↑i))) ⟶ 𝒰.obj j₀
hg :
∀ (j₀ : 𝒰.J) (x : { i // j i = j₀ }),
Spec.map (CommRingCat.ofHom (Pi.evalRingHom (fun x => ↑(R ↑x)) x)) ≫ g j₀ = IsOpenImmersion.lift (𝒰.map j₀) (f ↑x) ⋯
R' : 𝒰.J → CommRingCat := fun j₀ => CommRingCat.of ((i : { i // j i = j₀ }) → ↑(R ↑i))
e : ((i : ι) → ↑(R i)) ≃+* ((j₀ : 𝒰.J) → ↑(R' j₀)) :=
{ toFun := fun f x i => f ↑i, invFun := fun f i => f (j i) ⟨i, ⋯⟩, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯,
map_add' := ⋯ }
⊢ pointsPi R X
(Spec.map (CommRingCat.ofHom e.symm.toRingHom) ≫ inv (sigmaSpec R') ≫ Sigma.desc fun j₀ => g j₀ ≫ 𝒰.map j₀) =
f
|
ext i : 1
|
case h
ι : Type u
R : ι → CommRingCat
X : Scheme
inst✝¹ : CompactSpace ↑↑X.toPresheafedSpace
inst✝ : ∀ (i : ι), IsLocalRing ↑(R i)
f : (i : ι) → Spec (R i) ⟶ X
𝒰 : X.OpenCover := X.affineCover.finiteSubcover
this : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
j : ι → 𝒰.J
hj : ∀ (i : ι), Set.range ⇑(ConcreteCategory.hom (f i).base) ⊆ ↑(Scheme.Hom.opensRange (𝒰.map (j i)))
g : (j₀ : 𝒰.J) → Spec (CommRingCat.of ((i : { i // j i = j₀ }) → ↑(R ↑i))) ⟶ 𝒰.obj j₀
hg :
∀ (j₀ : 𝒰.J) (x : { i // j i = j₀ }),
Spec.map (CommRingCat.ofHom (Pi.evalRingHom (fun x => ↑(R ↑x)) x)) ≫ g j₀ = IsOpenImmersion.lift (𝒰.map j₀) (f ↑x) ⋯
R' : 𝒰.J → CommRingCat := fun j₀ => CommRingCat.of ((i : { i // j i = j₀ }) → ↑(R ↑i))
e : ((i : ι) → ↑(R i)) ≃+* ((j₀ : 𝒰.J) → ↑(R' j₀)) :=
{ toFun := fun f x i => f ↑i, invFun := fun f i => f (j i) ⟨i, ⋯⟩, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯,
map_add' := ⋯ }
i : ι
⊢ pointsPi R X
(Spec.map (CommRingCat.ofHom e.symm.toRingHom) ≫ inv (sigmaSpec R') ≫ Sigma.desc fun j₀ => g j₀ ≫ 𝒰.map j₀) i =
f i
|
35d67c613e419cbd
|
SimpleGraph.ConnectedComponent.mem_coe_supp_of_adj
|
Mathlib/Combinatorics/SimpleGraph/Path.lean
|
lemma mem_coe_supp_of_adj {v w : V} {H : Subgraph G} {c : ConnectedComponent H.coe}
(hv : v ∈ (↑) '' (c : Set H.verts)) (hw : w ∈ H.verts)
(hadj : H.Adj v w) : w ∈ (↑) '' (c : Set H.verts)
|
case h
V : Type u
G : SimpleGraph V
v w : V
H : G.Subgraph
c : H.coe.ConnectedComponent
hw : w ∈ H.verts
hadj : H.Adj v w
w✝ : ↑H.verts
h : w✝ ∈ ↑c ∧ ↑w✝ = v
⊢ ⟨w, hw⟩ ∈ ↑(H.coe.connectedComponentMk w✝) ∧ ↑⟨w, hw⟩ = w
|
exact ⟨connectedComponentMk_eq_of_adj <| Subgraph.Adj.coe <| h.2 ▸ hadj.symm, rfl⟩
|
no goals
|
d0853eeb7056ceb2
|
InnerProductSpaceable.I_prop
|
Mathlib/Analysis/InnerProductSpace/OfNorm.lean
|
theorem I_prop : innerProp' E (I : 𝕜)
|
case neg
𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : I * I = -1
h₁ : ‖-x - y‖ = ‖x + y‖
⊢ 4⁻¹ *
(𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ - 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖ + I * 𝓚 ‖-x + y‖ * 𝓚 ‖-x + y‖ -
I * 𝓚 ‖-x - y‖ * 𝓚 ‖-x - y‖) =
4⁻¹ *
(-I *
(𝓚 ‖x + y‖ * 𝓚 ‖x + y‖ - 𝓚 ‖x - y‖ * 𝓚 ‖x - y‖ + I * 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ -
I * 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖))
|
have h₂ : ‖-x + y‖ = ‖x - y‖ := by rw [← neg_sub, norm_neg, sub_eq_neg_add]
|
case neg
𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : I * I = -1
h₁ : ‖-x - y‖ = ‖x + y‖
h₂ : ‖-x + y‖ = ‖x - y‖
⊢ 4⁻¹ *
(𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ - 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖ + I * 𝓚 ‖-x + y‖ * 𝓚 ‖-x + y‖ -
I * 𝓚 ‖-x - y‖ * 𝓚 ‖-x - y‖) =
4⁻¹ *
(-I *
(𝓚 ‖x + y‖ * 𝓚 ‖x + y‖ - 𝓚 ‖x - y‖ * 𝓚 ‖x - y‖ + I * 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ -
I * 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖))
|
a4c1a41ce4d42a42
|
Fin.coe_orderIso_apply
|
Mathlib/Order/Fin/Basic.lean
|
/-- If `e` is an `orderIso` between `Fin n` and `Fin m`, then `n = m` and `e` is the identity
map. In this lemma we state that for each `i : Fin n` we have `(e i : ℕ) = (i : ℕ)`. -/
@[simp] lemma coe_orderIso_apply (e : Fin n ≃o Fin m) (i : Fin n) : (e i : ℕ) = i
|
case mk
m n : ℕ
e : Fin n ≃o Fin m
i : ℕ
hi : i < n
⊢ ↑(e ⟨i, hi⟩) = i
|
induction' i using Nat.strong_induction_on with i h
|
case mk.h
m n : ℕ
e : Fin n ≃o Fin m
i : ℕ
h : ∀ m_1 < i, ∀ (hi : m_1 < n), ↑(e ⟨m_1, hi⟩) = m_1
hi : i < n
⊢ ↑(e ⟨i, hi⟩) = i
|
f22dc0d8cb79ada4
|
Polynomial.Sequence.degree_strictMono
|
Mathlib/Algebra/Polynomial/Sequence.lean
|
/-- `S i` has strictly monotone degree. -/
lemma degree_strictMono : StrictMono <| degree ∘ S := fun _ _ ↦ by simp
|
R : Type u_1
inst✝ : Semiring R
S : Sequence R
x✝¹ x✝ : ℕ
⊢ x✝¹ < x✝ → (degree ∘ ↑S) x✝¹ < (degree ∘ ↑S) x✝
|
simp
|
no goals
|
c82e90676df63101
|
CategoryTheory.NonPreadditiveAbelian.sub_sub_sub
|
Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
|
theorem sub_sub_sub {X Y : C} (a b c d : X ⟶ Y) : a - c - (b - d) = a - b - (c - d)
|
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ a - c - (b - d) = a - b - (c - d)
|
rw [sub_def, ← lift_sub_lift, sub_def, Category.assoc, σ_comp, prod.lift_map_assoc]
|
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift (prod.lift a b ≫ σ) (prod.lift c d ≫ σ) ≫ σ = a - b - (c - d)
|
f10b3bcf911da574
|
integral_Ioi_cpow_of_lt
|
Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
|
theorem integral_Ioi_cpow_of_lt {a : ℂ} (ha : a.re < -1) {c : ℝ} (hc : 0 < c) :
(∫ t : ℝ in Ioi c, (t : ℂ) ^ a) = -(c : ℂ) ^ (a + 1) / (a + 1)
|
a : ℂ
ha : a.re < -1
c : ℝ
hc : 0 < c
⊢ 0 < -(a.re + 1)
|
linarith
|
no goals
|
548595cb49c80036
|
GenContFract.compExactValue_correctness_of_stream_eq_some_aux_comp
|
Mathlib/Algebra/ContinuedFractions/Computation/CorrectnessTerminating.lean
|
theorem compExactValue_correctness_of_stream_eq_some_aux_comp {a : K} (b c : K)
(fract_a_ne_zero : Int.fract a ≠ 0) :
((⌊a⌋ : K) * b + c) / Int.fract a + b = (b * a + c) / Int.fract a
|
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
a b c : K
fract_a_ne_zero : Int.fract a ≠ 0
⊢ (↑⌊a⌋ * b + c) / Int.fract a + b = (b * a + c) / Int.fract a
|
field_simp [fract_a_ne_zero]
|
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
a b c : K
fract_a_ne_zero : Int.fract a ≠ 0
⊢ ↑⌊a⌋ * b + c + b * Int.fract a = b * a + c
|
4bc31c2d1c2c0d60
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.derivedLitsInvariant_performRupCheck
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean
|
theorem derivedLitsInvariant_performRupCheck {n : Nat} (f : DefaultFormula n) (f_assignments_size : f.assignments.size = n)
(rupHints : Array Nat)
(f'_assignments_size : (performRupCheck f rupHints).1.assignments.size = n) :
let rupCheckRes := performRupCheck f rupHints
DerivedLitsInvariant f f_assignments_size rupCheckRes.1.assignments f'_assignments_size rupCheckRes.2.1
|
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop :=
fun x acc => ∃ hsize, f.DerivedLitsInvariant f_assignments_size acc.fst hsize acc.snd.fst
i : Fin n
⊢ let_fun i_lt_assignments_size := ⋯;
let_fun i_lt_f_assignments_size := ⋯;
let assignments_i := (f.assignments, [], false, false).fst[↑i];
let fassignments_i := f.assignments[↑i];
(assignments_i = fassignments_i ∧
∀ (l : Literal (PosFin n)), l ∈ (f.assignments, [], false, false).snd.fst → l.fst.val ≠ ↑i) ∨
(∃ j,
(List.get (f.assignments, [], false, false).snd.fst j).fst.val = ↑i ∧
assignments_i = addAssignment (List.get (f.assignments, [], false, false).snd.fst j).snd fassignments_i ∧
¬hasAssignment (List.get (f.assignments, [], false, false).snd.fst j).snd fassignments_i = true ∧
∀ (k : Fin (List.length (f.assignments, [], false, false).snd.fst)),
k ≠ j → (List.get (f.assignments, [], false, false).snd.fst k).fst.val ≠ ↑i) ∨
∃ j1 j2,
(List.get (f.assignments, [], false, false).snd.fst j1).fst.val = ↑i ∧
(List.get (f.assignments, [], false, false).snd.fst j2).fst.val = ↑i ∧
(List.get (f.assignments, [], false, false).snd.fst j1).snd = true ∧
(List.get (f.assignments, [], false, false).snd.fst j2).snd = false ∧
assignments_i = both ∧
fassignments_i = unassigned ∧
∀ (k : Fin (List.length (f.assignments, [], false, false).snd.fst)),
k ≠ j1 → k ≠ j2 → (List.get (f.assignments, [], false, false).snd.fst k).fst.val ≠ ↑i
|
apply Or.inl
|
case h
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop :=
fun x acc => ∃ hsize, f.DerivedLitsInvariant f_assignments_size acc.fst hsize acc.snd.fst
i : Fin n
⊢ (f.assignments, [], false, false).fst[↑i] = f.assignments[↑i] ∧
∀ (l : Literal (PosFin n)), l ∈ (f.assignments, [], false, false).snd.fst → l.fst.val ≠ ↑i
|
de25fdd0385200ff
|
toIocDiv_wcovBy_toIcoDiv
|
Mathlib/Algebra/Order/ToIntervalMod.lean
|
theorem toIocDiv_wcovBy_toIcoDiv (a b : α) : toIocDiv hp a b ⩿ toIcoDiv hp a b
|
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b : α
⊢ toIocDiv hp a b ⩿ toIcoDiv hp a b
|
suffices toIocDiv hp a b = toIcoDiv hp a b ∨ toIocDiv hp a b + 1 = toIcoDiv hp a b by
rwa [wcovBy_iff_eq_or_covBy, ← Order.succ_eq_iff_covBy]
|
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b : α
⊢ toIocDiv hp a b = toIcoDiv hp a b ∨ toIocDiv hp a b + 1 = toIcoDiv hp a b
|
e9d5b7f8dec9f69e
|
MeasureTheory.Measure.restrict_eq_self
|
Mathlib/MeasureTheory/Measure/Restrict.lean
|
theorem restrict_eq_self (h : s ⊆ t) : μ.restrict t s = μ s :=
(le_iff'.1 restrict_le_self s).antisymm <|
calc
μ s ≤ μ (toMeasurable (μ.restrict t) s ∩ t) :=
measure_mono (subset_inter (subset_toMeasurable _ _) h)
_ = μ.restrict t s
|
α : Type u_2
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : s ⊆ t
⊢ μ (toMeasurable (μ.restrict t) s ∩ t) = (μ.restrict t) s
|
rw [← restrict_apply (measurableSet_toMeasurable _ _), measure_toMeasurable]
|
no goals
|
fdc48b9df9dc2d43
|
FormalMultilinearSeries.applyComposition_single
|
Mathlib/Analysis/Analytic/Composition.lean
|
theorem applyComposition_single (p : FormalMultilinearSeries 𝕜 E F) {n : ℕ} (hn : 0 < n)
(v : Fin n → E) : p.applyComposition (Composition.single n hn) v = fun _j => p n v
|
case h.e_a
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : CommRing 𝕜
inst✝⁹ : AddCommGroup E
inst✝⁸ : AddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : IsTopologicalAddGroup E
inst✝² : ContinuousConstSMul 𝕜 E
inst✝¹ : IsTopologicalAddGroup F
inst✝ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
hn : 0 < n
v : Fin n → E
j : Fin (Composition.single n hn).length
i : ℕ
hi1 : i < (Composition.single n hn).blocksFun j
hi2 : i < n
⊢ ((Composition.single n hn).embedding j) ⟨i, hi1⟩ = ⟨i, hi2⟩
|
convert Composition.single_embedding hn ⟨i, hi2⟩ using 1
|
case h.e'_2
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : CommRing 𝕜
inst✝⁹ : AddCommGroup E
inst✝⁸ : AddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalSpace F
inst✝³ : IsTopologicalAddGroup E
inst✝² : ContinuousConstSMul 𝕜 E
inst✝¹ : IsTopologicalAddGroup F
inst✝ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
hn : 0 < n
v : Fin n → E
j : Fin (Composition.single n hn).length
i : ℕ
hi1 : i < (Composition.single n hn).blocksFun j
hi2 : i < n
⊢ ((Composition.single n hn).embedding j) ⟨i, hi1⟩ = ((Composition.single n hn).embedding 0) ⟨i, hi2⟩
|
3c651f8937b91732
|
ENNReal.log_surjective
|
Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
|
theorem log_surjective : Function.Surjective log
|
case h
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
exp_y_pos : ¬Real.exp y.toReal ≤ 0
⊢ (ENNReal.ofReal (Real.exp y.toReal)).log = y
|
simp only [log, ofReal_eq_zero, exp_y_pos, ↓reduceIte, ofReal_ne_top,
ENNReal.toReal_ofReal (Real.exp_pos y.toReal).le, Real.log_exp y.toReal]
|
case h
y : EReal
y_nbot : ⊥ < y
y_ntop : y < ⊤
exp_y_pos : ¬Real.exp y.toReal ≤ 0
⊢ ↑y.toReal = y
|
1d58ac00fdba3020
|
UniformContinuous.pow_const
|
Mathlib/Topology/Algebra/UniformGroup/Defs.lean
|
theorem UniformContinuous.pow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
∀ n : ℕ, UniformContinuous fun x => f x ^ n
| 0 => by
simp_rw [pow_zero]
exact uniformContinuous_const
| n + 1 => by
simp_rw [pow_succ']
exact hf.mul (hf.pow_const n)
|
α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ (n + 1)
|
simp_rw [pow_succ']
|
α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x * f x ^ n
|
5db82d8e2dacf3d4
|
Equiv.Perm.support_mul_le
|
Mathlib/GroupTheory/Perm/Support.lean
|
theorem support_mul_le (f g : Perm α) : (f * g).support ≤ f.support ⊔ g.support := fun x => by
simp only [sup_eq_union]
rw [mem_union, mem_support, mem_support, mem_support, mul_apply, ← not_and_or, not_imp_not]
rintro ⟨hf, hg⟩
rw [hg, hf]
|
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
⊢ x ∈ (f * g).support → x ∈ f.support ∪ g.support
|
rw [mem_union, mem_support, mem_support, mem_support, mul_apply, ← not_and_or, not_imp_not]
|
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
⊢ f x = x ∧ g x = x → f (g x) = x
|
6d98e5a02bd70b7c
|
not_disjoint_segment_convexHull_triple
|
Mathlib/Analysis/Convex/StoneSeparation.lean
|
theorem not_disjoint_segment_convexHull_triple {p q u v x y z : E} (hz : z ∈ segment 𝕜 x y)
(hu : u ∈ segment 𝕜 x p) (hv : v ∈ segment 𝕜 y q) :
¬Disjoint (segment 𝕜 u v) (convexHull 𝕜 {p, q, z})
|
𝕜 : Type u_1
E : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p q x y : E
az bz : 𝕜
haz : 0 ≤ az
hbz : 0 ≤ bz
habz : az + bz = 1
haz' : 0 < az
av bv : 𝕜
hav : 0 ≤ av
hbv : 0 ≤ bv
habv : av + bv = 1
hav' : 0 < av
au bu : 𝕜
hau : 0 ≤ au
hbu : 0 ≤ bu
habu : au + bu = 1
hab : 0 < az * av + bz * au
w : Fin 3 → 𝕜 := ![az * av * bu, bz * au * bv, au * av]
z : Fin 3 → E := ![p, q, az • x + bz • y]
hw₀ : ∀ (i : Fin 3), 0 ≤ w i
⊢ ∑ i : Fin 3, w i = az * av * bu + (bz * au * bv + au * av)
|
simp [w, Fin.sum_univ_succ, Fin.sum_univ_zero]
|
no goals
|
b7449eac49163f66
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.