name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Set.inv_mem_center
|
Mathlib.Algebra.Group.Center
|
β {M : Type u_1} [inst : DivisionMonoid M] {a : M}, a β Set.center M β aβ»ΒΉ β Set.center M
|
MeasureTheory.Measure.pi.isOpenPosMeasure
|
Mathlib.MeasureTheory.Constructions.Pi
|
β {ΞΉ : Type u_1} {Ξ± : ΞΉ β Type u_3} [inst : Fintype ΞΉ] [inst_1 : (i : ΞΉ) β MeasurableSpace (Ξ± i)]
(ΞΌ : (i : ΞΉ) β MeasureTheory.Measure (Ξ± i)) [β (i : ΞΉ), MeasureTheory.SigmaFinite (ΞΌ i)]
[inst_3 : (i : ΞΉ) β TopologicalSpace (Ξ± i)] [β (i : ΞΉ), (ΞΌ i).IsOpenPosMeasure],
(MeasureTheory.Measure.pi ΞΌ).IsOpenPosMeasure
|
LocallyConstant.indicator_of_notMem
|
Mathlib.Topology.LocallyConstant.Basic
|
β {X : Type u_1} [inst : TopologicalSpace X] {R : Type u_5} [inst_1 : Zero R] {U : Set X} (f : LocallyConstant X R)
{a : X} (hU : IsClopen U), a β U β (f.indicator hU) a = 0
|
Lean.Grind.instCommRingUSize._proof_5
|
Init.GrindInstances.Ring.UInt
|
β (n : β) (a : USize), ββn * a = βn * a
|
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._proof_1_1
|
Init.Data.BitVec.Bitblast
|
β {w : β} {x : BitVec w}, x.toInt < 0 β 0 β€ x.toInt β False
|
Lean.Compiler.LCNF.specExtension
|
Lean.Compiler.LCNF.SpecInfo
|
Lean.SimplePersistentEnvExtension Lean.Compiler.LCNF.SpecEntry Lean.Compiler.LCNF.SpecState
|
Bipointed.swapEquiv_functor_map_toFun
|
Mathlib.CategoryTheory.Category.Bipointed
|
β {X Y : Bipointed} (f : X βΆ Y) (a : X.X), (Bipointed.swapEquiv.functor.map f).toFun a = f.toFun a
|
Batteries.RBNode.foldr.match_1
|
Batteries.Data.RBMap.Basic
|
{Ξ± : Type u_1} β
{Ο : Sort u_3} β
(motive : Batteries.RBNode Ξ± β Ο β Sort u_2) β
(x : Batteries.RBNode Ξ±) β
(x_1 : Ο) β
((b : Ο) β motive Batteries.RBNode.nil b) β
((c : Batteries.RBColor) β
(l : Batteries.RBNode Ξ±) β
(v : Ξ±) β (r : Batteries.RBNode Ξ±) β (b : Ο) β motive (Batteries.RBNode.node c l v r) b) β
motive x x_1
|
Nat.greatestFib.eq_1
|
Mathlib.Data.Nat.Fib.Zeckendorf
|
β (n : β), n.greatestFib = Nat.findGreatest (fun k => Nat.fib k β€ n) (n + 1)
|
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.getFieldDefaultValue?
|
Lean.Elab.Structure
|
Lean.Name β Array Lean.Expr β Lean.Name β Lean.Elab.Command.Structure.StructElabMβ (Option Lean.Expr)
|
surjOn_Icc_of_monotone_surjective
|
Mathlib.Order.Interval.Set.SurjOn
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : LinearOrder Ξ±] [inst_1 : PartialOrder Ξ²] {f : Ξ± β Ξ²},
Monotone f β Function.Surjective f β β {a b : Ξ±}, a β€ b β Set.SurjOn f (Set.Icc a b) (Set.Icc (f a) (f b))
|
MeasureTheory.JordanDecomposition.zero_posPart
|
Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan
|
β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±], MeasureTheory.JordanDecomposition.posPart 0 = 0
|
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_14
|
Mathlib.Data.List.Triplewise
|
β {Ξ± : Type u_1} (tail : List Ξ±) (i j k : β), i < j β j < k β k < tail.length + 1 β i < tail.length
|
MapClusterPt.prodMap
|
Mathlib.Topology.Constructions
|
β {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Ξ± : Type u_5} {Ξ² : Type u_6}
{f : Ξ± β X} {g : Ξ² β Y} {la : Filter Ξ±} {lb : Filter Ξ²} {x : X} {y : Y},
MapClusterPt x la f β MapClusterPt y lb g β MapClusterPt (x, y) (la ΓΛ’ lb) (Prod.map f g)
|
Std.Tactic.BVDecide.Normalize.BitVec.zero_ult'
|
Std.Tactic.BVDecide.Normalize.BitVec
|
β {w : β} (a : BitVec w), (0#w).ult a = !a == 0#w
|
GroupExtension.Splitting.semidirectProductMulEquiv
|
Mathlib.GroupTheory.GroupExtension.Basic
|
{N : Type u_1} β
{G : Type u_2} β
[inst : Group N] β
[inst_1 : Group G] β
{E : Type u_3} β [inst_2 : Group E] β {S : GroupExtension N E G} β (s : S.Splitting) β N β[s.conjAct] G β* E
|
CompTriple.IsId.rec
|
Mathlib.Logic.Function.CompTypeclasses
|
{M : Type u_1} β
{Ο : M β M} β
{motive : CompTriple.IsId Ο β Sort u} β ((eq_id : Ο = id) β motive β―) β (t : CompTriple.IsId Ο) β motive t
|
_private.Lean.Data.Array.0.Array.mask.match_1
|
Lean.Data.Array
|
{Ξ± : Type u_1} β
(motive : Option (Ξ± Γ Subarray Ξ±) β Sort u_2) β
(x : Option (Ξ± Γ Subarray Ξ±)) β
(Unit β motive none) β ((x : Ξ±) β (s' : Subarray Ξ±) β motive (some (x, s'))) β motive x
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go._unary._proof_3
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft
|
β {Ξ± : Type} [inst : Hashable Ξ±] [inst_1 : DecidableEq Ξ±] {w : β} (aig : Std.Sat.AIG Ξ±) (input : aig.RefVec w)
(distance curr : β) (hcurr : curr β€ w) (s : aig.RefVec curr) (hidx : curr < w) (hdist : Β¬curr < distance),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun curr hcurr => PSigma.casesOn hcurr fun hcurr s => w - curr)
β¨curr + 1, β¨β―, s.push (input.get (curr - distance) β―)β©β© β¨curr, β¨hcurr, sβ©β©
|
neg_add_cancel_comm_assoc
|
Mathlib.Algebra.Group.Defs
|
β {G : Type u_1} [inst : AddCommGroup G] (a b : G), -a + (b + a) = b
|
Set.countable_setOf_finite_subset
|
Mathlib.Data.Set.Countable
|
β {Ξ± : Type u} {s : Set Ξ±}, s.Countable β {t | t.Finite β§ t β s}.Countable
|
IntervalIntegrable.mono_set
|
Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic
|
β {Ξ΅ : Type u_3} [inst : TopologicalSpace Ξ΅] [inst_1 : ENormedAddMonoid Ξ΅] {f : β β Ξ΅} {a b c d : β}
{ΞΌ : MeasureTheory.Measure β} [TopologicalSpace.PseudoMetrizableSpace Ξ΅],
IntervalIntegrable f ΞΌ a b β Set.uIcc c d β Set.uIcc a b β IntervalIntegrable f ΞΌ c d
|
Set.restrict_ite_compl
|
Mathlib.Data.Set.Restrict
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} (f g : Ξ± β Ξ²) (s : Set Ξ±) [inst : (x : Ξ±) β Decidable (x β s)],
(sαΆ.restrict fun a => if a β s then f a else g a) = sαΆ.restrict g
|
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution_map
|
Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor
|
β {Cβ : Type u_1} {Cβ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} Cβ]
[inst_1 : CategoryTheory.Category.{v_2, u_2} Cβ] {Wβ : CategoryTheory.MorphismProperty Cβ}
{Wβ : CategoryTheory.MorphismProperty Cβ} (Ξ¦ : CategoryTheory.LocalizerMorphism Wβ Wβ) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] (L : CategoryTheory.Functor Cβ D) [inst_3 : L.IsLocalization Wβ]
{Xβ : Cβ} {Xβ : D} (y : L.obj Xβ βΆ Xβ) {R R' : Ξ¦.RightResolution Xβ} (Ο : R βΆ R'),
(CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution Ξ¦ L y).map Ο =
CategoryTheory.CostructuredArrow.homMk (CategoryTheory.StructuredArrow.homMk Ο.f β―) β―
|
descPochhammer_eval_eq_descFactorial
|
Mathlib.RingTheory.Polynomial.Pochhammer
|
β (R : Type u) [inst : Ring R] (n k : β), Polynomial.eval (βn) (descPochhammer R k) = β(n.descFactorial k)
|
ONote.NFBelow
|
Mathlib.SetTheory.Ordinal.Notation
|
ONote β Ordinal.{0} β Prop
|
Units.instDecidableEq
|
Mathlib.Algebra.Group.Units.Defs
|
{Ξ± : Type u} β [inst : Monoid Ξ±] β [DecidableEq Ξ±] β DecidableEq Ξ±Λ£
|
_private.Mathlib.Analysis.Complex.Convex.0.Complex.instPathConnectedSpaceUnits._simp_3
|
Mathlib.Analysis.Complex.Convex
|
β {a b : Prop}, (Β¬(a β§ b)) = (Β¬a β¨ Β¬b)
|
OneHomClass
|
Mathlib.Algebra.Group.Hom.Defs
|
(F : Type u_10) β (M : outParam (Type u_11)) β (N : outParam (Type u_12)) β [One M] β [One N] β [FunLike F M N] β Prop
|
Std.Do.Β«term_β§β_Β»
|
Std.Do.PostCond
|
Lean.TrailingParserDescr
|
R0Space.closure_singleton
|
Mathlib.Topology.Separation.Basic
|
β {X : Type u_1} [inst : TopologicalSpace X] [R0Space X] (x : X), closure {x} = (nhds x).ker
|
Fin.val_natCast
|
Mathlib.Data.Fin.Basic
|
β (a n : β) [inst : NeZero n], ββa = a % n
|
OneHom.coe_id
|
Mathlib.Algebra.Group.Hom.Defs
|
β {M : Type u_10} [inst : One M], β(OneHom.id M) = id
|
Std.DHashMap.Const.getKey!_unitOfList_of_contains_eq_false
|
Std.Data.DHashMap.Lemmas
|
β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} [EquivBEq Ξ±] [LawfulHashable Ξ±] [inst : Inhabited Ξ±] {l : List Ξ±} {k : Ξ±},
l.contains k = false β (Std.DHashMap.Const.unitOfList l).getKey! k = default
|
Finset.SupIndep.le_sup_iff
|
Mathlib.Order.SupIndep
|
β {Ξ± : Type u_1} {ΞΉ : Type u_3} [inst : Lattice Ξ±] [inst_1 : OrderBot Ξ±] {s t : Finset ΞΉ} {f : ΞΉ β Ξ±} {i : ΞΉ},
s.SupIndep f β t β s β i β s β (β (i : ΞΉ), f i β β₯) β (f i β€ t.sup f β i β t)
|
_private.Mathlib.Dynamics.TopologicalEntropy.CoverEntropy.0.Dynamics.nonempty_inter_of_coverMincard._simp_1_1
|
Mathlib.Dynamics.TopologicalEntropy.CoverEntropy
|
β {Ξ± : Type u} {ΞΉ : Sort v} {x : Ξ±} {s : ΞΉ β Set Ξ±}, (x β β i, s i) = β i, x β s i
|
_private.Mathlib.MeasureTheory.Integral.Bochner.L1.0.MeasureTheory.SimpleFunc.integral_mono_measure._simp_1_1
|
Mathlib.MeasureTheory.Integral.Bochner.L1
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : MeasurableSpace Ξ±] {f : MeasureTheory.SimpleFunc Ξ± Ξ²} {p : Ξ² β Prop},
(β y β f.range, p y) = β (x : Ξ±), p (f x)
|
_private.Mathlib.RingTheory.PowerSeries.Derivative.0.PowerSeries.derivativeFun_coe_mul_coe
|
Mathlib.RingTheory.PowerSeries.Derivative
|
β {R : Type u_1} [inst : CommSemiring R] (f g : Polynomial R),
(βf * βg).derivativeFun = βf * β(Polynomial.derivative g) + βg * β(Polynomial.derivative f)
|
TensorProduct.LieModule.map._proof_1
|
Mathlib.Algebra.Lie.TensorProduct
|
β {R : Type u_3} [inst : CommRing R] {L : Type u_6} {M : Type u_5} {N : Type u_4} {P : Type u_1} {Q : Type u_2}
[inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M]
[inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N]
[inst_9 : LieRingModule L N] [inst_10 : LieModule R L N] [inst_11 : AddCommGroup P] [inst_12 : Module R P]
[inst_13 : LieRingModule L P] [inst_14 : LieModule R L P] [inst_15 : AddCommGroup Q] [inst_16 : Module R Q]
[inst_17 : LieRingModule L Q] [inst_18 : LieModule R L Q] (f : M βββ
R,Lβ P) (g : N βββ
R,Lβ Q) {x : L}
{t : TensorProduct R M N}, (TensorProduct.map βf βg).toFun β
x, tβ = β
x, (TensorProduct.map βf βg).toFun tβ
|
ZeroHom.mk.noConfusion
|
Mathlib.Algebra.Group.Hom.Defs
|
{M : Type u_10} β
{N : Type u_11} β
{inst : Zero M} β
{inst_1 : Zero N} β
{P : Sort u} β
{toFun : M β N} β
{map_zero' : toFun 0 = 0} β
{toFun' : M β N} β
{map_zero'' : toFun' 0 = 0} β
{ toFun := toFun, map_zero' := map_zero' } = { toFun := toFun', map_zero' := map_zero'' } β
(toFun β toFun' β P) β P
|
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._simp_1_3
|
Init.Data.SInt.Lemmas
|
β {x y : Int8}, (x < y) = (x.toInt < y.toInt)
|
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.findAux.match_1.splitter
|
Batteries.Data.UnionFind.Basic
|
(self : Batteries.UnionFind) β
(motive : Batteries.UnionFind.FindAux self.size β Sort u_1) β
(x : Batteries.UnionFind.FindAux self.size) β
((arrβ : Array Batteries.UFNode) β
(root : Fin self.size) β (H : arrβ.size = self.size) β motive { s := arrβ, root := root, size_eq := H }) β
motive x
|
CategoryTheory.WithInitial.equivComma._proof_12
|
Mathlib.CategoryTheory.WithTerminal.Basic
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D]
{X Y : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D))}
(f : X βΆ Y),
CategoryTheory.CategoryStruct.comp
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := β―, map_comp := β― }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := β―, map_comp := β― }).map
f)
(CategoryTheory.Iso.refl
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := β―, map_comp := β― }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := β―, map_comp := β― }).obj
Y)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := β―, map_comp := β― }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := β―, map_comp := β― }).obj
X)).hom
((CategoryTheory.Functor.id
(CategoryTheory.Comma (CategoryTheory.Functor.const C)
(CategoryTheory.Functor.id (CategoryTheory.Functor C D)))).map
f)
|
Aesop.RuleBuilderOptions.indexingMode?
|
Aesop.Builder.Basic
|
Aesop.RuleBuilderOptions β Option Aesop.IndexingMode
|
Units.inv_mul_of_eq
|
Mathlib.Algebra.Group.Units.Defs
|
β {Ξ± : Type u} [inst : Monoid Ξ±] {u : Ξ±Λ£} {a : Ξ±}, βu = a β βuβ»ΒΉ * a = 1
|
Nonneg.mk_smul
|
Mathlib.Algebra.Order.Nonneg.Module
|
β {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : SMul R S] (a : R) (ha : 0 β€ a)
(x : S), β¨a, haβ© β’ x = a β’ x
|
Set.preimage_singleton_eq_empty
|
Mathlib.Data.Set.Image
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β Ξ²} {y : Ξ²}, f β»ΒΉ' {y} = β
β y β Set.range f
|
Set.isSimpleOrder_Iic_iff_isAtom
|
Mathlib.Order.Atoms
|
β {Ξ± : Type u_2} [inst : PartialOrder Ξ±] [inst_1 : OrderBot Ξ±] {a : Ξ±}, IsSimpleOrder β(Set.Iic a) β IsAtom a
|
CategoryTheory.MonoidalCategory.fullSubcategory._proof_11
|
Mathlib.CategoryTheory.Monoidal.Category
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C) {Xβ Xβ Xβ Yβ Yβ Yβ : P.FullSubcategory} (fβ : Xβ.obj βΆ Yβ.obj)
(fβ : Xβ.obj βΆ Yβ.obj) (fβ : Xβ.obj βΆ Yβ.obj),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.tensorHom fβ fβ) fβ)
(CategoryTheory.MonoidalCategoryStruct.associator Yβ.obj Yβ.obj Yβ.obj).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Xβ.obj Xβ.obj Xβ.obj).hom
(CategoryTheory.MonoidalCategoryStruct.tensorHom fβ (CategoryTheory.MonoidalCategoryStruct.tensorHom fβ fβ))
|
Lean.Elab.Tactic.Conv.PatternMatchState.rec
|
Lean.Elab.Tactic.Conv.Pattern
|
{motive : Lean.Elab.Tactic.Conv.PatternMatchState β Sort u} β
((subgoals : Array Lean.MVarId) β motive (Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals)) β
((subgoals : Array (β Γ Lean.MVarId)) β
(idx : β) β
(remaining : List (β Γ β)) β motive (Lean.Elab.Tactic.Conv.PatternMatchState.occs subgoals idx remaining)) β
(t : Lean.Elab.Tactic.Conv.PatternMatchState) β motive t
|
OrderMonoidHom.inrβ
|
Mathlib.Algebra.Order.Monoid.Lex
|
(Ξ± : Type u_1) β
(Ξ² : Type u_2) β
[inst : Monoid Ξ±] β [inst_1 : PartialOrder Ξ±] β [inst_2 : Monoid Ξ²] β [inst_3 : Preorder Ξ²] β Ξ² β*o Lex (Ξ± Γ Ξ²)
|
selfAdjoint.instField._proof_12
|
Mathlib.Algebra.Star.SelfAdjoint
|
β {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (x : β€), ββx = ββx
|
WithBot.map_zero
|
Mathlib.Algebra.Order.Monoid.Unbundled.WithTop
|
β {Ξ± : Type u} [inst : Zero Ξ±] {Ξ² : Type u_1} (f : Ξ± β Ξ²), WithBot.map f 0 = β(f 0)
|
ZeroHom.instModule._proof_1
|
Mathlib.Algebra.Module.Hom
|
β {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : Semiring R] [inst_1 : AddMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R B] (r : R), r β’ 0 = 0
|
ConvexOn.lt_left_of_right_lt'
|
Mathlib.Analysis.Convex.Function
|
β {π : Type u_1} {E : Type u_2} {Ξ² : Type u_5} [inst : Semiring π] [inst_1 : PartialOrder π] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid Ξ²] [inst_4 : LinearOrder Ξ²] [IsOrderedCancelAddMonoid Ξ²] [inst_6 : Module π E]
[inst_7 : Module π Ξ²] [PosSMulStrictMono π Ξ²] {s : Set E} {f : E β Ξ²},
ConvexOn π s f β
β {x y : E},
x β s β y β s β β {a b : π}, 0 < a β 0 < b β a + b = 1 β f y < f (a β’ x + b β’ y) β f (a β’ x + b β’ y) < f x
|
Except.ctorIdx
|
Init.Prelude
|
{Ξ΅ : Type u} β {Ξ± : Type v} β Except Ξ΅ Ξ± β β
|
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_2
|
Mathlib.Algebra.Divisibility.Prod
|
β {Ξ± : Sort u} {Ξ² : Ξ± β Sort v} {f g : (x : Ξ±) β Ξ² x}, (f = g) = β (x : Ξ±), f x = g x
|
AlgebraicGeometry.Scheme.basicOpen_le
|
Mathlib.AlgebraicGeometry.Scheme
|
β (X : AlgebraicGeometry.Scheme) {U : X.Opens} (f : β(X.presheaf.obj (Opposite.op U))), X.basicOpen f β€ U
|
CategoryTheory.Precoverage.mem_coverings_of_isIso
|
Mathlib.CategoryTheory.Sites.Precoverage
|
β {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.Precoverage C} [self : J.HasIsos] {S T : C}
(f : S βΆ T) [CategoryTheory.IsIso f], CategoryTheory.Presieve.singleton f β J.coverings T
|
Primrec.PrimrecBounded
|
Mathlib.Computability.Primrec
|
{Ξ± : Type u_1} β {Ξ² : Type u_2} β [Primcodable Ξ±] β [Primcodable Ξ²] β (Ξ± β Ξ²) β Prop
|
Order.Ideal.toLowerSet_injective
|
Mathlib.Order.Ideal
|
β {P : Type u_1} [inst : LE P], Function.Injective Order.Ideal.toLowerSet
|
SimpleGraph.cliqueFinset_eq_empty_iff
|
Mathlib.Combinatorics.SimpleGraph.Clique
|
β {Ξ± : Type u_1} {G : SimpleGraph Ξ±} [inst : Fintype Ξ±] [inst_1 : DecidableEq Ξ±] [inst_2 : DecidableRel G.Adj] {n : β},
G.cliqueFinset n = β
β G.CliqueFree n
|
LieAlgebra.IsExtension.range_eq_top
|
Mathlib.Algebra.Lie.Extension
|
β {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} {inst : CommRing R} {inst_1 : LieRing L}
{inst_2 : LieAlgebra R L} {inst_3 : LieRing N} {inst_4 : LieAlgebra R N} {inst_5 : LieRing M}
{inst_6 : LieAlgebra R M} (i : N βββ
Rβ L) {p : L βββ
Rβ M} [self : LieAlgebra.IsExtension i p], p.range = β€
|
CategoryTheory.OverPresheafAux.restrictedYoneda._proof_3
|
Mathlib.CategoryTheory.Comma.Presheaf.Basic
|
β {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cα΅α΅ (Type u_2))
{X Y : CategoryTheory.Over A} (Ξ΅ : X βΆ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Functor Cα΅α΅ (Type u_2))).map Ξ΅.left)
Y.hom =
CategoryTheory.CategoryStruct.comp X.hom ((CategoryTheory.Functor.fromPUnit A).map Ξ΅.right)
|
Finset.Colex.toColex_sdiff_lt_toColex_sdiff'
|
Mathlib.Combinatorics.Colex
|
β {Ξ± : Type u_1} [inst : PartialOrder Ξ±] {s t : Finset Ξ±} [inst_1 : DecidableEq Ξ±],
toColex (s \ t) < toColex (t \ s) β toColex s < toColex t
|
Lean.Parser.ParserResolution.alias
|
Lean.Parser.Extension
|
Lean.Parser.ParserAliasValue β Lean.Parser.ParserResolution
|
HasSubset.noConfusion
|
Init.Core
|
{P : Sort u_1} β
{Ξ± : Type u} β
{t : HasSubset Ξ±} β {Ξ±' : Type u} β {t' : HasSubset Ξ±'} β Ξ± = Ξ±' β t β t' β HasSubset.noConfusionType P t t'
|
Lean.Lsp.FileIdent.casesOn
|
Lean.Server.FileSource
|
{motive : Lean.Lsp.FileIdent β Sort u} β
(t : Lean.Lsp.FileIdent) β
((uri : Lean.Lsp.DocumentUri) β motive (Lean.Lsp.FileIdent.uri uri)) β
((mod : Lean.Name) β motive (Lean.Lsp.FileIdent.mod mod)) β motive t
|
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion.match_1
|
Lean.Meta.LazyDiscrTree
|
(motive : Lean.Name β Sort u_1) β
(declName : Lean.Name) β ((pre : Lean.Name) β motive (pre.str "inj")) β ((x : Lean.Name) β motive x) β motive declName
|
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateArgsImp
|
Lean.Compiler.LCNF.Basic
|
Lean.Compiler.LCNF.LetValue β Array Lean.Compiler.LCNF.Arg β Lean.Compiler.LCNF.LetValue
|
CategoryTheory.IsDiscrete.sum
|
Mathlib.CategoryTheory.Discrete.SumsProducts
|
β (C : Type u_1) (C' : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C'] [CategoryTheory.IsDiscrete C] [CategoryTheory.IsDiscrete C'],
CategoryTheory.IsDiscrete (C β C')
|
USize.toNat_sub_of_le
|
Init.Data.UInt.Lemmas
|
β (a b : USize), b β€ a β (a - b).toNat = a.toNat - b.toNat
|
_private.Init.Data.Array.BinSearch.0.Array.binSearchAux._proof_3
|
Init.Data.Array.BinSearch
|
β {Ξ± : Type u_1} (as : Array Ξ±) (lo : Fin (as.size + 1)) (hi : Fin as.size),
βlo β€ βhi β Β¬(βlo + βhi) / 2 < as.size β False
|
PNat.XgcdType.flip_b
|
Mathlib.Data.PNat.Xgcd
|
β (u : PNat.XgcdType), u.flip.b = u.a
|
Lean.Lsp.LeanIleanInfoParams.recOn
|
Lean.Data.Lsp.Internal
|
{motive : Lean.Lsp.LeanIleanInfoParams β Sort u} β
(t : Lean.Lsp.LeanIleanInfoParams) β
((version : β) β
(references : Lean.Lsp.ModuleRefs) β
(decls : Lean.Lsp.Decls) β motive { version := version, references := references, decls := decls }) β
motive t
|
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Poly.combine_k_eq_combine._simp_1_8
|
Init.Grind.Ring.CommSolver
|
β (mβ mβ : Lean.Grind.CommRing.Mon), mβ.grevlex mβ = mβ.grevlex_k mβ
|
Complex.isOpen_im_lt_EReal
|
Mathlib.Analysis.Complex.HalfPlane
|
β (x : EReal), IsOpen {z | βz.im < x}
|
CategoryTheory.Bundled.mk.noConfusion
|
Mathlib.CategoryTheory.ConcreteCategory.Bundled
|
{c : Type u β Type v} β
{P : Sort u_1} β
{Ξ± : Type u} β
{str : autoParam (c Ξ±) CategoryTheory.Bundled.str._autoParam} β
{Ξ±' : Type u} β
{str' : autoParam (c Ξ±') CategoryTheory.Bundled.str._autoParam} β
{ Ξ± := Ξ±, str := str } = { Ξ± := Ξ±', str := str' } β (Ξ± = Ξ±' β str β str' β P) β P
|
Std.ExtDTreeMap.size_le_size_erase
|
Std.Data.ExtDTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.ExtDTreeMap Ξ± Ξ² cmp} [inst : Std.TransCmp cmp]
{k : Ξ±}, t.size β€ (t.erase k).size + 1
|
riemannZeta.eq_1
|
Mathlib.NumberTheory.LSeries.RiemannZeta
|
riemannZeta = HurwitzZeta.hurwitzZetaEven 0
|
CategoryTheory.ProjectivePresentation.noConfusionType
|
Mathlib.CategoryTheory.Preadditive.Projective.Basic
|
Sort u_1 β
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{X : C} β
CategoryTheory.ProjectivePresentation X β
{C' : Type u} β
[inst' : CategoryTheory.Category.{v, u} C'] β
{X' : C'} β CategoryTheory.ProjectivePresentation X' β Sort u_1
|
HahnSeries.instAddGroup._proof_8
|
Mathlib.RingTheory.HahnSeries.Addition
|
β {Ξ : Type u_1} {R : Type u_2} [inst : PartialOrder Ξ] [inst_1 : AddGroup R] (n : β) (x : HahnSeries Ξ R),
Int.negSucc n β’ x = -(βn.succ β’ x)
|
_private.Mathlib.MeasureTheory.Measure.HasOuterApproxClosed.0.MeasureTheory.measure_of_cont_bdd_of_tendsto_filter_indicator._simp_1_1
|
Mathlib.MeasureTheory.Measure.HasOuterApproxClosed
|
β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±}, MeasurableSet Set.univ = True
|
Filter.comk.congr_simp
|
Mathlib.Order.Filter.Basic
|
β {Ξ± : Type u_1} (p p_1 : Set Ξ± β Prop) (e_p : p = p_1) (he : p β
) (hmono : β (t : Set Ξ±), p t β β s β t, p s)
(hunion : β (s : Set Ξ±), p s β β (t : Set Ξ±), p t β p (s βͺ t)), Filter.comk p he hmono hunion = Filter.comk p_1 β― β― β―
|
CategoryTheory.Pretriangulated.Triangle.epiβ
|
Mathlib.CategoryTheory.Triangulated.Pretriangulated
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C β€] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : β (n : β€), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
β T β CategoryTheory.Pretriangulated.distinguishedTriangles, T.morβ = 0 β CategoryTheory.Epi T.morβ
|
AddSemigroupIdeal.fg_iff
|
Mathlib.Algebra.Group.Ideal
|
β {M : Type u_1} [inst : Add M] {I : AddSemigroupIdeal M}, I.FG β β s, I = AddSemigroupIdeal.closure βs
|
Std.ExtTreeMap.isEmpty_eq_size_beq_zero
|
Std.Data.ExtTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.ExtTreeMap Ξ± Ξ² cmp}, t.isEmpty = (t.size == 0)
|
NormedAddGroupHom.incl._proof_3
|
Mathlib.Analysis.Normed.Group.Hom
|
β {V : Type u_1} [inst : SeminormedAddCommGroup V] (s : AddSubgroup V), β C, β (v : β₯s), ββvβ β€ C * βvβ
|
CategoryTheory.BundledHom.casesOn
|
Mathlib.CategoryTheory.ConcreteCategory.BundledHom
|
{c : Type u β Type u} β
{hom : β¦Ξ± Ξ² : Type uβ¦ β c Ξ± β c Ξ² β Type u} β
{motive : CategoryTheory.BundledHom hom β Sort u_1} β
(t : CategoryTheory.BundledHom hom) β
((toFun : {Ξ± Ξ² : Type u} β (IΞ± : c Ξ±) β (IΞ² : c Ξ²) β hom IΞ± IΞ² β Ξ± β Ξ²) β
(id : {Ξ± : Type u} β (I : c Ξ±) β hom I I) β
(comp : {Ξ± Ξ² Ξ³ : Type u} β (IΞ± : c Ξ±) β (IΞ² : c Ξ²) β (IΞ³ : c Ξ³) β hom IΞ² IΞ³ β hom IΞ± IΞ² β hom IΞ± IΞ³) β
(hom_ext : β {Ξ± Ξ² : Type u} (IΞ± : c Ξ±) (IΞ² : c Ξ²), Function.Injective (toFun IΞ± IΞ²)) β
(id_toFun : β {Ξ± : Type u} (I : c Ξ±), toFun I I (id I) = _root_.id) β
(comp_toFun :
β {Ξ± Ξ² Ξ³ : Type u} (IΞ± : c Ξ±) (IΞ² : c Ξ²) (IΞ³ : c Ξ³) (f : hom IΞ± IΞ²) (g : hom IΞ² IΞ³),
toFun IΞ± IΞ³ (comp IΞ± IΞ² IΞ³ g f) = toFun IΞ² IΞ³ g β toFun IΞ± IΞ² f) β
motive
{ toFun := toFun, id := id, comp := comp, hom_ext := hom_ext, id_toFun := id_toFun,
comp_toFun := comp_toFun }) β
motive t
|
Part.Mem
|
Mathlib.Data.Part
|
{Ξ± : Type u_1} β Part Ξ± β Ξ± β Prop
|
Lean.Server.Watchdog.WorkerEvent.casesOn
|
Lean.Server.Watchdog
|
{motive : Lean.Server.Watchdog.WorkerEvent β Sort u} β
(t : Lean.Server.Watchdog.WorkerEvent) β
motive Lean.Server.Watchdog.WorkerEvent.terminated β
motive Lean.Server.Watchdog.WorkerEvent.importsChanged β
((exitCode : UInt32) β motive (Lean.Server.Watchdog.WorkerEvent.crashed exitCode)) β
((e : IO.Error) β motive (Lean.Server.Watchdog.WorkerEvent.ioError e)) β motive t
|
Acc.ndrec
|
Init.WF
|
{Ξ± : Sort u2} β
{r : Ξ± β Ξ± β Prop} β
{C : Ξ± β Sort u1} β
((x : Ξ±) β (β (y : Ξ±), r y x β Acc r y) β ((y : Ξ±) β r y x β C y) β C x) β {a : Ξ±} β Acc r a β C a
|
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameM
|
Lean.Elab.DeclNameGen
|
Type β Type
|
Std.DTreeMap.Const.get!_modify_self
|
Std.Data.DTreeMap.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} [Std.TransCmp cmp] {Ξ² : Type v} {t : Std.DTreeMap Ξ± (fun x => Ξ²) cmp} {k : Ξ±}
[inst : Inhabited Ξ²] {f : Ξ² β Ξ²},
Std.DTreeMap.Const.get! (Std.DTreeMap.Const.modify t k f) k = (Option.map f (Std.DTreeMap.Const.get? t k)).get!
|
Prod.instCoheytingAlgebra._proof_2
|
Mathlib.Order.Heyting.Basic
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : CoheytingAlgebra Ξ±] [inst_1 : CoheytingAlgebra Ξ²] (a : Ξ± Γ Ξ²), β€ \ a = οΏ’a
|
SSet.StrictSegal.ofIsStrictSegal._proof_2
|
Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal
|
β (X : SSet) [inst : X.IsStrictSegal] (n : β), (Equiv.ofBijective (X.spine n) β―).invFun β X.spine n = id
|
CoalgHom.mk._flat_ctor
|
Mathlib.RingTheory.Coalgebra.Hom
|
{R : Type u_1} β
{A : Type u_2} β
{B : Type u_3} β
[inst : CommSemiring R] β
[inst_1 : AddCommMonoid A] β
[inst_2 : Module R A] β
[inst_3 : AddCommMonoid B] β
[inst_4 : Module R B] β
[inst_5 : CoalgebraStruct R A] β
[inst_6 : CoalgebraStruct R B] β
(toFun : A β B) β
(map_add' : β (x y : A), toFun (x + y) = toFun x + toFun y) β
(map_smul' : β (m : R) (x : A), toFun (m β’ x) = (RingHom.id R) m β’ toFun x) β
CoalgebraStruct.counit ββ { toFun := toFun, map_add' := map_add', map_smul' := map_smul' } =
CoalgebraStruct.counit β
TensorProduct.map { toFun := toFun, map_add' := map_add', map_smul' := map_smul' }
{ toFun := toFun, map_add' := map_add', map_smul' := map_smul' } ββ
CoalgebraStruct.comul =
CoalgebraStruct.comul ββ
{ toFun := toFun, map_add' := map_add', map_smul' := map_smul' } β
A ββc[R] B
|
vectorSpan_mono
|
Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs
|
β (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {sβ sβ : Set P}, sβ β sβ β vectorSpan k sβ β€ vectorSpan k sβ
|
BoxIntegral.Prepartition.mk.sizeOf_spec
|
Mathlib.Analysis.BoxIntegral.Partition.Basic
|
β {ΞΉ : Type u_1} {I : BoxIntegral.Box ΞΉ} [inst : SizeOf ΞΉ] (boxes : Finset (BoxIntegral.Box ΞΉ))
(le_of_mem' : β J β boxes, J β€ I)
(pairwiseDisjoint : (βboxes).Pairwise (Function.onFun Disjoint BoxIntegral.Box.toSet)),
sizeOf { boxes := boxes, le_of_mem' := le_of_mem', pairwiseDisjoint := pairwiseDisjoint } = 1 + sizeOf boxes
|
Lean.Name.str._impl
|
Init.Prelude
|
UInt64 β Lean.Name β String β Lean.Name._impl
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.