Hugging Face's logo

Datasets:
mathlib-initiative
/
mathlib-types

Modalities:
Text
Formats:
parquet
Languages:
English
Size:
100K - 1M
Tags:
lean4
mathlib
theorem-proving
formal-mathematics
Libraries:
Datasets
Dask
License:
Dataset card Data Studio Files
xet
Community
1
Dataset Viewer
Auto-converted to Parquet Duplicate
Search is not available for this dataset
name
string
module
string
type
string
ProbabilityTheory.mgf_congr_identDistrib
Mathlib.Probability.Moments.Basic
βˆ€ {Ξ© : Type u_1} {m : MeasurableSpace Ξ©} {X : Ξ© β†’ ℝ} {ΞΌ : MeasureTheory.Measure Ξ©} {Ξ©' : Type u_3} {mΞ©' : MeasurableSpace Ξ©'} {ΞΌ' : MeasureTheory.Measure Ξ©'} {Y : Ξ©' β†’ ℝ}, ProbabilityTheory.IdentDistrib X Y ΞΌ ΞΌ' β†’ ProbabilityTheory.mgf X ΞΌ = ProbabilityTheory.mgf Y ΞΌ'
_private.Init.Data.Iterators.Lemmas.Consumers.Collect.0.Std.Iterators.Iter.reverse_toListRev._simp_1_1
Init.Data.Iterators.Lemmas.Consumers.Collect
βˆ€ {Ξ± Ξ² : Type w} {m : Type w β†’ Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterators.Iterator Ξ± m Ξ²] [inst_3 : Std.Iterators.Finite Ξ± m] [inst_4 : Std.Iterators.IteratorCollect Ξ± m m] [Std.Iterators.LawfulIteratorCollect Ξ± m m] {it : Std.IterM m Ξ²}, it.toList = List.reverse <$> it.toListRev
OrderIso.sumLexIicIoi_symm_apply_Iic
Mathlib.Order.Hom.Lex
βˆ€ {Ξ± : Type u_1} [inst : LinearOrder Ξ±] {x : Ξ±} (a : ↑(Set.Iic x)), (OrderIso.sumLexIicIoi x).symm ↑a = Sum.inl a
ProofWidgets.Html._sizeOf_1
ProofWidgets.Data.Html
ProofWidgets.Html β†’ β„•
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_mul_top_pos._simp_1_9
Mathlib.Topology.Instances.EReal.Lemmas
βˆ€ {Ξ± : Type u} [inst : LinearOrder Ξ±] {a b c : Ξ±}, (a < max b c) = (a < b ∨ a < c)
CategoryTheory.Mon.Hom.mk.sizeOf_spec
Mathlib.CategoryTheory.Monoidal.Mon_
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N : CategoryTheory.Mon C} [inst_2 : SizeOf C] (hom : M.X ⟢ N.X) [isMonHom_hom : CategoryTheory.IsMonHom hom], sizeOf { hom := hom, isMonHom_hom := isMonHom_hom } = 1 + sizeOf hom + sizeOf isMonHom_hom
Lean.Elab.Tactic.nonempty_to_inhabited
Mathlib.Tactic.Inhabit
(Ξ± : Sort u_1) β†’ Nonempty Ξ± β†’ Inhabited Ξ±
AlgebraicGeometry.IsLocalIso.instIsMultiplicativeScheme
Mathlib.AlgebraicGeometry.Morphisms.LocalIso
CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsLocalIso
Lean.Elab.Tactic.Do.Fuel.recOn
Lean.Elab.Tactic.Do.VCGen.Basic
{motive : Lean.Elab.Tactic.Do.Fuel β†’ Sort u} β†’ (t : Lean.Elab.Tactic.Do.Fuel) β†’ ((n : β„•) β†’ motive (Lean.Elab.Tactic.Do.Fuel.limited n)) β†’ motive Lean.Elab.Tactic.Do.Fuel.unlimited β†’ motive t
NonemptyChain.rec
Mathlib.Order.BourbakiWitt
{Ξ± : Type u_2} β†’ [inst : LE Ξ±] β†’ {motive : NonemptyChain Ξ± β†’ Sort u} β†’ ((carrier : Set Ξ±) β†’ (Nonempty' : carrier.Nonempty) β†’ (isChain' : IsChain (fun x1 x2 => x1 ≀ x2) carrier) β†’ motive { carrier := carrier, Nonempty' := Nonempty', isChain' := isChain' }) β†’ (t : NonemptyChain Ξ±) β†’ motive t
le_of_pow_le_pow_leftβ‚€
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic
βˆ€ {Mβ‚€ : Type u_2} [inst : MonoidWithZero Mβ‚€] [inst_1 : LinearOrder Mβ‚€] [PosMulStrictMono Mβ‚€] {a b : Mβ‚€} {n : β„•} [MulPosMono Mβ‚€], n β‰  0 β†’ 0 ≀ b β†’ a ^ n ≀ b ^ n β†’ a ≀ b
PadicAlgCl.valuation_p
Mathlib.NumberTheory.Padics.Complex
βˆ€ (p : β„•) [inst : Fact (Nat.Prime p)], Valued.v ↑p = 1 / ↑p
Nat.map_cast_int_atTop
Mathlib.Order.Filter.AtTopBot.Basic
Filter.map Nat.cast Filter.atTop = Filter.atTop
QuotientGroup.mk_mul
Mathlib.GroupTheory.QuotientGroup.Defs
βˆ€ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal] (a b : G), ↑(a * b) = ↑a * ↑b
Std.DTreeMap.contains_emptyc
Std.Data.DTreeMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {k : Ξ±}, βˆ….contains k = false
Finset.weightedVSub
Mathlib.LinearAlgebra.AffineSpace.Combination
{k : Type u_1} β†’ {V : Type u_2} β†’ {P : Type u_3} β†’ [inst : Ring k] β†’ [inst_1 : AddCommGroup V] β†’ [inst_2 : Module k V] β†’ [S : AddTorsor V P] β†’ {ΞΉ : Type u_4} β†’ Finset ΞΉ β†’ (ΞΉ β†’ P) β†’ (ΞΉ β†’ k) β†’β‚—[k] V
CategoryTheory.MorphismProperty.LeftFraction.unop_f
Mathlib.CategoryTheory.Localization.CalculusOfFractions
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {W : CategoryTheory.MorphismProperty Cα΅’α΅–} {X Y : Cα΅’α΅–} (Ο† : W.LeftFraction X Y), Ο†.unop.f = Ο†.f.unop
MeasureTheory.AddContent.mk._flat_ctor
Mathlib.MeasureTheory.Measure.AddContent
{Ξ± : Type u_1} β†’ {C : Set (Set Ξ±)} β†’ (toFun : Set Ξ± β†’ ENNReal) β†’ toFun βˆ… = 0 β†’ (βˆ€ (I : Finset (Set Ξ±)), ↑I βŠ† C β†’ (↑I).PairwiseDisjoint id β†’ ⋃₀ ↑I ∈ C β†’ toFun (⋃₀ ↑I) = βˆ‘ u ∈ I, toFun u) β†’ MeasureTheory.AddContent C
_auto._@.Mathlib.Probability.Independence.Conditional.1406646405._hygCtx._hyg.20
Mathlib.Probability.Independence.Conditional
Lean.Syntax
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.nlinarithGetSquareProofs
Mathlib.Tactic.Linarith.Preprocessing
List Lean.Expr β†’ Lean.MetaM (List Lean.Expr)
Int.natCast_toNat_eq_self
Init.Data.Int.LemmasAux
βˆ€ {a : β„€}, ↑a.toNat = a ↔ 0 ≀ a
instDecidableRelAssociatedOfDvd
Mathlib.Algebra.GroupWithZero.Associated
{M : Type u_1} β†’ [inst : CancelMonoidWithZero M] β†’ [DecidableRel fun x1 x2 => x1 ∣ x2] β†’ DecidableRel fun x1 x2 => Associated x1 x2
Filter.EventuallyEq.lieBracketWithin_vectorField_eq_of_insert
Mathlib.Analysis.Calculus.VectorField
βˆ€ {π•œ : Type u_1} [inst : NontriviallyNormedField π•œ] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π•œ E] {V W V₁ W₁ : E β†’ E} {s : Set E} {x : E}, V₁ =αΆ [nhdsWithin x (insert x s)] V β†’ W₁ =αΆ [nhdsWithin x (insert x s)] W β†’ VectorField.lieBracketWithin π•œ V₁ W₁ s x = VectorField.lieBracketWithin π•œ V W s x
Lean.AxiomVal.isUnsafeEx
Lean.Declaration
Lean.AxiomVal β†’ Bool
BitVec.not_or_self
Init.Data.BitVec.Lemmas
βˆ€ {w : β„•} (x : BitVec w), ~~~x ||| x = BitVec.allOnes w
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabLetE._sparseCasesOn_3
Lean.PrettyPrinter.Delaborator.Builtins
{motive : Lean.Expr β†’ Sort u} β†’ (t : Lean.Expr) β†’ ((declName : Lean.Name) β†’ (type value body : Lean.Expr) β†’ (nondep : Bool) β†’ motive (Lean.Expr.letE declName type value body nondep)) β†’ (t.ctorIdx β‰  8 β†’ motive t) β†’ motive t
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.splitStr._proof_1
Lean.Server.FileWorker.SemanticHighlighting
βˆ€ (text : Lean.FileMap) (pos : String.Pos.Raw), βˆ€ i ∈ [(text.toPosition pos).line:text.positions.size], i < text.positions.size
Pi.intCast_def
Mathlib.Data.Int.Cast.Pi
βˆ€ {ΞΉ : Type u_1} {Ο€ : ΞΉ β†’ Type u_2} [inst : (i : ΞΉ) β†’ IntCast (Ο€ i)] (n : β„€), ↑n = fun x => ↑n
CategoryTheory.ObjectProperty.ColimitOfShape._sizeOf_1
Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape
{C : Type u_1} β†’ {inst : CategoryTheory.Category.{u_2, u_1} C} β†’ {P : CategoryTheory.ObjectProperty C} β†’ {J : Type u'} β†’ {inst_1 : CategoryTheory.Category.{v', u'} J} β†’ {X : C} β†’ [SizeOf C] β†’ [(a : C) β†’ SizeOf (P a)] β†’ [SizeOf J] β†’ P.ColimitOfShape J X β†’ β„•
Lean.Lsp.FoldingRangeParams.mk.sizeOf_spec
Lean.Data.Lsp.LanguageFeatures
βˆ€ (textDocument : Lean.Lsp.TextDocumentIdentifier), sizeOf { textDocument := textDocument } = 1 + sizeOf textDocument
mul_self_nonneg
Mathlib.Algebra.Order.Ring.Unbundled.Basic
βˆ€ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulMono R] [AddLeftMono R] (a : R), 0 ≀ a * a
Matroid.comap_isBasis'_iff._simp_1
Mathlib.Combinatorics.Matroid.Map
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β†’ Ξ²} {N : Matroid Ξ²} {I X : Set Ξ±}, (N.comap f).IsBasis' I X = (N.IsBasis' (f '' I) (f '' X) ∧ Set.InjOn f I ∧ I βŠ† X)
_private.Init.Data.Order.PackageFactories.0.Std.LinearPreorderPackage.ofOrd._simp_4
Init.Data.Order.PackageFactories
βˆ€ {Ξ± : Type u} [inst : Ord Ξ±] [inst_1 : LE Ξ±] [Std.LawfulOrderOrd Ξ±] {a b : Ξ±}, ((compare a b).isGE = true) = (b ≀ a)
Ordinal.deriv_zero_left
Mathlib.SetTheory.Ordinal.FixedPoint
βˆ€ (a : Ordinal.{u_1}), Ordinal.deriv 0 a = a
SimpleGraph.completeEquipartiteGraph.completeMultipartiteGraph._proof_1
Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite
βˆ€ {r t : β„•} (a a_1 : Fin r Γ— Fin t), (SimpleGraph.comap Sigma.fst ⊀).Adj ⟨a.1, a.2⟩ ⟨a_1.1, a_1.2⟩ ↔ (SimpleGraph.comap Prod.fst ⊀).Adj a a_1
Lean.Grind.Linarith.lt_norm
Init.Grind.Ordered.Linarith
βˆ€ {Ξ± : Type u_1} [inst : Lean.Grind.IntModule Ξ±] [inst_1 : LE Ξ±] [inst_2 : LT Ξ±] [Std.LawfulOrderLT Ξ±] [inst_4 : Std.IsPreorder Ξ±] [Lean.Grind.OrderedAdd Ξ±] (ctx : Lean.Grind.Linarith.Context Ξ±) (lhs rhs : Lean.Grind.Linarith.Expr) (p : Lean.Grind.Linarith.Poly), Lean.Grind.Linarith.norm_cert lhs rhs p = true β†’ Lean.Grind.Linarith.Expr.denote ctx lhs < Lean.Grind.Linarith.Expr.denote ctx rhs β†’ Lean.Grind.Linarith.Poly.denote' ctx p < 0
DomMulAct.instCancelCommMonoidOfMulOpposite.eq_1
Mathlib.GroupTheory.GroupAction.DomAct.Basic
βˆ€ {M : Type u_1} [inst : CancelCommMonoid Mᡐᡒᡖ], DomMulAct.instCancelCommMonoidOfMulOpposite = inst
Lean.Grind.CommRing.Poly.degree
Lean.Meta.Tactic.Grind.Arith.CommRing.Poly
Lean.Grind.CommRing.Poly β†’ β„•
SimpleGraph.Copy.isoSubgraphMap._simp_3
Mathlib.Combinatorics.SimpleGraph.Copy
βˆ€ {Ξ± : Sort u_1} {p : Ξ± β†’ Prop} {a' : Ξ±}, (βˆƒ a, p a ∧ a = a') = p a'
Pi.addHom.eq_1
Mathlib.Algebra.Group.Pi.Lemmas
βˆ€ {I : Type u} {f : I β†’ Type v} {Ξ³ : Type w} [inst : (i : I) β†’ Add (f i)] [inst_1 : Add Ξ³] (g : (i : I) β†’ Ξ³ β†’β‚™+ f i), Pi.addHom g = { toFun := fun x i => (g i) x, map_add' := β‹― }
Qq.Impl.unquoteExpr
Qq.Macro
Lean.Expr β†’ Qq.Impl.UnquoteM Lean.Expr
Nat.reduceLeDiff._regBuiltin.Nat.reduceLeDiff.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.2466209926._hygCtx._hyg.24
Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat
IO Unit
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.algebraMap_mem_maximalIdeal_iff._simp_1_1
Mathlib.RingTheory.Valuation.Extension
βˆ€ {R : Type u_1} [inst : CommSemiring R] [inst_1 : IsLocalRing R] (x : R), (x ∈ IsLocalRing.maximalIdeal R) = (x ∈ nonunits R)
Lean.Compiler.LCNF.ConfigOptions.mk
Lean.Compiler.LCNF.ConfigOptions
β„• β†’ β„• β†’ β„• β†’ Bool β†’ Bool β†’ Lean.Compiler.LCNF.ConfigOptions
_private.Mathlib.Topology.Algebra.Module.LinearPMap.0.LinearPMap.inverse_isClosable_iff.match_1_1
Mathlib.Topology.Algebra.Module.LinearPMap
βˆ€ {R : Type u_1} {E : Type u_3} {F : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F] [inst_3 : Module R E] [inst_4 : Module R F] [inst_5 : TopologicalSpace E] [inst_6 : TopologicalSpace F] {f : E β†’β‚—.[R] F} [inst_7 : ContinuousAdd E] [inst_8 : ContinuousAdd F] [inst_9 : TopologicalSpace R] [inst_10 : ContinuousSMul R E] [inst_11 : ContinuousSMul R F] (motive : f.inverse.IsClosable β†’ Prop) (h : f.inverse.IsClosable), (βˆ€ (f' : F β†’β‚—.[R] E) (h : f.inverse.graph.topologicalClosure = f'.graph), motive β‹―) β†’ motive h
ne_zero_of_dvd_ne_zero
Mathlib.Algebra.GroupWithZero.Divisibility
βˆ€ {Ξ± : Type u_1} [inst : MonoidWithZero Ξ±] {p q : Ξ±}, q β‰  0 β†’ p ∣ q β†’ p β‰  0
Lean.Meta.Canonicalizer.CanonM.run'
Lean.Meta.Canonicalizer
{Ξ± : Type} β†’ Lean.Meta.CanonM Ξ± β†’ optParam Lean.Meta.TransparencyMode Lean.Meta.TransparencyMode.instances β†’ optParam Lean.Meta.Canonicalizer.State { } β†’ Lean.MetaM Ξ±
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.splitMax_eq.match_1_1
Mathlib.Data.Ordmap.Invariants
βˆ€ {Ξ± : Type u_1} (motive : β„• β†’ Ordnode Ξ± β†’ Ξ± β†’ Ordnode Ξ± β†’ Prop) (x : β„•) (x_1 : Ordnode Ξ±) (x_2 : Ξ±) (x_3 : Ordnode Ξ±), (βˆ€ (x : β„•) (x_4 : Ordnode Ξ±) (x_5 : Ξ±), motive x x_4 x_5 Ordnode.nil) β†’ (βˆ€ (x : β„•) (l : Ordnode Ξ±) (x_4 : Ξ±) (ls : β„•) (ll : Ordnode Ξ±) (lx : Ξ±) (lr : Ordnode Ξ±), motive x l x_4 (Ordnode.node ls ll lx lr)) β†’ motive x x_1 x_2 x_3
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_ring_1
Mathlib.Tactic.Ring.RingNF
Lean.Macro
AlgebraicGeometry.instQuasiCompactLiftSchemeIdOfQuasiSeparatedSpaceCarrierCarrierCommRingCat
Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated
βˆ€ {X : AlgebraicGeometry.Scheme} [QuasiSeparatedSpace β†₯X], AlgebraicGeometry.QuasiCompact (CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X))
Pi.subtractionMonoid.eq_1
Mathlib.Algebra.Group.Pi.Basic
βˆ€ {I : Type u} {f : I β†’ Type v₁} [inst : (i : I) β†’ SubtractionMonoid (f i)], Pi.subtractionMonoid = { toSubNegMonoid := Pi.subNegMonoid, neg_neg := β‹―, neg_add_rev := β‹―, neg_eq_of_add := β‹― }
CategoryTheory.regularEpiOfEpi
Mathlib.CategoryTheory.Limits.Shapes.RegularMono
{C : Type u₁} β†’ [inst : CategoryTheory.Category.{v₁, u₁} C] β†’ {X Y : C} β†’ [CategoryTheory.IsRegularEpiCategory C] β†’ (f : X ⟢ Y) β†’ [CategoryTheory.Epi f] β†’ CategoryTheory.RegularEpi f
AddAction.toAddSemigroupAction
Mathlib.Algebra.Group.Action.Defs
{G : Type u_9} β†’ {P : Type u_10} β†’ {inst : AddMonoid G} β†’ [self : AddAction G P] β†’ AddSemigroupAction G P
SimpContFract.IsContFract
Mathlib.Algebra.ContinuedFractions.Basic
{Ξ± : Type u_1} β†’ [inst : One Ξ±] β†’ [Zero Ξ±] β†’ [LT Ξ±] β†’ SimpContFract Ξ± β†’ Prop
SimpleGraph.chromaticNumber_eq_iInf
Mathlib.Combinatorics.SimpleGraph.Coloring
βˆ€ {V : Type u} {G : SimpleGraph V}, G.chromaticNumber = β¨… n, ↑↑n
Finsupp.liftAddHom._proof_2
Mathlib.Algebra.BigOperators.Finsupp.Basic
βˆ€ {Ξ± : Type u_1} {M : Type u_2} {N : Type u_3} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N] (F : Ξ± β†’ M β†’+ N) (x x_1 : Ξ± β†’β‚€ M), ((x + x_1).sum fun x => ⇑(F x)) = (x.sum fun x => ⇑(F x)) + x_1.sum fun x => ⇑(F x)
Mathlib.Meta.FunProp.LambdaTheorem.getProof
Mathlib.Tactic.FunProp.Theorems
Mathlib.Meta.FunProp.LambdaTheorem β†’ Lean.MetaM Lean.Expr
_private.Mathlib.Algebra.Group.Conj.0.isConj_iff_eq.match_1_1
Mathlib.Algebra.Group.Conj
βˆ€ {Ξ± : Type u_1} [inst : CommMonoid Ξ±] {a b : Ξ±} (motive : IsConj a b β†’ Prop) (x : IsConj a b), (βˆ€ (c : Ξ±Λ£) (hc : SemiconjBy (↑c) a b), motive β‹―) β†’ motive x
TopCat.pullbackHomeoPreimage._proof_7
Mathlib.Topology.Category.TopCat.Limits.Pullbacks
βˆ€ {X : Type u_3} {Y : Type u_1} {Z : Type u_2} (f : X β†’ Z) (g : Y β†’ Z) (x : ↑(f ⁻¹' Set.range g)), βˆƒ y, g y = f (β†‘βŸ¨(↑x, Exists.choose β‹―), β‹―βŸ©).1
GaloisInsertion.mk._flat_ctor
Mathlib.Order.GaloisConnection.Defs
{Ξ± : Type u_2} β†’ {Ξ² : Type u_3} β†’ [inst : Preorder Ξ±] β†’ [inst_1 : Preorder Ξ²] β†’ {l : Ξ± β†’ Ξ²} β†’ {u : Ξ² β†’ Ξ±} β†’ (choice : (x : Ξ±) β†’ u (l x) ≀ x β†’ Ξ²) β†’ GaloisConnection l u β†’ (βˆ€ (x : Ξ²), x ≀ l (u x)) β†’ (βˆ€ (a : Ξ±) (h : u (l a) ≀ a), choice a h = l a) β†’ GaloisInsertion l u
CategoryTheory.Pretriangulated.Triangle.isoMk._simp_1
Mathlib.CategoryTheory.Triangulated.Basic
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type uβ‚‚} [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} D] (self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟢ Y) (g : Y ⟢ Z), CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g)
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.filter_le.match_1_1
Mathlib.Analysis.BoxIntegral.Partition.Basic
βˆ€ {ΞΉ : Type u_1} {I : BoxIntegral.Box ΞΉ} (Ο€ : BoxIntegral.Prepartition I) (p : BoxIntegral.Box ΞΉ β†’ Prop) (J : BoxIntegral.Box ΞΉ) (motive : J ∈ Ο€ ∧ p J β†’ Prop) (x : J ∈ Ο€ ∧ p J), (βˆ€ (hΟ€ : J ∈ Ο€) (right : p J), motive β‹―) β†’ motive x
Finset.shadow_mono
Mathlib.Combinatorics.SetFamily.Shadow
βˆ€ {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {π’œ ℬ : Finset (Finset Ξ±)}, π’œ βŠ† ℬ β†’ π’œ.shadow βŠ† ℬ.shadow
AlgebraicGeometry.Scheme.canonicallyOverPullback
Mathlib.AlgebraicGeometry.Pullbacks
{M S T : AlgebraicGeometry.Scheme} β†’ [inst : M.Over S] β†’ {f : T ⟢ S} β†’ (CategoryTheory.Limits.pullback (M β†˜ S) f).CanonicallyOver T
_private.Plausible.Testable.0.Plausible.Decorations._aux_Plausible_Testable___elabRules_Plausible_Decorations_tacticMk_decorations_1.match_1
Plausible.Testable
(motive : Lean.Expr β†’ Sort u_1) β†’ (goalType : Lean.Expr) β†’ ((us : List Lean.Level) β†’ (body : Lean.Expr) β†’ motive ((Lean.Expr.const `Plausible.Decorations.DecorationsOf us).app body)) β†’ ((x : Lean.Expr) β†’ motive x) β†’ motive goalType
Int32.ofIntLE_le_iff_le
Init.Data.SInt.Lemmas
βˆ€ {a b : β„€} (ha₁ : Int32.minValue.toInt ≀ a) (haβ‚‚ : a ≀ Int32.maxValue.toInt) (hb₁ : Int32.minValue.toInt ≀ b) (hbβ‚‚ : b ≀ Int32.maxValue.toInt), Int32.ofIntLE a ha₁ haβ‚‚ ≀ Int32.ofIntLE b hb₁ hbβ‚‚ ↔ a ≀ b
LieEquiv.map_lie
Mathlib.Algebra.Lie.Basic
βˆ€ {R : Type u} {L₁ : Type v} {Lβ‚‚ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing Lβ‚‚] [inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R Lβ‚‚] (e : L₁ ≃ₗ⁅R⁆ Lβ‚‚) (x y : L₁), e ⁅x, y⁆ = ⁅e x, e y⁆
Std.DTreeMap.Internal.Impl.getKeyD_filter_key
Std.Data.DTreeMap.Internal.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {instOrd : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} [Std.TransOrd Ξ±] {f : Ξ± β†’ Bool} {k fallback : Ξ±} (h : t.WF), (Std.DTreeMap.Internal.Impl.filter (fun k x => f k) t β‹―).impl.getKeyD k fallback = (Option.filter f (t.getKey? k)).getD fallback
Dyadic.neg.eq_1
Init.Data.Dyadic.Basic
Dyadic.zero.neg = Dyadic.zero
Lean.PrettyPrinter.Formatter.Context.mk.inj
Lean.PrettyPrinter.Formatter
βˆ€ {options : Lean.Options} {table : Lean.Parser.TokenTable} {options_1 : Lean.Options} {table_1 : Lean.Parser.TokenTable}, { options := options, table := table } = { options := options_1, table := table_1 } β†’ options = options_1 ∧ table = table_1
AddAction.vadd_mem_of_set_mem_fixedBy
Mathlib.GroupTheory.GroupAction.FixedPoints
βˆ€ {Ξ± : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G Ξ±] {s : Set Ξ±} {g : G}, s ∈ AddAction.fixedBy (Set Ξ±) g β†’ βˆ€ {x : Ξ±}, g +α΅₯ x ∈ s ↔ x ∈ s
Set.unitEquivUnitsInteger._proof_3
Mathlib.RingTheory.DedekindDomain.SInteger
βˆ€ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R)) (K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (x : β†₯(S.unit K)), βŸ¨β†‘β†‘x, β‹―βŸ© * βŸ¨β†‘(↑x)⁻¹, β‹―βŸ© = 1
Lean.Lsp.instToJsonCodeActionClientCapabilities
Lean.Data.Lsp.CodeActions
Lean.ToJson Lean.Lsp.CodeActionClientCapabilities
UInt8.or_eq_zero_iff._simp_1
Init.Data.UInt.Bitwise
βˆ€ {a b : UInt8}, (a ||| b = 0) = (a = 0 ∧ b = 0)
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs.inj
Lean.Meta.Tactic.Grind.Arith.Cutsat.Types
βˆ€ {c₁ cβ‚‚ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k : β„€} {c₁_1 cβ‚‚_1 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k_1 : β„€}, Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁ cβ‚‚ k = Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁_1 cβ‚‚_1 k_1 β†’ c₁ = c₁_1 ∧ cβ‚‚ = cβ‚‚_1 ∧ k = k_1
CategoryTheory.preserves_mono_of_preservesLimit
Mathlib.CategoryTheory.Limits.Constructions.EpiMono
βˆ€ {C : Type u₁} {D : Type uβ‚‚} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟢ Y) [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f f) F] [CategoryTheory.Mono f], CategoryTheory.Mono (F.map f)
Finpartition.part
Mathlib.Order.Partition.Finpartition
{Ξ± : Type u_1} β†’ [inst : DecidableEq Ξ±] β†’ {s : Finset Ξ±} β†’ Finpartition s β†’ Ξ± β†’ Finset Ξ±
MeasureTheory.Lp.ext_iff
Mathlib.MeasureTheory.Function.LpSpace.Basic
βˆ€ {Ξ± : Type u_1} {E : Type u_4} {m : MeasurableSpace Ξ±} {p : ENNReal} {ΞΌ : MeasureTheory.Measure Ξ±} [inst : NormedAddCommGroup E] {f g : β†₯(MeasureTheory.Lp E p ΞΌ)}, f = g ↔ ↑↑f =ᡐ[ΞΌ] ↑↑g
LinearMap.coprod_comp_inl_inr
Mathlib.LinearAlgebra.Prod
βˆ€ {R : Type u} {M : Type v} {Mβ‚‚ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid Mβ‚‚] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R Mβ‚‚] [inst_6 : Module R M₃] (f : M Γ— Mβ‚‚ β†’β‚—[R] M₃), (f βˆ˜β‚— LinearMap.inl R M Mβ‚‚).coprod (f βˆ˜β‚— LinearMap.inr R M Mβ‚‚) = f
Std.DHashMap.Internal.Raw.fold_cons_key
Std.Data.DHashMap.Internal.WF
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {l : Std.DHashMap.Raw Ξ± Ξ²} {acc : List Ξ±}, Std.DHashMap.Raw.fold (fun acc k x => k :: acc) acc l = Std.Internal.List.keys (Std.DHashMap.Internal.toListModel l.buckets).reverse ++ acc
_private.Mathlib.Util.FormatTable.0.formatTable.match_1
Mathlib.Util.FormatTable
(motive : β„• β†’ Alignment β†’ Sort u_1) β†’ (w : β„•) β†’ (a : Alignment) β†’ ((x : Alignment) β†’ motive 0 x) β†’ ((x : Alignment) β†’ motive 1 x) β†’ ((n : β„•) β†’ motive n.succ.succ Alignment.left) β†’ ((n : β„•) β†’ motive n.succ.succ Alignment.right) β†’ ((n : β„•) β†’ motive n.succ.succ Alignment.center) β†’ motive w a
Nat.addUnits_eq_zero
Mathlib.Algebra.Group.Nat.Units
βˆ€ (u : AddUnits β„•), u = 0
Filter.EventuallyLE.measure_le
Mathlib.MeasureTheory.OuterMeasure.AE
βˆ€ {Ξ± : Type u_1} {F : Type u_3} [inst : FunLike F (Set Ξ±) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F Ξ±] {ΞΌ : F} {s t : Set Ξ±}, s ≀ᡐ[ΞΌ] t β†’ ΞΌ s ≀ ΞΌ t
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.mk.sizeOf_spec
Lean.PrettyPrinter.Delaborator.TopDownAnalyze
βˆ€ (f fType : Lean.Expr) (args mvars : Array Lean.Expr) (bInfos : Array Lean.BinderInfo) (forceRegularApp : Bool), sizeOf { f := f, fType := fType, args := args, mvars := mvars, bInfos := bInfos, forceRegularApp := forceRegularApp } = 1 + sizeOf f + sizeOf fType + sizeOf args + sizeOf mvars + sizeOf bInfos + sizeOf forceRegularApp
Padic.coe_one
Mathlib.NumberTheory.Padics.PadicNumbers
βˆ€ (p : β„•) [inst : Fact (Nat.Prime p)], ↑1 = 1
LocallyConstant.comapRingHom._proof_1
Mathlib.Topology.LocallyConstant.Algebra
βˆ€ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Z : Type u_1} [inst_2 : Semiring Z] (f : C(X, Y)), (↑(LocallyConstant.comapAddMonoidHom f)).toFun 0 = 0
AlgebraicGeometry.Scheme.LocalRepresentability.yonedaGluedToSheaf_app_toGlued
Mathlib.AlgebraicGeometry.Sites.Representability
βˆ€ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u)} {ΞΉ : Type u} {X : ΞΉ β†’ AlgebraicGeometry.Scheme} {f : (i : ΞΉ) β†’ CategoryTheory.yoneda.obj (X i) ⟢ F.val} (hf : βˆ€ (i : ΞΉ), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) {i : ΞΉ}, (AlgebraicGeometry.Scheme.LocalRepresentability.yonedaGluedToSheaf hf).val.app (Opposite.op (X i)) (AlgebraicGeometry.Scheme.LocalRepresentability.toGlued hf i) = CategoryTheory.yonedaEquiv (f i)
fderivPolarCoordSymm._proof_8
Mathlib.Analysis.SpecialFunctions.PolarCoord
FiniteDimensional ℝ (ℝ Γ— ℝ)
RingEquiv.nonUnitalSubringCongr
Mathlib.RingTheory.NonUnitalSubring.Basic
{R : Type u} β†’ [inst : NonUnitalRing R] β†’ {s t : NonUnitalSubring R} β†’ s = t β†’ β†₯s ≃+* β†₯t
UniqueFactorizationMonoid.radical_mul
Mathlib.RingTheory.Radical
βˆ€ {M : Type u_1} [inst : CancelCommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M] {a b : M}, IsRelPrime a b β†’ UniqueFactorizationMonoid.radical (a * b) = UniqueFactorizationMonoid.radical a * UniqueFactorizationMonoid.radical b
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe.eq_1
Mathlib.Topology.OpenPartialHomeomorph
βˆ€ {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X) (hs : Nonempty β†₯s), s.openPartialHomeomorphSubtypeCoe hs = Topology.IsOpenEmbedding.toOpenPartialHomeomorph Subtype.val β‹―
CategoryTheory.Lax.StrongTrans.mkOfLax._proof_1
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax
βˆ€ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C] {F G : CategoryTheory.LaxFunctor B C} (Ξ· : CategoryTheory.Lax.LaxTrans F G) (Ξ·' : CategoryTheory.Lax.LaxTrans.StrongCore Ξ·) {a b : B} {f g : a ⟢ b} (Ξ·_1 : f ⟢ g), CategoryTheory.CategoryStruct.comp (Ξ·'.naturality f).hom (CategoryTheory.Bicategory.whiskerRight (F.mapβ‚‚ Ξ·_1) (Ξ·.app b)) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (Ξ·.app a) (G.mapβ‚‚ Ξ·_1)) (Ξ·'.naturality g).hom
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.moebius_inversion_top._simp_1_10
Mathlib.Combinatorics.Enumerative.IncidenceAlgebra
βˆ€ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0)
Std.Iterators.IterM.step_filterMap
Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap
βˆ€ {Ξ± Ξ² Ξ²' : Type w} {m : Type w β†’ Type w'} [inst : Std.Iterators.Iterator Ξ± m Ξ²] {it : Std.IterM m Ξ²} [inst_1 : Monad m] [LawfulMonad m] {f : Ξ² β†’ Option Ξ²'}, (Std.Iterators.IterM.filterMap f it).step = do let __do_lift ← it.step match __do_lift.inflate with | ⟨Std.Iterators.IterStep.yield it' out, h⟩ => match h' : f out with | none => pure (Std.Shrink.deflate (Std.Iterators.PlausibleIterStep.skip (Std.Iterators.IterM.filterMap f it') β‹―)) | some out' => pure (Std.Shrink.deflate (Std.Iterators.PlausibleIterStep.yield (Std.Iterators.IterM.filterMap f it') out' β‹―)) | ⟨Std.Iterators.IterStep.skip it', h⟩ => pure (Std.Shrink.deflate (Std.Iterators.PlausibleIterStep.skip (Std.Iterators.IterM.filterMap f it') β‹―)) | ⟨Std.Iterators.IterStep.done, h⟩ => pure (Std.Shrink.deflate (Std.Iterators.PlausibleIterStep.done β‹―))
Lean.PrettyPrinter.Delaborator.OmissionReason.noConfusionType
Lean.PrettyPrinter.Delaborator.Basic
Sort u β†’ Lean.PrettyPrinter.Delaborator.OmissionReason β†’ Lean.PrettyPrinter.Delaborator.OmissionReason β†’ Sort u
FinsetFamily._aux_Mathlib_Combinatorics_SetFamily_Compression_UV___unexpand_UV_compression_1
Mathlib.Combinatorics.SetFamily.Compression.UV
Lean.PrettyPrinter.Unexpander
Std.ExtDTreeMap.Const.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_mem
Std.Data.ExtDTreeMap.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.ExtDTreeMap Ξ± (fun x => Unit) cmp} [inst : Std.TransCmp cmp] {l : List Ξ±} {k k' fallback : Ξ±}, cmp k k' = Ordering.eq β†’ k βˆ‰ t β†’ List.Pairwise (fun a b => Β¬cmp a b = Ordering.eq) l β†’ k ∈ l β†’ (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKeyD k' fallback = k
RatFunc.instAlgebraOfPolynomial
Mathlib.FieldTheory.RatFunc.Basic
(K : Type u) β†’ [inst : CommRing K] β†’ [inst_1 : IsDomain K] β†’ (R : Type u_1) β†’ [inst_2 : CommSemiring R] β†’ [Algebra R (Polynomial K)] β†’ Algebra R (RatFunc K)
CategoryTheory.ShortComplex.hasLeftHomology_of_epi_of_isIso_of_mono'
Mathlib.Algebra.Homology.ShortComplex.LeftHomology
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {S₁ Sβ‚‚ : CategoryTheory.ShortComplex C} (Ο† : S₁ ⟢ Sβ‚‚) [Sβ‚‚.HasLeftHomology] [CategoryTheory.Epi Ο†.τ₁] [CategoryTheory.IsIso Ο†.Ο„β‚‚] [CategoryTheory.Mono Ο†.τ₃], S₁.HasLeftHomology
Turing.EvalsTo.mk.inj
Mathlib.Computability.TMComputable
βˆ€ {Οƒ : Type u_1} {f : Οƒ β†’ Option Οƒ} {a : Οƒ} {b : Option Οƒ} {steps : β„•} {evals_in_steps : (flip bind f)^[steps] (some a) = b} {steps_1 : β„•} {evals_in_steps_1 : (flip bind f)^[steps_1] (some a) = b}, { steps := steps, evals_in_steps := evals_in_steps } = { steps := steps_1, evals_in_steps := evals_in_steps_1 } β†’ steps = steps_1
End of preview. Expand in Data Studio

Mathlib Types

This dataset contains information about types defined in Mathlib, the mathematical library for the Lean 4 theorem prover, extracted using lean_scout.

Extracted from the Mathlib commit with the following hash:

89ec9c848cb1c5922fa50b91eb5156a46bd71e85

The dataset follows this schema:

fields:
- type:
    datatype: string
  nullable: false
  name: name
- type:
    datatype: string
  nullable: true
  name: module
- type:
    datatype: string
  nullable: false
  name: type
Downloads last month
22
Size of downloaded dataset files:
77.5 MB
Size of the auto-converted Parquet files:
77.5 MB
Number of rows:
674,264