name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k β | allowCompletion bool 2
classes |
|---|---|---|---|---|
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 ΞΌ' | null | true |
Lean.Parser.Tactic.ImpossibleConfig.recOn | Init.Tactics | {motive : Lean.Parser.Tactic.ImpossibleConfig β Sort u} β
(t : Lean.Parser.Tactic.ImpossibleConfig) β ((levels : Bool) β motive { levels := levels }) β motive t | null | false |
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 | null | true |
ProofWidgets.Html._sizeOf_1 | ProofWidgets.Data.Html | ProofWidgets.Html β β | null | false |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_mul_top_pos._simp_1_9 | Mathlib.Topology.Instances.EReal.Lemmas | β {Ξ± : Type u_1} [inst : LinearOrder Ξ±] {a b c : Ξ±}, (c < max a b) = (c < a β¨ c < b) | null | false |
CategoryTheory.Limits.Cone.extendHom_hom | Mathlib.CategoryTheory.Limits.Cones | β {J : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} J] {C : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} C]
{F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cone F) {X : C} (f : X βΆ s.pt), (s.extendHom f).hom = f | null | true |
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 | null | true |
_private.Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm.0.PiTensorProduct.mapL_add_smul_aux._proof_1_9 | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | β {π : Type u_4} [inst : NontriviallyNormedField π] {ΞΉ : Type u_1} {E : ΞΉ β Type u_2}
[inst_1 : (i : ΞΉ) β SeminormedAddCommGroup (E i)] [inst_2 : (i : ΞΉ) β NormedSpace π (E i)] {E' : ΞΉ β Type u_3}
[inst_3 : (i : ΞΉ) β SeminormedAddCommGroup (E' i)] [inst_4 : (i : ΞΉ) β NormedSpace π (E' i)]
(f : (i : ΞΉ) β E i β... | null | false |
Lean.Elab.Tactic.nonempty_to_inhabited | Mathlib.Tactic.Inhabit | (Ξ± : Sort u_1) β Nonempty Ξ± β Inhabited Ξ± | Derives `Inhabited Ξ±` from `Nonempty Ξ±` with `Classical.choice`. | true |
AlgebraicGeometry.IsLocalIso.instIsMultiplicativeScheme | Mathlib.AlgebraicGeometry.Morphisms.LocalIso | CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsLocalIso | null | true |
NonemptyChain.rec | Mathlib.Order.BourbakiWitt | {Ξ± : Type u_4} β
[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 : N... | null | false |
Lean.Order.iSup | Std.Internal.Order.Basic | {Ξ± : Type u} β [Lean.Order.CompleteLattice Ξ±] β {ΞΉ : Type v} β (ΞΉ β Ξ±) β Ξ± | Indexed supremum | true |
le_of_pow_le_pow_leftβ | Mathlib.Algebra.Order.GroupWithZero.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 | null | true |
PadicAlgCl.valuation_p | Mathlib.NumberTheory.Padics.Complex | β (p : β) [inst : Fact (Nat.Prime p)], Valued.v βp = 1 / βp | The valuation of `p : PadicAlgCl p` is `1/p`. | true |
Nat.map_cast_int_atTop | Mathlib.Order.Filter.AtTopBot.Basic | Filter.map Nat.cast Filter.atTop = Filter.atTop | null | true |
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 | null | true |
Std.DTreeMap.contains_emptyc | Std.Data.DTreeMap.Lemmas | β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {k : Ξ±}, β
.contains k = false | null | true |
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 | A weighted sum of the results of subtracting a default base point
from the given points, as a linear map on the weights. This is
intended to be used when the sum of the weights is 0; that condition
is specified as a hypothesis on those lemmas that require it. | true |
CategoryTheory.MorphismProperty.LeftFraction.unop_f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | β {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty Cα΅α΅} {X Y : Cα΅α΅}
(Ο : W.LeftFraction X Y), Ο.unop.f = Ο.f.unop | null | true |
MeasureTheory.AddContent.mk._flat_ctor | Mathlib.MeasureTheory.Measure.AddContent | {Ξ± : Type u_1} β
{G : Type u_2} β
[inst : AddCommMonoid G] β
{C : Set (Set Ξ±)} β
(toFun : Set Ξ± β G) β
toFun β
= 0 β
(β (I : Finset (Set Ξ±)), βI β C β (βI).PairwiseDisjoint id β ββ βI β C β toFun (ββ βI) = β u β I, toFun u) β
MeasureTheory.AddContent G C | null | false |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.nlinarithGetSquareProofs | Mathlib.Tactic.Linarith.Preprocessing | List Lean.Expr β Lean.MetaM (List Lean.Expr) | Get proofs of `-x^2 β€ 0` and `-(x*x) β€ 0`, when those terms appear in `ls` | true |
Int.natCast_toNat_eq_self | Init.Data.Int.LemmasAux | β {a : β€}, βa.toNat = a β 0 β€ a | null | true |
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.lieBra... | null | true |
Lean.AxiomVal.isUnsafeEx | Lean.Declaration | Lean.AxiomVal β Bool | null | true |
BitVec.not_or_self | Init.Data.BitVec.Lemmas | β {w : β} (x : BitVec w), ~~~x ||| x = BitVec.allOnes w | null | true |
_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)) β
(Nat.hasNotBit 256 t.ctorIdx β motive t) β motive t | null | false |
Std.ExtDHashMap.getKey?_inter_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {Ξ² : Ξ± β Type v} {mβ mβ : Std.ExtDHashMap Ξ± Ξ²} [inst : EquivBEq Ξ±]
[inst_1 : LawfulHashable Ξ±] {k : Ξ±}, k β mβ β (mβ β© mβ).getKey? k = none | null | true |
_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 | null | false |
Pi.intCast_def | Mathlib.Data.Int.Cast.Pi | β {ΞΉ : Type u_1} {Ο : ΞΉ β Type u_2} [inst : (i : ΞΉ) β IntCast (Ο i)] (n : β€), βn = fun x => βn | null | true |
CategoryTheory.ObjectProperty.ColimitOfShape._sizeOf_1 | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | {C : Type u_1} β
{inst : CategoryTheory.Category.{v_1, 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 β β | null | false |
Lean.Lsp.FoldingRangeParams.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | β (textDocument : Lean.Lsp.TextDocumentIdentifier), sizeOf { textDocument := textDocument } = 1 + sizeOf textDocument | null | true |
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 | null | true |
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) | null | false |
AlexDisc.delabOf | Mathlib.Topology.Order.Category.AlexDisc | Lean.PrettyPrinter.Delaborator.Delab | This prints `AlexDisc.of X` as `β§X`. | true |
_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) | null | false |
CategoryTheory.IsoCat.noConfusion | Mathlib.CategoryTheory.IsoCat | {P : Sort u} β
{C : Type u_1} β
{D : Type u_2} β
{inst : CategoryTheory.Category.{v_1, u_1} C} β
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} β
{t : CategoryTheory.IsoCat C D} β
{C' : Type u_1} β
{D' : Type u_2} β
{inst' : CategoryTheory.Categor... | null | false |
Ordinal.deriv_zero_left | Mathlib.SetTheory.Ordinal.FixedPoint | β (a : Ordinal.{u_1}), Ordinal.deriv 0 a = a | null | true |
Lean.Order.le_iff_meet_eq_left | Std.Internal.Order.Lemmas | β {l : Type uβ} [inst : Lean.Order.CompleteLattice l] {P Q : l},
Lean.Order.PartialOrder.rel P Q β Lean.Order.meet P Q = P | null | true |
SimpleGraph.completeEquipartiteGraph.completeMultipartiteGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | β {r t : β} {a b : Fin r Γ Fin t},
(SimpleGraph.completeMultipartiteGraph (Function.const (Fin r) (Fin t))).Adj
((Equiv.sigmaEquivProd (Fin r) (Fin t)).symm a) ((Equiv.sigmaEquivProd (Fin r) (Fin t)).symm b) β
(SimpleGraph.completeEquipartiteGraph r t).Adj a b | null | false |
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 β
... | null | true |
DomMulAct.instCancelCommMonoidOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | β {M : Type u_1} [inst : CancelCommMonoid Mα΅α΅α΅], DomMulAct.instCancelCommMonoidOfMulOpposite = inst | null | true |
instRingFreeRing._proof_31 | Mathlib.RingTheory.FreeRing | β (Ξ± : Type u_1), autoParam (β (n : β), β(n + 1) = βn + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
Lean.Grind.CommRing.Poly.degree | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.Poly β β | null | true |
SSet.horn.IsCompatible.Ξ΄_pred_comp._auto_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | Lean.Syntax | null | false |
RBTree.RBNode.Slow.instDecidableMemP | Batteries.Recycling.RBTree.Basic | {Ξ± : Type u_1} β {cut : Ξ± β Ordering} β {t : RBTree.RBNode Ξ±} β Decidable (RBTree.RBNode.MemP cut t) | null | true |
SimpleGraph.Copy.isoSubgraphMap._simp_3 | Mathlib.Combinatorics.SimpleGraph.Copy | β {Ξ± : Sort u_1} {p : Ξ± β Prop} {a' : Ξ±}, (β a, p a β§ a = a') = p a' | null | false |
Pi.addHom.eq_1 | Mathlib.Algebra.Group.Pi.Lemmas | @Pi.addHom = @AddHom.pi | null | true |
Qq.Impl.unquoteExpr | Qq.Macro | Lean.Expr β Qq.Impl.UnquoteM Lean.Expr | null | true |
_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) | null | false |
Lean.Compiler.LCNF.ConfigOptions.mk | Lean.Compiler.LCNF.ConfigOptions | β β β β β β Bool β Bool β β β Bool β Lean.Compiler.LCNF.ConfigOptions | null | true |
_private.Lean.Meta.Tactic.Grind.Parser.0.Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.grindPatternCnstrs.parenthesizer_123 | Lean.Meta.Tactic.Grind.Parser | IO Unit | null | false |
_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 : TopologicalS... | null | false |
ne_zero_of_dvd_ne_zero | Mathlib.Algebra.GroupWithZero.Divisibility | β {Ξ± : Type u_1} [inst : MonoidWithZero Ξ±] {p q : Ξ±}, q β 0 β p β£ q β p β 0 | null | true |
_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.... | null | false |
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 Ξ± | The definitionally equality tests are performed using the given transparency mode.
We claim `TransparencyMode.instances` is a good setting for most applications.
| true |
LinearMap.BilinForm.Isometry.mk | Mathlib.LinearAlgebra.BilinearForm.Isometry | {R : Type u_1} β
{Mβ : Type u_3} β
{Mβ : Type u_4} β
[inst : CommSemiring R] β
[inst_1 : AddCommMonoid Mβ] β
[inst_2 : AddCommMonoid Mβ] β
[inst_3 : Module R Mβ] β
[inst_4 : Module R Mβ] β
{Bβ : LinearMap.BilinForm R Mβ} β
{Bβ : L... | null | true |
SSet.Edge.CompStruct.toSubcomplex | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | {X : SSet} β
{xβ xβ xβ : X.obj (Opposite.op { len := 0 })} β
{eββ : SSet.Edge xβ xβ} β
{eββ : SSet.Edge xβ xβ} β
{eββ : SSet.Edge xβ xβ} β
(h : eββ.CompStruct eββ eββ) β
(A : X.Subcomplex) β
(mem : h.simplex β A.obj (Opposite.op { len := 2 })) β
(e... | When the underlying simplex of a `CompStruct` belongs to a subcomplex,
this is the induced `CompStruct` for the corresponding edges of the subcomplex. | true |
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_ring_1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro | `ring` solves equations in *commutative* (semi)rings, allowing for variables in the
exponent. If the goal is not appropriate for `ring` (e.g. not an equality) `ring_nf` will be
suggested. See also `ring1`, which fails if the goal is not an equality.
* `ring!` will use a more aggressive reducibility setting to determin... | false |
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)) | null | true |
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 := β― } | null | true |
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 | In a category in which every epimorphism is regular, we can express every epimorphism as
a coequalizer. This is not an instance because it would create an instance loop. | true |
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 | null | true |
SimpContFract.IsContFract | Mathlib.Algebra.ContinuedFractions.Basic | {Ξ± : Type u_1} β [inst : One Ξ±] β [Zero Ξ±] β [LT Ξ±] β SimpContFract Ξ± β Prop | A simple continued fraction is a *(regular) continued fraction* ((r)cf) if all partial denominators
`bα΅’` are positive, i.e. `0 < bα΅’`.
| true |
SimpleGraph.chromaticNumber_eq_iInf | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | β {V : Type u} (G : SimpleGraph V), G.chromaticNumber = β¨
n, ββn | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int64.reduceBEq._regBuiltin.Int64.reduceBEq.declare_2._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.922157756._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
AbstractMeasure.convolveFunRight_apply._proof_1 | Mathlib.NumberTheory.Padics.Measure.Monoid | β {G : Type u_1} {R : Type u_2} [inst : TopologicalSpace G] [inst_1 : TopologicalSpace R] [inst_2 : Monoid G]
[ContinuousMul G] (f : C(G, R)) (x : G), Continuous fun y => f (x * y) | null | false |
Mathlib.Meta.FunProp.LambdaTheorem.getProof | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorem β Lean.MetaM Lean.Expr | Return proof of lambda theorem | true |
_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 | null | false |
TopCat.pullbackHomeoPreimage._proof_7 | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | β {X : Type u_2} {Y : Type u_3} {Z : Type u_1} (f : X β Z) (g : Y β Z) (x : β(f β»ΒΉ' Set.range g)),
f βx = g (Exists.choose β―) | null | false |
GaloisInsertion.mk._flat_ctor | Mathlib.Order.GaloisConnection.Defs | {Ξ± : Type u_1} β
{Ξ² : Type u_2} β
[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) β G... | null | false |
_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 | null | false |
Finset.shadow_mono | Mathlib.Combinatorics.SetFamily.Shadow | β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {π β¬ : Finset (Finset Ξ±)}, π β β¬ β π.shadow β β¬.shadow | null | true |
_private.Mathlib.Topology.Algebra.Affine.0.AffineMap.isOpenEmbedding_linear_iff._simp_1_2 | Mathlib.Topology.Algebra.Affine | β {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : X ββ Y) {f : Y β Z}, Topology.IsOpenEmbedding (f β βe) = Topology.IsOpenEmbedding f | null | false |
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 | null | true |
_private.Lean.Meta.Tactic.Grind.MarkNestedSubsingletons.0.Lean.Meta.Grind.ProofOrDecidableResult.noConfusion | Lean.Meta.Tactic.Grind.MarkNestedSubsingletons | {P : Sort u} β
{t t' : Lean.Meta.Grind.ProofOrDecidableResultβ} β
t = t' β Lean.Meta.Grind.ProofOrDecidableResult.noConfusionTypeβ P t t' | null | false |
LinearMap.FiniteRangeSetoid.equiv_comp_right | Mathlib.Algebra.Module.LinearMap.FiniteRange | β {K : Type u_1} {V : Type u_2} {Vβ : Type u_3} {Vβ : Type u_4} [inst : CommRing K] [inst_1 : AddCommGroup V]
[inst_2 : Module K V] [inst_3 : AddCommGroup Vβ] [inst_4 : Module K Vβ] [inst_5 : AddCommGroup Vβ]
[inst_6 : Module K Vβ] {u : V ββ[K] Vβ} {v v' : Vβ ββ[K] Vβ}, v β v' β v ββ u β v' ββ u | null | true |
CategoryTheory.Abelian.Preradical.ΞΉ_Ο | Mathlib.CategoryTheory.Abelian.Preradical.Colon | β {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Ξ¦ : CategoryTheory.Abelian.Preradical C), CategoryTheory.CategoryStruct.comp Ξ¦.ΞΉ Ξ¦.Ο = 0 | null | true |
_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 | null | false |
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 | null | true |
Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | β {Ξ± : Type u} {instOrd : Ord Ξ±} {Ξ² : Type v} {mβ mβ : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²} [Std.TransOrd Ξ±]
(hβ : mβ.WF),
mβ.WF β
β {k : Ξ±} {fallback : Ξ²},
Std.DTreeMap.Internal.Impl.contains k mβ = false β
Std.DTreeMap.Internal.Impl.Const.getD (mβ.diff mβ β―) k fallback = fallback | null | true |
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β | null | true |
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 | null | true |
Dyadic.neg.eq_1 | Init.Data.Dyadic.Basic | Dyadic.zero.neg = Dyadic.zero | null | true |
CategoryTheory.Limits.Fan.IsLimit.mk.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | β {Ξ² : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : Ξ² β C} (t : CategoryTheory.Limits.Fan f)
(lift : (s : CategoryTheory.Limits.Fan f) β s.pt βΆ t.pt)
(fac : β (s : CategoryTheory.Limits.Fan f) (j : Ξ²), CategoryTheory.CategoryStruct.comp (lift s) (t.proj j) = s.proj j)
(uniq :
β (s : Cat... | null | true |
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 | null | true |
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 | null | true |
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],
Function.RightInverse (fun x => β¨Units.mk0 ββx β―, β―β©) fun x =>
{ val := β¨ββx, β―β©, inv := β¨β(βx)β»ΒΉ, β―β©, val_i... | null | false |
Lean.Lsp.instToJsonCodeActionClientCapabilities | Lean.Data.Lsp.CodeActions | Lean.ToJson Lean.Lsp.CodeActionClientCapabilities | null | true |
ciSup_eq_top_of_top_mem | Mathlib.Order.ConditionallyCompleteLattice.Indexed | β {Ξ± : Type u_1} {ΞΉ : Sort u_4} [inst : ConditionallyCompleteLinearOrder Ξ±] [inst_1 : OrderTop Ξ±] {f : ΞΉ β Ξ±},
β€ β Set.range f β iSup f = β€ | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.instIsTriangulatedOppositeOpOp._proof_2 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | 1 + -1 = 0 | null | false |
UInt8.or_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | β {a b : UInt8}, (a ||| b = 0) = (a = 0 β§ b = 0) | null | false |
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 | null | true |
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) | If `F` preserves pullbacks, then it preserves monomorphisms. | true |
Finpartition.part | Mathlib.Order.Partition.Finpartition | {Ξ± : Type u_1} β [inst : DecidableEq Ξ±] β {s : Finset Ξ±} β Finpartition s β Ξ± β Finset Ξ± | The part of the finpartition that `a` lies in. | true |
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 | null | true |
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 | null | true |
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 | null | true |
_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 Align... | null | false |
AddCon.coe_iInf._simp_1 | Mathlib.GroupTheory.Congruence.Defs | β {M : Type u_1} [inst : Add M] {ΞΉ : Sort u_4} (f : ΞΉ β AddCon M), β¨
i, β(f i) = β(iInf f) | null | false |
Nat.addUnits_eq_zero | Mathlib.Algebra.Group.Nat.Units | β (u : AddUnits β), u = 0 | null | true |
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 with lean_scout.
Extracted from the Mathlib commit with the following hash.
56a005855ea17e0b0958f73ec801ae140b0a1679
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
- type:
datatype: string
nullable: true
name: docString
- type:
datatype: bool
nullable: false
name: allowCompletion
Attribution
This dataset is derived from Mathlib, an open-source mathematical library developed by the leanprover-community. If you use this dataset, please cite the Mathlib paper or the Mathlib repository.
A full list of Mathlib contributors is available at: https://github.com/leanprover-community/mathlib4/graphs/contributors
- Downloads last month
- 1,236