Datasets:
mathlib-initiative
/
mathlib-types

Dataset card Data Studio Files
xet
Community
1
name
stringlengths
2
347
module
stringlengths
6
90
type
stringlengths
1
5.42M
Set.encard_le_encard_diff_add_encard
Mathlib.Data.Set.Card
βˆ€ {Ξ± : Type u_1} (s t : Set Ξ±), s.encard ≀ (s \ t).encard + t.encard
UInt8.ofBitVec_ofFin
Init.Data.UInt.Lemmas
βˆ€ (n : Fin (2 ^ 8)), { toBitVec := { toFin := n } } = UInt8.ofFin n
LaurentPolynomial.smeval_T_pow
Mathlib.Algebra.Polynomial.Laurent
βˆ€ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid S] [inst_2 : MulActionWithZero R S] [inst_3 : Monoid S] (n : β„€) (x : SΛ£), (LaurentPolynomial.T n).smeval x = ↑(x ^ n)
Lean.Parser.Term.binop_lazy.parenthesizer
Lean.Parser.Term
Lean.PrettyPrinter.Parenthesizer
ProfiniteGrp.toLimit._proof_1
Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits
βˆ€ (P : ProfiniteGrp.{u_1}), CompactSpace ↑P.1.toTop
CategoryTheory.Limits.IsImage.ofIsoI._proof_2
Mathlib.CategoryTheory.Limits.Shapes.Images
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟢ Y} {F : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) {I' : C} (e : F.I β‰… I') (F'_1 : CategoryTheory.Limits.MonoFactorisation f), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp e.inv (hF.lift F'_1)) F'_1.m = CategoryTheory.CategoryStruct.comp e.inv F.m
Finset.sumLexLift_inl_inl
Mathlib.Data.Sum.Interval
βˆ€ {α₁ : Type u_1} {Ξ±β‚‚ : Type u_2} {β₁ : Type u_3} {Ξ²β‚‚ : Type u_4} {γ₁ : Type u_5} {Ξ³β‚‚ : Type u_6} (f₁ : α₁ β†’ β₁ β†’ Finset γ₁) (fβ‚‚ : Ξ±β‚‚ β†’ Ξ²β‚‚ β†’ Finset Ξ³β‚‚) (g₁ : α₁ β†’ Ξ²β‚‚ β†’ Finset γ₁) (gβ‚‚ : α₁ β†’ Ξ²β‚‚ β†’ Finset Ξ³β‚‚) (a : α₁) (b : β₁), Finset.sumLexLift f₁ fβ‚‚ g₁ gβ‚‚ (Sum.inl a) (Sum.inl b) = Finset.map Function.Embedding.inl (f₁ a b)
Lean.MetavarContext.addExprMVarDecl
Lean.MetavarContext
Lean.MetavarContext β†’ Lean.MVarId β†’ Lean.Name β†’ Lean.LocalContext β†’ Lean.LocalInstances β†’ Lean.Expr β†’ optParam Lean.MetavarKind Lean.MetavarKind.natural β†’ optParam β„• 0 β†’ Lean.MetavarContext
dualTensorHomEquivOfBasis._proof_3
Mathlib.LinearAlgebra.Contraction
βˆ€ {ΞΉ : Type u_4} {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [inst_5 : DecidableEq ΞΉ] [inst_6 : Fintype ΞΉ] (b : Module.Basis ΞΉ R M), (βˆ‘ i, (TensorProduct.mk R (Module.Dual R M) N) (b.dualBasis i) βˆ˜β‚— LinearMap.applyβ‚— (b i)) βˆ˜β‚— dualTensorHom R M N = LinearMap.id
Nat.sub_max_sub_left
Init.Data.Nat.Lemmas
βˆ€ (a b c : β„•), max (a - b) (a - c) = a - min b c
UInt64.toUInt8_eq
Init.Data.UInt.Lemmas
βˆ€ (a b : UInt64), a.toUInt8 = b.toUInt8 ↔ a % 256 = b % 256
Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq
Std.Data.DTreeMap.Internal.Lemmas
βˆ€ {Ξ± : Type u} {instOrd : Ord Ξ±} {Ξ² : Type v} {t : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²} [Std.TransOrd Ξ±] [inst : Inhabited Ξ±], t.WF β†’ βˆ€ {k : Ξ±} {f : Ξ² β†’ Ξ²}, compare (Std.DTreeMap.Internal.Impl.Const.modify k f t).maxKey! t.maxKey! = Ordering.eq
Mathlib.AssertNotExist.AssertExists.noConfusion
Mathlib.Util.AssertExistsExt
{P : Sort u} β†’ {t t' : Mathlib.AssertNotExist.AssertExists} β†’ t = t' β†’ Mathlib.AssertNotExist.AssertExists.noConfusionType P t t'
Cardinal.lift_inj._simp_1
Mathlib.SetTheory.Cardinal.Order
βˆ€ {a b : Cardinal.{u}}, (Cardinal.lift.{v, u} a = Cardinal.lift.{v, u} b) = (a = b)
Subtype.exists
Init.Data.Subtype.Basic
βˆ€ {Ξ± : Sort u} {p : Ξ± β†’ Prop} {q : { a // p a } β†’ Prop}, (βˆƒ x, q x) ↔ βˆƒ a, βˆƒ (b : p a), q ⟨a, b⟩
BoxIntegral.unitPartition.prepartition._proof_1
Mathlib.Analysis.BoxIntegral.UnitPartition
βˆ€ {ΞΉ : Type u_1} (n : β„•) [inst : NeZero n] [inst_1 : Fintype ΞΉ] (B x : BoxIntegral.Box ΞΉ), x ∈ Finset.image (fun Ξ½ => BoxIntegral.unitPartition.box n Ξ½) (BoxIntegral.unitPartition.admissibleIndex n B) β†’ x ≀ B
supClosure._proof_1
Mathlib.Order.SupClosed
βˆ€ {Ξ± : Type u_1} [inst : SemilatticeSup Ξ±] (s : Set Ξ±), βˆ€ a ∈ s, ↑{a} βŠ† s ∧ {a}.sup' β‹― id = a
DistribLattice.noConfusionType
Mathlib.Order.Lattice
Sort u β†’ {Ξ± : Type u_1} β†’ DistribLattice Ξ± β†’ {Ξ±' : Type u_1} β†’ DistribLattice Ξ±' β†’ Sort u
Real.tendsto_integral_gaussian_smul'
Mathlib.Analysis.Fourier.Inversion
βˆ€ {V : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MeasurableSpace V] [inst_3 : BorelSpace V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : NormedAddCommGroup E] [inst_6 : NormedSpace β„‚ E] {f : V β†’ E} [CompleteSpace E], MeasureTheory.Integrable f MeasureTheory.volume β†’ βˆ€ {v : V}, ContinuousAt f v β†’ Filter.Tendsto (fun c => ∫ (w : V), ((↑Real.pi * ↑c) ^ (↑(Module.finrank ℝ V) / 2) * Complex.exp (-↑Real.pi ^ 2 * ↑c * ↑‖v - wβ€– ^ 2)) β€’ f w) Filter.atTop (nhds (f v))
AffineBasis.instAddAction
Mathlib.LinearAlgebra.AffineSpace.Basis
{ΞΉ : Type u_1} β†’ {k : Type u_5} β†’ {V : Type u_6} β†’ {P : Type u_7} β†’ [inst : AddCommGroup V] β†’ [inst_1 : AddTorsor V P] β†’ [inst_2 : Ring k] β†’ [inst_3 : Module k V] β†’ AddAction V (AffineBasis ΞΉ k P)
Ideal.finsuppTotal
Mathlib.RingTheory.Ideal.Operations
(ΞΉ : Type u_1) β†’ (M : Type u_2) β†’ [inst : AddCommGroup M] β†’ {R : Type u_3} β†’ [inst_1 : CommRing R] β†’ [inst_2 : Module R M] β†’ (I : Ideal R) β†’ (ΞΉ β†’ M) β†’ (ΞΉ β†’β‚€ β†₯I) β†’β‚—[R] M
Lean.PersistentEnvExtensionDescrCore.ctorIdx
Lean.Environment
{Ξ± Ξ² Οƒ : Type} β†’ Lean.PersistentEnvExtensionDescrCore Ξ± Ξ² Οƒ β†’ β„•
Int64.toBitVec_ofIntTruncate
Init.Data.SInt.Lemmas
βˆ€ {n : β„€}, Int64.minValue.toInt ≀ n β†’ n ≀ Int64.maxValue.toInt β†’ (Int64.ofIntTruncate n).toBitVec = BitVec.ofInt 64 n
Std.Internal.List.getEntry?_filter
Std.Data.Internal.List.Associative
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} [inst : BEq Ξ±] [EquivBEq Ξ±] {f : (a : Ξ±) Γ— Ξ² a β†’ Bool} {l : List ((a : Ξ±) Γ— Ξ² a)} {k : Ξ±}, Std.Internal.List.DistinctKeys l β†’ Std.Internal.List.getEntry? k (List.filter f l) = Option.filter f (Std.Internal.List.getEntry? k l)
PerfectRing.comp_lift_apply
Mathlib.FieldTheory.IsPerfectClosure
βˆ€ {K : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing K] [inst_1 : CommRing L] [inst_2 : CommRing M] (i : K β†’+* L) (f : L β†’+* M) (p : β„•) [inst_3 : ExpChar M p] [inst_4 : ExpChar K p] [inst_5 : PerfectRing M p] [inst_6 : IsPRadical i p] [inst_7 : ExpChar L p] (x : L), (PerfectRing.lift i (f.comp i) p) x = f x
WeierstrassCurve.Projective.dblXYZ_Y
Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula
βˆ€ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (P : Fin 3 β†’ R), W'.dblXYZ P 1 = W'.dblY P
Set.Nonempty.star
Mathlib.Algebra.Star.Pointwise
βˆ€ {Ξ± : Type u_1} [inst : InvolutiveStar Ξ±] {s : Set Ξ±}, s.Nonempty β†’ (star s).Nonempty
Lean.DefinitionVal.mk.sizeOf_spec
Lean.Declaration
βˆ€ (toConstantVal : Lean.ConstantVal) (value : Lean.Expr) (hints : Lean.ReducibilityHints) (safety : Lean.DefinitionSafety) (all : List Lean.Name), sizeOf { toConstantVal := toConstantVal, value := value, hints := hints, safety := safety, all := all } = 1 + sizeOf toConstantVal + sizeOf value + sizeOf hints + sizeOf safety + sizeOf all
Lean.Grind.CommRing.SPolResult.casesOn
Lean.Meta.Tactic.Grind.Arith.CommRing.Poly
{motive : Lean.Grind.CommRing.SPolResult β†’ Sort u} β†’ (t : Lean.Grind.CommRing.SPolResult) β†’ ((spol : Lean.Grind.CommRing.Poly) β†’ (k₁ : β„€) β†’ (m₁ : Lean.Grind.CommRing.Mon) β†’ (kβ‚‚ : β„€) β†’ (mβ‚‚ : Lean.Grind.CommRing.Mon) β†’ motive { spol := spol, k₁ := k₁, m₁ := m₁, kβ‚‚ := kβ‚‚, mβ‚‚ := mβ‚‚ }) β†’ motive t
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.Const.minEntry?.match_1.splitter
Std.Data.DTreeMap.Internal.Model
{Ξ± : Type u_1} β†’ {Ξ² : Type u_2} β†’ (motive : (Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β†’ Sort u_3) β†’ (x : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β†’ (Unit β†’ motive Std.DTreeMap.Internal.Impl.leaf) β†’ ((size : β„•) β†’ (k : Ξ±) β†’ (v : Ξ²) β†’ (r : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β†’ motive (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r)) β†’ ((size : β„•) β†’ (k : Ξ±) β†’ (v : Ξ²) β†’ (size_1 : β„•) β†’ (k_1 : Ξ±) β†’ (v_1 : Ξ²) β†’ (l r r_1 : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β†’ motive (Std.DTreeMap.Internal.Impl.inner size k v (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l r) r_1)) β†’ motive x
Set.Nontrivial.eq_1
Mathlib.Data.Set.Subsingleton
βˆ€ {Ξ± : Type u} (s : Set Ξ±), s.Nontrivial = βˆƒ x ∈ s, βˆƒ y ∈ s, x β‰  y
_private.Mathlib.CategoryTheory.Preadditive.OfBiproducts.0.CategoryTheory.SemiadditiveOfBinaryBiproducts.Β«term_+α΅£_Β»
Mathlib.CategoryTheory.Preadditive.OfBiproducts
Lean.TrailingParserDescr
Matroid.map_isLoop_iff
Mathlib.Combinatorics.Matroid.Loop
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {M : Matroid Ξ±} {e : Ξ±} {f : Ξ± β†’ Ξ²} {hf : Set.InjOn f M.E}, autoParam (e ∈ M.E) Matroid.map_isLoop_iff._auto_1 β†’ ((M.map f hf).IsLoop (f e) ↔ M.IsLoop e)
PiLp.nnnorm_ofLp
Mathlib.Analysis.Normed.Lp.PiLp
βˆ€ {ΞΉ : Type u_2} {Ξ² : ΞΉ β†’ Type u_4} [inst : Fintype ΞΉ] [inst_1 : (i : ΞΉ) β†’ SeminormedAddCommGroup (Ξ² i)] (f : PiLp ⊀ Ξ²), β€–f.ofLpβ€–β‚Š = β€–fβ€–β‚Š
Valued.toNormedField.norm_le_iff
Mathlib.Topology.Algebra.Valued.NormedValued
βˆ€ {L : Type u_1} [inst : Field L] {Ξ“β‚€ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Ξ“β‚€] [val : Valued L Ξ“β‚€] [hv : Valued.v.RankOne] {x x' : L}, β€–xβ€– ≀ β€–x'β€– ↔ Valued.v x ≀ Valued.v x'
Matrix.Β«_aux_Mathlib_Data_Matrix_Mul___macroRules_Matrix_term_α΅₯*__1Β»
Mathlib.Data.Matrix.Mul
Lean.Macro
Topology._aux_Mathlib_Topology_Defs_Basic___macroRules_Topology_Continuous_of_1
Mathlib.Topology.Defs.Basic
Lean.Macro
FirstOrder.Ring.compatibleRingOfRingStructure._proof_6
Mathlib.ModelTheory.Algebra.Ring.Basic
βˆ€ (R : Type u_1) [inst : FirstOrder.Language.ring.Structure R] (x : Fin 0 β†’ R), FirstOrder.Language.Structure.funMap FirstOrder.Ring.zeroFunc x = 0
CategoryTheory.Functor.natTransEquiv_symm_apply_app
Mathlib.CategoryTheory.Functor.FunctorHom
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D] {F G : CategoryTheory.Functor C D} (f : F ⟢ G) (x : C) (x_1 : (CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor C (Type (max v' v u)))).obj x), (CategoryTheory.Functor.natTransEquiv.symm f).app x x_1 = CategoryTheory.Functor.HomObj.ofNatTrans f
Std.DTreeMap.Raw.Const.getEntryGED
Std.Data.DTreeMap.Raw.Basic
{Ξ± : Type u} β†’ {cmp : Ξ± β†’ Ξ± β†’ Ordering} β†’ {Ξ² : Type v} β†’ Std.DTreeMap.Raw Ξ± (fun x => Ξ²) cmp β†’ Ξ± β†’ Ξ± Γ— Ξ² β†’ Ξ± Γ— Ξ²
CategoryTheory.Limits.preservesBinaryBiproducts_of_preservesBinaryProducts
Mathlib.CategoryTheory.Preadditive.Biproducts
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] [CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F], CategoryTheory.Limits.PreservesBinaryBiproducts F
Lean.Lsp.DiagnosticSeverity.warning
Lean.Data.Lsp.Diagnostics
Lean.Lsp.DiagnosticSeverity
AlgCat.instIsRightAdjointForget
Mathlib.Algebra.Category.AlgCat.Basic
βˆ€ (R : Type u) [inst : CommRing R], (CategoryTheory.forget (AlgCat R)).IsRightAdjoint
RootPairing.pairing_reflection_perm
Mathlib.LinearAlgebra.RootSystem.Defs
βˆ€ {ΞΉ : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ΞΉ R M N) (i j k : ΞΉ), P.pairing j ((P.reflectionPerm i) k) = P.pairing ((P.reflectionPerm i) j) k
ContinuousAlternatingMap.add_apply
Mathlib.Topology.Algebra.Module.Alternating.Basic
βˆ€ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ΞΉ : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N] [inst_6 : TopologicalSpace N] (f g : M [β‹€^ΞΉ]β†’L[R] N) [inst_7 : ContinuousAdd N] (v : ΞΉ β†’ M), (f + g) v = f v + g v
Metric.PiNatEmbed.toPiNat.sizeOf_spec
Mathlib.Topology.MetricSpace.PiNat
βˆ€ {ΞΉ : Type u_2} {X : Type u_5} {Y : ΞΉ β†’ Type u_6} {f : (i : ΞΉ) β†’ X β†’ Y i} [inst : SizeOf ΞΉ] [inst_1 : SizeOf X] [inst_2 : (a : ΞΉ) β†’ SizeOf (Y a)] (ofPiNat : X), sizeOf { ofPiNat := ofPiNat } = 1 + sizeOf ofPiNat
Lean.QuotKind
Lean.Declaration
Type
CategoryTheory.PreGaloisCategory.PointedGaloisObject.noConfusionType
Mathlib.CategoryTheory.Galois.Prorepresentability
Sort u β†’ {C : Type u₁} β†’ [inst : CategoryTheory.Category.{uβ‚‚, u₁} C] β†’ [inst_1 : CategoryTheory.GaloisCategory C] β†’ {F : CategoryTheory.Functor C FintypeCat} β†’ CategoryTheory.PreGaloisCategory.PointedGaloisObject F β†’ {C' : Type u₁} β†’ [inst' : CategoryTheory.Category.{uβ‚‚, u₁} C'] β†’ [inst'_1 : CategoryTheory.GaloisCategory C'] β†’ {F' : CategoryTheory.Functor C' FintypeCat} β†’ CategoryTheory.PreGaloisCategory.PointedGaloisObject F' β†’ Sort u
_private.Mathlib.RingTheory.Support.0.Module.support_subset_of_injective._simp_1_1
Mathlib.RingTheory.Support
βˆ€ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {p : PrimeSpectrum R}, (p ∈ Module.support R M) = βˆƒ m, βˆ€ r βˆ‰ p.asIdeal, r β€’ m β‰  0
SubtractionCommMonoid.casesOn
Mathlib.Algebra.Group.Defs
{G : Type u} β†’ {motive : SubtractionCommMonoid G β†’ Sort u_1} β†’ (t : SubtractionCommMonoid G) β†’ ([toSubtractionMonoid : SubtractionMonoid G] β†’ (add_comm : βˆ€ (a b : G), a + b = b + a) β†’ motive { toSubtractionMonoid := toSubtractionMonoid, add_comm := add_comm }) β†’ motive t
SSet.N.cast._proof_1
Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices
βˆ€ {X : SSet} (s : X.N) {d : β„•} (hd : s.dim = d), (s.cast hd).simplex ∈ X.nonDegenerate (s.cast hd).dim
ProofWidgets.instToJsonMakeEditLinkProps
ProofWidgets.Component.MakeEditLink
Lean.ToJson ProofWidgets.MakeEditLinkProps
Aesop.instInhabitedNormSimpContext
Aesop.Search.SearchM
Inhabited Aesop.NormSimpContext
Filter.Germ.abs_def
Mathlib.Order.Filter.FilterProduct
βˆ€ {Ξ± : Type u} {Ξ² : Type v} {Ο† : Ultrafilter Ξ±} [inst : AddCommGroup Ξ²] [inst_1 : LinearOrder Ξ²] (x : (↑φ).Germ Ξ²), |x| = Filter.Germ.map abs x
Mathlib.Tactic.Order.AtomicFact.nle.sizeOf_spec
Mathlib.Tactic.Order.CollectFacts
βˆ€ (lhs rhs : β„•) (proof : Lean.Expr), sizeOf (Mathlib.Tactic.Order.AtomicFact.nle lhs rhs proof) = 1 + sizeOf lhs + sizeOf rhs + sizeOf proof
Int.pow_gcd_pow
Init.Data.Int.Gcd
βˆ€ {n m : β„€} {k : β„•}, (n ^ k).gcd (m ^ k) = n.gcd m ^ k
CategoryTheory.Abelian.coimageFunctorIsoImageFunctor
Mathlib.CategoryTheory.Abelian.Basic
{C : Type u} β†’ [inst : CategoryTheory.Category.{v, u} C] β†’ [inst_1 : CategoryTheory.Abelian C] β†’ CategoryTheory.Abelian.coim β‰… CategoryTheory.Abelian.im
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_modify._simp_1_1
Std.Data.DTreeMap.Internal.Lemmas
βˆ€ {Ξ± : Type u} {x : Ord Ξ±} {x_1 : BEq Ξ±} [Std.LawfulBEqOrd Ξ±] {a b : Ξ±}, (compare a b = Ordering.eq) = ((a == b) = true)
Interval.commMonoid
Mathlib.Algebra.Order.Interval.Basic
{Ξ± : Type u_2} β†’ [inst : CommMonoid Ξ±] β†’ [inst_1 : PartialOrder Ξ±] β†’ [IsOrderedMonoid Ξ±] β†’ CommMonoid (Interval Ξ±)
HasCardinalLT.Set.isColimitCocone._proof_2
Mathlib.CategoryTheory.Presentable.Type
βˆ€ (X : Type u_1) (ΞΊ : Cardinal.{u_1}), CategoryTheory.IsFiltered (HasCardinalLT.Set X ΞΊ) β†’ CategoryTheory.IsFilteredOrEmpty (HasCardinalLT.Set X ΞΊ)
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.checkSplitInfoArgStatus.match_1
Lean.Meta.Tactic.Grind.Split
(motive : Option Lean.Meta.Grind.SplitStatus β†’ Sort u_1) β†’ (x : Option Lean.Meta.Grind.SplitStatus) β†’ (Unit β†’ motive none) β†’ ((a : Lean.Meta.Grind.SplitStatus) β†’ motive (some a)) β†’ motive x
subset_extentClosure_intentClosure
Mathlib.Order.Concept
βˆ€ {Ξ± : Type u_2} {Ξ² : Type u_3} (r : Ξ± β†’ Ξ² β†’ Prop) (s : Set Ξ±), s βŠ† lowerPolar r (upperPolar r s)
MeasureTheory.intervalIntegral_integral_swap
Mathlib.MeasureTheory.Integral.Prod
βˆ€ {Ξ± : Type u_1} {E : Type u_3} [inst : MeasurableSpace Ξ±] {ΞΌ : MeasureTheory.Measure Ξ±} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [MeasureTheory.SFinite ΞΌ] {a b : ℝ} {f : ℝ β†’ Ξ± β†’ E}, MeasureTheory.Integrable (Function.uncurry f) ((MeasureTheory.volume.restrict (Set.uIoc a b)).prod ΞΌ) β†’ ∫ (x : ℝ) in a..b, ∫ (y : Ξ±), f x y βˆ‚ΞΌ = ∫ (y : Ξ±), ∫ (x : ℝ) in a..b, f x y βˆ‚ΞΌ
MonCat.FilteredColimits.colimitMulOneClass._proof_1
Mathlib.Algebra.Category.MonCat.FilteredColimits
βˆ€ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat) [inst_1 : CategoryTheory.IsFiltered J] (x : MonCat.FilteredColimits.M F), 1 * x = x
CategoryTheory.StructuredArrow.preEquivalenceFunctor._proof_2
Mathlib.CategoryTheory.Comma.StructuredArrow.Basic
βˆ€ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_5} [inst_1 : CategoryTheory.Category.{u_2, u_5} D] {E : Type u_6} [inst_2 : CategoryTheory.Category.{u_4, u_6} E] (F : CategoryTheory.Functor C D) {G : CategoryTheory.Functor D E} {e : E} (f : CategoryTheory.StructuredArrow e G) (X : CategoryTheory.StructuredArrow f (CategoryTheory.StructuredArrow.pre e F G)), CategoryTheory.StructuredArrow.homMk (CategoryTheory.CategoryStruct.id X).right.right β‹― = CategoryTheory.CategoryStruct.id (CategoryTheory.StructuredArrow.mk X.hom.right)
Lean.Compiler.LCNF.PP.ppLetValue
Lean.Compiler.LCNF.PrettyPrinter
Lean.Compiler.LCNF.LetValue β†’ Lean.Compiler.LCNF.PP.M Std.Format
AddGroupExtension.Splitting.coe_addMonoidHom_mk
Mathlib.GroupTheory.GroupExtension.Defs
βˆ€ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G] {S : AddGroupExtension N E G} (s : G β†’+ E) (hs : Function.RightInverse ⇑s ⇑S.rightHom), ↑{ toAddMonoidHom := s, rightInverse_rightHom := hs } = s
CategoryTheory.Enriched.HasConicalLimitsOfSize.recOn
Mathlib.CategoryTheory.Enriched.Limits.HasConicalLimits
{V : Type u'} β†’ [inst : CategoryTheory.Category.{v', u'} V] β†’ [inst_1 : CategoryTheory.MonoidalCategory V] β†’ {C : Type u} β†’ [inst_2 : CategoryTheory.Category.{v, u} C] β†’ [inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] β†’ {motive : CategoryTheory.Enriched.HasConicalLimitsOfSize.{v₁, u₁, v', v, u, u'} V C β†’ Sort u_1} β†’ (t : CategoryTheory.Enriched.HasConicalLimitsOfSize.{v₁, u₁, v', v, u, u'} V C) β†’ ((hasConicalLimitsOfShape : βˆ€ (J : Type u₁) [inst_4 : CategoryTheory.Category.{v₁, u₁} J], CategoryTheory.Enriched.HasConicalLimitsOfShape J V C) β†’ motive β‹―) β†’ motive t
GenLoop.continuous_fromLoop
Mathlib.Topology.Homotopy.HomotopyGroup
βˆ€ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] (i : N), Continuous (GenLoop.fromLoop i)
AddRightReflectLE
Mathlib.Algebra.Order.Monoid.Unbundled.Defs
(M : Type u_1) β†’ [Add M] β†’ [LE M] β†’ Prop
Lean.ModuleData.mk.inj
Lean.Environment
βˆ€ {isModule : Bool} {imports : Array Lean.Import} {constNames : Array Lean.Name} {constants : Array Lean.ConstantInfo} {extraConstNames : Array Lean.Name} {entries : Array (Lean.Name Γ— Array Lean.EnvExtensionEntry)} {isModule_1 : Bool} {imports_1 : Array Lean.Import} {constNames_1 : Array Lean.Name} {constants_1 : Array Lean.ConstantInfo} {extraConstNames_1 : Array Lean.Name} {entries_1 : Array (Lean.Name Γ— Array Lean.EnvExtensionEntry)}, { isModule := isModule, imports := imports, constNames := constNames, constants := constants, extraConstNames := extraConstNames, entries := entries } = { isModule := isModule_1, imports := imports_1, constNames := constNames_1, constants := constants_1, extraConstNames := extraConstNames_1, entries := entries_1 } β†’ isModule = isModule_1 ∧ imports = imports_1 ∧ constNames = constNames_1 ∧ constants = constants_1 ∧ extraConstNames = extraConstNames_1 ∧ entries = entries_1
CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence._proof_7
Mathlib.CategoryTheory.Elements
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor Cα΅’α΅– (Type u_1)) {X Y : CategoryTheory.CostructuredArrow CategoryTheory.yoneda F} (f : X ⟢ Y), CategoryTheory.CategoryStruct.comp (CategoryTheory.CostructuredArrow.homMk f.left β‹―) (CategoryTheory.CostructuredArrow.isoMk (CategoryTheory.Iso.refl Y.left) β‹―).hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.CostructuredArrow.isoMk (CategoryTheory.Iso.refl X.left) β‹―).hom f
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary._proof_2
Std.Time.Date.ValidDate
βˆ€ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : β„€), acc + 1 - acc = 1
Sublattice.map_map
Mathlib.Order.Sublattice
βˆ€ {Ξ± : Type u_2} {Ξ² : Type u_3} {Ξ³ : Type u_4} [inst : Lattice Ξ±] [inst_1 : Lattice Ξ²] [inst_2 : Lattice Ξ³] {L : Sublattice Ξ±} (g : LatticeHom Ξ² Ξ³) (f : LatticeHom Ξ± Ξ²), Sublattice.map g (Sublattice.map f L) = Sublattice.map (g.comp f) L
SModEq.sub
Mathlib.LinearAlgebra.SModEq.Basic
βˆ€ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M} {x₁ xβ‚‚ y₁ yβ‚‚ : M}, x₁ ≑ y₁ [SMOD U] β†’ xβ‚‚ ≑ yβ‚‚ [SMOD U] β†’ x₁ - xβ‚‚ ≑ y₁ - yβ‚‚ [SMOD U]
Std.DTreeMap.Raw.Const.getKey?_filter
Std.Data.DTreeMap.Raw.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {Ξ² : Type v} {t : Std.DTreeMap.Raw Ξ± (fun x => Ξ²) cmp} [inst : Std.TransCmp cmp] {f : Ξ± β†’ Ξ² β†’ Bool} {k : Ξ±} (h : t.WF), (Std.DTreeMap.Raw.filter f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (Std.DTreeMap.Raw.Const.get t x β‹―)
Lean.Expr.FoldConstsImpl.State.mk
Lean.Util.FoldConsts
Lean.PtrSet Lean.Expr β†’ Lean.NameHashSet β†’ Lean.Expr.FoldConstsImpl.State
instCommSemiringCorner._proof_6
Mathlib.RingTheory.Idempotents
βˆ€ {R : Type u_1} (e : R) [inst : NonUnitalCommSemiring R] (idem : IsIdempotentElem e) (x : idem.Corner), Semiring.npow 0 x = 1
Lean.Elab.DocElabInfo.noConfusion
Lean.Elab.InfoTree.Types
{P : Sort u} β†’ {t t' : Lean.Elab.DocElabInfo} β†’ t = t' β†’ Lean.Elab.DocElabInfo.noConfusionType P t t'
CategoryTheory.Codiscrete.unitApp
Mathlib.CategoryTheory.CodiscreteCategory
(C : Type u) β†’ [inst : CategoryTheory.Category.{v, u} C] β†’ CategoryTheory.Functor C (CategoryTheory.Codiscrete C)
lt_of_le_of_ne'
Mathlib.Order.Defs.PartialOrder
βˆ€ {Ξ± : Type u_1} [inst : PartialOrder Ξ±] {a b : Ξ±}, b ≀ a β†’ a β‰  b β†’ b < a
Int.add_modulus_mul_modEq_iff
Mathlib.Data.Int.ModEq
βˆ€ {n a b c : β„€}, a + n * b ≑ c [ZMOD n] ↔ a ≑ c [ZMOD n]
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosSemidef.natCast._simp_1_2
Mathlib.LinearAlgebra.Matrix.PosDef
βˆ€ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R] {a : R}, 0 ≀ a β†’ βˆ€ (c : R), (0 ≀ star c * a * c) = True
QuadraticForm.tensorRId_symm_apply
Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries
βˆ€ {R : Type uR} {M₁ : Type uM₁} [inst : CommRing R] [inst_1 : AddCommGroup M₁] [inst_2 : Module R M₁] [inst_3 : Invertible 2] (Q₁ : QuadraticForm R M₁) (x : M₁), Q₁.tensorRId.symm x = (TensorProduct.rid R M₁).symm x
SSet.S.dim_eq_of_mk_eq
Mathlib.AlgebraicTopology.SimplicialSet.Simplices
βˆ€ {X : SSet} {n m : β„•} {x : X.obj (Opposite.op (SimplexCategory.mk n))} {y : X.obj (Opposite.op (SimplexCategory.mk m))}, { dim := n, simplex := x } = { dim := m, simplex := y } β†’ n = m
Sbtw.oangle₁₃₂_eq_zero
Mathlib.Geometry.Euclidean.Angle.Oriented.Affine
βˆ€ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ pβ‚‚ p₃ : P}, Sbtw ℝ p₁ pβ‚‚ p₃ β†’ EuclideanGeometry.oangle p₁ p₃ pβ‚‚ = 0
CommRingCat.Colimits.Prequotient.of.sizeOf_spec
Mathlib.Algebra.Category.Ring.Colimits
βˆ€ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat} [inst_1 : SizeOf J] (j : J) (x : ↑(F.obj j)), sizeOf (CommRingCat.Colimits.Prequotient.of j x) = 1 + sizeOf j + sizeOf x
MeasureTheory.L1.measurable_coeFn
Mathlib.MeasureTheory.Function.L1Space.AEEqFun
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {m : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} [inst : NormedAddCommGroup Ξ²] [inst_1 : MeasurableSpace Ξ²] [BorelSpace Ξ²] (f : β†₯(MeasureTheory.Lp Ξ² 1 ΞΌ)), Measurable ↑↑f
CategoryTheory.EnrichedNatTrans.mk
Mathlib.CategoryTheory.Enriched.Basic
{V : Type v} β†’ [inst : CategoryTheory.Category.{w, v} V] β†’ [inst_1 : CategoryTheory.MonoidalCategory V] β†’ {C : Type u₁} β†’ [inst_2 : CategoryTheory.EnrichedCategory V C] β†’ {D : Type uβ‚‚} β†’ [inst_3 : CategoryTheory.EnrichedCategory V D] β†’ {F G : CategoryTheory.EnrichedFunctor V C D} β†’ (F.forget ⟢ G.forget) β†’ CategoryTheory.EnrichedNatTrans F G
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.horizontal_strip._simp_1_9
Mathlib.Analysis.Complex.PhragmenLindelof
βˆ€ {Ξ± : Type u_1} [inst : DivisionCommMonoid Ξ±] (a b : Ξ±), b⁻¹ * a = a / b
Matrix.mulVec_empty
Mathlib.LinearAlgebra.Matrix.Notation
βˆ€ {Ξ± : Type u} {m' : Type uβ‚˜} [inst : NonUnitalNonAssocSemiring Ξ±] (A : Matrix m' (Fin 0) Ξ±) (v : Fin 0 β†’ Ξ±), A.mulVec v = 0
DifferentiableOn.zpow
Mathlib.Analysis.Calculus.Deriv.ZPow
βˆ€ {π•œ : Type u} [inst : NontriviallyNormedField π•œ] {E : Type v} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π•œ E] {m : β„€} {f : E β†’ π•œ} {t : Set E}, DifferentiableOn π•œ f t β†’ (βˆ€ x ∈ t, f x β‰  0) ∨ 0 ≀ m β†’ DifferentiableOn π•œ (fun x => f x ^ m) t
Lat.ext
Mathlib.Order.Category.Lat
βˆ€ {X Y : Lat} {f g : X ⟢ Y}, (βˆ€ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) β†’ f = g
TruncatedWittVector.truncate_wittVector_truncate
Mathlib.RingTheory.WittVector.Truncated
βˆ€ {p n : β„•} {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] {m : β„•} (hm : n ≀ m) (x : WittVector p R), (TruncatedWittVector.truncate hm) ((WittVector.truncate m) x) = (WittVector.truncate n) x
StarAlgHom.rangeRestrict
Mathlib.Algebra.Star.Subalgebra
{R : Type u_2} β†’ {A : Type u_3} β†’ {B : Type u_4} β†’ [inst : CommSemiring R] β†’ [inst_1 : StarRing R] β†’ [inst_2 : Semiring A] β†’ [inst_3 : Algebra R A] β†’ [inst_4 : StarRing A] β†’ [inst_5 : Semiring B] β†’ [inst_6 : Algebra R B] β†’ [inst_7 : StarRing B] β†’ [inst_8 : StarModule R B] β†’ (f : A →⋆ₐ[R] B) β†’ A →⋆ₐ[R] β†₯f.range
CategoryTheory.LocalizerMorphism.LeftResolution.instCategory._proof_4
Mathlib.CategoryTheory.Localization.Resolution
βˆ€ {C₁ : Type u_2} {Cβ‚‚ : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C₁] [inst_1 : CategoryTheory.Category.{u_3, u_4} Cβ‚‚] {W₁ : CategoryTheory.MorphismProperty C₁} {Wβ‚‚ : CategoryTheory.MorphismProperty Cβ‚‚} {Ξ¦ : CategoryTheory.LocalizerMorphism W₁ Wβ‚‚} {Xβ‚‚ : Cβ‚‚} {X Y : Ξ¦.LeftResolution Xβ‚‚} (f : X.Hom Y), f.comp (CategoryTheory.LocalizerMorphism.LeftResolution.Hom.id Y) = f
_private.Mathlib.Order.Interval.Set.UnorderedInterval.0.Set.monotoneOn_or_antitoneOn_iff_uIcc._simp_1_4
Mathlib.Order.Interval.Set.UnorderedInterval
βˆ€ {Ξ± : Type u_1} [inst : LinearOrder Ξ±] {a b c : Ξ±}, (a ∈ Set.uIcc b c) = (b ≀ a ∧ a ≀ c ∨ c ≀ a ∧ a ≀ b)
_private.Mathlib.Tactic.TFAE.0.Mathlib.Tactic.TFAE._aux_Mathlib_Tactic_TFAE___elabRules_Mathlib_Tactic_TFAE_tfaeFinish_1._sparseCasesOn_3
Mathlib.Tactic.TFAE
{motive : Lean.Name β†’ Sort u} β†’ (t : Lean.Name) β†’ ((pre : Lean.Name) β†’ (str : String) β†’ motive (pre.str str)) β†’ (Nat.hasNotBit 2 t.ctorIdx β†’ motive t) β†’ motive t
SkewPolynomial.support
Mathlib.Algebra.SkewPolynomial.Basic
{R : Type u_1} β†’ [inst : Semiring R] β†’ SkewPolynomial R β†’ Finset β„•
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofMVarCluster.match_1
Aesop.Tree.ExtractProof
(motive : Option Aesop.GoalRef β†’ Sort u_1) β†’ (gref? : Option Aesop.GoalRef) β†’ ((gref : Aesop.GoalRef) β†’ motive (some gref)) β†’ ((x : Option Aesop.GoalRef) β†’ motive x) β†’ motive gref?