name
stringlengths 3
112
| file
stringlengths 21
116
| statement
stringlengths 17
8.64k
| state
stringlengths 7
205k
| tactic
stringlengths 3
4.55k
| result
stringlengths 7
205k
| id
stringlengths 16
16
|
|---|---|---|---|---|---|---|
LinearMap.exists_map_addHaar_eq_smul_addHaar'
|
Mathlib/MeasureTheory/Measure/Haar/Disintegration.lean
|
theorem LinearMap.exists_map_addHaar_eq_smul_addHaar' (h : Function.Surjective L) :
∃ (c : ℝ≥0∞), 0 < c ∧ c < ∞ ∧ μ.map L = (c * addHaar (univ : Set (LinearMap.ker L))) • ν
|
case h.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : CompleteSpace 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : MeasurableSpace E
inst✝⁸ : BorelSpace E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : MeasurableSpace F
inst✝⁴ : BorelSpace F
inst✝³ : NormedSpace 𝕜 F
L : E →ₗ[𝕜] F
μ : Measure E
ν : Measure F
inst✝² : μ.IsAddHaarMeasure
inst✝¹ : ν.IsAddHaarMeasure
inst✝ : LocallyCompactSpace E
h : Function.Surjective ⇑L
this✝¹ : FiniteDimensional 𝕜 E
this✝ : ProperSpace F
S : Submodule 𝕜 E := ker L
T : Submodule 𝕜 E
hT : IsCompl S T
M : (↥S × ↥T) ≃ₗ[𝕜] E := S.prodEquivOfIsCompl T hT
M_cont : Continuous ⇑M.symm
P : ↥S × ↥T →ₗ[𝕜] ↥T := snd 𝕜 ↥S ↥T
P_cont : Continuous ⇑P
I : Function.Bijective ⇑(L.domRestrict T)
L' : ↥T ≃ₗ[𝕜] F := LinearEquiv.ofBijective (L.domRestrict T) I
L'_cont : Continuous ⇑L'
x : E
y : ↥S
z : ↥T
hyz : M.symm x = (y, z)
this : x = M (y, z)
⊢ L x = (↑L' ∘ₗ P ∘ₗ ↑M.symm) x
|
simp [L', P, M, this]
|
no goals
|
2e191355893f8fd9
|
AlgebraicGeometry.HasRingHomProperty.respects_isOpenImmersion_aux
|
Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
|
private lemma respects_isOpenImmersion_aux
(hQ : RingHom.StableUnderCompositionWithLocalizationAwaySource Q)
{X Y : Scheme.{u}} [IsAffine Y] {U : Y.Opens}
(f : X ⟶ U.toScheme) (hf : P f) : P (f ≫ U.ι)
|
case inr.intro.intro
P : MorphismProperty Scheme
Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
inst✝¹ : HasRingHomProperty P Q
hQ : RingHom.StableUnderCompositionWithLocalizationAwaySource fun {R S} [CommRing R] [CommRing S] => Q
X Y : Scheme
inst✝ : IsAffine Y
U : Y.Opens
f : X ⟶ ↑U
hf : P f
this : ∀ {X Y : Scheme} [inst : IsAffine Y] {U : Y.Opens} (f : X ⟶ ↑U), P f → (∃ a, U = Y.basicOpen a) → P (f ≫ U.ι)
hYa : ¬∃ a, U = Y.basicOpen a
Us : Set Y.Opens
hUs : Us ⊆ Set.range Y.basicOpen
heq : U = sSup Us
V : ↑Us → X.Opens := fun s => f ⁻¹ᵁ U.ι ⁻¹ᵁ ↑s
s : ↑Us
f' : ↑(V s) ⟶ ↑(U.ι ⁻¹ᵁ ↑s) := f ∣_ U.ι ⁻¹ᵁ ↑s
⊢ P ((V s).ι ≫ f ≫ U.ι)
|
have hf' : P f' := IsLocalAtTarget.restrict hf _
|
case inr.intro.intro
P : MorphismProperty Scheme
Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
inst✝¹ : HasRingHomProperty P Q
hQ : RingHom.StableUnderCompositionWithLocalizationAwaySource fun {R S} [CommRing R] [CommRing S] => Q
X Y : Scheme
inst✝ : IsAffine Y
U : Y.Opens
f : X ⟶ ↑U
hf : P f
this : ∀ {X Y : Scheme} [inst : IsAffine Y] {U : Y.Opens} (f : X ⟶ ↑U), P f → (∃ a, U = Y.basicOpen a) → P (f ≫ U.ι)
hYa : ¬∃ a, U = Y.basicOpen a
Us : Set Y.Opens
hUs : Us ⊆ Set.range Y.basicOpen
heq : U = sSup Us
V : ↑Us → X.Opens := fun s => f ⁻¹ᵁ U.ι ⁻¹ᵁ ↑s
s : ↑Us
f' : ↑(V s) ⟶ ↑(U.ι ⁻¹ᵁ ↑s) := f ∣_ U.ι ⁻¹ᵁ ↑s
hf' : P f'
⊢ P ((V s).ι ≫ f ≫ U.ι)
|
f1fbd724d831d61a
|
StrictConcaveOn.secant_strict_mono
|
Mathlib/Analysis/Convex/Slope.lean
|
theorem StrictConcaveOn.secant_strict_mono (hf : StrictConcaveOn 𝕜 s f) {a x y : 𝕜} (ha : a ∈ s)
(hx : x ∈ s) (hy : y ∈ s) (hxa : x ≠ a) (hya : y ≠ a) (hxy : x < y) :
(f y - f a) / (y - a) < (f x - f a) / (x - a)
|
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa : x ≠ a
hya : y ≠ a
hxy : x < y
key : (-f x - -f a) / (x - a) < (-f y - -f a) / (y - a)
⊢ (f y - f a) / (y - a) < (f x - f a) / (x - a)
|
rw [← neg_lt_neg_iff]
|
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa : x ≠ a
hya : y ≠ a
hxy : x < y
key : (-f x - -f a) / (x - a) < (-f y - -f a) / (y - a)
⊢ -((f x - f a) / (x - a)) < -((f y - f a) / (y - a))
|
d3eea5b66cf73cfe
|
DHashMap.Const.mem_ofList
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Lemmas.lean
|
theorem mem_ofList [EquivBEq α] [LawfulHashable α]
{l : List (α × β)} {k : α} :
k ∈ ofList l ↔ (l.map Prod.fst).contains k
|
α : Type u
x✝¹ : BEq α
x✝ : Hashable α
β : Type v
inst✝¹ : EquivBEq α
inst✝ : LawfulHashable α
l : List (α × β)
k : α
⊢ k ∈ ofList l ↔ (List.map Prod.fst l).contains k = true
|
simp [mem_iff_contains]
|
no goals
|
a99c067319c7e19f
|
WeierstrassCurve.Jacobian.nonsingular_of_Z_eq_zero
|
Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
|
lemma nonsingular_of_Z_eq_zero {P : Fin 3 → R} (hPz : P z = 0) :
W'.Nonsingular P ↔ W'.Equation P ∧ (3 * P x ^ 2 ≠ 0 ∨ 2 * P y ≠ 0 ∨ W'.a₁ * P x * P y ≠ 0)
|
R : Type r
inst✝ : CommRing R
W' : Jacobian R
P : Fin 3 → R
hPz : P z = 0
⊢ W'.Nonsingular P ↔ W'.Equation P ∧ (3 * P x ^ 2 ≠ 0 ∨ 2 * P y ≠ 0 ∨ W'.a₁ * P x * P y ≠ 0)
|
simp only [nonsingular_iff, hPz, add_zero, sub_zero, zero_sub, mul_zero,
zero_pow <| OfNat.ofNat_ne_zero _, neg_ne_zero]
|
no goals
|
0963b0b75228a6ee
|
Nat.ne_of_odd_add
|
Mathlib/Algebra/Ring/Parity.lean
|
lemma ne_of_odd_add (h : Odd (m + n)) : m ≠ n
|
m n : ℕ
h : Odd (m + n)
⊢ m ≠ n
|
rintro rfl
|
m : ℕ
h : Odd (m + m)
⊢ False
|
bc529a2f632ddc82
|
LinearMap.range_domRestrict_eq_range_iff
|
Mathlib/LinearAlgebra/Span/Basic.lean
|
lemma _root_.LinearMap.range_domRestrict_eq_range_iff {f : M →ₛₗ[τ₁₂] M₂} {S : Submodule R M} :
LinearMap.range (f.domRestrict S) = LinearMap.range f ↔ S ⊔ (LinearMap.ker f) = ⊤
|
case refine_2.intro.intro.intro.intro.intro
R : Type u_1
R₂ : Type u_2
M : Type u_4
M₂ : Type u_5
inst✝⁶ : Semiring R
inst✝⁵ : Semiring R₂
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
S : Submodule R M
h : S ⊔ LinearMap.ker f = ⊤
s : M
hs : s ∈ S
t : M
ht : t ∈ LinearMap.ker f
⊢ f (s + t) ∈ LinearMap.range (f.domRestrict S)
|
exact ⟨⟨s, hs⟩, by simp [LinearMap.mem_ker.1 ht]⟩
|
no goals
|
38f16d98af2b2b11
|
PFunctor.M.cases_mk
|
Mathlib/Data/PFunctor/Univariate/M.lean
|
theorem cases_mk {r : M F → Sort*} (x : F (M F)) (f : ∀ x : F (M F), r (M.mk x)) :
PFunctor.M.cases f (M.mk x) = f x
|
case mk
F : PFunctor.{u}
r : F.M → Sort u_2
f : (x : ↑F F.M) → r (M.mk x)
fst✝ : F.A
snd✝ : F.B fst✝ → F.M
⊢ ⋯.mpr
(f
⟨match 0, CofixA.intro ⟨fst✝, snd✝⟩.fst fun i => (⟨fst✝, snd✝⟩.snd i).approx 0 with
| x, CofixA.intro i a => i,
fun i => children { approx := Approx.sMk ⟨fst✝, snd✝⟩, consistent := ⋯ } i⟩) =
f ⟨fst✝, snd✝⟩
|
dsimp only [Approx.sMk]
|
case mk
F : PFunctor.{u}
r : F.M → Sort u_2
f : (x : ↑F F.M) → r (M.mk x)
fst✝ : F.A
snd✝ : F.B fst✝ → F.M
⊢ ⋯.mpr
(f
⟨match 0, CofixA.intro fst✝ fun i => (snd✝ i).approx 0 with
| x, CofixA.intro i a => i,
fun i => children { approx := Approx.sMk ⟨fst✝, snd✝⟩, consistent := ⋯ } i⟩) =
f ⟨fst✝, snd✝⟩
|
5e467c87f2c13f11
|
Fin.cons_self_tail
|
Mathlib/Data/Fin/Tuple/Basic.lean
|
theorem cons_self_tail : cons (q 0) (tail q) = q
|
case neg
n : ℕ
α : Fin (n + 1) → Sort u
q : (i : Fin (n + 1)) → α i
j : Fin (n + 1)
h : ¬j = 0
j' : Fin n := j.pred h
this : j'.succ = j
⊢ cons (q 0) (tail q) j = q j
|
rw [← this]
|
case neg
n : ℕ
α : Fin (n + 1) → Sort u
q : (i : Fin (n + 1)) → α i
j : Fin (n + 1)
h : ¬j = 0
j' : Fin n := j.pred h
this : j'.succ = j
⊢ cons (q 0) (tail q) j'.succ = q j'.succ
|
499bb3ffe4d716dd
|
IsLeftRegular.of_mul
|
Mathlib/Algebra/Regular/Basic.lean
|
theorem IsLeftRegular.of_mul (ab : IsLeftRegular (a * b)) : IsLeftRegular b :=
Function.Injective.of_comp (f := (a * ·)) (by rwa [comp_mul_left a b])
|
R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsLeftRegular (a * b)
⊢ Function.Injective ((fun x => a * x) ∘ fun x => b * x)
|
rwa [comp_mul_left a b]
|
no goals
|
29e15757cfb05cb9
|
MeasurableEmbedding.gaussianReal_comap_apply
|
Mathlib/Probability/Distributions/Gaussian.lean
|
lemma _root_.MeasurableEmbedding.gaussianReal_comap_apply (hv : v ≠ 0)
{f : ℝ → ℝ} (hf : MeasurableEmbedding f)
{f' : ℝ → ℝ} (h_deriv : ∀ x, HasDerivAt f (f' x) x) {s : Set ℝ} (hs : MeasurableSet s) :
(gaussianReal μ v).comap f s
= ENNReal.ofReal (∫ x in s, |f' x| * gaussianPDFReal μ v (f x))
|
μ : ℝ
v : ℝ≥0
hv : v ≠ 0
f : ℝ → ℝ
hf : MeasurableEmbedding f
f' : ℝ → ℝ
h_deriv : ∀ (x : ℝ), HasDerivAt f (f' x) x
s : Set ℝ
hs : MeasurableSet s
⊢ (Measure.comap f (ℙ.withDensity fun x => ENNReal.ofReal (gaussianPDFReal μ v x))) s =
ENNReal.ofReal (∫ (x : ℝ) in s, |f' x| * gaussianPDFReal μ v (f x))
|
exact hf.withDensity_ofReal_comap_apply_eq_integral_abs_deriv_mul' hs h_deriv
(ae_of_all _ (gaussianPDFReal_nonneg _ _)) (integrable_gaussianPDFReal _ _)
|
no goals
|
c7d2383920c0b30f
|
MeasureTheory.absolutelyContinuous_map_div_left
|
Mathlib/MeasureTheory/Group/Prod.lean
|
theorem absolutelyContinuous_map_div_left (g : G) : μ ≪ map (fun h => g / h) μ
|
G : Type u_1
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Group G
inst✝³ : MeasurableMul₂ G
μ : Measure G
inst✝² : SFinite μ
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun h => g / h) μ
|
simp_rw [div_eq_mul_inv]
|
G : Type u_1
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Group G
inst✝³ : MeasurableMul₂ G
μ : Measure G
inst✝² : SFinite μ
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun h => g * h⁻¹) μ
|
681bf9d559c28a3c
|
geom_sum_alternating_of_le_neg_one
|
Mathlib/Algebra/GeomSum.lean
|
theorem geom_sum_alternating_of_le_neg_one [StrictOrderedRing α] (hx : x + 1 ≤ 0) (n : ℕ) :
if Even n then (∑ i ∈ range n, x ^ i) ≤ 0 else 1 ≤ ∑ i ∈ range n, x ^ i
|
case zero
α : Type u
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
⊢ if Even 0 then ∑ i ∈ range 0, x ^ i ≤ 0 else 1 ≤ ∑ i ∈ range 0, x ^ i
|
simp only [range_zero, sum_empty, le_refl, ite_true, Even.zero]
|
no goals
|
5d60d8a56ed4872c
|
Matrix.transpose_tsum
|
Mathlib/Topology/Instances/Matrix.lean
|
theorem Matrix.transpose_tsum [T2Space R] {f : X → Matrix m n R} : (∑' x, f x)ᵀ = ∑' x, (f x)ᵀ
|
X : Type u_1
m : Type u_4
n : Type u_5
R : Type u_8
inst✝² : AddCommMonoid R
inst✝¹ : TopologicalSpace R
inst✝ : T2Space R
f : X → Matrix m n R
⊢ (∑' (x : X), f x)ᵀ = ∑' (x : X), (f x)ᵀ
|
by_cases hf : Summable f
|
case pos
X : Type u_1
m : Type u_4
n : Type u_5
R : Type u_8
inst✝² : AddCommMonoid R
inst✝¹ : TopologicalSpace R
inst✝ : T2Space R
f : X → Matrix m n R
hf : Summable f
⊢ (∑' (x : X), f x)ᵀ = ∑' (x : X), (f x)ᵀ
case neg
X : Type u_1
m : Type u_4
n : Type u_5
R : Type u_8
inst✝² : AddCommMonoid R
inst✝¹ : TopologicalSpace R
inst✝ : T2Space R
f : X → Matrix m n R
hf : ¬Summable f
⊢ (∑' (x : X), f x)ᵀ = ∑' (x : X), (f x)ᵀ
|
b68c92dc9e395cb3
|
VectorBundleCore.localTriv_continuousLinearMapAt
|
Mathlib/Topology/VectorBundle/Basic.lean
|
theorem localTriv_continuousLinearMapAt {b : B} (hb : b ∈ Z.baseSet i) :
(Z.localTriv i).continuousLinearMapAt R b = Z.coordChange (Z.indexAt b) i b
|
R : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField R
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace R F
inst✝ : TopologicalSpace B
ι : Type u_5
Z : VectorBundleCore R B F ι
i : ι
b : B
hb : b ∈ Z.baseSet i
⊢ Trivialization.continuousLinearMapAt R (Z.localTriv i) b = Z.coordChange (Z.indexAt b) i b
|
ext1 v
|
case h
R : Type u_1
B : Type u_2
F : Type u_3
inst✝³ : NontriviallyNormedField R
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace R F
inst✝ : TopologicalSpace B
ι : Type u_5
Z : VectorBundleCore R B F ι
i : ι
b : B
hb : b ∈ Z.baseSet i
v : Z.Fiber b
⊢ (Trivialization.continuousLinearMapAt R (Z.localTriv i) b) v = (Z.coordChange (Z.indexAt b) i b) v
|
da74b8dccd3854a7
|
Array.push_eq_append_iff
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem push_eq_append_iff {a b c : Array α} {x : α} :
c.push x = a ++ b ↔ (b = #[] ∧ a = c.push x) ∨ (∃ b', b = b'.push x ∧ c = a ++ b')
|
α : Type u_1
a b c : Array α
x : α
⊢ c.push x = a ++ b ↔ b = #[] ∧ a = c.push x ∨ ∃ b', b = b'.push x ∧ c = a ++ b'
|
rw [eq_comm, append_eq_push_iff]
|
no goals
|
6073837ea6c32a36
|
Finset.prod_add
|
Mathlib/Algebra/BigOperators/Ring/Finset.lean
|
theorem prod_add (f g : ι → α) (s : Finset ι) :
∏ i ∈ s, (f i + g i) = ∑ t ∈ s.powerset, (∏ i ∈ t, f i) * ∏ i ∈ s \ t, g i
|
ι : Type u_1
α : Type u_3
inst✝¹ : CommSemiring α
inst✝ : DecidableEq ι
f g : ι → α
s : Finset ι
⊢ ∏ i ∈ s, (f i + g i) = ∏ i ∈ s, ∑ p ∈ {True, False}, if p then f i else g i
|
simp
|
no goals
|
bfeb78d0575b25b6
|
LinearPMap.mem_domain_of_mem_graph
|
Mathlib/LinearAlgebra/LinearPMap.lean
|
theorem mem_domain_of_mem_graph {f : E →ₗ.[R] F} {x : E} {y : F} (h : (x, y) ∈ f.graph) :
x ∈ f.domain
|
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
y : F
h : (x, y) ∈ f.graph
⊢ x ∈ f.domain
|
rw [mem_domain_iff]
|
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
y : F
h : (x, y) ∈ f.graph
⊢ ∃ y, (x, y) ∈ f.graph
|
b2b352d494382d73
|
mem_normalizedFactors_factor_dvd_iso_of_mem_normalizedFactors
|
Mathlib/RingTheory/ChainOfDivisors.lean
|
theorem mem_normalizedFactors_factor_dvd_iso_of_mem_normalizedFactors {m p : M} {n : N} (hm : m ≠ 0)
(hn : n ≠ 0) (hp : p ∈ normalizedFactors m) {d : { l : M // l ∣ m } ≃ { l : N // l ∣ n }}
(hd : ∀ l l', (d l : N) ∣ d l' ↔ (l : M) ∣ (l' : M)) :
↑(d ⟨p, dvd_of_mem_normalizedFactors hp⟩) ∈ normalizedFactors n
|
M : Type u_1
inst✝⁵ : CancelCommMonoidWithZero M
N : Type u_2
inst✝⁴ : CancelCommMonoidWithZero N
inst✝³ : Subsingleton Mˣ
inst✝² : Subsingleton Nˣ
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : UniqueFactorizationMonoid N
m p : M
n : N
hm : m ≠ 0
hn : n ≠ 0
hp : p ∈ normalizedFactors m
d : { l // l ∣ m } ≃ { l // l ∣ n }
hd : ∀ (l l' : { l // l ∣ m }), ↑(d l) ∣ ↑(d l') ↔ ↑l ∣ ↑l'
this : Prime ↑(d ⟨associatesEquivOfUniqueUnits (associatesEquivOfUniqueUnits.symm p), ⋯⟩)
⊢ ↑(d ⟨p, ⋯⟩) ∈ normalizedFactors n
|
simp only [associatesEquivOfUniqueUnits_apply, out_mk, normalize_eq,
associatesEquivOfUniqueUnits_symm_apply] at this
|
M : Type u_1
inst✝⁵ : CancelCommMonoidWithZero M
N : Type u_2
inst✝⁴ : CancelCommMonoidWithZero N
inst✝³ : Subsingleton Mˣ
inst✝² : Subsingleton Nˣ
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : UniqueFactorizationMonoid N
m p : M
n : N
hm : m ≠ 0
hn : n ≠ 0
hp : p ∈ normalizedFactors m
d : { l // l ∣ m } ≃ { l // l ∣ n }
hd : ∀ (l l' : { l // l ∣ m }), ↑(d l) ∣ ↑(d l') ↔ ↑l ∣ ↑l'
this : Prime ↑(d ⟨p, ⋯⟩)
⊢ ↑(d ⟨p, ⋯⟩) ∈ normalizedFactors n
|
f1fd55130dfcc672
|
Nat.Prime.dvd_add_pow_sub_pow_of_dvd
|
Mathlib/Algebra/CharP/Lemmas.lean
|
lemma Nat.Prime.dvd_add_pow_sub_pow_of_dvd (hpri : p.Prime) {r : R} (h₁ : r ∣ x ^ p)
(h₂ : r ∣ p * x) : r ∣ (x + y) ^ p - y ^ p
|
R : Type u_1
inst✝ : CommRing R
x y : R
p : ℕ
hpri : Prime p
r : R
h₁ : r ∣ x ^ p
h₂ : r ∣ ↑p * x
⊢ r ∣ (x + y) ^ p - y ^ p
|
rw [add_pow_prime_eq hpri, add_right_comm, add_assoc, add_sub_assoc, add_sub_cancel_right]
|
R : Type u_1
inst✝ : CommRing R
x y : R
p : ℕ
hpri : Prime p
r : R
h₁ : r ∣ x ^ p
h₂ : r ∣ ↑p * x
⊢ r ∣ x ^ p + ↑p * ∑ k ∈ Ioo 0 p, x ^ k * y ^ (p - k) * ↑(p.choose k / p)
|
9e6d5d4472727e74
|
SimpleGraph.Walk.edges_map
|
Mathlib/Combinatorics/SimpleGraph/Walk.lean
|
theorem edges_map : (p.map f).edges = p.edges.map (Sym2.map f)
|
case nil
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
f : G →g G'
u v : V
p : G.Walk u v
u✝ : V
⊢ (Walk.map f nil).edges = List.map (Sym2.map ⇑f) nil.edges
|
rfl
|
no goals
|
5eda5b5d896aec59
|
CategoryTheory.Limits.prod.map_comp_id
|
Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
|
theorem prod.map_comp_id {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasBinaryProduct X W]
[HasBinaryProduct Z W] [HasBinaryProduct Y W] :
prod.map (f ≫ g) (𝟙 W) = prod.map f (𝟙 W) ≫ prod.map g (𝟙 W)
|
C : Type u
inst✝³ : Category.{v, u} C
X Y Z W : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝² : HasBinaryProduct X W
inst✝¹ : HasBinaryProduct Z W
inst✝ : HasBinaryProduct Y W
⊢ map (f ≫ g) (𝟙 W) = map f (𝟙 W) ≫ map g (𝟙 W)
|
simp
|
no goals
|
a3c93faff1cc3605
|
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.image_preimage_is_empty
|
Mathlib/Geometry/RingedSpace/OpenImmersion.lean
|
theorem image_preimage_is_empty (j : Discrete ι) (h : i ≠ j) (U : Opens (F.obj i)) :
(Opens.map (colimit.ι (F ⋙ SheafedSpace.forgetToPresheafedSpace) j).base).obj
((Opens.map (preservesColimitIso SheafedSpace.forgetToPresheafedSpace F).inv.base).obj
((sigma_ι_isOpenEmbedding F i).isOpenMap.functor.obj U)) =
⊥
|
case h.h.h.intro.intro.mk.mk
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
ι : Type v
F : Discrete ι ⥤ SheafedSpace C
inst✝ : HasColimit F
as✝¹ : ι
U : Opens ↑↑(F.obj { as := as✝¹ }).toPresheafedSpace
y : ↑↑(F.obj { as := as✝¹ }).toPresheafedSpace
hy : y ∈ ↑U
as✝ : ι
x : ↑↑((F ⋙ forgetToPresheafedSpace).obj { as := as✝ })
h : { as := as✝¹ } ≠ { as := as✝ }
eq :
(ConcreteCategory.hom
(Discrete.natIsoFunctor.hom.app { as := as✝¹ } ≫ TopCat.sigmaι ((F ⋙ forget C).obj ∘ Discrete.mk) as✝¹))
y =
(ConcreteCategory.hom
(Discrete.natIsoFunctor.hom.app { as := as✝ } ≫ TopCat.sigmaι ((F ⋙ forget C).obj ∘ Discrete.mk) as✝))
x
⊢ False
|
exact h (congr_arg Discrete.mk (congr_arg Sigma.fst eq))
|
no goals
|
cf02ecb43481a17c
|
MeasureTheory.pdf.IsUniform.pdf_eq_zero_of_measure_eq_zero_or_top
|
Mathlib/Probability/Distributions/Uniform.lean
|
theorem pdf_eq_zero_of_measure_eq_zero_or_top {X : Ω → E} {s : Set E}
(hu : IsUniform X s ℙ μ) (hμs : μ s = 0 ∨ μ s = ∞) : pdf X ℙ μ =ᵐ[μ] 0
|
case inr
E : Type u_1
inst✝ : MeasurableSpace E
μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
H : μ s = ⊤
hu : Measure.map X ℙ = 0
⊢ pdf X ℙ μ =ᶠ[ae μ] 0
|
simp [pdf, hu]
|
no goals
|
0f51d427369dc4b7
|
Submodule.baseChange_top
|
Mathlib/LinearAlgebra/TensorProduct/Tower.lean
|
@[simp]
lemma baseChange_top : (⊤ : Submodule R M).baseChange A = ⊤
|
R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : A ⊗[R] M
a : A
y : M
⊢ a ⊗ₜ[R] y ∈ span A ↑(LinearMap.range ((TensorProduct.mk R A M) 1))
|
rw [← mul_one a, ← smul_eq_mul, ← smul_tmul']
|
R : Type u_1
M : Type u_2
A : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : A ⊗[R] M
a : A
y : M
⊢ a • 1 ⊗ₜ[R] y ∈ span A ↑(LinearMap.range ((TensorProduct.mk R A M) 1))
|
7a47417502811d97
|
Finset.dens_union_add_dens_inter
|
Mathlib/Data/Finset/Density.lean
|
lemma dens_union_add_dens_inter (s t : Finset α) :
dens (s ∪ t) + dens (s ∩ t) = dens s + dens t
|
α : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s t : Finset α
⊢ (s ∪ t).dens + (s ∩ t).dens = s.dens + t.dens
|
simp_rw [dens, ← add_div, ← Nat.cast_add, card_union_add_card_inter]
|
no goals
|
57042bcf7725b282
|
MeasureTheory.measure_compl_sigmaFiniteSetWRT
|
Mathlib/MeasureTheory/Decomposition/Exhaustion.lean
|
@[simp]
lemma measure_compl_sigmaFiniteSetWRT (hμν : μ ≪ ν) [SigmaFinite μ] [SFinite ν] :
ν (μ.sigmaFiniteSetWRT ν)ᶜ = 0
|
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
hμν : μ ≪ ν
inst✝¹ : SigmaFinite μ
inst✝ : SFinite ν
h : ν (μ.sigmaFiniteSetWRT ν)ᶜ ≠ 0 → μ (μ.sigmaFiniteSetWRT ν)ᶜ = ⊤
h0 : ¬ν (μ.sigmaFiniteSetWRT ν)ᶜ = 0
⊢ ⊤ = 0
|
rw [← h h0, ← Measure.iSup_restrict_spanningSets]
|
α : Type u_1
mα : MeasurableSpace α
μ ν : Measure α
hμν : μ ≪ ν
inst✝¹ : SigmaFinite μ
inst✝ : SFinite ν
h : ν (μ.sigmaFiniteSetWRT ν)ᶜ ≠ 0 → μ (μ.sigmaFiniteSetWRT ν)ᶜ = ⊤
h0 : ¬ν (μ.sigmaFiniteSetWRT ν)ᶜ = 0
⊢ ⨆ i, (μ.restrict (spanningSets μ i)) (μ.sigmaFiniteSetWRT ν)ᶜ = 0
|
fa62c7cde26ea6e7
|
SimpleGraph.dist_bot
|
Mathlib/Combinatorics/SimpleGraph/Metric.lean
|
@[simp]
lemma dist_bot : (⊥ : SimpleGraph V).dist u v = 0
|
V : Type u_1
u v : V
⊢ ⊥.dist u v = 0
|
by_cases h : u = v <;> simp [h]
|
no goals
|
e35a5b0d6752de9a
|
Fin.cons_rev
|
Mathlib/Data/Fin/Tuple/Basic.lean
|
theorem cons_rev {α n} (a : α) (f : Fin n → α) (i : Fin <| n + 1) :
cons (α := fun _ => α) a f i.rev = snoc (α := fun _ => α) (f ∘ Fin.rev : Fin _ → α) a i
|
α : Sort u_3
n : ℕ
a : α
f : Fin n → α
i : Fin (n + 1)
⊢ cons a f i.rev = snoc (f ∘ rev) a i
|
simpa using insertNth_rev 0 a f i
|
no goals
|
3a6555a1b88a51d8
|
integral_gaussian_complex_Ioi
|
Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
|
theorem integral_gaussian_complex_Ioi {b : ℂ} (hb : 0 < re b) :
∫ x : ℝ in Ioi 0, cexp (-b * (x : ℂ) ^ 2) = (π / b) ^ (1 / 2 : ℂ) / 2
|
b : ℂ
hb : 0 < b.re
full_integral :
∫ (x : ℝ) in Ioi 0, cexp (-b * ↑x ^ 2) ∂volume + ∫ (x : ℝ) in Iic 0, cexp (-b * ↑x ^ 2) ∂volume = (↑π / b) ^ (1 / 2)
this✝ : MeasurableSet (Ioi 0)
this : ∀ (c : ℝ), ∫ (x : ℝ) in 0 ..c, cexp (-b * ↑x ^ 2) = ∫ (x : ℝ) in -c..0, cexp (-b * ↑x ^ 2)
t1 :
Tendsto (fun i => ∫ (x : ℝ) in 0 ..id i, cexp (-b * ↑x ^ 2)) atTop
(𝓝 (∫ (x : ℝ) in Ioi 0, cexp (-b * ↑x ^ 2) ∂volume))
t2 : Tendsto (fun c => ∫ (x : ℝ) in 0 ..c, cexp (-b * ↑x ^ 2)) atTop (𝓝 (∫ (x : ℝ) in Iic 0, cexp (-b * ↑x ^ 2)))
⊢ ∫ (x : ℝ) in Iic 0, cexp (-b * ↑x ^ 2) = ∫ (x : ℝ) in Ioi 0, cexp (-b * ↑x ^ 2)
|
exact tendsto_nhds_unique t2 t1
|
no goals
|
eb587a98b8371e1c
|
CPolynomialOn.contDiffOn
|
Mathlib/Analysis/Calculus/ContDiff/CPolynomial.lean
|
theorem CPolynomialOn.contDiffOn (h : CPolynomialOn 𝕜 f s) {n : WithTop ℕ∞} :
ContDiffOn 𝕜 n f s
|
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
s : Set E
h : CPolynomialOn 𝕜 f s
n : WithTop ℕ∞
t : Set E := {x | CPolynomialAt 𝕜 f x}
H : CPolynomialOn 𝕜 f t
⊢ AnalyticOnNhd 𝕜 f t
|
exact H.analyticOnNhd
|
no goals
|
817bab7f3a65da8d
|
mem_convexHull_pi
|
Mathlib/Analysis/Convex/Combination.lean
|
lemma mem_convexHull_pi (h : ∀ i ∈ s, x i ∈ convexHull 𝕜 (t i)) : x ∈ convexHull 𝕜 (s.pi t)
|
case refine_1
𝕜 : Type u_1
ι : Type u_2
E : ι → Type u_3
inst✝³ : Finite ι
inst✝² : LinearOrderedField 𝕜
inst✝¹ : (i : ι) → AddCommGroup (E i)
inst✝ : (i : ι) → Module 𝕜 (E i)
s : Set ι
t✝ : (i : ι) → Set (E i)
x : (i : ι) → E i
val✝ : Fintype ι
t : (i : ι) → Set (E i)
κ : ι → Type
x✝ : (i : ι) → Fintype (κ i)
w : (i : ι) → κ i → 𝕜
f : (i : ι) → κ i → E i
hw₀ : ∀ (i : ι) (i_1 : κ i), 0 ≤ w i i_1
hw₁ : ∀ (i : ι), ∑ i_1 : κ i, w i i_1 = 1
hft : ∀ (i : ι) (i_1 : κ i), f i i_1 ∈ t i
hf : ∀ (i : ι), ∑ i_1 : κ i, w i i_1 • f i i_1 = x i
⊢ ∏ i : ι, ∑ j : κ i, w i j = 1
|
exact prod_eq_one fun _ _ ↦ hw₁ _
|
no goals
|
b925b1769d4b937f
|
AddCommGroup.equiv_directSum_zmod_of_finite
|
Mathlib/GroupTheory/FiniteAbelian/Basic.lean
|
theorem equiv_directSum_zmod_of_finite [Finite G] :
∃ (ι : Type) (_ : Fintype ι) (p : ι → ℕ) (_ : ∀ i, Nat.Prime <| p i) (e : ι → ℕ),
Nonempty <| G ≃+ ⨁ i : ι, ZMod (p i ^ e i)
|
case intro.intro.intro.intro.intro.intro.intro.intro.zero
G : Type u
inst✝¹ : AddCommGroup G
inst✝ : Finite G
val✝ : Fintype G
ι : Type
fι : Fintype ι
p : ι → ℕ
hp : ∀ (i : ι), Nat.Prime (p i)
e : ι → ℕ
f : G ≃+ (Fin 0 →₀ ℤ) × ⨁ (i : ι), ZMod (p i ^ e i)
this : Unique (Fin Nat.zero →₀ ℤ)
⊢ ∃ ι x p, ∃ (_ : ∀ (i : ι), Nat.Prime (p i)), ∃ e, Nonempty (G ≃+ ⨁ (i : ι), ZMod (p i ^ e i))
|
exact ⟨ι, fι, p, hp, e, ⟨f.trans AddEquiv.uniqueProd⟩⟩
|
no goals
|
3099aff464e43dc1
|
jacobiSym.ne_zero
|
Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
|
theorem ne_zero {a : ℤ} {b : ℕ} (h : a.gcd b = 1) : J(a | b) ≠ 0
|
case inl
a : ℤ
b : ℕ
h : a.gcd ↑b = 1
hb : b = 0
⊢ 1 ≠ 0
|
exact one_ne_zero
|
no goals
|
48b681b264ba030b
|
Subgroup.exists_isLeast_one_lt
|
Mathlib/GroupTheory/Archimedean.lean
|
theorem Subgroup.exists_isLeast_one_lt {H : Subgroup G} (hbot : H ≠ ⊥) {a : G} (h₀ : 1 < a)
(hd : Disjoint (H : Set G) (Ioo 1 a)) : ∃ b, IsLeast { g : G | g ∈ H ∧ 1 < g } b
|
G : Type u_1
inst✝¹ : LinearOrderedCommGroup G
inst✝ : MulArchimedean G
H : Subgroup G
hbot : H ≠ ⊥
a : G
h₀ : 1 < a
hd : Disjoint (↑H) (Ioo 1 a)
g : G
hg : g > 1
m : ℤ
hm : g ≤ a ^ (m + 1)
hm' : a ^ m < g
⊢ 1 < a ^ (m + 1)
|
exact hg.trans_le hm
|
no goals
|
e6f0c6934844ea17
|
CategoryTheory.Functor.OplaxMonoidal.right_unitality_hom
|
Mathlib/CategoryTheory/Monoidal/Functor.lean
|
theorem right_unitality_hom (X : C) :
δ F X (𝟙_ C) ≫ F.obj X ◁ η F ≫ (ρ_ (F.obj X)).hom = F.map (ρ_ X).hom
|
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
F : C ⥤ D
inst✝ : F.OplaxMonoidal
X : C
⊢ δ F X (𝟙_ C) ≫ F.obj X ◁ η F ≫ (ρ_ (F.obj X)).hom = F.map (ρ_ X).hom
|
rw [← Category.assoc, ← Iso.eq_comp_inv, right_unitality, ← Category.assoc,
← F.map_comp, Iso.hom_inv_id, F.map_id, id_comp]
|
no goals
|
68a32d3d204e7b70
|
ProbabilityTheory.IndepFun.integrable_right_of_integrable_mul
|
Mathlib/Probability/Integration.lean
|
theorem IndepFun.integrable_right_of_integrable_mul {β : Type*} [MeasurableSpace β] {X Y : Ω → β}
[NormedDivisionRing β] [BorelSpace β] (hXY : IndepFun X Y μ) (h'XY : Integrable (X * Y) μ)
(hX : AEStronglyMeasurable X μ) (hY : AEStronglyMeasurable Y μ) (h'X : ¬X =ᵐ[μ] 0) :
Integrable Y μ
|
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
β : Type u_2
inst✝² : MeasurableSpace β
X Y : Ω → β
inst✝¹ : NormedDivisionRing β
inst✝ : BorelSpace β
hXY : IndepFun X Y μ
h'XY : Integrable (X * Y) μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
H : ∫⁻ (ω : Ω), ‖X ω‖ₑ ∂μ = 0
I : (fun x => ‖X x‖ₑ) =ᶠ[ae μ] 0
⊢ False
|
apply h'X
|
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
β : Type u_2
inst✝² : MeasurableSpace β
X Y : Ω → β
inst✝¹ : NormedDivisionRing β
inst✝ : BorelSpace β
hXY : IndepFun X Y μ
h'XY : Integrable (X * Y) μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
H : ∫⁻ (ω : Ω), ‖X ω‖ₑ ∂μ = 0
I : (fun x => ‖X x‖ₑ) =ᶠ[ae μ] 0
⊢ X =ᶠ[ae μ] 0
|
3d8c1ff7f9aa90d7
|
Finset.offDiag_filter_lt_eq_filter_le
|
Mathlib/Data/Finset/Prod.lean
|
theorem offDiag_filter_lt_eq_filter_le {ι}
[PartialOrder ι] [DecidableEq ι]
[DecidableRel (LE.le (α := ι))] [DecidableRel (LT.lt (α := ι))]
(s : Finset ι) :
s.offDiag.filter (fun i => i.1 < i.2) = s.offDiag.filter (fun i => i.1 ≤ i.2)
|
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
⊢ ∀ ⦃a : ι × ι⦄, a ∈ s.offDiag → (a.1 < a.2 ↔ a.1 ≤ a.2)
|
rintro ⟨i, j⟩
|
case mk
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
i j : ι
⊢ (i, j) ∈ s.offDiag → ((i, j).1 < (i, j).2 ↔ (i, j).1 ≤ (i, j).2)
|
3953af221d1a5576
|
Substring.Valid.extract
|
Mathlib/.lake/packages/batteries/Batteries/Data/String/Lemmas.lean
|
theorem extract : ∀ {s}, Valid s → Valid ⟨s.toString, b, e⟩ → Valid (s.extract b e)
| _, h₁, h₂ => by
let ⟨l, m, r, h₁⟩ := h₁.validFor
rw [h₁.toString] at h₂
let ⟨ml, mm, mr, h₂⟩ := h₂.validFor
have ⟨l', r', h₃⟩ := h₁.extract h₂
exact h₃.valid
|
b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
h₂ : { str := x✝.toString, startPos := b, stopPos := e }.Valid
l m r : List Char
h₁ : ValidFor l m r x✝
⊢ (x✝.extract b e).Valid
|
rw [h₁.toString] at h₂
|
b e : Pos
x✝ : Substring
h₁✝ : x✝.Valid
l m : List Char
h₂ : { str := { data := m }, startPos := b, stopPos := e }.Valid
r : List Char
h₁ : ValidFor l m r x✝
⊢ (x✝.extract b e).Valid
|
74df9f07153861fb
|
SimpleGraph.isTree_iff_existsUnique_path
|
Mathlib/Combinatorics/SimpleGraph/Acyclic.lean
|
theorem isTree_iff_existsUnique_path :
G.IsTree ↔ Nonempty V ∧ ∀ v w : V, ∃! p : G.Walk v w, p.IsPath
|
case mpr.intro.refine_2
V : Type u
G : SimpleGraph V
hV : Nonempty V
h : ∀ (v w : V), ∃! p, p.IsPath
⊢ ∀ ⦃v w : V⦄ (p q : G.Path v w), p = q
|
rintro v w ⟨p, hp⟩ ⟨q, hq⟩
|
case mpr.intro.refine_2.mk.mk
V : Type u
G : SimpleGraph V
hV : Nonempty V
h : ∀ (v w : V), ∃! p, p.IsPath
v w : V
p : G.Walk v w
hp : p.IsPath
q : G.Walk v w
hq : q.IsPath
⊢ ⟨p, hp⟩ = ⟨q, hq⟩
|
6f041d11e3829adf
|
Array.toList_reverse
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
|
theorem toList_reverse (a : Array α) : a.reverse.toList = a.toList.reverse
|
α : Type u_1
a as : Array α
i j : Nat
hj : j < as.size
h : i + j + 1 = a.size
h₂ : as.size = a.size
H : ∀ (k : Nat), as.toList[k]? = if i ≤ k ∧ k ≤ j then a.toList[k]? else a.toList.reverse[k]?
k : Nat
⊢ (reverse.loop as i ⟨j, hj⟩).toList[k]? = a.toList.reverse[k]?
|
rw [reverse.loop]
|
α : Type u_1
a as : Array α
i j : Nat
hj : j < as.size
h : i + j + 1 = a.size
h₂ : as.size = a.size
H : ∀ (k : Nat), as.toList[k]? = if i ≤ k ∧ k ≤ j then a.toList[k]? else a.toList.reverse[k]?
k : Nat
⊢ (if h : i < ↑⟨j, hj⟩ then
let_fun this := ⋯;
let as_1 := as.swap i ↑⟨j, hj⟩ ⋯ ⋯;
let_fun this := ⋯;
reverse.loop as_1 (i + 1) ⟨↑⟨j, hj⟩ - 1, this⟩
else as).toList[k]? =
a.toList.reverse[k]?
|
e33b9bf1a6922395
|
MeasureTheory.integrable_const_iff
|
Mathlib/MeasureTheory/Function/L1Space/Integrable.lean
|
lemma integrable_const_iff {c : β} : Integrable (fun _ : α => c) μ ↔ c = 0 ∨ IsFiniteMeasure μ
|
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
c : β
⊢ Integrable (fun x => c) μ ↔ c = 0 ∨ IsFiniteMeasure μ
|
have : AEStronglyMeasurable (fun _ : α => c) μ := aestronglyMeasurable_const
|
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
c : β
this : AEStronglyMeasurable (fun x => c) μ
⊢ Integrable (fun x => c) μ ↔ c = 0 ∨ IsFiniteMeasure μ
|
63b818cfc587b092
|
Polynomial.degree_add_div
|
Mathlib/Algebra/Polynomial/FieldDivision.lean
|
theorem degree_add_div (hq0 : q ≠ 0) (hpq : degree q ≤ degree p) :
degree q + degree (p / q) = degree p
|
R : Type u
inst✝ : Field R
p q : R[X]
hq0 : q ≠ 0
hpq : q.degree ≤ p.degree
this : (p % q).degree < (q * (p / q)).degree
⊢ q.degree + (p / q).degree = p.degree
|
conv_rhs =>
rw [← EuclideanDomain.div_add_mod p q, degree_add_eq_left_of_degree_lt this, degree_mul]
|
no goals
|
ed2cb4a624153e8f
|
AlgebraicGeometry.Scheme.Cover.gluedCoverT'_snd_snd
|
Mathlib/AlgebraicGeometry/Gluing.lean
|
theorem gluedCoverT'_snd_snd (x y z : 𝒰.J) :
gluedCoverT' 𝒰 x y z ≫ pullback.snd _ _ ≫ pullback.snd _ _ =
pullback.fst _ _ ≫ pullback.fst _ _
|
X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (𝒰.map x) (𝒰.map z) (pullback.fst (𝒰.map x) (𝒰.map y))).hom ≫
(pullback.map (pullback.fst (𝒰.map x) (𝒰.map y) ≫ 𝒰.map x) (𝒰.map z)
(pullback.fst (𝒰.map y) (𝒰.map x) ≫ 𝒰.map y) (𝒰.map z) (pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom
(𝟙 (𝒰.obj z)) (𝟙 X) ⋯ ⋯ ≫
(pullbackRightPullbackFstIso (𝒰.map y) (𝒰.map z) (pullback.fst (𝒰.map y) (𝒰.map x))).inv) ≫
(pullbackSymmetry (pullback.fst (𝒰.map y) (𝒰.map x)) (pullback.fst (𝒰.map y) (𝒰.map z))).hom) ≫
pullback.snd (pullback.fst (𝒰.map y) (𝒰.map z)) (pullback.fst (𝒰.map y) (𝒰.map x)) ≫
pullback.snd (𝒰.map y) (𝒰.map x) =
pullback.fst (pullback.fst (𝒰.map x) (𝒰.map y)) (pullback.fst (𝒰.map x) (𝒰.map z)) ≫
pullback.fst (𝒰.map x) (𝒰.map y)
|
simp
|
no goals
|
3efc6a49d85b12cb
|
Filter.filter_injOn_Iic_iff_injOn
|
Mathlib/Order/Filter/Map.lean
|
theorem Filter.filter_injOn_Iic_iff_injOn {s : Set α} {m : α → β} :
InjOn (map m) (Iic <| 𝓟 s) ↔ InjOn m s
|
case refine_1
α : Type u_1
β : Type u_2
s : Set α
m : α → β
hm : InjOn (map m) (Iic (𝓟 s))
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : m x = m y
⊢ x = y
|
rwa [← pure_injective.eq_iff, ← map_pure, ← map_pure, hm.eq_iff, pure_injective.eq_iff]
at hxy <;> rwa [mem_Iic, pure_le_principal]
|
no goals
|
d6e29efebf50b69f
|
groupCohomology.twoCocycles_ρ_map_inv_sub_map_inv
|
Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
|
lemma twoCocycles_ρ_map_inv_sub_map_inv (f : twoCocycles A) (g : G) :
A.ρ g (f (g⁻¹, g)) - f (g, g⁻¹)
= f (1, 1) - f (g, 1)
|
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : f (g * g⁻¹, g) + f (g, g⁻¹) = (A.ρ g) (f (g⁻¹, g)) + f (g, g⁻¹ * g)
⊢ (A.ρ g) (f (g⁻¹, g)) - f (g, g⁻¹) = f (1, 1) - f (g, 1)
|
simp only [mul_inv_cancel, inv_mul_cancel, twoCocycles_map_one_fst _ g]
at this
|
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : f (1, 1) + f (g, g⁻¹) = (A.ρ g) (f (g⁻¹, g)) + f (g, 1)
⊢ (A.ρ g) (f (g⁻¹, g)) - f (g, g⁻¹) = f (1, 1) - f (g, 1)
|
7791ea868eeea9fd
|
MeasureTheory.Measure.hausdorffMeasure_smul₀
|
Mathlib/MeasureTheory/Measure/Hausdorff.lean
|
theorem MeasureTheory.Measure.hausdorffMeasure_smul₀ {𝕜 E : Type*} [NormedAddCommGroup E]
[NormedField 𝕜] [NormedSpace 𝕜 E] [MeasurableSpace E] [BorelSpace E] {d : ℝ} (hd : 0 ≤ d)
{r : 𝕜} (hr : r ≠ 0) (s : Set E) : μH[d] (r • s) = ‖r‖₊ ^ d • μH[d] s
|
𝕜 : Type u_4
E : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
d : ℝ
hd : 0 ≤ d
r : 𝕜
hr : r ≠ 0
s : Set E
this : ∀ {r : 𝕜} (s : Set E), μH[d] (r • s) ≤ ‖r‖₊ ^ d • μH[d] s
⊢ μH[d] (r • s) = ‖r‖₊ ^ d • μH[d] s
|
refine le_antisymm (this s) ?_
|
𝕜 : Type u_4
E : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
d : ℝ
hd : 0 ≤ d
r : 𝕜
hr : r ≠ 0
s : Set E
this : ∀ {r : 𝕜} (s : Set E), μH[d] (r • s) ≤ ‖r‖₊ ^ d • μH[d] s
⊢ ‖r‖₊ ^ d • μH[d] s ≤ μH[d] (r • s)
|
202468cb8a26002e
|
Real.log_intCast_nonneg
|
Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
|
theorem log_intCast_nonneg (n : ℤ) : 0 ≤ log n
|
case inl
n : ℤ
hn : 0 < n
⊢ 0 ≤ log ↑n
|
have : (1 : ℝ) ≤ n := mod_cast hn
|
case inl
n : ℤ
hn : 0 < n
this : 1 ≤ ↑n
⊢ 0 ≤ log ↑n
|
0f87919729bc1d5f
|
AlgHom.IsArithFrobAt.apply_of_pow_eq_one
|
Mathlib/RingTheory/Frobenius.lean
|
/-- Suppose `S` is a domain, and `φ : S →ₐ[R] S` is a Frobenius at `Q : Ideal S`.
Let `ζ` be a `m`-th root of unity with `Q ∤ m`, then `φ` sends `ζ` to `ζ ^ q`. -/
lemma apply_of_pow_eq_one [IsDomain S] {ζ : S} {m : ℕ} (hζ : ζ ^ m = 1) (hk' : ↑m ∉ Q) :
φ ζ = ζ ^ Nat.card (R ⧸ Q.under R)
|
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
φ : S →ₐ[R] S
Q : Ideal S
H : φ.IsArithFrobAt Q
inst✝ : IsDomain S
ζ : S
m : ℕ
hζ✝ : ζ ^ m = 1
hk'✝ : ↑m ∉ Q
q : ℕ := Nat.card (R ⧸ Ideal.under R Q)
hm : m ≠ 0
k : ℕ
hk : k > 0
hζ : IsPrimitiveRoot ζ k
hk' : ↑k ∉ Q
this : NeZero k
i : ℕ
hi : i < k
e : ζ ^ i = φ ζ
j : ℕ
⊢ 1 - ζ ^ ((q + k - i) * j) ∈ Q
|
rw [← Ideal.mul_unit_mem_iff_mem _ ((hζ.isUnit k.pos_of_neZero).pow (i * j)),
sub_mul, one_mul, ← pow_add, ← add_mul, tsub_add_cancel_of_le (by linarith), add_mul,
pow_add, pow_mul _ k, hζ.1, one_pow, mul_one, pow_mul, e, ← map_pow, mul_comm, pow_mul]
|
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
φ : S →ₐ[R] S
Q : Ideal S
H : φ.IsArithFrobAt Q
inst✝ : IsDomain S
ζ : S
m : ℕ
hζ✝ : ζ ^ m = 1
hk'✝ : ↑m ∉ Q
q : ℕ := Nat.card (R ⧸ Ideal.under R Q)
hm : m ≠ 0
k : ℕ
hk : k > 0
hζ : IsPrimitiveRoot ζ k
hk' : ↑k ∉ Q
this : NeZero k
i : ℕ
hi : i < k
e : ζ ^ i = φ ζ
j : ℕ
⊢ φ (ζ ^ j) - (ζ ^ j) ^ q ∈ Q
|
0e667ff9ac58a167
|
Finsupp.finsuppProdLEquiv_symm_apply
|
Mathlib/LinearAlgebra/Finsupp/Defs.lean
|
theorem finsuppProdLEquiv_symm_apply {α β R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
(f : α →₀ β →₀ M) (xy) : (finsuppProdLEquiv R).symm f xy = f xy.1 xy.2
|
α : Type u_7
β : Type u_8
R : Type u_9
M : Type u_10
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : α →₀ β →₀ M
xy : α × β
⊢ ((finsuppProdLEquiv R).symm f) xy = (f xy.1) xy.2
|
conv_rhs =>
rw [← (finsuppProdLEquiv R).apply_symm_apply f, finsuppProdLEquiv_apply]
|
no goals
|
2b4f168736b127b4
|
Finite.of_finite_mulAction_orbitRel_quotient
|
Mathlib/GroupTheory/GroupAction/Basic.lean
|
@[to_additive]
lemma _root_.Finite.of_finite_mulAction_orbitRel_quotient [Finite G] [Finite Ω] : Finite α
|
G : Type u_1
α : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : Finite G
inst✝ : Finite Ω
⊢ ∀ (g : Ω), Finite ↑g.orbit
|
intro g
|
G : Type u_1
α : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : Finite G
inst✝ : Finite Ω
g : Ω
⊢ Finite ↑g.orbit
|
e112575a1e169936
|
EReal.max_neg_neg
|
Mathlib/Data/Real/EReal.lean
|
lemma max_neg_neg (x y : EReal) : max (-x) (-y) = -min x y
|
x y : EReal
⊢ -x ⊔ -y = -(x ⊓ y)
|
rcases le_total x y with (h | h) <;> simp_all
|
no goals
|
88ef835d4361a18d
|
Matrix.isUnit_det_zpow_iff
|
Mathlib/LinearAlgebra/Matrix/ZPow.lean
|
theorem isUnit_det_zpow_iff {A : M} {z : ℤ} : IsUnit (A ^ z).det ↔ IsUnit A.det ∨ z = 0
|
case hn
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
z : ℕ
a✝ : IsUnit (A ^ (-↑z)).det ↔ IsUnit A.det ∨ -↑z = 0
⊢ IsUnit (A ^ (-↑z - 1)).det ↔ IsUnit A.det ∨ -↑z - 1 = 0
|
rw [← neg_add', ← Int.ofNat_succ, zpow_neg_natCast, isUnit_nonsing_inv_det_iff, det_pow,
isUnit_pow_succ_iff, neg_eq_zero, ← Int.ofNat_zero, Int.ofNat_inj]
|
case hn
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
z : ℕ
a✝ : IsUnit (A ^ (-↑z)).det ↔ IsUnit A.det ∨ -↑z = 0
⊢ IsUnit A.det ↔ IsUnit A.det ∨ z.succ = 0
|
fcc060d122cef82a
|
CategoryTheory.Presieve.isSheafFor_of_preservesProduct
|
Mathlib/CategoryTheory/Sites/Preserves.lean
|
theorem isSheafFor_of_preservesProduct [PreservesLimit (Discrete.functor (fun x ↦ op (X x))) F] :
(ofArrows X c.inj).IsSheafFor F
|
C : Type u
inst✝² : Category.{v, u} C
F : Cᵒᵖ ⥤ Type w
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝¹ : (ofArrows X c.inj).hasPullbacks
inst✝ : PreservesLimit (Discrete.functor fun x => op (X x)) F
⊢ IsSheafFor F (ofArrows X c.inj)
|
rw [Equalizer.Presieve.Arrows.sheaf_condition, Limits.Types.type_equalizer_iff_unique]
|
C : Type u
inst✝² : Category.{v, u} C
F : Cᵒᵖ ⥤ Type w
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝¹ : (ofArrows X c.inj).hasPullbacks
inst✝ : PreservesLimit (Discrete.functor fun x => op (X x)) F
⊢ ∀ (y : Equalizer.Presieve.Arrows.FirstObj F X),
Equalizer.Presieve.Arrows.firstMap F X c.inj y = Equalizer.Presieve.Arrows.secondMap F X c.inj y →
∃! x, Equalizer.Presieve.Arrows.forkMap F X c.inj x = y
|
63b7a789eba5ef5a
|
ENNReal.isUnit_iff
|
Mathlib/Data/ENNReal/Inv.lean
|
lemma isUnit_iff : IsUnit a ↔ a ≠ 0 ∧ a ≠ ∞
|
case intro
u : ℝ≥0∞ˣ
hu : ↑u = ⊤
this : ↑u * ↑u⁻¹ = ⊤ * ↑u⁻¹
⊢ False
|
norm_cast at this
|
case intro
u : ℝ≥0∞ˣ
hu : ↑u = ⊤
this : ↑(u * u⁻¹) = ⊤ * ↑u⁻¹
⊢ False
|
186548a2895d5c60
|
Std.DHashMap.Raw.contains_alter
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/RawLemmas.lean
|
theorem contains_alter [LawfulBEq α] {k k': α} {f : Option (β k) → Option (β k)} (h : m.WF) :
(m.alter k f).contains k' = if k == k' then (f (m.get? k)).isSome else m.contains k'
|
α : Type u
β : α → Type v
inst✝² : BEq α
inst✝¹ : Hashable α
m : Raw α β
inst✝ : LawfulBEq α
k k' : α
f : Option (β k) → Option (β k)
h : m.WF
⊢ (m.alter k f).contains k' = if (k == k') = true then (f (m.get? k)).isSome else m.contains k'
|
simp_to_raw using Raw₀.contains_alter
|
no goals
|
a6c0dc32397ab68b
|
FractionalIdeal.den_mem_inv
|
Mathlib/RingTheory/DedekindDomain/Ideal.lean
|
lemma den_mem_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≠ ⊥) :
(algebraMap R₁ K) (I.den : R₁) ∈ I⁻¹
|
K : Type u_3
inst✝⁴ : Field K
R₁ : Type u_4
inst✝³ : CommRing R₁
inst✝² : IsDomain R₁
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I : FractionalIdeal R₁⁰ K
hI : I ≠ ⊥
⊢ (algebraMap R₁ K) ↑I.den ∈ I⁻¹
|
rw [mem_inv_iff hI]
|
K : Type u_3
inst✝⁴ : Field K
R₁ : Type u_4
inst✝³ : CommRing R₁
inst✝² : IsDomain R₁
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I : FractionalIdeal R₁⁰ K
hI : I ≠ ⊥
⊢ ∀ y ∈ I, (algebraMap R₁ K) ↑I.den * y ∈ 1
|
f2255a2916b7b0a4
|
Real.posLog_add
|
Mathlib/Analysis/SpecialFunctions/Log/PosLog.lean
|
theorem posLog_add {a b : ℝ} : log⁺ (a + b) ≤ log 2 + log⁺ a + log⁺ b
|
a b : ℝ
⊢ log⁺ (a + b) ≤ log 2 + log⁺ a + log⁺ b
|
convert posLog_sum Finset.univ ![a, b] using 1 <;> simp [add_assoc]
|
no goals
|
c119f070e18b5fee
|
Polynomial.nodup_roots_iff_of_splits
|
Mathlib/FieldTheory/Separable.lean
|
theorem nodup_roots_iff_of_splits {f : F[X]} (hf : f ≠ 0) (h : f.Splits (RingHom.id F)) :
f.roots.Nodup ↔ f.Separable
|
F : Type u
inst✝ : Field F
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬f.Separable
⊢ ¬f.roots.Nodup
|
rw [Separable, ← gcd_isUnit_iff, isUnit_iff_degree_eq_zero] at hnsep
|
F : Type u
inst✝ : Field F
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬(GCDMonoid.gcd f (derivative f)).degree = 0
⊢ ¬f.roots.Nodup
|
d1a347c40a79ce42
|
Algebra.Presentation.span_range_relation_eq_ker_baseChange
|
Mathlib/RingTheory/Presentation.lean
|
private lemma span_range_relation_eq_ker_baseChange :
Ideal.span (Set.range fun i ↦ (MvPolynomial.map (algebraMap R T)) (P.relation i)) =
RingHom.ker (aeval (R := T) (S₁ := T ⊗[R] S) P.baseChange.val)
|
case a
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Presentation R S
x : MvPolynomial P.vars T
y : P.rels
hy : (fun i => (MvPolynomial.map (algebraMap R T)) (P.relation i)) y = x
Z : (aeval P.val) (P.relation y) = 0
⊢ x ∈ ↑(RingHom.ker (aeval P.baseChange.val))
|
apply_fun TensorProduct.includeRight (R := R) (A := T) at Z
|
case a
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Presentation R S
x : MvPolynomial P.vars T
y : P.rels
hy : (fun i => (MvPolynomial.map (algebraMap R T)) (P.relation i)) y = x
Z : TensorProduct.includeRight ((aeval P.val) (P.relation y)) = TensorProduct.includeRight 0
⊢ x ∈ ↑(RingHom.ker (aeval P.baseChange.val))
|
30b8d1d266b74361
|
ProbabilityTheory.Kernel.indepFun_zero_left
|
Mathlib/Probability/Independence/Kernel.lean
|
@[simp] lemma indepFun_zero_left {β γ} [MeasurableSpace β] [MeasurableSpace γ]
{f : Ω → β} {g : Ω → γ} : IndepFun f g (0 : Kernel α Ω) μ
|
α : Type u_1
Ω : Type u_2
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
μ : Measure α
β : Type u_5
γ : Type u_6
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : Ω → β
g : Ω → γ
⊢ IndepFun f g 0 μ
|
simp [IndepFun]
|
no goals
|
fb96b886289d6844
|
Ordinal.nmul_nadd_le
|
Mathlib/SetTheory/Ordinal/NaturalOps.lean
|
theorem nmul_nadd_le {a' b' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b'
|
a b a' b' : Ordinal.{u}
ha : a' ≤ a
hb : b' ≤ b
⊢ a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b'
|
rcases lt_or_eq_of_le ha with (ha | rfl)
|
case inl
a b a' b' : Ordinal.{u}
ha✝ : a' ≤ a
hb : b' ≤ b
ha : a' < a
⊢ a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b'
case inr
b a' b' : Ordinal.{u}
hb : b' ≤ b
ha : a' ≤ a'
⊢ a' ⨳ b ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a' ⨳ b'
|
1f70486e82091620
|
ne_zero_pow
|
Mathlib/Algebra/GroupWithZero/Basic.lean
|
lemma ne_zero_pow (hn : n ≠ 0) (ha : a ^ n ≠ 0) : a ≠ 0
|
M₀ : Type u_1
inst✝ : MonoidWithZero M₀
a : M₀
n : ℕ
hn : n ≠ 0
ha : a ^ n ≠ 0
⊢ a ≠ 0
|
rintro rfl
|
M₀ : Type u_1
inst✝ : MonoidWithZero M₀
n : ℕ
hn : n ≠ 0
ha : 0 ^ n ≠ 0
⊢ False
|
b027e4bd16aacf7e
|
Matrix.StdBasisMatrix.mul_same
|
Mathlib/Data/Matrix/Basis.lean
|
theorem mul_same (i : l) (j : m) (k : n) (d : α) :
stdBasisMatrix i j c * stdBasisMatrix j k d = stdBasisMatrix i k (c * d)
|
case a
l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
c : α
i : l
j : m
k : n
d : α
a : l
b : n
⊢ ∑ j_1 : m,
of (fun i' j' => if i = i' ∧ j = j' then c else 0) a j_1 *
of (fun i' j' => if j = i' ∧ k = j' then d else 0) j_1 b =
of (fun i' j' => if i = i' ∧ k = j' then c * d else 0) a b
|
by_cases h₁ : i = a <;> by_cases h₂ : k = b <;> simp [h₁, h₂]
|
no goals
|
dddd2530084bee6b
|
pow_le_pow_left'
|
Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
|
theorem pow_le_pow_left' {a b : M} (hab : a ≤ b) : ∀ i : ℕ, a ^ i ≤ b ^ i
| 0 => by simp
| k + 1 => by
rw [pow_succ, pow_succ]
exact mul_le_mul' (pow_le_pow_left' hab k) hab
|
M : Type u_3
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : MulLeftMono M
inst✝ : MulRightMono M
a b : M
hab : a ≤ b
⊢ a ^ 0 ≤ b ^ 0
|
simp
|
no goals
|
7a2619605266e9bf
|
CochainComplex.isStrictlyGE_of_ge
|
Mathlib/Algebra/Homology/Embedding/CochainComplex.lean
|
lemma isStrictlyGE_of_ge (p q : ℤ) (hpq : p ≤ q) [K.IsStrictlyGE q] :
K.IsStrictlyGE p
|
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
K : CochainComplex C ℤ
p q : ℤ
hpq : p ≤ q
inst✝ : K.IsStrictlyGE q
i : ℤ
hi : i < p
⊢ IsZero (K.X i)
|
apply K.isZero_of_isStrictlyGE q
|
case hi
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
K : CochainComplex C ℤ
p q : ℤ
hpq : p ≤ q
inst✝ : K.IsStrictlyGE q
i : ℤ
hi : i < p
⊢ i < q
|
92c2380a683aaa81
|
Nat.testBit_two_pow
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
|
theorem testBit_two_pow {n m : Nat} : testBit (2 ^ n) m = decide (n = m)
|
n m : Nat
h : ¬n = m
h✝ : n < m
⊢ 1 < 2
|
omega
|
no goals
|
bbc66499b4dfb877
|
Orientation.tan_oangle_sub_right_mul_norm_of_oangle_eq_pi_div_two
|
Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
|
theorem tan_oangle_sub_right_mul_norm_of_oangle_eq_pi_div_two {x y : V}
(h : o.oangle x y = ↑(π / 2)) : Real.Angle.tan (o.oangle y (y - x)) * ‖y‖ = ‖x‖
|
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle y (y - x)).sign = 1
|
rw [oangle_sign_sub_right_swap, h, Real.Angle.sign_coe_pi_div_two]
|
no goals
|
3acfb8b14d338dc2
|
SetTheory.PGame.quot_mul_assoc
|
Mathlib/SetTheory/Game/Basic.lean
|
theorem quot_mul_assoc (x y z : PGame) : (⟦x * y * z⟧ : Game) = ⟦x * (y * z)⟧ :=
match x, y, z with
| mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
let x := mk xl xr xL xR
let y := mk yl yr yL yR
let z := mk zl zr zL zR
refine quot_eq_of_mk'_quot_eq ?_ ?_ ?_ ?_
· fconstructor
· rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩) <;>
-- Porting note: as above, increased the `maxDepth` here by 1.
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
· rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩) <;>
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
· rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩) <;> rfl
· rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩) <;> rfl
· fconstructor
· rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩) <;>
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
· rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩) <;>
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk]
· rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩) <;> rfl
· rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩) <;> rfl
-- Porting note: explicitly wrote out arguments to each recursive
-- quot_mul_assoc reference below, because otherwise the decreasing_by block
-- failed. Each branch previously ended with: `simp [quot_mul_assoc]; abel`
-- See https://github.com/leanprover/lean4/issues/2288
· rintro (⟨⟨i, j⟩ | ⟨i, j⟩, k⟩ | ⟨⟨i, j⟩ | ⟨i, j⟩, k⟩)
· change
⟦(xL i * y + x * yL j - xL i * yL j) * z + x * y * zL k -
(xL i * y + x * yL j - xL i * yL j) * zL k⟧ =
⟦xL i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) -
xL i * (yL j * z + y * zL k - yL j * zL k)⟧
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
rw [quot_mul_assoc (xL i) (yL j) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zL k)]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zL k)]
rw [quot_mul_assoc (xL i) (yL j) (zL k)]
abel
· change
⟦(xR i * y + x * yR j - xR i * yR j) * z + x * y * zL k -
(xR i * y + x * yR j - xR i * yR j) * zL k⟧ =
⟦xR i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) -
xR i * (yR j * z + y * zL k - yR j * zL k)⟧
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
rw [quot_mul_assoc (xR i) (yR j) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zL k)]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zL k)]
rw [quot_mul_assoc (xR i) (yR j) (zL k)]
abel
· change
⟦(xL i * y + x * yR j - xL i * yR j) * z + x * y * zR k -
(xL i * y + x * yR j - xL i * yR j) * zR k⟧ =
⟦xL i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) -
xL i * (yR j * z + y * zR k - yR j * zR k)⟧
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
rw [quot_mul_assoc (xL i) (yR j) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zR k)]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zR k)]
rw [quot_mul_assoc (xL i) (yR j) (zR k)]
abel
· change
⟦(xR i * y + x * yL j - xR i * yL j) * z + x * y * zR k -
(xR i * y + x * yL j - xR i * yL j) * zR k⟧ =
⟦xR i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) -
xR i * (yL j * z + y * zR k - yL j * zR k)⟧
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
rw [quot_mul_assoc (xR i) (yL j) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zR k)]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zR k)]
rw [quot_mul_assoc (xR i) (yL j) (zR k)]
abel
· rintro (⟨⟨i, j⟩ | ⟨i, j⟩, k⟩ | ⟨⟨i, j⟩ | ⟨i, j⟩, k⟩)
· change
⟦(xL i * y + x * yL j - xL i * yL j) * z + x * y * zR k -
(xL i * y + x * yL j - xL i * yL j) * zR k⟧ =
⟦xL i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) -
xL i * (yL j * z + y * zR k - yL j * zR k)⟧
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
rw [quot_mul_assoc (xL i) (yL j) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zR k)]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zR k)]
rw [quot_mul_assoc (xL i) (yL j) (zR k)]
abel
· change
⟦(xR i * y + x * yR j - xR i * yR j) * z + x * y * zR k -
(xR i * y + x * yR j - xR i * yR j) * zR k⟧ =
⟦xR i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) -
xR i * (yR j * z + y * zR k - yR j * zR k)⟧
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
rw [quot_mul_assoc (xR i) (yR j) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zR k)]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zR k)]
rw [quot_mul_assoc (xR i) (yR j) (zR k)]
abel
· change
⟦(xL i * y + x * yR j - xL i * yR j) * z + x * y * zL k -
(xL i * y + x * yR j - xL i * yR j) * zL k⟧ =
⟦xL i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) -
xL i * (yR j * z + y * zL k - yR j * zL k)⟧
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)]
rw [quot_mul_assoc (xL i) (yR j) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zL k)]
rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zL k)]
rw [quot_mul_assoc (xL i) (yR j) (zL k)]
abel
· change
⟦(xR i * y + x * yL j - xR i * yL j) * z + x * y * zL k -
(xR i * y + x * yL j - xR i * yL j) * zL k⟧ =
⟦xR i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) -
xR i * (yL j * z + y * zL k - yL j * zL k)⟧
simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)]
rw [quot_mul_assoc (xR i) (yL j) (mk zl zr zL zR)]
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zL k)]
rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zL k)]
rw [quot_mul_assoc (xR i) (yL j) (zL k)]
abel
termination_by (x, y, z)
|
case refine_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ ⟦xL i * (mk yl yr yL yR * mk zl zr zL zR)⟧ + ⟦mk xl xr xL xR * (yR j * mk zl zr zL zR)⟧ -
⟦xL i * (yR j * mk zl zr zL zR)⟧ +
⟦x * y * zL k⟧ -
(⟦xL i * y * zL k⟧ + ⟦x * yR j * zL k⟧ - ⟦xL i * yR j * zL k⟧) =
⟦xL i * (y * z)⟧ + (⟦x * (yR j * z)⟧ + ⟦x * (y * zL k)⟧ - ⟦x * (yR j * zL k)⟧) -
(⟦xL i * (yR j * z)⟧ + ⟦xL i * (y * zL k)⟧ - ⟦xL i * (yR j * zL k)⟧)
|
rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)]
|
case refine_4.inr.mk.inl.mk
x✝ y✝ z✝ : PGame
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
yl yr : Type u_1
yL : yl → PGame
yR : yr → PGame
zl zr : Type u_1
zL : zl → PGame
zR : zr → PGame
x : PGame := mk xl xr xL xR
y : PGame := mk yl yr yL yR
z : PGame := mk zl zr zL zR
k : zl
i : xl
j : yr
⊢ ⟦xL i * (mk yl yr yL yR * mk zl zr zL zR)⟧ + ⟦mk xl xr xL xR * (yR j * mk zl zr zL zR)⟧ -
⟦xL i * (yR j * mk zl zr zL zR)⟧ +
⟦mk xl xr xL xR * (mk yl yr yL yR * zL k)⟧ -
(⟦xL i * y * zL k⟧ + ⟦x * yR j * zL k⟧ - ⟦xL i * yR j * zL k⟧) =
⟦xL i * (y * z)⟧ + (⟦x * (yR j * z)⟧ + ⟦x * (y * zL k)⟧ - ⟦x * (yR j * zL k)⟧) -
(⟦xL i * (yR j * z)⟧ + ⟦xL i * (y * zL k)⟧ - ⟦xL i * (yR j * zL k)⟧)
|
07a86410cd457eaf
|
AddChar.inv_apply'
|
Mathlib/Algebra/Group/AddChar.lean
|
lemma inv_apply' (ψ : AddChar A M) (a : A) : ψ⁻¹ a = (ψ a)⁻¹
|
A : Type u_1
M : Type u_2
inst✝¹ : AddCommGroup A
inst✝ : DivisionCommMonoid M
ψ : AddChar A M
a : A
⊢ ψ⁻¹ a = (ψ a)⁻¹
|
rw [inv_apply, map_neg_eq_inv]
|
no goals
|
11bf170bb1be7bc8
|
List.prod_concat
|
Mathlib/Algebra/BigOperators/Group/List/Basic.lean
|
theorem prod_concat : (l.concat a).prod = l.prod * a
|
M : Type u_4
inst✝ : Monoid M
l : List M
a : M
⊢ (l.concat a).prod = l.prod * a
|
rw [concat_eq_append, prod_append, prod_singleton]
|
no goals
|
4bed235831a8aa18
|
Real.fourierCoeff_tsum_comp_add
|
Mathlib/Analysis/Fourier/PoissonSummation.lean
|
theorem Real.fourierCoeff_tsum_comp_add {f : C(ℝ, ℂ)}
(hf : ∀ K : Compacts ℝ, Summable fun n : ℤ => ‖(f.comp (ContinuousMap.addRight n)).restrict K‖)
(m : ℤ) : fourierCoeff (Periodic.lift <| f.periodic_tsum_comp_add_zsmul 1) m = 𝓕 f m
|
case h.e'_5
f : C(ℝ, ℂ)
hf : ∀ (K : Compacts ℝ), Summable fun n => ‖ContinuousMap.restrict (↑K) (f.comp (ContinuousMap.addRight ↑n))‖
m : ℤ
e : C(ℝ, ℂ) := (fourier (-m)).comp { toFun := QuotientAddGroup.mk, continuous_toFun := ⋯ }
neK : ∀ (K : Compacts ℝ) (g : C(ℝ, ℂ)), ‖ContinuousMap.restrict (↑K) (e * g)‖ = ‖ContinuousMap.restrict (↑K) g‖
eadd : ∀ (n : ℤ), e.comp (ContinuousMap.addRight ↑n) = e
⊢ (fun n => ‖ContinuousMap.restrict (Icc 0 1) (e * f.comp (ContinuousMap.addRight ↑n))‖) = fun n =>
‖ContinuousMap.restrict (↑{ carrier := Icc 0 1, isCompact' := ⋯ }) (f.comp (ContinuousMap.addRight ↑n))‖
|
exact funext fun n => neK ⟨Icc 0 1, isCompact_Icc⟩ _
|
no goals
|
ec2dd51bd198a0fb
|
properlyDiscontinuousSMul_iff_properSMul
|
Mathlib/Topology/Algebra/ProperAction/ProperlyDiscontinuous.lean
|
theorem properlyDiscontinuousSMul_iff_properSMul [T2Space X] [DiscreteTopology G]
[ContinuousConstSMul G X] [CompactlyGeneratedSpace (X × X)] :
ProperlyDiscontinuousSMul G X ↔ ProperSMul G X
|
G : Type u_1
X : Type u_2
inst✝⁷ : Group G
inst✝⁶ : MulAction G X
inst✝⁵ : TopologicalSpace G
inst✝⁴ : TopologicalSpace X
inst✝³ : T2Space X
inst✝² : DiscreteTopology G
inst✝¹ : ContinuousConstSMul G X
inst✝ : CompactlyGeneratedSpace (X × X)
h : ProperlyDiscontinuousSMul G X
K : Set (X × X)
hK : IsCompact K
K' : Set X := fst '' K ∪ snd '' K
hK' : IsCompact K'
E : Set G := {g | ((fun x => g • x) '' K' ∩ K').Nonempty}
⊢ {g | (fun x => g • x) '' K' ∩ K' ≠ ∅}.Finite
|
exact h.finite_disjoint_inter_image hK' hK'
|
no goals
|
e455cea448594c52
|
BitVec.eq_of_getLsbD_eq
|
Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
|
theorem eq_of_getLsbD_eq {x y : BitVec w}
(pred : ∀ i, i < w → x.getLsbD i = y.getLsbD i) : x = y
|
w : Nat
x y : BitVec w
pred : ∀ (i : Nat), i < w → x.getLsbD i = y.getLsbD i
i : Nat
i_lt : i < w
⊢ x.toNat.testBit i = y.toNat.testBit i
|
exact pred i i_lt
|
no goals
|
c491b21788cdd007
|
locallyConnectedSpace_iff_subsets_isOpen_isConnected
|
Mathlib/Topology/Connected/LocallyConnected.lean
|
theorem locallyConnectedSpace_iff_subsets_isOpen_isConnected :
LocallyConnectedSpace α ↔
∀ x, ∀ U ∈ 𝓝 x, ∃ V : Set α, V ⊆ U ∧ IsOpen V ∧ x ∈ V ∧ IsConnected V
|
case mpr
α : Type u
inst✝ : TopologicalSpace α
x✝ : α
⊢ (∀ U ∈ 𝓝 x✝, ∃ V ⊆ U, IsOpen V ∧ x✝ ∈ V ∧ IsConnected V) →
(𝓝 x✝).HasBasis (fun s => IsOpen s ∧ x✝ ∈ s ∧ IsConnected s) id
|
exact fun h => ⟨fun U => ⟨fun hU =>
let ⟨V, hVU, hV⟩ := h U hU
⟨V, hV, hVU⟩, fun ⟨V, ⟨hV, hxV, _⟩, hVU⟩ => mem_nhds_iff.mpr ⟨V, hVU, hV, hxV⟩⟩⟩
|
no goals
|
a1a80a89e26b6406
|
Finset.prod_one_add
|
Mathlib/Algebra/BigOperators/Ring/Finset.lean
|
theorem prod_one_add {f : ι → α} (s : Finset ι) :
∏ i ∈ s, (1 + f i) = ∑ t ∈ s.powerset, ∏ i ∈ t, f i
|
ι : Type u_1
α : Type u_3
inst✝ : CommSemiring α
f : ι → α
s : Finset ι
⊢ ∏ i ∈ s, (1 + f i) = ∑ t ∈ s.powerset, ∏ i ∈ t, f i
|
classical simp only [add_comm (1 : α), prod_add, prod_const_one, mul_one]
|
no goals
|
2bc8e910046429f6
|
contractLeft_assoc_coevaluation'
|
Mathlib/LinearAlgebra/Coevaluation.lean
|
theorem contractLeft_assoc_coevaluation' :
(contractLeft K V).lTensor _ ∘ₗ
(TensorProduct.assoc K _ _ _).toLinearMap ∘ₗ (coevaluation K V).rTensor V =
(TensorProduct.rid K _).symm.toLinearMap ∘ₗ (TensorProduct.lid K _).toLinearMap
|
case H.h
K : Type u
inst✝³ : Field K
V : Type v
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
this : DecidableEq ↑(Basis.ofVectorSpaceIndex K V) := Classical.decEq ↑(Basis.ofVectorSpaceIndex K V)
⊢ ((TensorProduct.mk K K V).compr₂
(LinearMap.lTensor V (contractLeft K V) ∘ₗ
↑(TensorProduct.assoc K V (Dual K V) V) ∘ₗ LinearMap.rTensor V (coevaluation K V)))
1 =
((TensorProduct.mk K K V).compr₂ (↑(TensorProduct.rid K V).symm ∘ₗ ↑(TensorProduct.lid K V))) 1
|
apply (Basis.ofVectorSpace K V).ext
|
case H.h
K : Type u
inst✝³ : Field K
V : Type v
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
this : DecidableEq ↑(Basis.ofVectorSpaceIndex K V) := Classical.decEq ↑(Basis.ofVectorSpaceIndex K V)
⊢ ∀ (i : ↑(Basis.ofVectorSpaceIndex K V)),
(((TensorProduct.mk K K V).compr₂
(LinearMap.lTensor V (contractLeft K V) ∘ₗ
↑(TensorProduct.assoc K V (Dual K V) V) ∘ₗ LinearMap.rTensor V (coevaluation K V)))
1)
((Basis.ofVectorSpace K V) i) =
(((TensorProduct.mk K K V).compr₂ (↑(TensorProduct.rid K V).symm ∘ₗ ↑(TensorProduct.lid K V))) 1)
((Basis.ofVectorSpace K V) i)
|
fa558da7fb2ef0c7
|
Language.mem_kstar_iff_exists_nonempty
|
Mathlib/Computability/Language.lean
|
lemma mem_kstar_iff_exists_nonempty {x : List α} :
x ∈ l∗ ↔ ∃ S : List (List α), x = S.flatten ∧ ∀ y ∈ S, y ∈ l ∧ y ≠ []
|
case mpr
α : Type u_1
l : Language α
x : List α
⊢ (∃ S, x = S.flatten ∧ ∀ y ∈ S, y ∈ l ∧ y ≠ []) → x ∈ l∗
|
rintro ⟨S, hx, h⟩
|
case mpr.intro.intro
α : Type u_1
l : Language α
x : List α
S : List (List α)
hx : x = S.flatten
h : ∀ y ∈ S, y ∈ l ∧ y ≠ []
⊢ x ∈ l∗
|
976aeea620c10223
|
FirstOrder.Language.BoundedFormula.realize_relabelEquiv
|
Mathlib/ModelTheory/Semantics.lean
|
theorem realize_relabelEquiv {g : α ≃ β} {k} {φ : L.BoundedFormula α k} {v : β → M}
{xs : Fin k → M} : (relabelEquiv g φ).Realize v xs ↔ φ.Realize (v ∘ g) xs
|
L : Language
M : Type w
inst✝ : L.Structure M
α : Type u'
β : Type v'
g : α ≃ β
k : ℕ
φ : L.BoundedFormula α k
v : β → M
xs : Fin k → M
⊢ ((relabelEquiv g) φ).Realize v xs ↔ φ.Realize (v ∘ ⇑g) xs
|
simp only [relabelEquiv, mapTermRelEquiv_apply, Equiv.coe_refl]
|
L : Language
M : Type w
inst✝ : L.Structure M
α : Type u'
β : Type v'
g : α ≃ β
k : ℕ
φ : L.BoundedFormula α k
v : β → M
xs : Fin k → M
⊢ (mapTermRel (fun n => ⇑(Term.relabelEquiv (g.sumCongr (_root_.Equiv.refl (Fin n))))) (fun n => id) (fun x => id)
φ).Realize
v xs ↔
φ.Realize (v ∘ ⇑g) xs
|
ae9fa7341489438e
|
map_sub_le_max
|
Mathlib/Analysis/Normed/Group/Seminorm.lean
|
theorem map_sub_le_max : f (x - y) ≤ max (f x) (f y)
|
E : Type u_3
F : Type u_4
inst✝² : AddGroup E
inst✝¹ : FunLike F E ℝ
inst✝ : NonarchAddGroupSeminormClass F E
f : F
x y : E
⊢ f (x + -y) ≤ f x ⊔ f (-y)
|
exact map_add_le_max _ _ _
|
no goals
|
a9d6b956926a25a3
|
Nat.psp_from_prime_psp
|
Mathlib/NumberTheory/FermatPsp.lean
|
theorem psp_from_prime_psp {b : ℕ} (b_ge_two : 2 ≤ b) {p : ℕ} (p_prime : p.Prime)
(p_gt_two : 2 < p) (not_dvd : ¬p ∣ b * (b ^ 2 - 1)) : FermatPsp (psp_from_prime b p) b
|
case h
b : ℕ
b_ge_two : 2 ≤ b
p : ℕ
p_prime : Prime p
p_gt_two : 2 < p
not_dvd : ¬p ∣ b * (b ^ 2 - 1)
A : ℕ := (b ^ p - 1) / (b - 1)
B : ℕ := (b ^ p + 1) / (b + 1)
hi_A : 1 < A
hi_B : 1 < B
hi_AB : 1 < A * B
hi_b : 0 < b
hi_p : 1 ≤ p
hi_bsquared : 0 < b ^ 2 - 1
hi_bpowtwop : 1 ≤ b ^ (2 * p)
hi_bpowpsubone : 1 ≤ b ^ (p - 1)
p_odd : Odd p
AB_not_prime : ¬Prime (A * B)
AB_id : A * B = (b ^ (2 * p) - 1) / (b ^ 2 - 1)
hd : b ^ 2 - 1 ∣ b ^ (2 * p) - 1
ha₁ : (b ^ 2 - 1) * (A * B - 1) = b * (b ^ (p - 1) - 1) * (b ^ p + b)
ha₂ : 2 ∣ b ^ p + b
ha₃ : p ∣ b ^ (p - 1) - 1
ha₄ : b ^ 2 - 1 ∣ b ^ (p - 1) - 1
ha₅ : 2 * p * (b ^ 2 - 1) ∣ (b ^ 2 - 1) * (A * B - 1)
ha₆ : 2 * p ∣ A * B - 1
⊢ b ^ (2 * p) - 1 = A * B * (b ^ 2 - 1)
|
have : A * B * (b ^ 2 - 1) = (b ^ (2 * p) - 1) / (b ^ 2 - 1) * (b ^ 2 - 1) :=
congr_arg (fun x : ℕ => x * (b ^ 2 - 1)) AB_id
|
case h
b : ℕ
b_ge_two : 2 ≤ b
p : ℕ
p_prime : Prime p
p_gt_two : 2 < p
not_dvd : ¬p ∣ b * (b ^ 2 - 1)
A : ℕ := (b ^ p - 1) / (b - 1)
B : ℕ := (b ^ p + 1) / (b + 1)
hi_A : 1 < A
hi_B : 1 < B
hi_AB : 1 < A * B
hi_b : 0 < b
hi_p : 1 ≤ p
hi_bsquared : 0 < b ^ 2 - 1
hi_bpowtwop : 1 ≤ b ^ (2 * p)
hi_bpowpsubone : 1 ≤ b ^ (p - 1)
p_odd : Odd p
AB_not_prime : ¬Prime (A * B)
AB_id : A * B = (b ^ (2 * p) - 1) / (b ^ 2 - 1)
hd : b ^ 2 - 1 ∣ b ^ (2 * p) - 1
ha₁ : (b ^ 2 - 1) * (A * B - 1) = b * (b ^ (p - 1) - 1) * (b ^ p + b)
ha₂ : 2 ∣ b ^ p + b
ha₃ : p ∣ b ^ (p - 1) - 1
ha₄ : b ^ 2 - 1 ∣ b ^ (p - 1) - 1
ha₅ : 2 * p * (b ^ 2 - 1) ∣ (b ^ 2 - 1) * (A * B - 1)
ha₆ : 2 * p ∣ A * B - 1
this : A * B * (b ^ 2 - 1) = (b ^ (2 * p) - 1) / (b ^ 2 - 1) * (b ^ 2 - 1)
⊢ b ^ (2 * p) - 1 = A * B * (b ^ 2 - 1)
|
6f5ab4acf8539f9d
|
SSet.StrictSegal.isPointwiseRightKanExtensionAt.fac_aux₂
|
Mathlib/AlgebraicTopology/SimplicialSet/Coskeletal.lean
|
lemma fac_aux₂ {n : ℕ}
(s : Cone (proj (op ⦋n⦌) (Truncated.inclusion 2).op ⋙ (Truncated.inclusion 2).op ⋙ X))
(x : s.pt) (i j : ℕ) (hij : i ≤ j) (hj : j ≤ n) :
X.map (mkOfLe ⟨i, by omega⟩ ⟨j, by omega⟩ hij).op (lift s x) =
s.π.app (strArrowMk₂ (mkOfLe ⟨i, by omega⟩ ⟨j, by omega⟩ hij)) x
|
case intro.zero
X : SSet
inst✝ : X.StrictSegal
n : ℕ
s : Cone (proj (op ⦋n⦌) (Truncated.inclusion 2).op ⋙ (Truncated.inclusion 2).op ⋙ X)
x : s.pt
i : ℕ
hij : i ≤ i
hj : i ≤ n
this : mkOfLe ⟨i, ⋯⟩ ⟨i, ⋯⟩ ⋯ = ⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩
α : strArrowMk₂ (⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩) ⋯ ⟶ strArrowMk₂ (⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩) ⋯ :=
homMk (⦋1⦌.const ⦋0⦌ 0).op ⋯
⊢ X.map (⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩).op (lift s x) =
s.π.app (strArrowMk₂ (⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩) ⋯) x
|
have nat := congr_fun (s.π.naturality α) x
|
case intro.zero
X : SSet
inst✝ : X.StrictSegal
n : ℕ
s : Cone (proj (op ⦋n⦌) (Truncated.inclusion 2).op ⋙ (Truncated.inclusion 2).op ⋙ X)
x : s.pt
i : ℕ
hij : i ≤ i
hj : i ≤ n
this : mkOfLe ⟨i, ⋯⟩ ⟨i, ⋯⟩ ⋯ = ⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩
α : strArrowMk₂ (⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩) ⋯ ⟶ strArrowMk₂ (⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩) ⋯ :=
homMk (⦋1⦌.const ⦋0⦌ 0).op ⋯
nat :
(((Functor.const (StructuredArrow (op ⦋n⦌) (Truncated.inclusion 2).op)).obj s.pt).map α ≫
s.π.app (strArrowMk₂ (⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩) ⋯))
x =
(s.π.app (strArrowMk₂ (⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩) ⋯) ≫
(proj (op ⦋n⦌) (Truncated.inclusion 2).op ⋙ (Truncated.inclusion 2).op ⋙ X).map α)
x
⊢ X.map (⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩).op (lift s x) =
s.π.app (strArrowMk₂ (⦋1⦌.const ⦋0⦌ 0 ≫ ⦋0⦌.const ⦋n⦌ ⟨i, ⋯⟩) ⋯) x
|
764b0c7acb432811
|
MeasureTheory.stoppedProcess_eq'
|
Mathlib/Probability/Process/Stopping.lean
|
theorem stoppedProcess_eq' (n : ℕ) : stoppedProcess u τ n = Set.indicator {a | n + 1 ≤ τ a} (u n) +
∑ i ∈ Finset.range (n + 1), Set.indicator {a | τ a = i} (u i)
|
Ω : Type u_1
β : Type u_2
u : ℕ → Ω → β
τ : Ω → ℕ
inst✝ : AddCommMonoid β
n : ℕ
⊢ {a | n ≤ τ a}.indicator (u n) = {a | n + 1 ≤ τ a}.indicator (u n) + {a | τ a = n}.indicator (u n)
|
ext x
|
case h
Ω : Type u_1
β : Type u_2
u : ℕ → Ω → β
τ : Ω → ℕ
inst✝ : AddCommMonoid β
n : ℕ
x : Ω
⊢ {a | n ≤ τ a}.indicator (u n) x = ({a | n + 1 ≤ τ a}.indicator (u n) + {a | τ a = n}.indicator (u n)) x
|
30510ef3c36e238e
|
SzemerediRegularity.energy_increment
|
Mathlib/Combinatorics/SimpleGraph/Regularity/Increment.lean
|
theorem energy_increment (hP : P.IsEquipartition) (hP₇ : 7 ≤ #P.parts)
(hPε : 100 ≤ 4 ^ #P.parts * ε ^ 5) (hPα : #P.parts * 16 ^ #P.parts ≤ card α)
(hPG : ¬P.IsUniform G ε) (hε₀ : 0 ≤ ε) (hε₁ : ε ≤ 1) :
↑(P.energy G) + ε ^ 5 / 4 ≤ (increment hP G ε).energy G
|
case h₂
α : Type u_1
inst✝³ : Fintype α
inst✝² : DecidableEq α
P : Finpartition univ
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
inst✝ : Nonempty α
hP : P.IsEquipartition
hP₇ : 7 ≤ #P.parts
hPε : 100 ≤ 4 ^ #P.parts * ε ^ 5
hPα : #P.parts * 16 ^ #P.parts ≤ Fintype.card α
hPG : ↑(#P.parts.offDiag) * ε < ↑(#(P.nonUniforms G ε))
hε₀ : 0 ≤ ε
hε₁ : ε ≤ 1
⊢ 7 / 24 ≤ 22 / 75
|
norm_num
|
no goals
|
f9eb9daa7cfa4b0b
|
Prod.counit_comp_inl
|
Mathlib/RingTheory/Coalgebra/Basic.lean
|
theorem counit_comp_inl : counit ∘ₗ inl R A B = counit
|
case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : A
⊢ (counit ∘ₗ inl R A B) x✝ = counit x✝
|
simp
|
no goals
|
9e586911bcbb8889
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.assignmentsInvariant_insertRatUnits
|
Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.lean
|
theorem assignmentsInvariant_insertRatUnits {n : Nat} (f : DefaultFormula n)
(hf : f.ratUnits = #[] ∧ AssignmentsInvariant f) (units : CNF.Clause (PosFin n)) :
AssignmentsInvariant (insertRatUnits f units).1
|
case neg.h.left
n : Nat
f : DefaultFormula n
hf : f.ratUnits = #[] ∧ f.AssignmentsInvariant
units : CNF.Clause (PosFin n)
h :
let assignments := (f.insertRatUnits units).fst.assignments;
let_fun hsize := ⋯;
let ratUnits := (f.insertRatUnits units).fst.ratUnits;
InsertUnitInvariant f.assignments ⋯ ratUnits assignments hsize
hsize : (f.insertRatUnits units).fst.assignments.size = n
i : PosFin n
b : Bool
p : PosFin n → Bool
hp :
∀ (x : DefaultClause n),
(some x ∈ (f.insertRatUnits units).fst.clauses.toList ∨
(∃ a,
(a, false) ∈ (f.insertRatUnits units).fst.rupUnits.toList ∧ unit (a, false) = x ∨
(a, true) ∈ (f.insertRatUnits units).fst.rupUnits.toList ∧ unit (a, true) = x) ∨
∃ a,
(a, false) ∈ (f.insertRatUnits units).fst.ratUnits.toList ∧ unit (a, false) = x ∨
(a, true) ∈ (f.insertRatUnits units).fst.ratUnits.toList ∧ unit (a, true) = x) →
∃ a, (a, false) ∈ Clause.toList x ∧ decide (p a = false) = true ∨ (a, true) ∈ Clause.toList x ∧ p a = true
pf : p ⊨ f
j : Fin (f.insertRatUnits units).fst.ratUnits.size
b' : Bool
hb : hasAssignment b (addAssignment b' f.assignments[↑⟨i.val, ⋯⟩]) = true
i_gt_zero : ↑⟨i.val, ⋯⟩ > 0
h1✝ : (f.insertRatUnits units).fst.ratUnits[j] = (⟨↑⟨i.val, ⋯⟩, ⋯⟩, b')
h2 : (f.insertRatUnits units).fst.assignments[↑⟨i.val, ⋯⟩] = addAssignment b' f.assignments[↑⟨i.val, ⋯⟩]
h3 : ¬hasAssignment b' f.assignments[↑⟨i.val, ⋯⟩] = true
h4 :
∀ (k : Fin (f.insertRatUnits units).fst.ratUnits.size),
k ≠ j → (f.insertRatUnits units).fst.ratUnits[k].fst.val ≠ ↑⟨i.val, ⋯⟩
b_eq_b' : b = b'
j_unit : DefaultClause n := unit (f.insertRatUnits units).fst.ratUnits[j]
j_unit_def : j_unit = unit (f.insertRatUnits units).fst.ratUnits[j]
hb' : b' = false
h1 : (f.insertRatUnits units).fst.ratUnits[j] = (i, false)
⊢ (i, false) ∈ (f.insertRatUnits units).fst.ratUnits.toList
|
rw [← h1]
|
case neg.h.left
n : Nat
f : DefaultFormula n
hf : f.ratUnits = #[] ∧ f.AssignmentsInvariant
units : CNF.Clause (PosFin n)
h :
let assignments := (f.insertRatUnits units).fst.assignments;
let_fun hsize := ⋯;
let ratUnits := (f.insertRatUnits units).fst.ratUnits;
InsertUnitInvariant f.assignments ⋯ ratUnits assignments hsize
hsize : (f.insertRatUnits units).fst.assignments.size = n
i : PosFin n
b : Bool
p : PosFin n → Bool
hp :
∀ (x : DefaultClause n),
(some x ∈ (f.insertRatUnits units).fst.clauses.toList ∨
(∃ a,
(a, false) ∈ (f.insertRatUnits units).fst.rupUnits.toList ∧ unit (a, false) = x ∨
(a, true) ∈ (f.insertRatUnits units).fst.rupUnits.toList ∧ unit (a, true) = x) ∨
∃ a,
(a, false) ∈ (f.insertRatUnits units).fst.ratUnits.toList ∧ unit (a, false) = x ∨
(a, true) ∈ (f.insertRatUnits units).fst.ratUnits.toList ∧ unit (a, true) = x) →
∃ a, (a, false) ∈ Clause.toList x ∧ decide (p a = false) = true ∨ (a, true) ∈ Clause.toList x ∧ p a = true
pf : p ⊨ f
j : Fin (f.insertRatUnits units).fst.ratUnits.size
b' : Bool
hb : hasAssignment b (addAssignment b' f.assignments[↑⟨i.val, ⋯⟩]) = true
i_gt_zero : ↑⟨i.val, ⋯⟩ > 0
h1✝ : (f.insertRatUnits units).fst.ratUnits[j] = (⟨↑⟨i.val, ⋯⟩, ⋯⟩, b')
h2 : (f.insertRatUnits units).fst.assignments[↑⟨i.val, ⋯⟩] = addAssignment b' f.assignments[↑⟨i.val, ⋯⟩]
h3 : ¬hasAssignment b' f.assignments[↑⟨i.val, ⋯⟩] = true
h4 :
∀ (k : Fin (f.insertRatUnits units).fst.ratUnits.size),
k ≠ j → (f.insertRatUnits units).fst.ratUnits[k].fst.val ≠ ↑⟨i.val, ⋯⟩
b_eq_b' : b = b'
j_unit : DefaultClause n := unit (f.insertRatUnits units).fst.ratUnits[j]
j_unit_def : j_unit = unit (f.insertRatUnits units).fst.ratUnits[j]
hb' : b' = false
h1 : (f.insertRatUnits units).fst.ratUnits[j] = (i, false)
⊢ (f.insertRatUnits units).fst.ratUnits[j] ∈ (f.insertRatUnits units).fst.ratUnits.toList
|
b6d274376b14ee0b
|
le_total_of_codirected
|
Mathlib/Order/SuccPred/Archimedean.lean
|
lemma le_total_of_codirected {r v₁ v₂ : α} (h₁ : r ≤ v₁) (h₂ : r ≤ v₂) : v₁ ≤ v₂ ∨ v₂ ≤ v₁
|
case h.intro
α✝ : Type u_1
inst✝³ : Preorder α✝
α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α
n k : ℕ
h : n ≤ n + k
⊢ succ^[n] r ≤ succ^[k] (succ^[n] r)
|
apply Order.le_succ_iterate
|
no goals
|
18362a3552f3bbdf
|
LieModule.trace_toEnd_genWeightSpace
|
Mathlib/Algebra/Lie/Weights/Basic.lean
|
@[simp]
lemma trace_toEnd_genWeightSpace [IsDomain R] [IsPrincipalIdealRing R]
[Module.Free R M] [Module.Finite R M] (χ : L → R) (x : L) :
trace R _ (toEnd R L (genWeightSpace M χ) x) = finrank R (genWeightSpace M χ) • χ x
|
R : Type u_2
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
inst✝⁴ : LieRing.IsNilpotent L
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
inst✝¹ : Free R M
inst✝ : Module.Finite R M
χ : L → R
x : L
⊢ _root_.IsNilpotent ((toEnd R L ↥(genWeightSpace M χ)) x - (algebraMap R (End R ↥(genWeightSpace M χ))) (χ x))
|
exact isNilpotent_toEnd_sub_algebraMap M χ x
|
no goals
|
2105e30533b87f10
|
ProbabilityTheory.iIndepFun.integrable_exp_mul_sum
|
Mathlib/Probability/Moments/Basic.lean
|
theorem iIndepFun.integrable_exp_mul_sum [IsFiniteMeasure μ] {X : ι → Ω → ℝ}
(h_indep : iIndepFun (fun _ => inferInstance) X μ) (h_meas : ∀ i, Measurable (X i))
{s : Finset ι} (h_int : ∀ i ∈ s, Integrable (fun ω => exp (t * X i ω)) μ) :
Integrable (fun ω => exp (t * (∑ i ∈ s, X i) ω)) μ
|
case insert
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun x => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
i : ι
s : Finset ι
hi_notin_s : i ∉ s
h_rec : (∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ) → Integrable (fun ω => rexp (t * (∑ i ∈ s, X i) ω)) μ
h_int : ∀ i_1 ∈ insert i s, Integrable (fun ω => rexp (t * X i_1 ω)) μ
⊢ Integrable (fun ω => rexp (t * (∑ i ∈ insert i s, X i) ω)) μ
|
have : ∀ i : ι, i ∈ s → Integrable (fun ω : Ω => exp (t * X i ω)) μ := fun i hi =>
h_int i (mem_insert_of_mem hi)
|
case insert
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
X : ι → Ω → ℝ
h_indep : iIndepFun (fun x => inferInstance) X μ
h_meas : ∀ (i : ι), Measurable (X i)
i : ι
s : Finset ι
hi_notin_s : i ∉ s
h_rec : (∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ) → Integrable (fun ω => rexp (t * (∑ i ∈ s, X i) ω)) μ
h_int : ∀ i_1 ∈ insert i s, Integrable (fun ω => rexp (t * X i_1 ω)) μ
this : ∀ i ∈ s, Integrable (fun ω => rexp (t * X i ω)) μ
⊢ Integrable (fun ω => rexp (t * (∑ i ∈ insert i s, X i) ω)) μ
|
97e890d858de8868
|
Matrix.mulVec_zero
|
Mathlib/Data/Matrix/Mul.lean
|
theorem mulVec_zero [Fintype n] (A : Matrix m n α) : A *ᵥ 0 = 0
|
case h
m : Type u_2
n : Type u_3
α : Type v
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A : Matrix m n α
x✝ : m
⊢ (A *ᵥ 0) x✝ = 0 x✝
|
simp [mulVec]
|
no goals
|
faa1a119c9269cdc
|
IsLocalization.Away.sec_spec
|
Mathlib/RingTheory/Localization/Away/Basic.lean
|
lemma sec_spec (s : S) : s * (algebraMap R S) (x ^ (IsLocalization.Away.sec x s).2) =
algebraMap R S (IsLocalization.Away.sec x s).1
|
case e_a.h.e_6.h
R : Type u_1
inst✝³ : CommSemiring R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
x : R
inst✝ : Away x S
s : S
⊢ x ^ Exists.choose ⋯ = ↑(IsLocalization.sec (Submonoid.powers x) s).2
|
exact (IsLocalization.sec (Submonoid.powers x) s).2.property.choose_spec
|
no goals
|
ca7b7b572824d46a
|
Std.DHashMap.Internal.List.length_insertListIfNewUnit
|
Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean
|
theorem length_insertListIfNewUnit [BEq α] [EquivBEq α]
{l : List ((_ : α) × Unit)} {toInsert : List α}
(distinct_l : DistinctKeys l)
(distinct_toInsert : toInsert.Pairwise (fun a b => (a == b) = false))
(distinct_both : ∀ (a : α), containsKey a l → toInsert.contains a = false) :
(insertListIfNewUnit l toInsert).length = l.length + toInsert.length
|
case cons.distinct_both.inl
α : Type u
inst✝¹ : BEq α
inst✝ : EquivBEq α
hd : α
tl : List α
ih :
∀ {l : List ((_ : α) × Unit)},
DistinctKeys l →
List.Pairwise (fun a b => (a == b) = false) tl →
(∀ (a : α), containsKey a l = true → tl.contains a = false) →
(insertListIfNewUnit l tl).length = l.length + tl.length
l : List ((_ : α) × Unit)
distinct_l : DistinctKeys l
a : α
distinct_both : ∀ (a : α), containsKey a l = true → (a == hd || tl.contains a) = false
h : (hd == a) = true
distinct_toInsert : (∀ (a' : α), a' ∈ tl → (hd == a') = false) ∧ List.Pairwise (fun a b => (a == b) = false) tl
x : α
x_mem : x ∈ tl
⊢ (a == x) = false
|
rcases distinct_toInsert with ⟨left,_⟩
|
case cons.distinct_both.inl.intro
α : Type u
inst✝¹ : BEq α
inst✝ : EquivBEq α
hd : α
tl : List α
ih :
∀ {l : List ((_ : α) × Unit)},
DistinctKeys l →
List.Pairwise (fun a b => (a == b) = false) tl →
(∀ (a : α), containsKey a l = true → tl.contains a = false) →
(insertListIfNewUnit l tl).length = l.length + tl.length
l : List ((_ : α) × Unit)
distinct_l : DistinctKeys l
a : α
distinct_both : ∀ (a : α), containsKey a l = true → (a == hd || tl.contains a) = false
h : (hd == a) = true
x : α
x_mem : x ∈ tl
left : ∀ (a' : α), a' ∈ tl → (hd == a') = false
right✝ : List.Pairwise (fun a b => (a == b) = false) tl
⊢ (a == x) = false
|
952b24aae26e67fe
|
Finset.ruzsa_covering_mul
|
Mathlib/Combinatorics/Additive/RuzsaCovering.lean
|
theorem ruzsa_covering_mul (hB : B.Nonempty) (hK : #(A * B) ≤ K * #B) :
∃ F ⊆ A, #F ≤ K ∧ A ⊆ F * (B / B)
|
case pos
G : Type u_1
inst✝¹ : Group G
K : ℝ
inst✝ : DecidableEq G
A B : Finset G
hB : B.Nonempty
hK : ↑(#(A * B)) ≤ K * ↑(#B)
this : (F : Set G) → Decidable (F.PairwiseDisjoint fun x => x • B)
C : Finset (Finset G) := filter (fun F => (↑F).PairwiseDisjoint fun x => x • B) A.powerset
F : Finset G
hFmax : ∀ x ∈ C, ¬F < x
hFA : F ⊆ A
hF : (↑F).PairwiseDisjoint fun x => x • B
a : G
ha : a ∈ A
hau : a ∉ F
H : ∀ b ∈ F, Disjoint (a • B) (b • B)
⊢ (a ∈ A ∧ F ⊆ A) ∧ (insert a ↑F).PairwiseDisjoint fun x => x • B
|
exact ⟨⟨ha, hFA⟩, hF.insert fun _ hb _ ↦ H _ hb⟩
|
no goals
|
1d2e80669ecdd8c8
|
LieIdeal.map_comap_incl
|
Mathlib/Algebra/Lie/IdealOperations.lean
|
theorem map_comap_incl {I₁ I₂ : LieIdeal R L} : map I₁.incl (comap I₁.incl I₂) = I₁ ⊓ I₂
|
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
I₁ I₂ : LieIdeal R L
⊢ map I₁.incl (comap I₁.incl I₂) = I₁ ⊓ I₂
|
conv_rhs => rw [← I₁.incl_idealRange]
|
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
I₁ I₂ : LieIdeal R L
⊢ map I₁.incl (comap I₁.incl I₂) = I₁.incl.idealRange ⊓ I₂
|
f0fa7ad5ecbe808a
|
Polynomial.mem_aroots'
|
Mathlib/Algebra/Polynomial/Roots.lean
|
theorem mem_aroots' [CommRing S] [IsDomain S] [Algebra T S] {p : T[X]} {a : S} :
a ∈ p.aroots S ↔ p.map (algebraMap T S) ≠ 0 ∧ aeval a p = 0
|
S : Type v
T : Type w
inst✝³ : CommRing T
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
p : T[X]
a : S
⊢ a ∈ p.aroots S ↔ map (algebraMap T S) p ≠ 0 ∧ (aeval a) p = 0
|
rw [mem_roots', IsRoot.def, ← eval₂_eq_eval_map, aeval_def]
|
no goals
|
1964c592030336af
|
InnerProductGeometry.norm_add_eq_add_norm_iff_angle_eq_zero
|
Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
|
theorem norm_add_eq_add_norm_iff_angle_eq_zero {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
‖x + y‖ = ‖x‖ + ‖y‖ ↔ angle x y = 0
|
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ‖x‖ ^ 2 + 2 * inner x y + ‖y‖ ^ 2 = (‖x‖ + ‖y‖) ^ 2
hxy₁ : 0 ≤ ‖x + y‖
hxy₂ : 0 ≤ ‖x‖ + ‖y‖
⊢ inner x y = ((‖x‖ + ‖y‖) ^ 2 - ‖x‖ ^ 2 - ‖y‖ ^ 2) / 2
|
linarith
|
no goals
|
12c701cfc4191e1e
|
Turing.ToPartrec.cont_eval_fix
|
Mathlib/Computability/TMConfig.lean
|
theorem cont_eval_fix {f k v} (fok : Code.Ok f) :
Turing.eval step (stepNormal f (Cont.fix f k) v) =
f.fix.eval v >>= fun v => Turing.eval step (Cfg.ret k v)
|
case intro.intro.intro.intro
f : Code
k : Cont
v : List ℕ
fok : f.Ok
x : Cfg
this :
∀ (c : Cfg),
x ∈ eval step c →
∀ (v : List ℕ) (c' : Cfg),
c = c'.then (Cont.fix f k) →
Reaches step (stepNormal f Cont.halt v) c' →
∃ v₁ ∈ f.eval v,
∃ v₂ ∈ if v₁.headI = 0 then pure v₁.tail else f.fix.eval v₁.tail, x ∈ eval step (Cfg.ret k v₂)
h : x ∈ eval step (stepNormal f (Cont.fix f k) v)
v₁ : List ℕ
hv₁ : v₁ ∈ f.eval v
v₂ : List ℕ
hv₂ : v₂ ∈ if v₁.headI = 0 then pure v₁.tail else f.fix.eval v₁.tail
h₃ : x ∈ eval step (Cfg.ret k v₂)
⊢ Sum.inl v₂ ∈ Part.some (if v₁.headI = 0 then Sum.inl v₁.tail else Sum.inr v₁.tail) ∨
∃ a',
Sum.inr a' ∈ Part.some (if v₁.headI = 0 then Sum.inl v₁.tail else Sum.inr v₁.tail) ∧
v₂ ∈
PFun.fix (fun v => Part.map (fun v => if v.headI = 0 then Sum.inl v.tail else Sum.inr v.tail) (f.eval v)) a'
|
split_ifs at hv₂ ⊢
|
case pos
f : Code
k : Cont
v : List ℕ
fok : f.Ok
x : Cfg
this :
∀ (c : Cfg),
x ∈ eval step c →
∀ (v : List ℕ) (c' : Cfg),
c = c'.then (Cont.fix f k) →
Reaches step (stepNormal f Cont.halt v) c' →
∃ v₁ ∈ f.eval v,
∃ v₂ ∈ if v₁.headI = 0 then pure v₁.tail else f.fix.eval v₁.tail, x ∈ eval step (Cfg.ret k v₂)
h : x ∈ eval step (stepNormal f (Cont.fix f k) v)
v₁ : List ℕ
hv₁ : v₁ ∈ f.eval v
v₂ : List ℕ
h₃ : x ∈ eval step (Cfg.ret k v₂)
h✝ : v₁.headI = 0
hv₂ : v₂ ∈ pure v₁.tail
⊢ Sum.inl v₂ ∈ Part.some (Sum.inl v₁.tail) ∨
∃ a',
Sum.inr a' ∈ Part.some (Sum.inl v₁.tail) ∧
v₂ ∈
PFun.fix (fun v => Part.map (fun v => if v.headI = 0 then Sum.inl v.tail else Sum.inr v.tail) (f.eval v)) a'
case neg
f : Code
k : Cont
v : List ℕ
fok : f.Ok
x : Cfg
this :
∀ (c : Cfg),
x ∈ eval step c →
∀ (v : List ℕ) (c' : Cfg),
c = c'.then (Cont.fix f k) →
Reaches step (stepNormal f Cont.halt v) c' →
∃ v₁ ∈ f.eval v,
∃ v₂ ∈ if v₁.headI = 0 then pure v₁.tail else f.fix.eval v₁.tail, x ∈ eval step (Cfg.ret k v₂)
h : x ∈ eval step (stepNormal f (Cont.fix f k) v)
v₁ : List ℕ
hv₁ : v₁ ∈ f.eval v
v₂ : List ℕ
h₃ : x ∈ eval step (Cfg.ret k v₂)
h✝ : ¬v₁.headI = 0
hv₂ : v₂ ∈ f.fix.eval v₁.tail
⊢ Sum.inl v₂ ∈ Part.some (Sum.inr v₁.tail) ∨
∃ a',
Sum.inr a' ∈ Part.some (Sum.inr v₁.tail) ∧
v₂ ∈
PFun.fix (fun v => Part.map (fun v => if v.headI = 0 then Sum.inl v.tail else Sum.inr v.tail) (f.eval v)) a'
|
4a2318a05b9f1866
|
Nat.Squarefree.ext_iff
|
Mathlib/Data/Nat/Squarefree.lean
|
theorem Squarefree.ext_iff {n m : ℕ} (hn : Squarefree n) (hm : Squarefree m) :
n = m ↔ ∀ p, Prime p → (p ∣ n ↔ p ∣ m)
|
n m : ℕ
hn : Squarefree n
hm : Squarefree m
⊢ n = m ↔ ∀ (p : ℕ), Prime p → (p ∣ n ↔ p ∣ m)
|
refine ⟨by rintro rfl; simp, fun h => eq_of_factorization_eq hn.ne_zero hm.ne_zero fun p => ?_⟩
|
n m : ℕ
hn : Squarefree n
hm : Squarefree m
h : ∀ (p : ℕ), Prime p → (p ∣ n ↔ p ∣ m)
p : ℕ
⊢ n.factorization p = m.factorization p
|
85f7936cc1cdd615
|
ProbabilityTheory.Kernel.IsFiniteKernel.integrable
|
Mathlib/Probability/Kernel/Integral.lean
|
lemma IsFiniteKernel.integrable (μ : Measure α) [IsFiniteMeasure μ]
(κ : Kernel α β) [IsFiniteKernel κ] {s : Set β} (hs : MeasurableSet s) :
Integrable (fun x ↦ (κ x s).toReal) μ
|
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
inst✝¹ : IsFiniteMeasure μ
κ : Kernel α β
inst✝ : IsFiniteKernel κ
s : Set β
hs : MeasurableSet s
x : α
⊢ ‖((κ x) s).toReal‖ ≤ (IsFiniteKernel.bound κ).toReal
|
rw [Real.norm_eq_abs, abs_of_nonneg ENNReal.toReal_nonneg]
|
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
inst✝¹ : IsFiniteMeasure μ
κ : Kernel α β
inst✝ : IsFiniteKernel κ
s : Set β
hs : MeasurableSet s
x : α
⊢ ((κ x) s).toReal ≤ (IsFiniteKernel.bound κ).toReal
|
21b577f54532daa9
|
HasCompactSupport.integral_Ioi_deriv_eq
|
Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
|
theorem _root_.HasCompactSupport.integral_Ioi_deriv_eq (hf : ContDiff ℝ 1 f)
(h2f : HasCompactSupport f) (b : ℝ) : ∫ x in Ioi b, deriv f x = - f b
|
E : Type u_1
f : ℝ → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : HasCompactSupport f
b : ℝ
⊢ ∫ (x : ℝ) in Ioi b, deriv f x = -f b
|
have := fun x (_ : x ∈ Ioi b) ↦ hf.differentiable le_rfl x |>.hasDerivAt
|
E : Type u_1
f : ℝ → E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : HasCompactSupport f
b : ℝ
this : ∀ x ∈ Ioi b, HasDerivAt f (deriv f x) x
⊢ ∫ (x : ℝ) in Ioi b, deriv f x = -f b
|
94ee06e2341b0c23
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.