Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | goals listlengths 0 224 | goals_before listlengths 0 220 |
|---|---|---|---|---|---|---|---|
import Mathlib.Analysis.NormedSpace.AffineIsometry
import Mathlib.Topology.Algebra.ContinuousAffineMap
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
#align_import analysis.normed_space.continuous_affine_map from "leanprover-community/mathlib"@"17ef379e997badd73e5eabb4d38f11919ab3c4b3"
namespace Con... | Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean | 66 | 67 | theorem coe_contLinear_eq_linear (f : P βᴬ[R] Q) :
(f.contLinear : V ββ[R] W) = (f : P βα΅[R] Q).linear := by | ext; rfl
| [
" Continuous { toFun := βf.linear, map_add' := β―, map_smul' := β― }.toFun",
" Continuous βf.toAffineMap",
" βf.contLinear = f.linear",
" βf.contLinear xβ = f.linear xβ"
] | [
" Continuous { toFun := βf.linear, map_add' := β―, map_smul' := β― }.toFun",
" Continuous βf.toAffineMap"
] |
import Mathlib.Algebra.Lie.OfAssociative
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.LinearAlgebra.Matrix.ToLinearEquiv
#align_import algebra.lie.matrix from "leanprover-community/mathlib"@"55e2dfde0cff928ce5c70926a3f2c7dee3e2dd99"
universe u v w wβ wβ
section Matrices
open scoped Matrix
variabl... | Mathlib/Algebra/Lie/Matrix.lean | 76 | 79 | theorem Matrix.lieConj_symm_apply (P A : Matrix n n R) (h : Invertible P) :
(P.lieConj h).symm A = Pβ»ΒΉ * A * P := by |
simp [LinearEquiv.symm_conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp,
LinearMap.toMatrix'_toLin']
| [
" (β__srcβ).toFun β
T, Sβ = β
(β__srcβ).toFun T, (β__srcβ).toFun Sβ",
" f (T ββ S - S ββ T) = f T * f S - f S * f T",
" (P.lieConj h) A = P * A * Pβ»ΒΉ",
" (P.lieConj h).symm A = Pβ»ΒΉ * A * P"
] | [
" (β__srcβ).toFun β
T, Sβ = β
(β__srcβ).toFun T, (β__srcβ).toFun Sβ",
" f (T ββ S - S ββ T) = f T * f S - f S * f T",
" (P.lieConj h) A = P * A * Pβ»ΒΉ"
] |
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Analysis.LocallyConvex.Barrelled
import Mathlib.Topology.Baire.CompleteMetrizable
#align_import analysis.normed_space.banach_steinhaus from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set
variable {E F οΏ½... | Mathlib/Analysis/NormedSpace/BanachSteinhaus.lean | 47 | 51 | theorem banach_steinhaus_iSup_nnnorm {ΞΉ : Type*} [CompleteSpace E] {g : ΞΉ β E βSL[Οββ] F}
(h : β x, (β¨ i, ββg i xββ) < β) : (β¨ i, ββg iββ) < β := by |
rw [show ((β¨ i, ββg iββ) < β) β _ from (NormedSpace.equicontinuous_TFAE g).out 8 2]
refine (norm_withSeminorms πβ F).banach_steinhaus (fun _ x β¦ ?_)
simpa [β NNReal.bddAbove_coe, β Set.range_comp] using ENNReal.iSup_coe_lt_top.1 (h x)
| [
" β C', β (i : ΞΉ), βg iβ β€ C'",
" UniformEquicontinuous (DFunLike.coe β g)",
" BddAbove (range fun i => (normSeminorm πβ F) ((g i) x))",
" β¨ i, ββg iββ < β€"
] | [
" β C', β (i : ΞΉ), βg iβ β€ C'",
" UniformEquicontinuous (DFunLike.coe β g)",
" BddAbove (range fun i => (normSeminorm πβ F) ((g i) x))"
] |
import Mathlib.RingTheory.RootsOfUnity.Basic
import Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed
import Mathlib.Algebra.GCDMonoid.IntegrallyClosed
import Mathlib.FieldTheory.Finite.Basic
#align_import ring_theory.roots_of_unity.minpoly from "leanprover-community/mathlib"@"7fdeecc0d03cd40f7a165e6cf00a4d2286db599f"
... | Mathlib/RingTheory/RootsOfUnity/Minpoly.lean | 53 | 58 | theorem minpoly_dvd_x_pow_sub_one : minpoly β€ ΞΌ β£ X ^ n - 1 := by |
rcases n.eq_zero_or_pos with (rfl | h0)
Β· simp
apply minpoly.isIntegrallyClosed_dvd (isIntegral h h0)
simp only [((IsPrimitiveRoot.iff_def ΞΌ n).mp h).left, aeval_X_pow, eq_intCast, Int.cast_one,
aeval_one, AlgHom.map_sub, sub_self]
| [
" IsIntegral β€ ΞΌ",
" (X ^ n - 1).Monic β§ evalβ (algebraMap β€ K) ΞΌ (X ^ n - 1) = 0",
" (X ^ n - 1).Monic",
" evalβ (algebraMap β€ K) ΞΌ (X ^ n - 1) = 0",
" minpoly β€ ΞΌ β£ X ^ n - 1",
" minpoly β€ ΞΌ β£ X ^ 0 - 1",
" (Polynomial.aeval ΞΌ) (X ^ n - 1) = 0"
] | [
" IsIntegral β€ ΞΌ",
" (X ^ n - 1).Monic β§ evalβ (algebraMap β€ K) ΞΌ (X ^ n - 1) = 0",
" (X ^ n - 1).Monic",
" evalβ (algebraMap β€ K) ΞΌ (X ^ n - 1) = 0"
] |
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.RingTheory.Localization.FractionRing
#align_import data.polynomial.ring_division from "leanprover-community/mathlib"@"8efcf8022aac8e01df8d302dcebdbc25d6a886c8"
noncomputable section
namespace Polynomial
universe u v w z
variable {R : Type u} {S : Ty... | Mathlib/Algebra/Polynomial/Roots.lean | 82 | 87 | theorem card_roots_sub_C {p : R[X]} {a : R} (hp0 : 0 < degree p) :
(Multiset.card (p - C a).roots : WithBot β) β€ degree p :=
calc
(Multiset.card (p - C a).roots : WithBot β) β€ degree (p - C a) :=
card_roots <| mt sub_eq_zero.1 fun h => not_le_of_gt hp0 <| h.symm βΈ degree_C_le
_ = degree p := by | rw [sub_eq_add_neg, β C_neg]; exact degree_add_C hp0
| [
" p.roots = if h : p = 0 then β
else Classical.choose β―",
" β(Multiset.card p.roots) β€ p.degree",
" β(Multiset.card (if h : p = 0 then β
else Classical.choose β―)) β€ p.degree",
" β(Multiset.card (Classical.choose β―)) β€ p.degree",
" Multiset.card p.roots β€ p.natDegree",
" (p - C a).degree = p.degree",
" (... | [
" p.roots = if h : p = 0 then β
else Classical.choose β―",
" β(Multiset.card p.roots) β€ p.degree",
" β(Multiset.card (if h : p = 0 then β
else Classical.choose β―)) β€ p.degree",
" β(Multiset.card (Classical.choose β―)) β€ p.degree",
" Multiset.card p.roots β€ p.natDegree"
] |
import Mathlib.Algebra.Field.Basic
import Mathlib.Algebra.GroupWithZero.Units.Equiv
import Mathlib.Algebra.Order.Field.Defs
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Order.Bounds.OrderIso
import Mathlib.Tactic.Positivity.Core
#align_import algebra.order.field.basic from "leanprover-community/mathlib"@"8477... | Mathlib/Algebra/Order/Field/Basic.lean | 634 | 635 | theorem div_neg_iff : a / b < 0 β 0 < a β§ b < 0 β¨ a < 0 β§ 0 < b := by |
simp [division_def, mul_neg_iff]
| [
" 0 < a / b β 0 < a β§ 0 < b β¨ a < 0 β§ b < 0",
" a / b < 0 β 0 < a β§ b < 0 β¨ a < 0 β§ 0 < b"
] | [
" 0 < a / b β 0 < a β§ 0 < b β¨ a < 0 β§ b < 0"
] |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 192 | 195 | theorem length_pos_of_pos (h : 0 < n) : 0 < c.length := by |
apply length_pos_of_sum_pos
convert h
exact c.blocks_sum
| [
" β i : Fin c.length, c.blocksFun i = n",
"n : β c : Composition n | n",
" c.length β€ n",
" c.length β€ c.blocks.sum",
" 0 < c.length",
" 0 < c.blocks.sum",
" c.blocks.sum = n"
] | [
" β i : Fin c.length, c.blocksFun i = n",
"n : β c : Composition n | n",
" c.length β€ n",
" c.length β€ c.blocks.sum"
] |
import Mathlib.CategoryTheory.Category.Grpd
import Mathlib.CategoryTheory.Groupoid
import Mathlib.Topology.Category.TopCat.Basic
import Mathlib.Topology.Homotopy.Path
import Mathlib.Data.Set.Subsingleton
#align_import algebraic_topology.fundamental_groupoid.basic from "leanprover-community/mathlib"@"3d7987cda72abc473... | Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean | 46 | 53 | theorem continuous_reflTransSymmAux : Continuous reflTransSymmAux := by |
refine continuous_if_le ?_ ?_ (Continuous.continuousOn ?_) (Continuous.continuousOn ?_) ?_
Β· continuity
Β· continuity
Β· continuity
Β· continuity
intro x hx
norm_num [hx, mul_assoc]
| [
" Continuous reflTransSymmAux",
" Continuous fun x => βx.2",
" Continuous fun x => 1 / 2",
" Continuous fun x => βx.1 * 2 * βx.2",
" Continuous fun x => βx.1 * (2 - 2 * βx.2)",
" β (x : βI Γ βI), βx.2 = 1 / 2 β βx.1 * 2 * βx.2 = βx.1 * (2 - 2 * βx.2)",
" βx.1 * 2 * βx.2 = βx.1 * (2 - 2 * βx.2)"
] | [] |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.equiv from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMa... | Mathlib/Analysis/Calculus/FDeriv/Equiv.lean | 95 | 101 | theorem comp_differentiableWithinAt_iff {f : G β E} {s : Set G} {x : G} :
DifferentiableWithinAt π (iso β f) s x β DifferentiableWithinAt π f s x := by |
refine
β¨fun H => ?_, fun H => iso.differentiable.differentiableAt.comp_differentiableWithinAt x Hβ©
have : DifferentiableWithinAt π (iso.symm β iso β f) s x :=
iso.symm.differentiable.differentiableAt.comp_differentiableWithinAt x H
rwa [β Function.comp.assoc iso.symm iso f, iso.symm_comp_self] at this
| [
" DifferentiableWithinAt π (βiso β f) s x β DifferentiableWithinAt π f s x",
" DifferentiableWithinAt π f s x"
] | [] |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Asymptotics.SpecificAsymptotics
#align_import analysis.special_functions.compare_exp from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
open Asympto... | Mathlib/Analysis/SpecialFunctions/CompareExp.lean | 127 | 151 | theorem isLittleO_log_abs_re (hl : IsExpCmpFilter l) : (fun z => Real.log (abs z)) =o[l] re :=
calc
(fun z => Real.log (abs z)) =O[l] fun z => Real.log (β2) + Real.log (max z.re |z.im|) :=
IsBigO.of_bound 1 <|
(hl.tendsto_re.eventually_ge_atTop 1).mono fun z hz => by
have h2 : 0 < β2 := by | simp
have hz' : 1 β€ abs z := hz.trans (re_le_abs z)
have hmβ : 0 < max z.re |z.im| := lt_max_iff.2 (Or.inl <| one_pos.trans_le hz)
rw [one_mul, Real.norm_eq_abs, _root_.abs_of_nonneg (Real.log_nonneg hz')]
refine le_trans ?_ (le_abs_self _)
rw [β Real.log_mul, Real.log... | [
" (fun z => (z.re ^ r) ^ n) z = (fun z => z.re ^ (r * βn)) z",
" im =O[l] fun z => z.re ^ 0",
" (fun z => (z.im ^ n) ^ 2) = fun z => z.im ^ (2 * n)",
" (fun z => z.re.exp) = fun z => z.re.exp ^ 1",
" (fun z => |z.im| ^ n) β€αΆ [l] fun z => z.re.exp",
" β(abs z).logβ β€ 1 * β(β2).log + (max z.re |z.im|).logβ",... | [
" (fun z => (z.re ^ r) ^ n) z = (fun z => z.re ^ (r * βn)) z",
" im =O[l] fun z => z.re ^ 0",
" (fun z => (z.im ^ n) ^ 2) = fun z => z.im ^ (2 * n)",
" (fun z => z.re.exp) = fun z => z.re.exp ^ 1",
" (fun z => |z.im| ^ n) β€αΆ [l] fun z => z.re.exp"
] |
import Mathlib.CategoryTheory.Products.Basic
#align_import category_theory.products.bifunctor from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open CategoryTheory
namespace CategoryTheory.Bifunctor
universe vβ vβ vβ uβ uβ uβ
variable {C : Type uβ} {D : Type uβ} {E : Type uβ}
varia... | Mathlib/CategoryTheory/Products/Bifunctor.lean | 45 | 48 | theorem diagonal (F : C Γ D β₯€ E) (X X' : C) (f : X βΆ X') (Y Y' : D) (g : Y βΆ Y') :
F.map ((π X, g) : (X, Y) βΆ (X, Y')) β« F.map ((f, π Y') : (X, Y') βΆ (X', Y')) =
F.map ((f, g) : (X, Y) βΆ (X', Y')) := by |
rw [β Functor.map_comp, prod_comp, Category.id_comp, Category.comp_id]
| [
" F.map (π W, f β« g) = F.map (π W, f) β« F.map (π W, g)",
" F.map (f β« g, π W) = F.map (f, π W) β« F.map (g, π W)",
" F.map (π X, g) β« F.map (f, π Y') = F.map (f, g)"
] | [
" F.map (π W, f β« g) = F.map (π W, f) β« F.map (π W, g)",
" F.map (f β« g, π W) = F.map (f, π W) β« F.map (g, π W)"
] |
import Mathlib.MeasureTheory.Function.LpOrder
#align_import measure_theory.function.l1_space from "leanprover-community/mathlib"@"ccdbfb6e5614667af5aa3ab2d50885e0ef44a46f"
noncomputable section
open scoped Classical
open Topology ENNReal MeasureTheory NNReal
open Set Filter TopologicalSpace ENNReal EMetric Meas... | Mathlib/MeasureTheory/Function/L1Space.lean | 113 | 115 | theorem hasFiniteIntegral_iff_norm (f : Ξ± β Ξ²) :
HasFiniteIntegral f ΞΌ β (β«β» a, ENNReal.ofReal βf aβ βΞΌ) < β := by |
simp only [HasFiniteIntegral, ofReal_norm_eq_coe_nnnorm]
| [
" β«β» (a : Ξ±), ββf aββ βΞΌ = β«β» (a : Ξ±), edist (f a) 0 βΞΌ",
" β«β» (a : Ξ±), ENNReal.ofReal βf aβ βΞΌ = β«β» (a : Ξ±), edist (f a) 0 βΞΌ",
" β«β» (a : Ξ±), edist (f a) (g a) βΞΌ β€ β«β» (a : Ξ±), edist (f a) (h a) βΞΌ + β«β» (a : Ξ±), edist (g a) (h a) βΞΌ",
" β«β» (a : Ξ±), edist (f a) (g a) βΞΌ β€ β«β» (a : Ξ±), edist (f a) (h a) + edist... | [
" β«β» (a : Ξ±), ββf aββ βΞΌ = β«β» (a : Ξ±), edist (f a) 0 βΞΌ",
" β«β» (a : Ξ±), ENNReal.ofReal βf aβ βΞΌ = β«β» (a : Ξ±), edist (f a) 0 βΞΌ",
" β«β» (a : Ξ±), edist (f a) (g a) βΞΌ β€ β«β» (a : Ξ±), edist (f a) (h a) βΞΌ + β«β» (a : Ξ±), edist (g a) (h a) βΞΌ",
" β«β» (a : Ξ±), edist (f a) (g a) βΞΌ β€ β«β» (a : Ξ±), edist (f a) (h a) + edist... |
import Mathlib.Algebra.Polynomial.Derivative
import Mathlib.Tactic.LinearCombination
#align_import ring_theory.polynomial.chebyshev from "leanprover-community/mathlib"@"d774451114d6045faeb6751c396bea1eb9058946"
namespace Polynomial.Chebyshev
set_option linter.uppercaseLean3 false -- `T` `U` `X`
open Polynomial
v... | Mathlib/RingTheory/Polynomial/Chebyshev.lean | 118 | 129 | theorem T_neg (n : β€) : T R (-n) = T R n := by |
induction n using Polynomial.Chebyshev.induct with
| zero => rfl
| one => show 2 * X * 1 - X = X; ring
| add_two n ih1 ih2 =>
have hβ := T_add_two R n
have hβ := T_sub_two R (-n)
linear_combination (norm := ring_nf) (2 * (X:R[X])) * ih1 - ih2 - hβ + hβ
| neg_add_one n ih1 ih2 =>
have hβ := T_... | [
" motive (Int.negSucc n)",
" T R (-β(k + 1) + 2) = 2 * X * T R (-β(k + 1) + 1) - T R (-β(k + 1))",
" T R (-β(k + 1) + 2) - (2 * X * T R (-β(k + 1) + 1) - T R (-β(k + 1))) -\n (T R (Int.negSucc k) - (2 * X * T R (-βk) - T R (-βk + 1))) =\n 0",
" T R (-1 + -βk + 2) - (2 * X * T R (-βk) - T R (-1 + -βk))... | [
" motive (Int.negSucc n)",
" T R (-β(k + 1) + 2) = 2 * X * T R (-β(k + 1) + 1) - T R (-β(k + 1))",
" T R (-β(k + 1) + 2) - (2 * X * T R (-β(k + 1) + 1) - T R (-β(k + 1))) -\n (T R (Int.negSucc k) - (2 * X * T R (-βk) - T R (-βk + 1))) =\n 0",
" T R (-1 + -βk + 2) - (2 * X * T R (-βk) - T R (-1 + -βk))... |
import Mathlib.CategoryTheory.Subobject.Lattice
#align_import category_theory.subobject.limits from "leanprover-community/mathlib"@"956af7c76589f444f2e1313911bad16366ea476d"
universe v u
noncomputable section
open CategoryTheory CategoryTheory.Category CategoryTheory.Limits CategoryTheory.Subobject Opposite
var... | Mathlib/CategoryTheory/Subobject/Limits.lean | 328 | 329 | theorem imageSubobject_arrow_comp : factorThruImageSubobject f β« (imageSubobject f).arrow = f := by |
simp [factorThruImageSubobject, imageSubobject_arrow]
| [
" (imageSubobjectIso f).hom β« image.ΞΉ f = (imageSubobject f).arrow",
" (imageSubobjectIso f).inv β« (imageSubobject f).arrow = image.ΞΉ f",
" Epi (factorThruImageSubobject f)",
" Epi (factorThruImage f β« (imageSubobjectIso f).inv)",
" factorThruImageSubobject f β« (imageSubobject f).arrow = f"
] | [
" (imageSubobjectIso f).hom β« image.ΞΉ f = (imageSubobject f).arrow",
" (imageSubobjectIso f).inv β« (imageSubobject f).arrow = image.ΞΉ f",
" Epi (factorThruImageSubobject f)",
" Epi (factorThruImage f β« (imageSubobjectIso f).inv)"
] |
import Mathlib.Analysis.SpecialFunctions.Gamma.Beta
import Mathlib.NumberTheory.LSeries.HurwitzZeta
import Mathlib.Analysis.Complex.RemovableSingularity
import Mathlib.Analysis.PSeriesComplex
#align_import number_theory.zeta_function from "leanprover-community/mathlib"@"57f9349f2fe19d2de7207e99b0341808d977cdcf"
o... | Mathlib/NumberTheory/LSeries/RiemannZeta.lean | 179 | 189 | theorem completedZeta_eq_tsum_of_one_lt_re {s : β} (hs : 1 < re s) :
completedRiemannZeta s =
(Ο : β) ^ (-s / 2) * Gamma (s / 2) * β' n : β, 1 / (n : β) ^ s := by |
have := (hasSum_nat_completedCosZeta 0 hs).tsum_eq.symm
simp only [QuotientAddGroup.mk_zero, completedCosZeta_zero] at this
simp only [this, Gammaβ_def, mul_zero, zero_mul, Real.cos_zero, ofReal_one, mul_one, mul_one_div,
β tsum_mul_left]
congr 1 with n
split_ifs with h
Β· simp only [h, Nat.cast_zero, z... | [
" completedCosZeta 0 s = completedRiemannZeta s",
" completedCosZetaβ 0 s = completedRiemannZetaβ s",
" completedRiemannZeta s = completedRiemannZetaβ s - 1 / s - 1 / (1 - s)",
" completedRiemannZetaβ (1 - s) = completedRiemannZetaβ s",
" completedRiemannZeta (1 - s) = completedRiemannZeta s",
" cosZeta 0... | [
" completedCosZeta 0 s = completedRiemannZeta s",
" completedCosZetaβ 0 s = completedRiemannZetaβ s",
" completedRiemannZeta s = completedRiemannZetaβ s - 1 / s - 1 / (1 - s)",
" completedRiemannZetaβ (1 - s) = completedRiemannZetaβ s",
" completedRiemannZeta (1 - s) = completedRiemannZeta s",
" cosZeta 0... |
import Mathlib.Data.Nat.Bitwise
import Mathlib.SetTheory.Game.Birthday
import Mathlib.SetTheory.Game.Impartial
#align_import set_theory.game.nim from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
noncomputable section
universe u
namespace SetTheory
open scoped PGame
namespace PGame... | Mathlib/SetTheory/Game/Nim.lean | 111 | 111 | theorem moveLeft_nim {o : Ordinal} (i) : (nim o).moveLeft (toLeftMovesNim i) = nim i := by | simp
| [
" let_fun this := β―;\n nim o =\n mk (Quotient.out o).Ξ± (Quotient.out o).Ξ± (fun oβ => nim (typein (fun x x_1 => x < x_1) oβ)) fun oβ =>\n nim (typein (fun x x_1 => x < x_1) oβ)",
" let_fun this := β―;\n (mk (Quotient.out o).Ξ± (Quotient.out o).Ξ±\n (fun oβ =>\n let_fun x := β―;\n nim (type... | [
" let_fun this := β―;\n nim o =\n mk (Quotient.out o).Ξ± (Quotient.out o).Ξ± (fun oβ => nim (typein (fun x x_1 => x < x_1) oβ)) fun oβ =>\n nim (typein (fun x x_1 => x < x_1) oβ)",
" let_fun this := β―;\n (mk (Quotient.out o).Ξ± (Quotient.out o).Ξ±\n (fun oβ =>\n let_fun x := β―;\n nim (type... |
import Mathlib.Algebra.Field.Basic
import Mathlib.Deprecated.Subring
#align_import deprecated.subfield from "leanprover-community/mathlib"@"bd9851ca476957ea4549eb19b40e7b5ade9428cc"
variable {F : Type*} [Field F] (S : Set F)
structure IsSubfield extends IsSubring S : Prop where
inv_mem : β {x : F}, x β S β xβ»... | Mathlib/Deprecated/Subfield.lean | 134 | 137 | theorem closure_subset {T : Set F} (hT : IsSubfield T) (H : S β T) : closure S β T := by |
rintro _ β¨p, hp, q, hq, hq0, rflβ©
exact hT.div_mem (Ring.closure_subset hT.toIsSubring H hp)
(Ring.closure_subset hT.toIsSubring H hq)
| [
" x / y β S",
" x * yβ»ΒΉ β S",
" a ^ n β s",
" a ^ Int.ofNat n β s",
" a ^ βn β s",
" a ^ Int.negSucc n β s",
" (a ^ (n + 1))β»ΒΉ β s",
" f aβ»ΒΉ β s",
" (f a)β»ΒΉ β s",
" IsSubfield (Set.range βf)",
" IsSubfield (βf '' Set.univ)",
" β {a b : F}, a β closure S β b β closure S β a * b β closure S",
... | [
" x / y β S",
" x * yβ»ΒΉ β S",
" a ^ n β s",
" a ^ Int.ofNat n β s",
" a ^ βn β s",
" a ^ Int.negSucc n β s",
" (a ^ (n + 1))β»ΒΉ β s",
" f aβ»ΒΉ β s",
" (f a)β»ΒΉ β s",
" IsSubfield (Set.range βf)",
" IsSubfield (βf '' Set.univ)",
" β {a b : F}, a β closure S β b β closure S β a * b β closure S",
... |
import Mathlib.Order.Bounds.Basic
import Mathlib.Order.WellFounded
import Mathlib.Data.Set.Image
import Mathlib.Order.Interval.Set.Basic
import Mathlib.Data.Set.Lattice
#align_import order.conditionally_complete_lattice.basic from "leanprover-community/mathlib"@"29cb56a7b35f72758b05a30490e1f10bd62c35c1"
open Func... | Mathlib/Order/ConditionallyCompleteLattice/Basic.lean | 95 | 104 | theorem WithTop.coe_sInf' [InfSet Ξ±] {s : Set Ξ±} (hs : s.Nonempty) (h's : BddBelow s) :
β(sInf s) = (sInf ((fun (a : Ξ±) β¦ βa) '' s) : WithTop Ξ±) := by |
obtain β¨x, hxβ© := hs
change _ = ite _ _ _
split_ifs with h
Β· rcases h with h1 | h2
Β· cases h1 (mem_image_of_mem _ hx)
Β· exact (h2 (Monotone.map_bddBelow coe_mono h's)).elim
Β· rw [preimage_image_eq]
exact Option.some_injective _
| [
" Β¬(s β {β€} β¨ Β¬BddBelow s)",
" β
β {β€} β¨ Β¬BddBelow β
",
" β¨
i, f i = β€",
" β(sInf s) = sInf ((fun a => βa) '' s)",
" β(sInf s) =\n if (fun a => βa) '' s β {β€} β¨ Β¬BddBelow ((fun a => βa) '' s) then β€\n else β(sInf ((fun a => βa) β»ΒΉ' ((fun a => βa) '' s)))",
" β(sInf s) = β€",
" β(sInf s) = β(sInf ((f... | [
" Β¬(s β {β€} β¨ Β¬BddBelow s)",
" β
β {β€} β¨ Β¬BddBelow β
",
" β¨
i, f i = β€"
] |
import Mathlib.Order.Bounds.Basic
import Mathlib.Order.Hom.Set
#align_import order.bounds.order_iso from "leanprover-community/mathlib"@"a59dad53320b73ef180174aae867addd707ef00e"
set_option autoImplicit true
open Set
namespace OrderIso
variable [Preorder Ξ±] [Preorder Ξ²] (f : Ξ± βo Ξ²)
theorem upperBounds_image {... | Mathlib/Order/Bounds/OrderIso.lean | 55 | 56 | theorem isLUB_preimage {s : Set Ξ²} {x : Ξ±} : IsLUB (f β»ΒΉ' s) x β IsLUB s (f x) := by |
rw [β f.symm_symm, β image_eq_preimage, isLUB_image]
| [
" β {x y : Ξ±}, f x β€ f y β x β€ y",
" β {x y : Ξ²}, f.symm x β€ f.symm y β x β€ y",
" IsLUB (βf '' s) (f x) β IsLUB s x",
" IsLUB (βf β»ΒΉ' s) x β IsLUB s (f x)"
] | [
" β {x y : Ξ±}, f x β€ f y β x β€ y",
" β {x y : Ξ²}, f.symm x β€ f.symm y β x β€ y",
" IsLUB (βf '' s) (f x) β IsLUB s x"
] |
import Mathlib.Algebra.Lie.Abelian
#align_import algebra.lie.tensor_product from "leanprover-community/mathlib"@"657df4339ae6ceada048c8a2980fb10e393143ec"
suppress_compilation
universe u v w wβ wβ wβ
variable {R : Type u} [CommRing R]
open LieModule
namespace TensorProduct
open scoped TensorProduct
namespace... | Mathlib/Algebra/Lie/TensorProduct.lean | 125 | 127 | theorem liftLie_apply (f : M βββ
R,Lβ N ββ[R] P) (m : M) (n : N) :
liftLie R L M N P f (m ββ n) = f m n := by |
simp only [coe_liftLie_eq_lift_coe, LieModuleHom.coe_toLinearMap, lift_apply]
| [
" β
x + y, tβ = β
x, tβ + β
y, tβ",
" (LinearMap.rTensor N ((toEnd R L M) x)) t + (LinearMap.rTensor N ((toEnd R L M) y)) t +\n ((LinearMap.lTensor M ((toEnd R L N) x)) t + (LinearMap.lTensor M ((toEnd R L N) y)) t) =\n (LinearMap.rTensor N ((toEnd R L M) x)) t + (LinearMap.lTensor M ((toEnd R L N) x)) t +\n... | [
" β
x + y, tβ = β
x, tβ + β
y, tβ",
" (LinearMap.rTensor N ((toEnd R L M) x)) t + (LinearMap.rTensor N ((toEnd R L M) y)) t +\n ((LinearMap.lTensor M ((toEnd R L N) x)) t + (LinearMap.lTensor M ((toEnd R L N) y)) t) =\n (LinearMap.rTensor N ((toEnd R L M) x)) t + (LinearMap.lTensor M ((toEnd R L N) x)) t +\n... |
import Mathlib.Analysis.Calculus.LineDeriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Measurable
open MeasureTheory
variable {π : Type*} [NontriviallyNormedField π] [LocallyCompactSpace π]
{E : Type*} [NormedAddCommGroup E] [NormedSpace π E] [MeasurableSpace E] [OpensMeasurableSpace E]
{F : Type*} [Norm... | Mathlib/Analysis/Calculus/LineDeriv/Measurable.lean | 83 | 90 | theorem measurable_lineDeriv_uncurry [MeasurableSpace F] [BorelSpace F]
(hf : Continuous f) : Measurable (fun (p : E Γ E) β¦ lineDeriv π f p.1 p.2) := by |
borelize π
let g : (E Γ E) β π β F := fun p t β¦ f (p.1 + t β’ p.2)
have : Continuous g.uncurry :=
hf.comp <| (continuous_fst.comp continuous_fst).add
<| continuous_snd.smul (continuous_snd.comp continuous_fst)
exact (measurable_deriv_with_param this).comp measurable_prod_mk_right
| [
" MeasurableSet {x | LineDifferentiableAt π f x v}",
" Continuous (Function.uncurry g)",
" Continuous fun x => x.1 + x.2 β’ v",
" Measurable fun x => lineDeriv π f x v",
" StronglyMeasurable fun x => lineDeriv π f x v",
" MeasurableSet {p | LineDifferentiableAt π f p.1 p.2}",
" Measurable fun p => li... | [
" MeasurableSet {x | LineDifferentiableAt π f x v}",
" Continuous (Function.uncurry g)",
" Continuous fun x => x.1 + x.2 β’ v",
" Measurable fun x => lineDeriv π f x v",
" StronglyMeasurable fun x => lineDeriv π f x v",
" MeasurableSet {p | LineDifferentiableAt π f p.1 p.2}"
] |
import Mathlib.Algebra.DualNumber
import Mathlib.Algebra.QuaternionBasis
import Mathlib.Data.Complex.Module
import Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation
import Mathlib.LinearAlgebra.CliffordAlgebra.Star
import Mathlib.LinearAlgebra.QuadraticForm.Prod
#align_import linear_algebra.clifford_algebra.equivs fr... | Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean | 106 | 107 | theorem involute_eq_id :
(involute : CliffordAlgebra (0 : QuadraticForm R Unit) ββ[R] _) = AlgHom.id R _ := by | ext; simp
| [
" x * y = y * x",
" (algebraMap R (CliffordAlgebra 0)) r * y = y * (algebraMap R (CliffordAlgebra 0)) r",
" (ΞΉ 0) x * y = y * (ΞΉ 0) x",
" (xβ + xβ) * y = y * (xβ + xβ)",
" xβ * xβ * y = y * (xβ * xβ)",
" reverse x = x",
" reverse ((algebraMap R (CliffordAlgebra 0)) r) = (algebraMap R (CliffordAlgebra 0)... | [
" x * y = y * x",
" (algebraMap R (CliffordAlgebra 0)) r * y = y * (algebraMap R (CliffordAlgebra 0)) r",
" (ΞΉ 0) x * y = y * (ΞΉ 0) x",
" (xβ + xβ) * y = y * (xβ + xβ)",
" xβ * xβ * y = y * (xβ * xβ)",
" reverse x = x",
" reverse ((algebraMap R (CliffordAlgebra 0)) r) = (algebraMap R (CliffordAlgebra 0)... |
import Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic
import Mathlib.NumberTheory.GaussSum
#align_import number_theory.legendre_symbol.quadratic_char.gauss_sum from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
section SpecialValues
open ZMod MulChar
variable {F : Type*} ... | Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/GaussSum.lean | 130 | 143 | theorem FiniteField.isSquare_odd_prime_iff (hF : ringChar F β 2) {p : β} [Fact p.Prime]
(hp : p β 2) :
IsSquare (p : F) β quadraticChar (ZMod p) (Οβ (Fintype.card F) * Fintype.card F) β -1 := by |
classical
by_cases hFp : ringChar F = p
Β· rw [show (p : F) = 0 by rw [β hFp]; exact ringChar.Nat.cast_ringChar]
simp only [isSquare_zero, Ne, true_iff_iff, map_mul]
obtain β¨n, _, hcβ© := FiniteField.card F (ringChar F)
have hchar : ringChar F = ringChar (ZMod p) := by rw [hFp]; exact (ringChar_zmod_n ... | [
" IsSquare 2 β Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" (if Fintype.card F % 2 = 0 then 0 else if Fintype.card F % 8 = 1 β¨ Fintype.card F % 8 = 7 then 1 else -1) = 1 β\n Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" -1 β 1",
" Fintype.c... | [
" IsSquare 2 β Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" (if Fintype.card F % 2 = 0 then 0 else if Fintype.card F % 8 = 1 β¨ Fintype.card F % 8 = 7 then 1 else -1) = 1 β\n Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" -1 β 1",
" Fintype.c... |
import Mathlib.Data.Set.Basic
open Function
universe u v
namespace Set
section Nontrivial
variable {Ξ± : Type u} {a : Ξ±} {s t : Set Ξ±}
protected def Nontrivial (s : Set Ξ±) : Prop :=
β x β s, β y β s, x β y
#align set.nontrivial Set.Nontrivial
theorem nontrivial_of_mem_mem_ne {x y} (hx : x β s) (hy : y β... | Mathlib/Data/Set/Subsingleton.lean | 194 | 198 | theorem Nontrivial.exists_ne (hs : s.Nontrivial) (z) : β x β s, x β z := by |
by_contra! H
rcases hs with β¨x, hx, y, hy, hxyβ©
rw [H x hx, H y hy] at hxy
exact hxy rfl
| [
" β x β s, x β z",
" False"
] | [] |
import Mathlib.GroupTheory.Perm.Cycle.Basic
#align_import group_theory.perm.cycle.basic from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
open Equiv Function Finset
variable {ΞΉ Ξ± Ξ² : Type*}
namespace Equiv.Perm
section Generation
variable [Finite Ξ²]
open Subgroup
theorem closure... | Mathlib/GroupTheory/Perm/Closure.lean | 96 | 108 | theorem closure_cycle_coprime_swap {n : β} {Ο : Perm Ξ±} (h0 : Nat.Coprime n (Fintype.card Ξ±))
(h1 : IsCycle Ο) (h2 : Ο.support = Finset.univ) (x : Ξ±) :
closure ({Ο, swap x ((Ο ^ n) x)} : Set (Perm Ξ±)) = β€ := by |
rw [β Finset.card_univ, β h2, β h1.orderOf] at h0
cases' exists_pow_eq_self_of_coprime h0 with m hm
have h2' : (Ο ^ n).support = β€ := Eq.trans (support_pow_coprime h0) h2
have h1' : IsCycle ((Ο ^ n) ^ (m : β€)) := by rwa [β hm] at h1
replace h1' : IsCycle (Ο ^ n) :=
h1'.of_pow (le_trans (support_pow_le Ο ... | [
" closure {Ο | Ο.IsCycle} = β€",
" closure {Ο, swap x (Ο x)} = β€",
" β (n : β), swap ((Ο ^ n) x) ((Ο ^ (n + 1)) x) β H",
" swap ((Ο ^ n) x) ((Ο ^ (n + 1)) x) β H",
" swap ((Ο ^ 0) x) ((Ο ^ (0 + 1)) x) β H",
" swap ((Ο ^ (n + 1)) x) ((Ο ^ (n + 1 + 1)) x) β H",
" swap ((Ο ^ (n + 1)) x) ((Ο ^ (n + 1 + 1)) x... | [
" closure {Ο | Ο.IsCycle} = β€",
" closure {Ο, swap x (Ο x)} = β€",
" β (n : β), swap ((Ο ^ n) x) ((Ο ^ (n + 1)) x) β H",
" swap ((Ο ^ n) x) ((Ο ^ (n + 1)) x) β H",
" swap ((Ο ^ 0) x) ((Ο ^ (0 + 1)) x) β H",
" swap ((Ο ^ (n + 1)) x) ((Ο ^ (n + 1 + 1)) x) β H",
" swap ((Ο ^ (n + 1)) x) ((Ο ^ (n + 1 + 1)) x... |
import Mathlib.Data.Set.Lattice
#align_import data.set.intervals.disjoint from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
universe u v w
variable {ΞΉ : Sort u} {Ξ± : Type v} {Ξ² : Type w}
open Set
open OrderDual (toDual)
namespace Set
section LinearOrder
variable [LinearOrder Ξ±] ... | Mathlib/Order/Interval/Set/Disjoint.lean | 149 | 151 | theorem Ioc_disjoint_Ioc : Disjoint (Ioc aβ aβ) (Ioc bβ bβ) β min aβ bβ β€ max aβ bβ := by |
have h : _ β min (toDual aβ) (toDual bβ) β€ max (toDual aβ) (toDual bβ) := Ico_disjoint_Ico
simpa only [dual_Ico] using h
| [
" Disjoint (Ico aβ aβ) (Ico bβ bβ) β min aβ bβ β€ max aβ bβ",
" Disjoint (Ioc aβ aβ) (Ioc bβ bβ) β min aβ bβ β€ max aβ bβ"
] | [
" Disjoint (Ico aβ aβ) (Ico bβ bβ) β min aβ bβ β€ max aβ bβ"
] |
import Mathlib.Order.MinMax
import Mathlib.Data.Set.Subsingleton
import Mathlib.Tactic.Says
#align_import data.set.intervals.basic from "leanprover-community/mathlib"@"3ba15165bd6927679be7c22d6091a87337e3cd0c"
open Function
open OrderDual (toDual ofDual)
variable {Ξ± Ξ² : Type*}
namespace Set
section Preorder
v... | Mathlib/Order/Interval/Set/Basic.lean | 186 | 186 | theorem left_mem_Ico : a β Ico a b β a < b := by | simp [le_refl]
| [
" Decidable (x β Ioo a b)",
" Decidable (x β Ico a b)",
" Decidable (x β Iio b)",
" Decidable (x β Icc a b)",
" Decidable (x β Iic b)",
" Decidable (x β Ioc a b)",
" Decidable (x β Ici a)",
" Decidable (x β Ioi a)",
" a β Ioo a b β False",
" a β Ico a b β a < b"
] | [
" Decidable (x β Ioo a b)",
" Decidable (x β Ico a b)",
" Decidable (x β Iio b)",
" Decidable (x β Icc a b)",
" Decidable (x β Iic b)",
" Decidable (x β Ioc a b)",
" Decidable (x β Ici a)",
" Decidable (x β Ioi a)",
" a β Ioo a b β False"
] |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Top... | Mathlib/Analysis/Calculus/Deriv/Comp.lean | 133 | 136 | theorem HasDerivAt.scomp_hasDerivWithinAt_of_eq (hg : HasDerivAt gβ gβ' y)
(hh : HasDerivWithinAt h h' s x) (hy : y = h x) :
HasDerivWithinAt (gβ β h) (h' β’ gβ') s x := by |
rw [hy] at hg; exact hg.scomp_hasDerivWithinAt x hh
| [
" HasDerivAtFilter (gβ β h) (h' β’ gβ') x L",
" HasDerivAt (gβ β h) (h' β’ gβ') x",
" HasDerivWithinAt (gβ β h) (h' β’ gβ') s x",
" HasStrictDerivAt (gβ β h) (h' β’ gβ') x"
] | [
" HasDerivAtFilter (gβ β h) (h' β’ gβ') x L",
" HasDerivAt (gβ β h) (h' β’ gβ') x",
" HasDerivWithinAt (gβ β h) (h' β’ gβ') s x",
" HasStrictDerivAt (gβ β h) (h' β’ gβ') x"
] |
import Mathlib.Data.List.Lattice
import Mathlib.Data.List.Range
import Mathlib.Data.Bool.Basic
#align_import data.list.intervals from "leanprover-community/mathlib"@"7b78d1776212a91ecc94cf601f83bdcc46b04213"
open Nat
namespace List
def Ico (n m : β) : List β :=
range' n (m - n)
#align list.Ico List.Ico
names... | Mathlib/Data/List/Intervals.lean | 46 | 48 | theorem length (n m : β) : length (Ico n m) = m - n := by |
dsimp [Ico]
simp [length_range', autoParam]
| [
" Ico 0 n = range n",
" (Ico n m).length = m - n",
" (range' n (m - n)).length = m - n"
] | [
" Ico 0 n = range n"
] |
import Mathlib.Algebra.ContinuedFractions.Basic
import Mathlib.Algebra.GroupWithZero.Basic
#align_import algebra.continued_fractions.translations from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b348ce40ad"
namespace GeneralizedContinuedFraction
section WithDivisionRing
variable {K : Type*}... | Mathlib/Algebra/ContinuedFractions/Translations.lean | 166 | 167 | theorem first_denominator_eq {gp : Pair K} (zeroth_s_eq : g.s.get? 0 = some gp) :
g.denominators 1 = gp.b := by | simp [denom_eq_conts_b, first_continuant_eq zeroth_s_eq]
| [
" β conts, g.continuants n = conts β§ conts.a = A",
" β conts, g.continuants n = conts β§ conts.b = B",
" g.convergents 0 = g.h",
" g.continuantsAux 2 = { a := gp.b * g.h + gp.a, b := gp.b }",
" g.continuants 1 = { a := gp.b * g.h + gp.a, b := gp.b }",
" g.numerators 1 = gp.b * g.h + gp.a",
" g.denominato... | [
" β conts, g.continuants n = conts β§ conts.a = A",
" β conts, g.continuants n = conts β§ conts.b = B",
" g.convergents 0 = g.h",
" g.continuantsAux 2 = { a := gp.b * g.h + gp.a, b := gp.b }",
" g.continuants 1 = { a := gp.b * g.h + gp.a, b := gp.b }",
" g.numerators 1 = gp.b * g.h + gp.a"
] |
import Mathlib.Data.Set.Function
import Mathlib.Analysis.BoundedVariation
#align_import analysis.constant_speed from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
open scoped NNReal ENNReal
open Set MeasureTheory Classical
variable {Ξ± : Type*} [LinearOrder Ξ±] {E : Type*} [PseudoEMetr... | Mathlib/Analysis/ConstantSpeed.lean | 102 | 137 | theorem HasConstantSpeedOnWith.union {t : Set β} (hfs : HasConstantSpeedOnWith f s l)
(hft : HasConstantSpeedOnWith f t l) {x : β} (hs : IsGreatest s x) (ht : IsLeast t x) :
HasConstantSpeedOnWith f (s βͺ t) l := by |
rw [hasConstantSpeedOnWith_iff_ordered] at hfs hft β’
rintro z (zs | zt) y (ys | yt) zy
Β· have : (s βͺ t) β© Icc z y = s β© Icc z y := by
ext w; constructor
Β· rintro β¨ws | wt, zw, wyβ©
Β· exact β¨ws, zw, wyβ©
Β· exact β¨(le_antisymm (wy.trans (hs.2 ys)) (ht.2 wt)).symm βΈ hs.1, zw, wyβ©
Β· r... | [
" BoundedVariationOn f (s β© Icc x y)",
" HasConstantSpeedOnWith f s l",
" eVariationOn f (s β© Icc x y) = ENNReal.ofReal (βl * (y - x))",
" eVariationOn f (s β© Icc x x) = ENNReal.ofReal (βl * (x - x))",
" 0 = ENNReal.ofReal (βl * (x - x))",
" HasConstantSpeedOnWith f s l β\n β β¦x : ββ¦, x β s β β β¦y : ββ¦... | [
" BoundedVariationOn f (s β© Icc x y)",
" HasConstantSpeedOnWith f s l",
" eVariationOn f (s β© Icc x y) = ENNReal.ofReal (βl * (y - x))",
" eVariationOn f (s β© Icc x x) = ENNReal.ofReal (βl * (x - x))",
" 0 = ENNReal.ofReal (βl * (x - x))",
" HasConstantSpeedOnWith f s l β\n β β¦x : ββ¦, x β s β β β¦y : ββ¦... |
import Mathlib.Analysis.LocallyConvex.WithSeminorms
import Mathlib.Topology.Semicontinuous
import Mathlib.Topology.Baire.Lemmas
open Filter Topology Set ContinuousLinearMap
section defs
class BarrelledSpace (π E : Type*) [SeminormedRing π] [AddGroup E] [SMul π E]
[TopologicalSpace E] : Prop where
con... | Mathlib/Analysis/LocallyConvex/Barrelled.lean | 93 | 103 | theorem Seminorm.continuous_iSup
{ΞΉ : Sort*} {π E : Type*} [NormedField π] [AddCommGroup E] [Module π E]
[TopologicalSpace E] [BarrelledSpace π E] (p : ΞΉ β Seminorm π E)
(hp : β i, Continuous (p i)) (bdd : BddAbove (range p)) :
Continuous (β¨ i, p i) := by |
rw [β Seminorm.coe_iSup_eq bdd]
refine Seminorm.continuous_of_lowerSemicontinuous _ ?_
rw [Seminorm.coe_iSup_eq bdd]
rw [Seminorm.bddAbove_range_iff] at bdd
convert lowerSemicontinuous_ciSup (f := fun i x β¦ p i x) bdd (fun i β¦ (hp i).lowerSemicontinuous)
exact iSup_apply
| [
" Continuous (β¨ i, β(p i))",
" Continuous β(β¨ i, p i)",
" LowerSemicontinuous β(β¨ i, p i)",
" LowerSemicontinuous (β¨ i, β(p i))",
" (β¨ i, β(p i)) xβ = β¨ i, (p i) xβ"
] | [] |
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
import Mathlib.Analysis.Calculus.FDeriv.Extend
import Mathlib.Analysis.Calculus.Deriv.Prod
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
#... | Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean | 276 | 285 | theorem hasStrictFDerivAt_rpow_of_pos (p : β Γ β) (hp : 0 < p.1) :
HasStrictFDerivAt (fun x : β Γ β => x.1 ^ x.2)
((p.2 * p.1 ^ (p.2 - 1)) β’ ContinuousLinearMap.fst β β β +
(p.1 ^ p.2 * log p.1) β’ ContinuousLinearMap.snd β β β) p := by |
have : (fun x : β Γ β => x.1 ^ x.2) =αΆ [π p] fun x => exp (log x.1 * x.2) :=
(continuousAt_fst.eventually (lt_mem_nhds hp)).mono fun p hp => rpow_def_of_pos hp _
refine HasStrictFDerivAt.congr_of_eventuallyEq ?_ this.symm
convert ((hasStrictFDerivAt_fst.log hp.ne').mul hasStrictFDerivAt_snd).exp using 1
rw... | [
" HasStrictFDerivAt (fun x => x.1 ^ x.2)\n ((p.2 * p.1 ^ (p.2 - 1)) β’ ContinuousLinearMap.fst β β β + (p.1 ^ p.2 * p.1.log) β’ ContinuousLinearMap.snd β β β) p",
" HasStrictFDerivAt (fun x => rexp (x.1.log * x.2))\n ((p.2 * p.1 ^ (p.2 - 1)) β’ ContinuousLinearMap.fst β β β + (p.1 ^ p.2 * p.1.log) β’ Continuous... | [] |
import Mathlib.RingTheory.RootsOfUnity.Basic
universe u
variable {L : Type u} [CommRing L] [IsDomain L]
variable (n : β+)
theorem rootsOfUnity.integer_power_of_ringEquiv (g : L β+* L) :
β m : β€, β t : rootsOfUnity n L, g (t : LΛ£) = (t ^ m : LΛ£) := by
obtain β¨m, hmβ© := MonoidHom.map_cyclic ((g : L β* L).re... | Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean | 120 | 125 | theorem toFun_unique (g : L β+* L) (c : ZMod (Fintype.card (rootsOfUnity n L)))
(hc : β t : rootsOfUnity n L, g (t : LΛ£) = (t ^ c.val : LΛ£)) : c = Οβ n g := by |
apply IsCyclic.ext rfl (fun ΞΆ β¦ ?_)
specialize hc ΞΆ
suffices ((ΞΆ ^ c.val : LΛ£) : L) = (ΞΆ ^ (Οβ n g).val : LΛ£) by exact_mod_cast this
rw [β toFun_spec g ΞΆ, hc]
| [
" β m, β (t : β₯(rootsOfUnity n L)), g ββt = β(βt ^ m)",
" β m, β t β rootsOfUnity n L, g βt = β(t ^ m)",
" g ββt = β(βt ^ (Οβ n g).val)",
" ββ(t ^ ModularCyclotomicCharacter_aux g n) =\n β(βt ^ (ModularCyclotomicCharacter_aux g n % β(Fintype.card β₯(rootsOfUnity n L))))",
" c = Οβ n g",
" ΞΆ ^ c.val = ΞΆ ... | [
" β m, β (t : β₯(rootsOfUnity n L)), g ββt = β(βt ^ m)",
" β m, β t β rootsOfUnity n L, g βt = β(t ^ m)",
" g ββt = β(βt ^ (Οβ n g).val)",
" ββ(t ^ ModularCyclotomicCharacter_aux g n) =\n β(βt ^ (ModularCyclotomicCharacter_aux g n % β(Fintype.card β₯(rootsOfUnity n L))))"
] |
import Mathlib.Order.BooleanAlgebra
import Mathlib.Logic.Equiv.Basic
#align_import order.symm_diff from "leanprover-community/mathlib"@"6eb334bd8f3433d5b08ba156b8ec3e6af47e1904"
open Function OrderDual
variable {ΞΉ Ξ± Ξ² : Type*} {Ο : ΞΉ β Type*}
def symmDiff [Sup Ξ±] [SDiff Ξ±] (a b : Ξ±) : Ξ± :=
a \ b β b \ a
#ali... | Mathlib/Order/SymmDiff.lean | 256 | 256 | theorem top_bihimp : β€ β a = a := by | rw [bihimp_comm, bihimp_top]
| [
" β (p q : Bool), p β q = xor p q",
" a β b = b β a",
" a β a = β€",
" a β β€ = a",
" β€ β a = a"
] | [
" β (p q : Bool), p β q = xor p q",
" a β b = b β a",
" a β a = β€",
" a β β€ = a"
] |
import Mathlib.MeasureTheory.Integral.SetIntegral
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Measure.Haar.Unique
#align_import measure_theory.measure.lebesgue.integral from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
open Set Filter MeasureTheory... | Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean | 96 | 99 | theorem integral_comp_neg_Ioi {E : Type*} [NormedAddCommGroup E] [NormedSpace β E]
(c : β) (f : β β E) : (β« x in Ioi c, f (-x)) = β« x in Iic (-c), f x := by |
rw [β neg_neg c, β integral_comp_neg_Iic]
simp only [neg_neg]
| [
" β« (x : β) in Iic c, f (-x) = β« (x : β) in Ioi (-c), f x",
" β« (x : β) in Ioi c, f (-x) = β« (x : β) in Iic (-c), f x",
" β« (x : β) in Iic (-c), f (- -x) = β« (x : β) in Iic (- - -c), f x"
] | [
" β« (x : β) in Iic c, f (-x) = β« (x : β) in Ioi (-c), f x"
] |
import Mathlib.MeasureTheory.Group.GeometryOfNumbers
import Mathlib.MeasureTheory.Measure.Lebesgue.VolumeOfBalls
import Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic
#align_import number_theory.number_field.canonical_embedding from "leanprover-community/mathlib"@"60da01b41bbe4206f05d34fd70c8dd7498717a30"
... | Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean | 306 | 310 | theorem convexBodySumFun_add_le (x y : E K) :
convexBodySumFun (x + y) β€ convexBodySumFun x + convexBodySumFun y := by |
simp_rw [convexBodySumFun, β Finset.sum_add_distrib, β mul_add]
exact Finset.sum_le_sum
fun _ _ β¦ mul_le_mul_of_nonneg_left (normAtPlace_add_le _ x y) (Nat.cast_pos.mpr mult_pos).le
| [
" convexBodySumFun x = β w : { w // w.IsReal }, βx.1 wβ + 2 * β w : { w // w.IsComplex }, βx.2 wβ",
" β x_1 β Finset.subtype (fun x => x.IsReal) Finset.univ, β(βx_1).mult * (normAtPlace βx_1) x +\n β x_1 β Finset.subtype (fun x => x.IsComplex) Finset.univ, β(βx_1).mult * (normAtPlace βx_1) x =\n β x_1 β F... | [
" convexBodySumFun x = β w : { w // w.IsReal }, βx.1 wβ + 2 * β w : { w // w.IsComplex }, βx.2 wβ",
" β x_1 β Finset.subtype (fun x => x.IsReal) Finset.univ, β(βx_1).mult * (normAtPlace βx_1) x +\n β x_1 β Finset.subtype (fun x => x.IsComplex) Finset.univ, β(βx_1).mult * (normAtPlace βx_1) x =\n β x_1 β F... |
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Topology.Algebra.Module.Basic
#align_import analysis.normed_space.basic from "leanprover-community/mathlib"@"bc91ed7093bf098d253401e69df601fc33dde156"
open Metric Set Function Filter
open scoped NNReal Topology
instance Real.punctured_nhds_module_neBot {E ... | Mathlib/Analysis/NormedSpace/Real.lean | 76 | 78 | theorem frontier_ball (x : E) {r : β} (hr : r β 0) :
frontier (ball x r) = sphere x r := by |
rw [frontier, closure_ball x hr, isOpen_ball.interior_eq, closedBall_diff_ball]
| [
" βxββ»ΒΉ β’ x β closedBall 0 1",
" βt β’ xβ = t * βxβ",
" dist (r β’ x + (1 - r) β’ y) x = β1 - rβ * βx - yβ",
" β1 - rβ * βx - yβ = (1 - r) * dist y x",
" (1 - r) * dist y x β€ (1 - 0) * dist y x",
" 0 β€ r",
" (1 - 0) * dist y x = dist y x",
" closure (ball x r) = closedBall x r",
" y β closure (ball x r... | [
" βxββ»ΒΉ β’ x β closedBall 0 1",
" βt β’ xβ = t * βxβ",
" dist (r β’ x + (1 - r) β’ y) x = β1 - rβ * βx - yβ",
" β1 - rβ * βx - yβ = (1 - r) * dist y x",
" (1 - r) * dist y x β€ (1 - 0) * dist y x",
" 0 β€ r",
" (1 - 0) * dist y x = dist y x",
" closure (ball x r) = closedBall x r",
" y β closure (ball x r... |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*}
section lift
protect... | Mathlib/Order/Filter/Lift.lean | 45 | 53 | theorem HasBasis.mem_lift_iff {ΞΉ} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±} {f : Filter Ξ±}
(hf : f.HasBasis p s) {Ξ² : ΞΉ β Type*} {pg : β i, Ξ² i β Prop} {sg : β i, Ξ² i β Set Ξ³}
{g : Set Ξ± β Filter Ξ³} (hg : β i, (g <| s i).HasBasis (pg i) (sg i)) (gm : Monotone g)
{s : Set Ξ³} : s β f.lift g β β i, p i β§ β x, pg i x β§ sg... |
refine (mem_biInf_of_directed ?_ β¨univ, univ_sets _β©).trans ?_
Β· intro tβ htβ tβ htβ
exact β¨tβ β© tβ, inter_mem htβ htβ, gm inter_subset_left, gm inter_subset_rightβ©
Β· simp only [β (hg _).mem_iff]
exact hf.exists_iff fun tβ tβ ht H => gm ht H
| [
" β€.lift g = g univ",
" s β f.lift g β β i, p i β§ β x, pg i x β§ sg i x β s",
" DirectedOn ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) f.sets",
" β z β f.sets, ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) tβ z β§ ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) tβ z",
" (β i β f.sets, s β g i) β β i, p i β§ β x, pg i x... | [
" β€.lift g = g univ"
] |
import Mathlib.Algebra.Module.Zlattice.Basic
import Mathlib.NumberTheory.NumberField.Embeddings
import Mathlib.NumberTheory.NumberField.FractionalIdeal
#align_import number_theory.number_field.canonical_embedding from "leanprover-community/mathlib"@"60da01b41bbe4206f05d34fd70c8dd7498717a30"
variable (K : Type*) [F... | Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean | 185 | 187 | theorem _root_.NumberField.mixedEmbedding_injective [NumberField K] :
Function.Injective (NumberField.mixedEmbedding K) := by |
exact RingHom.injective _
| [
" Nontrivial (({ w // w.IsReal } β β) Γ ({ w // w.IsComplex } β β))",
" finrank β (({ w // w.IsReal } β β) Γ ({ w // w.IsComplex } β β)) = finrank β K",
" Function.Injective β(mixedEmbedding K)"
] | [
" Nontrivial (({ w // w.IsReal } β β) Γ ({ w // w.IsComplex } β β))",
" finrank β (({ w // w.IsReal } β β) Γ ({ w // w.IsComplex } β β)) = finrank β K"
] |
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.GaloisConnection
import Mathlib.Order.Hom.Basic
#align_import order.hom.order from "leanprover-community/mathlib"@"ba2245edf0c8bb155f1569fd9b9492a9b384cde6"
namespace OrderHom
variable {Ξ± Ξ² : Type*}
section Preorder
variable [Preorder Ξ±]
instance [Sem... | Mathlib/Order/Hom/Order.lean | 117 | 119 | theorem coe_iSup {ΞΉ : Sort*} [CompleteLattice Ξ²] (f : ΞΉ β Ξ± βo Ξ²) :
((β¨ i, f i : Ξ± βo Ξ²) : Ξ± β Ξ²) = β¨ i, (f i : Ξ± β Ξ²) := by |
funext x; simp [iSup_apply]
| [
" β(β¨
i, f i) = β¨
i, β(f i)",
" (β¨
i, f i) x = (β¨
i, β(f i)) x",
" β(β¨ i, f i) = β¨ i, β(f i)",
" (β¨ i, f i) x = (β¨ i, β(f i)) x"
] | [
" β(β¨
i, f i) = β¨
i, β(f i)",
" (β¨
i, f i) x = (β¨
i, β(f i)) x"
] |
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.Fintype.Fin
import Mathlib.GroupTheory.GroupAction.Pi
import Mathlib.Logic.Equiv.Fin
#align_import algebra.big_operators.fin from "leanprover-community/mathlib"@"cc5dd6244981976cc9da7afc4eee5682b037a013"
open Fins... | Mathlib/Algebra/BigOperators/Fin.lean | 136 | 138 | theorem prod_univ_four [CommMonoid Ξ²] (f : Fin 4 β Ξ²) : β i, f i = f 0 * f 1 * f 2 * f 3 := by |
rw [prod_univ_castSucc, prod_univ_three]
rfl
| [
" (List.ofFn f).prod = β i : Fin n, f i",
" β i : Fin n, f i = (List.map f (List.finRange n)).prod",
" β i : Fin (n + 1), f i = f x * β i : Fin n, f (x.succAbove i)",
" f x * β x_1 : Fin n, f (x.succAboveEmb x_1) = f x * β i : Fin n, f (x.succAbove i)",
" β i : Fin (n + 1), f i = (β i : Fin n, f i.castSucc)... | [
" (List.ofFn f).prod = β i : Fin n, f i",
" β i : Fin n, f i = (List.map f (List.finRange n)).prod",
" β i : Fin (n + 1), f i = f x * β i : Fin n, f (x.succAbove i)",
" f x * β x_1 : Fin n, f (x.succAboveEmb x_1) = f x * β i : Fin n, f (x.succAbove i)",
" β i : Fin (n + 1), f i = (β i : Fin n, f i.castSucc)... |
import Mathlib.Algebra.Group.Subgroup.MulOpposite
import Mathlib.Algebra.Group.Submonoid.Pointwise
import Mathlib.GroupTheory.GroupAction.ConjAct
#align_import group_theory.subgroup.pointwise from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
open Set
open Pointwise
variable {Ξ± G A S... | Mathlib/Algebra/Group/Subgroup/Pointwise.lean | 89 | 102 | theorem closure_induction_left {p : (x : G) β x β closure s β Prop} (one : p 1 (one_mem _))
(mul_left : β x (hx : x β s), β (y) hy, p y hy β p (x * y) (mul_mem (subset_closure hx) hy))
(mul_left_inv : β x (hx : x β s), β (y) hy, p y hy β
p (xβ»ΒΉ * y) (mul_mem (inv_mem (subset_closure hx)) hy))
{x : G} ... |
revert h
simp_rw [β mem_toSubmonoid, closure_toSubmonoid] at *
intro h
induction h using Submonoid.closure_induction_left with
| one => exact one
| mul_left x hx y hy ih =>
cases hx with
| inl hx => exact mul_left _ hx _ hy ih
| inr hx => simpa only [inv_inv] using mul_left_inv _ hx _ hy ih
| [
" a β’ βs = βs",
" xβ β a β’ βs β xβ β βs",
" MulOpposite.op a β’ βs = βs",
" xβ β MulOpposite.op a β’ βs β xβ β βs",
" βH * βH = βH",
" βH / βH = βH",
" s β β(closure S)",
" sβ»ΒΉ β closure S",
" (closure S).toSubmonoid = Submonoid.closure (S βͺ Sβ»ΒΉ)",
" x β Submonoid.closure (S βͺ Sβ»ΒΉ)",
" xβ»ΒΉ β Submo... | [
" a β’ βs = βs",
" xβ β a β’ βs β xβ β βs",
" MulOpposite.op a β’ βs = βs",
" xβ β MulOpposite.op a β’ βs β xβ β βs",
" βH * βH = βH",
" βH / βH = βH",
" s β β(closure S)",
" sβ»ΒΉ β closure S",
" (closure S).toSubmonoid = Submonoid.closure (S βͺ Sβ»ΒΉ)",
" x β Submonoid.closure (S βͺ Sβ»ΒΉ)",
" xβ»ΒΉ β Submo... |
import Mathlib.Analysis.Calculus.FDeriv.Equiv
import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn
#align_import analysis.calculus.inverse from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
open Function Set Filter Metric
open scoped Topology Classical NNReal
n... | Mathlib/Analysis/Calculus/InverseFunctionTheorem/FDeriv.lean | 74 | 83 | theorem approximates_deriv_on_nhds {f : E β F} {f' : E βL[π] F} {a : E}
(hf : HasStrictFDerivAt f f' a) {c : ββ₯0} (hc : Subsingleton E β¨ 0 < c) :
β s β π a, ApproximatesLinearOn f f' s c := by |
cases' hc with hE hc
Β· refine β¨univ, IsOpen.mem_nhds isOpen_univ trivial, fun x _ y _ => ?_β©
simp [@Subsingleton.elim E hE x y]
have := hf.def hc
rw [nhds_prod_eq, Filter.Eventually, mem_prod_same_iff] at this
rcases this with β¨s, has, hsβ©
exact β¨s, has, fun x hx y hy => hs (mk_mem_prod hx hy)β©
| [
" β s β π a, ApproximatesLinearOn f f' s c",
" βf x - f y - f' (x - y)β β€ βc * βx - yβ"
] | [] |
import Mathlib.Algebra.Divisibility.Basic
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Ring.Defs
#align_import algebra.euclidean_domain.defs from "leanprover-community/mathlib"@"ee7b9f9a9ac2a8d9f04ea39bbfe6b1a3be053b38"
universe u
class EuclideanDomain (R : Type u) extends CommRing R, Nontrivial R ... | Mathlib/Algebra/EuclideanDomain/Defs.lean | 151 | 153 | theorem mul_right_not_lt {a : R} (b) (h : a β 0) : Β¬a * b βΊ b := by |
rw [mul_comm]
exact mul_left_not_lt b h
| [
" m % k + m / k * k = m",
" m % k + k * (m / k) = m",
" m / k * k + m % k = m",
" k * (m / k) + m % k = m",
" b * (a / b) + a % b - b * (a / b) = a - b * (a / b)",
" Β¬a * b βΊ b",
" Β¬b * a βΊ b"
] | [
" m % k + m / k * k = m",
" m % k + k * (m / k) = m",
" m / k * k + m % k = m",
" k * (m / k) + m % k = m",
" b * (a / b) + a % b - b * (a / b) = a - b * (a / b)"
] |
import Mathlib.FieldTheory.RatFunc.AsPolynomial
import Mathlib.RingTheory.EuclideanDomain
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Polynomial.Content
noncomputable section
universe u
variable {K : Type u}
namespace RatFunc
section IntDegree
open Polynomial
variable [Field... | Mathlib/FieldTheory/RatFunc/Degree.lean | 44 | 45 | theorem intDegree_zero : intDegree (0 : RatFunc K) = 0 := by |
rw [intDegree, num_zero, natDegree_zero, denom_zero, natDegree_one, sub_self]
| [
" intDegree 0 = 0"
] | [] |
import Mathlib.RingTheory.Localization.Module
import Mathlib.RingTheory.Norm
import Mathlib.RingTheory.Discriminant
#align_import ring_theory.localization.norm from "leanprover-community/mathlib"@"2e59a6de168f95d16b16d217b808a36290398c0a"
open scoped nonZeroDivisors
variable (R : Type*) {S : Type*} [CommRing R] ... | Mathlib/RingTheory/Localization/NormTrace.lean | 115 | 119 | theorem Algebra.discr_localizationLocalization (b : Basis ΞΉ R S) :
Algebra.discr Rβ (b.localizationLocalization Rβ M Sβ) =
algebraMap R Rβ (Algebra.discr R b) := by |
rw [Algebra.discr_def, Algebra.discr_def, RingHom.map_det,
Algebra.traceMatrix_localizationLocalization]
| [
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a)",
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) i j =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a) i j",
" (norm Rβ) ((algebr... | [
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a)",
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) i j =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a) i j",
" (norm Rβ) ((algebr... |
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.CategoryTheory.Groupoid.VertexGroup
import Mathlib.CategoryTheory.Groupoid.Basic
import Mathlib.CategoryTheory.Groupoid
import Mathlib.Data.Set.Lattice
import Mathlib.Order.GaloisConnection
#align_import category_theory.groupoid.subgroupoid from "leanprover-c... | Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean | 90 | 97 | theorem mul_mem_cancel_left {c d e : C} {f : c βΆ d} {g : d βΆ e} (hf : f β S.arrows c d) :
f β« g β S.arrows c e β g β S.arrows d e := by |
constructor
Β· rintro h
suffices Groupoid.inv f β« f β« g β S.arrows d e by
simpa only [inv_eq_inv, IsIso.inv_hom_id_assoc] using this
apply S.mul (S.inv hf) h
Β· apply S.mul hf
| [
" Groupoid.inv f β S.arrows d c β f β S.arrows c d",
" Groupoid.inv f β S.arrows d c β f β S.arrows c d",
" f β S.arrows c d",
" f β S.arrows c d β Groupoid.inv f β S.arrows d c",
" f β« g β S.arrows c e β g β S.arrows d e",
" f β« g β S.arrows c e β g β S.arrows d e",
" g β S.arrows d e",
" Groupoid.in... | [
" Groupoid.inv f β S.arrows d c β f β S.arrows c d",
" Groupoid.inv f β S.arrows d c β f β S.arrows c d",
" f β S.arrows c d",
" f β S.arrows c d β Groupoid.inv f β S.arrows d c"
] |
import Batteries.Data.Fin.Basic
namespace Fin
attribute [norm_cast] val_last
protected theorem le_antisymm_iff {x y : Fin n} : x = y β x β€ y β§ y β€ x :=
Fin.ext_iff.trans Nat.le_antisymm_iff
protected theorem le_antisymm {x y : Fin n} (h1 : x β€ y) (h2 : y β€ x) : x = y :=
Fin.le_antisymm_iff.2 β¨h1, h2β©
@[simp... | .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean | 63 | 64 | theorem foldl_loop_eq (f : Ξ± β Fin n β Ξ±) (x) : foldl.loop n f x n = x := by |
rw [foldl.loop, dif_neg (Nat.lt_irrefl _)]
| [
" enum 0 = #[]",
" (list n).length = n",
" (list n).get i = cast β― i",
" (list n).get β¨valβ, isLtββ© = cast β― β¨valβ, isLtββ©",
" (enum n).data.get β¨valβ, isLtββ© = cast β― β¨valβ, isLtββ©",
" list 0 = []",
" list (n + 1) = 0 :: List.map succ (list n)",
" β (n_1 : Nat) (hβ : n_1 < (list (n + 1)).length) (hβ ... | [
" enum 0 = #[]",
" (list n).length = n",
" (list n).get i = cast β― i",
" (list n).get β¨valβ, isLtββ© = cast β― β¨valβ, isLtββ©",
" (enum n).data.get β¨valβ, isLtββ© = cast β― β¨valβ, isLtββ©",
" list 0 = []",
" list (n + 1) = 0 :: List.map succ (list n)",
" β (n_1 : Nat) (hβ : n_1 < (list (n + 1)).length) (hβ ... |
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Ring.Action.Subobjects
import Mathlib.Algebra.Ring.Equiv
import Mathlib.Algebra.Ring.Prod
import Mathlib.Data.Set.Finite
import Mathlib.GroupTheory.Submonoid.Centralizer
import Mathlib.RingTheory.NonUnitalSubsem... | Mathlib/Algebra/Ring/Subsemiring/Basic.lean | 39 | 40 | theorem natCast_mem [AddSubmonoidWithOneClass S R] (n : β) : (n : R) β s := by |
induction n <;> simp [zero_mem, add_mem, one_mem, *]
| [
" βn β s",
" β0 β s",
" β(nβ + 1) β s"
] | [] |
import Mathlib.Data.Finset.Lattice
import Mathlib.Data.Finset.NAry
import Mathlib.Data.Multiset.Functor
#align_import data.finset.functor from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
universe u
open Function
namespace Finset
protected instance pure : Pure Finset :=
β¨fun... | Mathlib/Data/Finset/Functor.lean | 200 | 202 | theorem id_traverse [DecidableEq Ξ±] (s : Finset Ξ±) : traverse (pure : Ξ± β Id Ξ±) s = s := by |
rw [traverse, Multiset.id_traverse]
exact s.val_toFinset
| [
" traverse pure s = s",
" Multiset.toFinset <$> s.val = s"
] | [] |
import Mathlib.Algebra.Order.Monoid.Defs
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Util.AssertExists
#align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"
open Function
universe u
variable {Ξ± : Type u}
class OrderedAddCommGroup (Ξ± : Ty... | Mathlib/Algebra/Order/Group/Defs.lean | 98 | 100 | theorem Left.inv_le_one_iff : aβ»ΒΉ β€ 1 β 1 β€ a := by |
rw [β mul_le_mul_iff_left a]
simp
| [
" b β€ c",
" aβ»ΒΉ β€ 1 β 1 β€ a",
" a * aβ»ΒΉ β€ a * 1 β 1 β€ a"
] | [
" b β€ c"
] |
import Mathlib.Algebra.Lie.CartanSubalgebra
import Mathlib.Algebra.Lie.Weights.Basic
suppress_compilation
open Set
variable {R L : Type*} [CommRing R] [LieRing L] [LieAlgebra R L]
(H : LieSubalgebra R L) [LieAlgebra.IsNilpotent R H]
{M : Type*} [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L ... | Mathlib/Algebra/Lie/Weights/Cartan.lean | 127 | 132 | theorem coe_rootSpaceWeightSpaceProduct_tmul (Οβ Οβ Οβ : H β R) (hΟ : Οβ + Οβ = Οβ)
(x : rootSpace H Οβ) (m : weightSpace M Οβ) :
(rootSpaceWeightSpaceProduct R L H M Οβ Οβ Οβ hΟ (x ββ m) : M) = β
(x : L), (m : M)β := by |
simp only [rootSpaceWeightSpaceProduct, rootSpaceWeightSpaceProductAux, coe_liftLie_eq_lift_coe,
AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, lift_apply, LinearMap.coe_mk, AddHom.coe_mk,
Submodule.coe_mk]
| [
" β
x, mβ β weightSpace M (Οβ + Οβ)",
" β (i : β₯H), β
x, mβ β weightSpaceOf M ((Οβ + Οβ) i) i",
" β
x, mβ β weightSpaceOf M ((Οβ + Οβ) y) y",
" x β weightSpaceOf L (Οβ y) y",
" m β weightSpaceOf M (Οβ y) y",
" ((toEnd R L M) x ^ n) m β weightSpace M (n β’ Οβ + Οβ)",
" ((toEnd R L M) x ^ 0) m β weightSpace M... | [
" β
x, mβ β weightSpace M (Οβ + Οβ)",
" β (i : β₯H), β
x, mβ β weightSpaceOf M ((Οβ + Οβ) i) i",
" β
x, mβ β weightSpaceOf M ((Οβ + Οβ) y) y",
" x β weightSpaceOf L (Οβ y) y",
" m β weightSpaceOf M (Οβ y) y",
" ((toEnd R L M) x ^ n) m β weightSpace M (n β’ Οβ + Οβ)",
" ((toEnd R L M) x ^ 0) m β weightSpace M... |
import Mathlib.AlgebraicGeometry.Morphisms.Basic
import Mathlib.Topology.LocalAtTarget
#align_import algebraic_geometry.morphisms.universally_closed from "leanprover-community/mathlib"@"a8ae1b3f7979249a0af6bc7cf20c1f6bf656ca73"
noncomputable section
open CategoryTheory CategoryTheory.Limits Opposite TopologicalS... | Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean | 88 | 94 | theorem universallyClosed_is_local_at_target : PropertyIsLocalAtTarget @UniversallyClosed := by |
rw [universallyClosed_eq]
apply universallyIsLocalAtTargetOfMorphismRestrict
Β· exact topologically_isClosedMap_respectsIso
Β· intro X Y f ΞΉ U hU H
simp_rw [topologically, morphismRestrict_base] at H
exact (isClosedMap_iff_isClosedMap_of_iSup_eq_top hU).mpr H
| [
" @UniversallyClosed = (topologically @IsClosedMap).universally",
" UniversallyClosed f β (topologically @IsClosedMap).universally f",
" IsStableUnderComposition @UniversallyClosed",
" (topologically @IsClosedMap).universally.IsStableUnderComposition",
" (topologically @IsClosedMap).RespectsIso",
" isomor... | [
" @UniversallyClosed = (topologically @IsClosedMap).universally",
" UniversallyClosed f β (topologically @IsClosedMap).universally f",
" IsStableUnderComposition @UniversallyClosed",
" (topologically @IsClosedMap).universally.IsStableUnderComposition",
" (topologically @IsClosedMap).RespectsIso",
" isomor... |
import Mathlib.Data.ULift
import Mathlib.Data.ZMod.Defs
import Mathlib.SetTheory.Cardinal.PartENat
#align_import set_theory.cardinal.finite from "leanprover-community/mathlib"@"3ff3f2d6a3118b8711063de7111a0d77a53219a8"
set_option autoImplicit true
open Cardinal Function
noncomputable section
variable {Ξ± Ξ² : Typ... | Mathlib/SetTheory/Cardinal/Finite.lean | 97 | 98 | theorem card_eq_of_equiv_fin {Ξ± : Type*} {n : β} (f : Ξ± β Fin n) : Nat.card Ξ± = n := by |
simpa only [card_eq_fintype_card, Fintype.card_fin] using card_congr f
| [
" Nat.card { x // x β s } = s.card",
" Nat.card βs = s.toFinset.card",
" Nat.card βs = hs.toFinset.card",
" Nat.card Ξ± = 0",
" Nat.card Ξ± = 0 β IsEmpty Ξ± β¨ Infinite Ξ±",
" Nat.card Ξ± β 0 β Nonempty Ξ± β§ Finite Ξ±",
" 0 < Nat.card Ξ± β Nonempty Ξ± β§ Finite Ξ±",
" Nat.card Ξ± β€ Nat.card Ξ²",
" lift.{u, v} #Ξ² ... | [
" Nat.card { x // x β s } = s.card",
" Nat.card βs = s.toFinset.card",
" Nat.card βs = hs.toFinset.card",
" Nat.card Ξ± = 0",
" Nat.card Ξ± = 0 β IsEmpty Ξ± β¨ Infinite Ξ±",
" Nat.card Ξ± β 0 β Nonempty Ξ± β§ Finite Ξ±",
" 0 < Nat.card Ξ± β Nonempty Ξ± β§ Finite Ξ±",
" Nat.card Ξ± β€ Nat.card Ξ²",
" lift.{u, v} #Ξ² ... |
import Mathlib.Analysis.Calculus.Deriv.Basic
#align_import analysis.calculus.deriv.support from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v
variable {π : Type u} [NontriviallyNormedField π]
variable {E : Type v} [NormedAddCommGroup E] [NormedSpace π E]
variable {f : ... | Mathlib/Analysis/Calculus/Deriv/Support.lean | 36 | 41 | theorem support_deriv_subset : support (deriv f) β tsupport f := by |
intro x
rw [β not_imp_not]
intro h2x
rw [not_mem_tsupport_iff_eventuallyEq] at h2x
exact nmem_support.mpr (h2x.deriv_eq.trans (deriv_const x 0))
| [
" support (deriv f) β tsupport f",
" x β support (deriv f) β x β tsupport f",
" x β tsupport f β x β support (deriv f)",
" x β support (deriv f)"
] | [] |
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Tactic.Ring
#align_import data.nat.hyperoperation from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
def hyperoperation : β β β β β β β
| 0, _, k => k + 1
| 1, m, 0 => m
| 2, _, 0 => 0
| _ + 3, _, 0 => 1
| n + 1, m, k + 1 ... | Mathlib/Data/Nat/Hyperoperation.lean | 49 | 50 | theorem hyperoperation_ge_three_eq_one (n m : β) : hyperoperation (n + 3) m 0 = 1 := by |
rw [hyperoperation]
| [
" hyperoperation 0 m k = k.succ",
" hyperoperation (n + 3) m 0 = 1"
] | [
" hyperoperation 0 m k = k.succ"
] |
import Mathlib.Data.ZMod.Basic
import Mathlib.Algebra.Group.Nat
import Mathlib.Tactic.IntervalCases
import Mathlib.GroupTheory.SpecificGroups.Dihedral
import Mathlib.GroupTheory.SpecificGroups.Cyclic
#align_import group_theory.specific_groups.quaternion from "leanprover-community/mathlib"@"879155bff5af618b9062cbb2915... | Mathlib/GroupTheory/SpecificGroups/Quaternion.lean | 174 | 176 | theorem card [NeZero n] : Fintype.card (QuaternionGroup n) = 4 * n := by |
rw [β Fintype.card_eq.mpr β¨fintypeHelperβ©, Fintype.card_sum, ZMod.card, two_mul]
ring
| [
" β (a b c : QuaternionGroup n), a * b * c = a * (b * c)",
" a i * a j * a k = a i * (a j * a k)",
" a i * a j * xa k = a i * (a j * xa k)",
" a i * xa j * a k = a i * (xa j * a k)",
" a i * xa j * xa k = a i * (xa j * xa k)",
" xa i * a j * a k = xa i * (a j * a k)",
" xa i * a j * xa k = xa i * (a j *... | [
" β (a b c : QuaternionGroup n), a * b * c = a * (b * c)",
" a i * a j * a k = a i * (a j * a k)",
" a i * a j * xa k = a i * (a j * xa k)",
" a i * xa j * a k = a i * (xa j * a k)",
" a i * xa j * xa k = a i * (xa j * xa k)",
" xa i * a j * a k = xa i * (a j * a k)",
" xa i * a j * xa k = xa i * (a j *... |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.NormedSpace.FiniteDimension
#align_import analysis.calculus.cont_diff from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
universe uD uE uF uG
variable {π : Type*} [NontriviallyNormedField ... | Mathlib/Analysis/Calculus/ContDiff/FiniteDimension.lean | 35 | 43 | theorem contDiffOn_clm_apply {n : ββ} {f : E β F βL[π] G} {s : Set E} [FiniteDimensional π F] :
ContDiffOn π n f s β β y, ContDiffOn π n (fun x => f x y) s := by |
refine β¨fun h y => h.clm_apply contDiffOn_const, fun h => ?_β©
let d := finrank π F
have hd : d = finrank π (Fin d β π) := (finrank_fin_fun π).symm
let eβ := ContinuousLinearEquiv.ofFinrankEq hd
let eβ := (eβ.arrowCongr (1 : G βL[π] G)).trans (ContinuousLinearEquiv.piRing (Fin d))
rw [β id_comp f, β eβ... | [
" ContDiffOn π n f s β β (y : F), ContDiffOn π n (fun x => (f x) y) s",
" ContDiffOn π n f s",
" ContDiffOn π n ((βeβ.symm β βeβ) β f) s"
] | [] |
import Mathlib.MeasureTheory.Measure.AEMeasurable
#align_import dynamics.ergodic.measure_preserving from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
variable {Ξ± Ξ² Ξ³ Ξ΄ : Type*} [MeasurableSpace Ξ±] [MeasurableSpace Ξ²] [MeasurableSpace Ξ³]
[MeasurableSpace Ξ΄]
namespace MeasureTheory
... | Mathlib/Dynamics/Ergodic/MeasurePreserving.lean | 87 | 89 | theorem restrict_image_emb {f : Ξ± β Ξ²} (hf : MeasurePreserving f ΞΌa ΞΌb) (hβ : MeasurableEmbedding f)
(s : Set Ξ±) : MeasurePreserving f (ΞΌa.restrict s) (ΞΌb.restrict (f '' s)) := by |
simpa only [Set.preimage_image_eq _ hβ.injective] using hf.restrict_preimage_emb hβ (f '' s)
| [
" map (βe.symm) ΞΌb = ΞΌa",
" map f (ΞΌa.restrict (f β»ΒΉ' s)) = ΞΌb.restrict s",
" MeasurePreserving f (ΞΌa.restrict s) (ΞΌb.restrict (f '' s))"
] | [
" map (βe.symm) ΞΌb = ΞΌa",
" map f (ΞΌa.restrict (f β»ΒΉ' s)) = ΞΌb.restrict s"
] |
import Mathlib.Algebra.Ring.Regular
import Mathlib.Data.Int.GCD
import Mathlib.Data.Int.Order.Lemmas
import Mathlib.Tactic.NormNum.Basic
#align_import data.nat.modeq from "leanprover-community/mathlib"@"47a1a73351de8dd6c8d3d32b569c8e434b03ca47"
assert_not_exists Function.support
namespace Nat
def ModEq (n a b :... | Mathlib/Data/Nat/ModEq.lean | 89 | 91 | theorem modEq_iff_dvd : a β‘ b [MOD n] β (n : β€) β£ b - a := by |
rw [ModEq, eq_comm, β Int.natCast_inj, Int.natCast_mod, Int.natCast_mod,
Int.emod_eq_emod_iff_emod_sub_eq_zero, Int.dvd_iff_emod_eq_zero]
| [
" a β‘ 0 [MOD n] β n β£ a",
" a β‘ b [MOD n] β βn β£ βb - βa"
] | [
" a β‘ 0 [MOD n] β n β£ a"
] |
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Data.Set.Lattice
#align_import group_theory.archimedean from "leanprover-community/mathlib"@"f93c11933efbc3c2f0299e47b8ff83e9b539cbf6"
open Set
variable {G : Type*} [LinearOrderedAddCommGroup G] [Archimedean G]
th... | Mathlib/GroupTheory/Archimedean.lean | 91 | 95 | theorem AddSubgroup.cyclic_of_isolated_zero {H : AddSubgroup G} {a : G} (hβ : 0 < a)
(hd : Disjoint (H : Set G) (Ioo 0 a)) : β b, H = closure {b} := by |
rcases eq_or_ne H β₯ with rfl | hbot
Β· exact β¨0, closure_singleton_zero.symmβ©
Β· exact (exists_isLeast_pos hbot hβ hd).imp fun _ => cyclic_of_min
| [
" H = closure {a}",
" {a} β βH",
" H β€ closure {a}",
" g β closure {a}",
" g - k β’ a = 0",
" False",
" a β€ g - k β’ a",
" g - k β’ a β H",
" 0 < g - k β’ a",
" β b, IsLeast {g | g β H β§ 0 < g} b",
" β n, g β Ioc (n β’ a) ((n + 1) β’ a)",
" 0 β€ m",
" 0 < (m + 1) β’ a",
" β n, (βH β© Ioc (n β’ a) ((... | [
" H = closure {a}",
" {a} β βH",
" H β€ closure {a}",
" g β closure {a}",
" g - k β’ a = 0",
" False",
" a β€ g - k β’ a",
" g - k β’ a β H",
" 0 < g - k β’ a",
" β b, IsLeast {g | g β H β§ 0 < g} b",
" β n, g β Ioc (n β’ a) ((n + 1) β’ a)",
" 0 β€ m",
" 0 < (m + 1) β’ a",
" β n, (βH β© Ioc (n β’ a) ((... |
import Mathlib.Algebra.MonoidAlgebra.Basic
import Mathlib.Data.Finset.Pointwise
#align_import algebra.monoid_algebra.support from "leanprover-community/mathlib"@"16749fc4661828cba18cd0f4e3c5eb66a8e80598"
open scoped Pointwise
universe uβ uβ uβ
namespace MonoidAlgebra
open Finset Finsupp
variable {k : Type uβ} ... | Mathlib/Algebra/MonoidAlgebra/Support.lean | 95 | 97 | theorem mem_span_support (f : MonoidAlgebra k G) :
f β Submodule.span k (of k G '' (f.support : Set G)) := by |
erw [of, MonoidHom.coe_mk, β supported_eq_span_single, Finsupp.mem_supported]
| [
" (a * b).support β a.support * b.support",
" (sum a fun aβ bβ => sum b fun aβ bβ => single (aβ * aβ) (bβ * bβ)).support β a.support * b.support",
" imageβ (fun x x_1 => x * x_1) {a} f.support β image (fun x => a * x) f.support",
" imageβ (fun x x_1 => x * x_1) f.support {a} β image (fun x => x * a) f.support... | [
" (a * b).support β a.support * b.support",
" (sum a fun aβ bβ => sum b fun aβ bβ => single (aβ * aβ) (bβ * bβ)).support β a.support * b.support",
" imageβ (fun x x_1 => x * x_1) {a} f.support β image (fun x => a * x) f.support",
" imageβ (fun x x_1 => x * x_1) f.support {a} β image (fun x => x * a) f.support... |
import Batteries.Tactic.Init
import Batteries.Tactic.Alias
import Batteries.Tactic.Lint.Misc
instance {f : Ξ± β Ξ²} [DecidablePred p] : DecidablePred (p β f) :=
inferInstanceAs <| DecidablePred fun x => p (f x)
@[deprecated] alias proofIrrel := proof_irrel
theorem Function.id_def : @id Ξ± = fun x => x := rfl
al... | .lake/packages/batteries/Batteries/Logic.lean | 94 | 97 | theorem eqRec_heq_self {Ξ± : Sort _} {a : Ξ±} {motive : (a' : Ξ±) β a = a' β Sort _}
(x : motive a (rfl : a = a)) {a' : Ξ±} (e : a = a') :
HEq (@Eq.rec Ξ± a motive x a' e) x := by |
subst e; rfl
| [
" h βΈ y = y",
" β― βΈ y = y",
" f x y = f x' y'",
" f x y = f x y",
" xβ = xβ β yβ = yβ",
" xβ = xβ β xβ = yβ",
" xβ = xβ β xβ = xβ",
" x = z β y = z",
" z = x β z = y",
" cast e a = a'",
" cast e a = a",
" e βΈ x = cast β― x",
" β― βΈ x = cast β― x",
" HEq (e βΈ x) x",
" HEq (β― βΈ x) x"
] | [
" h βΈ y = y",
" β― βΈ y = y",
" f x y = f x' y'",
" f x y = f x y",
" xβ = xβ β yβ = yβ",
" xβ = xβ β xβ = yβ",
" xβ = xβ β xβ = xβ",
" x = z β y = z",
" z = x β z = y",
" cast e a = a'",
" cast e a = a",
" e βΈ x = cast β― x",
" β― βΈ x = cast β― x"
] |
import Mathlib.Order.Interval.Finset.Nat
import Mathlib.Data.PNat.Defs
#align_import data.pnat.interval from "leanprover-community/mathlib"@"1d29de43a5ba4662dd33b5cfeecfc2a27a5a8a29"
open Finset Function PNat
namespace PNat
variable (a b : β+)
instance instLocallyFiniteOrder : LocallyFiniteOrder β+ := Subtype.... | Mathlib/Data/PNat/Interval.lean | 76 | 81 | theorem card_Ico : (Ico a b).card = b - a := by |
rw [β Nat.card_Ico]
-- Porting note: I had to change this to `erw` *and* provide the proof, yuck.
-- https://github.com/leanprover-community/mathlib4/issues/5164
erw [β Finset.map_subtype_embedding_Ico _ a b (fun c x _ hx _ hc _ => hc.trans_le hx)]
rw [card_map]
| [
" (Icc a b).card = βb + 1 - βa",
" (Icc a b).card = (Icc βa βb).card",
" (Icc a b).card = (map (Embedding.subtype fun n => 0 < n) (Icc a b)).card",
" (Ico a b).card = βb - βa",
" (Ico a b).card = (Ico βa βb).card",
" (Ico a b).card = (map (Embedding.subtype fun n => 0 < n) (Ico a b)).card"
] | [
" (Icc a b).card = βb + 1 - βa",
" (Icc a b).card = (Icc βa βb).card",
" (Icc a b).card = (map (Embedding.subtype fun n => 0 < n) (Icc a b)).card"
] |
import Mathlib.MeasureTheory.Function.LpSeminorm.Basic
import Mathlib.MeasureTheory.Integral.MeanInequalities
#align_import measure_theory.function.lp_seminorm from "leanprover-community/mathlib"@"c4015acc0a223449d44061e27ddac1835a3852b9"
open Filter
open scoped ENNReal Topology
namespace MeasureTheory
section B... | Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean | 158 | 196 | theorem snorm_le_snorm_top_mul_snorm (p : ββ₯0β) (f : Ξ± β E) {g : Ξ± β F}
(hg : AEStronglyMeasurable g ΞΌ) (b : E β F β G)
(h : βα΅ x βΞΌ, βb (f x) (g x)ββ β€ βf xββ * βg xββ) :
snorm (fun x => b (f x) (g x)) p ΞΌ β€ snorm f β ΞΌ * snorm g p ΞΌ := by |
by_cases hp_top : p = β
Β· simp_rw [hp_top, snorm_exponent_top]
refine le_trans (essSup_mono_ae <| h.mono fun a ha => ?_) (ENNReal.essSup_mul_le _ _)
simp_rw [Pi.mul_apply, β ENNReal.coe_mul, ENNReal.coe_le_coe]
exact ha
by_cases hp_zero : p = 0
Β· simp only [hp_zero, snorm_exponent_zero, mul_zero, l... | [
" snorm (fun x => b (f x) (g x)) p ΞΌ β€ snorm f β€ ΞΌ * snorm g p ΞΌ",
" snormEssSup (fun x => b (f x) (g x)) ΞΌ β€ snormEssSup f ΞΌ * snormEssSup g ΞΌ",
" (fun x => ββ(fun x => b (f x) (g x)) xββ) a β€ ((fun x => ββf xββ) * fun x => ββg xββ) a",
" βb (f a) (g a)ββ β€ βf aββ * βg aββ",
" (β«β» (x : Ξ±), ββb (f x) (g x)β... | [] |
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Maximal
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Noetherian
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
#align_impo... | Mathlib/RingTheory/DedekindDomain/Ideal.lean | 148 | 150 | theorem spanSingleton_div_spanSingleton (x y : K) :
spanSingleton Rββ° x / spanSingleton Rββ° y = spanSingleton Rββ° (x / y) := by |
rw [div_spanSingleton, mul_comm, spanSingleton_mul_spanSingleton, div_eq_mul_inv]
| [
" βJβ»ΒΉ = IsLocalization.coeSubmodule K β€ / βJ",
" Jβ»ΒΉ β€ Iβ»ΒΉ",
" x β (fun a => βa) Jβ»ΒΉ β x β (fun a => βa) Iβ»ΒΉ",
" (β y β J, x * y β 1) β β y β I, x * y β 1",
" J = Iβ»ΒΉ",
" I * (1 / I) = 1",
" I * (1 / I) β€ 1",
" β i β I, β j β 1 / I, i * j β 1",
" x * y β 1",
" y * x β 1",
" 1 β€ I * (1 / I)",
... | [
" βJβ»ΒΉ = IsLocalization.coeSubmodule K β€ / βJ",
" Jβ»ΒΉ β€ Iβ»ΒΉ",
" x β (fun a => βa) Jβ»ΒΉ β x β (fun a => βa) Iβ»ΒΉ",
" (β y β J, x * y β 1) β β y β I, x * y β 1",
" J = Iβ»ΒΉ",
" I * (1 / I) = 1",
" I * (1 / I) β€ 1",
" β i β I, β j β 1 / I, i * j β 1",
" x * y β 1",
" y * x β 1",
" 1 β€ I * (1 / I)",
... |
import Mathlib.Probability.Martingale.BorelCantelli
import Mathlib.Probability.ConditionalExpectation
import Mathlib.Probability.Independence.Basic
#align_import probability.borel_cantelli from "leanprover-community/mathlib"@"2f8347015b12b0864dfaf366ec4909eb70c78740"
open scoped MeasureTheory ProbabilityTheory EN... | Mathlib/Probability/BorelCantelli.lean | 60 | 66 | theorem iIndepSet.condexp_indicator_filtrationOfSet_ae_eq (hsm : β n, MeasurableSet (s n))
(hs : iIndepSet s ΞΌ) (hij : i < j) :
ΞΌ[(s j).indicator (fun _ => 1 : Ξ© β β)|filtrationOfSet hsm i] =α΅[ΞΌ]
fun _ => (ΞΌ (s j)).toReal := by |
rw [Filtration.filtrationOfSet_eq_natural (Ξ² := β) hsm]
refine (iIndepFun.condexp_natural_ae_eq_of_lt _ hs.iIndepFun_indicator hij).trans ?_
simp only [integral_indicator_const _ (hsm _), Algebra.id.smul_eq_mul, mul_one]; rfl
| [
" Indep (MeasurableSpace.comap (f j) mΞ²) (β(Filtration.natural f hf) i) ΞΌ",
" Indep (β¨ k β {j}, MeasurableSpace.comap (f k) mΞ²) (β¨ k β {k | k β€ i}, MeasurableSpace.comap (f k) mΞ²) ΞΌ",
" Disjoint {j} {k | k β€ i}",
" ΞΌ[(s j).indicator fun x => 1|β(filtrationOfSet hsm) i] =αΆ [ae ΞΌ] fun x => (ΞΌ (s j)).toReal",
"... | [
" Indep (MeasurableSpace.comap (f j) mΞ²) (β(Filtration.natural f hf) i) ΞΌ",
" Indep (β¨ k β {j}, MeasurableSpace.comap (f k) mΞ²) (β¨ k β {k | k β€ i}, MeasurableSpace.comap (f k) mΞ²) ΞΌ",
" Disjoint {j} {k | k β€ i}"
] |
import Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer
import Mathlib.CategoryTheory.Limits.Preserves.Basic
#align_import category_theory.limits.preserves.shapes.equalizers from "leanprover-community/mathlib"@"4698e35ca56a0d4fa53aa5639c3364e0a77f4eba"
noncomputable section
universe w vβ vβ uβ uβ
open Cate... | Mathlib/CategoryTheory/Limits/Preserves/Shapes/Equalizers.lean | 215 | 218 | theorem map_Ο_preserves_coequalizer_inv_desc {W : D} (k : G.obj Y βΆ W)
(wk : G.map f β« k = G.map g β« k) : G.map (coequalizer.Ο f g) β«
(PreservesCoequalizer.iso G f g).inv β« coequalizer.desc k wk = k := by |
rw [β Category.assoc, map_Ο_preserves_coequalizer_inv, coequalizer.Ο_desc]
| [
" G.map f β« G.map h = G.map g β« G.map h",
" Cofork.Ο\n ((Cocones.precompose (diagramIsoParallelPair (parallelPair f g β G)).inv).obj (G.mapCocone (Cofork.ofΟ h w))) β«\n (Iso.refl\n ((Cocones.precompose (diagramIsoParallelPair (parallelPair f g β G)).inv).obj\n (G.mapCocone (Cofor... | [
" G.map f β« G.map h = G.map g β« G.map h",
" Cofork.Ο\n ((Cocones.precompose (diagramIsoParallelPair (parallelPair f g β G)).inv).obj (G.mapCocone (Cofork.ofΟ h w))) β«\n (Iso.refl\n ((Cocones.precompose (diagramIsoParallelPair (parallelPair f g β G)).inv).obj\n (G.mapCocone (Cofor... |
import Mathlib.AlgebraicGeometry.GammaSpecAdjunction
import Mathlib.AlgebraicGeometry.Restrict
import Mathlib.CategoryTheory.Limits.Opposites
import Mathlib.RingTheory.Localization.InvSubmonoid
#align_import algebraic_geometry.AffineScheme from "leanprover-community/mathlib"@"88474d1b5af6d37c2ab728b757771bced7f5194c"... | Mathlib/AlgebraicGeometry/AffineScheme.lean | 209 | 215 | theorem isBasis_affine_open (X : Scheme) : Opens.IsBasis X.affineOpens := by |
rw [Opens.isBasis_iff_nbhd]
rintro U x (hU : x β (U : Set X))
obtain β¨S, hS, hxS, hSUβ© := X.affineBasisCover_is_basis.exists_subset_of_mem_open hU U.isOpen
refine β¨β¨S, X.affineBasisCover_is_basis.isOpen hSβ©, ?_, hxS, hSUβ©
rcases hS with β¨i, rflβ©
exact rangeIsAffineOpenOfOpenImmersion _
| [
" IsAffine X",
" X β Scheme.Spec.essImage",
" IsAffineOpen (Scheme.Hom.opensRange f)",
" Set.range βf.val.base = Set.range β(Y.ofRestrict β―).val.base",
" IsAffineOpen β€",
" β€ = Scheme.Hom.opensRange (π X)",
" ββ€ = β(Scheme.Hom.opensRange (π X))",
" Opens.IsBasis X.affineOpens",
" β {U : Opens ββX.... | [
" IsAffine X",
" X β Scheme.Spec.essImage",
" IsAffineOpen (Scheme.Hom.opensRange f)",
" Set.range βf.val.base = Set.range β(Y.ofRestrict β―).val.base",
" IsAffineOpen β€",
" β€ = Scheme.Hom.opensRange (π X)",
" ββ€ = β(Scheme.Hom.opensRange (π X))"
] |
import Mathlib.Data.Matrix.Basic
variable {l m n o : Type*}
universe u v w
variable {R : Type*} {Ξ± : Type v} {Ξ² : Type w}
namespace Matrix
def col (w : m β Ξ±) : Matrix m Unit Ξ± :=
of fun x _ => w x
#align matrix.col Matrix.col
-- TODO: set as an equation lemma for `col`, see mathlib4#3024
@[simp]
theorem col... | Mathlib/Data/Matrix/RowCol.lean | 123 | 126 | theorem col_vecMul [Fintype m] [NonUnitalNonAssocSemiring Ξ±] (M : Matrix m n Ξ±) (v : m β Ξ±) :
Matrix.col (v α΅₯* M) = (Matrix.row v * M)α΅ := by |
ext
rfl
| [
" col (v + w) = col v + col w",
" col (v + w) iβ jβ = (col v + col w) iβ jβ",
" col (x β’ v) = x β’ col v",
" col (x β’ v) iβ jβ = (x β’ col v) iβ jβ",
" row (v + w) = row v + row w",
" row (v + w) iβ jβ = (row v + row w) iβ jβ",
" row (x β’ v) = x β’ row v",
" row (x β’ v) iβ jβ = (x β’ row v) iβ jβ",
" (c... | [
" col (v + w) = col v + col w",
" col (v + w) iβ jβ = (col v + col w) iβ jβ",
" col (x β’ v) = x β’ col v",
" col (x β’ v) iβ jβ = (x β’ col v) iβ jβ",
" row (v + w) = row v + row w",
" row (v + w) iβ jβ = (row v + row w) iβ jβ",
" row (x β’ v) = x β’ row v",
" row (x β’ v) iβ jβ = (x β’ row v) iβ jβ",
" (c... |
import Mathlib.CategoryTheory.Preadditive.Injective
import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
import Mathlib.Algebra.Homology.QuasiIso
#align_import category_theory.preadditive.injective_resolution from "leanprover-community/mathlib"@"14b69e9f3c16630440a2cbd46f1ddad0d561dee7"
noncomputable s... | Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean | 104 | 106 | theorem ΞΉ_f_zero_comp_complex_d :
I.ΞΉ.f 0 β« I.cocomplex.d 0 1 = 0 := by |
simp
| [
" ExactAt I.cocomplex (n + 1)",
" QuasiIsoAt I.ΞΉ (n + 1)",
" (ComplexShape.up β).prev (n + 1) = n",
" (ComplexShape.up β).next (n + 1) = n + 2",
" n + 1 + 1 = n + 2",
" n + 1 β 0",
" I.ΞΉ.f 0 β« I.cocomplex.d 0 1 = 0"
] | [
" ExactAt I.cocomplex (n + 1)",
" QuasiIsoAt I.ΞΉ (n + 1)",
" (ComplexShape.up β).prev (n + 1) = n",
" (ComplexShape.up β).next (n + 1) = n + 2",
" n + 1 + 1 = n + 2",
" n + 1 β 0"
] |
import Mathlib.Analysis.SpecialFunctions.Exp
import Mathlib.Topology.ContinuousFunction.Basic
import Mathlib.Analysis.Normed.Field.UnitBall
#align_import analysis.complex.circle from "leanprover-community/mathlib"@"ad3dfaca9ea2465198bcf58aa114401c324e29d1"
noncomputable section
open Complex Metric
open ComplexC... | Mathlib/Analysis/Complex/Circle.lean | 66 | 66 | theorem normSq_eq_of_mem_circle (z : circle) : normSq z = 1 := by | simp [normSq_eq_abs]
| [
" z β circle β normSq z = 1",
" normSq βz = 1"
] | [
" z β circle β normSq z = 1"
] |
import Mathlib.Analysis.Normed.Field.Basic
#align_import analysis.normed_space.int from "leanprover-community/mathlib"@"5cc2dfdd3e92f340411acea4427d701dc7ed26f8"
namespace Int
theorem nnnorm_coe_units (e : β€Λ£) : β(e : β€)ββ = 1 := by
obtain rfl | rfl := units_eq_one_or e <;>
simp only [Units.coe_neg_one, Un... | Mathlib/Analysis/NormedSpace/Int.lean | 41 | 42 | theorem toNat_add_toNat_neg_eq_nnnorm (n : β€) : βn.toNat + β(-n).toNat = βnββ := by |
rw [β Nat.cast_add, toNat_add_toNat_neg_eq_natAbs, NNReal.natCast_natAbs]
| [
" ββeββ = 1",
" ββ1ββ = 1",
" ββ(-1)ββ = 1",
" ββeβ = 1",
" βn.toNat + β(-n).toNat = βnββ"
] | [
" ββeββ = 1",
" ββ1ββ = 1",
" ββ(-1)ββ = 1",
" ββeβ = 1"
] |
import Mathlib.Algebra.CharP.Invertible
import Mathlib.Algebra.Order.Interval.Set.Group
import Mathlib.Analysis.Convex.Segment
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.FieldSimp
#align_import analysis.convex.between from "leanprover-community/mathlib"@"571e13cacbed7bf042fd3058c... | Mathlib/Analysis/Convex/Between.lean | 67 | 74 | theorem affineSegment_same (x : P) : affineSegment R x x = {x} := by |
-- Porting note: added as this doesn't do anything in `simp_rw` any more
rw [affineSegment]
-- Note: when adding "simp made no progress" in lean4#2336,
-- had to change `lineMap_same` to `lineMap_same _`. Not sure why?
-- Porting note: added `_ _` and `Function.const`
simp_rw [lineMap_same _, AffineMap.coe... | [
" affineSegment R x y = segment R x y",
" affineSegment R x y = affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R y x",
" 1 - t β Set.Icc 0 1",
" (lineMap y x) (1 - t) = z",
" z β affineSegment R y x ... | [
" affineSegment R x y = segment R x y",
" affineSegment R x y = affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R y x",
" 1 - t β Set.Icc 0 1",
" (lineMap y x) (1 - t) = z",
" z β affineSegment R y x ... |
import Mathlib.Algebra.Group.Center
#align_import group_theory.subsemigroup.centralizer from "leanprover-community/mathlib"@"cc67cd75b4e54191e13c2e8d722289a89e67e4fa"
variable {M : Type*} {S T : Set M}
namespace Set
variable (S)
@[to_additive addCentralizer " The centralizer of a subset of an additive magma. ... | Mathlib/Algebra/Group/Centralizer.lean | 64 | 65 | theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) β centralizer S := by |
simp [mem_centralizer_iff]
| [
" 1 β S.centralizer",
" 0 β S.centralizer"
] | [
" 1 β S.centralizer"
] |
import Mathlib.FieldTheory.RatFunc.Defs
import Mathlib.RingTheory.EuclideanDomain
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Polynomial.Content
#align_import field_theory.ratfunc from "leanprover-community/mathlib"@"bf9bbbcf0c1c1ead18280b0d010e417b10abb1b6"
universe u v
noncompu... | Mathlib/FieldTheory/RatFunc/Basic.lean | 89 | 91 | theorem ofFractionRing_add (p q : FractionRing K[X]) :
ofFractionRing (p + q) = ofFractionRing p + ofFractionRing q := by |
simp only [HAdd.hAdd, Add.add, RatFunc.add]
| [
" { toFractionRing := 0 } = 0",
" { toFractionRing := p + q } = { toFractionRing := p } + { toFractionRing := q }"
] | [
" { toFractionRing := 0 } = 0"
] |
import Mathlib.Analysis.BoxIntegral.Partition.Basic
#align_import analysis.box_integral.partition.split from "leanprover-community/mathlib"@"6ca1a09bc9aa75824bf97388c9e3b441fc4ccf3f"
noncomputable section
open scoped Classical
open Filter
open Function Set Filter
namespace BoxIntegral
variable {ΞΉ M : Type*} {... | Mathlib/Analysis/BoxIntegral/Partition/Split.lean | 130 | 136 | theorem splitUpper_def [DecidableEq ΞΉ] {i x} (h : x β Ioo (I.lower i) (I.upper i))
(h' : β j, update I.lower i x j < I.upper j :=
(forall_update_iff I.lower fun j y => y < I.upper j).2
β¨h.2, fun j _ => I.lower_lt_upper _β©) :
I.splitUpper i x = (β¨update I.lower i x, I.upper, h'β© : Box ΞΉ) := by |
simp (config := { unfoldPartialApp := true }) only [splitUpper, mk'_eq_coe, max_eq_left h.1.le,
update, and_self]
| [
" β(I.splitLower i x) = βI β© {y | y i β€ x}",
" (univ.pi fun i_1 => Ioc (I.lower i_1) (update I.upper i (min x (I.upper i)) i_1)) = βI β© {y | y i β€ x}",
" (y β univ.pi fun i_1 => Ioc (I.lower i_1) (update I.upper i (min x (I.upper i)) i_1)) β y β βI β© {y | y i β€ x}",
" ((β (x : ΞΉ), I.lower x < y x) β§ y i β€ x β§... | [
" β(I.splitLower i x) = βI β© {y | y i β€ x}",
" (univ.pi fun i_1 => Ioc (I.lower i_1) (update I.upper i (min x (I.upper i)) i_1)) = βI β© {y | y i β€ x}",
" (y β univ.pi fun i_1 => Ioc (I.lower i_1) (update I.upper i (min x (I.upper i)) i_1)) β y β βI β© {y | y i β€ x}",
" ((β (x : ΞΉ), I.lower x < y x) β§ y i β€ x β§... |
import Mathlib.Order.ConditionallyCompleteLattice.Finset
import Mathlib.Order.Interval.Finset.Nat
#align_import data.nat.lattice from "leanprover-community/mathlib"@"52fa514ec337dd970d71d8de8d0fd68b455a1e54"
assert_not_exists MonoidWithZero
open Set
namespace Nat
open scoped Classical
noncomputable instance : ... | Mathlib/Data/Nat/Lattice.lean | 75 | 77 | theorem sInf_mem {s : Set β} (h : s.Nonempty) : sInf s β s := by |
rw [Nat.sInf_def h]
exact Nat.find_spec h
| [
" sInf s = 0 β 0 β s β¨ s = β
",
" sInf β
= 0 β 0 β β
β¨ β
= β
",
" sInf β
= 0",
" 0 β β
β¨ β
= β
",
" β
= β
",
" iInf f = 0",
" β¨
i, 0 = 0",
" (0 β range fun i => 0) β¨ (range fun i => 0) = β
",
" sInf s β s",
" Nat.find h β s"
] | [
" sInf s = 0 β 0 β s β¨ s = β
",
" sInf β
= 0 β 0 β β
β¨ β
= β
",
" sInf β
= 0",
" 0 β β
β¨ β
= β
",
" β
= β
",
" iInf f = 0",
" β¨
i, 0 = 0",
" (0 β range fun i => 0) β¨ (range fun i => 0) = β
"
] |
import Mathlib.Analysis.MeanInequalities
import Mathlib.Analysis.NormedSpace.WithLp
open Real Set Filter RCLike Bornology Uniformity Topology NNReal ENNReal
noncomputable section
variable (p : ββ₯0β) (π Ξ± Ξ² : Type*)
namespace WithLp
section DistNorm
section Dist
variable [Dist Ξ±] [Dist Ξ²]
open scoped C... | Mathlib/Analysis/NormedSpace/ProdLp.lean | 231 | 233 | theorem prod_dist_eq_card (f g : WithLp 0 (Ξ± Γ Ξ²)) : dist f g =
(if dist f.fst g.fst = 0 then 0 else 1) + (if dist f.snd g.snd = 0 then 0 else 1) := by |
convert if_pos rfl
| [
" dist f g = (if dist f.1 g.1 = 0 then 0 else 1) + if dist f.2 g.2 = 0 then 0 else 1"
] | [] |
import Mathlib.MeasureTheory.SetSemiring
open MeasurableSpace Set
namespace MeasureTheory
variable {Ξ± : Type*} {π : Set (Set Ξ±)} {s t : Set Ξ±}
structure IsSetAlgebra (π : Set (Set Ξ±)) : Prop where
empty_mem : β
β π
compl_mem : β β¦sβ¦, s β π β sαΆ β π
union_mem : β β¦s tβ¦, s β π β t β π β s βͺ t β π
... | Mathlib/MeasureTheory/SetAlgebra.lean | 151 | 158 | theorem generateSetAlgebra_subset {β¬ : Set (Set Ξ±)} (h : π β β¬)
(hβ¬ : IsSetAlgebra β¬) : generateSetAlgebra π β β¬ := by |
intro s hs
induction hs with
| base t t_mem => exact h t_mem
| empty => exact hβ¬.empty_mem
| compl t _ t_mem => exact hβ¬.compl_mem t_mem
| union t u _ _ t_mem u_mem => exact hβ¬.union_mem t_mem u_mem
| [
" generateFrom (generateSetAlgebra π) = generateFrom π",
" MeasurableSet s",
" MeasurableSet t",
" MeasurableSet u",
" MeasurableSet β
",
" MeasurableSet uαΆ",
" MeasurableSet (u βͺ v)",
" generateSetAlgebra π β generateSetAlgebra β¬",
" s β generateSetAlgebra β¬",
" t β generateSetAlgebra β¬",
" β
... | [
" generateFrom (generateSetAlgebra π) = generateFrom π",
" MeasurableSet s",
" MeasurableSet t",
" MeasurableSet u",
" MeasurableSet β
",
" MeasurableSet uαΆ",
" MeasurableSet (u βͺ v)",
" generateSetAlgebra π β generateSetAlgebra β¬",
" s β generateSetAlgebra β¬",
" t β generateSetAlgebra β¬",
" β
... |
import Mathlib.Algebra.Polynomial.Degree.Lemmas
open Polynomial
namespace Mathlib.Tactic.ComputeDegree
section recursion_lemmas
variable {R : Type*}
section semiring
variable [Semiring R]
theorem natDegree_C_le (a : R) : natDegree (C a) β€ 0 := (natDegree_C a).le
theorem natDegree_natCast_le (n : β) : natDeg... | Mathlib/Tactic/ComputeDegree.lean | 117 | 126 | theorem coeff_pow_of_natDegree_le_of_eq_ite' {m n o : β} {a : R} {p : R[X]}
(h_pow : natDegree p β€ n) (h_exp : m * n β€ o) (h_pow_bas : coeff p n = a) :
coeff (p ^ m) o = if o = m * n then a ^ m else 0 := by |
split_ifs with h
Β· subst h h_pow_bas
exact coeff_pow_of_natDegree_le βΉ_βΊ
Β· apply coeff_eq_zero_of_natDegree_lt
apply lt_of_le_of_lt ?_ (lt_of_le_of_ne βΉ_βΊ ?_)
Β· exact natDegree_pow_le_of_le m βΉ_βΊ
Β· exact Iff.mp ne_comm h
| [
" (f + g).coeff n = a + b",
" (f + g).coeff n = f.coeff n + g.coeff n",
" (f * g).coeff d = if d = df + dg then a * b else 0",
" (f * g).coeff d = a * b",
" (f * g).coeff (df + dg) = f.coeff df * g.coeff dg",
" (f * g).coeff d = 0",
" (f * g).natDegree < d",
" (f * g).natDegree β€ df + dg",
" df + dg... | [
" (f + g).coeff n = a + b",
" (f + g).coeff n = f.coeff n + g.coeff n",
" (f * g).coeff d = if d = df + dg then a * b else 0",
" (f * g).coeff d = a * b",
" (f * g).coeff (df + dg) = f.coeff df * g.coeff dg",
" (f * g).coeff d = 0",
" (f * g).natDegree < d",
" (f * g).natDegree β€ df + dg",
" df + dg... |
import Mathlib.Algebra.Group.Aut
import Mathlib.Algebra.Group.Invertible.Basic
import Mathlib.Algebra.GroupWithZero.Units.Basic
import Mathlib.GroupTheory.GroupAction.Units
#align_import group_theory.group_action.group from "leanprover-community/mathlib"@"3b52265189f3fb43aa631edffce5d060fafaf82f"
universe u v w
... | Mathlib/GroupTheory/GroupAction/Group.lean | 35 | 36 | theorem smul_inv_smul (c : Ξ±) (x : Ξ²) : c β’ cβ»ΒΉ β’ x = x := by |
rw [smul_smul, mul_right_inv, one_smul]
| [
" cβ»ΒΉ β’ c β’ x = x",
" c β’ cβ»ΒΉ β’ x = x"
] | [
" cβ»ΒΉ β’ c β’ x = x"
] |
import Mathlib.RingTheory.Ideal.Cotangent
import Mathlib.RingTheory.QuotientNilpotent
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.RingTheory.FinitePresentation
import Mathlib.RingTheory.Localization.Away.Basic
import Mathlib.RingTheory.Localization.Away.AdjoinRoot
#align_import ring_theory.etale from ... | Mathlib/RingTheory/Smooth/Basic.lean | 148 | 153 | theorem of_equiv [FormallySmooth R A] (e : A ββ[R] B) : FormallySmooth R B := by |
constructor
intro C _ _ I hI f
use (FormallySmooth.lift I β¨2, hIβ© (f.comp e : A ββ[R] C β§Έ I)).comp e.symm
rw [β AlgHom.comp_assoc, FormallySmooth.comp_lift, AlgHom.comp_assoc, AlgEquiv.comp_symm,
AlgHom.comp_id]
| [
" β f, (Ideal.Quotient.mkβ R I).comp f = g",
" β (g : A ββ[R] B β§Έ I), β f, (Ideal.Quotient.mkβ R I).comp f = g",
" Function.Surjective (Ideal.Quotient.mkβ R I).comp",
" β [_RB : Algebra R B], Function.Surjective (Ideal.Quotient.mkβ R I).comp",
" β β¦S : Type uβ¦ [inst : CommRing S] (I : Ideal S),\n I ^ 2 =... | [
" β f, (Ideal.Quotient.mkβ R I).comp f = g",
" β (g : A ββ[R] B β§Έ I), β f, (Ideal.Quotient.mkβ R I).comp f = g",
" Function.Surjective (Ideal.Quotient.mkβ R I).comp",
" β [_RB : Algebra R B], Function.Surjective (Ideal.Quotient.mkβ R I).comp",
" β β¦S : Type uβ¦ [inst : CommRing S] (I : Ideal S),\n I ^ 2 =... |
import Mathlib.Topology.MetricSpace.PseudoMetric
#align_import topology.metric_space.basic from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"
open Set Filter Bornology
open scoped NNReal Uniformity
universe u v w
variable {Ξ± : Type u} {Ξ² : Type v} {X ΞΉ : Type*}
variable [PseudoMetricS... | Mathlib/Topology/MetricSpace/Basic.lean | 74 | 74 | theorem zero_eq_dist {x y : Ξ³} : 0 = dist x y β x = y := by | rw [eq_comm, dist_eq_zero]
| [
" m = m'",
" mk eq_of_dist_eq_zeroβ = m'",
" mk eq_of_dist_eq_zeroβΒΉ = mk eq_of_dist_eq_zeroβ",
" toPseudoMetricSpaceβΒΉ = toPseudoMetricSpaceβ",
" PseudoMetricSpace.toDist = PseudoMetricSpace.toDist",
" 0 = dist x y β x = y"
] | [
" m = m'",
" mk eq_of_dist_eq_zeroβ = m'",
" mk eq_of_dist_eq_zeroβΒΉ = mk eq_of_dist_eq_zeroβ",
" toPseudoMetricSpaceβΒΉ = toPseudoMetricSpaceβ",
" PseudoMetricSpace.toDist = PseudoMetricSpace.toDist"
] |
import Mathlib.Analysis.RCLike.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.Basic
import Mathlib.Analysis.NormedSpace.Pointwise
#align_import analysis.normed_space.is_R_or_C from "leanprover-community/mathlib"@"3f655f5297b030a87d641ad4e825af8d9679eb0b"
open Metric
variable {π : Type*} [RCLike π] {E :... | Mathlib/Analysis/NormedSpace/RCLike.lean | 36 | 36 | theorem RCLike.norm_coe_norm {z : E} : β(βzβ : π)β = βzβ := by | simp
| [
" βββzββ = βzβ"
] | [] |
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Finset.Sum
import Mathlib.Logic.Embedding.Set
#align_import data.fintype.sum from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"
universe u v
variable {Ξ± Ξ² : Type*}
open Finset
instance (Ξ± : Type u) (Ξ² : Type v) [Fintype Ξ±] [Fintyp... | Mathlib/Data/Fintype/Sum.lean | 47 | 57 | theorem image_subtype_ne_univ_eq_image_erase [Fintype Ξ±] [DecidableEq Ξ²] (k : Ξ²) (b : Ξ± β Ξ²) :
image (fun i : { a // b a β k } => b βi) univ = (image b univ).erase k := by |
apply subset_antisymm
Β· rw [image_subset_iff]
intro i _
apply mem_erase_of_ne_of_mem i.2 (mem_image_of_mem _ (mem_univ _))
Β· intro i hi
rw [mem_image]
rcases mem_image.1 (erase_subset _ _ hi) with β¨a, _, haβ©
subst ha
exact β¨β¨a, ne_of_mem_erase hiβ©, mem_univ _, rflβ©
| [
" β (x : Ξ± β Ξ²), x β univ.disjSum univ",
" Sum.inl valβ β univ.disjSum univ",
" Sum.inr valβ β univ.disjSum univ",
" Function.Bijective (Sum.elim Subtype.val Subtype.val)",
" image (fun i => b βi) univ = (image b univ).erase k",
" image (fun i => b βi) univ β (image b univ).erase k",
" β x β univ, b βx ... | [
" β (x : Ξ± β Ξ²), x β univ.disjSum univ",
" Sum.inl valβ β univ.disjSum univ",
" Sum.inr valβ β univ.disjSum univ",
" Function.Bijective (Sum.elim Subtype.val Subtype.val)"
] |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q... | Mathlib/Data/ENNReal/Operations.lean | 255 | 258 | theorem mul_self_lt_top_iff {a : ββ₯0β} : a * a < β€ β a < β€ := by |
rw [ENNReal.mul_lt_top_iff, and_self, or_self, or_iff_left_iff_imp]
rintro rfl
exact zero_lt_top
| [
" (rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal",
" (βrβ + rβ).toNNReal = (βrβ).toNNReal + rβ.toNNReal",
" (βrβ + βrβ).toNNReal = (βrβ).toNNReal + (βrβ).toNNReal",
" Β¬x < β€ β x = β€",
" a + b β β€ β a β β€ β§ b β β€",
" a * β€ = if a = 0 then 0 else β€",
" β€ * a = if a = 0 then 0 else β€",
" β€ ^ (m + 1) = β€"... | [
" (rβ + rβ).toNNReal = rβ.toNNReal + rβ.toNNReal",
" (βrβ + rβ).toNNReal = (βrβ).toNNReal + rβ.toNNReal",
" (βrβ + βrβ).toNNReal = (βrβ).toNNReal + (βrβ).toNNReal",
" Β¬x < β€ β x = β€",
" a + b β β€ β a β β€ β§ b β β€",
" a * β€ = if a = 0 then 0 else β€",
" β€ * a = if a = 0 then 0 else β€",
" β€ ^ (m + 1) = β€"... |
import Mathlib.Algebra.Module.DedekindDomain
import Mathlib.LinearAlgebra.FreeModule.PID
import Mathlib.Algebra.Module.Projective
import Mathlib.Algebra.Category.ModuleCat.Biproducts
import Mathlib.RingTheory.SimpleModule
#align_import algebra.module.pid from "leanprover-community/mathlib"@"cdc34484a07418af43daf8198b... | Mathlib/Algebra/Module/PID.lean | 124 | 148 | theorem p_pow_smul_lift {x y : M} {k : β} (hM' : Module.IsTorsionBy R M (p ^ pOrder hM y))
(h : p ^ k β’ x β R β y) : β a : R, p ^ k β’ x = p ^ k β’ a β’ y := by |
-- Porting note: needed to make `smul_smul` work below.
letI : MulAction R M := MulActionWithZero.toMulAction
by_cases hk : k β€ pOrder hM y
Β· let f :=
((R β p ^ (pOrder hM y - k) * p ^ k).quotEquivOfEq _ ?_).trans
(quotTorsionOfEquivSpanSingleton R M y)
Β· have : f.symm β¨p ^ k β’ x, hβ© β
... | [
" DirectSum.IsInternal fun p => torsionBy R M (IsPrincipal.generator βp ^ Multiset.count (βp) (factors β€.annihilator))",
" torsionBy R M (IsPrincipal.generator βxβ ^ Multiset.count (βxβ) (factors β€.annihilator)) =\n torsionBySet R M β(βxβ ^ Multiset.count (βxβ) (factors β€.annihilator))",
" p β torsionBy R M ... | [
" DirectSum.IsInternal fun p => torsionBy R M (IsPrincipal.generator βp ^ Multiset.count (βp) (factors β€.annihilator))",
" torsionBy R M (IsPrincipal.generator βxβ ^ Multiset.count (βxβ) (factors β€.annihilator)) =\n torsionBySet R M β(βxβ ^ Multiset.count (βxβ) (factors β€.annihilator))",
" p β torsionBy R M ... |
import Mathlib.Topology.Homotopy.Path
import Mathlib.Topology.Homotopy.Equiv
#align_import topology.homotopy.contractible from "leanprover-community/mathlib"@"16728b3064a1751103e1dc2815ed8d00560e0d87"
noncomputable section
namespace ContinuousMap
variable {X Y Z : Type*} [TopologicalSpace X] [TopologicalSpace Y]... | Mathlib/Topology/Homotopy/Contractible.lean | 39 | 43 | theorem Nullhomotopic.comp_left {f : C(Y, Z)} (hf : f.Nullhomotopic) (g : C(X, Y)) :
(f.comp g).Nullhomotopic := by |
cases' hf with y hy
use y
exact Homotopic.hcomp (Homotopic.refl g) hy
| [
" (const X y).Homotopic (const X y)",
" (g.comp f).Nullhomotopic",
" (g.comp f).Homotopic (const X (g y))",
" (f.comp g).Nullhomotopic",
" (f.comp g).Homotopic (const X y)"
] | [
" (const X y).Homotopic (const X y)",
" (g.comp f).Nullhomotopic",
" (g.comp f).Homotopic (const X (g y))"
] |
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Algebra.Order.Group.Int
import Mathlib.Algebra.Order.Ring.Nat
import Mathlib.Algebra.Ring.Rat
import Mathlib.Data.PNat.Defs
#align_import data.rat.lemmas from "leanprover-community/mathlib"@"550b58538991c8977703fdeb7c9d51a5aa27df11"
namespace Rat
o... | Mathlib/Data/Rat/Lemmas.lean | 33 | 38 | theorem den_dvd (a b : β€) : ((a /. b).den : β€) β£ b := by |
by_cases b0 : b = 0; Β· simp [b0]
cases' e : a /. b with n d h c
rw [mk'_eq_divInt, divInt_eq_iff b0 (ne_of_gt (Int.natCast_pos.2 (Nat.pos_of_ne_zero h)))] at e
refine Int.dvd_natAbs.1 <| Int.natCast_dvd_natCast.2 <| c.symm.dvd_of_dvd_mul_left ?_
rw [β Int.natAbs_mul, β Int.natCast_dvd_natCast, Int.dvd_natAbs... | [
" (a /. b).num β£ a",
" { num := n, den := d, den_nz := h, reduced := c }.num β£ a",
" n.natAbs β£ a.natAbs * d",
" β(a /. b).den β£ b",
" β{ num := n, den := d, den_nz := h, reduced := c }.den β£ b",
" d β£ n.natAbs * b.natAbs",
" βd β£ a * βd"
] | [
" (a /. b).num β£ a",
" { num := n, den := d, den_nz := h, reduced := c }.num β£ a",
" n.natAbs β£ a.natAbs * d"
] |
import Mathlib.Algebra.MvPolynomial.PDeriv
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Derivative
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.RingTheory.Polynomial.Pochhammer
#align_import ring_theory.polynomial.bernstein from "le... | Mathlib/RingTheory/Polynomial/Bernstein.lean | 146 | 161 | theorem iterate_derivative_at_0_eq_zero_of_lt (n : β) {Ξ½ k : β} :
k < Ξ½ β (Polynomial.derivative^[k] (bernsteinPolynomial R n Ξ½)).eval 0 = 0 := by |
cases' Ξ½ with Ξ½
Β· rintro β¨β©
Β· rw [Nat.lt_succ_iff]
induction' k with k ih generalizing n Ξ½
Β· simp [eval_at_0]
Β· simp only [derivative_succ, Int.natCast_eq_zero, mul_eq_zero, Function.comp_apply,
Function.iterate_succ, Polynomial.iterate_derivative_sub,
Polynomial.iterate_derivative_na... | [
" bernsteinPolynomial β€ 3 2 = 3 * X ^ 2 - 3 * X ^ 3",
" 3 * X ^ 2 * (1 - X) = 3 * X ^ 2 - 3 * X ^ 3",
" bernsteinPolynomial R n Ξ½ = 0",
" Polynomial.map f (bernsteinPolynomial R n Ξ½) = bernsteinPolynomial S n Ξ½",
" (bernsteinPolynomial R n Ξ½).comp (1 - X) = bernsteinPolynomial R n (n - Ξ½)",
" bernsteinPol... | [
" bernsteinPolynomial β€ 3 2 = 3 * X ^ 2 - 3 * X ^ 3",
" 3 * X ^ 2 * (1 - X) = 3 * X ^ 2 - 3 * X ^ 3",
" bernsteinPolynomial R n Ξ½ = 0",
" Polynomial.map f (bernsteinPolynomial R n Ξ½) = bernsteinPolynomial S n Ξ½",
" (bernsteinPolynomial R n Ξ½).comp (1 - X) = bernsteinPolynomial R n (n - Ξ½)",
" bernsteinPol... |
import Mathlib.Topology.Sets.Opens
#align_import topology.local_at_target from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open TopologicalSpace Set Filter
open Topology Filter
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [TopologicalSpace Ξ²] {f : Ξ± β Ξ²}
variable {s : Set Ξ²} {ΞΉ : Ty... | Mathlib/Topology/LocalAtTarget.lean | 116 | 126 | theorem isClosedMap_iff_isClosedMap_of_iSup_eq_top :
IsClosedMap f β β i, IsClosedMap ((U i).1.restrictPreimage f) := by |
refine β¨fun h i => h.restrictPreimage _, ?_β©
rintro H s hs
rw [isClosed_iff_coe_preimage_of_iSup_eq_top hU]
intro i
convert H i _ β¨β¨_, hs.1, eq_compl_comm.mpr rflβ©β©
ext β¨x, hxβ©
suffices (β y, y β s β§ f y = x) β β y, y β s β§ f y β U i β§ f y = x by
simpa [Set.restrictPreimage, β Subtype.coe_inj]
exac... | [
" Inducing (s.restrictPreimage f)",
" β (x : β(f β»ΒΉ' s)), π x = comap Subtype.val (comap f (π (f βx)))",
" π a = comap Subtype.val (comap f (π (f βa)))",
" IsClosedMap (s.restrictPreimage f)",
" IsClosed t β IsClosed (s.restrictPreimage f '' t)",
" β (u : Set Ξ±), IsClosed u β Subtype.val β»ΒΉ' u = t β β... | [
" Inducing (s.restrictPreimage f)",
" β (x : β(f β»ΒΉ' s)), π x = comap Subtype.val (comap f (π (f βx)))",
" π a = comap Subtype.val (comap f (π (f βa)))",
" IsClosedMap (s.restrictPreimage f)",
" IsClosed t β IsClosed (s.restrictPreimage f '' t)",
" β (u : Set Ξ±), IsClosed u β Subtype.val β»ΒΉ' u = t β β... |
import Mathlib.Algebra.Group.Commutator
import Mathlib.Algebra.Group.Subgroup.Finite
import Mathlib.Data.Bracket
import Mathlib.GroupTheory.Subgroup.Centralizer
import Mathlib.Tactic.Group
#align_import group_theory.commutator from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"
variable... | Mathlib/GroupTheory/Commutator.lean | 108 | 116 | theorem commutator_commutator_eq_bot_of_rotate (h1 : β
β
Hβ, Hββ, Hββ = β₯) (h2 : β
β
Hβ, Hββ, Hββ = β₯) :
β
β
Hβ, Hββ, Hββ = β₯ := by |
simp_rw [commutator_eq_bot_iff_le_centralizer, commutator_le,
mem_centralizer_iff_commutator_eq_one, β commutatorElement_def] at h1 h2 β’
intro x hx y hy z hz
trans x * z * β
y, β
zβ»ΒΉ, xβ»ΒΉβββ»ΒΉ * zβ»ΒΉ * y * β
xβ»ΒΉ, β
yβ»ΒΉ, zβββ»ΒΉ * yβ»ΒΉ * xβ»ΒΉ
Β· group
Β· rw [h1 _ (Hβ.inv_mem hy) _ hz _ (Hβ.inv_mem hx), h2 _ (Hβ.inv_m... | [
" β
gβ, gββ = 1 β gβ * gβ = gβ * gβ",
" β
gβ, gβββ»ΒΉ = β
gβ, gββ",
" f β
gβ, gββ = β
f gβ, f gββ",
" β
Hβ, Hββ = β₯ β Hβ β€ centralizer βHβ",
" (β gβ β Hβ, β gβ β Hβ, β
gβ, gββ β β₯) β Hβ β€ centralizer βHβ",
" β
p, qβ β β₯ β q * p = p * q",
" β
β
Hβ, Hββ, Hββ = β₯",
" β gβ β Hβ, β gβ β Hβ, β h β βHβ, β
h, β
gβ, gβββ = ... | [
" β
gβ, gββ = 1 β gβ * gβ = gβ * gβ",
" β
gβ, gβββ»ΒΉ = β
gβ, gββ",
" f β
gβ, gββ = β
f gβ, f gββ",
" β
Hβ, Hββ = β₯ β Hβ β€ centralizer βHβ",
" (β gβ β Hβ, β gβ β Hβ, β
gβ, gββ β β₯) β Hβ β€ centralizer βHβ",
" β
p, qβ β β₯ β q * p = p * q"
] |
import Mathlib.AlgebraicGeometry.AffineScheme
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.Topology.Sheaves.SheafCondition.Sites
import Mathlib.Algebra.Category.Ring.Constructions
import Mathlib.RingTheory.LocalProperties
#align_import algebraic_geometry.properties from "leanprover-community/mathlib"@"88... | Mathlib/AlgebraicGeometry/Properties.lean | 115 | 119 | theorem isReducedOfIsAffineIsReduced [IsAffine X] [h : _root_.IsReduced (X.presheaf.obj (op β€))] :
IsReduced X :=
haveI : IsReduced (Scheme.Spec.obj (op (Scheme.Ξ.obj (op X)))) := by |
rw [affine_isReduced_iff]; exact h
isReducedOfOpenImmersion X.isoSpec.hom
| [
" T0Space ββX.toPresheafedSpace",
" β s, x β s β§ IsOpen s β§ T0Space βs",
" QuasiSober ββX.toPresheafedSpace",
" β (s : β(Set.range fun x => Set.range β(X.affineCover.map x).val.base)), IsOpen βs",
" IsOpen ββ¨(fun x => Set.range β(X.affineCover.map x).val.base) i, β―β©",
" β (s : β(Set.range fun x => Set.ran... | [
" T0Space ββX.toPresheafedSpace",
" β s, x β s β§ IsOpen s β§ T0Space βs",
" QuasiSober ββX.toPresheafedSpace",
" β (s : β(Set.range fun x => Set.range β(X.affineCover.map x).val.base)), IsOpen βs",
" IsOpen ββ¨(fun x => Set.range β(X.affineCover.map x).val.base) i, β―β©",
" β (s : β(Set.range fun x => Set.ran... |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Algebra.Ring.Opposite
import Mathlib.Tactic.Abel
#align_import algebra.geom_sum fro... | Mathlib/Algebra/GeomSum.lean | 76 | 76 | theorem one_geom_sum (n : β) : β i β range n, (1 : Ξ±) ^ i = n := by | simp
| [
" β i β range (n + 1), x ^ i = x * β i β range n, x ^ i + 1",
" β i β range 1, x ^ i = 1",
" β i β range 2, x ^ i = x + 1",
" β i β range 0, 0 ^ i = if 0 = 0 then 0 else 1",
" β i β range 1, 0 ^ i = if 1 = 0 then 0 else 1",
" β i β range (n + 2), 0 ^ i = if n + 2 = 0 then 0 else 1",
" 0 ^ (n + 1) + β i ... | [
" β i β range (n + 1), x ^ i = x * β i β range n, x ^ i + 1",
" β i β range 1, x ^ i = 1",
" β i β range 2, x ^ i = x + 1",
" β i β range 0, 0 ^ i = if 0 = 0 then 0 else 1",
" β i β range 1, 0 ^ i = if 1 = 0 then 0 else 1",
" β i β range (n + 2), 0 ^ i = if n + 2 = 0 then 0 else 1",
" 0 ^ (n + 1) + β i ... |
import Aesop
import Mathlib.Algebra.Group.Defs
import Mathlib.Data.Nat.Defs
import Mathlib.Data.Int.Defs
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Cases
import Mathlib.Tactic.SimpRw
import Mathlib.Tactic.SplitIfs
#align_import algebra.group.basic from "leanprover-community/mathlib"@"a07d750983b94c530a... | Mathlib/Algebra/Group/Basic.lean | 146 | 148 | theorem ite_mul_one {P : Prop} [Decidable P] {a b : M} :
ite P (a * b) 1 = ite P a 1 * ite P b 1 := by |
by_cases h:P <;> simp [h]
| [
" (if P then a * b else 1) = (if P then a else 1) * if P then b else 1"
] | [] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Derivative
import Mathlib.Algebra.Polynomial.Module.AEval
import Mathlib.RingTheory.Derivation.Basic
noncomputable section
namespace Polynomial
section CommSemiring
variable {R A : Type*} [CommSemiring R]
@[simps]
def derivative' : D... | Mathlib/Algebra/Polynomial/Derivation.lean | 43 | 46 | theorem C_smul_derivation_apply (D : Derivation R R[X] A) (a : R) (f : R[X]) :
C a β’ D f = a β’ D f := by |
have : C a β’ D f = D (C a * f) := by simp
rw [this, C_mul', D.map_smul]
| [
" { toFun := βderivative, map_add' := β―, map_smul' := β― } (f * g) =\n f β’ { toFun := βderivative, map_add' := β―, map_smul' := β― } g +\n g β’ { toFun := βderivative, map_add' := β―, map_smul' := β― } f",
" C a β’ D f = a β’ D f",
" C a β’ D f = D (C a * f)"
] | [
" { toFun := βderivative, map_add' := β―, map_smul' := β― } (f * g) =\n f β’ { toFun := βderivative, map_add' := β―, map_smul' := β― } g +\n g β’ { toFun := βderivative, map_add' := β―, map_smul' := β― } f"
] |
import Mathlib.Order.UpperLower.Basic
import Mathlib.Data.Finset.Preimage
#align_import combinatorics.young.young_diagram from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
open Function
@[ext]
structure YoungDiagram where
cells : Finset (β Γ β)
isLowerSet : IsLowerSet (cel... | Mathlib/Combinatorics/Young/YoungDiagram.lean | 214 | 215 | theorem mem_transpose {ΞΌ : YoungDiagram} {c : β Γ β} : c β ΞΌ.transpose β c.swap β ΞΌ := by |
simp [transpose]
| [
" ΞΌ = Ξ½",
" xβΒΉ β β((Equiv.prodComm β β).finsetCongr ΞΌ.cells) β xβ β β((Equiv.prodComm β β).finsetCongr ΞΌ.cells)",
" (Equiv.prodComm β β).symm xβΒΉ β ΞΌ.cells β (Equiv.prodComm β β).symm xβ β ΞΌ.cells",
" (Equiv.prodComm β β).symm xβ β ΞΌ.cells",
" (Equiv.prodComm β β).symm xβ β€ (Equiv.prodComm β β).symm xβΒΉ",
... | [
" ΞΌ = Ξ½",
" xβΒΉ β β((Equiv.prodComm β β).finsetCongr ΞΌ.cells) β xβ β β((Equiv.prodComm β β).finsetCongr ΞΌ.cells)",
" (Equiv.prodComm β β).symm xβΒΉ β ΞΌ.cells β (Equiv.prodComm β β).symm xβ β ΞΌ.cells",
" (Equiv.prodComm β β).symm xβ β ΞΌ.cells",
" (Equiv.prodComm β β).symm xβ β€ (Equiv.prodComm β β).symm xβΒΉ"
] |
import Mathlib.CategoryTheory.GlueData
import Mathlib.Topology.Category.TopCat.Limits.Pullbacks
import Mathlib.Topology.Category.TopCat.Opens
import Mathlib.Tactic.Generalize
import Mathlib.CategoryTheory.Elementwise
#align_import topology.gluing from "leanprover-community/mathlib"@"178a32653e369dce2da68dc6b2694e385d... | Mathlib/Topology/Gluing.lean | 164 | 201 | theorem eqvGen_of_Ο_eq
-- Porting note: was `{x y : β D.U} (h : π£.Ο x = π£.Ο y)`
{x y : sigmaObj (Ξ² := D.toGlueData.J) (C := TopCat) D.toGlueData.U}
(h : π£.Ο x = π£.Ο y) :
EqvGen
-- Porting note: was (Types.CoequalizerRel π£.diagram.fstSigmaMap π£.diagram.sndSigmaMap)
(Types.CoequalizerRel... |
delta GlueData.Ο Multicoequalizer.sigmaΟ at h
-- Porting note: inlined `inferInstance` instead of leaving as a side goal.
replace h := (TopCat.mono_iff_injective (Multicoequalizer.isoCoequalizer π£.diagram).inv).mp
inferInstance h
let diagram := parallelPair π£.diagram.fstSigmaMap π£.diagram.sndSigmaMap β ... | [
" IsOpen U β β (i : D.J), IsOpen (β(D.ΞΉ i) β»ΒΉ' U)",
" IsOpen U β β (i : D.J), IsOpen (β(Multicoequalizer.Ο D.diagram i) β»ΒΉ' U)",
" IsOpen U β β (i : D.J), IsOpen (β(Sigma.ΞΉ D.diagram.right i β« Multicoequalizer.sigmaΟ D.diagram) β»ΒΉ' U)",
" IsOpen (β(homeoOfIso (Multicoequalizer.isoCoequalizer D.diagram).symm) ... | [
" IsOpen U β β (i : D.J), IsOpen (β(D.ΞΉ i) β»ΒΉ' U)",
" IsOpen U β β (i : D.J), IsOpen (β(Multicoequalizer.Ο D.diagram i) β»ΒΉ' U)",
" IsOpen U β β (i : D.J), IsOpen (β(Sigma.ΞΉ D.diagram.right i β« Multicoequalizer.sigmaΟ D.diagram) β»ΒΉ' U)",
" IsOpen (β(homeoOfIso (Multicoequalizer.isoCoequalizer D.diagram).symm) ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.