name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | 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 ΞΌ' | true |
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 | true |
ProofWidgets.Html._sizeOf_1 | ProofWidgets.Data.Html | ProofWidgets.Html β β | false |
_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) | 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 | 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 | true |
Lean.Elab.Tactic.nonempty_to_inhabited | Mathlib.Tactic.Inhabit | (Ξ± : Sort u_1) β Nonempty Ξ± β Inhabited Ξ± | true |
AlgebraicGeometry.IsLocalIso.instIsMultiplicativeScheme | Mathlib.AlgebraicGeometry.Morphisms.LocalIso | CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsLocalIso | true |
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 | false |
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 : N... | false |
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 | true |
PadicAlgCl.valuation_p | Mathlib.NumberTheory.Padics.Complex | β (p : β) [inst : Fact (Nat.Prime p)], Valued.v βp = 1 / βp | true |
Nat.map_cast_int_atTop | Mathlib.Order.Filter.AtTopBot.Basic | Filter.map Nat.cast Filter.atTop = Filter.atTop | 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 | true |
Std.DTreeMap.contains_emptyc | Std.Data.DTreeMap.Lemmas | β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {k : Ξ±}, β
.contains k = false | 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 | 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 | 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 | false |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.nlinarithGetSquareProofs | Mathlib.Tactic.Linarith.Preprocessing | List Lean.Expr β Lean.MetaM (List Lean.Expr) | true |
Int.natCast_toNat_eq_self | Init.Data.Int.LemmasAux | β {a : β€}, βa.toNat = a β 0 β€ a | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_3.eq_4 | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound | β {n : β} (motive : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClauseAction n) β Sort u_1) (id : β)
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(pivot : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (rupHints : Array β)
(ratHints : Array (β Γ Array β)) (h_1 : Unit β motive none)
... | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_664 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
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... | true |
Lean.AxiomVal.isUnsafeEx | Lean.Declaration | Lean.AxiomVal β Bool | true |
BitVec.not_or_self | Init.Data.BitVec.Lemmas | β {w : β} (x : BitVec w), ~~~x ||| x = BitVec.allOnes w | 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 | 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 | 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 | false |
Pi.intCast_def | Mathlib.Data.Int.Cast.Pi | β {ΞΉ : Type u_1} {Ο : ΞΉ β Type u_2} [inst : (i : ΞΉ) β IntCast (Ο i)] (n : β€), βn = fun x => βn | 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 β β | false |
Lean.Lsp.FoldingRangeParams.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | β (textDocument : Lean.Lsp.TextDocumentIdentifier), sizeOf { textDocument := textDocument } = 1 + sizeOf textDocument | 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 | 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) | false |
_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) | false |
Ordinal.deriv_zero_left | Mathlib.SetTheory.Ordinal.FixedPoint | β (a : Ordinal.{u_1}), Ordinal.deriv 0 a = a | 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 | 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 β
... | true |
DomMulAct.instCancelCommMonoidOfMulOpposite.eq_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | β {M : Type u_1} [inst : CancelCommMonoid Mα΅α΅α΅], DomMulAct.instCancelCommMonoidOfMulOpposite = inst | true |
instRingFreeRing._proof_31 | Mathlib.RingTheory.FreeRing | β (Ξ± : Type u_1),
autoParam (β (n : β) (x : FreeRing Ξ±), instRingFreeRing._aux_28 Ξ± (n + 1) x = instRingFreeRing._aux_28 Ξ± n x * x)
Monoid.npow_succ._autoParam | false |
Lean.Grind.CommRing.Poly.degree | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly β β | true |
SimpleGraph.Copy.isoSubgraphMap._simp_3 | Mathlib.Combinatorics.SimpleGraph.Copy | β {Ξ± : Sort u_1} {p : Ξ± β Prop} {a' : Ξ±}, (β a, p a β§ a = a') = p a' | false |
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' := β― } | true |
Qq.Impl.unquoteExpr | Qq.Macro | Lean.Expr β Qq.Impl.UnquoteM Lean.Expr | true |
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 | false |
_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) | false |
Lean.Compiler.LCNF.ConfigOptions.mk | Lean.Compiler.LCNF.ConfigOptions | β β β β β β Bool β Bool β β β Bool β Lean.Compiler.LCNF.ConfigOptions | true |
_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... | false |
ne_zero_of_dvd_ne_zero | Mathlib.Algebra.GroupWithZero.Divisibility | β {Ξ± : Type u_1} [inst : MonoidWithZero Ξ±] {p q : Ξ±}, q β 0 β p β£ q β p β 0 | true |
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 Ξ± | 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.... | false |
Bool.dite_else_false._simp_1 | Init.PropLemmas | β {p : Prop} [inst : Decidable p] {x : p β Bool}, ((if h : p then x h else false) = true) = β (h : p), x h = true | false |
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_ring_1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro | 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)) | 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 := β― } | 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 | 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 | true |
SimpContFract.IsContFract | Mathlib.Algebra.ContinuedFractions.Basic | {Ξ± : Type u_1} β [inst : One Ξ±] β [Zero Ξ±] β [LT Ξ±] β SimpContFract Ξ± β Prop | true |
SimpleGraph.chromaticNumber_eq_iInf | Mathlib.Combinatorics.SimpleGraph.Coloring.VertexColoring | β {V : Type u} (G : SimpleGraph V), G.chromaticNumber = β¨
n, ββn | true |
Mathlib.Meta.FunProp.LambdaTheorem.getProof | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorem β Lean.MetaM Lean.Expr | 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 | 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 β―) | false |
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) β G... | 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 | false |
Finset.shadow_mono | Mathlib.Combinatorics.SetFamily.Shadow | β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {π β¬ : Finset (Finset Ξ±)}, π β β¬ β π.shadow β β¬.shadow | true |
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 | 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 | 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 | 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 | 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 | 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β | 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 | true |
_private.Lean.Meta.Match.MatchEqs.0.Lean.Meta.Match.initFn._@.Lean.Meta.Match.MatchEqs.136844199._hygCtx._hyg.2 | Lean.Meta.Match.MatchEqs | IO Unit | false |
Dyadic.neg.eq_1 | Init.Data.Dyadic.Basic | Dyadic.zero.neg = Dyadic.zero | 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 | 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 | 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... | false |
Lean.Lsp.instToJsonCodeActionClientCapabilities | Lean.Data.Lsp.CodeActions | Lean.ToJson Lean.Lsp.CodeActionClientCapabilities | 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 = β€ | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.instIsTriangulatedOppositeOpOp._proof_2 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | 1 + -1 = 0 | false |
UInt8.or_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | β {a b : UInt8}, (a ||| b = 0) = (a = 0 β§ b = 0) | 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 | 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) | true |
Finpartition.part | Mathlib.Order.Partition.Finpartition | {Ξ± : Type u_1} β [inst : DecidableEq Ξ±] β {s : Finset Ξ±} β Finpartition s β Ξ± β Finset Ξ± | 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 | 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 | 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 | 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... | 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) | false |
Nat.addUnits_eq_zero | Mathlib.Algebra.Group.Nat.Units | β (u : AddUnits β), u = 0 | true |
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 | true |
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 +... | true |
Padic.coe_one | Mathlib.NumberTheory.Padics.PadicNumbers | β (p : β) [inst : Fact (Nat.Prime p)], β1 = 1 | true |
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 | false |
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.obj}
(hf : β (i : ΞΉ), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) {i : ΞΉ},
(AlgebraicGeometry.Scheme.LocalRepresentability.yonedaG... | true |
fderivPolarCoordSymm._proof_8 | Mathlib.Analysis.SpecialFunctions.PolarCoord | FiniteDimensional β (β Γ β) | false |
RingEquiv.nonUnitalSubringCongr | Mathlib.RingTheory.NonUnitalSubring.Basic | {R : Type u} β [inst : NonUnitalRing R] β {s t : NonUnitalSubring R} β s = t β β₯s β+* β₯t | true |
UniqueFactorizationMonoid.radical_mul | Mathlib.RingTheory.Radical.Basic | β {M : Type u_1} [inst : CommMonoidWithZero 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 | true |
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe.eq_1 | Mathlib.Topology.OpenPartialHomeomorph.Basic | β {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X) (hs : Nonempty β₯s),
s.openPartialHomeomorphSubtypeCoe hs = Topology.IsOpenEmbedding.toOpenPartialHomeomorph Subtype.val β― | true |
_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) | false |
Lean.PrettyPrinter.Delaborator.OmissionReason.noConfusionType | Lean.PrettyPrinter.Delaborator.Basic | Sort u β Lean.PrettyPrinter.Delaborator.OmissionReason β Lean.PrettyPrinter.Delaborator.OmissionReason β Sort u | false |
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.
df818bb9eb19ac8bc0d33dd316b3baf5bd394cab
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: 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
- 842