name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
CategoryTheory.Limits.IsImage.noConfusionType
|
Mathlib.CategoryTheory.Limits.Shapes.Images
|
Sort u_1 β
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{X Y : C} β
{f : X βΆ Y} β
{F : CategoryTheory.Limits.MonoFactorisation f} β
CategoryTheory.Limits.IsImage F β
{C' : Type u} β
[inst' : CategoryTheory.Category.{v, u} C'] β
{X' Y' : C'} β
{f' : X' βΆ Y'} β
{F' : CategoryTheory.Limits.MonoFactorisation f'} β CategoryTheory.Limits.IsImage F' β Sort u_1
|
CategoryTheory.Pseudofunctor.presheafHom_obj
|
Mathlib.CategoryTheory.Sites.Descent.IsPrestack
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cα΅α΅) CategoryTheory.Cat) {S : C}
(M N : β(F.obj { as := Opposite.op S })) (T : (CategoryTheory.Over S)α΅α΅),
(F.presheafHom M N).obj T =
((F.map (Opposite.unop T).hom.op.toLoc).toFunctor.obj M βΆ (F.map (Opposite.unop T).hom.op.toLoc).toFunctor.obj N)
|
instLTInt8
|
Init.Data.SInt.Basic
|
LT Int8
|
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.getLHS
|
Lean.Meta.Tactic.Grind.EMatch
|
Array Lean.Expr β β β Lean.MetaM Lean.Expr
|
CategoryTheory.coeMonad
|
Mathlib.CategoryTheory.Monad.Basic
|
{C : Type uβ} β [inst : CategoryTheory.Category.{vβ, uβ} C] β Coe (CategoryTheory.Monad C) (CategoryTheory.Functor C C)
|
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.forgetToPresheafedSpace_reflectsPullback_of_right
|
Mathlib.Geometry.RingedSpace.OpenImmersion
|
β {X Y Z : AlgebraicGeometry.LocallyRingedSpace} (f : X βΆ Z) (g : Y βΆ Z)
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f],
CategoryTheory.Limits.ReflectsLimit (CategoryTheory.Limits.cospan g f)
(AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.comp
AlgebraicGeometry.SheafedSpace.forgetToPresheafedSpace)
|
CategoryTheory.Functor.CorepresentableBy.ofIsoObj
|
Mathlib.CategoryTheory.Yoneda
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
{F : CategoryTheory.Functor C (Type w)} β {X Y : C} β F.CorepresentableBy X β (Y β
X) β F.CorepresentableBy Y
|
SymOptionSuccEquiv.decode_inl
|
Mathlib.Data.Sym.Basic
|
β {Ξ± : Type u_1} {n : β} (s : Sym (Option Ξ±) n), SymOptionSuccEquiv.decode (Sum.inl s) = none ::β s
|
LinearEquiv.compDer._proof_1
|
Mathlib.RingTheory.Derivation.Basic
|
β {R : Type u_3} {A : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] {N : Type u_4}
[inst_6 : AddCommMonoid N] [inst_7 : Module A N] [inst_8 : Module R N] [inst_9 : IsScalarTower R A M]
[inst_10 : IsScalarTower R A N] (e : M ββ[A] N) (D : Derivation R A M), (βe.symm).compDer ((βe).compDer.toFun D) = D
|
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.length.eq_1
|
Std.Data.DHashMap.Internal.AssocList.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} (l : Std.DHashMap.Internal.AssocList Ξ± Ξ²),
l.length = Std.DHashMap.Internal.AssocList.foldl (fun n x x_1 => n + 1) 0 l
|
List.eraseIdx_cons_zero
|
Init.Data.List.Basic
|
β {Ξ± : Type u_1} {a : Ξ±} {as : List Ξ±}, (a :: as).eraseIdx 0 = as
|
_private.Mathlib.Algebra.Order.Floor.Semiring.0.Nat.preimage_Ioi._simp_1_1
|
Mathlib.Algebra.Order.Floor.Semiring
|
β {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R} {n : β},
0 β€ a β (βaββ < n) = (a < βn)
|
IsMulFreimanIso.subset
|
Mathlib.Combinatorics.Additive.FreimanHom
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : CommMonoid Ξ±] [inst_1 : CommMonoid Ξ²] {Aβ Aβ : Set Ξ±} {Bβ Bβ : Set Ξ²}
{f : Ξ± β Ξ²} {n : β}, Aβ β Aβ β IsMulFreimanIso n Aβ Bβ f β Set.BijOn f Aβ Bβ β IsMulFreimanIso n Aβ Bβ f
|
CategoryTheory.LocalizerMorphism.inverts
|
Mathlib.CategoryTheory.Localization.LocalizerMorphism
|
β {Cβ : Type uβ} {Cβ : Type uβ} {Dβ : Type uβ
} [inst : CategoryTheory.Category.{vβ, uβ} Cβ]
[inst_1 : CategoryTheory.Category.{vβ, uβ} Cβ] [inst_2 : CategoryTheory.Category.{vβ
, uβ
} Dβ]
{Wβ : CategoryTheory.MorphismProperty Cβ} {Wβ : CategoryTheory.MorphismProperty Cβ}
(Ξ¦ : CategoryTheory.LocalizerMorphism Wβ Wβ) (Lβ : CategoryTheory.Functor Cβ Dβ) [Lβ.IsLocalization Wβ],
Wβ.IsInvertedBy (Ξ¦.functor.comp Lβ)
|
GromovHausdorff.instMetricSpaceGHSpace._proof_13
|
Mathlib.Topology.MetricSpace.GromovHausdorff
|
(Bornology.cobounded GromovHausdorff.GHSpace).sets = (Bornology.cobounded GromovHausdorff.GHSpace).sets
|
Lean.Lsp.DidChangeTextDocumentParams._sizeOf_1
|
Lean.Data.Lsp.TextSync
|
Lean.Lsp.DidChangeTextDocumentParams β β
|
MvPowerSeries.monomial_zero_one
|
Mathlib.RingTheory.MvPowerSeries.Basic
|
β {Ο : Type u_1} {R : Type u_2} [inst : Semiring R], (MvPowerSeries.monomial 0) 1 = 1
|
CFC.rpow_eq_cfc_real._auto_1
|
Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic
|
Lean.Syntax
|
_private.Mathlib.FieldTheory.LinearDisjoint.0.IntermediateField.LinearDisjoint.lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic.match_1_1
|
Mathlib.FieldTheory.LinearDisjoint
|
β {F : Type u_2} {E : Type u_1} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A : IntermediateField F E}
{L : Type u_3} [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E]
(motive : β₯(IntermediateField.extendScalars β―) β Prop) (x : β₯(IntermediateField.extendScalars β―)),
(β (x : E) (hx : x β IntermediateField.extendScalars β―), motive β¨x, hxβ©) β motive x
|
_private.Std.Time.Time.PlainTime.0.Std.Time.instDecidableEqPlainTime.decEq._proof_3
|
Std.Time.Time.PlainTime
|
β (a : Std.Time.Hour.Ordinal) (a_1 : Std.Time.Minute.Ordinal) (a_2 : Std.Time.Second.Ordinal true)
(a_3 : Std.Time.Nanosecond.Ordinal) (b : Std.Time.Second.Ordinal true) (b_1 : Std.Time.Nanosecond.Ordinal),
Β¬a_2 = b β
{ hour := a, minute := a_1, second := a_2, nanosecond := a_3 } =
{ hour := a, minute := a_1, second := b, nanosecond := b_1 } β
False
|
instCompleteLinearOrderWithBotENat
|
Mathlib.Data.ENat.Lattice
|
CompleteLinearOrder (WithBot ββ)
|
Homeomorph.setCongr
|
Mathlib.Topology.Homeomorph.Lemmas
|
{X : Type u_1} β [inst : TopologicalSpace X] β {s t : Set X} β s = t β βs ββ βt
|
MulAut.instGroup._proof_3
|
Mathlib.Algebra.Group.End
|
β (M : Type u_1) [inst : Mul M] (a b : MulAut M), a / b = a / b
|
AlgebraNorm.isScalarTower_restriction._proof_4
|
Mathlib.Analysis.Normed.Unbundled.AlgebraNorm
|
β {R : Type u_2} [inst : SeminormedCommRing R] {S : Type u_1} [inst_1 : Ring S] [inst_2 : Algebra R S] {A : Type u_3}
[inst_3 : CommRing A] [inst_4 : Algebra A S] (f : AlgebraNorm R S) (x : A),
f ((algebraMap A S) (-x)) = f ((algebraMap A S) x)
|
_private.Mathlib.Data.DFinsupp.BigOperators.0.DFinsupp.sumAddHom._simp_1
|
Mathlib.Data.DFinsupp.BigOperators
|
β {Ξ± : Type u_1} {a : Ξ±} {s t : Multiset Ξ±}, (a β s + t) = (a β s β¨ a β t)
|
Real.sigmoid_neg
|
Mathlib.Analysis.SpecialFunctions.Sigmoid
|
β (x : β), (-x).sigmoid = 1 - x.sigmoid
|
PFun.core
|
Mathlib.Data.PFun
|
{Ξ± : Type u_1} β {Ξ² : Type u_2} β (Ξ± β. Ξ²) β Set Ξ² β Set Ξ±
|
SemiNormedGrpβ.instHasCokernels
|
Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels
|
CategoryTheory.Limits.HasCokernels SemiNormedGrpβ
|
Lean.DefinitionSafety._sizeOf_inst
|
Lean.Declaration
|
SizeOf Lean.DefinitionSafety
|
CategoryTheory.nerve.Ξ΄β_two
|
Mathlib.AlgebraicTopology.SimplicialSet.Nerve
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.ComposableArrows C 2),
CategoryTheory.SimplicialObject.Ξ΄ (CategoryTheory.nerve C) 2 x =
CategoryTheory.ComposableArrows.mkβ
(x.map' 0 1 CategoryTheory.nerve.Ξ΄β_two._proof_2 CategoryTheory.nerve.Ξ΄β_two._proof_4)
|
String.Pos.prev._proof_1
|
Init.Data.String.Basic
|
β {s : String} (pos : s.Pos),
pos β s.startPos β String.Pos.ofToSlice pos.toSlice β String.Pos.ofToSlice s.toSlice.startPos
|
Array.getElem?_map
|
Init.Data.Array.Lemmas
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β Ξ²} {xs : Array Ξ±} {i : β}, (Array.map f xs)[i]? = Option.map f xs[i]?
|
TopologicalSpace.Opens.CompleteCopy.instMetricSpace._proof_4
|
Mathlib.Topology.MetricSpace.Polish
|
β {Ξ± : Type u_1} [inst : MetricSpace Ξ±] {s : TopologicalSpace.Opens Ξ±} (t : Set s.CompleteCopy),
IsOpen t β β x β t, β Ξ΅ > 0, β (y : s.CompleteCopy), dist x y < Ξ΅ β y β t
|
Mathlib.Tactic.CC.ACEntry.RRHSOccs
|
Mathlib.Tactic.CC.Datatypes
|
Mathlib.Tactic.CC.ACEntry β Mathlib.Tactic.CC.ACAppsSet
|
CategoryTheory.GradedObject.Monoidal.pentagon
|
Mathlib.CategoryTheory.GradedObject.Monoidal
|
β {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (Xβ Xβ Xβ Xβ : CategoryTheory.GradedObject I C)
[inst_3 : Xβ.HasTensor Xβ] [inst_4 : Xβ.HasTensor Xβ] [inst_5 : Xβ.HasTensor Xβ]
[inst_6 : (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ).HasTensor Xβ]
[inst_7 : Xβ.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ)]
[inst_8 : (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ).HasTensor Xβ]
[inst_9 : Xβ.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ)]
[inst_10 :
(CategoryTheory.GradedObject.Monoidal.tensorObj (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ) Xβ).HasTensor
Xβ]
[inst_11 :
(CategoryTheory.GradedObject.Monoidal.tensorObj Xβ (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ)).HasTensor
Xβ]
[inst_12 :
Xβ.HasTensor
(CategoryTheory.GradedObject.Monoidal.tensorObj (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ) Xβ)]
[inst_13 :
Xβ.HasTensor
(CategoryTheory.GradedObject.Monoidal.tensorObj Xβ (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ))]
[inst_14 :
(CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ).HasTensor
(CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ)]
[inst_15 : Xβ.HasGoodTensorββTensor Xβ Xβ] [inst_16 : Xβ.HasGoodTensorTensorββ Xβ Xβ]
[inst_17 : Xβ.HasGoodTensorββTensor (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ) Xβ]
[inst_18 : Xβ.HasGoodTensorTensorββ (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ) Xβ]
[inst_19 : Xβ.HasGoodTensorββTensor Xβ Xβ] [inst_20 : Xβ.HasGoodTensorTensorββ Xβ Xβ]
[inst_21 : (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ).HasGoodTensorββTensor Xβ Xβ]
[inst_22 : (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ).HasGoodTensorTensorββ Xβ Xβ]
[inst_23 : Xβ.HasGoodTensorββTensor Xβ (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ)]
[inst_24 : Xβ.HasGoodTensorTensorββ Xβ (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ)]
[Xβ.HasTensorβObjExt Xβ Xβ Xβ],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.Monoidal.tensorHom (CategoryTheory.GradedObject.Monoidal.associator Xβ Xβ Xβ).hom
(CategoryTheory.CategoryStruct.id Xβ))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.Monoidal.associator Xβ (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ)
Xβ).hom
(CategoryTheory.GradedObject.Monoidal.tensorHom (CategoryTheory.CategoryStruct.id Xβ)
(CategoryTheory.GradedObject.Monoidal.associator Xβ Xβ Xβ).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.Monoidal.associator (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ) Xβ Xβ).hom
(CategoryTheory.GradedObject.Monoidal.associator Xβ Xβ (CategoryTheory.GradedObject.Monoidal.tensorObj Xβ Xβ)).hom
|
_private.Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary.0.ModelWithCorners.isBoundaryPoint_iff_isBoundaryPoint_val._simp_1_1
|
Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary
|
β {a b : Prop}, (Β¬a β Β¬b) = (a β b)
|
Complex.ofReal_mul'
|
Mathlib.Data.Complex.Basic
|
β (r : β) (z : β), βr * z = { re := r * z.re, im := r * z.im }
|
MvQPF.WEquiv.below.ind
|
Mathlib.Data.QPF.Multivariate.Constructions.Fix
|
β {n : β} {F : TypeVec.{u} (n + 1) β Type u} [q : MvQPF F] {Ξ± : TypeVec.{u} n}
{motive : (a a_1 : (MvQPF.P F).W Ξ±) β MvQPF.WEquiv a a_1 β Prop} (a : (MvQPF.P F).A)
(f' : ((MvQPF.P F).drop.B a).Arrow Ξ±) (fβ fβ : (MvQPF.P F).last.B a β (MvQPF.P F).W Ξ±)
(a_1 : β (x : (MvQPF.P F).last.B a), MvQPF.WEquiv (fβ x) (fβ x)),
(β (x : (MvQPF.P F).last.B a), MvQPF.WEquiv.below β―) β
(β (x : (MvQPF.P F).last.B a), motive (fβ x) (fβ x) β―) β MvQPF.WEquiv.below β―
|
Cardinal.ord_zero
|
Mathlib.SetTheory.Ordinal.Basic
|
Cardinal.ord 0 = 0
|
Lean.Lsp.instFromJsonVersionedTextDocumentIdentifier.fromJson
|
Lean.Data.Lsp.Basic
|
Lean.Json β Except String Lean.Lsp.VersionedTextDocumentIdentifier
|
Lean.Parser.Term.syntheticHole._regBuiltin.Lean.Parser.Term.syntheticHole.docString_3
|
Lean.Parser.Term.Basic
|
IO Unit
|
nhds_translation_mul_invβ
|
Mathlib.Topology.Algebra.GroupWithZero
|
β {Gβ : Type u_3} [inst : TopologicalSpace Gβ] [inst_1 : GroupWithZero Gβ] [ContinuousMul Gβ] {a : Gβ},
a β 0 β Filter.comap (fun x => x * aβ»ΒΉ) (nhds 1) = nhds a
|
Polynomial.IsDistinguishedAt.algEquivQuotient._proof_4
|
Mathlib.RingTheory.PowerSeries.WeierstrassPreparation
|
β {A : Type u_1} [inst : CommRing A] {g : Polynomial A} {I : Ideal A} (H : g.IsDistinguishedAt I)
[inst_1 : IsAdicComplete I A] (f : Polynomial A β§Έ Ideal.span {g}),
(β(Ideal.Quotient.mk (Ideal.span {g})) β ββ―.mod')
((ββ(Ideal.quotientMapβ (Ideal.span {βg}) (Polynomial.coeToPowerSeries.algHom A) β―).toRingHom).toFun f) =
f
|
Module.Relations.Solution.IsPresentationCore.noConfusion
|
Mathlib.Algebra.Module.Presentation.Basic
|
{P : Sort u_1} β
{A : Type u} β
{inst : Ring A} β
{relations : Module.Relations A} β
{M : Type v} β
{inst_1 : AddCommGroup M} β
{inst_2 : Module A M} β
{solution : relations.Solution M} β
{t : solution.IsPresentationCore} β
{A' : Type u} β
{inst' : Ring A'} β
{relations' : Module.Relations A'} β
{M' : Type v} β
{inst'_1 : AddCommGroup M'} β
{inst'_2 : Module A' M'} β
{solution' : relations'.Solution M'} β
{t' : solution'.IsPresentationCore} β
A = A' β
inst β inst' β
relations β relations' β
M = M' β
inst_1 β inst'_1 β
inst_2 β inst'_2 β
solution β solution' β
t β t' β
Module.Relations.Solution.IsPresentationCore.noConfusionType P t t'
|
IsMinFilter.min
|
Mathlib.Order.Filter.Extr
|
β {Ξ± : Type u} {Ξ² : Type v} [inst : LinearOrder Ξ²] {f g : Ξ± β Ξ²} {a : Ξ±} {l : Filter Ξ±},
IsMinFilter f l a β IsMinFilter g l a β IsMinFilter (fun x => min (f x) (g x)) l a
|
Equiv.locallyFinite_comp_iff
|
Mathlib.Topology.LocallyFinite
|
β {ΞΉ : Type u_1} {ΞΉ' : Type u_2} {X : Type u_4} [inst : TopologicalSpace X] {f : ΞΉ β Set X} (e : ΞΉ' β ΞΉ),
LocallyFinite (f β βe) β LocallyFinite f
|
CategoryTheory.left_comp_retraction
|
Mathlib.CategoryTheory.Limits.Shapes.Reflexive
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} (f g : A βΆ B)
[inst_1 : CategoryTheory.IsCoreflexivePair f g],
CategoryTheory.CategoryStruct.comp f (CategoryTheory.commonRetraction f g) = CategoryTheory.CategoryStruct.id A
|
_private.Mathlib.Tactic.CC.MkProof.0.Mathlib.Tactic.CC.CCM.mkCongrProofCore._sparseCasesOn_3
|
Mathlib.Tactic.CC.MkProof
|
{motive : Lean.Meta.CongrArgKind β Sort u} β
(t : Lean.Meta.CongrArgKind) β motive Lean.Meta.CongrArgKind.heq β (Nat.hasNotBit 16 t.ctorIdx β motive t) β motive t
|
CategoryTheory.GrothendieckTopology.Subcanonical.recOn
|
Mathlib.CategoryTheory.Sites.Canonical
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{J : CategoryTheory.GrothendieckTopology C} β
{motive : J.Subcanonical β Sort u_1} β
(t : J.Subcanonical) β ((le_canonical : J β€ CategoryTheory.Sheaf.canonicalTopology C) β motive β―) β motive t
|
Polynomial.smul_eq_C_mul
|
Mathlib.Algebra.Polynomial.Coeff
|
β {R : Type u} [inst : Semiring R] {p : Polynomial R} (a : R), a β’ p = Polynomial.C a * p
|
List.fst_mem_of_mem_zipIdx
|
Init.Data.List.Nat.Range
|
β {Ξ± : Type u_1} {x : Ξ± Γ β} {l : List Ξ±} {k : β}, x β l.zipIdx k β x.1 β l
|
Turing.TM2.Stmt.pop.elim
|
Mathlib.Computability.TuringMachine
|
{K : Type u_1} β
{Ξ : K β Type u_2} β
{Ξ : Type u_3} β
{Ο : Type u_4} β
{motive : Turing.TM2.Stmt Ξ Ξ Ο β Sort u} β
(t : Turing.TM2.Stmt Ξ Ξ Ο) β
t.ctorIdx = 2 β
((k : K) β
(a : Ο β Option (Ξ k) β Ο) β (a_1 : Turing.TM2.Stmt Ξ Ξ Ο) β motive (Turing.TM2.Stmt.pop k a a_1)) β
motive t
|
Subsemiring.gi
|
Mathlib.Algebra.Ring.Subsemiring.Basic
|
(R : Type u) β [inst : NonAssocSemiring R] β GaloisInsertion Subsemiring.closure SetLike.coe
|
CategoryTheory.Limits.colimitQuotientCoproduct._proof_1
|
Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers
|
β {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
[CategoryTheory.Limits.HasColimitsOfSize.{u_1, u_1, u_2, u_3} C] (F : CategoryTheory.Functor J C),
CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun j => F.obj j)
|
AffineSubspace.sOppSide_iff_exists_left
|
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β : P},
pβ β s β (s.SOppSide x y β x β s β§ y β s β§ β pβ β s, SameRay R (x -α΅₯ pβ) (pβ -α΅₯ y))
|
MvPolynomial.rename_expand
|
Mathlib.Algebra.MvPolynomial.Expand
|
β {Ο : Type u_1} {Ο : Type u_2} {R : Type u_3} [inst : CommSemiring R] (f : Ο β Ο) (p : β) (Ο : MvPolynomial Ο R),
(MvPolynomial.rename f) ((MvPolynomial.expand p) Ο) = (MvPolynomial.expand p) ((MvPolynomial.rename f) Ο)
|
MonovaryOn.subset
|
Mathlib.Order.Monotone.Monovary
|
β {ΞΉ : Type u_1} {Ξ± : Type u_3} {Ξ² : Type u_4} [inst : Preorder Ξ±] [inst_1 : Preorder Ξ²] {f : ΞΉ β Ξ±} {g : ΞΉ β Ξ²}
{s t : Set ΞΉ}, s β t β MonovaryOn f g t β MonovaryOn f g s
|
HasProdUniformly.hasProdLocallyUniformly
|
Mathlib.Topology.Algebra.InfiniteSum.UniformOn
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {ΞΉ : Type u_3} [inst : CommMonoid Ξ±] {f : ΞΉ β Ξ² β Ξ±} {g : Ξ² β Ξ±}
[inst_1 : UniformSpace Ξ±] [inst_2 : TopologicalSpace Ξ²], HasProdUniformly f g β HasProdLocallyUniformly f g
|
gauge_gaugeRescale_le
|
Mathlib.Analysis.Convex.GaugeRescale
|
β {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module β E] (s t : Set E) (x : E),
gauge t (gaugeRescale s t x) β€ gauge s x
|
Module.Invertible.toSubmodule
|
Mathlib.RingTheory.PicardGroup
|
(R : Type u) β
(M : Type v) β
(A : Type u_4) β
[inst : CommSemiring R] β
[inst_1 : CommSemiring A] β
[inst_2 : AddCommMonoid M] β
[inst_3 : Algebra R A] β
[inst_4 : Module R M] β [Module.Invertible R M] β [Module.Free A (TensorProduct R A M)] β Submodule R A
|
_private.Mathlib.Computability.PostTuringMachine.0.Turing.TM0to1.tr.match_3.eq_1
|
Mathlib.Computability.PostTuringMachine
|
β {Ξ : Type u_1} {Ξ : Type u_2} (motive : Turing.TM0to1.Ξ' Ξ Ξ β Sort u_3) (q : Ξ)
(h_1 : (q : Ξ) β motive (Turing.TM0to1.Ξ'.normal q))
(h_2 : (d : Turing.Dir) β (q : Ξ) β motive (Turing.TM0to1.Ξ'.act (Turing.TM0.Stmt.move d) q))
(h_3 : (a : Ξ) β (q : Ξ) β motive (Turing.TM0to1.Ξ'.act (Turing.TM0.Stmt.write a) q)),
(match Turing.TM0to1.Ξ'.normal q with
| Turing.TM0to1.Ξ'.normal q => h_1 q
| Turing.TM0to1.Ξ'.act (Turing.TM0.Stmt.move d) q => h_2 d q
| Turing.TM0to1.Ξ'.act (Turing.TM0.Stmt.write a) q => h_3 a q) =
h_1 q
|
Nat.instCommutativeHAdd
|
Init.Data.Nat.Basic
|
Std.Commutative fun x1 x2 => x1 + x2
|
aeconst_of_dense_setOf_preimage_vadd_ae
|
Mathlib.Dynamics.Ergodic.Action.OfMinimal
|
β {M : Type u_1} [inst : TopologicalSpace M] {X : Type u_2} [inst_1 : TopologicalSpace X] [R1Space X]
[inst_3 : MeasurableSpace X] [BorelSpace X] [inst_5 : VAdd M X] [ContinuousVAdd M X] {ΞΌ : MeasureTheory.Measure X}
[MeasureTheory.IsFiniteMeasure ΞΌ] [ΞΌ.InnerRegular] [ErgodicVAdd M X ΞΌ] {s : Set X},
MeasureTheory.NullMeasurableSet s ΞΌ β
Dense {g | (fun x => g +α΅₯ x) β»ΒΉ' s =α΅[ΞΌ] s} β Filter.EventuallyConst s (MeasureTheory.ae ΞΌ)
|
CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_add_unitIso_hom_app_eq._proof_4
|
Mathlib.CategoryTheory.Triangulated.Opposite.Basic
|
β (m n p : β€),
autoParam (m + n = p) CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_add_unitIso_hom_app_eq._auto_1 β
n + m = p
|
Lean.Meta.Simp.ConfigCtx.iota._inherited_default
|
Init.MetaTypes
|
Bool
|
Std.TreeMap.getKey_maxKey!
|
Std.Data.TreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.TreeMap Ξ± Ξ² cmp} [Std.TransCmp cmp] [inst : Inhabited Ξ±]
{hc : t.maxKey! β t}, t.getKey t.maxKey! hc = t.maxKey!
|
AdjoinRoot.evalβ_root
|
Mathlib.RingTheory.AdjoinRoot
|
β {R : Type u_1} [inst : CommRing R] (f : Polynomial R), Polynomial.evalβ (AdjoinRoot.of f) (AdjoinRoot.root f) f = 0
|
IsDedekindDomain.HeightOneSpectrum.ofPrime
|
Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas
|
{R : Type u_1} β
[inst : CommRing R] β [IsDedekindDomain R] β {p : Ideal R} β Prime p β IsDedekindDomain.HeightOneSpectrum R
|
_private.Lean.Elab.PreDefinition.Eqns.0.Lean.Elab.Eqns.removeUnusedEqnHypotheses.go._sparseCasesOn_3
|
Lean.Elab.PreDefinition.Eqns
|
{motive : Lean.Expr β Sort u} β
(t : Lean.Expr) β
((binderName : Lean.Name) β
(binderType body : Lean.Expr) β
(binderInfo : Lean.BinderInfo) β motive (Lean.Expr.lam binderName binderType body binderInfo)) β
(Nat.hasNotBit 64 t.ctorIdx β motive t) β motive t
|
CategoryTheory.Limits.PreservesColimitsOfSize.preservesFiniteColimits
|
Mathlib.CategoryTheory.Limits.Preserves.Finite
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesColimitsOfSize.{w, wβ, vβ, vβ, uβ, uβ} F],
CategoryTheory.Limits.PreservesFiniteColimits F
|
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM.computeCoefficients.go
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op β
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap β
Lean.Expr β
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rotateLeft_of_lt._proof_1_1
|
Init.Data.BitVec.Lemmas
|
β {r n : β} (w : β), r < w + 1 β n < w + 1 - r β Β¬r + n < w + 1 β False
|
Vector.find?.eq_1
|
Init.Data.Vector.Lemmas
|
β {n : β} {Ξ± : Type} (f : Ξ± β Bool) (as : Vector Ξ± n), Vector.find? f as = Array.find? f as.toArray
|
Filter.sup_limsup
|
Mathlib.Order.LiminfLimsup
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : CompleteDistribLattice Ξ±] {f : Filter Ξ²} {u : Ξ² β Ξ±} [f.NeBot] (a : Ξ±),
a β Filter.limsup u f = Filter.limsup (fun x => a β u x) f
|
SSet.RelativeMorphism.HomotopyClass
|
Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism
|
{X Y : SSet} β (A : X.Subcomplex) β (B : Y.Subcomplex) β (A.toSSet βΆ B.toSSet) β Type u
|
_private.Lean.Language.Basic.0.Lean.Language.SnapshotTree.forM.match_1
|
Lean.Language.Basic
|
(motive : Lean.Language.SnapshotTree β Sort u_1) β
(s : Lean.Language.SnapshotTree) β
((element : Lean.Language.Snapshot) β
(children : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree)) β
motive { element := element, children := children }) β
motive s
|
MonCat.sectionsSubmonoid
|
Mathlib.Algebra.Category.MonCat.Limits
|
{J : Type v} β
[inst : CategoryTheory.Category.{w, v} J] β (F : CategoryTheory.Functor J MonCat) β Submonoid ((j : J) β β(F.obj j))
|
Set.fintypeProd
|
Mathlib.Data.Finite.Prod
|
{Ξ± : Type u_1} β {Ξ² : Type u_2} β (s : Set Ξ±) β (t : Set Ξ²) β [Fintype βs] β [Fintype βt] β Fintype β(s ΓΛ’ t)
|
_private.Init.Data.UInt.Bitwise.0.UInt64.neg_one_shiftLeft_or_shiftLeft._simp_1_1
|
Init.Data.UInt.Bitwise
|
β {a b c : UInt64}, a <<< c ||| b <<< c = (a ||| b) <<< c
|
CategoryTheory.Localization.induction_structuredArrow
|
Mathlib.CategoryTheory.Localization.StructuredArrow
|
β {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : L.IsLocalization W] {X : C}
(P : CategoryTheory.StructuredArrow (L.obj X) L β Prop),
P (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.id (L.obj X))) β
(β β¦Yβ Yβ : Cβ¦ (f : Yβ βΆ Yβ) (Ο : L.obj X βΆ L.obj Yβ),
P (CategoryTheory.StructuredArrow.mk Ο) β
P (CategoryTheory.StructuredArrow.mk (CategoryTheory.CategoryStruct.comp Ο (L.map f)))) β
(β β¦Yβ Yβ : Cβ¦ (w : Yβ βΆ Yβ) (hw : W w) (Ο : L.obj X βΆ L.obj Yβ),
P (CategoryTheory.StructuredArrow.mk Ο) β
P
(CategoryTheory.StructuredArrow.mk
(CategoryTheory.CategoryStruct.comp Ο (CategoryTheory.Localization.isoOfHom L W w hw).inv))) β
β (g : CategoryTheory.StructuredArrow (L.obj X) L), P g
|
_private.Init.Data.Nat.Power2.0.Nat.isPowerOfTwo_nextPowerOfTwo.isPowerOfTwo_go._unary
|
Init.Data.Nat.Power2
|
β (n : β) (_x : (power : β) Γ' (_ : power > 0) Γ' power.isPowerOfTwo), (Nat.nextPowerOfTwo.goβ n _x.1 β―).isPowerOfTwo
|
Lean.Elab.DefViewElabHeader.noConfusion
|
Lean.Elab.MutualDef
|
{P : Sort u} β {t t' : Lean.Elab.DefViewElabHeader} β t = t' β Lean.Elab.DefViewElabHeader.noConfusionType P t t'
|
pow_mulLeftLinearMap
|
Mathlib.Data.Matrix.Bilinear
|
β {m : Type u_2} {n : Type u_3} {R : Type u_5} {A : Type u_6} [inst : Fintype m] [inst_1 : DecidableEq m]
[inst_2 : Semiring R] [inst_3 : Semiring A] [inst_4 : Module R A] [inst_5 : SMulCommClass R A A] (a : Matrix m m A)
(k : β), mulLeftLinearMap n R a ^ k = mulLeftLinearMap n R (a ^ k)
|
Lean.Compiler.CSimp.Entry.mk.noConfusion
|
Lean.Compiler.CSimpAttr
|
{P : Sort u} β
{fromDeclName toDeclName thmName fromDeclName' toDeclName' thmName' : Lean.Name} β
{ fromDeclName := fromDeclName, toDeclName := toDeclName, thmName := thmName } =
{ fromDeclName := fromDeclName', toDeclName := toDeclName', thmName := thmName' } β
(fromDeclName = fromDeclName' β toDeclName = toDeclName' β thmName = thmName' β P) β P
|
Lean.Meta.Simp.SimprocQ
|
Qq.Simp
|
Type
|
DirectLimit.Ring.hom_ext
|
Mathlib.Algebra.Colimit.DirectLimit
|
β {ΞΉ : Type u_2} [inst : Preorder ΞΉ] {G : ΞΉ β Type u_3} {T : β¦i j : ΞΉβ¦ β i β€ j β Type u_4}
{f : (x x_1 : ΞΉ) β (h : x β€ x_1) β T h} [inst_1 : (i j : ΞΉ) β (h : i β€ j) β FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => β(f x1 x2 x3)] [inst_3 : IsDirectedOrder ΞΉ]
[inst_4 : (i : ΞΉ) β NonAssocSemiring (G i)] [inst_5 : β (i j : ΞΉ) (h : i β€ j), RingHomClass (T h) (G i) (G j)]
[inst_6 : Nonempty ΞΉ] (P : Type u_5) [inst_7 : NonAssocSemiring P] {gβ gβ : DirectLimit G f β+* P},
(β (i : ΞΉ), gβ.comp (DirectLimit.Ring.of G f i) = gβ.comp (DirectLimit.Ring.of G f i)) β gβ = gβ
|
MeasureTheory.Submartingale.stoppedAbove
|
Mathlib.Probability.Martingale.BorelCantelli
|
β {Ξ© : Type u_1} {m0 : MeasurableSpace Ξ©} {ΞΌ : MeasureTheory.Measure Ξ©} {β± : MeasureTheory.Filtration β m0}
{f : β β Ξ© β β} [MeasureTheory.IsFiniteMeasure ΞΌ],
MeasureTheory.Submartingale f β± ΞΌ β β (r : β), MeasureTheory.Submartingale (MeasureTheory.stoppedAbove f r) β± ΞΌ
|
CategoryTheory.MorphismProperty.HasPullbacksAlong.hasPullback
|
Mathlib.CategoryTheory.MorphismProperty.Limits
|
β {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.MorphismProperty C} {X Y : C} {f : X βΆ Y}
[self : P.HasPullbacksAlong f] {W : C} (g : W βΆ Y), P g β CategoryTheory.Limits.HasPullback g f
|
_private.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabStrLit.match_1
|
Lean.Elab.BuiltinTerm
|
(motive : Option String β Sort u_1) β
(x : Option String) β ((val : String) β motive (some val)) β (Unit β motive none) β motive x
|
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.one_ascFactorial.match_1_1
|
Mathlib.Data.Nat.Factorial.Basic
|
β (motive : β β Prop) (x : β), (β (a : Unit), motive 0) β (β (k : β), motive k.succ) β motive x
|
CategoryTheory.InitiallySmall.instCategoryCofilteredInitialModel
|
Mathlib.CategoryTheory.Filtered.FinallySmall
|
(C : Type u) β
[inst : CategoryTheory.Category.{v, u} C] β
[inst_1 : CategoryTheory.IsCofiltered C] β
[inst_2 : CategoryTheory.LocallySmall.{w, v, u} C] β
[inst_3 : CategoryTheory.InitiallySmall C] β
CategoryTheory.Category.{w, w} (CategoryTheory.InitiallySmall.CofilteredInitialModel C)
|
finSuccEquiv'_symm_coe_below
|
Mathlib.Logic.Equiv.Fin.Basic
|
β {n : β} {i : Fin (n + 1)} {m : Fin n}, m.castSucc < i β (finSuccEquiv' i).symm (some m) = m.castSucc
|
Algebra.Generators.H1Cotangent.Ξ΄
|
Mathlib.RingTheory.Kaehler.JacobiZariski
|
{R : Type uβ} β
{S : Type uβ} β
[inst : CommRing R] β
[inst_1 : CommRing S] β
[inst_2 : Algebra R S] β
{T : Type uβ} β
[inst_3 : CommRing T] β
[inst_4 : Algebra R T] β
[inst_5 : Algebra S T] β
[IsScalarTower R S T] β
{ΞΉ : Type wβ} β
{Ο : Type wβ} β
(Q : Algebra.Generators S T ΞΉ) β
Algebra.Generators R S Ο β Q.toExtension.H1Cotangent ββ[T] TensorProduct S T Ξ©[SβR]
|
Option.map_min
|
Init.Data.Option.Lemmas
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Min Ξ±] [inst_1 : Min Ξ²] {o o' : Option Ξ±} {f : Ξ± β Ξ²},
(β (x y : Ξ±), f (x β y) = f x β f y) β Option.map f (o β o') = Option.map f o β Option.map f o'
|
Ideal.quotientMap.eq_1
|
Mathlib.RingTheory.Ideal.Quotient.Operations
|
β {R : Type u} [inst : Ring R] {S : Type v} [inst_1 : Ring S] {I : Ideal R} (J : Ideal S) [inst_2 : I.IsTwoSided]
[inst_3 : J.IsTwoSided] (f : R β+* S) (hIJ : I β€ Ideal.comap f J),
Ideal.quotientMap J f hIJ = Ideal.Quotient.lift I ((Ideal.Quotient.mk J).comp f) β―
|
TopHom.map_top'
|
Mathlib.Order.Hom.Bounded
|
β {Ξ± : Type u_6} {Ξ² : Type u_7} [inst : Top Ξ±] [inst_1 : Top Ξ²] (self : TopHom Ξ± Ξ²), self.toFun β€ = β€
|
inf_lt_right
|
Mathlib.Order.Lattice
|
β {Ξ± : Type u} [inst : SemilatticeInf Ξ±] {a b : Ξ±}, a β b < b β Β¬b β€ a
|
_private.Lean.Meta.Check.0.Lean.Meta.addPPExplicitToExposeDiff.visit.match_24
|
Lean.Meta.Check
|
(motive : DoResultPR (Lean.Expr Γ Lean.Expr) (Lean.Expr Γ Lean.Expr) PUnit.{1} β Sort u_1) β
(r : DoResultPR (Lean.Expr Γ Lean.Expr) (Lean.Expr Γ Lean.Expr) PUnit.{1}) β
((a : Lean.Expr Γ Lean.Expr) β (u : PUnit.{1}) β motive (DoResultPR.pure a u)) β
((b : Lean.Expr Γ Lean.Expr) β (u : PUnit.{1}) β motive (DoResultPR.return b u)) β motive r
|
Mathlib.Tactic.RingNF.Config._sizeOf_inst
|
Mathlib.Tactic.Ring.RingNF
|
SizeOf Mathlib.Tactic.RingNF.Config
|
Action.forget_Ξ΅
|
Mathlib.CategoryTheory.Action.Monoidal
|
β (V : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} V] (G : Type u_2) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V],
CategoryTheory.Functor.LaxMonoidal.Ξ΅ (Action.forget V G) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit V)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.