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
CommRingCat
Mathlib.Algebra.Category.Ring.Basic
Type (u + 1)
Mathlib.Tactic.Find.Β«_aux_Mathlib_Tactic_Find___elabRules_Mathlib_Tactic_Find_command#find__1Β»
Mathlib.Tactic.Find
Lean.Elab.Command.CommandElab
_private.Mathlib.Data.Nat.Multiplicity.0.Nat.Prime.emultiplicity_choose_prime_pow_add_emultiplicity._simp_1_1
Mathlib.Data.Nat.Multiplicity
βˆ€ {Ξ± : Type u_1} {s t : Finset Ξ±}, Disjoint s t = βˆ€ ⦃a : α⦄, a ∈ t β†’ a βˆ‰ s
AffineEquiv.toAffineMap_injective
Mathlib.LinearAlgebra.AffineSpace.AffineEquiv
βˆ€ {k : Type u_1} {P₁ : Type u_2} {Pβ‚‚ : Type u_3} {V₁ : Type u_6} {Vβ‚‚ : Type u_7} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup Vβ‚‚] [inst_3 : Module k V₁] [inst_4 : Module k Vβ‚‚] [inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor Vβ‚‚ Pβ‚‚], Function.Injective AffineEquiv.toAffineMap
Computation.Bind.f.match_1
Mathlib.Data.Seq.Computation
{Ξ± : Type u_1} β†’ {Ξ² : Type u_2} β†’ (motive : Computation Ξ± βŠ• Computation Ξ² β†’ Sort u_3) β†’ (x : Computation Ξ± βŠ• Computation Ξ²) β†’ ((ca : Computation Ξ±) β†’ motive (Sum.inl ca)) β†’ ((cb : Computation Ξ²) β†’ motive (Sum.inr cb)) β†’ motive x
Std.ExtTreeSet.minD_empty
Std.Data.ExtTreeSet.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} [inst : Std.TransCmp cmp] {fallback : Ξ±}, βˆ….minD fallback = fallback
HahnSeries.instSMulZeroClass
Mathlib.RingTheory.HahnSeries.Addition
{Ξ“ : Type u_1} β†’ {R : Type u_3} β†’ [inst : PartialOrder Ξ“] β†’ {V : Type u_8} β†’ [inst_1 : Zero V] β†’ [SMulZeroClass R V] β†’ SMulZeroClass R (HahnSeries Ξ“ V)
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.unfoldMessageDataTracesContaining._unsafe_rec
Lean.Server.FileWorker.WidgetRequests
String β†’ β„• β†’ Lean.MessageData β†’ Lean.NamingContext β†’ Option Lean.MessageDataContext β†’ BaseIO (Lean.MessageData Γ— Bool)
birkhoffAverage_apply_sub_birkhoffAverage
Mathlib.Dynamics.BirkhoffSum.Average
βˆ€ {R : Type u_1} {Ξ± : Type u_2} {M : Type u_3} [inst : DivisionSemiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : Ξ± β†’ Ξ±) (g : Ξ± β†’ M) (n : β„•) (x : Ξ±), birkhoffAverage R f g n (f x) - birkhoffAverage R f g n x = (↑n)⁻¹ β€’ (g (f^[n] x) - g x)
Partrec.optionCasesOn_right
Mathlib.Computability.Partrec
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Οƒ : Type u_4} [inst : Primcodable Ξ±] [inst_1 : Primcodable Ξ²] [inst_2 : Primcodable Οƒ] {o : Ξ± β†’ Option Ξ²} {f : Ξ± β†’ Οƒ} {g : Ξ± β†’ Ξ² β†’. Οƒ}, Computable o β†’ Computable f β†’ Partrecβ‚‚ g β†’ Partrec fun a => Option.casesOn (o a) (Part.some (f a)) (g a)
Lean.InductiveVal.ctors
Lean.Declaration
Lean.InductiveVal β†’ List Lean.Name
EMetric.exists_ball_subset_ball
Mathlib.Topology.EMetricSpace.Defs
βˆ€ {Ξ± : Type u} [inst : PseudoEMetricSpace Ξ±] {x y : Ξ±} {Ξ΅ : ENNReal}, y ∈ EMetric.ball x Ξ΅ β†’ βˆƒ Ξ΅' > 0, EMetric.ball y Ξ΅' βŠ† EMetric.ball x Ξ΅
_private.Mathlib.Geometry.Manifold.PartitionOfUnity.0.IsOpen.exists_msmooth_support_eq._simp_1_2
Mathlib.Geometry.Manifold.PartitionOfUnity
βˆ€ {Ξ± : Type u} (x : Ξ±) (a b : Set Ξ±), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b)
Lean.Elab.Term.UseImplicitLambdaResult.yes.inj
Lean.Elab.Term.TermElabM
βˆ€ {expectedType expectedType_1 : Lean.Expr}, Lean.Elab.Term.UseImplicitLambdaResult.yes expectedType = Lean.Elab.Term.UseImplicitLambdaResult.yes expectedType_1 β†’ expectedType = expectedType_1
RightDerivMeasurableAux.B
Mathlib.Analysis.Calculus.FDeriv.Measurable
{F : Type u_1} β†’ [inst : NormedAddCommGroup F] β†’ [NormedSpace ℝ F] β†’ (ℝ β†’ F) β†’ Set F β†’ ℝ β†’ ℝ β†’ ℝ β†’ Set ℝ
Finset.mem_mul
Mathlib.Algebra.Group.Pointwise.Finset.Basic
βˆ€ {Ξ± : Type u_2} [inst : DecidableEq Ξ±] [inst_1 : Mul Ξ±] {s t : Finset Ξ±} {x : Ξ±}, x ∈ s * t ↔ βˆƒ y ∈ s, βˆƒ z ∈ t, y * z = x
List.head_cons_tail
Mathlib.Data.List.Basic
βˆ€ {Ξ± : Type u} (x : List Ξ±) (h : x β‰  []), x.head h :: x.tail = x
Lean.Lsp.WorkspaceEdit._sizeOf_1
Lean.Data.Lsp.Basic
Lean.Lsp.WorkspaceEdit β†’ β„•
Filter.limsSup_top
Mathlib.Order.LiminfLimsup
βˆ€ {Ξ± : Type u_1} [inst : CompleteLattice Ξ±], ⊀.limsSup = ⊀
AlgebraicGeometry.Scheme.IdealSheafData.radical_sup
Mathlib.AlgebraicGeometry.IdealSheaf.Basic
βˆ€ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData}, (I βŠ” J).radical = (I.radical βŠ” J.radical).radical
AffineSubspace.sOppSide_pointReflection
Mathlib.Analysis.Convex.Side
βˆ€ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] {s : AffineSubspace R P} {x y : P}, x ∈ s β†’ y βˆ‰ s β†’ s.SOppSide y ((AffineEquiv.pointReflection R x) y)
_private.Lean.Compiler.LCNF.SpecInfo.0.Lean.Compiler.LCNF.saveSpecParamInfo.match_7
Lean.Compiler.LCNF.SpecInfo
(motive : Lean.Compiler.LCNF.SpecParamInfo β†’ Sort u_1) β†’ (info : Lean.Compiler.LCNF.SpecParamInfo) β†’ (Unit β†’ motive Lean.Compiler.LCNF.SpecParamInfo.fixedNeutral) β†’ ((x : Lean.Compiler.LCNF.SpecParamInfo) β†’ motive x) β†’ motive info
CommGrpCat.ctorIdx
Mathlib.Algebra.Category.Grp.Basic
CommGrpCat β†’ β„•
UInt8.mul_def
Init.Data.UInt.Lemmas
βˆ€ (a b : UInt8), a * b = { toBitVec := a.toBitVec * b.toBitVec }
Matrix.toLinearEquiv'_symm_apply
Mathlib.LinearAlgebra.Matrix.ToLinearEquiv
βˆ€ {n : Type u_1} [inst : Fintype n] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : DecidableEq n] (P : Matrix n n R) (h : Invertible P), ↑(P.toLinearEquiv' h).symm = Matrix.toLin' β…ŸP
AddMonoidHom.add._proof_1
Mathlib.Algebra.Group.Hom.Basic
βˆ€ {M : Type u_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N] (f g : M β†’+ N), f 0 + g 0 = 0
FreeAddGroup.instAddGroup._proof_10
Mathlib.GroupTheory.FreeGroup.Basic
βˆ€ {Ξ± : Type u_1} (a : FreeAddGroup Ξ±), -a + a = 0
Computation.LiftRel.symm
Mathlib.Data.Seq.Computation
βˆ€ {Ξ± : Type u} (R : Ξ± β†’ Ξ± β†’ Prop), Symmetric R β†’ Symmetric (Computation.LiftRel R)
MeasureTheory.Measure.nullMeasurable_comp_snd
Mathlib.MeasureTheory.Measure.Prod
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} [inst : MeasurableSpace Ξ±] [inst_1 : MeasurableSpace Ξ²] [inst_2 : MeasurableSpace Ξ³] {ΞΌ : MeasureTheory.Measure Ξ±} {Ξ½ : MeasureTheory.Measure Ξ²} [MeasureTheory.SFinite Ξ½] [NeZero ΞΌ] {f : Ξ² β†’ Ξ³}, MeasureTheory.NullMeasurable (f ∘ Prod.snd) (ΞΌ.prod Ξ½) ↔ MeasureTheory.NullMeasurable f Ξ½
Set.inter_mul_union_subset_union
Mathlib.Algebra.Group.Pointwise.Set.Basic
βˆ€ {Ξ± : Type u_2} [inst : Mul Ξ±] {s₁ sβ‚‚ t₁ tβ‚‚ : Set Ξ±}, s₁ ∩ sβ‚‚ * (t₁ βˆͺ tβ‚‚) βŠ† s₁ * t₁ βˆͺ sβ‚‚ * tβ‚‚
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.count_support._proof_1_9
Mathlib.Combinatorics.SimpleGraph.Paths
βˆ€ {V : Type u_1} {G : SimpleGraph V} {v : V} [inst : DecidableEq V] {c : G.Walk v v} (this_1 : List.count v c.support.tail = 1), (List.findIdxs (fun x => decide (x = v)) c.support.tail)[0] + 2 ≀ c.support.length β†’ (List.findIdxs (fun x => decide (x = v)) c.support.tail)[0] + 1 < c.support.length
UInt64.toUSize_ofFin
Init.Data.UInt.Lemmas
βˆ€ (n : Fin UInt64.size), (UInt64.ofFin n).toUSize = USize.ofNat ↑n
WithZero.map'_comp
Mathlib.Algebra.GroupWithZero.WithZero
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} [inst : MulOneClass Ξ±] [inst_1 : MulOneClass Ξ²] [inst_2 : MulOneClass Ξ³] (f : Ξ± β†’* Ξ²) (g : Ξ² β†’* Ξ³), WithZero.map' (g.comp f) = (WithZero.map' g).comp (WithZero.map' f)
Filter.disjoint_prod
Mathlib.Order.Filter.Prod
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Filter Ξ±} {g : Filter Ξ²} {f' : Filter Ξ±} {g' : Filter Ξ²}, Disjoint (f Γ—Λ’ g) (f' Γ—Λ’ g') ↔ Disjoint f f' ∨ Disjoint g g'
GaloisConnection.u_eq_top
Mathlib.Order.GaloisConnection.Defs
βˆ€ {Ξ± : Type u} {Ξ² : Type v} [inst : PartialOrder Ξ±] [inst_1 : Preorder Ξ²] [inst_2 : OrderTop Ξ±] {l : Ξ± β†’ Ξ²} {u : Ξ² β†’ Ξ±}, GaloisConnection l u β†’ βˆ€ {x : Ξ²}, u x = ⊀ ↔ l ⊀ ≀ x
instDistribPNat
Mathlib.Data.PNat.Basic
Distrib β„•+
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.isFullyInvariant_iff_le_imp_isotypicComponent_le.match_1_5
Mathlib.RingTheory.SimpleModule.Isotypic
βˆ€ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S S' : Submodule R M) (e : β†₯S' ≃ₗ[R] β†₯S) (motive : (βˆƒ h, h βˆ˜β‚— S.subtype = S'.subtype βˆ˜β‚— ↑e.symm) β†’ Prop) (x : βˆƒ h, h βˆ˜β‚— S.subtype = S'.subtype βˆ˜β‚— ↑e.symm), (βˆ€ (p : M β†’β‚—[R] M) (eq : p βˆ˜β‚— S.subtype = S'.subtype βˆ˜β‚— ↑e.symm), motive β‹―) β†’ motive x
Lean.Parser.Command.structFields.formatter
Lean.Parser.Command
Lean.PrettyPrinter.Formatter
Representation.mem_invariants_iff_of_forall_mem_zpowers
Mathlib.RepresentationTheory.Invariants
βˆ€ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Group G] [inst_2 : AddCommMonoid V] [inst_3 : Module k V] (ρ : Representation k G V) (g : G), (βˆ€ (x : G), x ∈ Subgroup.zpowers g) β†’ βˆ€ (x : V), x ∈ ρ.invariants ↔ (ρ g) x = x
Lean.Grind.CommRing.Poly.combine.go.eq_def
Init.Grind.Ring.CommSolver
βˆ€ (fuel : β„•) (p₁ pβ‚‚ : Lean.Grind.CommRing.Poly), Lean.Grind.CommRing.Poly.combine.go fuel p₁ pβ‚‚ = match fuel with | 0 => p₁.concat pβ‚‚ | fuel.succ => match p₁, pβ‚‚ with | Lean.Grind.CommRing.Poly.num k₁, Lean.Grind.CommRing.Poly.num kβ‚‚ => Lean.Grind.CommRing.Poly.num (k₁ + kβ‚‚) | Lean.Grind.CommRing.Poly.num k₁, Lean.Grind.CommRing.Poly.add kβ‚‚ mβ‚‚ pβ‚‚ => (Lean.Grind.CommRing.Poly.add kβ‚‚ mβ‚‚ pβ‚‚).addConst k₁ | Lean.Grind.CommRing.Poly.add k₁ m₁ p₁, Lean.Grind.CommRing.Poly.num kβ‚‚ => (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁).addConst kβ‚‚ | Lean.Grind.CommRing.Poly.add k₁ m₁ p₁, Lean.Grind.CommRing.Poly.add kβ‚‚ mβ‚‚ pβ‚‚ => match m₁.grevlex mβ‚‚ with | Ordering.eq => have k := k₁ + kβ‚‚; bif k == 0 then Lean.Grind.CommRing.Poly.combine.go fuel p₁ pβ‚‚ else Lean.Grind.CommRing.Poly.add k m₁ (Lean.Grind.CommRing.Poly.combine.go fuel p₁ pβ‚‚) | Ordering.gt => Lean.Grind.CommRing.Poly.add k₁ m₁ (Lean.Grind.CommRing.Poly.combine.go fuel p₁ (Lean.Grind.CommRing.Poly.add kβ‚‚ mβ‚‚ pβ‚‚)) | Ordering.lt => Lean.Grind.CommRing.Poly.add kβ‚‚ mβ‚‚ (Lean.Grind.CommRing.Poly.combine.go fuel (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁) pβ‚‚)
Mathlib.Tactic.IntervalCases.Methods.bisect
Mathlib.Tactic.IntervalCases
Mathlib.Tactic.IntervalCases.Methods β†’ Lean.MVarId β†’ Subarray Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal β†’ Mathlib.Tactic.IntervalCases.Bound β†’ Mathlib.Tactic.IntervalCases.Bound β†’ Lean.Expr β†’ Lean.Expr β†’ Lean.Expr β†’ Lean.Expr β†’ Lean.Expr β†’ Lean.MetaM Unit
CategoryTheory.finCategoryOpposite
Mathlib.CategoryTheory.FinCategory.Basic
{J : Type v} β†’ [inst : CategoryTheory.SmallCategory J] β†’ [CategoryTheory.FinCategory J] β†’ CategoryTheory.FinCategory Jα΅’α΅–
Mathlib.Tactic.rflTac
Mathlib.Tactic.Relation.Rfl
Lean.Elab.Tactic.TacticM Unit
IsCompact.lt_sInf_iff_of_continuous
Mathlib.Topology.Order.Compact
βˆ€ {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : ConditionallyCompleteLinearOrder Ξ±] [inst_1 : TopologicalSpace Ξ±] [inst_2 : TopologicalSpace Ξ²] [ClosedIicTopology Ξ±] {f : Ξ² β†’ Ξ±} {K : Set Ξ²}, IsCompact K β†’ K.Nonempty β†’ ContinuousOn f K β†’ βˆ€ (y : Ξ±), y < sInf (f '' K) ↔ βˆ€ x ∈ K, y < f x
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.Builder.mk._flat_ctor
Lean.Compiler.IR.LLVMBindings
{Context : Sort u_1} β†’ {ctx : Context} β†’ USize β†’ LLVM.Builder ctx
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_6
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract
βˆ€ {newWidth : β„•}, βˆ€ curr ≀ newWidth, Β¬curr < newWidth β†’ curr = newWidth
VAddAssocClass.opposite_mid
Mathlib.Algebra.Group.Action.Opposite
βˆ€ {M : Type u_5} {N : Type u_6} [inst : Add N] [inst_1 : VAdd M N] [VAddCommClass M N N], VAddAssocClass M Nᡃᡒᡖ N
znumCoe
Mathlib.Data.Num.Basic
{Ξ± : Type u_1} β†’ [Zero Ξ±] β†’ [One Ξ±] β†’ [Add Ξ±] β†’ [Neg Ξ±] β†’ CoeHTCT ZNum Ξ±
Vector.countP_toList
Init.Data.Vector.Lemmas
βˆ€ {Ξ± : Type u_1} {n : β„•} {p : Ξ± β†’ Bool} {xs : Vector Ξ± n}, List.countP p xs.toList = Vector.countP p xs
CStarMatrix.add_mul
Mathlib.Analysis.CStarAlgebra.CStarMatrix
βˆ€ {m : Type u_1} {n : Type u_2} {A : Type u_5} {l : Type u_7} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring A] (L M : CStarMatrix l m A) (N : CStarMatrix m n A), (L + M) * N = L * N + M * N
MonoidAlgebra.instFree
Mathlib.LinearAlgebra.Finsupp.VectorSpace
βˆ€ {M : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S] [Module.Free R S], Module.Free R (MonoidAlgebra S M)
CategoryTheory.IndParallelPairPresentation
Mathlib.CategoryTheory.Limits.Indization.ParallelPair
{C : Type u₁} β†’ [inst : CategoryTheory.Category.{v₁, u₁} C] β†’ {A B : CategoryTheory.Functor Cα΅’α΅– (Type v₁)} β†’ (A ⟢ B) β†’ (A ⟢ B) β†’ Type (max u₁ (v₁ + 1))
_private.Lean.Expr.0.Lean.Expr.isLet.match_1
Lean.Expr
(motive : Lean.Expr β†’ Sort u_1) β†’ (x : Lean.Expr) β†’ ((declName : Lean.Name) β†’ (type value body : Lean.Expr) β†’ (nondep : Bool) β†’ motive (Lean.Expr.letE declName type value body nondep)) β†’ ((x : Lean.Expr) β†’ motive x) β†’ motive x
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_4
Mathlib.Analysis.MeanInequalities
βˆ€ {p q : Prop}, (Β¬(p ∨ q)) = (Β¬p ∧ Β¬q)
CategoryTheory.Functor.WellOrderInductionData.lift
Mathlib.CategoryTheory.SmallObject.WellOrderInductionData
{J : Type u} β†’ [inst : LinearOrder J] β†’ [inst_1 : SuccOrder J] β†’ {F : CategoryTheory.Functor Jα΅’α΅– (Type v)} β†’ F.WellOrderInductionData β†’ (j : J) β†’ Order.IsSuccLimit j β†’ ↑(β‹―.functor.op.comp F).sections β†’ F.obj (Opposite.op j)
AList
Mathlib.Data.List.AList
{Ξ± : Type u} β†’ (Ξ± β†’ Type v) β†’ Type (max u v)
_private.Lean.Parser.Basic.0.Lean.Parser.strAux.parse._unsafe_rec
Lean.Parser.Basic
String β†’ String β†’ String.Pos.Raw β†’ Lean.Parser.ParserContext β†’ Lean.Parser.ParserState β†’ Lean.Parser.ParserState
Std.Time.TimeZone.ZoneRules.mk._flat_ctor
Std.Time.Zoned.ZoneRules
Std.Time.TimeZone.LocalTimeType β†’ Array Std.Time.TimeZone.Transition β†’ Std.Time.TimeZone.ZoneRules
Encodable.encodeSubtype
Mathlib.Logic.Encodable.Basic
{Ξ± : Type u_1} β†’ {P : Ξ± β†’ Prop} β†’ [encA : Encodable Ξ±] β†’ { a // P a } β†’ β„•
_private.Batteries.Lean.Meta.UnusedNames.0.Lean.LocalContext.getUnusedUserNameIndex.match_1
Batteries.Lean.Meta.UnusedNames
(motive : Lean.Name.MatchUpToIndexSuffix β†’ Sort u_1) β†’ (x : Lean.Name.MatchUpToIndexSuffix) β†’ (Unit β†’ motive Lean.Name.MatchUpToIndexSuffix.exactMatch) β†’ (Unit β†’ motive Lean.Name.MatchUpToIndexSuffix.noMatch) β†’ ((i : β„•) β†’ motive (Lean.Name.MatchUpToIndexSuffix.suffixMatch i)) β†’ motive x
Topology.WithLower.toLower_lt_toLower
Mathlib.Topology.Order.LowerUpperTopology
βˆ€ {Ξ± : Type u_1} [inst : Preorder Ξ±] {x y : Ξ±}, Topology.WithLower.toLower x < Topology.WithLower.toLower y ↔ x < y
AddEquiv.toAddSemigrpIso._proof_1
Mathlib.Algebra.Category.Semigrp.Basic
βˆ€ {X Y : Type u_1} [inst : AddSemigroup X] [inst_1 : AddSemigroup Y] (e : X ≃+ Y), CategoryTheory.CategoryStruct.comp (AddSemigrp.ofHom e.toAddHom) (AddSemigrp.ofHom e.symm.toAddHom) = CategoryTheory.CategoryStruct.id (AddSemigrp.of X)
Set.instDistribLattice._proof_3
Mathlib.Data.Set.Basic
βˆ€ {Ξ± : Type u_1} (a b : Ξ± β†’ Prop), a < b ↔ a ≀ b ∧ Β¬b ≀ a
AlgEquiv.mk.injEq
Mathlib.Algebra.Algebra.Equiv
βˆ€ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] (toEquiv : A ≃ B) (map_mul' : βˆ€ (x y : A), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y) (map_add' : βˆ€ (x y : A), toEquiv.toFun (x + y) = toEquiv.toFun x + toEquiv.toFun y) (commutes' : βˆ€ (r : R), toEquiv.toFun ((algebraMap R A) r) = (algebraMap R B) r) (toEquiv_1 : A ≃ B) (map_mul'_1 : βˆ€ (x y : A), toEquiv_1.toFun (x * y) = toEquiv_1.toFun x * toEquiv_1.toFun y) (map_add'_1 : βˆ€ (x y : A), toEquiv_1.toFun (x + y) = toEquiv_1.toFun x + toEquiv_1.toFun y) (commutes'_1 : βˆ€ (r : R), toEquiv_1.toFun ((algebraMap R A) r) = (algebraMap R B) r), ({ toEquiv := toEquiv, map_mul' := map_mul', map_add' := map_add', commutes' := commutes' } = { toEquiv := toEquiv_1, map_mul' := map_mul'_1, map_add' := map_add'_1, commutes' := commutes'_1 }) = (toEquiv = toEquiv_1)
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_union._simp_1_2
Std.Data.DTreeMap.Internal.Lemmas
βˆ€ {Ξ± : Type u} {instOrd : Ord Ξ±} {a b : Ξ±}, (compare a b β‰  Ordering.eq) = ((a == b) = false)
MeasureTheory.AEEqFun.coeFn_compMeasurable
Mathlib.MeasureTheory.Function.AEEqFun
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} [inst : MeasurableSpace Ξ±] {ΞΌ : MeasureTheory.Measure Ξ±} [inst_1 : TopologicalSpace Ξ²] [inst_2 : TopologicalSpace Ξ³] [inst_3 : MeasurableSpace Ξ²] [inst_4 : TopologicalSpace.PseudoMetrizableSpace Ξ²] [inst_5 : BorelSpace Ξ²] [inst_6 : MeasurableSpace Ξ³] [inst_7 : TopologicalSpace.PseudoMetrizableSpace Ξ³] [inst_8 : OpensMeasurableSpace Ξ³] [inst_9 : SecondCountableTopology Ξ³] (g : Ξ² β†’ Ξ³) (hg : Measurable g) (f : Ξ± β†’β‚˜[ΞΌ] Ξ²), ↑(MeasureTheory.AEEqFun.compMeasurable g hg f) =ᡐ[ΞΌ] g ∘ ↑f
ofUnits_units_gc
Mathlib.Algebra.Group.Submonoid.Units
βˆ€ {M : Type u_1} [inst : Monoid M], GaloisConnection Subgroup.ofUnits Submonoid.units
_private.Mathlib.RingTheory.ZMod.UnitsCyclic.0.ZMod.isCyclic_units_iff_of_odd._simp_1_1
Mathlib.RingTheory.ZMod.UnitsCyclic
IsCyclic (ZMod 1)Λ£ = True
Module.DirectLimit.lift_injective
Mathlib.Algebra.Colimit.Module
βˆ€ {R : Type u_1} [inst : Semiring R] {ΞΉ : Type u_2} [inst_1 : Preorder ΞΉ] {G : ΞΉ β†’ Type u_3} [inst_2 : DecidableEq ΞΉ] [inst_3 : (i : ΞΉ) β†’ AddCommMonoid (G i)] [inst_4 : (i : ΞΉ) β†’ Module R (G i)] {f : (i j : ΞΉ) β†’ i ≀ j β†’ G i β†’β‚—[R] G j} {P : Type u_4} [inst_5 : AddCommMonoid P] [inst_6 : Module R P] (g : (i : ΞΉ) β†’ G i β†’β‚—[R] P) (Hg : βˆ€ (i j : ΞΉ) (hij : i ≀ j) (x : G i), (g j) ((f i j hij) x) = (g i) x) [IsDirectedOrder ΞΉ], (βˆ€ (i : ΞΉ), Function.Injective ⇑(g i)) β†’ Function.Injective ⇑(Module.DirectLimit.lift R ΞΉ G f g Hg)
NonUnitalStarAlgHom.prod_fst_snd
Mathlib.Algebra.Star.StarAlgHom
βˆ€ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : DistribMulAction R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B] [inst_5 : DistribMulAction R B] [inst_6 : Star B], (NonUnitalStarAlgHom.fst R A B).prod (NonUnitalStarAlgHom.snd R A B) = 1
mul_le_mul_iff_leftβ‚€._simp_1
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs
βˆ€ {Ξ± : Type u_1} [inst : Mul Ξ±] [inst_1 : Zero Ξ±] [inst_2 : Preorder Ξ±] {a b c : Ξ±} [MulPosMono Ξ±] [MulPosReflectLE Ξ±], 0 < a β†’ (b * a ≀ c * a) = (b ≀ c)
SetTheory.PGame.LeftMoves.match_1
Mathlib.SetTheory.PGame.Basic
(motive : SetTheory.PGame β†’ Sort u_2) β†’ (x : SetTheory.PGame) β†’ ((l Ξ² : Type u_1) β†’ (a : l β†’ SetTheory.PGame) β†’ (a_1 : Ξ² β†’ SetTheory.PGame) β†’ motive (SetTheory.PGame.mk l Ξ² a a_1)) β†’ motive x
AddAction.IsTrivialBlock.vadd_iff
Mathlib.GroupTheory.GroupAction.Blocks
βˆ€ {M : Type u_3} {Ξ± : Type u_4} [inst : AddGroup M] [inst_1 : AddAction M Ξ±] {B : Set Ξ±} (g : M), AddAction.IsTrivialBlock (g +α΅₯ B) ↔ AddAction.IsTrivialBlock B
CategoryTheory.coeComonad
Mathlib.CategoryTheory.Monad.Basic
{C : Type u₁} β†’ [inst : CategoryTheory.Category.{v₁, u₁} C] β†’ Coe (CategoryTheory.Comonad C) (CategoryTheory.Functor C C)
LLVM.buildLoad2
Lean.Compiler.IR.LLVMBindings
{ctx : LLVM.Context} β†’ LLVM.Builder ctx β†’ LLVM.LLVMType ctx β†’ LLVM.Value ctx β†’ optParam String "" β†’ BaseIO (LLVM.Value ctx)
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.count_support_of_mem._proof_1_16
Mathlib.Combinatorics.SimpleGraph.Paths
βˆ€ {V : Type u_1} {G : SimpleGraph V} {u v : V} [inst : DecidableEq V] {c : G.Walk v v}, u ∈ c.support β†’ -1 * ↑(List.count u c.support) + 1 ≀ 0 β†’ u = c.support.head β‹― β†’ List.findIdx (fun x => decide (x = u)) c.support < c.support.length
Lean.Meta.Grind.UnitLike.State
Lean.Meta.Tactic.Grind.Types
Type
CategoryTheory.NatTrans.CommShiftβ‚‚.commShift_app
Mathlib.CategoryTheory.Shift.CommShiftTwo
βˆ€ {C₁ : Type u_1} {Cβ‚‚ : Type u_3} {D : Type u_5} {inst : CategoryTheory.Category.{v_1, u_1} C₁} {inst_1 : CategoryTheory.Category.{v_3, u_3} Cβ‚‚} {inst_2 : CategoryTheory.Category.{v_5, u_5} D} {M : Type u_6} {inst_3 : AddCommMonoid M} {inst_4 : CategoryTheory.HasShift C₁ M} {inst_5 : CategoryTheory.HasShift Cβ‚‚ M} {inst_6 : CategoryTheory.HasShift D M} {G₁ Gβ‚‚ : CategoryTheory.Functor C₁ (CategoryTheory.Functor Cβ‚‚ D)} {Ο„ : G₁ ⟢ Gβ‚‚} {h : CategoryTheory.CommShiftβ‚‚Setup D M} {inst_7 : G₁.CommShiftβ‚‚ h} {inst_8 : Gβ‚‚.CommShiftβ‚‚ h} [self : CategoryTheory.NatTrans.CommShiftβ‚‚ Ο„ h] (X₁ : C₁), CategoryTheory.NatTrans.CommShift (Ο„.app X₁) M
OmegaCompletePartialOrder.ContinuousHom.bind._proof_1
Mathlib.Order.OmegaCompletePartialOrder
βˆ€ {Ξ± : Type u_2} [inst : OmegaCompletePartialOrder Ξ±] {Ξ² Ξ³ : Type u_1} (f : Ξ± →𝒄 Part Ξ²) (g : Ξ± →𝒄 Ξ² β†’ Part Ξ³) (c : OmegaCompletePartialOrder.Chain Ξ±), ((↑f).partBind g.toOrderHom).toFun (OmegaCompletePartialOrder.Ο‰Sup c) = OmegaCompletePartialOrder.Ο‰Sup (c.map ((↑f).partBind g.toOrderHom))
Std.DTreeMap.self_le_maxKeyD_insert
Std.Data.DTreeMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.DTreeMap Ξ± Ξ² cmp} [Std.TransCmp cmp] {k : Ξ±} {v : Ξ² k} {fallback : Ξ±}, (cmp k ((t.insert k v).maxKeyD fallback)).isLE = true
Multiset.inter_le_ndinter
Mathlib.Data.Multiset.FinsetOps
βˆ€ {Ξ± : Type u_1} [inst : DecidableEq Ξ±] (s t : Multiset Ξ±), s ∩ t ≀ s.ndinter t
Finset.min'_subset
Mathlib.Data.Finset.Max
βˆ€ {Ξ± : Type u_2} [inst : LinearOrder Ξ±] {s t : Finset Ξ±} (H : s.Nonempty) (hst : s βŠ† t), t.min' β‹― ≀ s.min' H
Multiset.prod_toList
Mathlib.Algebra.BigOperators.Group.Multiset.Defs
βˆ€ {M : Type u_3} [inst : CommMonoid M] (s : Multiset M), s.toList.prod = s.prod
Associates.exists_non_zero_rep
Mathlib.Algebra.GroupWithZero.Associated
βˆ€ {M : Type u_1} [inst : MonoidWithZero M] {a : Associates M}, a β‰  0 β†’ βˆƒ a0, a0 β‰  0 ∧ Associates.mk a0 = a
CategoryTheory.BasedFunctor._aux_Mathlib_CategoryTheory_FiberedCategory_BasedCategory___unexpand_CategoryTheory_BasedFunctor_id_1
Mathlib.CategoryTheory.FiberedCategory.BasedCategory
Lean.PrettyPrinter.Unexpander
Orientation.definition._@.Mathlib.Analysis.InnerProductSpace.TwoDim.2712757639._hygCtx._hyg.2
Mathlib.Analysis.InnerProductSpace.TwoDim
{E : Type u_1} β†’ [inst : NormedAddCommGroup E] β†’ [inst_1 : InnerProductSpace ℝ E] β†’ [Fact (Module.finrank ℝ E = 2)] β†’ Orientation ℝ E (Fin 2) β†’ E ≃ₗᡒ[ℝ] E
Std.Time.ZonedDateTime.nowAt
Std.Time.Zoned
String β†’ IO Std.Time.ZonedDateTime
Std.HashSet.Raw.size
Std.Data.HashSet.Raw
{Ξ± : Type u} β†’ Std.HashSet.Raw Ξ± β†’ β„•
CategoryTheory.Functor.essImage.counit_isIso
Mathlib.CategoryTheory.Adjunction.Reflective
βˆ€ {C : Type u₁} {D : Type uβ‚‚} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} D] {j : CategoryTheory.Functor C D} [inst_2 : CategoryTheory.Coreflective j] {A : D}, j.essImage A β†’ CategoryTheory.IsIso ((CategoryTheory.coreflectorAdjunction j).counit.app A)
Lean.Data.Trie.find?
Lean.Data.Trie
{Ξ± : Type} β†’ Lean.Data.Trie Ξ± β†’ String β†’ Option Ξ±
Array.erase_comm
Init.Data.Array.Erase
βˆ€ {Ξ± : Type u_1} [inst : BEq Ξ±] [LawfulBEq Ξ±] (a b : Ξ±) {xs : Array Ξ±}, (xs.erase a).erase b = (xs.erase b).erase a
_private.Mathlib.Algebra.QuadraticDiscriminant.0.quadratic_eq_zero_iff._simp_1_5
Mathlib.Algebra.QuadraticDiscriminant
βˆ€ {Mβ‚€ : Type u_1} [inst : MonoidWithZero Mβ‚€] {a : Mβ‚€} [NoZeroDivisors Mβ‚€] (n : β„•), a β‰  0 β†’ (a ^ n = 0) = False
Real.tendsto_pow_mul_exp_neg_atTop_nhds_zero
Mathlib.Analysis.SpecialFunctions.Exp
βˆ€ (n : β„•), Filter.Tendsto (fun x => x ^ n * Real.exp (-x)) Filter.atTop (nhds 0)
Lean.IR.EmitC.emitReuse
Lean.Compiler.IR.EmitC
Lean.IR.VarId β†’ Lean.IR.VarId β†’ Lean.IR.CtorInfo β†’ Bool β†’ Array Lean.IR.Arg β†’ Lean.IR.EmitC.M Unit
Std.LinearPreorderPackage.ofOrd._proof_4
Init.Data.Order.PackageFactories
βˆ€ (Ξ± : Type u_1) (args : Std.Packages.LinearPreorderOfOrdArgs Ξ±), Std.IsPreorder Ξ±
Std.ExtDTreeMap.mem_keys
Std.Data.ExtDTreeMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.ExtDTreeMap Ξ± Ξ² cmp} [Std.LawfulEqCmp cmp] [inst : Std.TransCmp cmp] {k : Ξ±}, k ∈ t.keys ↔ k ∈ t
uniformity_lift_le_comp
Mathlib.Topology.UniformSpace.Defs
βˆ€ {Ξ± : Type ua} {Ξ² : Type ub} [inst : UniformSpace Ξ±] {f : SetRel Ξ± Ξ± β†’ Filter Ξ²}, Monotone f β†’ ((uniformity Ξ±).lift fun s => f (SetRel.comp s s)) ≀ (uniformity Ξ±).lift f
CategoryTheory.Presheaf.isLimitOfIsSheaf._proof_1
Mathlib.CategoryTheory.Sites.Sheaf
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cα΅’α΅– A) {X : C} (S : J.Cover X) (hP : CategoryTheory.Presheaf.IsSheaf J P) (E : CategoryTheory.Limits.Cone (S.index P).multicospan) (j : CategoryTheory.Limits.WalkingMulticospan S.shape), CategoryTheory.CategoryStruct.comp (hP.amalgamate S (fun x => CategoryTheory.Limits.Multifork.ΞΉ E x) β‹―) ((S.multifork P).Ο€.app j) = E.Ο€.app j
Std.DHashMap.Raw.Const.get!_union_of_not_mem_right
Std.Data.DHashMap.RawLemmas
βˆ€ {Ξ± : Type u} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {Ξ² : Type v} {m₁ mβ‚‚ : Std.DHashMap.Raw Ξ± fun x => Ξ²} [EquivBEq Ξ±] [LawfulHashable Ξ±] [inst_4 : Inhabited Ξ²], m₁.WF β†’ mβ‚‚.WF β†’ βˆ€ {k : Ξ±}, k βˆ‰ mβ‚‚ β†’ Std.DHashMap.Raw.Const.get! (m₁ βˆͺ mβ‚‚) k = Std.DHashMap.Raw.Const.get! m₁ k
GrpWithZero
Mathlib.Algebra.Category.GrpWithZero
Type (u_1 + 1)