name
string | module
string | type
string |
|---|---|---|
Int.le_iff_lt_or_eq
|
Init.Data.Int.Order
|
β {a b : β€}, a β€ b β a < b β¨ a = b
|
CategoryTheory.Idempotents.instIsIdempotentCompleteCosimplicialObject
|
Mathlib.CategoryTheory.Idempotents.SimplicialObject
|
β {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.IsIdempotentComplete C],
CategoryTheory.IsIdempotentComplete (CategoryTheory.CosimplicialObject C)
|
LieHom._sizeOf_1
|
Mathlib.Algebra.Lie.Basic
|
{R : Type u_1} β
{L : Type u_2} β
{L' : Type u_3} β
{inst : CommRing R} β
{inst_1 : LieRing L} β
{inst_2 : LieAlgebra R L} β
{inst_3 : LieRing L'} β
{inst_4 : LieAlgebra R L'} β [SizeOf R] β [SizeOf L] β [SizeOf L'] β (L βββ
Rβ L') β β
|
Vector.zipWith_replicate
|
Init.Data.Vector.Zip
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ±_1 : Type u_3} {f : Ξ± β Ξ² β Ξ±_1} {a : Ξ±} {b : Ξ²} {n : β},
Vector.zipWith f (Vector.replicate n a) (Vector.replicate n b) = Vector.replicate n (f a b)
|
IsSelfAdjoint.conjugate'
|
Mathlib.Algebra.Star.SelfAdjoint
|
β {R : Type u_1} [inst : Semigroup R] [inst_1 : StarMul R] {x : R},
IsSelfAdjoint x β β (z : R), IsSelfAdjoint (star z * x * z)
|
Int.reduceNe._regBuiltin.Int.reduceNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.625502844._hygCtx._hyg.22
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int
|
IO Unit
|
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.Key.noConfusionType
|
Lean.Meta.Tactic.Grind.MBTC
|
Sort u β Lean.Meta.Grind.Keyβ β Lean.Meta.Grind.Keyβ β Sort u
|
_private.Mathlib.RingTheory.Unramified.Locus.0.Algebra.unramifiedLocus_eq_compl_support._simp_1_2
|
Mathlib.RingTheory.Unramified.Locus
|
β {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R}, (p β Module.support R M) = Subsingleton (LocalizedModule p.asIdeal.primeCompl M)
|
ZNum.decidableLT
|
Mathlib.Data.Num.Basic
|
DecidableLT ZNum
|
CompHausLike.LocallyConstant.sigmaComparison_comp_sigmaIso
|
Mathlib.Condensed.Discrete.LocallyConstant
|
β {P : TopCat β Prop} [inst : β (S : CompHausLike P) (p : βS.toTop β Prop), CompHausLike.HasProp P (Subtype p)]
{Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (βQ.toTop) Z) (a : Function.Fiber βr)
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P]
(X : CategoryTheory.Functor (CompHausLike P)α΅α΅ (Type (max u w))),
CategoryTheory.CategoryStruct.comp (X.mapIso (CompHausLike.LocallyConstant.sigmaIso r).op).hom
(CategoryTheory.CategoryStruct.comp
(CompHausLike.sigmaComparison X fun a => β(CompHausLike.LocallyConstant.fiber r a).toTop) fun g => g a) =
X.map (CompHausLike.LocallyConstant.sigmaIncl r a).op
|
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM.0.Lean.Meta.Grind.Arith.CommRing.setTermSemiringId.match_1
|
Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM
|
(motive : Option β β Sort u_1) β
(__do_lift : Option β) β
((semiringId' : β) β motive (some semiringId')) β ((x : Option β) β motive x) β motive __do_lift
|
Array.range'_append_1
|
Init.Data.Array.Range
|
β {s m n : β}, Array.range' s m ++ Array.range' (s + m) n = Array.range' s (m + n)
|
Finset.prod_prod_Ioi_mul_eq_prod_prod_off_diag
|
Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite
|
β {Ξ± : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : LinearOrder Ξ±] [inst_2 : Fintype Ξ±]
[inst_3 : LocallyFiniteOrderTop Ξ±] [LocallyFiniteOrderBot Ξ±] (f : Ξ± β Ξ± β M),
β i, β j β Finset.Ioi i, f j i * f i j = β i, β j β {i}αΆ, f j i
|
NonUnitalNonAssocRing.toHasDistribNeg._proof_3
|
Mathlib.Algebra.Ring.Defs
|
β {Ξ± : Type u_1} [inst : NonUnitalNonAssocRing Ξ±] (a b : Ξ±), a * -b = -(a * b)
|
FundamentalGroupoid.instSubsingletonHomPUnit
|
Mathlib.AlgebraicTopology.FundamentalGroupoid.PUnit
|
β {x y : FundamentalGroupoid PUnit.{u_1 + 1}}, Subsingleton (x βΆ y)
|
_private.Mathlib.Analysis.SpecificLimits.Normed.0.Monotone.tendsto_le_alternating_series._simp_1_2
|
Mathlib.Analysis.SpecificLimits.Normed
|
β {Ξ± : Type u} [inst : AddGroup Ξ±] [inst_1 : LE Ξ±] [AddRightMono Ξ±] {a b c : Ξ±}, (a - c β€ b) = (a β€ b + c)
|
Submonoid.LocalizationMap.mulEquivOfMulEquiv
|
Mathlib.GroupTheory.MonoidLocalization.Basic
|
{M : Type u_1} β
[inst : CommMonoid M] β
{S : Submonoid M} β
{N : Type u_2} β
[inst_1 : CommMonoid N] β
{P : Type u_3} β
[inst_2 : CommMonoid P] β
S.LocalizationMap N β
{T : Submonoid P} β
{Q : Type u_4} β
[inst_3 : CommMonoid Q] β
T.LocalizationMap Q β {j : M β* P} β Submonoid.map j.toMonoidHom S = T β N β* Q
|
_private.Mathlib.Dynamics.TopologicalEntropy.NetEntropy.0.Dynamics.coverMincard_le_netMaxcard._simp_1_5
|
Mathlib.Dynamics.TopologicalEntropy.NetEntropy
|
β {a b : Prop}, (Β¬(a β§ b)) = (a β Β¬b)
|
Submodule.finiteDimensional_iSup
|
Mathlib.LinearAlgebra.FiniteDimensional.Basic
|
β {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ΞΉ : Sort u_1}
[Finite ΞΉ] (S : ΞΉ β Submodule K V) [β (i : ΞΉ), FiniteDimensional K β₯(S i)], FiniteDimensional K β₯(β¨ i, S i)
|
LieSubmodule.ext
|
Mathlib.Algebra.Lie.Submodule
|
β {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (β (m : M), m β N β m β N') β N = N'
|
SetTheory.PGame.sub_self_equiv
|
Mathlib.SetTheory.PGame.Algebra
|
β (x : SetTheory.PGame), x - x β 0
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.clzAuxRec_le._proof_1_1
|
Init.Data.BitVec.Lemmas
|
Β¬1 < 2 β False
|
Lean.StructureDescr.fields
|
Lean.Structure
|
Lean.StructureDescr β Array Lean.StructureFieldInfo
|
FirstOrder.Language.DirectLimit.inductionOn
|
Mathlib.ModelTheory.DirectLimit
|
β {L : FirstOrder.Language} {ΞΉ : Type v} [inst : Preorder ΞΉ] {G : ΞΉ β Type w} [inst_1 : (i : ΞΉ) β L.Structure (G i)]
{f : (i j : ΞΉ) β i β€ j β L.Embedding (G i) (G j)} [inst_2 : IsDirectedOrder ΞΉ]
[inst_3 : DirectedSystem G fun i j h => β(f i j h)] [inst_4 : Nonempty ΞΉ]
{C : FirstOrder.Language.DirectLimit G f β Prop} (z : FirstOrder.Language.DirectLimit G f),
(β (i : ΞΉ) (x : G i), C ((FirstOrder.Language.DirectLimit.of L ΞΉ G f i) x)) β C z
|
mul_mem_ball_iff_norm
|
Mathlib.Analysis.Normed.Group.Basic
|
β {E : Type u_5} [inst : SeminormedCommGroup E] {a b : E} {r : β}, a * b β Metric.ball a r β βbβ < r
|
_private.Batteries.Data.String.Lemmas.0.String.Legacy.instDecidableEqIterator.decEq.match_1.splitter
|
Batteries.Data.String.Lemmas
|
(motive : String.Legacy.Iterator β String.Legacy.Iterator β Sort u_1) β
(x x_1 : String.Legacy.Iterator) β
((a : String) β
(a_1 : String.Pos.Raw) β
(b : String) β (b_1 : String.Pos.Raw) β motive { s := a, i := a_1 } { s := b, i := b_1 }) β
motive x x_1
|
CategoryTheory.Limits.Types.TypeMax.colimitCocone
|
Mathlib.CategoryTheory.Limits.Types.Colimits
|
{J : Type v} β
[inst : CategoryTheory.Category.{w, v} J] β
(F : CategoryTheory.Functor J (Type (max v u))) β CategoryTheory.Limits.Cocone F
|
disjoint_of_subsingleton._simp_1
|
Mathlib.Order.Disjoint
|
β {Ξ± : Type u_1} [inst : PartialOrder Ξ±] [inst_1 : OrderBot Ξ±] {a b : Ξ±} [Subsingleton Ξ±], Disjoint a b = True
|
SetTheory.PGame.Relabelling.isEmpty
|
Mathlib.SetTheory.PGame.Basic
|
(x : SetTheory.PGame) β [IsEmpty x.LeftMoves] β [IsEmpty x.RightMoves] β x.Relabelling 0
|
_private.Std.Data.Iterators.Lemmas.Equivalence.HetT.0.Std.Iterators.HetT.pmap_map._simp_1_1
|
Std.Data.Iterators.Lemmas.Equivalence.HetT
|
β {m : Type w β Type w'} [inst : Monad m] [LawfulMonad m] {Ξ± : Type v} {x y : Std.Iterators.HetT m Ξ±},
(x = y) =
β (h : x.Property = y.Property),
β (Ξ² : Type w) (f : (a : Ξ±) β x.Property a β m Ξ²), x.prun f = y.prun fun a ha => f a β―
|
_private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowLocalThms._regBuiltin._private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowLocalThms_1
|
Lean.Elab.Tactic.Grind.ShowState
|
IO Unit
|
CategoryTheory.Localization.inverts
|
Mathlib.CategoryTheory.Localization.Predicate
|
β {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_5, u_2} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [L.IsLocalization W], W.IsInvertedBy L
|
Set.iUnionβ_inter
|
Mathlib.Data.Set.Lattice
|
β {Ξ± : Type u_1} {ΞΉ : Sort u_5} {ΞΊ : ΞΉ β Sort u_8} (s : (i : ΞΉ) β ΞΊ i β Set Ξ±) (t : Set Ξ±),
(β i, β j, s i j) β© t = β i, β j, s i j β© t
|
_private.Mathlib.Order.WithBot.0.WithBot.noMaxOrder.match_1
|
Mathlib.Order.WithBot
|
β {Ξ± : Type u_1} [inst : LT Ξ±] (a : Ξ±) (motive : (β b, a < b) β Prop) (x : β b, a < b),
(β (b : Ξ±) (hba : a < b), motive β―) β motive x
|
CategoryTheory.Functor.OplaxRightLinear.noConfusion
|
Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor
|
{D : Type u_1} β
{D' : Type u_2} β
[inst : CategoryTheory.Category.{u_4, u_1} D] β
[inst_1 : CategoryTheory.Category.{u_5, u_2} D'] β
{F : CategoryTheory.Functor D D'} β
{C : Type u_3} β
[inst_2 : CategoryTheory.Category.{u_6, u_3} C] β
[inst_3 : CategoryTheory.MonoidalCategory C] β
[inst_4 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] β
[inst_5 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D'] β
{P : Sort u} β
{x1 x2 : F.OplaxRightLinear C} β
x1 = x2 β CategoryTheory.Functor.OplaxRightLinear.noConfusionType P x1 x2
|
TopologicalSpace.instWellFoundedLTClosedsOfNoetherianSpace
|
Mathlib.Topology.NoetherianSpace
|
β {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] [TopologicalSpace.NoetherianSpace Ξ±],
WellFoundedLT (TopologicalSpace.Closeds Ξ±)
|
Finset.erase_val
|
Mathlib.Data.Finset.Erase
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] (s : Finset Ξ±) (a : Ξ±), (s.erase a).val = s.val.erase a
|
BddDistLat.Iso.mk._proof_3
|
Mathlib.Order.Category.BddDistLat
|
β {Ξ± Ξ² : BddDistLat} (e : βΞ±.toDistLat βo βΞ².toDistLat) (a b : βΞ±.1),
{ toFun := βe, map_sup' := β―, map_inf' := β― }.toFun (a β b) =
{ toFun := βe, map_sup' := β―, map_inf' := β― }.toFun a β { toFun := βe, map_sup' := β―, map_inf' := β― }.toFun b
|
SimpleGraph.Walk.ofBoxProdLeft._proof_2
|
Mathlib.Combinatorics.SimpleGraph.Prod
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {H : SimpleGraph Ξ²} {x : Ξ± Γ Ξ²} (v : Ξ± Γ Ξ²), H.Adj x.2 v.2 β§ x.1 = v.1 β v.1 = x.1
|
List.isEqv.eq_2
|
Init.Data.List.Lemmas
|
β {Ξ± : Type u} (x : Ξ± β Ξ± β Bool) (a : Ξ±) (as : List Ξ±) (b : Ξ±) (bs : List Ξ±),
(a :: as).isEqv (b :: bs) x = (x a b && as.isEqv bs x)
|
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.instHashableKey.hash.match_1
|
Lean.Meta.Tactic.Grind.MBTC
|
(motive : Lean.Meta.Grind.Keyβ β Sort u_1) β
(x : Lean.Meta.Grind.KeyβΒΉ) β ((a : Lean.Expr) β motive { mask := a }) β motive x
|
AffineBasis.instInhabitedPUnit._proof_1
|
Mathlib.LinearAlgebra.AffineSpace.Basis
|
β {k : Type u_1} [inst : Ring k], AffineIndependent k id
|
CategoryTheory.Abelian.im
|
Mathlib.CategoryTheory.Abelian.Basic
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
[CategoryTheory.Abelian C] β CategoryTheory.Functor (CategoryTheory.Arrow C) C
|
MonoidHom.exists_nhds_isBounded
|
Mathlib.MeasureTheory.Measure.Haar.NormedSpace
|
β {G : Type u_1} {H : Type u_2} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : TopologicalSpace G]
[IsTopologicalGroup G] [BorelSpace G] [LocallyCompactSpace G] [inst_6 : MeasurableSpace H]
[inst_7 : SeminormedGroup H] [OpensMeasurableSpace H] (f : G β* H),
Measurable βf β β (x : G), β s β nhds x, Bornology.IsBounded (βf '' s)
|
QuotientGroup.equivQuotientZPowOfEquiv_symm
|
Mathlib.GroupTheory.QuotientGroup.Basic
|
β {A B : Type u} [inst : CommGroup A] [inst_1 : CommGroup B] (e : A β* B) (n : β€),
(QuotientGroup.equivQuotientZPowOfEquiv e n).symm = QuotientGroup.equivQuotientZPowOfEquiv e.symm n
|
Lean.Lsp.RpcConnected.casesOn
|
Lean.Data.Lsp.Extra
|
{motive : Lean.Lsp.RpcConnected β Sort u} β
(t : Lean.Lsp.RpcConnected) β ((sessionId : UInt64) β motive { sessionId := sessionId }) β motive t
|
Measure.eq_prod_of_integral_prod_mul_boundedContinuousFunction
|
Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd
|
β {ΞΉ : Type u_1} {T : Type u_4} [inst : Fintype ΞΉ] {X : ΞΉ β Type u_5} {mX : (i : ΞΉ) β MeasurableSpace (X i)}
[inst_1 : (i : ΞΉ) β TopologicalSpace (X i)] [β (i : ΞΉ), BorelSpace (X i)] [β (i : ΞΉ), HasOuterApproxClosed (X i)]
{mT : MeasurableSpace T} [inst_4 : TopologicalSpace T] [BorelSpace T] [HasOuterApproxClosed T]
{ΞΌ : MeasureTheory.Measure ((i : ΞΉ) β X i)} {Ξ½ : MeasureTheory.Measure T}
{ΞΎ : MeasureTheory.Measure (((i : ΞΉ) β X i) Γ T)} [MeasureTheory.IsFiniteMeasure ΞΌ] [MeasureTheory.IsFiniteMeasure Ξ½]
[MeasureTheory.IsFiniteMeasure ΞΎ],
(β (f : (i : ΞΉ) β BoundedContinuousFunction (X i) β) (g : BoundedContinuousFunction T β),
β« (p : ((i : ΞΉ) β X i) Γ T), (β i, (f i) (p.1 i)) * g p.2 βΞΎ =
(β« (x : (i : ΞΉ) β X i), β i, (f i) (x i) βΞΌ) * β« (t : T), g t βΞ½) β
ΞΎ = ΞΌ.prod Ξ½
|
IsApproximateSubgroup.subgroup
|
Mathlib.Combinatorics.Additive.ApproximateSubgroup
|
β {G : Type u_1} [inst : Group G] {S : Type u_2} [inst_1 : SetLike S G] [SubgroupClass S G] {H : S},
IsApproximateSubgroup 1 βH
|
symmetrizeRel_subset_self
|
Mathlib.Topology.UniformSpace.Defs
|
β {Ξ± : Type ua} (V : SetRel Ξ± Ξ±), symmetrizeRel V β V
|
Sylow.mulEquivIteratedWreathProduct._proof_3
|
Mathlib.GroupTheory.RegularWreathProduct
|
β (p n : β) (Ξ± : Type u_2) [inst : Finite Ξ±] (hΞ± : Nat.card Ξ± = p ^ n) (G : Type u_1) [inst_1 : Group G]
[inst_2 : Finite G] (hG : Nat.card G = p),
Function.Injective
(β((Finite.equivFinOfCardEq hΞ±).trans (Finite.equivFinOfCardEq β―).symm).symm.permCongrHom.toEquiv β
β(iteratedWreathToPermHom G n))
|
LocallyFiniteOrder.toLocallyFiniteOrderBot._proof_2
|
Mathlib.Order.Interval.Finset.Defs
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] [inst_1 : OrderBot Ξ±] [inst_2 : LocallyFiniteOrder Ξ±] (a x : Ξ±),
x β Finset.Ico β₯ a β x < a
|
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedTotalDegree'_eq_bot_iff._simp_1_4
|
Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
|
β {Ξ± : Type u_1} {a : Ξ±}, (βa = β₯) = False
|
instAddRightCancelMonoidOrderDual
|
Mathlib.Algebra.Order.Group.Synonym
|
{Ξ± : Type u_1} β [h : AddRightCancelMonoid Ξ±] β AddRightCancelMonoid Ξ±α΅α΅
|
PadicInt.norm_intCast_lt_one_iff
|
Mathlib.NumberTheory.Padics.PadicIntegers
|
β {p : β} [hp : Fact (Nat.Prime p)] {z : β€}, ββzβ < 1 β βp β£ z
|
_private.Lean.Widget.UserWidget.0.Lean.Widget.builtinModulesRef
|
Lean.Widget.UserWidget
|
IO.Ref (Std.TreeMap UInt64 (Lean.Name Γ Lean.Widget.Module) compare)
|
LieSubalgebra.span_univ
|
Mathlib.Algebra.Lie.Subalgebra
|
β (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieSubalgebra.lieSpan R L Set.univ = β€
|
CategoryTheory.Lax.OplaxTrans.mk.sizeOf_spec
|
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax
|
β {B : Type uβ} [inst : CategoryTheory.Bicategory B] {C : Type uβ} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C] (app : (a : B) β F.obj a βΆ G.obj a)
(naturality :
{a b : B} β
(f : a βΆ b) β
CategoryTheory.CategoryStruct.comp (F.map f) (app b) βΆ CategoryTheory.CategoryStruct.comp (app a) (G.map f))
(naturality_naturality :
autoParam
(β {a b : B} {f g : a βΆ b} (Ξ· : f βΆ g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapβ Ξ·) (app b)) (naturality g) =
CategoryTheory.CategoryStruct.comp (naturality f) (CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapβ Ξ·)))
CategoryTheory.Lax.OplaxTrans.naturality_naturality._autoParam)
(naturality_id :
autoParam
(β (a : B),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapId a) (app a))
(naturality (CategoryTheory.CategoryStruct.id a)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (app a)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor (app a)).inv
(CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapId a))))
CategoryTheory.Lax.OplaxTrans.naturality_id._autoParam)
(naturality_comp :
autoParam
(β {a b c : B} (f : a βΆ b) (g : b βΆ c),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapComp f g) (app c))
(naturality (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (F.map g) (app c)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (naturality g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (app b) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (naturality f) (G.map g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (app a) (G.map f) (G.map g)).hom
(CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapComp f g)))))))
CategoryTheory.Lax.OplaxTrans.naturality_comp._autoParam),
sizeOf
{ app := app, naturality := naturality, naturality_naturality := naturality_naturality,
naturality_id := naturality_id, naturality_comp := naturality_comp } =
1
|
Batteries.BinomialHeap.merge.match_1
|
Batteries.Data.BinomialHeap.Basic
|
{Ξ± : Type u_1} β
{le : Ξ± β Ξ± β Bool} β
(motive : Batteries.BinomialHeap Ξ± le β Batteries.BinomialHeap Ξ± le β Sort u_2) β
(x x_1 : Batteries.BinomialHeap Ξ± le) β
((bβ : Batteries.BinomialHeap.Imp.Heap Ξ±) β
(hβ : Batteries.BinomialHeap.Imp.Heap.WF le 0 bβ) β
(bβ : Batteries.BinomialHeap.Imp.Heap Ξ±) β
(hβ : Batteries.BinomialHeap.Imp.Heap.WF le 0 bβ) β motive β¨bβ, hββ© β¨bβ, hββ©) β
motive x x_1
|
Lean.Doc.instImpl._@.Lean.Elab.DocString.Builtin.Postponed.1250074310._hygCtx._hyg.32
|
Lean.Elab.DocString.Builtin.Postponed
|
TypeName Lean.Doc.PostponedCheck
|
List.min_replicate
|
Init.Data.List.MinMax
|
β {Ξ± : Type u_1} [inst : Min Ξ±] [Std.MinEqOr Ξ±] {n : β} {a : Ξ±} (h : List.replicate n a β []),
(List.replicate n a).min h = a
|
_private.Aesop.Tree.Tracing.0.Aesop.Goal.traceMetadata.match_1
|
Aesop.Tree.Tracing
|
(motive : Option (Lean.MVarId Γ Lean.Meta.SavedState) β Sort u_1) β
(x : Option (Lean.MVarId Γ Lean.Meta.SavedState)) β
(Unit β motive none) β
((goal : Lean.MVarId) β (state : Lean.Meta.SavedState) β motive (some (goal, state))) β motive x
|
Valuation.IsEquiv.orderRingIso.congr_simp
|
Mathlib.Topology.Algebra.Valued.WithVal
|
β {R : Type u_4} {Ξβ : Type u_5} {Ξβ' : Type u_6} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Ξβ]
[inst_2 : LinearOrderedCommGroupWithZero Ξβ'] {v : Valuation R Ξβ} {w : Valuation R Ξβ'} (h : v.IsEquiv w),
h.orderRingIso = h.orderRingIso
|
_private.Mathlib.Algebra.Group.TypeTags.Basic.0.isRegular_toMul._simp_1_2
|
Mathlib.Algebra.Group.TypeTags.Basic
|
β {R : Type u_1} [inst : Mul R] {c : R}, IsRegular c = (IsLeftRegular c β§ IsRightRegular c)
|
Nat.mul_pos_iff_of_pos_left
|
Init.Data.Nat.Lemmas
|
β {a b : β}, 0 < a β (0 < a * b β 0 < b)
|
LinOrd.instConcreteCategoryOrderHomCarrier._proof_4
|
Mathlib.Order.Category.LinOrd
|
β {X Y Z : LinOrd} (f : X βΆ Y) (g : Y βΆ Z) (x : βX), (CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x)
|
HomologicalComplex.monoidalCategoryStruct._proof_4
|
Mathlib.Algebra.Homology.Monoidal
|
β (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] {I : Type u_1} [inst_3 : AddMonoid I] (c : ComplexShape I)
[β (Xβ Xβ Xβ : CategoryTheory.GradedObject I C), Xβ.HasGoodTensorββTensor Xβ Xβ] (Kβ Kβ Kβ : HomologicalComplex C c),
CategoryTheory.GradedObject.HasGoodTensorββTensor Kβ.X Kβ.X Kβ.X
|
OrderIso.symm_image_image
|
Mathlib.Order.Hom.Set
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : LE Ξ±] [inst_1 : LE Ξ²] (e : Ξ± βo Ξ²) (s : Set Ξ±), βe.symm '' (βe '' s) = s
|
spinGroup.mul_star_self_of_mem
|
Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup
|
β {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} {x : CliffordAlgebra Q}, x β spinGroup Q β x * star x = 1
|
_private.Mathlib.RingTheory.Ideal.Span.0.Ideal.span_pair_add_mul_left.match_1_1
|
Mathlib.RingTheory.Ideal.Span
|
β {R : Type u_1} [inst : CommRing R] {x y : R} (z x_1 : R) (motive : (β a b, a * (x + y * z) + b * y = x_1) β Prop)
(x_2 : β a b, a * (x + y * z) + b * y = x_1), (β (a b : R) (h : a * (x + y * z) + b * y = x_1), motive β―) β motive x_2
|
Lean.Parser.sepByElemParser.formatter
|
Lean.Parser.Extra
|
Lean.PrettyPrinter.Formatter β String β Lean.PrettyPrinter.Formatter
|
Finset.coe_pow._simp_4
|
Mathlib.Algebra.Group.Pointwise.Finset.Basic
|
β {Ξ± : Type u_2} [inst : DecidableEq Ξ±] [inst_1 : AddMonoid Ξ±] (s : Finset Ξ±) (n : β), n β’ βs = β(n β’ s)
|
Submodule.finite_iSup
|
Mathlib.RingTheory.Finiteness.Lattice
|
β {R : Type u_2} {V : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {ΞΉ : Sort u_1}
[Finite ΞΉ] (S : ΞΉ β Submodule R V) [β (i : ΞΉ), Module.Finite R β₯(S i)], Module.Finite R β₯(β¨ i, S i)
|
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.ofLE?
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo
|
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo β Option (Option Lean.Expr)
|
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.ofComapInteger._simp_1_2
|
Mathlib.RingTheory.Valuation.Extension
|
β {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] {s : Subring S} {f : R β+* S} {x : R},
(x β Subring.comap f s) = (f x β s)
|
_private.Init.Data.Int.Order.0.Int.instLawfulOrderLT._simp_2
|
Init.Data.Int.Order
|
β {a b : Prop} [Decidable a], (a β b) = (Β¬a β¨ b)
|
ContinuousMultilinearMap.zero_apply
|
Mathlib.Topology.Algebra.Module.Multilinear.Basic
|
β {R : Type u} {ΞΉ : Type v} {Mβ : ΞΉ β Type wβ} {Mβ : Type wβ} [inst : Semiring R]
[inst_1 : (i : ΞΉ) β AddCommMonoid (Mβ i)] [inst_2 : AddCommMonoid Mβ] [inst_3 : (i : ΞΉ) β Module R (Mβ i)]
[inst_4 : Module R Mβ] [inst_5 : (i : ΞΉ) β TopologicalSpace (Mβ i)] [inst_6 : TopologicalSpace Mβ]
(m : (i : ΞΉ) β Mβ i), 0 m = 0
|
Order.height_eq_krullDim_Iic
|
Mathlib.Order.KrullDimension
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] (x : Ξ±), β(Order.height x) = Order.krullDim β(Set.Iic x)
|
Lean.Elab.WF.GuessLex.RecCallCache.callerName
|
Lean.Elab.PreDefinition.WF.GuessLex
|
Lean.Elab.WF.GuessLex.RecCallCache β Lean.Name
|
Batteries.RBNode.lowerBound?_eq_find?
|
Batteries.Data.RBMap.Lemmas
|
β {Ξ± : Type u_1} {x : Ξ±} {t : Batteries.RBNode Ξ±} {cut : Ξ± β Ordering} (lb : Option Ξ±),
Batteries.RBNode.find? cut t = some x β Batteries.RBNode.lowerBound? cut t lb = some x
|
_private.Mathlib.Order.KrullDimension.0.Order.height_le_of_krullDim_preimage_le._proof_1_4
|
Mathlib.Order.KrullDimension
|
β {Ξ± : Type u_2} {Ξ² : Type u_1} [inst : Preorder Ξ±] [inst_1 : PartialOrder Ξ²] {m : β} (f : Ξ± βo Ξ²) (n : β),
(β m_1 < n, β (x : Ξ±), Order.height (f x) = βm_1 β Order.height x β€ (βm + 1) * βm_1 + βm) β
β (x : Ξ±),
Order.height (f x) = βn β
β (p : LTSeries Ξ±),
RelSeries.last p β€ x β
(βm + 1) * βn + βm < βp.length β
f x β€ f (p.toFun β¨p.length - (m + 1), β―β©) β p.length β€ m + (p.length - (m + 1)) β p.length > m β False
|
Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.grindPattern.formatter_13
|
Lean.Meta.Tactic.Grind.Parser
|
IO Unit
|
Combinatorics.Subspace.reindex._simp_1
|
Mathlib.Combinatorics.HalesJewett
|
β {Ξ± : Sort u_1} {Ξ² : Sort u_2} (e : Ξ± β Ξ²) {x : Ξ²} {y : Ξ±}, (y = e.symm x) = (e y = x)
|
HomologicalComplex.HomologySequence.snakeInput._proof_37
|
Mathlib.Algebra.Homology.HomologySequence
|
β {C : Type u_2} {ΞΉ : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ΞΉ} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i j : ΞΉ),
CategoryTheory.Epi
((HomologicalComplex.HomologySequence.composableArrowsβ S.Xβ i j).map' 2 3
HomologicalComplex.HomologySequence.snakeInput._proof_33 HomologicalComplex.HomologySequence.snakeInput._proof_34)
|
CategoryTheory.DifferentialObject.mk._flat_ctor
|
Mathlib.CategoryTheory.DifferentialObject
|
{S : Type u_1} β
[inst : AddMonoidWithOne S] β
{C : Type u} β
[inst_1 : CategoryTheory.Category.{v, u} C] β
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] β
[inst_3 : CategoryTheory.HasShift C S] β
(obj : C) β
(d : obj βΆ (CategoryTheory.shiftFunctor C 1).obj obj) β
autoParam (CategoryTheory.CategoryStruct.comp d ((CategoryTheory.shiftFunctor C 1).map d) = 0)
CategoryTheory.DifferentialObject.d_squared._autoParam β
CategoryTheory.DifferentialObject S C
|
PiTensorProduct.ofFinsuppEquiv'.eq_1
|
Mathlib.LinearAlgebra.PiTensorProduct.Finsupp
|
β {R : Type u_1} {ΞΉ : Type u_2} {ΞΊ : ΞΉ β Type u_3} [inst : CommSemiring R] [inst_1 : Fintype ΞΉ] [inst_2 : DecidableEq ΞΉ]
[inst_3 : (i : ΞΉ) β DecidableEq (ΞΊ i)] [inst_4 : DecidableEq R],
PiTensorProduct.ofFinsuppEquiv' =
PiTensorProduct.ofFinsuppEquiv.trans
(Finsupp.lcongr (Equiv.refl ((i : ΞΉ) β ΞΊ i)) (PiTensorProduct.constantBaseRingEquiv ΞΉ R).toLinearEquiv)
|
_private.Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct.0.CategoryTheory.Limits.SequentialProduct.functorMap_commSq_aux._proof_1_9
|
Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct
|
β {C : Type u_1} {M N : β β C} [inst : CategoryTheory.Category.{u_2, u_1} C] (f : (n : β) β M n βΆ N n)
[inst_1 : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete β) C] {n k : β} β¦m_1 : ββ¦ (h : n β€ m_1),
(β (hh : m_1 β€ k),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.ofOpSequence (CategoryTheory.Limits.SequentialProduct.functorMap f)).map
(CategoryTheory.homOfLE h).op)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.limit.Ο (CategoryTheory.Discrete.functor fun m => if x : m < n then M m else N m)
{ as := k })
(CategoryTheory.eqToHom β―)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.limit.Ο (CategoryTheory.Discrete.functor fun i => if x : i < m_1 then M i else N i)
{ as := k })
(CategoryTheory.eqToHom β―)) β
m_1 + 1 β€ k β (if x : k < m_1 then M k else N k) = N k
|
Turing.TM0.Machine.map_respects
|
Mathlib.Computability.PostTuringMachine
|
β {Ξ : Type u_1} [inst : Inhabited Ξ] {Ξ' : Type u_2} [inst_1 : Inhabited Ξ'] {Ξ : Type u_3} [inst_2 : Inhabited Ξ]
{Ξ' : Type u_4} [inst_3 : Inhabited Ξ'] (M : Turing.TM0.Machine Ξ Ξ) (fβ : Turing.PointedMap Ξ Ξ')
(fβ : Turing.PointedMap Ξ' Ξ) (gβ : Turing.PointedMap Ξ Ξ') (gβ : Ξ' β Ξ) {S : Set Ξ},
Turing.TM0.Supports M S β
Function.RightInverse fβ.f fβ.f β
(β q β S, gβ (gβ.f q) = q) β
Turing.Respects (Turing.TM0.step M) (Turing.TM0.step (M.map fβ fβ gβ.f gβ)) fun a b =>
a.q β S β§ Turing.TM0.Cfg.map fβ gβ.f a = b
|
LaurentPolynomial.ext
|
Mathlib.Algebra.Polynomial.Laurent
|
β {R : Type u_1} [inst : Semiring R] {p q : LaurentPolynomial R}, (β (a : β€), p a = q a) β p = q
|
signedDist_triangle_left
|
Mathlib.Geometry.Euclidean.SignedDist
|
β {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v : V) (p q r : P), ((signedDist v) p) q - ((signedDist v) p) r = ((signedDist v) r) q
|
CategoryTheory.Functor.PreservesLeftKanExtension
|
Mathlib.CategoryTheory.Functor.KanExtension.Preserves
|
{A : Type u_1} β
{B : Type u_2} β
{C : Type u_3} β
{D : Type u_4} β
[inst : CategoryTheory.Category.{u_5, u_1} A] β
[inst_1 : CategoryTheory.Category.{u_6, u_2} B] β
[inst_2 : CategoryTheory.Category.{u_7, u_3} C] β
[inst_3 : CategoryTheory.Category.{u_8, u_4} D] β
CategoryTheory.Functor B D β CategoryTheory.Functor A B β CategoryTheory.Functor A C β Prop
|
ContinuousMap.exists_finite_sum_smul_approximation_of_mem_uniformity
|
Mathlib.Topology.UniformSpace.ProdApproximation
|
β {X : Type u_1} {Y : Type u_2} {R : Type u_3} {V : Type u_4} [inst : TopologicalSpace X] [TotallyDisconnectedSpace X]
[T2Space X] [CompactSpace X] [inst_4 : TopologicalSpace Y] [CompactSpace Y] [inst_6 : AddCommGroup V]
[inst_7 : UniformSpace V] [IsUniformAddGroup V] {S : Set (V Γ V)} [inst_9 : TopologicalSpace R]
[inst_10 : MonoidWithZero R] [inst_11 : MulActionWithZero R V] (f : C(X Γ Y, V)),
S β uniformity V β β n g h, β (x : X) (y : Y), (f (x, y), β i, (g i) x β’ (h i) y) β S
|
Nat.gcd_dvd_gcd_mul_right_left
|
Init.Data.Nat.Gcd
|
β (m n k : β), m.gcd n β£ (m * k).gcd n
|
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.buildInductionBody._unsafe_rec
|
Lean.Meta.Tactic.FunInd
|
Array Lean.FVarId β
Array Lean.FVarId β
Lean.Expr β
Lean.FVarId β Lean.FVarId β (Lean.Expr β Option Lean.Expr) β Lean.Expr β Lean.Tactic.FunInd.M2β Lean.Expr
|
CategoryTheory.Discrete.ctorIdx
|
Mathlib.CategoryTheory.Discrete.Basic
|
{Ξ± : Type uβ} β CategoryTheory.Discrete Ξ± β β
|
CompleteLattice.mk._flat_ctor
|
Mathlib.Order.CompleteLattice.Defs
|
{Ξ± : Type u_8} β
(le lt : Ξ± β Ξ± β Prop) β
(β (a : Ξ±), le a a) β
(β (a b c : Ξ±), le a b β le b c β le a c) β
autoParam (β (a b : Ξ±), lt a b β le a b β§ Β¬le b a) Preorder.lt_iff_le_not_ge._autoParam β
(β (a b : Ξ±), le a b β le b a β a = b) β
(sup : Ξ± β Ξ± β Ξ±) β
(β (a b : Ξ±), le a (sup a b)) β
(β (a b : Ξ±), le b (sup a b)) β
(β (a b c : Ξ±), le a c β le b c β le (sup a b) c) β
(inf : Ξ± β Ξ± β Ξ±) β
(β (a b : Ξ±), le (inf a b) a) β
(β (a b : Ξ±), le (inf a b) b) β
(β (a b c : Ξ±), le a b β le a c β le a (inf b c)) β
(sSup : Set Ξ± β Ξ±) β
(β (s : Set Ξ±), β a β s, le a (sSup s)) β
(β (s : Set Ξ±) (a : Ξ±), (β b β s, le b a) β le (sSup s) a) β
(sInf : Set Ξ± β Ξ±) β
(β (s : Set Ξ±), β a β s, le (sInf s) a) β
(β (s : Set Ξ±) (a : Ξ±), (β b β s, le a b) β le a (sInf s)) β
(top : Ξ±) β
(β (a : Ξ±), le a top) β (bot : Ξ±) β (β (a : Ξ±), le bot a) β CompleteLattice Ξ±
|
Lean.Lsp.Ipc.expandModuleHierarchyImports
|
Lean.Data.Lsp.Ipc
|
β β Lean.Lsp.DocumentUri β Lean.Lsp.Ipc.IpcM (Option Lean.Lsp.Ipc.ModuleHierarchy Γ β)
|
Holor.assocLeft.eq_1
|
Mathlib.Data.Holor
|
β {Ξ± : Type} {dsβ dsβ dsβ : List β}, Holor.assocLeft = cast β―
|
AlgebraicGeometry.Scheme.pretopology._proof_3
|
Mathlib.AlgebraicGeometry.Sites.Pretopology
|
β (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) [P.IsMultiplicative],
(AlgebraicGeometry.Scheme.precoverage P).IsStableUnderComposition
|
_auto._@.Mathlib.Order.ConditionallyCompleteLattice.Finset.2276574750._hygCtx._hyg.52
|
Mathlib.Order.ConditionallyCompleteLattice.Finset
|
Lean.Syntax
|
WeierstrassCurve.Projective.Point
|
Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point
|
{R : Type r} β [CommRing R] β WeierstrassCurve.Projective R β Type r
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.