Dataset Viewer
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
|
|---|---|---|---|---|---|---|
Matroid.uniqueBaseOn_dual_eq | Mathlib/Data/Matroid/Constructions.lean | theorem uniqueBaseOn_dual_eq (I E : Set α) :
(uniqueBaseOn I E)✶ = uniqueBaseOn (E \ I) E | α : Type u_1
I E B : Set α
hB : B ⊆ E
h : B = E \ I
⊢ E \ B = I ∩ E | rw [h, inter_comm I] | α : Type u_1
I E B : Set α
hB : B ⊆ E
h : B = E \ I
⊢ E \ (E \ I) = E ∩ I | 60744eced319574b |
Finsupp.linearCombinationOn_range | Mathlib/LinearAlgebra/Finsupp/LinearCombination.lean | theorem linearCombinationOn_range (s : Set α) :
LinearMap.range (linearCombinationOn α M R v s) = ⊤ | α : Type u_1
M : Type u_2
R : Type u_5
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
v : α → M
s : Set α
⊢ span R (v '' s) ≤ map (linearCombination R v) (supported R R s) | exact (span_image_eq_map_linearCombination _ _).le | no goals | 5d96391416327877 |
CoxeterSystem.prod_alternatingWord_eq_prod_alternatingWord_sub | Mathlib/GroupTheory/Coxeter/Basic.lean | theorem prod_alternatingWord_eq_prod_alternatingWord_sub (i i' : B) (m : ℕ) (hm : m ≤ M i i' * 2) :
π (alternatingWord i i' m) = π (alternatingWord i' i (M i i' * 2 - m)) | B : Type u_1
W : Type u_3
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m : ℕ
hm : m ≤ M.M i i' * 2
⊢ (if Even ↑m then 1 else cs.simple i') * (cs.simple i * cs.simple i') ^ (↑m / ↑2) =
(if Even (↑(M.M i i' * 2) - ↑m) then 1 else cs.simple i) *
(cs.simple i' * cs.simple i) ^ ((↑(M.M i i' * 2) - ↑m) / ↑2) | generalize (m : ℤ) = m' | B : Type u_1
W : Type u_3
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m : ℕ
hm : m ≤ M.M i i' * 2
m' : ℤ
⊢ (if Even m' then 1 else cs.simple i') * (cs.simple i * cs.simple i') ^ (m' / ↑2) =
(if Even (↑(M.M i i' * 2) - m') then 1 else cs.simple i) *
(cs.simple i' * cs.simple i) ^ ((↑(M.M i i' * 2) - m') / ↑2) | 8b276f2d43ad82bd |
IsCompactlyGenerated.BooleanGenerators.sSup_inter | Mathlib/Order/BooleanGenerators.lean | lemma sSup_inter (hS : BooleanGenerators S) {T₁ T₂ : Set α} (hT₁ : T₁ ⊆ S) (hT₂ : T₂ ⊆ S) :
sSup (T₁ ∩ T₂) = (sSup T₁) ⊓ (sSup T₂) | case a.a
α : Type u_1
inst✝¹ : CompleteLattice α
S : Set α
inst✝ : IsCompactlyGenerated α
hS : BooleanGenerators S
T₁ T₂ : Set α
hT₁ : T₁ ⊆ S
hT₂ : T₂ ⊆ S
⊢ sSup (T₁ ∩ T₂) ≤ sSup T₁ | apply sSup_le_sSup Set.inter_subset_left | no goals | 7804e1cb5854118b |
CategoryTheory.ShortComplex.exact_iff_mono | Mathlib/Algebra/Homology/ShortComplex/Exact.lean | lemma exact_iff_mono [HasZeroObject C] (hf : S.f = 0) :
S.Exact ↔ Mono S.g | case mp
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
S : ShortComplex C
inst✝ : HasZeroObject C
hf : S.f = 0
this✝ : S.HasHomology
h : IsZero S.homology
this : IsIso S.pOpcycles
⊢ Mono S.g | have := mono_of_isZero_kernel' _ S.homologyIsKernel h | case mp
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
S : ShortComplex C
inst✝ : HasZeroObject C
hf : S.f = 0
this✝¹ : S.HasHomology
h : IsZero S.homology
this✝ : IsIso S.pOpcycles
this : Mono S.fromOpcycles
⊢ Mono S.g | f4e5eedef442a362 |
Real.sign_eq_zero_iff | Mathlib/Data/Real/Sign.lean | theorem sign_eq_zero_iff {r : ℝ} : sign r = 0 ↔ r = 0 | case inl
r : ℝ
h : r.sign = 0
hn : r < 0
⊢ r = 0 | rw [sign_of_neg hn, neg_eq_zero] at h | case inl
r : ℝ
h : 1 = 0
hn : r < 0
⊢ r = 0 | 2e6f33eeda35157a |
WeierstrassCurve.exists_variableChange_of_char_two | Mathlib/AlgebraicGeometry/EllipticCurve/IsomOfJ.lean | private lemma exists_variableChange_of_char_two (heq : E.j = E'.j) :
∃ C : VariableChange F, E.variableChange C = E' | case intro.of_j_ne_zero.intro.of_j_ne_zero
F : Type u_1
inst✝⁶ : Field F
inst✝⁵ : IsSepClosed F
E E' : WeierstrassCurve F
inst✝⁴ : E.IsElliptic
inst✝³ : E'.IsElliptic
inst✝² : CharP F 2
heq : E.j = E'.j
C : VariableChange F
inst✝¹ : (E.variableChange C).IsCharTwoJNeZeroNF
C' : VariableChange F
inst✝ : (E'.variableChange C').IsCharTwoJNeZeroNF
⊢ ∃ C, E.variableChange C = E' | simp_rw [← variableChange_j E C, ← variableChange_j E' C',
j_of_isCharTwoJNeZeroNF_of_char_two, one_div, inv_inj] at heq | case intro.of_j_ne_zero.intro.of_j_ne_zero
F : Type u_1
inst✝⁶ : Field F
inst✝⁵ : IsSepClosed F
E E' : WeierstrassCurve F
inst✝⁴ : E.IsElliptic
inst✝³ : E'.IsElliptic
inst✝² : CharP F 2
C : VariableChange F
inst✝¹ : (E.variableChange C).IsCharTwoJNeZeroNF
C' : VariableChange F
inst✝ : (E'.variableChange C').IsCharTwoJNeZeroNF
heq : (E.variableChange C).a₆ = (E'.variableChange C').a₆
⊢ ∃ C, E.variableChange C = E' | 777fc2b6b6b2f928 |
Std.Sat.CNF.nonempty_or_impossible | Mathlib/.lake/packages/lean4/src/lean/Std/Sat/CNF/Relabel.lean | theorem nonempty_or_impossible (f : CNF α) : Nonempty α ∨ ∃ n, f = List.replicate n [] | case nil
α : Type u_1
⊢ Nonempty α ∨ ∃ n, [] = List.replicate n [] | exact Or.inr ⟨0, rfl⟩ | no goals | eb153cbe9df80b19 |
MeasureTheory.ae_nonneg_of_forall_setIntegral_nonneg | Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean | theorem ae_nonneg_of_forall_setIntegral_nonneg (hf : Integrable f μ)
(hf_zero : ∀ s, MeasurableSet s → μ s < ∞ → 0 ≤ ∫ x in s, f x ∂μ) : 0 ≤ᵐ[μ] f | α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : Integrable f μ
hf_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
b : ℝ
hb_neg : b < 0
s : Set α := {x | f x ≤ b}
hs : NullMeasurableSet s μ
mus : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ, x ∈ s → f x ≤ b | exact Eventually.of_forall fun x hxs => hxs | no goals | d52a385303ec1354 |
MvPowerSeries.WithPiTopology.tendsto_pow_of_constantCoeff_nilpotent_iff | Mathlib/RingTheory/MvPowerSeries/PiTopology.lean | theorem tendsto_pow_of_constantCoeff_nilpotent_iff [CommRing R] [DiscreteTopology R] (f) :
Tendsto (fun n : ℕ => f ^ n) atTop (nhds 0) ↔
IsNilpotent (constantCoeff σ R f) | σ : Type u_1
R : Type u_2
inst✝² : TopologicalSpace R
inst✝¹ : CommRing R
inst✝ : DiscreteTopology R
f : MvPowerSeries σ R
h : Tendsto (fun n => f ^ n) atTop (nhds 0)
this : Tendsto (fun n => (constantCoeff σ R) (f ^ n)) atTop (nhds 0)
⊢ IsNilpotent ((constantCoeff σ R) f) | simp only [tendsto_def] at this | σ : Type u_1
R : Type u_2
inst✝² : TopologicalSpace R
inst✝¹ : CommRing R
inst✝ : DiscreteTopology R
f : MvPowerSeries σ R
h : Tendsto (fun n => f ^ n) atTop (nhds 0)
this : ∀ s ∈ nhds 0, (fun n => (constantCoeff σ R) (f ^ n)) ⁻¹' s ∈ atTop
⊢ IsNilpotent ((constantCoeff σ R) f) | 75b216f0c0004b82 |
RCLike.add_conj | Mathlib/Analysis/RCLike/Basic.lean | theorem add_conj (z : K) : z + conj z = 2 * re z :=
calc
z + conj z = re z + im z * I + (re z - im z * I) | K : Type u_1
inst✝ : RCLike K
z : K
⊢ ↑(re z) + ↑(im z) * I + (↑(re z) - ↑(im z) * I) = 2 * ↑(re z) | rw [add_add_sub_cancel, two_mul] | no goals | 935131c31d9ee0b1 |
Array.exists_of_eraseP | Mathlib/.lake/packages/lean4/src/lean/Init/Data/Array/Erase.lean | theorem exists_of_eraseP {l : Array α} {a} (hm : a ∈ l) (hp : p a) :
∃ a l₁ l₂, (∀ b ∈ l₁, ¬p b) ∧ p a ∧ l = l₁.push a ++ l₂ ∧ l.eraseP p = l₁ ++ l₂ | α : Type u_1
p : α → Bool
l : Array α
a : α
hm : a ∈ l
hp : p a = true
⊢ ∃ a l₁ l₂, (∀ (b : α), b ∈ l₁ → ¬p b = true) ∧ p a = true ∧ l = l₁.push a ++ l₂ ∧ l.eraseP p = l₁ ++ l₂ | rcases l with ⟨l⟩ | case mk
α : Type u_1
p : α → Bool
a : α
hp : p a = true
l : List α
hm : a ∈ { toList := l }
⊢ ∃ a l₁ l₂,
(∀ (b : α), b ∈ l₁ → ¬p b = true) ∧
p a = true ∧ { toList := l } = l₁.push a ++ l₂ ∧ { toList := l }.eraseP p = l₁ ++ l₂ | 3081e6f43f7730fa |
Matrix.zpow_sub_one | Mathlib/LinearAlgebra/Matrix/ZPow.lean | theorem zpow_sub_one {A : M} (h : IsUnit A.det) (n : ℤ) : A ^ (n - 1) = A ^ n * A⁻¹ :=
calc
A ^ (n - 1) = A ^ (n - 1) * A * A⁻¹ | n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℤ
⊢ A ^ (n - 1) = A ^ (n - 1) * A * A⁻¹ | rw [mul_assoc, mul_nonsing_inv _ h, mul_one] | no goals | 21343db4aa6e3915 |
Complex.norm_sub_mem_Icc_angle | Mathlib/Analysis/Complex/Angle.lean | /-- Chord-length is a multiple of arc-length up to constants. -/
lemma norm_sub_mem_Icc_angle (hx : ‖x‖ = 1) (hy : ‖y‖ = 1) :
‖x - y‖ ∈ Icc (2 / π * angle x y) (angle x y) | x y : ℂ
hy : ‖1‖ = 1
θ : ℝ
hθ : θ ∈ Ioc (-π) π
⊢ 2 * (1 - Real.cos θ) = (Real.cos θ - 1) ^ 2 + Real.sin θ ^ 2 | linear_combination -θ.cos_sq_add_sin_sq | no goals | 5f1a2d709d27832f |
UniformSpace.secondCountable_of_separable | Mathlib/Topology/UniformSpace/Cauchy.lean | theorem secondCountable_of_separable [SeparableSpace α] : SecondCountableTopology α | case intro.intro.intro.intro.refine_2.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
uniformSpace : UniformSpace α
inst✝¹ : (𝓤 α).IsCountablyGenerated
inst✝ : SeparableSpace α
s : Set α
hsc : s.Countable
hsd : Dense s
t : ℕ → Set (α × α)
h_basis : (𝓤 α).HasAntitoneBasis t
ht_mem : ∀ (i : ℕ), t i ∈ (𝓤 α).sets
hto : ∀ (i : ℕ), IsOpen (t i)
hts : ∀ (i : ℕ), SymmetricRel (t i)
x : α
V : Set α
hxV : x ∈ V
hVo : IsOpen V
U : Set (α × α)
hU : U ∈ 𝓤 α
hUV : ball x U ⊆ V
U' : Set (α × α)
hU' : U' ∈ 𝓤 α
left✝ : ∀ {a b : α}, (a, b) ∈ U' → (b, a) ∈ U'
hUU' : U' ○ U' ⊆ U
k : ℕ
hk : t k ⊆ U'
y : α
hxy : y ∈ ball x (t k)
hys : y ∈ s
⊢ ∃ v, (∃ i ∈ s, ∃ y, ball i (t y) = v) ∧ x ∈ v ∧ v ⊆ V | refine ⟨_, ⟨y, hys, k, rfl⟩, (hts k).subset hxy, fun z hz => ?_⟩ | case intro.intro.intro.intro.refine_2.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
uniformSpace : UniformSpace α
inst✝¹ : (𝓤 α).IsCountablyGenerated
inst✝ : SeparableSpace α
s : Set α
hsc : s.Countable
hsd : Dense s
t : ℕ → Set (α × α)
h_basis : (𝓤 α).HasAntitoneBasis t
ht_mem : ∀ (i : ℕ), t i ∈ (𝓤 α).sets
hto : ∀ (i : ℕ), IsOpen (t i)
hts : ∀ (i : ℕ), SymmetricRel (t i)
x : α
V : Set α
hxV : x ∈ V
hVo : IsOpen V
U : Set (α × α)
hU : U ∈ 𝓤 α
hUV : ball x U ⊆ V
U' : Set (α × α)
hU' : U' ∈ 𝓤 α
left✝ : ∀ {a b : α}, (a, b) ∈ U' → (b, a) ∈ U'
hUU' : U' ○ U' ⊆ U
k : ℕ
hk : t k ⊆ U'
y : α
hxy : y ∈ ball x (t k)
hys : y ∈ s
z : α
hz : z ∈ ball y (t k)
⊢ z ∈ V | 4ad08f66c78319f3 |
Std.Tactic.BVDecide.BVExpr.bitblast.go_decl_eq | Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.lean | theorem bitblast.go_decl_eq (aig : AIG BVBit) (expr : BVExpr w) :
∀ (idx : Nat) (h1) (h2), (go aig expr).val.aig.decls[idx]'h2 = aig.decls[idx]'h1 | case const
w idx w✝ : Nat
val✝ : BitVec w✝
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (const val✝)).val.aig.decls.size
⊢ (go aig (const val✝)).val.aig.decls[idx] = aig.decls[idx] | dsimp only [go] | case const
w idx w✝ : Nat
val✝ : BitVec w✝
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (const val✝)).val.aig.decls.size
⊢ (blastConst aig val✝).aig.decls[idx] = aig.decls[idx] | f92988d5a1595b39 |
ContinuousMultilinearMap.changeOrigin_toFormalMultilinearSeries | Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | theorem changeOrigin_toFormalMultilinearSeries [DecidableEq ι] :
continuousMultilinearCurryFin1 𝕜 (∀ i, E i) F (f.toFormalMultilinearSeries.changeOrigin x 1) =
f.linearDeriv x | case h.inr
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝³ : (i : ι) → NormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
x : (i : ι) → E i
inst✝ : DecidableEq ι
y : (i : ι) → E i
h✝ : Nonempty ι
⊢ (∑ a : { s // #s = Fintype.card ι - 1 },
((f.toFormalMultilinearSeries.changeOriginSeriesTerm 1 (Fintype.card ι - 1) ↑a ⋯) fun x_1 => x) fun x => y) =
∑ i : ι, f (Function.update x i (y i)) | simp_rw [changeOriginSeriesTerm_apply] | case h.inr
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝³ : (i : ι) → NormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
x : (i : ι) → E i
inst✝ : DecidableEq ι
y : (i : ι) → E i
h✝ : Nonempty ι
⊢ ∑ x_1 : { s // #s = Fintype.card ι - 1 },
(f.toFormalMultilinearSeries (1 + (Fintype.card ι - 1))) ((↑x_1).piecewise (fun x_2 => x) fun x => y) =
∑ i : ι, f (Function.update x i (y i)) | d7dded01cf2a4e1b |
QuaternionAlgebra.Basis.lift_mul | Mathlib/Algebra/QuaternionBasis.lean | theorem lift_mul (x y : ℍ[R,c₁,c₂,c₃]) : q.lift (x * y) = q.lift x * q.lift y | R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
c₁ c₂ c₃ : R
q : Basis A c₁ c₂ c₃
x y : ℍ[R,c₁,c₂,c₃]
⊢ (x * y).re • 1 + (x * y).imI • q.i + (x * y).imJ • q.j + (x * y).imK • q.k =
(x.re * y.re) • 1 + (x.re * y.imI) • q.i + (x.re * y.imJ) • q.j + (x.re * y.imK) • q.k + (x.imI * y.re) • q.i +
(x.imI * y.imI) • (c₁ • 1 + c₂ • q.i) +
(x.imI * y.imJ) • q.k +
(x.imI * y.imK) • (c₁ • q.j + c₂ • q.k) +
(x.imJ * y.re) • q.j +
(x.imJ * y.imI) • (c₂ • q.j + -q.k) +
(x.imJ * c₃ * y.imJ) • 1 +
(x.imJ * y.imK) • ((c₂ * c₃) • 1 + -(c₃ • q.i)) +
(x.imK * y.re) • q.k +
-((c₁ * x.imK * y.imI) • q.j) +
(x.imK * c₃ * y.imJ) • q.i +
-((c₁ * c₃ * x.imK * y.imK) • 1) | simp only [mul_re, sub_eq_add_neg, add_smul, neg_smul, mul_imI, ← add_assoc, mul_imJ, mul_imK] | R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
c₁ c₂ c₃ : R
q : Basis A c₁ c₂ c₃
x y : ℍ[R,c₁,c₂,c₃]
⊢ (x.re * y.re) • 1 + (c₁ * x.imI * y.imI) • 1 + (c₃ * x.imJ * y.imJ) • 1 + (c₂ * c₃ * x.imJ * y.imK) • 1 +
-((c₁ * c₃ * x.imK * y.imK) • 1) +
(x.re * y.imI) • q.i +
(x.imI * y.re) • q.i +
(c₂ * x.imI * y.imI) • q.i +
-((c₃ * x.imJ * y.imK) • q.i) +
(c₃ * x.imK * y.imJ) • q.i +
(x.re * y.imJ) • q.j +
(c₁ * x.imI * y.imK) • q.j +
(x.imJ * y.re) • q.j +
(c₂ * x.imJ * y.imI) • q.j +
-((c₁ * x.imK * y.imI) • q.j) +
(x.re * y.imK) • q.k +
(x.imI * y.imJ) • q.k +
(c₂ * x.imI * y.imK) • q.k +
-((x.imJ * y.imI) • q.k) +
(x.imK * y.re) • q.k =
(x.re * y.re) • 1 + (x.re * y.imI) • q.i + (x.re * y.imJ) • q.j + (x.re * y.imK) • q.k + (x.imI * y.re) • q.i +
(x.imI * y.imI) • (c₁ • 1 + c₂ • q.i) +
(x.imI * y.imJ) • q.k +
(x.imI * y.imK) • (c₁ • q.j + c₂ • q.k) +
(x.imJ * y.re) • q.j +
(x.imJ * y.imI) • (c₂ • q.j + -q.k) +
(x.imJ * c₃ * y.imJ) • 1 +
(x.imJ * y.imK) • ((c₂ * c₃) • 1 + -(c₃ • q.i)) +
(x.imK * y.re) • q.k +
-((c₁ * x.imK * y.imI) • q.j) +
(x.imK * c₃ * y.imJ) • q.i +
-((c₁ * c₃ * x.imK * y.imK) • 1) | 09bfbbd836e86c34 |
CategoryTheory.Dial.tensor_comp | Mathlib/CategoryTheory/Dialectica/Monoidal.lean | theorem tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : Dial C}
(f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂) :
tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom f₁ f₂ ≫ tensorHom g₁ g₂ | C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ Y₁ Z₁ X₂ Y₂ Z₂ : Dial C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
g₁ : Y₁ ⟶ Z₁
g₂ : Y₂ ⟶ Z₂
⊢ tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom f₁ f₂ ≫ tensorHom g₁ g₂ | ext <;> simp | case hF
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ Y₁ Z₁ X₂ Y₂ Z₂ : Dial C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
g₁ : Y₁ ⟶ Z₁
g₂ : Y₂ ⟶ Z₂
⊢ π(prod.map π₁ π₁ ≫ π(π₁, prod.map f₁.f (𝟙 Z₁.tgt) ≫ g₁.F) ≫ f₁.F,
prod.map π₂ π₂ ≫ π(π₁, prod.map f₂.f (𝟙 Z₂.tgt) ≫ g₂.F) ≫ f₂.F) =
π(π(π₁ ≫ π₁, prod.map (π₁ ≫ f₁.f) π₁ ≫ g₁.F) ≫ f₁.F, π(π₁ ≫ π₂, prod.map (π₂ ≫ f₂.f) π₂ ≫ g₂.F) ≫ f₂.F) | 1e9289a58304a4a7 |
Module.support_of_noZeroSMulDivisors | Mathlib/RingTheory/Support.lean | lemma Module.support_of_noZeroSMulDivisors [NoZeroSMulDivisors R M] [Nontrivial M] :
Module.support R M = Set.univ | R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : Nontrivial M
⊢ support R M = Set.univ | simp only [Set.eq_univ_iff_forall, mem_support_iff', ne_eq, smul_eq_zero, not_or] | R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : Nontrivial M
⊢ ∀ (x : PrimeSpectrum R), ∃ m, ∀ r ∉ x.asIdeal, ¬r = 0 ∧ ¬m = 0 | 40f3ce29daf90d9a |
Ordinal.CNF_sorted | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | theorem CNF_sorted (b o : Ordinal) : ((CNF b o).map Prod.fst).Sorted (· > ·) | b o : Ordinal.{u_1}
⊢ Sorted (fun x1 x2 => x1 > x2) (map Prod.fst (CNF b o)) | refine CNFRec b ?_ (fun o ho IH ↦ ?_) o | case refine_1
b o : Ordinal.{u_1}
⊢ Sorted (fun x1 x2 => x1 > x2) (map Prod.fst (CNF b 0))
case refine_2
b o✝ o : Ordinal.{u_1}
ho : o ≠ 0
IH : Sorted (fun x1 x2 => x1 > x2) (map Prod.fst (CNF b (o % b ^ log b o)))
⊢ Sorted (fun x1 x2 => x1 > x2) (map Prod.fst (CNF b o)) | d982c7966c162266 |
interior_subset_gauge_lt_one | Mathlib/Analysis/Convex/Gauge.lean | theorem interior_subset_gauge_lt_one (s : Set E) : interior s ⊆ { x | gauge s x < 1 } | E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s : Set E
⊢ interior s ⊆ {x | gauge s x < 1} | intro x hx | E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s : Set E
x : E
hx : x ∈ interior s
⊢ x ∈ {x | gauge s x < 1} | 3cd737264597e0ba |
PMF.support_normalize | Mathlib/Probability/ProbabilityMassFunction/Constructions.lean | theorem support_normalize : (normalize f hf0 hf).support = Function.support f :=
Set.ext fun a => by simp [hf, mem_support_iff]
| α : Type u_1
f : α → ℝ≥0∞
hf0 : tsum f ≠ 0
hf : tsum f ≠ ⊤
a : α
⊢ a ∈ (normalize f hf0 hf).support ↔ a ∈ Function.support f | simp [hf, mem_support_iff] | no goals | 6e34b3d5b5061659 |
continuousAt_gauge_zero | Mathlib/Analysis/Convex/Gauge.lean | theorem continuousAt_gauge_zero (hs : s ∈ 𝓝 0) : ContinuousAt (gauge s) 0 | E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s : Set E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs : s ∈ 𝓝 0
⊢ ContinuousAt (gauge s) 0 | rw [ContinuousAt, gauge_zero] | E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s : Set E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs : s ∈ 𝓝 0
⊢ Tendsto (gauge s) (𝓝 0) (𝓝 0) | 5dd1f9e9b5f3bede |
t2_separation_compact_nhds | Mathlib/Topology/Separation/Hausdorff.lean | theorem t2_separation_compact_nhds [LocallyCompactSpace X] [T2Space X] {x y : X} (h : x ≠ y) :
∃ u v, u ∈ 𝓝 x ∧ v ∈ 𝓝 y ∧ IsCompact u ∧ IsCompact v ∧ Disjoint u v | X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : LocallyCompactSpace X
inst✝ : T2Space X
x y : X
h : x ≠ y
⊢ ∃ u v, u ∈ 𝓝 x ∧ v ∈ 𝓝 y ∧ IsCompact u ∧ IsCompact v ∧ Disjoint u v | simpa only [exists_prop, ← exists_and_left, and_comm, and_assoc, and_left_comm] using
((compact_basis_nhds x).disjoint_iff (compact_basis_nhds y)).1 (disjoint_nhds_nhds.2 h) | no goals | ee342c49880ccde1 |
sum_mul_eq_sub_integral_mul₀ | Mathlib/NumberTheory/AbelSummation.lean | theorem sum_mul_eq_sub_integral_mul₀ (hc : c 0 = 0) (b : ℝ)
(hf_diff : ∀ t ∈ Set.Icc 1 b, DifferentiableAt ℝ f t)
(hf_int : IntegrableOn (deriv f) (Set.Icc 1 b)) :
∑ k ∈ Icc 0 ⌊b⌋₊, f k * c k =
f b * (∑ k ∈ Icc 0 ⌊b⌋₊, c k) - ∫ t in Set.Ioc 1 b, deriv f t * ∑ k ∈ Icc 0 ⌊t⌋₊, c k | 𝕜 : Type u_1
inst✝ : RCLike 𝕜
c : ℕ → 𝕜
f : ℝ → 𝕜
hc : c 0 = 0
b : ℝ
hf_diff : ∀ t ∈ Set.Icc 1 b, DifferentiableAt ℝ f t
hf_int : IntegrableOn (deriv f) (Set.Icc 1 b) volume
⊢ ∑ k ∈ Icc 0 ⌊b⌋₊, f ↑k * c k =
f b * ∑ k ∈ Icc 0 ⌊b⌋₊, c k - ∫ (t : ℝ) in Set.Ioc 1 b, deriv f t * ∑ k ∈ Icc 0 ⌊t⌋₊, c k | obtain hb | hb := le_or_gt 1 b | case inl
𝕜 : Type u_1
inst✝ : RCLike 𝕜
c : ℕ → 𝕜
f : ℝ → 𝕜
hc : c 0 = 0
b : ℝ
hf_diff : ∀ t ∈ Set.Icc 1 b, DifferentiableAt ℝ f t
hf_int : IntegrableOn (deriv f) (Set.Icc 1 b) volume
hb : 1 ≤ b
⊢ ∑ k ∈ Icc 0 ⌊b⌋₊, f ↑k * c k =
f b * ∑ k ∈ Icc 0 ⌊b⌋₊, c k - ∫ (t : ℝ) in Set.Ioc 1 b, deriv f t * ∑ k ∈ Icc 0 ⌊t⌋₊, c k
case inr
𝕜 : Type u_1
inst✝ : RCLike 𝕜
c : ℕ → 𝕜
f : ℝ → 𝕜
hc : c 0 = 0
b : ℝ
hf_diff : ∀ t ∈ Set.Icc 1 b, DifferentiableAt ℝ f t
hf_int : IntegrableOn (deriv f) (Set.Icc 1 b) volume
hb : 1 > b
⊢ ∑ k ∈ Icc 0 ⌊b⌋₊, f ↑k * c k =
f b * ∑ k ∈ Icc 0 ⌊b⌋₊, c k - ∫ (t : ℝ) in Set.Ioc 1 b, deriv f t * ∑ k ∈ Icc 0 ⌊t⌋₊, c k | 715329581e1c96e7 |
Nat.minSqFac_has_prop | Mathlib/Data/Nat/Squarefree.lean | theorem minSqFac_has_prop (n : ℕ) : MinSqFacProp n (minSqFac n) | case neg.inr
n : ℕ
d2 : ¬2 ∣ n
n0 : n > 0
⊢ n.MinSqFacProp (n.minSqFacAux 3) | refine minSqFacAux_has_prop _ n0 0 rfl ?_ | case neg.inr
n : ℕ
d2 : ¬2 ∣ n
n0 : n > 0
⊢ ∀ (m : ℕ), Prime m → m ∣ n → 3 ≤ m | 60eba7de40a3a105 |
UniformContinuousOn.continuousOn | Mathlib/Topology/UniformSpace/Basic.lean | theorem UniformContinuousOn.continuousOn [UniformSpace α] [UniformSpace β] {f : α → β} {s : Set α}
(h : UniformContinuousOn f s) : ContinuousOn f s | α : Type ua
β : Type ub
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuousOn f s
⊢ ContinuousOn f s | rw [uniformContinuousOn_iff_restrict] at h | α : Type ua
β : Type ub
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
h : UniformContinuous (s.restrict f)
⊢ ContinuousOn f s | 5802946f1c9cbf58 |
irreducible_pow_sup_of_le | Mathlib/RingTheory/DedekindDomain/Ideal.lean | theorem irreducible_pow_sup_of_le (hJ : Irreducible J) (n : ℕ) (hn : n ≤ emultiplicity J I) :
J ^ n ⊔ I = J ^ n | case neg
T : Type u_4
inst✝¹ : CommRing T
inst✝ : IsDedekindDomain T
I J : Ideal T
hJ : Irreducible J
n : ℕ
hn : ↑n ≤ emultiplicity J I
hI : ¬I = ⊥
⊢ n ≤ count J (normalizedFactors I) | rw [emultiplicity_eq_count_normalizedFactors hJ hI, normalize_eq J] at hn | case neg
T : Type u_4
inst✝¹ : CommRing T
inst✝ : IsDedekindDomain T
I J : Ideal T
hJ : Irreducible J
n : ℕ
hn : ↑n ≤ ↑(count J (normalizedFactors I))
hI : ¬I = ⊥
⊢ n ≤ count J (normalizedFactors I) | c29a75c2640d6fa6 |
PadicInt.bojanic_mahler_step2 | Mathlib/NumberTheory/Padics/MahlerBasis.lean | /--
Second step in Bojanić's proof of Mahler's theorem (equation (11) of [bojanic74]): show that values
`Δ_[1]^[n + p ^ t] f 0` for large enough `n` are bounded by the max of `(‖f‖ / p ^ s)` and `1 / p`
times a sup over values for smaller `n`.
We use `nnnorm`s on the RHS since `Finset.sup` requires an order with a bottom element.
-/
private lemma bojanic_mahler_step2 {f : C(ℤ_[p], E)} {s t : ℕ}
(hst : ∀ x y : ℤ_[p], ‖x - y‖ ≤ p ^ (-t : ℤ) → ‖f x - f y‖ ≤ ‖f‖ / p ^ s) (n : ℕ) :
‖Δ_[1]^[n + p ^ t] f 0‖ ≤ max ↑((Finset.range (p ^ t - 1)).sup
fun j ↦ ‖Δ_[1]^[n + (j + 1)] f 0‖₊ / p) (‖f‖ / p ^ s) | p : ℕ
hp : Fact (Nat.Prime p)
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℚ_[p] E
inst✝ : IsUltrametricDist E
f : C(ℤ_[p], E)
s t : ℕ
hst : ∀ (x y : ℤ_[p]), ‖x - y‖ ≤ ↑p ^ (-↑t) → ‖f x - f y‖ ≤ ‖f‖ / ↑p ^ s
n : ℕ
⊢ ‖Δ_[1]^[n + p ^ t] (⇑f) 0‖ ≤ ↑((range (p ^ t - 1)).sup fun j => ‖Δ_[1]^[n + (j + 1)] (⇑f) 0‖₊ / ↑p) ⊔ ‖f‖ / ↑p ^ s | rw [bojanic_mahler_step1 _ _ (one_le_pow₀ hp.out.one_le)] | p : ℕ
hp : Fact (Nat.Prime p)
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℚ_[p] E
inst✝ : IsUltrametricDist E
f : C(ℤ_[p], E)
s t : ℕ
hst : ∀ (x y : ℤ_[p]), ‖x - y‖ ≤ ↑p ^ (-↑t) → ‖f x - f y‖ ≤ ‖f‖ / ↑p ^ s
n : ℕ
⊢ ‖-∑ j ∈ range (p ^ t - 1), (p ^ t).choose (j + 1) • Δ_[1]^[n + (j + 1)] (⇑f) 0 +
∑ k ∈ range (n + 1), ((-1) ^ (n - k) * ↑(n.choose k)) • (f (↑k + ↑(p ^ t)) - f ↑k)‖ ≤
↑((range (p ^ t - 1)).sup fun j => ‖Δ_[1]^[n + (j + 1)] (⇑f) 0‖₊ / ↑p) ⊔ ‖f‖ / ↑p ^ s | 2db3408803885b9e |
Real.strictConcaveOn_rpow | Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean | lemma strictConcaveOn_rpow {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1) :
StrictConcaveOn ℝ (Set.Ici 0) fun x : ℝ ↦ x ^ p | case a
p : ℝ
hp₀ : 0 < p
hp₁ : p < 1
x : ℝ
hx : x ∈ Ici 0
y : ℝ
hy : y ∈ Ici 0
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
x' : ℝ≥0 := ⟨x, hx⟩
y' : ℝ≥0 := ⟨y, hy⟩
a' : ℝ≥0 := ⟨a, ⋯⟩
b' : ℝ≥0 := ⟨b, ⋯⟩
hxy' : x' ≠ y'
⊢ ↑(a' + b') = ↑1 | simp [a', b', hab] | no goals | e355702cbbe8ec4b |
IncidenceAlgebra.mu_toDual | Mathlib/Combinatorics/Enumerative/IncidenceAlgebra.lean | @[simp]
lemma mu_toDual (a b : α) : mu 𝕜 (toDual a) (toDual b) = mu 𝕜 b a | 𝕜 : Type u_2
α : Type u_5
inst✝³ : Ring 𝕜
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
this : DecidableRel fun x1 x2 => x1 ≤ x2 := Classical.decRel fun x1 x2 => x1 ≤ x2
mud : IncidenceAlgebra 𝕜 αᵒᵈ := { toFun := fun a b => (mu 𝕜) (ofDual b) (ofDual a), eq_zero_of_not_le' := ⋯ }
⊢ mud * zeta 𝕜 = 1 | ext a b | case h
𝕜 : Type u_2
α : Type u_5
inst✝³ : Ring 𝕜
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
this : DecidableRel fun x1 x2 => x1 ≤ x2 := Classical.decRel fun x1 x2 => x1 ≤ x2
mud : IncidenceAlgebra 𝕜 αᵒᵈ := { toFun := fun a b => (mu 𝕜) (ofDual b) (ofDual a), eq_zero_of_not_le' := ⋯ }
a b : αᵒᵈ
a✝ : a ≤ b
⊢ (mud * zeta 𝕜) a b = 1 a b | 95f4eed14862eb7a |
BoundedContinuousFunction.isBounded_range_integral | Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean | lemma isBounded_range_integral
{ι : Type*} (μs : ι → Measure X) [∀ i, IsProbabilityMeasure (μs i)] (f : X →ᵇ E) :
Bornology.IsBounded (Set.range (fun i ↦ ∫ x, f x ∂ (μs i))) | case intro
X : Type u_1
inst✝⁸ : MeasurableSpace X
inst✝⁷ : TopologicalSpace X
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : OpensMeasurableSpace X
inst✝⁴ : SecondCountableTopology E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : NormedSpace ℝ E
ι : Type u_3
μs : ι → Measure X
inst✝ : ∀ (i : ι), IsProbabilityMeasure (μs i)
f : X →ᵇ E
v : E
i : ι
hi : (fun i => ∫ (x : X), f x ∂μs i) i = v
⊢ ‖v‖ ≤ ‖f‖ | rw [← hi] | case intro
X : Type u_1
inst✝⁸ : MeasurableSpace X
inst✝⁷ : TopologicalSpace X
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : OpensMeasurableSpace X
inst✝⁴ : SecondCountableTopology E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : NormedSpace ℝ E
ι : Type u_3
μs : ι → Measure X
inst✝ : ∀ (i : ι), IsProbabilityMeasure (μs i)
f : X →ᵇ E
v : E
i : ι
hi : (fun i => ∫ (x : X), f x ∂μs i) i = v
⊢ ‖(fun i => ∫ (x : X), f x ∂μs i) i‖ ≤ ‖f‖ | ab2ff73039861d6a |
Set.range_ite_subset' | Mathlib/Data/Set/Image.lean | theorem range_ite_subset' {p : Prop} [Decidable p] {f g : α → β} :
range (if p then f else g) ⊆ range f ∪ range g | case neg
α : Type u_1
β : Type u_2
p : Prop
inst✝ : Decidable p
f g : α → β
h : ¬p
⊢ range g ⊆ range f ∪ range g | exact subset_union_right | no goals | 62472e83fd94611c |
Basis.maximal | Mathlib/LinearAlgebra/Basis/Basic.lean | theorem maximal [Nontrivial R] (b : Basis ι R M) : b.linearIndependent.Maximal := fun w hi h => by
-- If `w` is strictly bigger than `range b`,
apply le_antisymm h
-- then choose some `x ∈ w \ range b`,
intro x p
by_contra q
-- and write it in terms of the basis.
have e := b.linearCombination_repr x
-- This then expresses `x` as a linear combination
-- of elements of `w` which are in the range of `b`,
let u : ι ↪ w :=
⟨fun i => ⟨b i, h ⟨i, rfl⟩⟩, fun i i' r =>
b.injective (by simpa only [Subtype.mk_eq_mk] using r)⟩
simp_rw [Finsupp.linearCombination_apply] at e
change ((b.repr x).sum fun (i : ι) (a : R) ↦ a • (u i : M)) = ((⟨x, p⟩ : w) : M) at e
rw [← Finsupp.sum_embDomain (f := u) (g := fun x r ↦ r • (x : M)),
← Finsupp.linearCombination_apply] at e
-- Now we can contradict the linear independence of `hi`
refine hi.linearCombination_ne_of_not_mem_support _ ?_ e
simp only [Finset.mem_map, Finsupp.support_embDomain]
rintro ⟨j, -, W⟩
simp only [u, Embedding.coeFn_mk, Subtype.mk_eq_mk] at W
apply q ⟨j, W⟩
| ι : Type u_1
R : Type u_3
M : Type u_5
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Nontrivial R
b : Basis ι R M
w : Set M
hi : LinearIndependent R Subtype.val
h : range ⇑b ≤ w
⊢ w ≤ range ⇑b | intro x p | ι : Type u_1
R : Type u_3
M : Type u_5
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Nontrivial R
b : Basis ι R M
w : Set M
hi : LinearIndependent R Subtype.val
h : range ⇑b ≤ w
x : M
p : x ∈ w
⊢ x ∈ range ⇑b | 26f21cbf99980896 |
PowerSeries.trunc_X | Mathlib/RingTheory/PowerSeries/Trunc.lean | theorem trunc_X (n) : trunc (n + 2) X = (Polynomial.X : R[X]) | case a
R : Type u_1
inst✝ : Semiring R
n d : ℕ
⊢ (if d < n + 2 then if d = 1 then 1 else 0 else 0) = Polynomial.X.coeff d | split_ifs with h₁ h₂ | case pos
R : Type u_1
inst✝ : Semiring R
n d : ℕ
h₁ : d < n + 2
h₂ : d = 1
⊢ 1 = Polynomial.X.coeff d
case neg
R : Type u_1
inst✝ : Semiring R
n d : ℕ
h₁ : d < n + 2
h₂ : ¬d = 1
⊢ 0 = Polynomial.X.coeff d
case neg
R : Type u_1
inst✝ : Semiring R
n d : ℕ
h₁ : ¬d < n + 2
⊢ 0 = Polynomial.X.coeff d | b873ec511fef51ee |
MeasureTheory.Measure.pi_pi_aux | Mathlib/MeasureTheory/Constructions/Pi.lean | theorem pi_pi_aux [∀ i, SigmaFinite (μ i)] (s : ∀ i, Set (α i)) (hs : ∀ i, MeasurableSet (s i)) :
Measure.pi μ (pi univ s) = ∏ i, μ i (s i) | case refine_2
ι : Type u_1
α : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝ : ∀ (i : ι), SigmaFinite (μ i)
s : (i : ι) → Set (α i)
hs : ∀ (i : ι), MeasurableSet (s i)
this : Encodable ι
⊢ (pi' μ) (univ.pi s) ≤ (OuterMeasure.pi fun i => (μ i).toOuterMeasure) (univ.pi s) | suffices (pi' μ).toOuterMeasure ≤ OuterMeasure.pi fun i => (μ i).toOuterMeasure by exact this _ | case refine_2
ι : Type u_1
α : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝ : ∀ (i : ι), SigmaFinite (μ i)
s : (i : ι) → Set (α i)
hs : ∀ (i : ι), MeasurableSet (s i)
this : Encodable ι
⊢ (pi' μ).toOuterMeasure ≤ OuterMeasure.pi fun i => (μ i).toOuterMeasure | d6eb1f2f929e1b76 |
IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_root_cyclotomic | Mathlib/NumberTheory/Cyclotomic/Basic.lean | theorem adjoin_roots_cyclotomic_eq_adjoin_root_cyclotomic {n : ℕ+} [IsDomain B] {ζ : B}
(hζ : IsPrimitiveRoot ζ n) : adjoin A ((cyclotomic n A).rootSet B) = adjoin A {ζ} | case refine_2
A : Type u
B : Type v
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : Algebra A B
n : ℕ+
inst✝ : IsDomain B
ζ : B
hζ : IsPrimitiveRoot ζ ↑n
x : B
hx : x = ζ
⊢ x ∈ (cyclotomic (↑n) A).rootSet B | simpa only [hx, mem_rootSet', map_cyclotomic, aeval_def, ← eval_map, IsRoot] using
And.intro (cyclotomic_ne_zero n B) (hζ.isRoot_cyclotomic n.pos) | no goals | 47345c8f34a7fd33 |
factorsThrough_of_pullbackCondition | Mathlib/Condensed/TopComparison.lean | theorem factorsThrough_of_pullbackCondition {Z B : C} {π : Z ⟶ B} [HasPullback π π]
[PreservesLimit (cospan π π) G]
{a : C(G.obj Z, X)}
(ha : a ∘ (G.map (pullback.fst _ _)) = a ∘ (G.map (pullback.snd π π))) :
Function.FactorsThrough a (G.map π) | C : Type u
inst✝³ : Category.{v, u} C
G : C ⥤ TopCat
X : Type w'
inst✝² : TopologicalSpace X
Z B : C
π : Z ⟶ B
inst✝¹ : HasPullback π π
inst✝ : PreservesLimit (cospan π π) G
a : C(↑(G.obj Z), X)
ha : ⇑a ∘ ⇑(ConcreteCategory.hom (G.map (pullback.fst π π))) = ⇑a ∘ ⇑(ConcreteCategory.hom (G.map (pullback.snd π π)))
x y : ↑(G.obj Z)
hxy : (ConcreteCategory.hom (G.map π)) x = (ConcreteCategory.hom (G.map π)) y
⊢ a x = a y | let xy : G.obj (pullback π π) := (PreservesPullback.iso G π π).inv <|
(TopCat.pullbackIsoProdSubtype (G.map π) (G.map π)).inv ⟨(x, y), hxy⟩ | C : Type u
inst✝³ : Category.{v, u} C
G : C ⥤ TopCat
X : Type w'
inst✝² : TopologicalSpace X
Z B : C
π : Z ⟶ B
inst✝¹ : HasPullback π π
inst✝ : PreservesLimit (cospan π π) G
a : C(↑(G.obj Z), X)
ha : ⇑a ∘ ⇑(ConcreteCategory.hom (G.map (pullback.fst π π))) = ⇑a ∘ ⇑(ConcreteCategory.hom (G.map (pullback.snd π π)))
x y : ↑(G.obj Z)
hxy : (ConcreteCategory.hom (G.map π)) x = (ConcreteCategory.hom (G.map π)) y
xy : ↑(G.obj (pullback π π)) :=
(ConcreteCategory.hom (PreservesPullback.iso G π π).inv)
((ConcreteCategory.hom (TopCat.pullbackIsoProdSubtype (G.map π) (G.map π)).inv) ⟨(x, y), hxy⟩)
⊢ a x = a y | 579a4db837d3077a |
Module.Finite.exists_fin' | Mathlib/RingTheory/Finiteness/Cardinality.lean | /-- A finite module admits a surjective linear map from a finite free module. -/
lemma exists_fin' [Module.Finite R M] : ∃ (n : ℕ) (f : (Fin n → R) →ₗ[R] M), Surjective f | R : Type u
M : Type u_3
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
⊢ ∃ n f, Surjective ⇑f | have ⟨n, s, hs⟩ := exists_fin (R := R) (M := M) | R : Type u
M : Type u_3
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
n : ℕ
s : Fin n → M
hs : span R (Set.range s) = ⊤
⊢ ∃ n f, Surjective ⇑f | a44152e4175c7cd5 |
intervalIntegral.integral_comp_neg | Mathlib/MeasureTheory/Integral/IntervalIntegral.lean | theorem integral_comp_neg : (∫ x in a..b, f (-x)) = ∫ x in -b..-a, f x | E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
⊢ ∫ (x : ℝ) in a..b, f (-x) = ∫ (x : ℝ) in -b..-a, f x | simpa only [zero_sub] using integral_comp_sub_left f 0 | no goals | 3ac1cbee3bf8f34a |
VectorFourier.integral_bilin_fourierIntegral_eq_flip | Mathlib/Analysis/Fourier/FourierTransform.lean | theorem integral_bilin_fourierIntegral_eq_flip
{f : V → E} {g : W → F} (M : E →L[ℂ] F →L[ℂ] G) (he : Continuous e)
(hL : Continuous fun p : V × W ↦ L p.1 p.2) (hf : Integrable f μ) (hg : Integrable g ν) :
∫ ξ, M (fourierIntegral e μ L f ξ) (g ξ) ∂ν =
∫ x, M (f x) (fourierIntegral e ν L.flip g x) ∂μ | case hf.h.h
𝕜 : Type u_1
inst✝²³ : CommRing 𝕜
V : Type u_2
inst✝²² : AddCommGroup V
inst✝²¹ : Module 𝕜 V
inst✝²⁰ : MeasurableSpace V
W : Type u_3
inst✝¹⁹ : AddCommGroup W
inst✝¹⁸ : Module 𝕜 W
E : Type u_4
F : Type u_5
G : Type u_6
inst✝¹⁷ : NormedAddCommGroup E
inst✝¹⁶ : NormedSpace ℂ E
inst✝¹⁵ : NormedAddCommGroup F
inst✝¹⁴ : NormedSpace ℂ F
inst✝¹³ : NormedAddCommGroup G
inst✝¹² : NormedSpace ℂ G
inst✝¹¹ : TopologicalSpace 𝕜
inst✝¹⁰ : IsTopologicalRing 𝕜
inst✝⁹ : TopologicalSpace V
inst✝⁸ : BorelSpace V
inst✝⁷ : TopologicalSpace W
inst✝⁶ : MeasurableSpace W
inst✝⁵ : BorelSpace W
e : AddChar 𝕜 𝕊
μ : Measure V
L : V →ₗ[𝕜] W →ₗ[𝕜] 𝕜
ν : Measure W
inst✝⁴ : SigmaFinite μ
inst✝³ : SigmaFinite ν
inst✝² : SecondCountableTopology V
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
f : V → E
g : W → F
M : E →L[ℂ] F →L[ℂ] G
he : Continuous ⇑e
hL : Continuous fun p => (L p.1) p.2
hf : Integrable f μ
hg : Integrable g ν
hG : CompleteSpace G
this : Integrable (fun p => ‖M‖ * (‖g p.1‖ * ‖f p.2‖)) (ν.prod μ)
ξ : W
x : V
⊢ ‖(M (f x)) (g ξ)‖ ≤ ‖M‖ * ‖f (ξ, x).2‖ * ‖g (ξ, x).1‖ | exact M.le_opNorm₂ (f x) (g ξ) | no goals | 81aa292dd9850619 |
List.dedup_eq_cons | Mathlib/Data/List/Dedup.lean | theorem dedup_eq_cons (l : List α) (a : α) (l' : List α) :
l.dedup = a :: l' ↔ a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l' | case refine_1
α : Type u_1
inst✝ : DecidableEq α
l : List α
a : α
l' : List α
h : l.dedup = a :: l'
⊢ a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l' | refine ⟨mem_dedup.1 (h.symm ▸ mem_cons_self _ _), fun ha => ?_, by rw [h, tail_cons]⟩ | case refine_1
α : Type u_1
inst✝ : DecidableEq α
l : List α
a : α
l' : List α
h : l.dedup = a :: l'
ha : a ∈ l'
⊢ False | 31be0178b993dde6 |
iInter_halfSpaces_eq | Mathlib/Analysis/NormedSpace/HahnBanach/Separation.lean | theorem iInter_halfSpaces_eq (hs₁ : Convex ℝ s) (hs₂ : IsClosed s) :
⋂ l : E →L[ℝ] ℝ, { x | ∃ y ∈ s, l x ≤ l y } = s | E : Type u_2
inst✝⁵ : TopologicalSpace E
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s : Set E
inst✝² : IsTopologicalAddGroup E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : LocallyConvexSpace ℝ E
hs₁ : Convex ℝ s
hs₂ : IsClosed s
⊢ {x | ∀ (i : E →L[ℝ] ℝ), ∃ y ∈ s, i x ≤ i y} = s | refine Set.Subset.antisymm (fun x hx => ?_) fun x hx l => ⟨x, hx, le_rfl⟩ | E : Type u_2
inst✝⁵ : TopologicalSpace E
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s : Set E
inst✝² : IsTopologicalAddGroup E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : LocallyConvexSpace ℝ E
hs₁ : Convex ℝ s
hs₂ : IsClosed s
x : E
hx : x ∈ {x | ∀ (i : E →L[ℝ] ℝ), ∃ y ∈ s, i x ≤ i y}
⊢ x ∈ s | 62fc6b991b51d567 |
AlgebraicGeometry.Scheme.Opens.toSpecΓ_top | Mathlib/AlgebraicGeometry/AffineScheme.lean | @[simp]
lemma Scheme.Opens.toSpecΓ_top {X : Scheme} :
(⊤ : X.Opens).toSpecΓ = (⊤ : X.Opens).ι ≫ X.toSpecΓ | X : Scheme
⊢ (↑⊤).toSpecΓ ≫ Spec.map (X.presheaf.map (eqToHom ⋯)) = (↑⊤).toSpecΓ ≫ Spec.map (X.presheaf.map (homOfLE ⋯).op) | rfl | no goals | 30e215b07924d3af |
polynomialFunctions.comap_compRightAlgHom_iccHomeoI | Mathlib/Topology/ContinuousMap/Polynomial.lean | theorem polynomialFunctions.comap_compRightAlgHom_iccHomeoI (a b : ℝ) (h : a < b) :
(polynomialFunctions I).comap (compRightAlgHom ℝ ℝ (iccHomeoI a b h).symm) =
polynomialFunctions (Set.Icc a b) | case h.mpr.intro.intro.refine_2.h
a b : ℝ
h : a < b
p : ℝ[X]
q : ℝ[X] := p.comp ((b - a) • X + Polynomial.C a)
x : ↑I
⊢ (↑(toContinuousMapOnAlgHom I) q) x =
(↑(compRightAlgHom ℝ ℝ ↑(iccHomeoI a b h).symm) (↑(toContinuousMapOnAlgHom (Set.Icc a b)) p)) x | simp [q, mul_comm] | no goals | c86eff4051268cff |
Submodule.exists_sub_one_mem_and_smul_eq_zero_of_fg_of_le_smul | Mathlib/RingTheory/Finiteness/Nakayama.lean | theorem exists_sub_one_mem_and_smul_eq_zero_of_fg_of_le_smul {R : Type*} [CommRing R] {M : Type*}
[AddCommGroup M] [Module R M] (I : Ideal R) (N : Submodule R M) (hn : N.FG) (hin : N ≤ I • N) :
∃ r : R, r - 1 ∈ I ∧ ∀ n ∈ N, r • n = (0 : M) | case intro.intro.refine_2
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
N : Submodule R M
s✝ : Set M
hfs : s✝.Finite
i : M
s : Set M
x✝¹ : i ∉ s
x✝ : s.Finite
ih :
(∃ r, r - 1 ∈ I ∧ N ≤ comap ((LinearMap.lsmul R M) r) (I • span R s) ∧ s ⊆ ↑N) → ∃ r, r - 1 ∈ I ∧ ∀ n ∈ N, r • n = 0
H : ∃ r, r - 1 ∈ I ∧ N ≤ comap ((LinearMap.lsmul R M) r) (I • span R (insert i s)) ∧ insert i s ⊆ ↑N
⊢ ∃ r, r - 1 ∈ I ∧ N ≤ comap ((LinearMap.lsmul R M) r) (I • span R s) ∧ s ⊆ ↑N | rcases H with ⟨r, hr1, hrn, hs⟩ | case intro.intro.refine_2.intro.intro.intro
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
N : Submodule R M
s✝ : Set M
hfs : s✝.Finite
i : M
s : Set M
x✝¹ : i ∉ s
x✝ : s.Finite
ih :
(∃ r, r - 1 ∈ I ∧ N ≤ comap ((LinearMap.lsmul R M) r) (I • span R s) ∧ s ⊆ ↑N) → ∃ r, r - 1 ∈ I ∧ ∀ n ∈ N, r • n = 0
r : R
hr1 : r - 1 ∈ I
hrn : N ≤ comap ((LinearMap.lsmul R M) r) (I • span R (insert i s))
hs : insert i s ⊆ ↑N
⊢ ∃ r, r - 1 ∈ I ∧ N ≤ comap ((LinearMap.lsmul R M) r) (I • span R s) ∧ s ⊆ ↑N | ddde3c87abdd1812 |
LieSubmodule.isCompactElement_lieSpan_singleton | Mathlib/Algebra/Lie/Submodule.lean | lemma isCompactElement_lieSpan_singleton (m : M) :
CompleteLattice.IsCompactElement (lieSpan R L {m}) | R : Type u
L : Type v
M : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : LieRingModule L M
m : M
s : Set (LieSubmodule R L M)
hne : s.Nonempty
hdir : DirectedOn (fun x1 x2 => x1 ≤ x2) s
hsup : m ∈ ↑(sSup s)
this : ↑(sSup s) = ⋃ N ∈ s, ↑N
N : LieSubmodule R L M
hN : N ∈ s
hN' : m ∈ N
⊢ lieSpan R L {m} ≤ N | simpa | no goals | 016ba20f16d8a5de |
exists_continuous_add_one_of_isCompact_nnreal | Mathlib/MeasureTheory/Integral/RieszMarkovKakutani/Basic.lean | lemma exists_continuous_add_one_of_isCompact_nnreal
{s₀ s₁ : Set X} {t : Set X} (s₀_compact : IsCompact s₀) (s₁_compact : IsCompact s₁)
(t_compact : IsCompact t) (disj : Disjoint s₀ s₁) (hst : s₀ ∪ s₁ ⊆ t) :
∃ (f₀ f₁ : C_c(X, ℝ≥0)), EqOn f₀ 1 s₀ ∧ EqOn f₁ 1 s₁ ∧ EqOn (f₀ + f₁) 1 t | case h.refine_3
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : T2Space X
inst✝ : LocallyCompactSpace X
s₀ s₁ t : Set X
s₀_compact : IsCompact s₀
s₁_compact : IsCompact s₁
t_compact : IsCompact t
disj : Disjoint s₀ s₁
hst : s₀ ∪ s₁ ⊆ t
so : Fin 2 → Set X := fun j => if j = 0 then s₀ᶜ else s₁ᶜ
hso : so = fun j => if j = 0 then s₀ᶜ else s₁ᶜ
soopen : ∀ (j : Fin 2), IsOpen (so j)
hsot : t ⊆ ⋃ j, so j
f : Fin 2 → C(X, ℝ)
f_supp_in_so : ∀ (i : Fin 2), tsupport ⇑(f i) ⊆ so i
sum_f_one_on_t : EqOn (∑ i : Fin 2, ⇑(f i)) 1 t
f_in_icc : ∀ (i : Fin 2) (x : X), (f i) x ∈ Icc 0 1
f_hcs : ∀ (i : Fin 2), HasCompactSupport ⇑(f i)
sum_one_x : ∀ x ∈ t, (f 0) x + (f 1) x = 1
x : X
hx : x ∈ t
⊢ ((f 1) x).toNNReal + ((f 0) x).toNNReal = 1 | rw [Real.toNNReal_add_toNNReal (f_in_icc 1 x).1 (f_in_icc 0 x).1, add_comm] | case h.refine_3
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : T2Space X
inst✝ : LocallyCompactSpace X
s₀ s₁ t : Set X
s₀_compact : IsCompact s₀
s₁_compact : IsCompact s₁
t_compact : IsCompact t
disj : Disjoint s₀ s₁
hst : s₀ ∪ s₁ ⊆ t
so : Fin 2 → Set X := fun j => if j = 0 then s₀ᶜ else s₁ᶜ
hso : so = fun j => if j = 0 then s₀ᶜ else s₁ᶜ
soopen : ∀ (j : Fin 2), IsOpen (so j)
hsot : t ⊆ ⋃ j, so j
f : Fin 2 → C(X, ℝ)
f_supp_in_so : ∀ (i : Fin 2), tsupport ⇑(f i) ⊆ so i
sum_f_one_on_t : EqOn (∑ i : Fin 2, ⇑(f i)) 1 t
f_in_icc : ∀ (i : Fin 2) (x : X), (f i) x ∈ Icc 0 1
f_hcs : ∀ (i : Fin 2), HasCompactSupport ⇑(f i)
sum_one_x : ∀ x ∈ t, (f 0) x + (f 1) x = 1
x : X
hx : x ∈ t
⊢ ((f 0) x + (f 1) x).toNNReal = 1 | c2d96a23593bed78 |
AddCircle.closedBall_ae_eq_ball | Mathlib/MeasureTheory/Group/AddCircle.lean | theorem closedBall_ae_eq_ball {x : AddCircle T} {ε : ℝ} : closedBall x ε =ᵐ[volume] ball x ε | T : ℝ
hT : Fact (0 < T)
x : AddCircle T
ε : ℝ
⊢ closedBall x ε =ᶠ[ae volume] ball x ε | rcases le_or_lt ε 0 with hε | hε | case inl
T : ℝ
hT : Fact (0 < T)
x : AddCircle T
ε : ℝ
hε : ε ≤ 0
⊢ closedBall x ε =ᶠ[ae volume] ball x ε
case inr
T : ℝ
hT : Fact (0 < T)
x : AddCircle T
ε : ℝ
hε : 0 < ε
⊢ closedBall x ε =ᶠ[ae volume] ball x ε | d4d4a4368219224a |
DerivedCategory.mem_distTriang_iff | Mathlib/Algebra/Homology/DerivedCategory/Basic.lean | lemma mem_distTriang_iff (T : Triangle (DerivedCategory C)) :
(T ∈ distTriang (DerivedCategory C)) ↔ ∃ (X Y : CochainComplex C ℤ) (f : X ⟶ Y),
Nonempty (T ≅ Q.mapTriangle.obj (CochainComplex.mappingCone.triangle f)) | C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
T : Triangle (DerivedCategory C)
⊢ T ∈ distinguishedTriangles ↔ ∃ X Y f, Nonempty (T ≅ Q.mapTriangle.obj (CochainComplex.mappingCone.triangle f)) | constructor | case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
T : Triangle (DerivedCategory C)
⊢ T ∈ distinguishedTriangles → ∃ X Y f, Nonempty (T ≅ Q.mapTriangle.obj (CochainComplex.mappingCone.triangle f))
case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
T : Triangle (DerivedCategory C)
⊢ (∃ X Y f, Nonempty (T ≅ Q.mapTriangle.obj (CochainComplex.mappingCone.triangle f))) → T ∈ distinguishedTriangles | 03b436a0c0486942 |
MeasureTheory.L1.setToL1_mono | Mathlib/MeasureTheory/Integral/SetToL1.lean | theorem setToL1_mono {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
(hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f g : α →₁[μ] G'}
(hfg : f ≤ g) : setToL1 hT f ≤ setToL1 hT g | α : Type u_1
m : MeasurableSpace α
μ : Measure α
G' : Type u_7
G'' : Type u_8
inst✝⁴ : NormedLatticeAddCommGroup G''
inst✝³ : NormedSpace ℝ G''
inst✝² : CompleteSpace G''
inst✝¹ : NormedLatticeAddCommGroup G'
inst✝ : NormedSpace ℝ G'
T : Set α → G' →L[ℝ] G''
C : ℝ
hT : DominatedFinMeasAdditive μ T C
hT_nonneg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∀ (x : G'), 0 ≤ x → 0 ≤ (T s) x
f g : ↥(Lp G' 1 μ)
hfg : 0 ≤ g - f
⊢ 0 ≤ (setToL1 hT) g - (setToL1 hT) f | rw [← (setToL1 hT).map_sub] | α : Type u_1
m : MeasurableSpace α
μ : Measure α
G' : Type u_7
G'' : Type u_8
inst✝⁴ : NormedLatticeAddCommGroup G''
inst✝³ : NormedSpace ℝ G''
inst✝² : CompleteSpace G''
inst✝¹ : NormedLatticeAddCommGroup G'
inst✝ : NormedSpace ℝ G'
T : Set α → G' →L[ℝ] G''
C : ℝ
hT : DominatedFinMeasAdditive μ T C
hT_nonneg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∀ (x : G'), 0 ≤ x → 0 ≤ (T s) x
f g : ↥(Lp G' 1 μ)
hfg : 0 ≤ g - f
⊢ 0 ≤ (setToL1 hT) (g - f) | d553f717872d4afe |
separableClosure_le_iff | Mathlib/FieldTheory/PurelyInseparable/Basic.lean | theorem separableClosure_le_iff [Algebra.IsAlgebraic F E] (L : IntermediateField F E) :
separableClosure F E ≤ L ↔ IsPurelyInseparable L E | F : Type u
E : Type v
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Algebra.IsAlgebraic F E
L : IntermediateField F E
⊢ separableClosure F E ≤ L ↔ IsPurelyInseparable (↥L) E | refine ⟨fun h ↦ ?_, fun _ ↦ separableClosure_le F E L⟩ | F : Type u
E : Type v
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Algebra.IsAlgebraic F E
L : IntermediateField F E
h : separableClosure F E ≤ L
⊢ IsPurelyInseparable (↥L) E | 3ca97f86bd963620 |
strictConvexOn_rpow | Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean | theorem strictConvexOn_rpow {p : ℝ} (hp : 1 < p) : StrictConvexOn ℝ (Ici 0) fun x : ℝ ↦ x ^ p | p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
q : 0 < y - x
⊢ (y ^ p - x ^ p) / (y - x) < p * y ^ (p - 1) | rw [div_lt_iff₀ q, ← div_lt_div_iff_of_pos_right hy', _root_.sub_div, div_self hy'.ne',
← div_rpow hx hy.le, sub_lt_comm, ← add_sub_cancel_right (x / y) 1, add_comm, add_sub_assoc,
← div_mul_eq_mul_div, mul_div_assoc, ← rpow_sub hy, sub_sub_cancel_left, rpow_neg_one,
mul_assoc, ← div_eq_inv_mul, sub_eq_add_neg, ← mul_neg, ← neg_div, neg_sub, _root_.sub_div,
div_self hy.ne'] | p : ℝ
hp : 1 < p
x y z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hxy : x < y
hyz : y < z
hy : 0 < y
hy' : 0 < y ^ p
q : 0 < y - x
⊢ 1 + p * (x / y - 1) < (1 + (x / y - 1)) ^ p | 003004303f55f1b7 |
NumberField.InfinitePlace.mk_eq_iff | Mathlib/NumberTheory/NumberField/Embeddings.lean | theorem mk_eq_iff {φ ψ : K →+* ℂ} : mk φ = mk ψ ↔ φ = ψ ∨ ComplexEmbedding.conjugate φ = ψ | case mp.intro.inl.h
K : Type u_2
inst✝ : Field K
φ ψ : K →+* ℂ
h₀ : mk φ = mk ψ
j : ℂ → K
hiφ : Function.LeftInverse j ⇑φ
ι : K ≃+* ↥φ.range := RingEquiv.ofLeftInverse hiφ
hlip : LipschitzWith 1 ⇑(ψ.comp ι.symm.toRingHom)
h : (↑↑(ψ.comp ι.symm.toRingHom)).toFun = ⇑φ.fieldRange.subtype
⊢ φ = ψ | ext1 x | case mp.intro.inl.h.a
K : Type u_2
inst✝ : Field K
φ ψ : K →+* ℂ
h₀ : mk φ = mk ψ
j : ℂ → K
hiφ : Function.LeftInverse j ⇑φ
ι : K ≃+* ↥φ.range := RingEquiv.ofLeftInverse hiφ
hlip : LipschitzWith 1 ⇑(ψ.comp ι.symm.toRingHom)
h : (↑↑(ψ.comp ι.symm.toRingHom)).toFun = ⇑φ.fieldRange.subtype
x : K
⊢ φ x = ψ x | 1d2ef4e3545a7979 |
CliffordAlgebra.involute_eq_of_mem_odd | Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean | theorem involute_eq_of_mem_odd {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 1) : involute x = -x | R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : CliffordAlgebra Q
h : x ∈ evenOdd Q 1
⊢ involute x = -x | induction x, h using odd_induction with
| ι m => exact involute_ι _
| add x y _hx _hy ihx ihy =>
rw [map_add, ihx, ihy, neg_add]
| ι_mul_ι_mul m₁ m₂ x _hx ihx =>
rw [map_mul, map_mul, involute_ι, involute_ι, ihx, neg_mul_neg, mul_neg] | no goals | de256de08fdc980b |
AlgebraicGeometry.spread_out_of_isGermInjective | Mathlib/AlgebraicGeometry/SpreadingOut.lean | /--
Given `S`-schemes `X Y` and points `x : X` `y : Y` over `s : S`.
Suppose we have the following diagram of `S`-schemes
```
Spec 𝒪_{X, x} ⟶ X
|
Spec(φ)
↓
Spec 𝒪_{Y, y} ⟶ Y
```
Then the map `Spec(φ)` spreads out to an `S`-morphism on an open subscheme `U ⊆ X`,
```
Spec 𝒪_{X, x} ⟶ U ⊆ X
| |
Spec(φ) |
↓ ↓
Spec 𝒪_{Y, y} ⟶ Y
```
provided that `Y` is locally of finite type over `S` and
`X` is "germ-injective" at `x` (e.g. when it's integral or locally noetherian).
TODO: The condition on `X` is unnecessary when `Y` is locally of finite presentation.
-/
@[stacks 0BX6]
lemma spread_out_of_isGermInjective [LocallyOfFiniteType sY] {x : X} [X.IsGermInjectiveAt x] {y : Y}
(e : sX.base x = sY.base y) (φ : Y.presheaf.stalk y ⟶ X.presheaf.stalk x)
(h : sY.stalkMap y ≫ φ =
S.presheaf.stalkSpecializes (Inseparable.of_eq e).specializes ≫ sX.stalkMap x) :
∃ (U : X.Opens) (hxU : x ∈ U) (f : U.toScheme ⟶ Y),
Spec.map φ ≫ Y.fromSpecStalk y = U.fromSpecStalkOfMem x hxU ≫ f ∧
f ≫ sY = U.ι ≫ sX | case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
X Y S : Scheme
sX : X ⟶ S
sY : Y ⟶ S
inst✝¹ : LocallyOfFiniteType sY
x : ↑↑X.toPresheafedSpace
inst✝ : X.IsGermInjectiveAt x
y : ↑↑Y.toPresheafedSpace
e : (ConcreteCategory.hom sX.base) x = (ConcreteCategory.hom sY.base) y
φ : Y.presheaf.stalk y ⟶ X.presheaf.stalk x
h : Scheme.Hom.stalkMap sY y ≫ φ = S.presheaf.stalkSpecializes ⋯ ≫ Scheme.Hom.stalkMap sX x
U : TopologicalSpace.Opens ↑↑S.toPresheafedSpace
hU : U ∈ S.affineOpens
hxU : (ConcreteCategory.hom sX.base) x ∈ ↑U
hyU : (ConcreteCategory.hom sY.base) y ∈ U
V : Y.Opens
hV : V ∈ Y.affineOpens
hyV : y ∈ ↑V
iVU : ↑V ⊆ (sY ⁻¹ᵁ U).carrier
this :
Scheme.Hom.appLE sY U V iVU ≫ Y.presheaf.germ V y hyV ≫ φ = Scheme.Hom.app sX U ≫ X.presheaf.germ (sX ⁻¹ᵁ U) x hxU
⊢ ∃ U, ∃ (hxU : x ∈ U), ∃ f, Spec.map φ ≫ Y.fromSpecStalk y = U.fromSpecStalkOfMem x hxU ≫ f ∧ f ≫ sY = U.ι ≫ sX | obtain ⟨W, hxW, φ', i, hW, h₁, h₂⟩ :=
exists_lift_of_germInjective (R := Γ(S, U)) (A := Γ(Y, V)) (U := sX ⁻¹ᵁ U) (x := x) hxU
(Y.presheaf.germ _ y hyV ≫ φ) (sY.appLE U V iVU) (sX.app U)
(LocallyOfFiniteType.finiteType_of_affine_subset ⟨_, hU⟩ ⟨_, hV⟩ _) this | case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
X Y S : Scheme
sX : X ⟶ S
sY : Y ⟶ S
inst✝¹ : LocallyOfFiniteType sY
x : ↑↑X.toPresheafedSpace
inst✝ : X.IsGermInjectiveAt x
y : ↑↑Y.toPresheafedSpace
e : (ConcreteCategory.hom sX.base) x = (ConcreteCategory.hom sY.base) y
φ : Y.presheaf.stalk y ⟶ X.presheaf.stalk x
h : Scheme.Hom.stalkMap sY y ≫ φ = S.presheaf.stalkSpecializes ⋯ ≫ Scheme.Hom.stalkMap sX x
U : TopologicalSpace.Opens ↑↑S.toPresheafedSpace
hU : U ∈ S.affineOpens
hxU : (ConcreteCategory.hom sX.base) x ∈ ↑U
hyU : (ConcreteCategory.hom sY.base) y ∈ U
V : Y.Opens
hV : V ∈ Y.affineOpens
hyV : y ∈ ↑V
iVU : ↑V ⊆ (sY ⁻¹ᵁ U).carrier
this :
Scheme.Hom.appLE sY U V iVU ≫ Y.presheaf.germ V y hyV ≫ φ = Scheme.Hom.app sX U ≫ X.presheaf.germ (sX ⁻¹ᵁ U) x hxU
W : X.Opens
hxW : x ∈ W
φ' : Γ(Y, V) ⟶ Γ(X, W)
i : W ≤ sX ⁻¹ᵁ U
hW : IsAffineOpen W
h₁ : Y.presheaf.germ V y hyV ≫ φ = φ' ≫ X.presheaf.germ W x hxW
h₂ : Scheme.Hom.app sX U ≫ X.presheaf.map i.hom.op = Scheme.Hom.appLE sY U V iVU ≫ φ'
⊢ ∃ U, ∃ (hxU : x ∈ U), ∃ f, Spec.map φ ≫ Y.fromSpecStalk y = U.fromSpecStalkOfMem x hxU ≫ f ∧ f ≫ sY = U.ι ≫ sX | 6cace8db5fa36278 |
List.Sublist.of_sublist_append_right | Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Sublist.lean | theorem Sublist.of_sublist_append_right (w : ∀ a, a ∈ l → a ∉ l₁) (h : l <+ l₁ ++ l₂) : l <+ l₂ | case intro.intro.intro.intro
α✝ : Type u_1
l₁ l₂ l₁' l₂' : List α✝
w : ∀ (a : α✝), a ∈ l₁' ++ l₂' → ¬a ∈ l₁
h₁ : l₁' <+ l₁
h₂ : l₂' <+ l₂
⊢ l₁' ++ l₂' <+ l₂ | have : l₁' = [] := by
rw [eq_nil_iff_forall_not_mem]
exact fun x m => w x (mem_append_left l₂' m) (h₁.mem m) | case intro.intro.intro.intro
α✝ : Type u_1
l₁ l₂ l₁' l₂' : List α✝
w : ∀ (a : α✝), a ∈ l₁' ++ l₂' → ¬a ∈ l₁
h₁ : l₁' <+ l₁
h₂ : l₂' <+ l₂
this : l₁' = []
⊢ l₁' ++ l₂' <+ l₂ | a561ed959cac614f |
Vector.append_eq_append_iff | Mathlib/.lake/packages/lean4/src/lean/Init/Data/Vector/Lemmas.lean | theorem append_eq_append_iff {a : Vector α n} {b : Vector α m} {c : Vector α k} {d : Vector α l}
(w : k + l = n + m) :
a ++ b = (c ++ d).cast w ↔
if h : n ≤ k then
∃ a' : Vector α (k - n), c = (a ++ a').cast (by omega) ∧ b = (a' ++ d).cast (by omega)
else
∃ c' : Vector α (n - k), a = (c ++ c').cast (by omega) ∧ d = (c' ++ b).cast (by omega) | case mk.mk.mk.mk.mpr.isFalse.intro.intro
α : Type u_1
a b c : Array α
h : ¬a.size ≤ c.size
c' : Vector α (a.size - c.size)
ha : a = ({ toArray := c, size_toArray := ⋯ } ++ c').toArray
w : c.size + (c' ++ { toArray := b, size_toArray := ⋯ }).size = a.size + b.size
⊢ (∃ a', c = a ++ a' ∧ b = a' ++ (c' ++ { toArray := b, size_toArray := ⋯ }).toArray) ∨
∃ c'_1, a = c ++ c'_1 ∧ (c' ++ { toArray := b, size_toArray := ⋯ }).toArray = c'_1 ++ b | right | case mk.mk.mk.mk.mpr.isFalse.intro.intro.h
α : Type u_1
a b c : Array α
h : ¬a.size ≤ c.size
c' : Vector α (a.size - c.size)
ha : a = ({ toArray := c, size_toArray := ⋯ } ++ c').toArray
w : c.size + (c' ++ { toArray := b, size_toArray := ⋯ }).size = a.size + b.size
⊢ ∃ c'_1, a = c ++ c'_1 ∧ (c' ++ { toArray := b, size_toArray := ⋯ }).toArray = c'_1 ++ b | 6aa03c7084d30f0e |
Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip₀₁' | Mathlib/Analysis/Complex/Hadamard.lean | /-- **Hadamard three-line theorem** on `re ⁻¹' [0, 1]` (Variant in simpler terms): Let `f` be a
bounded function, continuous on the closed strip `re ⁻¹' [0, 1]` and differentiable on open strip
`re ⁻¹' (0, 1)`. If, for all `z.re = 0`, `‖f z‖ ≤ a` for some `a ∈ ℝ` and, similarly, for all
`z.re = 1`, `‖f z‖ ≤ b` for some `b ∈ ℝ` then for all `z` in the closed strip
`re ⁻¹' [0, 1]` the inequality `‖f(z)‖ ≤ a ^ (1 - z.re) * b ^ z.re` holds. -/
lemma norm_le_interp_of_mem_verticalClosedStrip₀₁' (f : ℂ → E) {z : ℂ} {a b : ℝ}
(hz : z ∈ verticalClosedStrip 0 1) (hd : DiffContOnCl ℂ f (verticalStrip 0 1))
(hB : BddAbove ((norm ∘ f) '' verticalClosedStrip 0 1))
(ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a) (hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b) :
‖f z‖ ≤ a ^ (1 - z.re) * b ^ z.re | E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
a b : ℝ
hz : z ∈ verticalClosedStrip 0 1
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a
hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b
this : ‖interpStrip f z‖ ≤ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re
⊢ sSupNormIm f 0 ^ (1 - z.re) ≤ a ^ (1 - z.re) | apply Real.rpow_le_rpow (sSupNormIm_nonneg f _) _ (sub_nonneg.mpr hz.2) | E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
a b : ℝ
hz : z ∈ verticalClosedStrip 0 1
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a
hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b
this : ‖interpStrip f z‖ ≤ sSupNormIm f 0 ^ (1 - z.re) * sSupNormIm f 1 ^ z.re
⊢ sSupNormIm f 0 ≤ a | 0fab8ad239caab3f |
BitVec.iunfoldr_getLsbD' | Mathlib/.lake/packages/lean4/src/lean/Init/Data/BitVec/Folds.lean | theorem iunfoldr_getLsbD' {f : Fin w → α → α × Bool} (state : Nat → α)
(ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
(∀ i : Fin w, getLsbD (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd)
∧ (iunfoldr f (state 0)).fst = state w | case right
w : Nat
α : Type u_1
f : Fin w → α → α × Bool
state : Nat → α
ind : ∀ (i : Fin w), (f i (state ↑i)).fst = state (↑i + 1)
j : Fin w
s : α
v : BitVec ↑j
ih : ∀ (hj : ↑j ≤ w), (∀ (i : Fin ↑j), (s, v).snd.getLsbD ↑i = (f ⟨↑i, ⋯⟩ (state ↑i)).snd) ∧ (s, v).fst = state ↑j
hj : ↑j + 1 ≤ w
⊢ ((f j (s, v).fst).fst, cons (f j (s, v).fst).snd (s, v).snd).fst = state (↑j + 1) | case right =>
simp
have hj2 : j.val ≤ w := by simp
rw [← ind j, ← (ih hj2).2] | no goals | 2142a073bff43190 |
IntermediateField.mem_adjoin_iff | Mathlib/FieldTheory/IntermediateField/Adjoin/Basic.lean | theorem mem_adjoin_iff (x : E) :
x ∈ adjoin F S ↔ ∃ r s : MvPolynomial S F,
x = MvPolynomial.aeval Subtype.val r / MvPolynomial.aeval Subtype.val s | F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
⊢ x ∈ adjoin F S ↔ ∃ r s, x = (MvPolynomial.aeval Subtype.val) r / (MvPolynomial.aeval Subtype.val) s | rw [← mem_adjoin_range_iff, Subtype.range_coe] | no goals | 366eafc3485b2f7a |
Topology.IsUpperSet.monotone_to_upperTopology_continuous | Mathlib/Topology/Order/UpperLowerSetTopology.lean | lemma monotone_to_upperTopology_continuous [TopologicalSpace α] [TopologicalSpace β]
[Topology.IsUpperSet α] [IsUpper β] {f : α → β} (hf : Monotone f) : Continuous f | α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper β
f : α → β
hf : Monotone f
s : Set β
hs : IsOpen s
⊢ IsUpperSet (f ⁻¹' s) | exact (IsUpper.isUpperSet_of_isOpen hs).preimage hf | no goals | ee33d0fa84466562 |
recursion' | Mathlib/Data/Real/Pi/Irrational.lean | /--
Auxiliary for the proof that `π` is irrational.
While it is most natural to give the recursive formula for `I (n + 2) θ`, as well as give the second
base case of `I 1 θ`, it is in fact more convenient to give the recursive formula for `I (n + 1) θ`
in terms of `I n θ` and `I (n - 1) θ` (note the natural subtraction!).
Despite the usually inconvenient subtraction, this in fact allows deducing both of the above facts
with significantly fewer analysis computations.
In addition, note the `0 ^ n` on the right hand side - this is intentional, and again allows
combining the proof of the "usual" recursion formula and the base case `I 1 θ`.
-/
private lemma recursion' (n : ℕ) :
I (n + 1) θ * θ ^ 2 = - (2 * 2 * ((n + 1) * (0 ^ n * cos θ))) +
2 * (n + 1) * (2 * n + 1) * I n θ - 4 * (n + 1) * n * I (n - 1) θ | case convert_2.convert_2.hg
θ : ℝ
n : ℕ
f : ℝ → ℝ := fun x => 1 - x ^ 2
u₁ : ℝ → ℝ := fun x => f x ^ (n + 1)
u₁' : ℝ → ℝ := fun x => -(2 * (↑n + 1) * x * f x ^ n)
v₁ : ℝ → ℝ := fun x => sin (x * θ)
v₁' : ℝ → ℝ := fun x => cos (x * θ) * θ
u₂ : ℝ → ℝ := fun x => x * f x ^ n
u₂' : ℝ → ℝ := fun x => f x ^ n - 2 * ↑n * x ^ 2 * f x ^ (n - 1)
v₂ : ℝ → ℝ := fun x => cos (x * θ)
v₂' : ℝ → ℝ := fun x => -sin (x * θ) * θ
hfd : Continuous f
hu₁d : Continuous u₁'
hv₁d : Continuous v₁'
hu₂d : Continuous u₂'
hv₂d : Continuous v₂'
hu₁_eval_one : u₁ 1 = 0
hu₁_eval_neg_one : u₁ (-1) = 0
t : u₂ 1 * v₂ 1 - u₂ (-1) * v₂ (-1) = 2 * (0 ^ n * cos θ)
hf : ∀ (x : ℝ), HasDerivAt f (-2 * x) x
hu₁ : ∀ (x : ℝ), HasDerivAt u₁ (u₁' x) x
hv₁ : ∀ (x : ℝ), HasDerivAt v₁ (v₁' x) x
hu₂ : ∀ (x : ℝ), HasDerivAt u₂ (u₂' x) x
hv₂ : ∀ (x : ℝ), HasDerivAt v₂ (v₂' x) x
this✝ : ∀ (x : ℝ), u₂' x = (2 * ↑n + 1) * f x ^ n - 2 * ↑n * f x ^ (n - 1)
this : Continuous v₂
⊢ IntervalIntegrable (fun x => 2 * ↑n * (f x ^ (n - 1) * v₂ x)) volume (-1) 1 | exact Continuous.intervalIntegrable (by fun_prop) _ _ | no goals | 834ac76d1ec60c71 |
AlgebraicGeometry.Scheme.ofRestrict_appIso | Mathlib/AlgebraicGeometry/OpenImmersion.lean | @[simp]
lemma Scheme.ofRestrict_appIso (U) :
(X.ofRestrict h).appIso U = Iso.refl _ | case w
U✝ : TopCat
X : Scheme
f : U✝ ⟶ TopCat.of ↑↑X.toPresheafedSpace
h : IsOpenEmbedding ⇑(ConcreteCategory.hom f)
U : (X.restrict h).Opens
⊢ (Hom.appIso (X.ofRestrict h) U).hom = (Iso.refl Γ(X, X.ofRestrict h ''ᵁ U)).hom | simp only [restrict_presheaf_obj, Hom.appIso_hom', ofRestrict_appLE, homOfLE_refl, op_id,
CategoryTheory.Functor.map_id, Iso.refl_hom] | no goals | 7473df1570c2c905 |
Array.size_eraseIdxIfInBounds | Mathlib/.lake/packages/batteries/Batteries/Data/Array/Lemmas.lean | theorem size_eraseIdxIfInBounds (a : Array α) (i : Nat) :
(a.eraseIdxIfInBounds i).size = if i < a.size then a.size-1 else a.size | case isTrue
α : Type u_1
a : Array α
i : Nat
h✝ : i < a.size
⊢ (a.eraseIdx i h✝).size = a.size - 1
case isFalse
α : Type u_1
a : Array α
i : Nat
h✝ : ¬i < a.size
⊢ a.size = a.size | simp | case isFalse
α : Type u_1
a : Array α
i : Nat
h✝ : ¬i < a.size
⊢ a.size = a.size | c70fb068dccb7279 |
DFinsupp.neLocus_self_sub_left | Mathlib/Data/DFinsupp/NeLocus.lean | theorem neLocus_self_sub_left : neLocus (f - g) f = g.support | α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f g : Π₀ (a : α), N a
⊢ (f - g).neLocus f = g.support | rw [neLocus_comm, neLocus_self_sub_right] | no goals | 552fe3903be4c087 |
MeasureTheory.AEStronglyMeasurable.piecewise | Mathlib/MeasureTheory/Function/StronglyMeasurable/AEStronglyMeasurable.lean | theorem piecewise {s : Set α} [DecidablePred (· ∈ s)]
(hs : MeasurableSet s) (hf : AEStronglyMeasurable f (μ.restrict s))
(hg : AEStronglyMeasurable g (μ.restrict sᶜ)) :
AEStronglyMeasurable (s.piecewise f g) μ | case h
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace β
m₀ : MeasurableSpace α
μ : Measure α
f g : α → β
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
hf : AEStronglyMeasurable f (μ.restrict s)
hg : AEStronglyMeasurable g (μ.restrict sᶜ)
h : ∀ᵐ (x : α) ∂μ, x ∈ sᶜ → g x = AEStronglyMeasurable.mk g hg x
x : α
hx : x ∈ sᶜ → g x = AEStronglyMeasurable.mk g hg x
⊢ x ∈ sᶜ → s.piecewise f g x = s.piecewise (AEStronglyMeasurable.mk f hf) (AEStronglyMeasurable.mk g hg) x | intro hx_mem | case h
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace β
m₀ : MeasurableSpace α
μ : Measure α
f g : α → β
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
hf : AEStronglyMeasurable f (μ.restrict s)
hg : AEStronglyMeasurable g (μ.restrict sᶜ)
h : ∀ᵐ (x : α) ∂μ, x ∈ sᶜ → g x = AEStronglyMeasurable.mk g hg x
x : α
hx : x ∈ sᶜ → g x = AEStronglyMeasurable.mk g hg x
hx_mem : x ∈ sᶜ
⊢ s.piecewise f g x = s.piecewise (AEStronglyMeasurable.mk f hf) (AEStronglyMeasurable.mk g hg) x | 3fd4cff7b1ce1750 |
ProbabilityTheory.condExp_prod_ae_eq_integral_condDistrib' | Mathlib/Probability/Kernel/CondDistrib.lean | theorem condExp_prod_ae_eq_integral_condDistrib' [NormedSpace ℝ F] [CompleteSpace F]
(hX : Measurable X) (hY : AEMeasurable Y μ)
(hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
μ[fun a => f (X a, Y a)|mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a,y) ∂condDistrib Y X μ (X a) | case refine_2.intro.intro
α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hX : Measurable X
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
hf_int' : Integrable (fun a => f (X a, Y a)) μ
t : Set β
ht : MeasurableSet t
a✝ : μ (X ⁻¹' t) < ⊤
⊢ ∫ (y : β), ∫ (y_1 : Ω), f (y, y_1) ∂(condDistrib Y X μ) y ∂Measure.map X (μ.restrict (X ⁻¹' t)) =
∫ (a : α) in X ⁻¹' t, f (X a, Y a) ∂μ | rw [← Measure.restrict_map hX ht, ← Measure.fst_map_prod_mk₀ hY, condDistrib,
Measure.setIntegral_condKernel_univ_right ht hf_int.integrableOn,
setIntegral_map (ht.prod MeasurableSet.univ) hf_int.1 (hX.aemeasurable.prod_mk hY),
mk_preimage_prod, preimage_univ, inter_univ] | no goals | 824ee395dfccb749 |
CategoryTheory.isUniversalColimit_extendCofan | Mathlib/CategoryTheory/Limits/VanKampen.lean | theorem isUniversalColimit_extendCofan {n : ℕ} (f : Fin (n + 1) → C)
{c₁ : Cofan fun i : Fin n ↦ f i.succ} {c₂ : BinaryCofan (f 0) c₁.pt}
(t₁ : IsUniversalColimit c₁) (t₂ : IsUniversalColimit c₂)
[∀ {Z} (i : Z ⟶ c₂.pt), HasPullback c₂.inr i] :
IsUniversalColimit (extendCofan c₁ c₂) | case refine_3
C : Type u
inst✝¹ : Category.{v, u} C
n : ℕ
f : Fin (n + 1) → C
c₁ : Cofan fun i => f i.succ
c₂ : BinaryCofan (f 0) c₁.pt
t₁ : IsUniversalColimit c₁
t₂ : IsUniversalColimit c₂
inst✝ : ∀ {Z : C} (i : Z ⟶ c₂.pt), HasPullback c₂.inr i
F : Discrete (Fin (n + 1)) ⥤ C
c : Cocone F
α : F ⟶ Discrete.functor f
i : c.pt ⟶ (extendCofan c₁ c₂).pt
e : α ≫ (extendCofan c₁ c₂).ι = c.ι ≫ (Functor.const (Discrete (Fin (n + 1)))).map i
hα : NatTrans.Equifibered α
H : ∀ (j : Discrete (Fin (n + 1))), IsPullback (c.ι.app j) (α.app j) i ((extendCofan c₁ c₂).ι.app j)
F' : Fin (n + 1) → C := F.obj ∘ Discrete.mk
this : F = Discrete.functor F'
j : Discrete (Fin n)
⊢ IsPullback
((Cofan.mk (pullback c₂.inr i) fun j =>
pullback.lift (α.app { as := j.succ } ≫ c₁.inj j) (c.ι.app { as := j.succ }) ⋯).ι.app
j)
((Discrete.natTrans fun i => α.app { as := i.as.succ }).app j) (pullback.fst c₂.inr i) (c₁.ι.app j) | simp only [pair_obj_right, Functor.const_obj_obj, Discrete.functor_obj, id_eq,
extendCofan_pt, eq_mpr_eq_cast, Cofan.mk_pt, Cofan.mk_ι_app, Discrete.natTrans_app] | case refine_3
C : Type u
inst✝¹ : Category.{v, u} C
n : ℕ
f : Fin (n + 1) → C
c₁ : Cofan fun i => f i.succ
c₂ : BinaryCofan (f 0) c₁.pt
t₁ : IsUniversalColimit c₁
t₂ : IsUniversalColimit c₂
inst✝ : ∀ {Z : C} (i : Z ⟶ c₂.pt), HasPullback c₂.inr i
F : Discrete (Fin (n + 1)) ⥤ C
c : Cocone F
α : F ⟶ Discrete.functor f
i : c.pt ⟶ (extendCofan c₁ c₂).pt
e : α ≫ (extendCofan c₁ c₂).ι = c.ι ≫ (Functor.const (Discrete (Fin (n + 1)))).map i
hα : NatTrans.Equifibered α
H : ∀ (j : Discrete (Fin (n + 1))), IsPullback (c.ι.app j) (α.app j) i ((extendCofan c₁ c₂).ι.app j)
F' : Fin (n + 1) → C := F.obj ∘ Discrete.mk
this : F = Discrete.functor F'
j : Discrete (Fin n)
⊢ IsPullback (pullback.lift (α.app { as := j.as.succ } ≫ c₁.inj j.as) (c.ι.app { as := j.as.succ }) ⋯)
(α.app { as := j.as.succ }) (pullback.fst c₂.inr i) (c₁.ι.app j) | 26415e6516008f86 |
Ordinal.preOmega_natCast | Mathlib/SetTheory/Cardinal/Aleph.lean | theorem preOmega_natCast (n : ℕ) : preOmega n = n | case succ
n : ℕ
IH : preOmega ↑n = ↑n
⊢ preOmega ↑(n + 1) = ↑(n + 1) | apply (le_preOmega_self _).antisymm' | case succ
n : ℕ
IH : preOmega ↑n = ↑n
⊢ preOmega ↑(n + 1) ≤ ↑(n + 1) | 5ffb6949c81c19a7 |
Std.DHashMap.Internal.List.getValueCast?_insertList_of_mem | Mathlib/.lake/packages/lean4/src/lean/Std/Data/DHashMap/Internal/List/Associative.lean | theorem getValueCast?_insertList_of_mem [BEq α] [LawfulBEq α]
{l toInsert : List ((a : α) × β a)}
{k k' : α} (k_beq : k == k') {v : β k}
(distinct_l : DistinctKeys l)
(distinct_toInsert : toInsert.Pairwise (fun a b => (a.1 == b.1) = false))
(mem : ⟨k, v⟩ ∈ toInsert) :
getValueCast? k' (insertList l toInsert) =
some (cast (by congr; exact LawfulBEq.eq_of_beq k_beq) v) | case e_a
α : Type u
β : α → Type v
γ : α → Type w
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l toInsert : List ((a : α) × β a)
k k' : α
k_beq : (k == k') = true
v : β k
distinct_l : DistinctKeys l
distinct_toInsert : List.Pairwise (fun a b => (a.fst == b.fst) = false) toInsert
mem : ⟨k, v⟩ ∈ toInsert
⊢ k = k' | exact LawfulBEq.eq_of_beq k_beq | no goals | 82c18001be4198ba |
Traversable.toList_spec | Mathlib/Control/Fold.lean | theorem toList_spec (xs : t α) : toList xs = FreeMonoid.toList (foldMap FreeMonoid.of xs) :=
Eq.symm <|
calc
FreeMonoid.toList (foldMap FreeMonoid.of xs) =
FreeMonoid.toList (foldMap FreeMonoid.of xs).reverse.reverse | α : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
xs : t α
⊢ (unop ((Foldl.ofFreeMonoid (flip cons)) (foldMap FreeMonoid.of xs)) []).reverse = toList xs | rw [foldMap_hom_free (Foldl.ofFreeMonoid (flip <| @cons α))] | α : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
xs : t α
⊢ (unop (foldMap (⇑(Foldl.ofFreeMonoid (flip cons)) ∘ FreeMonoid.of) xs) []).reverse = toList xs | 9cc7a5054b1c54eb |
ProbabilityTheory.IndepFun.variance_add | Mathlib/Probability/Variance.lean | theorem IndepFun.variance_add [IsProbabilityMeasure μ] {X Y : Ω → ℝ} (hX : MemLp X 2 μ)
(hY : MemLp Y 2 μ) (h : IndepFun X Y μ) : variance (X + Y) μ = variance X μ + variance Y μ :=
calc
variance (X + Y) μ = μ[fun a => X a ^ 2 + Y a ^ 2 + 2 * X a * Y a] - μ[X + Y] ^ 2 | case hg
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X Y : Ω → ℝ
hX : MemLp X 2 μ
hY : MemLp Y 2 μ
h : IndepFun X Y μ
⊢ Integrable (fun a => Y a ^ 2) μ | exact hY.integrable_sq | no goals | 6996a4817b022b25 |
Finset.mulEnergy_univ_left | Mathlib/Combinatorics/Additive/Energy.lean | @[to_additive (attr := simp)]
lemma mulEnergy_univ_left : Eₘ[univ, t] = Fintype.card α * t.card ^ 2 | α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : CommGroup α
inst✝ : Fintype α
t : Finset α
f : α × α × α → (α × α) × α × α := fun x => ((x.1 * x.2.2, x.1 * x.2.1), x.2)
⊢ Set.InjOn f ↑(univ ×ˢ t ×ˢ t) | rintro ⟨a₁, b₁, c₁⟩ _ ⟨a₂, b₂, c₂⟩ h₂ h | case mk.mk.mk.mk
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : CommGroup α
inst✝ : Fintype α
t : Finset α
f : α × α × α → (α × α) × α × α := fun x => ((x.1 * x.2.2, x.1 * x.2.1), x.2)
a₁ b₁ c₁ : α
a✝ : (a₁, b₁, c₁) ∈ ↑(univ ×ˢ t ×ˢ t)
a₂ b₂ c₂ : α
h₂ : (a₂, b₂, c₂) ∈ ↑(univ ×ˢ t ×ˢ t)
h : f (a₁, b₁, c₁) = f (a₂, b₂, c₂)
⊢ (a₁, b₁, c₁) = (a₂, b₂, c₂) | 744bbda61960c041 |
Nat.succ_dvd_centralBinom | Mathlib/Data/Nat/Choose/Central.lean | theorem succ_dvd_centralBinom (n : ℕ) : n + 1 ∣ n.centralBinom | n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ n + 1 ∣ (2 * n + 1) * n.centralBinom | apply Nat.dvd_of_mul_dvd_mul_left zero_lt_two | n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ 2 * (n + 1) ∣ 2 * ((2 * n + 1) * n.centralBinom) | fb1b90bbcc5f1bf9 |
LinearMap.trace_one | Mathlib/LinearAlgebra/Trace.lean | theorem trace_one : trace R M 1 = (finrank R M : R) | R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Free R M
inst✝ : Module.Finite R M
⊢ (trace R M) 1 = ↑(finrank R M) | cases subsingleton_or_nontrivial R | case inl
R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Free R M
inst✝ : Module.Finite R M
h✝ : Subsingleton R
⊢ (trace R M) 1 = ↑(finrank R M)
case inr
R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Free R M
inst✝ : Module.Finite R M
h✝ : Nontrivial R
⊢ (trace R M) 1 = ↑(finrank R M) | 4959d10d80e34ef9 |
Equiv.Perm.signAux_swap_zero_one' | Mathlib/GroupTheory/Perm/Sign.lean | theorem signAux_swap_zero_one' (n : ℕ) : signAux (swap (0 : Fin (n + 2)) 1) = -1 :=
show _ = ∏ x ∈ {(⟨1, 0⟩ : Σ _ : Fin (n + 2), Fin (n + 2))},
if (Equiv.swap 0 1) x.1 ≤ swap 0 1 x.2 then (-1 : ℤˣ) else 1 by
refine Eq.symm (prod_subset (fun ⟨x₁, x₂⟩ => by
simp +contextual [mem_finPairsLT, Fin.one_pos]) fun a ha₁ ha₂ => ?_)
rcases a with ⟨a₁, a₂⟩
replace ha₁ : a₂ < a₁ := mem_finPairsLT.1 ha₁
dsimp only
rcases a₁.zero_le.eq_or_lt with (rfl | H)
· exact absurd a₂.zero_le ha₁.not_le
rcases a₂.zero_le.eq_or_lt with (rfl | H')
· simp only [and_true, eq_self_iff_true, heq_iff_eq, mem_singleton, Sigma.mk.inj_iff] at ha₂
have : 1 < a₁ := lt_of_le_of_ne (Nat.succ_le_of_lt ha₁)
(Ne.symm (by intro h; apply ha₂; simp [h]))
have h01 : Equiv.swap (0 : Fin (n + 2)) 1 0 = 1 | case mk
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1 | rcases a₁.zero_le.eq_or_lt with (rfl | H) | case mk.inl
n : ℕ
a₂ : Fin (n + 2)
ha₂ : ⟨0, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < 0
⊢ (if (swap 0 1) 0 ≤ (swap 0 1) a₂ then -1 else 1) = 1
case mk.inr
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1 | 31014fc4c4be8869 |
abs_sub_round_eq_min | Mathlib/Algebra/Order/Round.lean | theorem abs_sub_round_eq_min (x : α) : |x - round x| = min (fract x) (1 - fract x) | α : Type u_2
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
hx : fract x ≥ 1 - fract x
⊢ 0 < fract x | replace hx : 0 < fract x + fract x := lt_of_lt_of_le zero_lt_one (tsub_le_iff_left.mp hx) | α : Type u_2
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
hx : 0 < fract x + fract x
⊢ 0 < fract x | 04106663884a2f2b |
Module.End.eigenspace_restrict_le_eigenspace | Mathlib/LinearAlgebra/Eigenspace/Basic.lean | theorem eigenspace_restrict_le_eigenspace (f : End R M) {p : Submodule R M} (hfp : ∀ x ∈ p, f x ∈ p)
(μ : R) : (eigenspace (f.restrict hfp) μ).map p.subtype ≤ f.eigenspace μ | case intro.intro
R : Type v
M : Type w
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hfp : ∀ x ∈ p, f x ∈ p
μ : R
x : ↥p
hx : x ∈ ↑(eigenspace (LinearMap.restrict f hfp) μ)
⊢ p.subtype x ∈ f.eigenspace μ | simp only [SetLike.mem_coe, mem_eigenspace_iff, LinearMap.restrict_apply] at hx ⊢ | case intro.intro
R : Type v
M : Type w
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hfp : ∀ x ∈ p, f x ∈ p
μ : R
x : ↥p
hx : ⟨f ↑x, ⋯⟩ = μ • x
⊢ f (p.subtype x) = μ • p.subtype x | b2a6d59fdcc08e4e |
IsFractional.mul | Mathlib/RingTheory/FractionalIdeal/Basic.lean | theorem _root_.IsFractional.mul {I J : Submodule R P} :
IsFractional S I → IsFractional S J → IsFractional S (I * J : Submodule R P)
| ⟨aI, haI, hI⟩, ⟨aJ, haJ, hJ⟩ =>
⟨aI * aJ, S.mul_mem haI haJ, fun b hb => by
refine Submodule.mul_induction_on hb ?_ ?_
· intro m hm n hn
obtain ⟨n', hn'⟩ := hJ n hn
rw [mul_smul, mul_comm m, ← smul_mul_assoc, ← hn', ← Algebra.smul_def]
apply hI
exact Submodule.smul_mem _ _ hm
· intro x y hx hy
rw [smul_add]
apply isInteger_add hx hy⟩
| case refine_1
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
I J : Submodule R P
aI : R
haI : aI ∈ S
hI : ∀ b ∈ I, IsInteger R (aI • b)
aJ : R
haJ : aJ ∈ S
hJ : ∀ b ∈ J, IsInteger R (aJ • b)
b : P
hb : b ∈ I * J
⊢ ∀ m ∈ I, ∀ n ∈ J, IsInteger R ((aI * aJ) • (m * n)) | intro m hm n hn | case refine_1
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
I J : Submodule R P
aI : R
haI : aI ∈ S
hI : ∀ b ∈ I, IsInteger R (aI • b)
aJ : R
haJ : aJ ∈ S
hJ : ∀ b ∈ J, IsInteger R (aJ • b)
b : P
hb : b ∈ I * J
m : P
hm : m ∈ I
n : P
hn : n ∈ J
⊢ IsInteger R ((aI * aJ) • (m * n)) | 003413a5af38d292 |
AlgebraicGeometry.affineAnd_isLocal | Mathlib/AlgebraicGeometry/Morphisms/AffineAnd.lean | /-- `affineAnd P` is local if `P` is local on the (algebraic) source. -/
lemma affineAnd_isLocal (hPi : RingHom.RespectsIso Q) (hQl : RingHom.LocalizationAwayPreserves Q)
(hQs : RingHom.OfLocalizationSpan Q) : (affineAnd Q).IsLocal where
respectsIso := affineAnd_respectsIso hPi
to_basicOpen {X Y _} f r := fun ⟨hX, hf⟩ ↦ by
simp only [Opens.map_top] at hf
constructor
· simp only [Scheme.preimage_basicOpen, Opens.map_top]
exact (isAffineOpen_top X).basicOpen _
· dsimp only
rw [morphismRestrict_appTop, CommRingCat.hom_comp, hPi.cancel_right_isIso]
-- Not sure why the `show` fixes the following `rw` complaining about "motive is incorrect"
show Q (Scheme.Hom.app f ((Y.basicOpen r).ι ''ᵁ ⊤)).hom
rw [Scheme.Opens.ι_image_top]
rw [(isAffineOpen_top Y).app_basicOpen_eq_away_map f (isAffineOpen_top X),
CommRingCat.hom_comp, hPi.cancel_right_isIso, ← Scheme.Hom.appTop]
dsimp only [Opens.map_top]
haveI := (isAffineOpen_top X).isLocalization_basicOpen (f.appTop r)
apply hQl
exact hf
of_basicOpenCover {X Y _} f s hs hf | Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hPi : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => Q
hQl : RingHom.LocalizationAwayPreserves fun {R S} [CommRing R] [CommRing S] => Q
hQs : RingHom.OfLocalizationSpan fun {R S} [CommRing R] [CommRing S] => Q
X Y : Scheme
x✝ : IsAffine Y
f : X ⟶ Y
s : Finset ↑Γ(Y, ⊤)
hs : Ideal.span ↑s = ⊤
hf :
∀ (r : { x // x ∈ s }),
IsAffine ↑(f ⁻¹ᵁ Y.basicOpen ↑r) ∧ Q (CommRingCat.Hom.hom (Scheme.Hom.appTop (f ∣_ Y.basicOpen ↑r)))
this : IsAffine X
⊢ affineAnd (fun {R S} [CommRing R] [CommRing S] => Q) f | refine ⟨inferInstance, hQs.ofIsLocalization' hPi (f.appTop).hom s hs fun a ↦ ?_⟩ | Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hPi : RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => Q
hQl : RingHom.LocalizationAwayPreserves fun {R S} [CommRing R] [CommRing S] => Q
hQs : RingHom.OfLocalizationSpan fun {R S} [CommRing R] [CommRing S] => Q
X Y : Scheme
x✝ : IsAffine Y
f : X ⟶ Y
s : Finset ↑Γ(Y, ⊤)
hs : Ideal.span ↑s = ⊤
hf :
∀ (r : { x // x ∈ s }),
IsAffine ↑(f ⁻¹ᵁ Y.basicOpen ↑r) ∧ Q (CommRingCat.Hom.hom (Scheme.Hom.appTop (f ∣_ Y.basicOpen ↑r)))
this : IsAffine X
a : ↑↑s
⊢ ∃ Rᵣ Sᵣ x x_1 x_2 x_3,
∃ (x_4 : IsLocalization.Away (↑a) Rᵣ) (x_5 :
IsLocalization.Away ((CommRingCat.Hom.hom (Scheme.Hom.appTop f)) ↑a) Sᵣ),
Q (IsLocalization.Away.map Rᵣ Sᵣ (CommRingCat.Hom.hom (Scheme.Hom.appTop f)) ↑a) | 2b5f5ef2a8aa609c |
List.pairwise_filter | Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Pairwise.lean | theorem pairwise_filter {p : α → Prop} [DecidablePred p] {l : List α} :
Pairwise R (filter p l) ↔ Pairwise (fun x y => p x → p y → R x y) l | α : Type u_1
R : α → α → Prop
p : α → Prop
inst✝ : DecidablePred p
l : List α
⊢ Pairwise R (filter (fun b => decide (p b)) l) ↔ Pairwise (fun x y => p x → p y → R x y) l | rw [← filterMap_eq_filter, pairwise_filterMap] | α : Type u_1
R : α → α → Prop
p : α → Prop
inst✝ : DecidablePred p
l : List α
⊢ Pairwise
(fun a a' =>
∀ (b : α),
b ∈ Option.guard (fun x => decide (p x) = true) a →
∀ (b' : α), b' ∈ Option.guard (fun x => decide (p x) = true) a' → R b b')
l ↔
Pairwise (fun x y => p x → p y → R x y) l | 7ca88e024fd3a25b |
SetTheory.PGame.insertRight_numeric | Mathlib/SetTheory/Surreal/Basic.lean | theorem insertRight_numeric {x x' : PGame} (x_num : x.Numeric) (x'_num : x'.Numeric)
(h : x ≤ x') : (insertRight x x').Numeric | x x' : PGame
x_num : x.Numeric
x'_num : x'.Numeric
h : x ≤ x'
⊢ (-(-x).insertLeft (-x')).Numeric | apply Numeric.neg | case x
x x' : PGame
x_num : x.Numeric
x'_num : x'.Numeric
h : x ≤ x'
⊢ ((-x).insertLeft (-x')).Numeric | 3fe52f8d55a21b54 |
SimpleGraph.Walk.concat_inj | Mathlib/Combinatorics/SimpleGraph/Walk.lean | theorem concat_inj {u v v' w : V} {p : G.Walk u v} {h : G.Adj v w} {p' : G.Walk u v'}
{h' : G.Adj v' w} (he : p.concat h = p'.concat h') : ∃ hv : v = v', p.copy rfl hv = p' | case nil.cons.intro
V : Type u
G : SimpleGraph V
u v v' w : V
h' : G.Adj v' w
u✝ : V
h h✝ : G.Adj u✝ w
p✝ : G.Walk w v'
he : nil = p✝.concat h'
⊢ False | exact concat_ne_nil _ _ he.symm | no goals | 6aa77e2092977f18 |
contDiffWithinAt_localInvariantProp_of_le | Mathlib/Geometry/Manifold/ContMDiff/Defs.lean | theorem contDiffWithinAt_localInvariantProp_of_le (n m : WithTop ℕ∞) (hmn : m ≤ n) :
(contDiffGroupoid n I).LocalInvariantProp (contDiffGroupoid n I')
(ContDiffWithinAtProp I I' m) where
is_local {s x u f} u_open xu | case convert_2
𝕜 : 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
E' : Type u_5
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
n m : WithTop ℕ∞
hmn : m ≤ n
s : Set H
x : H
f : H → H'
e : PartialHomeomorph H H
he : e ∈ contDiffGroupoid n I
hx : x ∈ e.source
h : ContDiffWithinAt 𝕜 m (↑I' ∘ f ∘ ↑I.symm) (↑I.symm ⁻¹' s ∩ range ↑I) ((↑I ∘ ↑e.symm ∘ ↑I.symm) (↑I (↑e x)))
this✝¹ : ↑I x = (↑I ∘ ↑e.symm ∘ ↑I.symm) (↑I (↑e x))
this✝ : ↑I (↑e x) ∈ ↑I.symm ⁻¹' e.target ∩ range ↑I
this : ContDiffWithinAt 𝕜 n (↑I ∘ ↑e.symm ∘ ↑I.symm) (↑I.symm ⁻¹' e.target ∩ range ↑I) (↑I (↑e x))
⊢ ↑I.symm ⁻¹' e.target ∩ (↑I.symm ⁻¹' (↑e.symm ⁻¹' s) ∩ range ↑I) ⊆
↑I.symm ⁻¹' e.target ∩ range ↑I ∩ ↑I ∘ ↑e.symm ∘ ↑I.symm ⁻¹' (↑I.symm ⁻¹' s ∩ range ↑I) | mfld_set_tac | no goals | 841928255da4a913 |
MeasureTheory.Measure.eq_withDensity_rnDeriv | Mathlib/MeasureTheory/Decomposition/Lebesgue.lean | theorem eq_withDensity_rnDeriv {s : Measure α} {f : α → ℝ≥0∞} (hf : Measurable f) (hs : s ⟂ₘ ν)
(hadd : μ = s + ν.withDensity f) : ν.withDensity f = ν.withDensity (μ.rnDeriv ν) | α : Type u_1
m : MeasurableSpace α
μ ν s : Measure α
f : α → ℝ≥0∞
hf : Measurable f
hs : s ⟂ₘ ν
hadd : μ = s + ν.withDensity f
⊢ ν.withDensity f = ν.withDensity (μ.rnDeriv ν) | have : HaveLebesgueDecomposition μ ν := ⟨⟨⟨s, f⟩, hf, hs, hadd⟩⟩ | α : Type u_1
m : MeasurableSpace α
μ ν s : Measure α
f : α → ℝ≥0∞
hf : Measurable f
hs : s ⟂ₘ ν
hadd : μ = s + ν.withDensity f
this : μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity f = ν.withDensity (μ.rnDeriv ν) | fc3f06ec8038d87c |
MeasureTheory.continuous_of_dominated | Mathlib/MeasureTheory/Integral/Bochner.lean | theorem continuous_of_dominated {F : X → α → G} {bound : α → ℝ}
(hF_meas : ∀ x, AEStronglyMeasurable (F x) μ) (h_bound : ∀ x, ∀ᵐ a ∂μ, ‖F x a‖ ≤ bound a)
(bound_integrable : Integrable bound μ) (h_cont : ∀ᵐ a ∂μ, Continuous fun x => F x a) :
Continuous fun x => ∫ a, F x a ∂μ | case pos
α : Type u_1
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
F : X → α → G
bound : α → ℝ
hF_meas : ∀ (x : X), AEStronglyMeasurable (F x) μ
h_bound : ∀ (x : X), ∀ᵐ (a : α) ∂μ, ‖F x a‖ ≤ bound a
bound_integrable : Integrable bound μ
h_cont : ∀ᵐ (a : α) ∂μ, Continuous fun x => F x a
hG : CompleteSpace G
⊢ Continuous fun x => ∫ (a : α), F x a ∂μ | simp only [integral, hG, L1.integral] | case pos
α : Type u_1
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
F : X → α → G
bound : α → ℝ
hF_meas : ∀ (x : X), AEStronglyMeasurable (F x) μ
h_bound : ∀ (x : X), ∀ᵐ (a : α) ∂μ, ‖F x a‖ ≤ bound a
bound_integrable : Integrable bound μ
h_cont : ∀ᵐ (a : α) ∂μ, Continuous fun x => F x a
hG : CompleteSpace G
⊢ Continuous fun x =>
if h : True then
if hf : Integrable (fun a => F x a) μ then L1.integralCLM (Integrable.toL1 (fun a => F x a) hf) else 0
else 0 | 4a2462339b98c2fb |
Localization.smul_mk | Mathlib/GroupTheory/MonoidLocalization/Basic.lean | theorem smul_mk [SMul R M] [IsScalarTower R M M] (c : R) (a b) :
c • (mk a b : Localization S) = mk (c • a) b | M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
R : Type u_4
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : ↥S
⊢ (c • 1) • a /ₒ (b * 1) = c • a /ₒ b | rw [smul_assoc, one_smul, mul_one] | no goals | f28c11ec5885a209 |
isZero_Ext_succ_of_projective | Mathlib/CategoryTheory/Abelian/Ext.lean | /-- If `X : C` is projective and `n : ℕ`, then `Ext^(n + 1) X Y ≅ 0` for any `Y`. -/
lemma isZero_Ext_succ_of_projective (X Y : C) [Projective X] (n : ℕ) :
IsZero (((Ext R C (n + 1)).obj (Opposite.op X)).obj Y) | case hf.h
R : Type u_1
inst✝⁵ : Ring R
C : Type u_2
inst✝⁴ : Category.{u_3, u_2} C
inst✝³ : Abelian C
inst✝² : Linear R C
inst✝¹ : EnoughProjectives C
X Y : C
inst✝ : Projective X
n : ℕ
⊢ (ModuleCat.Hom.hom (𝟙 (((linearYoneda R C).obj Y).obj (Opposite.op (((ChainComplex.single₀ C).obj X).X (n + 1))))))
0 =
(ModuleCat.Hom.hom 0) 0 | rfl | no goals | 40abdca1318b58b3 |
eVariationOn.add_point | Mathlib/Topology/EMetricSpace/BoundedVariation.lean | theorem add_point (f : α → E) {s : Set α} {x : α} (hx : x ∈ s) (u : ℕ → α) (hu : Monotone u)
(us : ∀ i, u i ∈ s) (n : ℕ) :
∃ (v : ℕ → α) (m : ℕ), Monotone v ∧ (∀ i, v i ∈ s) ∧ x ∈ v '' Iio m ∧
(∑ i ∈ Finset.range n, edist (f (u (i + 1))) (f (u i))) ≤
∑ j ∈ Finset.range m, edist (f (v (j + 1))) (f (v j)) | case inr.refine_2
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
hw : Monotone w
⊢ ∑ i ∈ Finset.range n, edist (f (u (i + 1))) (f (u i)) ≤ ∑ j ∈ Finset.range (n + 1), edist (f (w (j + 1))) (f (w j)) | rcases eq_or_lt_of_le (zero_le N) with (Npos | Npos) | case inr.refine_2.inl
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
hw : Monotone w
Npos : 0 = N
⊢ ∑ i ∈ Finset.range n, edist (f (u (i + 1))) (f (u i)) ≤ ∑ j ∈ Finset.range (n + 1), edist (f (w (j + 1))) (f (w j))
case inr.refine_2.inr
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
hw : Monotone w
Npos : 0 < N
⊢ ∑ i ∈ Finset.range n, edist (f (u (i + 1))) (f (u i)) ≤ ∑ j ∈ Finset.range (n + 1), edist (f (w (j + 1))) (f (w j)) | 760e94573f7a043d |
Homotopy.nullHomotopicMap_comp | Mathlib/Algebra/Homology/Homotopy.lean | theorem nullHomotopicMap_comp (hom : ∀ i j, C.X i ⟶ D.X j) (g : D ⟶ E) :
nullHomotopicMap hom ≫ g = nullHomotopicMap fun i j => hom i j ≫ g.f j | case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
hom : (i j : ι) → C.X i ⟶ D.X j
g : D ⟶ E
n : ι
⊢ (C.dFrom n ≫ hom (c.next n) n + hom n (c.prev n) ≫ D.dTo n) ≫ g.f n =
C.dFrom n ≫ hom (c.next n) n ≫ g.f n + (hom n (c.prev n) ≫ g.f (c.prev n)) ≫ E.dTo n | simp only [Preadditive.add_comp, assoc, g.comm] | no goals | 08696897e099d0bd |
ContinuousMultilinearMap.hasFTaylorSeriesUpTo_iteratedFDeriv | Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | theorem hasFTaylorSeriesUpTo_iteratedFDeriv :
HasFTaylorSeriesUpTo ⊤ f (fun v n ↦ f.iteratedFDeriv n v) | 𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
⊢ HasFTaylorSeriesUpTo ⊤ ⇑f fun v n => f.iteratedFDeriv n v | constructor | case zero_eq
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
⊢ ∀ (x : (i : ι) → E i), (f.iteratedFDeriv 0 x).curry0 = f x
case fderiv
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
⊢ ∀ (m : ℕ),
↑m < ⊤ → ∀ (x : (i : ι) → E i), HasFDerivAt (fun y => f.iteratedFDeriv m y) (f.iteratedFDeriv m.succ x).curryLeft x
case cont
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
⊢ ∀ (m : ℕ), ↑m ≤ ⊤ → Continuous fun x => f.iteratedFDeriv m x | ae8227810170d45c |
IsPGroup.smul_mul_inv_trivial_or_surjective | Mathlib/GroupTheory/SpecificGroups/ZGroup.lean | theorem smul_mul_inv_trivial_or_surjective [IsCyclic G] (hG : IsPGroup p G)
{K : Type*} [Group K] [MulDistribMulAction K G] (hGK : (Nat.card G).Coprime (Nat.card K)) :
(∀ g : G, ∀ k : K, k • g * g⁻¹ = 1) ∨ (∀ g : G, ∃ k : K, ∃ q : G, k • q * q⁻¹ = g) | case neg.inr.intro.intro.mk
G : Type u_1
inst✝⁴ : Group G
p✝ : ℕ
inst✝³ : Fact (Nat.Prime p✝)
inst✝² : IsCyclic G
K : Type u_4
inst✝¹ : Group K
inst✝ : MulDistribMulAction K G
hGK : (Nat.card G).Coprime (Nat.card K)
hc : ¬Nat.card G = 0
this : Finite G
ϕ : K →* ZMod (Nat.card G) := MulDistribMulAction.toMonoidHomZModOfIsCyclic G K ⋯
h : ∀ (g : G) (k : K) (n : ℤ), ϕ k - 1 = ↑n → k • g * g⁻¹ = g ^ n
hG : ∀ (k : K), ϕ k = 1 ∨ IsUnit (ϕ k - 1)
k : K
hk : ¬ϕ k = 1
u v : ZMod (Nat.card G)
hvu : v.cast * u.cast ≡ 1 [ZMOD ↑(Nat.card G)]
hu : ↑u.cast = ϕ k - 1
p : G
⊢ k • p ^ v.cast * (p ^ v.cast)⁻¹ = p ^ 1 | rw [h (p ^ v.cast) k u.cast hu.symm, ← zpow_mul, zpow_eq_zpow_iff_modEq] | case neg.inr.intro.intro.mk
G : Type u_1
inst✝⁴ : Group G
p✝ : ℕ
inst✝³ : Fact (Nat.Prime p✝)
inst✝² : IsCyclic G
K : Type u_4
inst✝¹ : Group K
inst✝ : MulDistribMulAction K G
hGK : (Nat.card G).Coprime (Nat.card K)
hc : ¬Nat.card G = 0
this : Finite G
ϕ : K →* ZMod (Nat.card G) := MulDistribMulAction.toMonoidHomZModOfIsCyclic G K ⋯
h : ∀ (g : G) (k : K) (n : ℤ), ϕ k - 1 = ↑n → k • g * g⁻¹ = g ^ n
hG : ∀ (k : K), ϕ k = 1 ∨ IsUnit (ϕ k - 1)
k : K
hk : ¬ϕ k = 1
u v : ZMod (Nat.card G)
hvu : v.cast * u.cast ≡ 1 [ZMOD ↑(Nat.card G)]
hu : ↑u.cast = ϕ k - 1
p : G
⊢ v.cast * u.cast ≡ 1 [ZMOD ↑(orderOf p)] | b33bc739e8adc37b |
abs_one_div | Mathlib/Algebra/Order/Field/Basic.lean | theorem abs_one_div (a : α) : |1 / a| = 1 / |a| | α : Type u_2
inst✝ : LinearOrderedField α
a : α
⊢ |1 / a| = 1 / |a| | rw [abs_div, abs_one] | no goals | ed2a7b8e8201fe19 |
Nat.card_pair_lcm_eq.f_img | Mathlib/Algebra/Order/Antidiag/Nat.lean | theorem f_img {n : ℕ} (hn : Squarefree n) (a : Fin 3 → ℕ)
(ha : a ∈ finMulAntidiag 3 n) :
f a ha ∈ Finset.filter (fun ⟨x, y⟩ => x.lcm y = n) (n.divisors ×ˢ n.divisors) | case h
n : ℕ
hn : Squarefree n
a : Fin 3 → ℕ
ha : a ∈ finMulAntidiag 3 n
⊢ a 0 * a 1 * a 2 = a 1 * a 2 * a 0 | ring | no goals | 266d4fcf66130dfe |
Batteries.RBNode.Balanced.zoom | Mathlib/.lake/packages/batteries/Batteries/Data/RBMap/Alter.lean | theorem _root_.Batteries.RBNode.Balanced.zoom : t.Balanced c n → path.Balanced c₀ n₀ c n →
zoom cut t path = (t', path') → ∃ c n, t'.Balanced c n ∧ path'.Balanced c₀ n₀ c n
| .nil, hp => fun e => by cases e; exact ⟨_, _, .nil, hp⟩
| .red ha hb, hp => by
unfold zoom; split
· exact ha.zoom (.redL hb hp)
· exact hb.zoom (.redR ha hp)
· intro e; cases e; exact ⟨_, _, .red ha hb, hp⟩
| .black ha hb, hp => by
unfold zoom; split
· exact ha.zoom (.blackL hb hp)
· exact hb.zoom (.blackR ha hp)
· intro e; cases e; exact ⟨_, _, .black ha hb, hp⟩
| case h_3
α✝ : Type u_1
cut : α✝ → Ordering
t : RBNode α✝
path : Path α✝
t' : RBNode α✝
path' : Path α✝
c₀ : RBColor
n₀ : Nat
c : RBColor
n✝ n : Nat
x✝¹ y✝ : RBNode α✝
v✝ : α✝
ha : x✝¹.Balanced black n
hb : y✝.Balanced black n
hp : Path.Balanced c₀ n₀ path red n
x✝ : Ordering
heq✝ : cut v✝ = Ordering.eq
e : (node red x✝¹ v✝ y✝, path) = (t', path')
⊢ ∃ c n, t'.Balanced c n ∧ Path.Balanced c₀ n₀ path' c n | cases e | case h_3.refl
α✝ : Type u_1
cut : α✝ → Ordering
t : RBNode α✝
path : Path α✝
c₀ : RBColor
n₀ : Nat
c : RBColor
n✝ n : Nat
x✝¹ y✝ : RBNode α✝
v✝ : α✝
ha : x✝¹.Balanced black n
hb : y✝.Balanced black n
hp : Path.Balanced c₀ n₀ path red n
x✝ : Ordering
heq✝ : cut v✝ = Ordering.eq
⊢ ∃ c n, (node red x✝¹ v✝ y✝).Balanced c n ∧ Path.Balanced c₀ n₀ path c n | cff44faeb7153c11 |
Polynomial.content_X_mul | Mathlib/RingTheory/Polynomial/Content.lean | theorem content_X_mul {p : R[X]} : content (X * p) = content p | case h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
a : ℕ
⊢ ¬(X * p).coeff a = 0 ↔ ∃ a_1, ¬p.coeff a_1 = 0 ∧ a_1.succ = a | rcases a with - | a | case h.zero
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ ¬(X * p).coeff 0 = 0 ↔ ∃ a, ¬p.coeff a = 0 ∧ a.succ = 0
case h.succ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
a : ℕ
⊢ ¬(X * p).coeff (a + 1) = 0 ↔ ∃ a_1, ¬p.coeff a_1 = 0 ∧ a_1.succ = a + 1 | ac071a5a6c3a3683 |
Submodule.LinearDisjoint.of_linearDisjoint_fg_right | Mathlib/LinearAlgebra/LinearDisjoint.lean | theorem of_linearDisjoint_fg_right
(H : ∀ N' : Submodule R S, N' ≤ N → N'.FG → M.LinearDisjoint N') :
M.LinearDisjoint N := (linearDisjoint_iff _ _).2 fun x y hxy ↦ by
obtain ⟨N', hN, hFG, h⟩ :=
TensorProduct.exists_finite_submodule_right_of_finite' {x, y} (Set.toFinite _)
rw [Module.Finite.iff_fg] at hFG
obtain ⟨x', hx'⟩ := h (show x ∈ {x, y} by simp)
obtain ⟨y', hy'⟩ := h (show y ∈ {x, y} by simp)
rw [← hx', ← hy']; congr
exact (H N' hN hFG).injective (by simp [← mulMap_comp_lTensor _ hN, hx', hy', hxy])
| case intro.intro.intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
H : ∀ N' ≤ N, N'.FG → M.LinearDisjoint N'
x y : ↥M ⊗[R] ↥N
hxy : (M.mulMap N) x = (M.mulMap N) y
N' : Submodule R S
hN : N' ≤ N
hFG : N'.FG
h : {x, y} ⊆ ↑(LinearMap.range (LinearMap.lTensor (↥M) (inclusion hN)))
⊢ x = y | obtain ⟨x', hx'⟩ := h (show x ∈ {x, y} by simp) | case intro.intro.intro.intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
H : ∀ N' ≤ N, N'.FG → M.LinearDisjoint N'
x y : ↥M ⊗[R] ↥N
hxy : (M.mulMap N) x = (M.mulMap N) y
N' : Submodule R S
hN : N' ≤ N
hFG : N'.FG
h : {x, y} ⊆ ↑(LinearMap.range (LinearMap.lTensor (↥M) (inclusion hN)))
x' : ↥M ⊗[R] ↥N'
hx' : (LinearMap.lTensor (↥M) (inclusion hN)) x' = x
⊢ x = y | 3ea9d0fb125f2a5e |
WithSeminorms.isVonNBounded_iff_seminorm_bounded | Mathlib/Analysis/LocallyConvex/WithSeminorms.lean | theorem WithSeminorms.isVonNBounded_iff_seminorm_bounded {s : Set E} (hp : WithSeminorms p) :
Bornology.IsVonNBounded 𝕜 s ↔ ∀ i : ι, ∃ r > 0, ∀ x ∈ s, p i x < r | case neg
𝕜 : Type u_1
E : Type u_5
ι : Type u_8
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
p : SeminormFamily 𝕜 E ι
inst✝ : TopologicalSpace E
s : Set E
hp : WithSeminorms p
hi : ∀ (i : ι), ∃ r > 0, ∀ x ∈ s, (p i) x < r
I : Finset ι
hI : ¬I.Nonempty
⊢ ∃ r > 0, ∀ x ∈ s, (I.sup p) x < r | simp only [Finset.not_nonempty_iff_eq_empty.mp hI, Finset.sup_empty, coe_bot, Pi.zero_apply,
exists_prop] | case neg
𝕜 : Type u_1
E : Type u_5
ι : Type u_8
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
p : SeminormFamily 𝕜 E ι
inst✝ : TopologicalSpace E
s : Set E
hp : WithSeminorms p
hi : ∀ (i : ι), ∃ r > 0, ∀ x ∈ s, (p i) x < r
I : Finset ι
hI : ¬I.Nonempty
⊢ ∃ r > 0, ∀ x ∈ s, 0 < r | 24b13a155e892387 |
End of preview. Expand
in Data Studio
ABOUT
This is the result of running the LeanDojo extractor on Mathlib 4.18. It was extracted by Charlie Meyer, and has been published here so I can desecrate his work without bothering him.
Purpose
You could use this to fine tune language models to output in a certain format for automated theorem proving.
- Downloads last month
- 22