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
|
|---|---|---|---|---|---|---|
Algebra.isOpen_smoothLocus
|
Mathlib/RingTheory/Smooth/Locus.lean
|
lemma isOpen_smoothLocus [FinitePresentation R A] : IsOpen (smoothLocus R A)
|
case intro.intro.intro.intro.intro.intro
R A : Type u
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : FinitePresentation R A
x : PrimeSpectrum A
hx : x ∈ smoothLocus R A
f : A
hxf : x ∈ ↑(basicOpen f)
hf : Module.Projective (Localization.Away f) (LocalizedModule (Submonoid.powers f) (Ω[A⁄R]))
⊢ ∃ t ⊆ smoothLocus R A, IsOpen t ∧ x ∈ t
|
let Af := Localization.Away f
|
case intro.intro.intro.intro.intro.intro
R A : Type u
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
inst✝ : FinitePresentation R A
x : PrimeSpectrum A
hx : x ∈ smoothLocus R A
f : A
hxf : x ∈ ↑(basicOpen f)
hf : Module.Projective (Localization.Away f) (LocalizedModule (Submonoid.powers f) (Ω[A⁄R]))
Af : Type u := Localization.Away f
⊢ ∃ t ⊆ smoothLocus R A, IsOpen t ∧ x ∈ t
|
f811a0293eb7511f
|
not_irreducible_pow
|
Mathlib/Algebra/Prime/Lemmas.lean
|
theorem not_irreducible_pow {M} [Monoid M] {x : M} {n : ℕ} (hn : n ≠ 1) :
¬ Irreducible (x ^ n)
|
case zero
M : Type u_3
inst✝ : Monoid M
x : M
hn : 0 ≠ 1
⊢ ¬Irreducible (x ^ 0)
|
simp
|
no goals
|
b9fd06b49708f472
|
crossProduct_ne_zero_iff_linearIndependent
|
Mathlib/LinearAlgebra/CrossProduct.lean
|
lemma crossProduct_ne_zero_iff_linearIndependent {F : Type*} [Field F] {v w : Fin 3 → F} :
crossProduct v w ≠ 0 ↔ LinearIndependent F ![v, w]
|
F : Type u_2
inst✝ : Field F
v w : Fin 3 → F
hv : ¬v = 0
hv' : v = ![v 0, v 1, v 2]
⊢ w = ![w 0, w 1, w 2]
|
simp [← List.ofFn_inj]
|
no goals
|
7afc9aa3161c3f50
|
lp.norm_const_smul_le
|
Mathlib/Analysis/Normed/Lp/lpSpace.lean
|
theorem norm_const_smul_le (hp : p ≠ 0) (c : 𝕜) (f : lp E p) : ‖c • f‖ ≤ ‖c‖ * ‖f‖
|
case inr.inr
𝕜 : Type u_1
α : Type u_3
E : α → Type u_4
p : ℝ≥0∞
inst✝³ : (i : α) → NormedAddCommGroup (E i)
inst✝² : NormedRing 𝕜
inst✝¹ : (i : α) → Module 𝕜 (E i)
inst✝ : ∀ (i : α), BoundedSMul 𝕜 (E i)
hp✝ : p ≠ 0
c : 𝕜
f : ↥(lp E p)
hp : 0 < p.toReal
inst : NNNorm ↥(lp E p) := { nnnorm := fun f => ⟨‖f‖, ⋯⟩ }
⊢ ‖c • f‖ ≤ ‖c‖ * ‖f‖
|
have coe_nnnorm : ∀ f : lp E p, ↑‖f‖₊ = ‖f‖ := fun _ => rfl
|
case inr.inr
𝕜 : Type u_1
α : Type u_3
E : α → Type u_4
p : ℝ≥0∞
inst✝³ : (i : α) → NormedAddCommGroup (E i)
inst✝² : NormedRing 𝕜
inst✝¹ : (i : α) → Module 𝕜 (E i)
inst✝ : ∀ (i : α), BoundedSMul 𝕜 (E i)
hp✝ : p ≠ 0
c : 𝕜
f : ↥(lp E p)
hp : 0 < p.toReal
inst : NNNorm ↥(lp E p) := { nnnorm := fun f => ⟨‖f‖, ⋯⟩ }
coe_nnnorm : ∀ (f : ↥(lp E p)), ↑‖f‖₊ = ‖f‖
⊢ ‖c • f‖ ≤ ‖c‖ * ‖f‖
|
226c34467852710f
|
emultiplicity_prime_le_emultiplicity_image_by_factor_orderIso
|
Mathlib/RingTheory/ChainOfDivisors.lean
|
theorem emultiplicity_prime_le_emultiplicity_image_by_factor_orderIso {m p : Associates M}
{n : Associates N} (hp : p ∈ normalizedFactors m) (d : Set.Iic m ≃o Set.Iic n) :
emultiplicity p m ≤ emultiplicity (↑(d ⟨p, dvd_of_mem_normalizedFactors hp⟩)) n
|
case neg
M : Type u_1
inst✝³ : CancelCommMonoidWithZero M
N : Type u_2
inst✝² : CancelCommMonoidWithZero N
inst✝¹ : UniqueFactorizationMonoid N
inst✝ : UniqueFactorizationMonoid M
m p : Associates M
n : Associates N
hp : p ∈ normalizedFactors m
d : ↑(Set.Iic m) ≃o ↑(Set.Iic n)
hn : ¬n = 0
hm : ¬m = 0
⊢ ↑(d ⟨p, ⋯⟩) ^ multiplicity p m ∣ n
|
apply pow_image_of_prime_by_factor_orderIso_dvd hn hp d (pow_multiplicity_dvd ..)
|
no goals
|
61c7ac6c10a4255e
|
BoxIntegral.integrable_of_bounded_and_ae_continuousWithinAt
|
Mathlib/Analysis/BoxIntegral/Basic.lean
|
theorem integrable_of_bounded_and_ae_continuousWithinAt [CompleteSpace E] {I : Box ι} {f : ℝⁿ → E}
(hb : ∃ C : ℝ, ∀ x ∈ Box.Icc I, ‖f x‖ ≤ C) (μ : Measure ℝⁿ) [IsLocallyFiniteMeasure μ]
(hc : ∀ᵐ x ∂(μ.restrict (Box.Icc I)), ContinuousWithinAt f (Box.Icc I) x) :
Integrable I l f μ.toBoxAdditive.toSMul
|
ι : Type u
E : Type v
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : Fintype ι
l : IntegrationParams
inst✝¹ : CompleteSpace E
I : Box ι
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
hc : ∀ᵐ (x : ι → ℝ) ∂μ.restrict (Box.Icc I), ContinuousWithinAt f (Box.Icc I) x
ε : ℝ
ε0 : ε > 0
ε₁ : ℝ
ε₁0 : 0 < ε₁
hε₁ : 2 * μ.toBoxAdditive I * ε₁ < ε
C : ℝ
hC : ∀ x ∈ Box.Icc I, ‖f x‖ ≤ C
C0 : 0 ≤ C
ε₂ : ℝ
ε₂0 : 0 < ε₂
hε₂ : 4 * C * ε₂ < ε
ε₂0' : ENNReal.ofReal ε₂ ≠ 0
D : Set (ι → ℝ) := {x | x ∈ Box.Icc I ∧ ¬ContinuousWithinAt f (Box.Icc I) x}
μ' : Measure (ι → ℝ) := μ.restrict (Box.Icc I)
μ'D : μ' D = 0
U : Set (ι → ℝ)
UD : U ⊇ D
Uopen : IsOpen U
hU : μ' U < ENNReal.ofReal ε₂
comp : IsCompact (Box.Icc I \ U)
this✝ : ∀ x ∈ Box.Icc I \ U, oscillationWithin f (Box.Icc I) x < ENNReal.ofReal ε₁
r : ℝ
r0 : r > 0
hr : ∀ x ∈ Box.Icc I \ U, EMetric.diam (f '' (EMetric.ball x (ENNReal.ofReal r) ∩ Box.Icc I)) ≤ ENNReal.ofReal ε₁
c₁ c₂ : ℝ≥0
π₁ π₂ : TaggedPrepartition I
h₁ : l.MemBaseSet I c₁ ((fun x x => ⟨r / 2, ⋯⟩) c₁) π₁
h₁p : π₁.IsPartition
h₂ : l.MemBaseSet I c₂ ((fun x x => ⟨r / 2, ⋯⟩) c₂) π₂
h₂p : π₂.IsPartition
μI : μ ↑I < ⊤
t₁ : Box ι → ι → ℝ := fun J => (π₁.infPrepartition π₂.toPrepartition).tag J
t₂ : Box ι → ι → ℝ := fun J => (π₂.infPrepartition π₁.toPrepartition).tag J
B : Finset (Box ι) := (π₁.toPrepartition ⊓ π₂.toPrepartition).boxes
B' : Finset (Box ι) := Finset.filter (fun J => ↑J ⊆ U) B
hB' : B' ⊆ B
μJ_ne_top : ∀ J ∈ B, μ ↑J ≠ ⊤
un : ∀ S ⊆ B, ⋃ J ∈ S, ↑J ⊆ ↑I
this : ∀ J ∈ B \ B', ‖μ.toBoxAdditive J • (f (t₁ J) - f (t₂ J))‖ ≤ μ.toBoxAdditive J * ε₁
⊢ ∑' (x : { x // x ∈ B \ B' }), μ ↑↑x ≤ μ.measureOf (⋃ J ∈ B \ B', ↑J)
|
refine le_of_eq (measure_biUnion (countable_toSet _) ?_ (fun J _ ↦ J.measurableSet_coe)).symm
|
ι : Type u
E : Type v
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : Fintype ι
l : IntegrationParams
inst✝¹ : CompleteSpace E
I : Box ι
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
hc : ∀ᵐ (x : ι → ℝ) ∂μ.restrict (Box.Icc I), ContinuousWithinAt f (Box.Icc I) x
ε : ℝ
ε0 : ε > 0
ε₁ : ℝ
ε₁0 : 0 < ε₁
hε₁ : 2 * μ.toBoxAdditive I * ε₁ < ε
C : ℝ
hC : ∀ x ∈ Box.Icc I, ‖f x‖ ≤ C
C0 : 0 ≤ C
ε₂ : ℝ
ε₂0 : 0 < ε₂
hε₂ : 4 * C * ε₂ < ε
ε₂0' : ENNReal.ofReal ε₂ ≠ 0
D : Set (ι → ℝ) := {x | x ∈ Box.Icc I ∧ ¬ContinuousWithinAt f (Box.Icc I) x}
μ' : Measure (ι → ℝ) := μ.restrict (Box.Icc I)
μ'D : μ' D = 0
U : Set (ι → ℝ)
UD : U ⊇ D
Uopen : IsOpen U
hU : μ' U < ENNReal.ofReal ε₂
comp : IsCompact (Box.Icc I \ U)
this✝ : ∀ x ∈ Box.Icc I \ U, oscillationWithin f (Box.Icc I) x < ENNReal.ofReal ε₁
r : ℝ
r0 : r > 0
hr : ∀ x ∈ Box.Icc I \ U, EMetric.diam (f '' (EMetric.ball x (ENNReal.ofReal r) ∩ Box.Icc I)) ≤ ENNReal.ofReal ε₁
c₁ c₂ : ℝ≥0
π₁ π₂ : TaggedPrepartition I
h₁ : l.MemBaseSet I c₁ ((fun x x => ⟨r / 2, ⋯⟩) c₁) π₁
h₁p : π₁.IsPartition
h₂ : l.MemBaseSet I c₂ ((fun x x => ⟨r / 2, ⋯⟩) c₂) π₂
h₂p : π₂.IsPartition
μI : μ ↑I < ⊤
t₁ : Box ι → ι → ℝ := fun J => (π₁.infPrepartition π₂.toPrepartition).tag J
t₂ : Box ι → ι → ℝ := fun J => (π₂.infPrepartition π₁.toPrepartition).tag J
B : Finset (Box ι) := (π₁.toPrepartition ⊓ π₂.toPrepartition).boxes
B' : Finset (Box ι) := Finset.filter (fun J => ↑J ⊆ U) B
hB' : B' ⊆ B
μJ_ne_top : ∀ J ∈ B, μ ↑J ≠ ⊤
un : ∀ S ⊆ B, ⋃ J ∈ S, ↑J ⊆ ↑I
this : ∀ J ∈ B \ B', ‖μ.toBoxAdditive J • (f (t₁ J) - f (t₂ J))‖ ≤ μ.toBoxAdditive J * ε₁
⊢ (↑(B \ B')).PairwiseDisjoint Box.toSet
|
603a1c16b71ac0cf
|
Int.sub_eq_zero_of_eq
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
|
theorem sub_eq_zero_of_eq {a b : Int} (h : a = b) : a - b = 0
|
a b : Int
h : a = b
⊢ a - b = 0
|
rw [h, Int.sub_self]
|
no goals
|
f67aa3f6c837d54d
|
LieModule.trace_toEnd_eq_zero_of_mem_lcs
|
Mathlib/Algebra/Lie/TraceForm.lean
|
lemma trace_toEnd_eq_zero_of_mem_lcs
{k : ℕ} {x : L} (hk : 1 ≤ k) (hx : x ∈ lowerCentralSeries R L L k) :
trace R _ (toEnd R L M x) = 0
|
R : Type u_1
L : Type u_3
M : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
x : L
hk : 1 ≤ k
hx : x ∈ lowerCentralSeries R L L 1
⊢ x ∈ Submodule.span R {m | ∃ u v, ⁅u, v⁆ = m}
|
rw [lowerCentralSeries_succ, ← LieSubmodule.mem_toSubmodule,
LieSubmodule.lieIdeal_oper_eq_linear_span'] at hx
|
R : Type u_1
L : Type u_3
M : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
x : L
hk : 1 ≤ k
hx : x ∈ Submodule.span R {x | ∃ x_1 ∈ ⊤, ∃ n ∈ lowerCentralSeries R L L 0, ⁅x_1, n⁆ = x}
⊢ x ∈ Submodule.span R {m | ∃ u v, ⁅u, v⁆ = m}
|
93c4c71234cad1df
|
MeasureTheory.Measure.haar.is_left_invariant_chaar
|
Mathlib/MeasureTheory/Measure/Haar/Basic.lean
|
theorem is_left_invariant_chaar {K₀ : PositiveCompacts G} (g : G) (K : Compacts G) :
chaar K₀ (K.map _ <| continuous_mul_left g) = chaar K₀ K
|
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : IsTopologicalGroup G
K₀ : PositiveCompacts G
g : G
K : Compacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f (Compacts.map (fun b => g * b) ⋯ K) - f K
this : Continuous eval
⊢ closure (prehaar ↑K₀ '' {U | U ⊆ ↑⊤.toOpens ∧ IsOpen U ∧ 1 ∈ U}) ⊆ eval ⁻¹' {0}
|
rw [IsClosed.closure_subset_iff]
|
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : IsTopologicalGroup G
K₀ : PositiveCompacts G
g : G
K : Compacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f (Compacts.map (fun b => g * b) ⋯ K) - f K
this : Continuous eval
⊢ prehaar ↑K₀ '' {U | U ⊆ ↑⊤.toOpens ∧ IsOpen U ∧ 1 ∈ U} ⊆ eval ⁻¹' {0}
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : IsTopologicalGroup G
K₀ : PositiveCompacts G
g : G
K : Compacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f (Compacts.map (fun b => g * b) ⋯ K) - f K
this : Continuous eval
⊢ IsClosed (eval ⁻¹' {0})
|
6ade7b3c444e172e
|
Affine.Triangle.dist_orthocenter_reflection_circumcenter
|
Mathlib/Geometry/Euclidean/MongePoint.lean
|
theorem dist_orthocenter_reflection_circumcenter (t : Triangle ℝ P) {i₁ i₂ : Fin 3} (h : i₁ ≠ i₂) :
dist t.orthocenter (reflection (affineSpan ℝ (t.points '' {i₁, i₂})) t.circumcenter) =
t.circumradius
|
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
⊢ -(∑ x : Fin (0 + 2 + 1),
(∑ x_1 : Fin (0 + 2 + 1),
((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
((↑(0 + 1))⁻¹ - if x_1 = i₁ ∨ x_1 = i₂ then 1 else 0) *
(dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))
(pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x_1)) *
dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))
(pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x_1))) +
((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
(dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))
(pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex) *
dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))
(pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex))) +
(∑ x : Fin (0 + 2 + 1),
(-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
(dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)
(pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x)) *
dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)
(pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))) +
(-2 / ↑(0 + 1) - -1) * (-2 / ↑(0 + 1) - -1) *
(dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)
(pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex) *
dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)
(pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)))) /
2 =
circumradius t * circumradius t
|
have hu : ({i₁, i₂} : Finset (Fin 3)) ⊆ univ := subset_univ _
|
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
hu : {i₁, i₂} ⊆ univ
⊢ -(∑ x : Fin (0 + 2 + 1),
(∑ x_1 : Fin (0 + 2 + 1),
((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
((↑(0 + 1))⁻¹ - if x_1 = i₁ ∨ x_1 = i₂ then 1 else 0) *
(dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))
(pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x_1)) *
dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))
(pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x_1))) +
((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
(dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))
(pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex) *
dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))
(pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex))) +
(∑ x : Fin (0 + 2 + 1),
(-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
(dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)
(pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x)) *
dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)
(pointsWithCircumcenter t (PointsWithCircumcenterIndex.pointIndex x))) +
(-2 / ↑(0 + 1) - -1) * (-2 / ↑(0 + 1) - -1) *
(dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)
(pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex) *
dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)
(pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenterIndex)))) /
2 =
circumradius t * circumradius t
|
cf2667ffc8b63c24
|
Rel.interedges_mono
|
Mathlib/Combinatorics/SimpleGraph/Density.lean
|
theorem interedges_mono (hs : s₂ ⊆ s₁) (ht : t₂ ⊆ t₁) : interedges r s₂ t₂ ⊆ interedges r s₁ t₁ :=
fun x ↦ by
simp_rw [mem_interedges_iff]
exact fun h ↦ ⟨hs h.1, ht h.2.1, h.2.2⟩
|
α : Type u_4
β : Type u_5
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s₁ s₂ : Finset α
t₁ t₂ : Finset β
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
x : α × β
⊢ x ∈ interedges r s₂ t₂ → x ∈ interedges r s₁ t₁
|
simp_rw [mem_interedges_iff]
|
α : Type u_4
β : Type u_5
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s₁ s₂ : Finset α
t₁ t₂ : Finset β
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
x : α × β
⊢ x.1 ∈ s₂ ∧ x.2 ∈ t₂ ∧ r x.1 x.2 → x.1 ∈ s₁ ∧ x.2 ∈ t₁ ∧ r x.1 x.2
|
24cb9d9ef47a802b
|
Pell.IsFundamental.eq_pow_of_nonneg
|
Mathlib/NumberTheory/Pell.lean
|
theorem eq_pow_of_nonneg {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 0 < a.x)
(hay : 0 ≤ a.y) : ∃ n : ℕ, a = a₁ ^ n
|
case intro.h.inl
d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
x : ℕ
ih : ∀ m < x, ∀ {a : Solution₁ d}, 0 ≤ a.y → ↑m = a.x → 0 < ↑m → ∃ n, a = a₁ ^ n
a : Solution₁ d
hay : 0 ≤ a.y
hax' : ↑x = a.x
hax : 0 < ↑x
hy : 0 = a.y
⊢ a = a₁ ^ 0
|
simp only [pow_zero]
|
case intro.h.inl
d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
x : ℕ
ih : ∀ m < x, ∀ {a : Solution₁ d}, 0 ≤ a.y → ↑m = a.x → 0 < ↑m → ∃ n, a = a₁ ^ n
a : Solution₁ d
hay : 0 ≤ a.y
hax' : ↑x = a.x
hax : 0 < ↑x
hy : 0 = a.y
⊢ a = 1
|
e2cabc4b76df1e43
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_insert
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.lean
|
theorem readyForRupAdd_insert {n : Nat} (f : DefaultFormula n) (c : DefaultClause n) :
ReadyForRupAdd f → ReadyForRupAdd (insert f c)
|
case pos
n : Nat
f : DefaultFormula n
c : DefaultClause n
f_readyForRupAdd : f.ReadyForRupAdd
x✝ : Option (Literal (PosFin n))
l : PosFin n
hc : c.isUnit = some (l, false)
hsize : (f.assignments.modify l.val addNegAssignment).size = n
i : PosFin n
b : Bool
hb : hasAssignment b (f.assignments.modify l.val addNegAssignment)[i.val] = true
hf : hasAssignment b f.assignments[i.val] = true → unit (i, b) ∈ f.toList
i_in_bounds : i.val < f.assignments.size
ib_ne_c : ¬(i, b) = (l, false)
l_eq_i : l.val = i.val
h✝ : b = true
⊢ b = true
|
assumption
|
no goals
|
c1096ba3fc377c54
|
Fin.sizeOf
|
Mathlib/.lake/packages/lean4/src/lean/Init/SizeOfLemmas.lean
|
theorem Fin.sizeOf (a : Fin n) : sizeOf a = a.val + 1
|
n : Nat
a : Fin n
⊢ sizeOf a = ↑a + 1
|
cases a
|
case mk
n val✝ : Nat
isLt✝ : val✝ < n
⊢ sizeOf ⟨val✝, isLt✝⟩ = ↑⟨val✝, isLt✝⟩ + 1
|
79ad8ea852aac7e2
|
LinearMap.toSpanSingleton_homothety
|
Mathlib/Analysis/Normed/Module/Span.lean
|
theorem toSpanSingleton_homothety (x : E) (c : 𝕜) :
‖LinearMap.toSpanSingleton 𝕜 E x c‖ = ‖x‖ * ‖c‖
|
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedDivisionRing 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
x : E
c : 𝕜
⊢ ‖(toSpanSingleton 𝕜 E x) c‖ = ‖x‖ * ‖c‖
|
rw [mul_comm]
|
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedDivisionRing 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
x : E
c : 𝕜
⊢ ‖(toSpanSingleton 𝕜 E x) c‖ = ‖c‖ * ‖x‖
|
ddfe2b87fc17adc4
|
List.zip_append
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Zip.lean
|
theorem zip_append :
∀ {l₁ r₁ : List α} {l₂ r₂ : List β} (_h : length l₁ = length l₂),
zip (l₁ ++ r₁) (l₂ ++ r₂) = zip l₁ l₂ ++ zip r₁ r₂
| [], r₁, l₂, r₂, h => by simp only [eq_nil_of_length_eq_zero h.symm]; rfl
| l₁, r₁, [], r₂, h => by simp only [eq_nil_of_length_eq_zero h]; rfl
| a :: l₁, r₁, b :: l₂, r₂, h => by
simp only [cons_append, zip_cons_cons, zip_append (Nat.succ.inj h)]
|
α : Type u_1
β : Type u_2
a : α
l₁ r₁ : List α
b : β
l₂ r₂ : List β
h : (a :: l₁).length = (b :: l₂).length
⊢ (a :: l₁ ++ r₁).zip (b :: l₂ ++ r₂) = (a :: l₁).zip (b :: l₂) ++ r₁.zip r₂
|
simp only [cons_append, zip_cons_cons, zip_append (Nat.succ.inj h)]
|
no goals
|
cb39c7e8a1d8f244
|
Lean.Omega.IntList.mul_distrib_left
|
Mathlib/.lake/packages/lean4/src/lean/Init/Omega/IntList.lean
|
theorem mul_distrib_left (xs ys zs : IntList) : (xs + ys) * zs = xs * zs + ys * zs
|
case cons.cons.nil
x : Int
xs : List Int
ih₁ : ∀ (ys zs : IntList), (xs + ys) * zs = xs * zs + ys * zs
head✝ : Int
tail✝ : List Int
⊢ (x :: xs + head✝ :: tail✝) * [] = (x :: xs) * [] + (head✝ :: tail✝) * []
|
simp
|
no goals
|
ad435ae640ae9032
|
Algebra.FormallyUnramified.isSeparable
|
Mathlib/RingTheory/Unramified/Field.lean
|
theorem isSeparable : Algebra.IsSeparable K L
|
K : Type u_1
L : Type u_3
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : FormallyUnramified K L
inst✝ : EssFiniteType K L
this✝¹ : Module.Finite K L
this✝ : FormallyUnramified (↥(separableClosure K L)) L
this : EssFiniteType (↥(separableClosure K L)) L
⊢ separableClosure K L = ⊤
|
ext
|
case h
K : Type u_1
L : Type u_3
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : FormallyUnramified K L
inst✝ : EssFiniteType K L
this✝¹ : Module.Finite K L
this✝ : FormallyUnramified (↥(separableClosure K L)) L
this : EssFiniteType (↥(separableClosure K L)) L
x✝ : L
⊢ x✝ ∈ separableClosure K L ↔ x✝ ∈ ⊤
|
098767b1d96a2eff
|
Std.DHashMap.Internal.Raw₀.expand.go_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/WF.lean
|
theorem expand.go_eq [BEq α] [Hashable α] [PartialEquivBEq α] (source : Array (AssocList α β))
(target : {d : Array (AssocList α β) // 0 < d.size}) : expand.go 0 source target =
(toListModel source).foldl (fun acc p => reinsertAux hash acc p.1 p.2) target
|
α : Type u
β : α → Type v
inst✝¹ : BEq α
inst✝ : Hashable α
i : PartialEquivBEq α
source : Nat
target : Array (AssocList α β)
target✝ : { d // 0 < d.size }
hi : source < target.size
es : AssocList α β := target[source]
newSource : Array (AssocList α β) := target.set source AssocList.nil hi
newTarget : { d // 0 < d.size } := AssocList.foldl (reinsertAux hash) target✝ es
ih :
go (source + 1) (target.set source AssocList.nil hi) (AssocList.foldl (reinsertAux hash) target✝ target[source]) =
foldl (fun acc p => reinsertAux hash acc p.fst p.snd) (AssocList.foldl (reinsertAux hash) target✝ target[source])
(flatMap AssocList.toList (drop (source + 1) (target.set source AssocList.nil hi).toList))
⊢ foldl (fun acc p => reinsertAux hash acc p.fst p.snd)
(foldl (fun acc p => reinsertAux hash acc p.fst p.snd) target✝ target[source].toList)
(flatMap AssocList.toList (drop (source + 1) (target.toList.set source AssocList.nil))) =
foldl (fun acc p => reinsertAux hash acc p.fst p.snd) target✝ (flatMap AssocList.toList (drop source target.toList))
|
rw [List.drop_eq_getElem_cons hi, List.flatMap_cons, List.foldl_append,
List.drop_set_of_lt _ _ (by omega), Array.getElem_toList]
|
no goals
|
c4dec2d2e93626cd
|
LightCondensed.isLocallySurjective_iff_locallySurjective_on_lightProfinite
|
Mathlib/Condensed/Light/Epi.lean
|
lemma isLocallySurjective_iff_locallySurjective_on_lightProfinite : IsLocallySurjective f ↔
∀ (S : LightProfinite) (y : ToType (Y.val.obj ⟨S⟩)),
(∃ (S' : LightProfinite) (φ : S' ⟶ S) (_ : Function.Surjective φ)
(x : ToType (X.val.obj ⟨S'⟩)),
f.val.app ⟨S'⟩ x = Y.val.map ⟨φ⟩ y)
|
A : Type u'
inst✝³ : Category.{v', u'} A
FA : A → A → Type u_1
CA : A → Type w
inst✝² : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)
inst✝¹ : ConcreteCategory A FA
inst✝ : PreservesFiniteProducts (CategoryTheory.forget A)
X Y : LightCondensed A
f : X ⟶ Y
⊢ IsLocallySurjective f ↔
∀ (S : LightProfinite) (y : ToType (Y.val.obj (Opposite.op S))),
∃ S' φ,
∃ (_ : Function.Surjective ⇑(ConcreteCategory.hom φ)),
∃ x,
(ConcreteCategory.hom (f.val.app (Opposite.op S'))) x = (ConcreteCategory.hom (Y.val.map (Opposite.op φ))) y
|
rw [coherentTopology.isLocallySurjective_iff,
regularTopology.isLocallySurjective_iff]
|
A : Type u'
inst✝³ : Category.{v', u'} A
FA : A → A → Type u_1
CA : A → Type w
inst✝² : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)
inst✝¹ : ConcreteCategory A FA
inst✝ : PreservesFiniteProducts (CategoryTheory.forget A)
X Y : LightCondensed A
f : X ⟶ Y
⊢ (∀ (X_1 : LightProfinite) (y : ToType (Y.val.obj (Opposite.op X_1))),
∃ X' φ,
∃ (_ : EffectiveEpi φ),
∃ x,
(ConcreteCategory.hom (f.val.app (Opposite.op X'))) x =
(ConcreteCategory.hom (Y.val.map (Opposite.op φ))) y) ↔
∀ (S : LightProfinite) (y : ToType (Y.val.obj (Opposite.op S))),
∃ S' φ,
∃ (_ : Function.Surjective ⇑(ConcreteCategory.hom φ)),
∃ x,
(ConcreteCategory.hom (f.val.app (Opposite.op S'))) x = (ConcreteCategory.hom (Y.val.map (Opposite.op φ))) y
|
0a92c944fa2c53b6
|
PowerSeries.invOneSubPow_val_one_eq_invUnitSub_one
|
Mathlib/RingTheory/PowerSeries/WellKnown.lean
|
theorem invOneSubPow_val_one_eq_invUnitSub_one :
(invOneSubPow S 1).val = invUnitsSub (1 : Sˣ)
|
S : Type u_1
inst✝ : CommRing S
⊢ ↑(invOneSubPow S 1) = invUnitsSub 1
|
simp [invOneSubPow, invUnitsSub]
|
no goals
|
f51ab1b0b25494bc
|
Nat.factorization_prod
|
Mathlib/Data/Nat/Factorization/Defs.lean
|
theorem factorization_prod {α : Type*} {S : Finset α} {g : α → ℕ} (hS : ∀ x ∈ S, g x ≠ 0) :
(S.prod g).factorization = S.sum fun x => (g x).factorization
|
case h.refine_2
α : Type u_1
S : Finset α
g : α → ℕ
hS : ∀ x ∈ S, g x ≠ 0
p : ℕ
⊢ ∀ {a : α} {s : Finset α},
a ∈ S →
s ⊆ S →
a ∉ s →
(s.prod g).factorization p = (∑ x ∈ s, (g x).factorization) p →
((insert a s).prod g).factorization p = (∑ x ∈ insert a s, (g x).factorization) p
|
intro x T hxS hTS hxT IH
|
case h.refine_2
α : Type u_1
S : Finset α
g : α → ℕ
hS : ∀ x ∈ S, g x ≠ 0
p : ℕ
x : α
T : Finset α
hxS : x ∈ S
hTS : T ⊆ S
hxT : x ∉ T
IH : (T.prod g).factorization p = (∑ x ∈ T, (g x).factorization) p
⊢ ((insert x T).prod g).factorization p = (∑ x ∈ insert x T, (g x).factorization) p
|
0f85b322fea385d6
|
Ordnode.Valid'.map_aux
|
Mathlib/Data/Ordmap/Ordset.lean
|
theorem Valid'.map_aux {β} [Preorder β] {f : α → β} (f_strict_mono : StrictMono f) {t a₁ a₂}
(h : Valid' a₁ t a₂) :
Valid' (Option.map f a₁) (map f t) (Option.map f a₂) ∧ (map f t).size = t.size
|
case node.intro.intro.bal.right.left
α : Type u_1
inst✝¹ : Preorder α
β : Type u_2
inst✝ : Preorder β
f : α → β
f_strict_mono : StrictMono f
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
a₁ : WithBot α
a₂ : WithTop α
h : Valid' a₁ (Ordnode.node size✝ l✝ x✝ r✝) a₂
t_l_valid : Valid' (Option.map f a₁) (map f l✝) (Option.map f ↑x✝)
t_l_size : (map f l✝).size = l✝.size
t_r_valid : Valid' (Option.map f ↑x✝) (map f r✝) (Option.map f a₂)
t_r_size : (map f r✝).size = r✝.size
⊢ (map f l✝).Balanced
|
exact t_l_valid.bal
|
no goals
|
ff36f5e3d5092df5
|
CliffordAlgebra.even_induction
|
Mathlib/LinearAlgebra/CliffordAlgebra/Grading.lean
|
theorem even_induction {motive : ∀ x, x ∈ evenOdd Q 0 → Prop}
(algebraMap : ∀ r : R, motive (algebraMap _ _ r) (SetLike.algebraMap_mem_graded _ _))
(add : ∀ x y hx hy, motive x hx → motive y hy → motive (x + y) (Submodule.add_mem _ hx hy))
(ι_mul_ι_mul :
∀ m₁ m₂ x hx,
motive x hx →
motive (ι Q m₁ * ι Q m₂ * x)
(zero_add (0 : ZMod 2) ▸ SetLike.mul_mem_graded (ι_mul_ι_mem_evenOdd_zero Q m₁ m₂) hx))
(x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q 0) : motive x hx
|
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
motive : (x : CliffordAlgebra Q) → x ∈ evenOdd Q 0 → Prop
algebraMap : ∀ (r : R), motive ((_root_.algebraMap R (CliffordAlgebra Q)) r) ⋯
add :
∀ (x y : CliffordAlgebra Q) (hx : x ∈ evenOdd Q 0) (hy : y ∈ evenOdd Q 0),
motive x hx → motive y hy → motive (x + y) ⋯
ι_mul_ι_mul :
∀ (m₁ m₂ : M) (x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q 0), motive x hx → motive ((ι Q) m₁ * (ι Q) m₂ * x) ⋯
x : CliffordAlgebra Q
hx : x ∈ evenOdd Q 0
rx : CliffordAlgebra Q
h : rx ∈ LinearMap.range (ι Q) ^ ZMod.val 0
⊢ motive rx ⋯
|
obtain ⟨r, rfl⟩ := Submodule.mem_one.mp h
|
case intro
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
motive : (x : CliffordAlgebra Q) → x ∈ evenOdd Q 0 → Prop
algebraMap : ∀ (r : R), motive ((_root_.algebraMap R (CliffordAlgebra Q)) r) ⋯
add :
∀ (x y : CliffordAlgebra Q) (hx : x ∈ evenOdd Q 0) (hy : y ∈ evenOdd Q 0),
motive x hx → motive y hy → motive (x + y) ⋯
ι_mul_ι_mul :
∀ (m₁ m₂ : M) (x : CliffordAlgebra Q) (hx : x ∈ evenOdd Q 0), motive x hx → motive ((ι Q) m₁ * (ι Q) m₂ * x) ⋯
x : CliffordAlgebra Q
hx : x ∈ evenOdd Q 0
r : R
h : (_root_.algebraMap R (CliffordAlgebra Q)) r ∈ LinearMap.range (ι Q) ^ ZMod.val 0
⊢ motive ((_root_.algebraMap R (CliffordAlgebra Q)) r) ⋯
|
24e125e8024e9761
|
Polynomial.Chebyshev.S_add_two
|
Mathlib/RingTheory/Polynomial/Chebyshev.lean
|
theorem S_add_two : ∀ n, S R (n + 2) = X * S R (n + 1) - S R n
| (k : ℕ) => S.eq_3 R k
| -(k + 1 : ℕ) => by linear_combination (norm := (simp [Int.negSucc_eq]; ring_nf)) S.eq_4 R k
|
R : Type u_1
inst✝ : CommRing R
k : ℕ
⊢ S R (-↑(k + 1) + 2) = X * S R (-↑(k + 1) + 1) - S R (-↑(k + 1))
|
linear_combination (norm := (simp [Int.negSucc_eq]; ring_nf)) S.eq_4 R k
|
no goals
|
440be322469157c0
|
FormalMultilinearSeries.radius_shift
|
Mathlib/Analysis/Analytic/Basic.lean
|
theorem radius_shift (p : FormalMultilinearSeries 𝕜 E F) : p.shift.radius = p.radius
|
case h.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
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
C : ℝ
⊢ (∀ (n : ℕ), ‖p (n + 1)‖ * ↑r ^ n ≤ C) → ∃ (_ : ∀ (n : ℕ), ‖p n‖ * ↑r ^ n ≤ ‖p 0‖ ⊔ C * ↑r), ↑r ≤ ↑r
|
intro h
|
case h.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
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
C : ℝ
h : ∀ (n : ℕ), ‖p (n + 1)‖ * ↑r ^ n ≤ C
⊢ ∃ (_ : ∀ (n : ℕ), ‖p n‖ * ↑r ^ n ≤ ‖p 0‖ ⊔ C * ↑r), ↑r ≤ ↑r
|
b15148c409de31ac
|
String.firstDiffPos_loop_eq
|
Mathlib/.lake/packages/batteries/Batteries/Data/String/Lemmas.lean
|
theorem firstDiffPos_loop_eq (l₁ l₂ r₁ r₂ stop p)
(hl₁ : p = utf8Len l₁) (hl₂ : p = utf8Len l₂)
(hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂)) :
firstDiffPos.loop ⟨l₁ ++ r₁⟩ ⟨l₂ ++ r₂⟩ ⟨stop⟩ ⟨p⟩ =
⟨p + utf8Len (List.takeWhile₂ (· = ·) r₁ r₂).1⟩
|
case hnc
l₁ l₂ r₁ r₂ : List Char
stop p : Nat
hl₁ : p = utf8Len l₁
hl₂ : p = utf8Len l₂
hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂)
x✝¹ x✝ : List Char
h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False
⊢ 0 < utf8Len r₁ → ¬0 < utf8Len r₂
|
intro h₁ h₂
|
case hnc
l₁ l₂ r₁ r₂ : List Char
stop p : Nat
hl₁ : p = utf8Len l₁
hl₂ : p = utf8Len l₂
hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂)
x✝¹ x✝ : List Char
h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False
h₁ : 0 < utf8Len r₁
h₂ : 0 < utf8Len r₂
⊢ False
|
5881499f2c507cc8
|
Std.Sat.AIG.mkOrCached_decl_eq
|
Mathlib/.lake/packages/lean4/src/lean/Std/Sat/AIG/CachedGatesLemmas.lean
|
theorem mkOrCached_decl_eq idx (aig : AIG α) (input : BinaryInput aig) {h : idx < aig.decls.size}
{h2} :
(aig.mkOrCached input).aig.decls[idx]'h2 = aig.decls[idx]
|
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
idx : Nat
aig : AIG α
input : aig.BinaryInput
h : idx < aig.decls.size
h2 : idx < (aig.mkOrCached input).aig.decls.size
⊢ (aig.mkGateCached (input.asGateInput true true)).aig.decls[idx] = aig.decls[idx]
|
rw [AIG.LawfulOperator.decl_eq (f := mkGateCached)]
|
case h2
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
idx : Nat
aig : AIG α
input : aig.BinaryInput
h : idx < aig.decls.size
h2 : idx < (aig.mkOrCached input).aig.decls.size
⊢ idx < (aig.mkGateCached (input.asGateInput true true)).aig.decls.size
|
2825f1c9a489a1bb
|
Equiv.Perm.signAux_eq_signAux2
|
Mathlib/GroupTheory/Perm/Sign.lean
|
theorem signAux_eq_signAux2 {n : ℕ} :
∀ (l : List α) (f : Perm α) (e : α ≃ Fin n) (_h : ∀ x, f x ≠ x → x ∈ l),
signAux ((e.symm.trans f).trans e) = signAux2 l f
| [], f, e, h => by
have : f = 1 := Equiv.ext fun y => Classical.not_not.1 (mt (h y) (List.not_mem_nil _))
rw [this, one_def, Equiv.trans_refl, Equiv.symm_trans_self, ← one_def, signAux_one, signAux2]
| x::l, f, e, h => by
rw [signAux2]
by_cases hfx : x = f x
· rw [if_pos hfx]
exact
signAux_eq_signAux2 l f _ fun y (hy : f y ≠ y) =>
List.mem_of_ne_of_mem (fun h : y = x => by simp [h, hfx.symm] at hy) (h y hy)
· have hy : ∀ y : α, (swap x (f x) * f) y ≠ y → y ∈ l := fun y hy =>
have : f y ≠ y ∧ y ≠ x := ne_and_ne_of_swap_mul_apply_ne_self hy
List.mem_of_ne_of_mem this.2 (h _ this.1)
have : (e.symm.trans (swap x (f x) * f)).trans e =
swap (e x) (e (f x)) * (e.symm.trans f).trans e
|
α : Type u
inst✝ : DecidableEq α
n : ℕ
f : Perm α
e : α ≃ Fin n
h : ∀ (x : α), f x ≠ x → x ∈ []
this : f = 1
⊢ signAux ((e.symm.trans f).trans e) = signAux2 [] f
|
rw [this, one_def, Equiv.trans_refl, Equiv.symm_trans_self, ← one_def, signAux_one, signAux2]
|
no goals
|
f94966561d754325
|
Nat.dvd_of_pow_dvd
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
|
theorem dvd_of_pow_dvd {p k m : Nat} (hk : 1 ≤ k) (hpk : p ^ k ∣ m) : p ∣ m
|
p k m : Nat
hk : 1 ≤ k
hpk : p ^ k ∣ m
⊢ p ^ 1 ∣ m
|
exact pow_dvd_of_le_of_pow_dvd hk hpk
|
no goals
|
e8dc4bde1893e501
|
Function.Periodic.const_smul
|
Mathlib/Algebra/Ring/Periodic.lean
|
theorem Periodic.const_smul [AddMonoid α] [Group γ] [DistribMulAction γ α]
(h : Periodic f c) (a : γ) : Periodic (fun x => f (a • x)) (a⁻¹ • c) := fun x => by
simpa only [smul_add, smul_inv_smul] using h (a • x)
|
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
c : α
inst✝² : AddMonoid α
inst✝¹ : Group γ
inst✝ : DistribMulAction γ α
h : Periodic f c
a : γ
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = (fun x => f (a • x)) x
|
simpa only [smul_add, smul_inv_smul] using h (a • x)
|
no goals
|
dac44d0f1d21a425
|
Nat.succ_div
|
Mathlib/Data/Nat/Init.lean
|
lemma succ_div : ∀ a b : ℕ, (a + 1) / b = a / b + if b ∣ a + 1 then 1 else 0
| a, 0 => by simp
| 0, 1 => by simp
| 0, b + 2 => by
have hb2 : b + 2 > 1
|
case pos
a b : ℕ
hb_eq_a : ¬b = a + 1
hb_le_a1 : b ≤ a + 1
hb_le_a : b ≤ a
h₁ : 0 < b + 1 ∧ b + 1 ≤ a + 1 + 1
⊢ (if 0 < b + 1 ∧ b + 1 ≤ a + 1 + 1 then (a + 1 + 1 - (b + 1)) / (b + 1) + 1 else 0) =
(if 0 < b + 1 ∧ b + 1 ≤ a + 1 then (a + 1 - (b + 1)) / (b + 1) + 1 else 0) + if b + 1 ∣ a + 1 + 1 then 1 else 0
|
have h₂ : 0 < b + 1 ∧ b + 1 ≤ a + 1 := ⟨succ_pos _, Nat.add_le_add_iff_right.2 hb_le_a⟩
|
case pos
a b : ℕ
hb_eq_a : ¬b = a + 1
hb_le_a1 : b ≤ a + 1
hb_le_a : b ≤ a
h₁ : 0 < b + 1 ∧ b + 1 ≤ a + 1 + 1
h₂ : 0 < b + 1 ∧ b + 1 ≤ a + 1
⊢ (if 0 < b + 1 ∧ b + 1 ≤ a + 1 + 1 then (a + 1 + 1 - (b + 1)) / (b + 1) + 1 else 0) =
(if 0 < b + 1 ∧ b + 1 ≤ a + 1 then (a + 1 - (b + 1)) / (b + 1) + 1 else 0) + if b + 1 ∣ a + 1 + 1 then 1 else 0
|
77c7480efd928acc
|
Complex.Gammaℝ_ne_zero_of_re_pos
|
Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean
|
lemma Gammaℝ_ne_zero_of_re_pos {s : ℂ} (hs : 0 < re s) : Gammaℝ s ≠ 0
|
s : ℂ
hs : 0 < s.re
⊢ s.Gammaℝ ≠ 0
|
apply mul_ne_zero
|
case ha
s : ℂ
hs : 0 < s.re
⊢ ↑π ^ (-s / 2) ≠ 0
case hb
s : ℂ
hs : 0 < s.re
⊢ Gamma (s / 2) ≠ 0
|
c9782cf89a013ea8
|
EReal.continuousAt_add_bot_bot
|
Mathlib/Topology/Instances/EReal/Lemmas.lean
|
theorem continuousAt_add_bot_bot : ContinuousAt (fun p : EReal × EReal => p.1 + p.2) (⊥, ⊥)
|
r : ℝ
x✝ : EReal × EReal
h : x✝.1 < ↑0 ∧ x✝.2 < ↑r
⊢ x✝.1 + x✝.2 < ↑r
|
simpa only [coe_zero, zero_add] using add_lt_add h.1 h.2
|
no goals
|
025b907b97b97f54
|
LinearMap.det_conj
|
Mathlib/LinearAlgebra/Determinant.lean
|
theorem det_conj {N : Type*} [AddCommGroup N] [Module A N] (f : M →ₗ[A] M) (e : M ≃ₗ[A] N) :
LinearMap.det ((e : M →ₗ[A] N) ∘ₗ f ∘ₗ (e.symm : N →ₗ[A] M)) = LinearMap.det f
|
case neg
M : Type u_2
inst✝⁴ : AddCommGroup M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
N : Type u_7
inst✝¹ : AddCommGroup N
inst✝ : Module A N
f : M →ₗ[A] M
e : M ≃ₗ[A] N
H : ¬∃ s, Nonempty (Basis { x // x ∈ s } A M)
⊢ LinearMap.det (↑e ∘ₗ f ∘ₗ ↑e.symm) = LinearMap.det f
|
have H' : ¬∃ t : Finset N, Nonempty (Basis t A N) := by
contrapose! H
rcases H with ⟨s, ⟨b⟩⟩
exact ⟨_, ⟨(b.map e.symm).reindexFinsetRange⟩⟩
|
case neg
M : Type u_2
inst✝⁴ : AddCommGroup M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
N : Type u_7
inst✝¹ : AddCommGroup N
inst✝ : Module A N
f : M →ₗ[A] M
e : M ≃ₗ[A] N
H : ¬∃ s, Nonempty (Basis { x // x ∈ s } A M)
H' : ¬∃ t, Nonempty (Basis { x // x ∈ t } A N)
⊢ LinearMap.det (↑e ∘ₗ f ∘ₗ ↑e.symm) = LinearMap.det f
|
97fcc4f0d8a18a2c
|
CategoryTheory.epi_iff_surjective_up_to_refinements
|
Mathlib/CategoryTheory/Abelian/Refinements.lean
|
lemma epi_iff_surjective_up_to_refinements (f : X ⟶ Y) :
Epi f ↔ ∀ ⦃A : C⦄ (y : A ⟶ Y),
∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (x : A' ⟶ X), π ≫ y = x ≫ f
|
case mp
C : Type u_2
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
a✝ : Epi f
A : C
a : A ⟶ Y
⊢ ∃ A' π, ∃ (_ : Epi π), ∃ x, π ≫ a = x ≫ f
|
exact ⟨pullback a f, pullback.fst a f, inferInstance, pullback.snd a f, pullback.condition⟩
|
no goals
|
8dab997ceac1b3da
|
CategoryTheory.GrothendieckTopology.over_map_compatiblePreserving
|
Mathlib/CategoryTheory/Sites/Over.lean
|
lemma over_map_compatiblePreserving {X Y : C} (f : X ⟶ Y) :
CompatiblePreserving (J.over Y) (Over.map f) where
compatible {F Z _ x hx Y₁ Y₂ W f₁ f₂ g₁ g₂ hg₁ hg₂ h}
|
case h.e'_3.h.e_a
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : Sheaf (J.over Y) (Type u_1)
Z : Over X
x✝ : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) x✝
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : x✝ g₁
hg₂ : x✝ g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl ((Over.map f).obj W').left) ⋯
⊢ f₂.op = ((Over.isoMk (Iso.refl W.left) ⋯).inv ≫ (Over.map f).map (Over.homMk f₂.left ⋯)).op
|
congr 1
|
case h.e'_3.h.e_a.e_f
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : Sheaf (J.over Y) (Type u_1)
Z : Over X
x✝ : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) x✝
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : x✝ g₁
hg₂ : x✝ g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl ((Over.map f).obj W').left) ⋯
⊢ f₂ = (Over.isoMk (Iso.refl W.left) ⋯).inv ≫ (Over.map f).map (Over.homMk f₂.left ⋯)
|
b30448b3f4083fa8
|
Path.delayReflRight_zero
|
Mathlib/Topology/Homotopy/HSpaces.lean
|
theorem delayReflRight_zero (γ : Path x y) : delayReflRight 0 γ = γ.trans (Path.refl y)
|
case pos
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ γ (qRight (t, 0)) = γ ⟨2 * ↑t, ⋯⟩
|
apply congr_arg γ
|
case pos
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ qRight (t, 0) = ⟨2 * ↑t, ⋯⟩
|
ece5c946a8b6b2c4
|
LinearPMap.mem_domain_iff
|
Mathlib/LinearAlgebra/LinearPMap.lean
|
theorem mem_domain_iff {f : E →ₗ.[R] F} {x : E} : x ∈ f.domain ↔ ∃ y : F, (x, y) ∈ f.graph
|
R : Type u_1
inst✝⁴ : Ring R
E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module R E
F : Type u_3
inst✝¹ : AddCommGroup F
inst✝ : Module R F
f : E →ₗ.[R] F
x : E
⊢ x ∈ f.domain ↔ ∃ y, (x, y) ∈ f.graph
|
constructor <;> intro h
|
case mp
R : Type u_1
inst✝⁴ : Ring R
E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module R E
F : Type u_3
inst✝¹ : AddCommGroup F
inst✝ : Module R F
f : E →ₗ.[R] F
x : E
h : x ∈ f.domain
⊢ ∃ y, (x, y) ∈ f.graph
case mpr
R : Type u_1
inst✝⁴ : Ring R
E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module R E
F : Type u_3
inst✝¹ : AddCommGroup F
inst✝ : Module R F
f : E →ₗ.[R] F
x : E
h : ∃ y, (x, y) ∈ f.graph
⊢ x ∈ f.domain
|
8da0e3a2043b5c33
|
MeasureTheory.eLpNorm_le_eLpNorm_fderiv_of_eq_inner
|
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean
|
theorem eLpNorm_le_eLpNorm_fderiv_of_eq_inner {u : E → F'}
(hu : ContDiff ℝ 1 u) (h2u : HasCompactSupport u)
{p p' : ℝ≥0} (hp : 1 ≤ p) (hn : 0 < finrank ℝ E)
(hp' : (p' : ℝ)⁻¹ = p⁻¹ - (finrank ℝ E : ℝ)⁻¹) :
eLpNorm u p' μ ≤ eLpNormLESNormFDerivOfEqInnerConst μ p * eLpNorm (fderiv ℝ u) p μ
|
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F' : Type u_5
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : CompleteSpace F'
u : E → F'
hu : ContDiff ℝ 1 u
h2u : HasCompactSupport u
p p' : ℝ≥0
hp : 1 ≤ p
hp'0 : ¬p' = 0
n : ℕ := finrank ℝ E
hn : 0 < n
hp' : (↑p')⁻¹ = ↑p⁻¹ - (↑n)⁻¹
n' : ℝ≥0 := (↑n).conjExponent
this : 0 < ↑p⁻¹ - (↑n)⁻¹
⊢ ↑p < ↑n
|
rwa [NNReal.coe_inv, sub_pos,
inv_lt_inv₀ _ (zero_lt_one.trans_le (NNReal.coe_le_coe.mpr hp))] at this
|
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F' : Type u_5
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : CompleteSpace F'
u : E → F'
hu : ContDiff ℝ 1 u
h2u : HasCompactSupport u
p p' : ℝ≥0
hp : 1 ≤ p
hp'0 : ¬p' = 0
n : ℕ := finrank ℝ E
hn : 0 < n
hp' : (↑p')⁻¹ = ↑p⁻¹ - (↑n)⁻¹
n' : ℝ≥0 := (↑n).conjExponent
this : (↑n)⁻¹ < (↑p)⁻¹
⊢ 0 < ↑n
|
728bbe5fb5258103
|
WeakDual.CharacterSpace.ext_ker
|
Mathlib/Topology/Algebra/Module/CharacterSpace.lean
|
theorem ext_ker {φ ψ : characterSpace 𝕜 A} (h : RingHom.ker φ = RingHom.ker ψ) : φ = ψ
|
case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
⊢ φ x = ψ x
|
have : x - algebraMap 𝕜 A (ψ x) ∈ RingHom.ker φ := by
simpa only [h, RingHom.mem_ker, map_sub, AlgHomClass.commutes] using sub_self (ψ x)
|
case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
this : x - (algebraMap 𝕜 A) (ψ x) ∈ RingHom.ker φ
⊢ φ x = ψ x
|
536b9d00b0364064
|
Lean.Omega.Constraint.scale_sat
|
Mathlib/.lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
|
theorem scale_sat {c : Constraint} (k) (w : c.sat t) : (scale k c).sat (k * t)
|
case isFalse.mk.none.some.isFalse
t k : Int
h✝ : ¬k = 0
u : Int
w : t ≤ u
h : k ≤ 0
⊢ k * u ≤ k * t
|
exact Int.mul_le_mul_of_nonpos_left h w
|
no goals
|
498e5968042038b0
|
DFinsupp.support_update_ne_zero
|
Mathlib/Data/DFinsupp/Defs.lean
|
theorem support_update_ne_zero (f : Π₀ i, β i) (i : ι) {b : β i} (h : b ≠ 0) :
support (f.update i b) = insert i f.support
|
case h.inl
ι : Type u
β : ι → Type v
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
⊢ i ∈ (f.update i b).support ↔ i ∈ insert i f.support
|
simp [h]
|
no goals
|
c7d5d2c6b8773acd
|
Nat.getLast_digit_ne_zero
|
Mathlib/Data/Nat/Digits.lean
|
theorem getLast_digit_ne_zero (b : ℕ) {m : ℕ} (hm : m ≠ 0) :
(digits b m).getLast (digits_ne_nil_iff_ne_zero.mpr hm) ≠ 0
|
case zero.zero
hm : 0 ≠ 0
⊢ (digits 0 0).getLast ⋯ ≠ 0
|
cases hm rfl
|
no goals
|
f80a47e31809cc02
|
Subgroup.smul_mem_of_mem_closure_of_mem
|
Mathlib/Algebra/Group/Subgroup/Pointwise.lean
|
theorem smul_mem_of_mem_closure_of_mem {X : Type*} [MulAction G X] {s : Set G} {t : Set X}
(hs : ∀ g ∈ s, g⁻¹ ∈ s) (hst : ∀ᵉ (g ∈ s) (x ∈ t), g • x ∈ t) {g : G}
(hg : g ∈ Subgroup.closure s) {x : X} (hx : x ∈ t) : g • x ∈ t
|
case inv_mem
G : Type u_2
inst✝¹ : Group G
X : Type u_5
inst✝ : MulAction G X
s : Set G
t : Set X
hs : ∀ g ∈ s, g⁻¹ ∈ s
hst : ∀ g ∈ s, ∀ x ∈ t, g • x ∈ t
g g' : G
hg' : g' ∈ s
x : X
hx : x ∈ t
⊢ g'⁻¹ • x ∈ t
|
exact hst g'⁻¹ (hs g' hg') x hx
|
no goals
|
4eab67206dcd6372
|
orthonormal_fourier
|
Mathlib/Analysis/Fourier/AddCircle.lean
|
theorem orthonormal_fourier : Orthonormal ℂ (@fourierLp T _ 2 _)
|
T : ℝ
hT : Fact (0 < T)
i j : ℤ
h : ¬i = j
⊢ -i + j ≠ 0
|
rw [add_comm]
|
T : ℝ
hT : Fact (0 < T)
i j : ℤ
h : ¬i = j
⊢ j + -i ≠ 0
|
1362cf6350008e93
|
AlgebraicGeometry.PresheafedSpace.GlueData.snd_invApp_t_app'
|
Mathlib/Geometry/RingedSpace/PresheafedSpace/Gluing.lean
|
theorem snd_invApp_t_app' (i j k : D.J) (U : Opens (pullback (D.f i j) (D.f i k)).carrier) :
∃ eq,
(π₂⁻¹ i, j, k) U ≫ (D.t k i).c.app _ ≫ (D.V (k, i)).presheaf.map (eqToHom eq) =
(D.t' k i j).c.app _ ≫ (π₁⁻¹ k, j, i) (unop _)
|
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
⊢ (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
(D.V (k, i)).presheaf.map (eqToHom ⋯) =
(((pullback.snd (D.f i j) (D.f i k)).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
(D.t' k i j).c.app
(op
((Opens.map (pullback.snd (D.f i j) (D.f i k)).base).obj
((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)))) ≫
(pullback (D.f k i) (D.f k j)).presheaf.map ((Opens.map (D.t' k i j).base).map (eqToHom ⋯).unop).op) ≫
invApp (pullback.fst (D.f k i) (D.f k j)) ((Opens.map (D.t' k i j).base).toPrefunctor.1 U)
|
rw [← comp_c_app, congr_app (D.t_fac k i j), comp_c_app]
|
case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
⊢ (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
(D.V (k, i)).presheaf.map (eqToHom ⋯) =
((((D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
(pullback.fst (D.f k i) (D.f k j)).c.app
(op
((Opens.map (D.t k i).base).obj
(unop (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)))))) ≫
(pullback (D.f k i) (D.f k j)).presheaf.map (eqToHom ⋯)) ≫
(pullback (D.f k i) (D.f k j)).presheaf.map ((Opens.map (D.t' k i j).base).map (eqToHom ⋯).unop).op) ≫
invApp (pullback.fst (D.f k i) (D.f k j)) ((Opens.map (D.t' k i j).base).toPrefunctor.1 U)
|
e08cb0129b520e6d
|
Equiv.Perm.mem_list_cycles_iff
|
Mathlib/GroupTheory/Perm/Cycle/Factors.lean
|
theorem mem_list_cycles_iff {α : Type*} [Finite α] {l : List (Perm α)}
(h1 : ∀ σ : Perm α, σ ∈ l → σ.IsCycle) (h2 : l.Pairwise Disjoint) {σ : Perm α} :
σ ∈ l ↔ σ.IsCycle ∧ ∀ a, σ a ≠ a → σ a = l.prod a
|
case h.e'_5
α : Type u_4
inst✝ : Finite α
l : List (Perm α)
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
σ : Perm α
h3 : σ.IsCycle
val✝ : Fintype α
h : ∀ (a : α), σ a ≠ a → σ a = l.prod a
hσl : σ.support ⊆ l.prod.support
a : α
ha : a ∈ σ.support
τ : Perm α
hτ : τ ∈ l
hτa : a ∈ τ.support
hτl : ∀ x ∈ τ.support, τ x = l.prod x
key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x
⊢ σ = τ
|
refine h3.eq_on_support_inter_nonempty_congr (h1 _ hτ) key ?_ ha
|
case h.e'_5
α : Type u_4
inst✝ : Finite α
l : List (Perm α)
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
σ : Perm α
h3 : σ.IsCycle
val✝ : Fintype α
h : ∀ (a : α), σ a ≠ a → σ a = l.prod a
hσl : σ.support ⊆ l.prod.support
a : α
ha : a ∈ σ.support
τ : Perm α
hτ : τ ∈ l
hτa : a ∈ τ.support
hτl : ∀ x ∈ τ.support, τ x = l.prod x
key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x
⊢ σ a = τ a
|
0cc516b4ece5c647
|
Polynomial.natDegree_mod_lt
|
Mathlib/Algebra/Polynomial/FieldDivision.lean
|
lemma natDegree_mod_lt [Field k] (p : k[X]) {q : k[X]} (hq : q.natDegree ≠ 0) :
(p % q).natDegree < q.natDegree
|
k : Type y
inst✝ : Field k
p q : k[X]
hq : q.natDegree ≠ 0
⊢ (p % q).natDegree < q.natDegree
|
have hq' : q.leadingCoeff ≠ 0 := by
rw [leadingCoeff_ne_zero]
contrapose! hq
simp [hq]
|
k : Type y
inst✝ : Field k
p q : k[X]
hq : q.natDegree ≠ 0
hq' : q.leadingCoeff ≠ 0
⊢ (p % q).natDegree < q.natDegree
|
c1edaa831c1aaa7d
|
List.countP_erase
|
Mathlib/Data/List/Count.lean
|
lemma countP_erase (p : α → Bool) (l : List α) (a : α) :
countP p (l.erase a) = countP p l - if a ∈ l ∧ p a then 1 else 0
|
α : Type u_1
inst✝ : DecidableEq α
p : α → Bool
l : List α
a : α
⊢ countP p (l.erase a) = countP p l - if a ∈ l ∧ p a = true then 1 else 0
|
rw [countP_eq_length_filter, countP_eq_length_filter, ← erase_filter, length_erase]
|
α : Type u_1
inst✝ : DecidableEq α
p : α → Bool
l : List α
a : α
⊢ (if a ∈ filter p l then (filter p l).length - 1 else (filter p l).length) =
(filter p l).length - if a ∈ l ∧ p a = true then 1 else 0
|
3c5560675ae847f4
|
Submodule.mem_iSup_iff_exists_finsupp
|
Mathlib/LinearAlgebra/DFinsupp.lean
|
lemma mem_iSup_iff_exists_finsupp (p : ι → Submodule R N) (x : N) :
x ∈ iSup p ↔ ∃ (f : ι →₀ N), (∀ i, f i ∈ p i) ∧ (f.sum fun _i xi ↦ xi) = x
|
case intro.intro.refine_2
ι : Type u_1
R : Type u_2
N : Type u_5
inst✝² : Semiring R
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
p : ι → Submodule R N
f : ι →₀ N
hf : ∀ (i : ι), f i ∈ p i
i : ι
hi : i ∈ f.support
⊢ (fun x xi => ↑xi) i ((DFinsupp.mk f.support fun i => ⟨f ↑i, ⋯⟩) i) = (fun _i xi => xi) i (f i)
|
simp [Finsupp.mem_support_iff.mp hi]
|
no goals
|
1c0c258395c7890b
|
Int.Cooper.resolve_left_dvd₁
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Int/Cooper.lean
|
theorem resolve_left_dvd₁ (a c d p x : Int) (h₁ : p ≤ a * x) :
a ∣ resolve_left a c d p x + p
|
a c d p x : Int
h₁ : p ≤ a * x
k' : Nat
w : a * x = p + ↑k'
⊢ ↑k' + p = a * x
|
rw [w, Int.add_comm]
|
no goals
|
4717869eaf119b13
|
FDRep.average_char_eq_finrank_invariants
|
Mathlib/RepresentationTheory/Character.lean
|
theorem average_char_eq_finrank_invariants (V : FDRep k G) :
⅟ (Fintype.card G : k) • ∑ g : G, V.character g = finrank k (invariants V.ρ)
|
k : Type u
inst✝³ : Field k
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
inst✝ : Invertible ↑(Fintype.card G)
V : FDRep k G
⊢ ⅟↑(Fintype.card G) • ∑ g : G, V.character g = (trace k ↑V.V) (averageMap V.ρ)
|
simp [character, GroupAlgebra.average, _root_.map_sum]
|
no goals
|
905d0d1df2842315
|
List.forIn'_congr
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Monadic.lean
|
theorem forIn'_congr [Monad m] {as bs : List α} (w : as = bs)
{b b' : β} (hb : b = b')
{f : (a' : α) → a' ∈ as → β → m (ForInStep β)}
{g : (a' : α) → a' ∈ bs → β → m (ForInStep β)}
(h : ∀ a m b, f a (by simpa [w] using m) b = g a m b) :
forIn' as b f = forIn' bs b' g
|
case cons.cons.intro.e_a.h.yield
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
b✝ b' : β
hb : b✝ = b'
a : α
as : List α
f : (a' : α) → a' ∈ a :: as → β → m (ForInStep β)
ih :
∀ {as_1 : List α} (w : as_1 = as) {b b' : β},
b = b' →
∀ {f : (a' : α) → a' ∈ as_1 → β → m (ForInStep β)} {g : (a' : α) → a' ∈ as → β → m (ForInStep β)},
(∀ (a : α) (m_1 : a ∈ as) (b : β), f a ⋯ b = g a m_1 b) → forIn' as_1 b f = forIn' as b' g
g : (a' : α) → a' ∈ a :: as → β → m (ForInStep β)
w : a :: as = a :: as
h : ∀ (a_1 : α) (m_1 : a_1 ∈ a :: as) (b : β), f a_1 ⋯ b = g a_1 m_1 b
b : β
⊢ ∀ (a_1 : α) (m_1 : a_1 ∈ as) (b : β), f a_1 ⋯ b = g a_1 ⋯ b
|
intro a m b
|
case cons.cons.intro.e_a.h.yield
m✝ : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m✝
b✝¹ b' : β
hb : b✝¹ = b'
a✝ : α
as : List α
f : (a' : α) → a' ∈ a✝ :: as → β → m✝ (ForInStep β)
ih :
∀ {as_1 : List α} (w : as_1 = as) {b b' : β},
b = b' →
∀ {f : (a' : α) → a' ∈ as_1 → β → m✝ (ForInStep β)} {g : (a' : α) → a' ∈ as → β → m✝ (ForInStep β)},
(∀ (a : α) (m : a ∈ as) (b : β), f a ⋯ b = g a m b) → forIn' as_1 b f = forIn' as b' g
g : (a' : α) → a' ∈ a✝ :: as → β → m✝ (ForInStep β)
w : a✝ :: as = a✝ :: as
h : ∀ (a : α) (m : a ∈ a✝ :: as) (b : β), f a ⋯ b = g a m b
b✝ : β
a : α
m : a ∈ as
b : β
⊢ f a ⋯ b = g a ⋯ b
|
b21e9d91722268c4
|
List.head?_zipWith
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Zip.lean
|
theorem head?_zipWith {f : α → β → γ} :
(List.zipWith f as bs).head? = match as.head?, bs.head? with
| some a, some b => some (f a b) | _, _ => none
|
α : Type u_1
β : Type u_2
γ : Type u_3
as : List α
bs : List β
f : α → β → γ
⊢ (zipWith f as bs).head? =
match as.head?, bs.head? with
| some a, some b => some (f a b)
| x, x_1 => none
|
simp [head?_eq_getElem?, getElem?_zipWith]
|
no goals
|
7f88082bfe80a9fd
|
CategoryTheory.extensiveTopology.mem_sieves_iff_contains_colimit_cofan
|
Mathlib/CategoryTheory/Sites/Coherent/ExtensiveTopology.lean
|
lemma extensiveTopology.mem_sieves_iff_contains_colimit_cofan {X : C} (S : Sieve X) :
S ∈ (extensiveTopology C) X ↔
(∃ (α : Type) (_ : Finite α) (Y : α → C) (π : (a : α) → (Y a ⟶ X)),
Nonempty (IsColimit (Cofan.mk X π)) ∧ (∀ a : α, (S.arrows) (π a)))
|
case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : FinitaryPreExtensive C
X : C
S : Sieve X
⊢ (∃ α, ∃ (_ : Finite α), ∃ Y π, Nonempty (IsColimit (Cofan.mk X π)) ∧ ∀ (a : α), S.arrows (π a)) →
S ∈ (extensiveTopology C) X
|
intro ⟨α, _, Y, π, h, h'⟩
|
case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : FinitaryPreExtensive C
X : C
S : Sieve X
α : Type
w✝ : Finite α
Y : α → C
π : (a : α) → Y a ⟶ X
h : Nonempty (IsColimit (Cofan.mk X π))
h' : ∀ (a : α), S.arrows (π a)
⊢ S ∈ (extensiveTopology C) X
|
3464c4e8e1c1caf4
|
AffineSubspace.setOf_sSameSide_eq_image2
|
Mathlib/Analysis/Convex/Side.lean
|
theorem setOf_sSameSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
{ y | s.SSameSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Ioi 0) s
|
case h.mp
R : Type u_1
V : Type u_2
P : Type u_4
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
⊢ s.SSameSide x y → ∃ a, 0 < a ∧ ∃ b ∈ ↑s, a • (x -ᵥ p) +ᵥ b = y
|
rw [sSameSide_iff_exists_left hp]
|
case h.mp
R : Type u_1
V : Type u_2
P : Type u_4
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
⊢ (x ∉ s ∧ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p) (y -ᵥ p₂)) → ∃ a, 0 < a ∧ ∃ b ∈ ↑s, a • (x -ᵥ p) +ᵥ b = y
|
96d8b7db8dee1b03
|
Ergodic.zero_measure
|
Mathlib/Dynamics/Ergodic/Ergodic.lean
|
theorem zero_measure {f : α → α} (hf : Measurable f) : @Ergodic α m f 0 where
measurable := hf
map_eq
|
α : Type u_1
m : MeasurableSpace α
f : α → α
hf : Measurable f
⊢ Measure.map f 0 = 0
|
simp
|
no goals
|
a746010c0e268f32
|
piiUnionInter_singleton
|
Mathlib/MeasureTheory/PiSystem.lean
|
theorem piiUnionInter_singleton (π : ι → Set (Set α)) (i : ι) :
piiUnionInter π {i} = π i ∪ {univ}
|
case pos
α : Type u_3
ι : Type u_4
π : ι → Set (Set α)
i : ι
t : Finset ι
f : ι → Set α
hfπ : ∀ x ∈ t, f x ∈ π x
hti : ∀ y ∈ t, y = i
hi : i ∈ t
ht_eq_i : t = {i}
⊢ f i ∈ π i ∨ f i ∈ {univ}
|
exact Or.inl (hfπ i hi)
|
no goals
|
d8b76da0d2d10fc7
|
CategoryTheory.InjectiveResolution.ofCocomplex_exactAt_succ
|
Mathlib/CategoryTheory/Abelian/Injective/Resolution.lean
|
lemma ofCocomplex_exactAt_succ (n : ℕ) :
(ofCocomplex Z).ExactAt (n + 1)
|
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : EnoughInjectives C
Z : C
n : ℕ
⊢ (ShortComplex.mk
(CochainComplex.mkAux (under Z) (syzygies (Injective.ι Z)) (syzygies (d (Injective.ι Z))) (d (Injective.ι Z))
(d (d (Injective.ι Z))) ⋯ (fun S => ⟨syzygies S.g, ⟨d S.g, ⋯⟩⟩) 0).f
(CochainComplex.mkAux (under Z) (syzygies (Injective.ι Z)) (syzygies (d (Injective.ι Z))) (d (Injective.ι Z))
(d (d (Injective.ι Z))) ⋯ (fun S => ⟨syzygies S.g, ⟨d S.g, ⋯⟩⟩) (0 + 1)).f
⋯).Exact
|
apply exact_f_d ((CochainComplex.mkAux _ _ _
(d (Injective.ι Z)) (d (d (Injective.ι Z))) _ _ 0).f)
|
no goals
|
7abb2c8c6ef1cb12
|
dist_integral_mulExpNegMulSq_comp_le
|
Mathlib/Analysis/SpecialFunctions/MulExpNegMulSqIntegral.lean
|
theorem dist_integral_mulExpNegMulSq_comp_le (f : E →ᵇ ℝ)
{A : Subalgebra ℝ C(E, ℝ)} (hA : A.SeparatesPoints)
(hbound : ∀ g ∈ A, ∃ C, ∀ x y : E, dist (g x) (g y) ≤ C)
(heq : ∀ g ∈ A, ∫ x, (g : E → ℝ) x ∂P = ∫ x, (g : E → ℝ) x ∂P') (hε : 0 < ε) :
|∫ x, mulExpNegMulSq ε (f x) ∂P - ∫ x, mulExpNegMulSq ε (f x) ∂P'| ≤ 6 * sqrt ε
|
case neg.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
ε : ℝ
E : Type u_2
inst✝⁶ : MeasurableSpace E
inst✝⁵ : PseudoEMetricSpace E
inst✝⁴ : BorelSpace E
inst✝³ : CompleteSpace E
inst✝² : SecondCountableTopology E
P P' : Measure E
inst✝¹ : IsFiniteMeasure P
inst✝ : IsFiniteMeasure P'
f : E →ᵇ ℝ
A : Subalgebra ℝ C(E, ℝ)
hA : A.SeparatesPoints
hbound : ∀ g ∈ A, ∃ C, ∀ (x y : E), dist (g x) (g y) ≤ C
heq : ∀ g ∈ A, ∫ (x : E), g x ∂P = ∫ (x : E), g x ∂P'
hε : 0 < ε
hPP' : ¬(P = 0 ∧ P' = 0)
const : ℝ := (P Set.univ).toReal ⊔ (P' Set.univ).toReal
pos_of_measure : 0 < const
KP : Set E
left✝¹ : KP ⊆ Set.univ
hKPco : IsCompact KP
hKPcl : IsClosed KP
KP' : Set E
left✝ : KP' ⊆ Set.univ
hKP'co : IsCompact KP'
hKP'cl : IsClosed KP'
K : Set E := KP ∪ KP'
hKco : IsCompact (KP ∪ KP')
hKcl : IsClosed (KP ∪ KP')
hKP : P KPᶜ < ENNReal.ofReal ε
hKP' : P' KP'ᶜ < ENNReal.ofReal ε
hKPbound : P (KP ∪ KP')ᶜ < ↑ε.toNNReal
hKP'bound : P' (KP ∪ KP')ᶜ < ↑ε.toNNReal
g : C(E, ℝ)
hgA : g ∈ A
hgapprox : ∀ x ∈ KP ∪ KP', ‖g x - f.toContinuousMap x‖ < √ε * const⁻¹
line1 : |∫ (x : E), ε.mulExpNegMulSq (f x) ∂P - ∫ (x : E) in K, ε.mulExpNegMulSq (f x) ∂P| < √ε
⊢ |∫ (x : E), ε.mulExpNegMulSq (f x) ∂P - ∫ (x : E), ε.mulExpNegMulSq (f x) ∂P'| ≤ 6 * √ε
|
have line3 : |∫ x in K, mulExpNegMulSq ε (g x) ∂P
- ∫ x, mulExpNegMulSq ε (g x) ∂P| < sqrt ε := by
rw [abs_sub_comm]
exact (abs_integral_sub_setIntegral_mulExpNegMulSq_comp_lt
g (IsClosed.measurableSet hKcl) hε hKPbound)
|
case neg.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
ε : ℝ
E : Type u_2
inst✝⁶ : MeasurableSpace E
inst✝⁵ : PseudoEMetricSpace E
inst✝⁴ : BorelSpace E
inst✝³ : CompleteSpace E
inst✝² : SecondCountableTopology E
P P' : Measure E
inst✝¹ : IsFiniteMeasure P
inst✝ : IsFiniteMeasure P'
f : E →ᵇ ℝ
A : Subalgebra ℝ C(E, ℝ)
hA : A.SeparatesPoints
hbound : ∀ g ∈ A, ∃ C, ∀ (x y : E), dist (g x) (g y) ≤ C
heq : ∀ g ∈ A, ∫ (x : E), g x ∂P = ∫ (x : E), g x ∂P'
hε : 0 < ε
hPP' : ¬(P = 0 ∧ P' = 0)
const : ℝ := (P Set.univ).toReal ⊔ (P' Set.univ).toReal
pos_of_measure : 0 < const
KP : Set E
left✝¹ : KP ⊆ Set.univ
hKPco : IsCompact KP
hKPcl : IsClosed KP
KP' : Set E
left✝ : KP' ⊆ Set.univ
hKP'co : IsCompact KP'
hKP'cl : IsClosed KP'
K : Set E := KP ∪ KP'
hKco : IsCompact (KP ∪ KP')
hKcl : IsClosed (KP ∪ KP')
hKP : P KPᶜ < ENNReal.ofReal ε
hKP' : P' KP'ᶜ < ENNReal.ofReal ε
hKPbound : P (KP ∪ KP')ᶜ < ↑ε.toNNReal
hKP'bound : P' (KP ∪ KP')ᶜ < ↑ε.toNNReal
g : C(E, ℝ)
hgA : g ∈ A
hgapprox : ∀ x ∈ KP ∪ KP', ‖g x - f.toContinuousMap x‖ < √ε * const⁻¹
line1 : |∫ (x : E), ε.mulExpNegMulSq (f x) ∂P - ∫ (x : E) in K, ε.mulExpNegMulSq (f x) ∂P| < √ε
line3 : |∫ (x : E) in K, ε.mulExpNegMulSq (g x) ∂P - ∫ (x : E), ε.mulExpNegMulSq (g x) ∂P| < √ε
⊢ |∫ (x : E), ε.mulExpNegMulSq (f x) ∂P - ∫ (x : E), ε.mulExpNegMulSq (f x) ∂P'| ≤ 6 * √ε
|
6c7688b02378f81c
|
CategoryTheory.Subgroupoid.isNormal_map
|
Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
|
theorem isNormal_map (hφ : Function.Injective φ.obj) (hφ' : im φ hφ = ⊤) (Sn : S.IsNormal) :
(map φ hφ S).IsNormal :=
{ wide := fun d => by
obtain ⟨c, rfl⟩ := obj_surjective_of_im_eq_top φ hφ hφ' d
change Map.Arrows φ hφ S _ _ (𝟙 _); rw [← Functor.map_id]
constructor; exact Sn.wide c
conj := fun {d d'} g δ hδ => by
rw [mem_map_iff] at hδ
obtain ⟨c, c', γ, cd, cd', γS, hγ⟩ := hδ; subst_vars; cases hφ cd'
have : d' ∈ (im φ hφ).objs
|
case intro.intro.intro.intro.intro.intro.refl.intro
C : Type u
inst✝¹ : Groupoid C
S : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
hφ' : im φ hφ = ⊤
Sn : S.IsNormal
c : C
γ : c ⟶ c
γS : γ ∈ S.arrows c c
cd' : φ.obj c = φ.obj c
c' : C
g : φ.obj c ⟶ φ.obj c'
⊢ Groupoid.inv g ≫ (eqToHom ⋯ ≫ φ.map γ ≫ eqToHom cd') ≫ g ∈ (map φ hφ S).arrows (φ.obj c') (φ.obj c')
|
have : g ∈ (im φ hφ).arrows (φ.obj c) (φ.obj c') := by rw [hφ']; trivial
|
case intro.intro.intro.intro.intro.intro.refl.intro
C : Type u
inst✝¹ : Groupoid C
S : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
hφ' : im φ hφ = ⊤
Sn : S.IsNormal
c : C
γ : c ⟶ c
γS : γ ∈ S.arrows c c
cd' : φ.obj c = φ.obj c
c' : C
g : φ.obj c ⟶ φ.obj c'
this : g ∈ (im φ hφ).arrows (φ.obj c) (φ.obj c')
⊢ Groupoid.inv g ≫ (eqToHom ⋯ ≫ φ.map γ ≫ eqToHom cd') ≫ g ∈ (map φ hφ S).arrows (φ.obj c') (φ.obj c')
|
38dea252c0a3b817
|
uniformCauchySeqOn_ball_of_deriv
|
Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
|
theorem uniformCauchySeqOn_ball_of_deriv {r : ℝ} (hf' : UniformCauchySeqOn f' l (Metric.ball x r))
(hf : ∀ n : ι, ∀ y : 𝕜, y ∈ Metric.ball x r → HasDerivAt (f n) (f' n y) y)
(hfg : Cauchy (map (fun n => f n x) l)) : UniformCauchySeqOn f l (Metric.ball x r)
|
ι : Type u_1
l : Filter ι
𝕜 : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f f' : ι → 𝕜 → G
x : 𝕜
inst✝ : IsRCLikeNormedField 𝕜
r : ℝ
hf'✝ : UniformCauchySeqOnFilter f' l (𝓟 (Metric.ball x r))
hfg : Cauchy (map (fun n => f n x) l)
hf : ∀ (n : ι), ∀ y ∈ Metric.ball x r, HasFDerivAt (f n) (ContinuousLinearMap.smulRight 1 (f' n y)) y
hf' : UniformCauchySeqOn (fun n z => ContinuousLinearMap.smulRight 1 (f' n z)) l (Metric.ball x r)
⊢ UniformCauchySeqOn f l (Metric.ball x r)
|
exact uniformCauchySeqOn_ball_of_fderiv hf' hf hfg
|
no goals
|
38780b170b1d275d
|
Complex.mul_cpow_ofReal_nonneg
|
Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
|
theorem mul_cpow_ofReal_nonneg {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (r : ℂ) :
((a : ℂ) * (b : ℂ)) ^ r = (a : ℂ) ^ r * (b : ℂ) ^ r
|
case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
|
have ha'' : (a : ℂ) ≠ 0 := ofReal_ne_zero.mpr ha'.ne'
|
case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
ha'' : ↑a ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
|
385cc79a0a30c890
|
SatisfiesM_EStateM_eq
|
Mathlib/.lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
|
theorem SatisfiesM_EStateM_eq :
SatisfiesM (m := EStateM ε σ) p x ↔ ∀ s a s', x.run s = .ok a s' → p a
|
case mpr.refine_2.h
ε σ α✝ : Type u_1
p : α✝ → Prop
x : EStateM ε σ α✝
w : ∀ (s : σ) (a : α✝) (s' : σ), x.run s = EStateM.Result.ok a s' → p a
s : σ
⊢ (Subtype.val <$> fun s =>
match q : x.run s with
| EStateM.Result.ok a s' => EStateM.Result.ok ⟨a, ⋯⟩ s'
| EStateM.Result.error e s' => EStateM.Result.error e s').run
s =
x.run s
|
rw [EStateM.run_map, EStateM.run]
|
case mpr.refine_2.h
ε σ α✝ : Type u_1
p : α✝ → Prop
x : EStateM ε σ α✝
w : ∀ (s : σ) (a : α✝) (s' : σ), x.run s = EStateM.Result.ok a s' → p a
s : σ
⊢ EStateM.Result.map Subtype.val
(match q : x.run s with
| EStateM.Result.ok a s' => EStateM.Result.ok ⟨a, ⋯⟩ s'
| EStateM.Result.error e s' => EStateM.Result.error e s') =
x.run s
|
6fb1fa46dc09b1a6
|
MeasureTheory.SignedMeasure.toSignedMeasure_toJordanDecomposition
|
Mathlib/MeasureTheory/Decomposition/Jordan.lean
|
theorem toSignedMeasure_toJordanDecomposition (s : SignedMeasure α) :
s.toJordanDecomposition.toSignedMeasure = s
|
case intro.intro.intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hi₁ : MeasurableSet i
hi₂ : 0 ≤[i] s
hi₃ : s ≤[iᶜ] 0
hμ : s.toJordanDecomposition.posPart = s.toMeasureOfZeroLE i hi₁ hi₂
hν : s.toJordanDecomposition.negPart = s.toMeasureOfLEZero iᶜ ⋯ hi₃
⊢ s.toJordanDecomposition.toSignedMeasure = s
|
simp only [JordanDecomposition.toSignedMeasure, hμ, hν]
|
case intro.intro.intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hi₁ : MeasurableSet i
hi₂ : 0 ≤[i] s
hi₃ : s ≤[iᶜ] 0
hμ : s.toJordanDecomposition.posPart = s.toMeasureOfZeroLE i hi₁ hi₂
hν : s.toJordanDecomposition.negPart = s.toMeasureOfLEZero iᶜ ⋯ hi₃
⊢ (s.toMeasureOfZeroLE i hi₁ hi₂).toSignedMeasure - (s.toMeasureOfLEZero iᶜ ⋯ hi₃).toSignedMeasure = s
|
eb0fd2c3a693cf1a
|
Subgroup.leftCoset_cover_filter_FiniteIndex_aux
|
Mathlib/GroupTheory/CosetCover.lean
|
theorem leftCoset_cover_filter_FiniteIndex_aux
[DecidablePred (FiniteIndex : Subgroup G → Prop)] :
(⋃ k ∈ s.filter (fun i => (H i).FiniteIndex), g k • (H k : Set G) = Set.univ) ∧
(1 ≤ ∑ i ∈ s, ((H i).index : ℚ)⁻¹) ∧
(∑ i ∈ s, ((H i).index : ℚ)⁻¹ = 1 → Set.PairwiseDisjoint
(s.filter (fun i => (H i).FiniteIndex)) (fun i ↦ g i • (H i : Set G)))
|
case refine_2
G : Type u_1
inst✝¹ : Group G
ι : Type u_2
H : ι → Subgroup G
g : ι → G
s : Finset ι
hcovers : ⋃ i ∈ s, g i • ↑(H i) = Set.univ
inst✝ : DecidablePred FiniteIndex
D : Subgroup G := ⨅ k ∈ Finset.filter (fun i => (H i).FiniteIndex) s, H k
hD : D.FiniteIndex
hD_le : ∀ {i : ι}, i ∈ s → (H i).FiniteIndex → D ≤ H i
t : (i : ι) → i ∈ s → (H i).FiniteIndex → Finset ↥(H i)
ht :
∀ (i : ι) (hi : i ∈ s) (hfi : (H i).FiniteIndex),
IsComplement ↑(t i hi hfi) ↑(D.subgroupOf (H i)) ∧ ⋃ g ∈ t i hi hfi, ↑g • ↑D = ↑(H i)
κ : Type (max u_2 u_1) := (i : { x // x ∈ s }) × { x // x ∈ if h : (H ↑i).FiniteIndex then t ↑i ⋯ h else {1} }
f : κ → G := fun k => g ↑k.fst * ↑↑k.snd
K : κ → Subgroup G := fun k => if (H ↑k.fst).FiniteIndex then D else H ↑k.fst
k : κ
hkfi : (H ↑k.fst).FiniteIndex
hk : K k = D
hcovers' : ⋃ i ∈ Finset.filter (fun x => K x = D) Finset.univ, f i • ↑D = Set.univ
hHD : ∀ (i : ι), ¬(H i).FiniteIndex → H i ≠ D
hdensity : ∑ i ∈ s, (↑(H i).index)⁻¹ = ↑(Finset.filter (fun x => K x = D) Finset.univ).card * (↑D.index)⁻¹
⊢ 1 * ↑D.index ≤ ↑(Finset.filter (fun x => K x = D) Finset.univ).card * (↑D.index)⁻¹ * ↑D.index
|
rw [one_mul, mul_assoc, inv_mul_cancel₀ (Nat.cast_ne_zero.mpr hD.finiteIndex), mul_one,
Nat.cast_le]
|
case refine_2
G : Type u_1
inst✝¹ : Group G
ι : Type u_2
H : ι → Subgroup G
g : ι → G
s : Finset ι
hcovers : ⋃ i ∈ s, g i • ↑(H i) = Set.univ
inst✝ : DecidablePred FiniteIndex
D : Subgroup G := ⨅ k ∈ Finset.filter (fun i => (H i).FiniteIndex) s, H k
hD : D.FiniteIndex
hD_le : ∀ {i : ι}, i ∈ s → (H i).FiniteIndex → D ≤ H i
t : (i : ι) → i ∈ s → (H i).FiniteIndex → Finset ↥(H i)
ht :
∀ (i : ι) (hi : i ∈ s) (hfi : (H i).FiniteIndex),
IsComplement ↑(t i hi hfi) ↑(D.subgroupOf (H i)) ∧ ⋃ g ∈ t i hi hfi, ↑g • ↑D = ↑(H i)
κ : Type (max u_2 u_1) := (i : { x // x ∈ s }) × { x // x ∈ if h : (H ↑i).FiniteIndex then t ↑i ⋯ h else {1} }
f : κ → G := fun k => g ↑k.fst * ↑↑k.snd
K : κ → Subgroup G := fun k => if (H ↑k.fst).FiniteIndex then D else H ↑k.fst
k : κ
hkfi : (H ↑k.fst).FiniteIndex
hk : K k = D
hcovers' : ⋃ i ∈ Finset.filter (fun x => K x = D) Finset.univ, f i • ↑D = Set.univ
hHD : ∀ (i : ι), ¬(H i).FiniteIndex → H i ≠ D
hdensity : ∑ i ∈ s, (↑(H i).index)⁻¹ = ↑(Finset.filter (fun x => K x = D) Finset.univ).card * (↑D.index)⁻¹
⊢ D.index ≤ (Finset.filter (fun x => K x = D) Finset.univ).card
|
6c7a447596ed19f6
|
Finset.prod_add_prod_le'
|
Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
|
/-- If `g, h ≤ f` and `g i + h i ≤ f i`, then the product of `f` over `s` is at least the
sum of the products of `g` and `h`. This is the version for `CanonicallyOrderedAdd`.
-/
lemma prod_add_prod_le' (hi : i ∈ s) (h2i : g i + h i ≤ f i) (hgf : ∀ j ∈ s, j ≠ i → g j ≤ f j)
(hhf : ∀ j ∈ s, j ≠ i → h j ≤ f j) : ((∏ i ∈ s, g i) + ∏ i ∈ s, h i) ≤ ∏ i ∈ s, f i
|
ι : Type u_1
R : Type u_2
inst✝² : CommSemiring R
inst✝¹ : PartialOrder R
inst✝ : CanonicallyOrderedAdd R
f g h : ι → R
s : Finset ι
i : ι
hi : i ∈ s
h2i : g i + h i ≤ f i
hgf : ∀ j ∈ s, j ≠ i → g j ≤ f j
hhf : ∀ j ∈ s, j ≠ i → h j ≤ f j
⊢ g i * ∏ i ∈ s \ {i}, g i + h i * ∏ i ∈ s \ {i}, h i ≤ g i * ∏ i ∈ s \ {i}, f i + h i * ∏ i ∈ s \ {i}, f i
|
gcongr with j hj j hj <;> simp_all
|
no goals
|
b1ae00d51a4733f1
|
EuclideanGeometry.mul_dist_le_mul_dist_add_mul_dist
|
Mathlib/Geometry/Euclidean/Inversion/Basic.lean
|
theorem mul_dist_le_mul_dist_add_mul_dist (a b c d : P) :
dist a c * dist b d ≤ dist a b * dist c d + dist b c * dist a d
|
case inr.inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d : P
hb : b ≠ a
hc : c ≠ a
⊢ dist a c * dist b d ≤ dist a b * dist c d + dist b c * dist a d
|
rcases eq_or_ne d a with (rfl | hd)
|
case inr.inr.inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
b c d : P
hb : b ≠ d
hc : c ≠ d
⊢ dist d c * dist b d ≤ dist d b * dist c d + dist b c * dist d d
case inr.inr.inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d : P
hb : b ≠ a
hc : c ≠ a
hd : d ≠ a
⊢ dist a c * dist b d ≤ dist a b * dist c d + dist b c * dist a d
|
d7abc1e0712fcb18
|
Batteries.TransCmp.compareOfLessAndEq
|
Mathlib/.lake/packages/batteries/Batteries/Classes/Order.lean
|
theorem TransCmp.compareOfLessAndEq
[LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) :
TransCmp (α := α) (compareOfLessAndEq · ·)
|
case isFalse.isTrue
α : Type u_1
inst✝² : LT α
inst✝¹ : DecidableRel LT.lt
inst✝ : DecidableEq α
lt_irrefl : ∀ (x : α), ¬x < x
lt_trans : ∀ {x y z : α}, x < y → y < z → x < z
lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y
x : α
h✝ : ¬x < x
⊢ Ordering.eq.swap = if x < x then Ordering.lt else if x = x then Ordering.eq else Ordering.gt
|
rw [if_neg ‹_›, if_pos rfl]
|
case isFalse.isTrue
α : Type u_1
inst✝² : LT α
inst✝¹ : DecidableRel LT.lt
inst✝ : DecidableEq α
lt_irrefl : ∀ (x : α), ¬x < x
lt_trans : ∀ {x y z : α}, x < y → y < z → x < z
lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y
x : α
h✝ : ¬x < x
⊢ Ordering.eq.swap = Ordering.eq
|
265051c307a250c5
|
Std.DHashMap.Raw.getD_insert
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/RawLemmas.lean
|
theorem getD_insert [LawfulBEq α] (h : m.WF) {k a : α} {fallback : β a} {v : β k} :
(m.insert k v).getD a fallback =
if h : k == a then cast (congrArg β (eq_of_beq h)) v else m.getD a fallback
|
α : Type u
β : α → Type v
m : Raw α β
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : LawfulBEq α
h : m.WF
k a : α
fallback : β a
v : β k
⊢ (m.insert k v).getD a fallback = if h : (k == a) = true then cast ⋯ v else m.getD a fallback
|
simp_to_raw using Raw₀.getD_insert
|
no goals
|
3fd9207edc078058
|
Set.uIcc_injective_right
|
Mathlib/Order/Interval/Set/UnorderedInterval.lean
|
lemma uIcc_injective_right (a : α) : Injective fun b => uIcc b a := fun b c h => by
rw [Set.ext_iff] at h
exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc)
|
α : Type u_1
inst✝ : DistribLattice α
a b c : α
h : (fun b => [[b, a]]) b = (fun b => [[b, a]]) c
⊢ b = c
|
rw [Set.ext_iff] at h
|
α : Type u_1
inst✝ : DistribLattice α
a b c : α
h : ∀ (x : α), x ∈ (fun b => [[b, a]]) b ↔ x ∈ (fun b => [[b, a]]) c
⊢ b = c
|
e3501e8407613320
|
Nat.testBit_bitwise
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
|
theorem testBit_bitwise (of_false_false : f false false = false) (x y i : Nat) :
(bitwise f x y).testBit i = f (x.testBit i) (y.testBit i)
|
f : Bool → Bool → Bool
of_false_false : f false false = false
i : Nat
hyp : ∀ (m : Nat), m < i → ∀ (x y : Nat), (bitwise f x y).testBit m = f (x.testBit m) (y.testBit m)
x y : Nat
x_zero : x = 0
⊢ (if x = 0 then if f false true = true then y else 0
else
if y = 0 then if f true false = true then x else 0
else
let n' := x / 2;
let m' := y / 2;
let b₁ := x % 2 = 1;
let b₂ := y % 2 = 1;
let r := bitwise f n' m';
if f (decide b₁) (decide b₂) = true then r + r + 1 else r + r).testBit
i =
f (x.testBit i) (y.testBit i)
|
cases p : f false true <;>
cases yi : testBit y i <;>
simp [x_zero, p, yi, of_false_false]
|
no goals
|
19fb8270ffef0c8a
|
ShrinkingLemma.PartialRefinement.exists_gt
|
Mathlib/Topology/ShrinkingLemma.lean
|
theorem exists_gt [NormalSpace X] (v : PartialRefinement u s ⊤) (hs : IsClosed s)
(i : ι) (hi : i ∉ v.carrier) :
∃ v' : PartialRefinement u s ⊤, v < v'
|
ι : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace X
u : ι → Set X
s : Set X
inst✝ : NormalSpace X
v : PartialRefinement u s ⊤
hs : IsClosed s
i : ι
hi : i ∉ v.carrier
⊢ s ∩ ⋂ j, ⋂ (_ : j ≠ i), (v.toFun j)ᶜ ⊆ v.toFun i
|
simp only [subset_def, mem_inter_iff, mem_iInter, and_imp]
|
ι : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace X
u : ι → Set X
s : Set X
inst✝ : NormalSpace X
v : PartialRefinement u s ⊤
hs : IsClosed s
i : ι
hi : i ∉ v.carrier
⊢ ∀ x ∈ s, (∀ (i_1 : ι), i_1 ≠ i → x ∈ (v.toFun i_1)ᶜ) → x ∈ v.toFun i
|
f07fb14ff2f0d64d
|
CompleteLattice.isCompactElement_iff_le_of_directed_sSup_le
|
Mathlib/Order/CompactlyGenerated/Basic.lean
|
theorem isCompactElement_iff_le_of_directed_sSup_le (k : α) :
IsCompactElement k ↔
∀ s : Set α, s.Nonempty → DirectedOn (· ≤ ·) s → k ≤ sSup s → ∃ x : α, x ∈ s ∧ k ≤ x
|
case h.left
α : Type u_2
inst✝ : CompleteLattice α
k : α
hk : ∀ (s : Set α), s.Nonempty → DirectedOn (fun x1 x2 => x1 ≤ x2) s → k ≤ sSup s → ∃ x ∈ s, k ≤ x
s : Set α
hsup : k ≤ sSup s
S : Set α := {x | ∃ t, ↑t ⊆ s ∧ x = t.sup id}
x : α
c : Finset α
hc : ↑c ⊆ s ∧ x = c.sup id
y : α
d : Finset α
hd : ↑d ⊆ s ∧ y = d.sup id
⊢ ↑(c ∪ d) ⊆ s
|
simp only [hc.left, hd.left, Set.union_subset_iff, Finset.coe_union, and_self_iff]
|
no goals
|
445bf3d7fb93c3e6
|
HasFPowerSeriesOnBall.tendstoUniformlyOn
|
Mathlib/Analysis/Analytic/Basic.lean
|
theorem HasFPowerSeriesOnBall.tendstoUniformlyOn {r' : ℝ≥0} (hf : HasFPowerSeriesOnBall f p x r)
(h : (r' : ℝ≥0∞) < r) :
TendstoUniformlyOn (fun n y => p.partialSum n y) (fun y => f (x + y)) atTop
(Metric.ball (0 : E) r')
|
𝕜 : 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
x : E
r : ℝ≥0∞
r' : ℝ≥0
hf : HasFPowerSeriesOnBall f p x r
h : ↑r' < r
⊢ TendstoUniformlyOn (fun n y => p.partialSum n y) (fun y => f (x + y)) atTop (Metric.ball 0 ↑r')
|
rw [← hasFPowerSeriesWithinOnBall_univ] at hf
|
𝕜 : 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
x : E
r : ℝ≥0∞
r' : ℝ≥0
hf : HasFPowerSeriesWithinOnBall f p univ x r
h : ↑r' < r
⊢ TendstoUniformlyOn (fun n y => p.partialSum n y) (fun y => f (x + y)) atTop (Metric.ball 0 ↑r')
|
903b769ac55d34fe
|
DFinsupp.lex_fibration
|
Mathlib/Data/DFinsupp/WellFounded.lean
|
theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
Fibration (InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd) (DFinsupp.Lex r s)
fun x => piecewise x.2.1 x.2.2 x.1
|
case neg
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
inst✝ : (i : ι) → (s : Set ι) → Decidable (i ∈ s)
p : Set ι
x₁ x₂ x : Π₀ (i : ι), α i
i : ι
hr : ∀ (j : ι), r j i → x j = if j ∈ p then x₁ j else x₂ j
hp : i ∉ p
hs : s i (x i) (x₂ i)
hi : ¬r i i
⊢ s i (x i) (x₂ i)
|
assumption
|
no goals
|
ce70f659976abe0e
|
MeasureTheory.MemLp.induction
|
Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
|
theorem MemLp.induction [_i : Fact (1 ≤ p)] (hp_ne_top : p ≠ ∞) (P : (α → E) → Prop)
(h_ind : ∀ (c : E) ⦃s⦄, MeasurableSet s → μ s < ∞ → P (s.indicator fun _ => c))
(h_add : ∀ ⦃f g : α → E⦄, Disjoint (support f) (support g) → MemLp f p μ → MemLp g p μ →
P f → P g → P (f + g))
(h_closed : IsClosed { f : Lp E p μ | P f })
(h_ae : ∀ ⦃f g⦄, f =ᵐ[μ] g → MemLp f p μ → P f → P g) :
∀ ⦃f : α → E⦄, MemLp f p μ → P f
|
case h.e'_1.h
α : Type u_1
E : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
μ : Measure α
_i : Fact (1 ≤ p)
hp_ne_top : p ≠ ⊤
P : (α → E) → Prop
h_ind : ∀ (c : E) ⦃s : Set α⦄, MeasurableSet s → μ s < ⊤ → P (s.indicator fun x => c)
h_add : ∀ ⦃f g : α → E⦄, Disjoint (support f) (support g) → MemLp f p μ → MemLp g p μ → P f → P g → P (f + g)
h_closed : IsClosed {f | P ↑↑f}
h_ae : ∀ ⦃f g : α → E⦄, f =ᶠ[ae μ] g → MemLp f p μ → P f → P g
s : Set α
hs : MeasurableSet s
h : MemLp (⇑(SimpleFunc.piecewise s hs (SimpleFunc.const α 0) (SimpleFunc.const α 0))) p μ
x✝ : α
⊢ (SimpleFunc.piecewise s hs (SimpleFunc.const α 0) (SimpleFunc.const α 0)) x✝ = ∅.indicator (fun x => 0) x✝
|
simp [const]
|
no goals
|
bf4a6fb28ab310ad
|
BumpCovering.exists_isSubordinate
|
Mathlib/Topology/PartitionOfUnity.lean
|
theorem exists_isSubordinate [NormalSpace X] [ParacompactSpace X] (hs : IsClosed s) (U : ι → Set X)
(ho : ∀ i, IsOpen (U i)) (hU : s ⊆ ⋃ i, U i) : ∃ f : BumpCovering ι X s, f.IsSubordinate U
|
case intro.intro.intro.intro
ι : Type u
X : Type v
inst✝² : TopologicalSpace X
s : Set X
inst✝¹ : NormalSpace X
inst✝ : ParacompactSpace X
hs : IsClosed s
U : ι → Set X
ho : ∀ (i : ι), IsOpen (U i)
hU : s ⊆ ⋃ i, U i
V : ι → Set X
hVo : ∀ (i : ι), IsOpen (V i)
hsV : s ⊆ ⋃ i, V i
hVf : LocallyFinite V
hVU : ∀ (i : ι), V i ⊆ U i
⊢ ∃ f, f.IsSubordinate U
|
rcases exists_isSubordinate_of_locallyFinite hs V hVo hVf hsV with ⟨f, hf⟩
|
case intro.intro.intro.intro.intro
ι : Type u
X : Type v
inst✝² : TopologicalSpace X
s : Set X
inst✝¹ : NormalSpace X
inst✝ : ParacompactSpace X
hs : IsClosed s
U : ι → Set X
ho : ∀ (i : ι), IsOpen (U i)
hU : s ⊆ ⋃ i, U i
V : ι → Set X
hVo : ∀ (i : ι), IsOpen (V i)
hsV : s ⊆ ⋃ i, V i
hVf : LocallyFinite V
hVU : ∀ (i : ι), V i ⊆ U i
f : BumpCovering ι X s
hf : f.IsSubordinate V
⊢ ∃ f, f.IsSubordinate U
|
2201cd5e2b224650
|
isPurelyInseparable_of_finSepDegree_eq_one
|
Mathlib/FieldTheory/PurelyInseparable/Basic.lean
|
theorem isPurelyInseparable_of_finSepDegree_eq_one
(hdeg : finSepDegree F E = 1) : IsPurelyInseparable F E
|
case pos
F : Type u
E : Type v
inst✝² : Field F
inst✝¹ : Field E
inst✝ : Algebra F E
hdeg : finSepDegree F E = 1
H : Algebra.IsAlgebraic F E
x : E
hsep : IsSeparable F x
this✝ : Algebra.IsAlgebraic (↥F⟮x⟯) E
this : F⟮x⟯ = ⊥ ∧ finSepDegree (↥F⟮x⟯) E = 1
⊢ x ∈ (algebraMap F E).range
|
simpa only [this.1] using mem_adjoin_simple_self F x
|
no goals
|
3a40061a1043c350
|
WfDvdMonoid.of_setOf_isPrincipal_wellFoundedOn_gt
|
Mathlib/RingTheory/UniqueFactorizationDomain/Ideal.lean
|
/-- The ascending chain condition on principal ideals in a domain is sufficient to prove that
the domain is `WfDvdMonoid`. -/
lemma WfDvdMonoid.of_setOf_isPrincipal_wellFoundedOn_gt [CommSemiring α] [IsDomain α]
(h : {I : Ideal α | I.IsPrincipal}.WellFoundedOn (· > ·)) :
WfDvdMonoid α
|
case wf
α : Type u_1
inst✝¹ : CommSemiring α
inst✝ : IsDomain α
h : {I | Submodule.IsPrincipal I}.WellFoundedOn fun x1 x2 => x1 > x2
this : WellFounded fun x1 x2 => x1 > x2
⊢ WellFounded DvdNotUnit
|
convert InvImage.wf (fun a => ⟨Ideal.span ({a} : Set α), _, rfl⟩) this
|
case h.e'_2
α : Type u_1
inst✝¹ : CommSemiring α
inst✝ : IsDomain α
h : {I | Submodule.IsPrincipal I}.WellFoundedOn fun x1 x2 => x1 > x2
this : WellFounded fun x1 x2 => x1 > x2
⊢ DvdNotUnit = InvImage (fun x1 x2 => x1 > x2) fun a => ⟨Ideal.span {a}, ⋯⟩
|
1d2e74032df7b812
|
UV.compress_idem
|
Mathlib/Combinatorics/SetFamily/Compression/UV.lean
|
theorem compress_idem (u v a : α) : compress u v (compress u v a) = compress u v a
|
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x1 x2 => x1 ≤ x2
u v a : α
⊢ compress u v (compress u v a) = compress u v a
|
unfold compress
|
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x1 x2 => x1 ≤ x2
u v a : α
⊢ (if
Disjoint u (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ∧
v ≤ if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a then
((if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ⊔ u) \ v
else if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) =
if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a
|
8839cd8a05af7046
|
IsNonarchimedean.finset_image_add_of_nonempty
|
Mathlib/Data/Real/IsNonarchimedean.lean
|
theorem finset_image_add_of_nonempty {F α β : Type*} [AddCommGroup α] [FunLike F α ℝ]
[AddGroupSeminormClass F α ℝ] [Nonempty β] {f : F} (hna : IsNonarchimedean f)
(g : β → α) {t : Finset β} (ht : t.Nonempty) :
∃ b : β, (b ∈ t) ∧ f (t.sum g) ≤ f (g b)
|
case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : AddCommGroup α
inst✝² : FunLike F α ℝ
inst✝¹ : AddGroupSeminormClass F α ℝ
inst✝ : Nonempty β
f : F
hna : IsNonarchimedean ⇑f
g : β → α
t : Finset β
ht : t.Nonempty
b : β
hbt : t.Nonempty → b ∈ t
hbf : f (t.sum g) ≤ f (g b)
⊢ ∃ b ∈ t, f (t.sum g) ≤ f (g b)
|
exact ⟨b, hbt ht, hbf⟩
|
no goals
|
c760e0a9e25a1e82
|
Set.Iio_subset_Iio_iff
|
Mathlib/Order/Interval/Set/Basic.lean
|
theorem Iio_subset_Iio_iff : Iio a ⊆ Iio b ↔ a ≤ b
|
α : Type u_1
inst✝ : LinearOrder α
a b : α
⊢ Iio a ⊆ Iio b ↔ a ≤ b
|
refine ⟨fun h => ?_, fun h => Iio_subset_Iio h⟩
|
α : Type u_1
inst✝ : LinearOrder α
a b : α
h : Iio a ⊆ Iio b
⊢ a ≤ b
|
3af4c0dba423e29b
|
Turing.PartrecToTM2.head_stack_ok
|
Mathlib/Computability/TMToPartrec.lean
|
theorem head_stack_ok {q s L₁ L₂ L₃} :
Reaches₁ (TM2.step tr)
⟨some (head stack q), s, K'.elim (trList L₁) [] [] (trList L₂ ++ Γ'.consₗ :: L₃)⟩
⟨some q, none, K'.elim (trList (L₂.headI :: L₁)) [] [] L₃⟩
|
case cons
q : Λ'
s : Option Γ'
L₁ : List ℕ
L₃ : List Γ'
a : ℕ
L₂ : List ℕ
⊢ Reaches₁ (TM2.step tr)
{ l := some (head stack q), var := s, stk := elim (trList L₁) [] [] (trList (a :: L₂) ++ Γ'.consₗ :: L₃) }
{ l := some q, var := none, stk := elim (trList ((a :: L₂).headI :: L₁)) [] [] L₃ }
|
refine
TransGen.trans
(move_ok (by decide)
(splitAtPred_eq _ _ (trNat a) (some Γ'.cons) (trList L₂ ++ Γ'.consₗ :: L₃)
(trNat_natEnd _) ⟨rfl, by simp⟩))
(TransGen.head rfl (TransGen.head rfl ?_))
|
case cons
q : Λ'
s : Option Γ'
L₁ : List ℕ
L₃ : List Γ'
a : ℕ
L₂ : List ℕ
⊢ TransGen (fun a b => b ∈ TM2.step tr a)
(TM2.stepAux
(tr
((fun x =>
Λ'.read fun s =>
(if s = some Γ'.consₗ then id else Λ'.clear (fun x => decide (x = Γ'.consₗ)) stack) (unrev q))
(some Γ'.cons)))
(some Γ'.cons)
(update
(update
(update (elim (trList L₁) [] [] (trList (a :: L₂) ++ Γ'.consₗ :: L₃)) stack (trList L₂ ++ Γ'.consₗ :: L₃)) rev
((trNat a).reverseAux (elim (trList L₁) [] [] (trList (a :: L₂) ++ Γ'.consₗ :: L₃) rev)))
rev
((fun s => ((fun x => some Γ'.cons) s).iget) (some Γ'.cons) ::
update
(update (elim (trList L₁) [] [] (trList (a :: L₂) ++ Γ'.consₗ :: L₃)) stack (trList L₂ ++ Γ'.consₗ :: L₃))
rev ((trNat a).reverseAux (elim (trList L₁) [] [] (trList (a :: L₂) ++ Γ'.consₗ :: L₃) rev)) rev)))
{ l := some q, var := none, stk := elim (trList ((a :: L₂).headI :: L₁)) [] [] L₃ }
|
5cadd8176b1827d5
|
TopCat.GlueData.ι_eq_iff_rel
|
Mathlib/Topology/Gluing.lean
|
theorem ι_eq_iff_rel (i j : D.J) (x : D.U i) (y : D.U j) :
𝖣.ι i x = 𝖣.ι j y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩
|
case mp
D : GlueData
i j : D.J
x : ↑(D.U i)
y : ↑(D.U j)
h :
(ConcreteCategory.hom (Sigma.ι D.diagram.right i ≫ Multicoequalizer.sigmaπ D.diagram)) x =
(ConcreteCategory.hom (Sigma.ι D.diagram.right j ≫ Multicoequalizer.sigmaπ D.diagram)) y
⊢ D.Rel (((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) ⟨i, x⟩) ⟨j, y⟩
|
rw [←
show _ = Sigma.mk j y from ConcreteCategory.congr_hom (sigmaIsoSigma.{_, u} D.U).inv_hom_id _]
|
case mp
D : GlueData
i j : D.J
x : ↑(D.U i)
y : ↑(D.U j)
h :
(ConcreteCategory.hom (Sigma.ι D.diagram.right i ≫ Multicoequalizer.sigmaπ D.diagram)) x =
(ConcreteCategory.hom (Sigma.ι D.diagram.right j ≫ Multicoequalizer.sigmaπ D.diagram)) y
⊢ D.Rel (((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) ⟨i, x⟩)
(((sigmaIsoSigma D.U).inv ≫ (sigmaIsoSigma D.U).hom) ⟨j, y⟩)
|
e0a110dda282edcf
|
Filter.HasBasis.sup'
|
Mathlib/Order/Filter/Bases.lean
|
theorem HasBasis.sup' (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
(l ⊔ l').HasBasis (fun i : PProd ι ι' => p i.1 ∧ p' i.2) fun i => s i.1 ∪ s' i.2 :=
⟨by
intro t
simp_rw [mem_sup, hl.mem_iff, hl'.mem_iff, PProd.exists, union_subset_iff,
← exists_and_right, ← exists_and_left]
simp only [and_assoc, and_left_comm]⟩
|
α : Type u_1
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
p' : ι' → Prop
s' : ι' → Set α
hl : l.HasBasis p s
hl' : l'.HasBasis p' s'
t : Set α
⊢ (∃ x x_1, (p x ∧ s x ⊆ t) ∧ p' x_1 ∧ s' x_1 ⊆ t) ↔ ∃ a b, (p a ∧ p' b) ∧ s a ⊆ t ∧ s' b ⊆ t
|
simp only [and_assoc, and_left_comm]
|
no goals
|
00fa2602b09511a8
|
Cardinal.mk_Ioi_real
|
Mathlib/Data/Real/Cardinality.lean
|
theorem mk_Ioi_real (a : ℝ) : #(Ioi a) = 𝔠
|
a : ℝ
h : #↑(Ioi a) < 𝔠
⊢ #↑Set.univ < 𝔠
|
have hu : Iio a ∪ {a} ∪ Ioi a = Set.univ := by
convert @Iic_union_Ioi ℝ _ _
exact Iio_union_right
|
a : ℝ
h : #↑(Ioi a) < 𝔠
hu : Iio a ∪ {a} ∪ Ioi a = Set.univ
⊢ #↑Set.univ < 𝔠
|
564ae2d1d94f837f
|
Std.DHashMap.Raw.getKey?_eq_some_getKey!
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/RawLemmas.lean
|
theorem getKey?_eq_some_getKey! [EquivBEq α] [LawfulHashable α] [Inhabited α] (h : m.WF) {a : α} :
a ∈ m → m.getKey? a = some (m.getKey! a)
|
α : Type u
β : α → Type v
m : Raw α β
inst✝⁴ : BEq α
inst✝³ : Hashable α
inst✝² : EquivBEq α
inst✝¹ : LawfulHashable α
inst✝ : Inhabited α
h : m.WF
a : α
⊢ a ∈ m → m.getKey? a = some (m.getKey! a)
|
simpa [mem_iff_contains] using getKey?_eq_some_getKey!_of_contains h
|
no goals
|
986b5940dcf7795b
|
Multiset.Icc_eq_zero_iff
|
Mathlib/Order/Interval/Multiset.lean
|
theorem Icc_eq_zero_iff : Icc a b = 0 ↔ ¬a ≤ b
|
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b : α
⊢ Icc a b = 0 ↔ ¬a ≤ b
|
rw [Icc, Finset.val_eq_zero, Finset.Icc_eq_empty_iff]
|
no goals
|
f7346d2b96938a0d
|
writtenInExtChartAt_comp
|
Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
|
theorem writtenInExtChartAt_comp (h : ContinuousWithinAt f s x) :
{y | writtenInExtChartAt I I'' x (g ∘ f) y =
(writtenInExtChartAt I' I'' (f x) g ∘ writtenInExtChartAt I I' x f) y} ∈
𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] (extChartAt I x) x
|
𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedSpace 𝕜 E
H : Type u_3
inst✝¹² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹¹ : TopologicalSpace M
inst✝¹⁰ : ChartedSpace H M
E' : Type u_5
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝⁷ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : ChartedSpace H' M'
E'' : Type u_8
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : NormedSpace 𝕜 E''
H'' : Type u_9
inst✝² : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
M'' : Type u_10
inst✝¹ : TopologicalSpace M''
inst✝ : ChartedSpace H'' M''
f : M → M'
x : M
s : Set M
g : M' → M''
h : ContinuousWithinAt f s x
⊢ {y | writtenInExtChartAt I I'' x (g ∘ f) y = (writtenInExtChartAt I' I'' (f x) g ∘ writtenInExtChartAt I I' x f) y} ∈
𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ range ↑I] ↑(extChartAt I x) x
|
apply
@Filter.mem_of_superset _ _ (f ∘ (extChartAt I x).symm ⁻¹' (extChartAt I' (f x)).source) _
(extChartAt_preimage_mem_nhdsWithin
(h.preimage_mem_nhdsWithin (extChartAt_source_mem_nhds _)))
|
𝕜 : 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'
E'' : Type u_8
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : NormedSpace 𝕜 E''
H'' : Type u_9
inst✝² : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
M'' : Type u_10
inst✝¹ : TopologicalSpace M''
inst✝ : ChartedSpace H'' M''
f : M → M'
x : M
s : Set M
g : M' → M''
h : ContinuousWithinAt f s x
⊢ f ∘ ↑(extChartAt I x).symm ⁻¹' (extChartAt I' (f x)).source ⊆
{y | writtenInExtChartAt I I'' x (g ∘ f) y = (writtenInExtChartAt I' I'' (f x) g ∘ writtenInExtChartAt I I' x f) y}
|
4e42d7572fbdc0d2
|
List.replace_eq_replaceTR
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
|
theorem replace_eq_replaceTR : @List.replace = @replaceTR
|
⊢ @replace = @replaceTR
|
funext α _ l b c
|
case h.h.h.h.h
α : Type u_1
x✝ : BEq α
l : List α
b c : α
⊢ l.replace b c = l.replaceTR b c
|
a82f1469e1b7fcc8
|
BddAbove.continuous_convolution_right_of_integrable
|
Mathlib/Analysis/Convolution.lean
|
theorem _root_.BddAbove.continuous_convolution_right_of_integrable
[FirstCountableTopology G] [SecondCountableTopologyEither G E']
(hbg : BddAbove (range fun x => ‖g x‖)) (hf : Integrable f μ) (hg : Continuous g) :
Continuous (f ⋆[L, μ] g)
|
case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
F : Type uF
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedAddCommGroup E'
inst✝¹² : NormedAddCommGroup F
f : G → E
g : 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✝¹ : FirstCountableTopology G
inst✝ : SecondCountableTopologyEither G E'
hbg : BddAbove (range fun x => ‖g x‖)
hf : Integrable f μ
hg : Continuous g
x₀ x : G
⊢ ∀ᵐ (t : G) ∂μ, ‖(L (f t)) (g (x - t))‖ ≤ ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖
|
filter_upwards with t
|
case h.h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
F : Type uF
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedAddCommGroup E'
inst✝¹² : NormedAddCommGroup F
f : G → E
g : 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✝¹ : FirstCountableTopology G
inst✝ : SecondCountableTopologyEither G E'
hbg : BddAbove (range fun x => ‖g x‖)
hf : Integrable f μ
hg : Continuous g
x₀ x t : G
⊢ ‖(L (f t)) (g (x - t))‖ ≤ ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖
|
7cef45832d5d6aeb
|
SetTheory.PGame.numeric_def
|
Mathlib/SetTheory/Surreal/Basic.lean
|
theorem numeric_def {x : PGame} :
Numeric x ↔
(∀ i j, x.moveLeft i < x.moveRight j) ∧
(∀ i, Numeric (x.moveLeft i)) ∧ ∀ j, Numeric (x.moveRight j)
|
case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝).Numeric ↔
(∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves) (j : (mk α✝ β✝ a✝¹ a✝).RightMoves),
(mk α✝ β✝ a✝¹ a✝).moveLeft i < (mk α✝ β✝ a✝¹ a✝).moveRight j) ∧
(∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves), ((mk α✝ β✝ a✝¹ a✝).moveLeft i).Numeric) ∧
∀ (j : (mk α✝ β✝ a✝¹ a✝).RightMoves), ((mk α✝ β✝ a✝¹ a✝).moveRight j).Numeric
|
rfl
|
no goals
|
d26425902c048a37
|
ProbabilityTheory.IndepFun.integral_mul_of_integrable
|
Mathlib/Probability/Integration.lean
|
theorem IndepFun.integral_mul_of_integrable (hXY : IndepFun X Y μ) (hX : Integrable X μ)
(hY : Integrable Y μ) : integral μ (X * Y) = integral μ X * integral μ Y
|
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : Integrable X μ
hY : Integrable Y μ
pos : ℝ → ℝ := fun x => x ⊔ 0
neg : ℝ → ℝ := fun x => -x ⊔ 0
posm : Measurable pos
negm : Measurable neg
Xp : Ω → ℝ := pos ∘ X
Xm : Ω → ℝ := neg ∘ X
Yp : Ω → ℝ := pos ∘ Y
Ym : Ω → ℝ := neg ∘ Y
hXpm : X = Xp - Xm
hYpm : Y = Yp - Ym
hp1 : 0 ≤ Xm
hp2 : 0 ≤ Xp
hp3 : 0 ≤ Ym
hp4 : 0 ≤ Yp
hm1 : AEMeasurable Xm μ
hm2 : AEMeasurable Xp μ
⊢ integral μ (X * Y) = integral μ X * integral μ Y
|
have hm3 : AEMeasurable Ym μ := hY.1.aemeasurable.neg.max aemeasurable_const
|
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : Integrable X μ
hY : Integrable Y μ
pos : ℝ → ℝ := fun x => x ⊔ 0
neg : ℝ → ℝ := fun x => -x ⊔ 0
posm : Measurable pos
negm : Measurable neg
Xp : Ω → ℝ := pos ∘ X
Xm : Ω → ℝ := neg ∘ X
Yp : Ω → ℝ := pos ∘ Y
Ym : Ω → ℝ := neg ∘ Y
hXpm : X = Xp - Xm
hYpm : Y = Yp - Ym
hp1 : 0 ≤ Xm
hp2 : 0 ≤ Xp
hp3 : 0 ≤ Ym
hp4 : 0 ≤ Yp
hm1 : AEMeasurable Xm μ
hm2 : AEMeasurable Xp μ
hm3 : AEMeasurable Ym μ
⊢ integral μ (X * Y) = integral μ X * integral μ Y
|
1836e7e522e593a2
|
Finsupp.single_of_single_apply
|
Mathlib/Data/Finsupp/Single.lean
|
theorem single_of_single_apply (a a' : α) (b : M) :
single a ((single a' b) a) = single a' (single a' b) a
|
case neg
α : Type u_1
M : Type u_5
inst✝ : Zero M
a a' : α
b : M
a✝ : α
h : ¬a' = a
⊢ (single a 0) a✝ = 0 a✝
|
rw [zero_apply, single_apply, ite_self]
|
no goals
|
33af47e1a4958c4f
|
Nat.Primrec'.sqrt
|
Mathlib/Computability/Primrec.lean
|
theorem sqrt : @Primrec' 1 fun v => v.head.sqrt
|
H : ∀ (n : ℕ), n.sqrt = Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n
v : List.Vector ℕ (1 + 2)
x : ℕ
⊢ ℕ
|
have y := v.tail.head
|
H : ∀ (n : ℕ), n.sqrt = Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n
v : List.Vector ℕ (1 + 2)
x y : ℕ
⊢ ℕ
|
99d6f1beec25882a
|
CategoryTheory.finrank_hom_simple_simple_eq_zero_iff
|
Mathlib/CategoryTheory/Preadditive/Schur.lean
|
theorem finrank_hom_simple_simple_eq_zero_iff (X Y : C) [FiniteDimensional 𝕜 (X ⟶ X)]
[FiniteDimensional 𝕜 (X ⟶ Y)] [Simple X] [Simple Y] :
finrank 𝕜 (X ⟶ Y) = 0 ↔ IsEmpty (X ≅ Y)
|
C : Type u_1
inst✝⁹ : Category.{u_3, u_1} C
inst✝⁸ : Preadditive C
𝕜 : Type u_2
inst✝⁷ : Field 𝕜
inst✝⁶ : IsAlgClosed 𝕜
inst✝⁵ : Linear 𝕜 C
inst✝⁴ : HasKernels C
X Y : C
inst✝³ : FiniteDimensional 𝕜 (X ⟶ X)
inst✝² : FiniteDimensional 𝕜 (X ⟶ Y)
inst✝¹ : Simple X
inst✝ : Simple Y
⊢ finrank 𝕜 (X ⟶ Y) = 0 ↔ IsEmpty (X ≅ Y)
|
rw [← not_nonempty_iff, ← not_congr (finrank_hom_simple_simple_eq_one_iff 𝕜 X Y)]
|
C : Type u_1
inst✝⁹ : Category.{u_3, u_1} C
inst✝⁸ : Preadditive C
𝕜 : Type u_2
inst✝⁷ : Field 𝕜
inst✝⁶ : IsAlgClosed 𝕜
inst✝⁵ : Linear 𝕜 C
inst✝⁴ : HasKernels C
X Y : C
inst✝³ : FiniteDimensional 𝕜 (X ⟶ X)
inst✝² : FiniteDimensional 𝕜 (X ⟶ Y)
inst✝¹ : Simple X
inst✝ : Simple Y
⊢ finrank 𝕜 (X ⟶ Y) = 0 ↔ ¬finrank 𝕜 (X ⟶ Y) = 1
|
36d01ca65cae1c3e
|
Besicovitch.exist_disjoint_covering_families
|
Mathlib/MeasureTheory/Covering/Besicovitch.lean
|
theorem exist_disjoint_covering_families {N : ℕ} {τ : ℝ} (hτ : 1 < τ)
(hN : IsEmpty (SatelliteConfig α N τ)) (q : BallPackage β α) :
∃ s : Fin N → Set β,
(∀ i : Fin N, (s i).PairwiseDisjoint fun j => closedBall (q.c j) (q.r j)) ∧
range q.c ⊆ ⋃ i : Fin N, ⋃ j ∈ s i, ball (q.c j) (q.r j)
|
case hs
α : Type u_1
inst✝ : MetricSpace α
β : Type u
N : ℕ
τ : ℝ
hτ : 1 < τ
hN : IsEmpty (SatelliteConfig α N τ)
q : BallPackage β α
h✝ : Nonempty β
p : TauPackage β α := { toBallPackage := q, τ := τ, one_lt_tau := hτ }
s : Fin N → Set β := fun i => ⋃ k, ⋃ (_ : k < p.lastStep), ⋃ (_ : p.color k = ↑i), {p.index k}
i : Fin N
jx : Ordinal.{u}
jx_lt : jx < p.lastStep
jxi : p.color jx = ↑i
hx : p.index jx ∈ s i
jy : Ordinal.{u}
jy_lt : jy < p.lastStep
jyi : p.color jy = ↑i
hy : p.index jy ∈ s i
x_ne_y : p.index jx ≠ p.index jy
jxy : jx < jy
A : Set ℕ :=
⋃ j,
⋃ (_ :
(closedBall (p.c (p.index ↑j)) (p.r (p.index ↑j)) ∩ closedBall (p.c (p.index jy)) (p.r (p.index jy))).Nonempty),
{p.color ↑j}
color_j : p.color jy = sInf (univ \ A)
k : Ordinal.{u}
hk : k < jy
a✝ : (closedBall (p.c (p.index k)) (p.r (p.index k)) ∩ closedBall (p.c (p.index jy)) (p.r (p.index jy))).Nonempty
⊢ ¬N = p.color k
|
exact (p.color_lt (hk.trans jy_lt) hN).ne'
|
no goals
|
416e48a035cdf3d5
|
MulAction.smul_bijective_of_is_unit
|
Mathlib/GroupTheory/GroupAction/Pointwise.lean
|
theorem MulAction.smul_bijective_of_is_unit
{M : Type*} [Monoid M] {α : Type*} [MulAction M α] {m : M} (hm : IsUnit m) :
Function.Bijective (fun (a : α) ↦ m • a)
|
case h.left
M : Type u_1
inst✝¹ : Monoid M
α : Type u_2
inst✝ : MulAction M α
m : Mˣ
x : α
⊢ (fun a => m⁻¹ • a) ((fun a => ↑m • a) x) = x
|
simp [← Units.smul_def]
|
no goals
|
91b4009f7a529152
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.