name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Std.DTreeMap.Internal.Impl.link2._proof_19
|
Std.Data.DTreeMap.Internal.Operations
|
β {Ξ± : Type u_1} {Ξ² : Ξ± β Type u_2} (l r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) (szl : β) (k' : Ξ±) (v' : Ξ² k')
(l' r' : Std.DTreeMap.Internal.Impl Ξ± Ξ²),
(Std.DTreeMap.Internal.Impl.inner szl k' v' l' r').Balanced β
l = Std.DTreeMap.Internal.Impl.inner szl k' v' l' r' β
β (szr : β) (k'' : Ξ±) (v'' : Ξ² k'') (l'' r'' : Std.DTreeMap.Internal.Impl Ξ± Ξ²),
(Std.DTreeMap.Internal.Impl.inner szr k'' v'' l'' r'').Balanced β
r = Std.DTreeMap.Internal.Impl.inner szr k'' v'' l'' r'' β l''.Balanced
|
Homotopy.ext
|
Mathlib.Algebra.Homology.Homotopy
|
β {ΞΉ : Type u_1} {V : Type u} {inst : CategoryTheory.Category.{v, u} V} {inst_1 : CategoryTheory.Preadditive V}
{c : ComplexShape ΞΉ} {C D : HomologicalComplex V c} {f g : C βΆ D} {x y : Homotopy f g}, x.hom = y.hom β x = y
|
ContinuousLinearMap.cont._autoParam
|
Mathlib.Topology.Algebra.Module.LinearMap
|
Lean.Syntax
|
_private.Lean.Data.Json.Printer.0.Lean.Json.needEscape.go._proof_3
|
Lean.Data.Json.Printer
|
β (s : String), β i < s.utf8ByteSize, InvImage (fun x1 x2 => x1 < x2) (fun x => s.utf8ByteSize - x) (i + 1) i
|
Lean.Elab.ComputedFields.Context.compFieldVars
|
Lean.Elab.ComputedFields
|
Lean.Elab.ComputedFields.Context β Array Lean.Expr
|
WithTop.instOrderedSub
|
Mathlib.Algebra.Order.Sub.WithTop
|
β {Ξ± : Type u_1} [inst : Add Ξ±] [inst_1 : LE Ξ±] [inst_2 : OrderBot Ξ±] [inst_3 : Sub Ξ±] [OrderedSub Ξ±],
OrderedSub (WithTop Ξ±)
|
CoalgCat.Hom.casesOn
|
Mathlib.Algebra.Category.CoalgCat.Basic
|
{R : Type u} β
[inst : CommRing R] β
{V W : CoalgCat R} β
{motive : V.Hom W β Sort u_1} β
(t : V.Hom W) β
((toCoalgHom' : βV.toModuleCat ββc[R] βW.toModuleCat) β motive { toCoalgHom' := toCoalgHom' }) β motive t
|
AddSemigroupIdeal.coe_closure'
|
Mathlib.Algebra.Group.Ideal
|
β {M : Type u_1} [inst : AddMonoid M] {s : Set M}, β(AddSemigroupIdeal.closure s) = Set.univ + s
|
Finset.Colex._sizeOf_1
|
Mathlib.Combinatorics.Colex
|
{Ξ± : Type u_3} β [SizeOf Ξ±] β Finset.Colex Ξ± β β
|
zpow_natCast
|
Mathlib.Algebra.Group.Defs
|
β {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : β), a ^ βn = a ^ n
|
SimplicialObject.Split.nondegComplexFunctor_map_f
|
Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject
|
β {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{Sβ Sβ : SimplicialObject.Split C} (Ξ¦ : Sβ βΆ Sβ) (n : β),
(SimplicialObject.Split.nondegComplexFunctor.map Ξ¦).f n = Ξ¦.f n
|
Lean.Meta.TransparencyMode.reducible
|
Init.MetaTypes
|
Lean.Meta.TransparencyMode
|
intervalIntegral.integral_mono_on_of_le_Ioo
|
Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic
|
β {f g : β β β} {a b : β} {ΞΌ : MeasureTheory.Measure β},
a β€ b β
IntervalIntegrable f ΞΌ a b β
IntervalIntegrable g ΞΌ a b β
β [MeasureTheory.NoAtoms ΞΌ],
(β x β Set.Ioo a b, f x β€ g x) β β« (u : β) in a..b, f u βΞΌ β€ β« (u : β) in a..b, g u βΞΌ
|
CategoryTheory.locallyDiscreteBicategory._proof_17
|
Mathlib.CategoryTheory.Bicategory.LocallyDiscrete
|
β (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] {a b c d : CategoryTheory.LocallyDiscrete C}
{f f' : a βΆ b} (Ξ· : f βΆ f') (g : b βΆ c) (h : c βΆ d),
CategoryTheory.eqToHom β― =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom β―)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom β―) (CategoryTheory.eqToHom β―))
|
Aesop.instInhabitedRulePattern
|
Aesop.RulePattern
|
Inhabited Aesop.RulePattern
|
Lean.Meta.getCoeFnInfo?
|
Lean.Meta.CoeAttr
|
Lean.Name β Lean.CoreM (Option Lean.Meta.CoeFnInfo)
|
AddEquiv.symm_map_add
|
Mathlib.Algebra.Group.Equiv.Defs
|
β {M : Type u_9} {N : Type u_10} [inst : Add M] [inst_1 : Add N] (h : M β+ N) (x y : N),
h.symm (x + y) = h.symm x + h.symm y
|
MvPolynomial.instIsPushout
|
Mathlib.RingTheory.TensorProduct.MvPolynomial
|
β {R : Type u} [inst : CommSemiring R] {Ο : Type u_1} {S : Type u_3} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
Algebra.IsPushout R S (MvPolynomial Ο R) (MvPolynomial Ο S)
|
Aesop.UnsafeRuleInfo.mk.injEq
|
Aesop.Rule
|
β (successProbability successProbability_1 : Aesop.Percent),
({ successProbability := successProbability } = { successProbability := successProbability_1 }) =
(successProbability = successProbability_1)
|
QuadraticAlgebra.mk_eq_add_smul_omega
|
Mathlib.Algebra.QuadraticAlgebra.Basic
|
β {R : Type u_1} {a b : R} [inst : CommSemiring R] (x y : R),
{ re := x, im := y } = (algebraMap R (QuadraticAlgebra R a b)) x + y β’ QuadraticAlgebra.omega
|
UniformFun.uniformCore.match_7
|
Mathlib.Topology.UniformSpace.UniformConvergenceTopology
|
β (Ξ² : Type u_1) [inst : UniformSpace Ξ²] (w : Set (Ξ² Γ Ξ²)) (motive : (β t β uniformity Ξ², SetRel.comp t t β w) β Prop)
(x : β t β uniformity Ξ², SetRel.comp t t β w),
(β (W : Set (Ξ² Γ Ξ²)) (hW : W β uniformity Ξ²) (hWV : SetRel.comp W W β w), motive β―) β motive x
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_alter._simp_1_2
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {instOrd : Ord Ξ±} {a b : Ξ±}, (compare a b β Ordering.eq) = ((a == b) = false)
|
tsum_geometric_two'
|
Mathlib.Analysis.SpecificLimits.Basic
|
β (a : β), β' (n : β), a / 2 / 2 ^ n = a
|
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Rawβ.insert._proof_3
|
Std.Data.DHashMap.Internal.Defs
|
β {Ξ± : Type u_1} {Ξ² : Ξ± β Type u_2} (a : Ξ±) (b : Ξ² a) (size : β)
(buckets : Array (Std.DHashMap.Internal.AssocList Ξ± Ξ²)),
0 < { size := size, buckets := buckets }.buckets.size β
β (i : USize) (h : i.toNat < buckets.size),
0 <
{ size := size + 1,
buckets := buckets.uset i (Std.DHashMap.Internal.AssocList.cons a b buckets[i]) h }.buckets.size
|
Lean.instReprDefinitionSafety
|
Lean.Declaration
|
Repr Lean.DefinitionSafety
|
Aesop.Script.StaticStructureM.Context._sizeOf_1
|
Aesop.Script.StructureStatic
|
Aesop.Script.StaticStructureM.Context β β
|
Lean.VersoModuleDocs.isEmpty
|
Lean.DocString.Extension
|
Lean.VersoModuleDocs β Bool
|
Set.Finite.encard_biUnion_le
|
Mathlib.Data.Set.Card.Arithmetic
|
β {Ξ± : Type u_1} {ΞΉ : Type u_2} {t : Set ΞΉ},
t.Finite β β (s : ΞΉ β Set Ξ±), (β i β t, s i).encard β€ βαΆ (i : ΞΉ) (_ : i β t), (s i).encard
|
Set.prod_add_prod_comm
|
Mathlib.Algebra.Group.Pointwise.Set.Basic
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : Add Ξ±] [inst_1 : Add Ξ²] (sβ sβ : Set Ξ±) (tβ tβ : Set Ξ²),
sβ ΓΛ’ tβ + sβ ΓΛ’ tβ = (sβ + sβ) ΓΛ’ (tβ + tβ)
|
SpectrumRestricts.compactSpace
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict
|
β {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : Semifield R] [inst_1 : Semifield S] [inst_2 : Ring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A]
[inst_7 : TopologicalSpace R] [inst_8 : TopologicalSpace S] {a : A} (f : C(S, R)),
SpectrumRestricts a βf β β [h_cpct : CompactSpace β(spectrum S a)], CompactSpace β(spectrum R a)
|
Lean.Parser.Term.num.parenthesizer
|
Lean.Parser.Term
|
Lean.PrettyPrinter.Parenthesizer
|
Subsemigroup.centerToMulOpposite._proof_2
|
Mathlib.GroupTheory.Submonoid.Center
|
β {M : Type u_1} [inst : Mul M] (x : β₯(Subsemigroup.center Mα΅α΅α΅)),
β¨MulOpposite.op ββ¨MulOpposite.unop βx, β―β©, β―β© = β¨MulOpposite.op ββ¨MulOpposite.unop βx, β―β©, β―β©
|
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Visibility.isPublic._sparseCasesOn_1
|
Lean.Elab.DeclModifiers
|
{motive : Lean.Elab.Visibility β Sort u} β
(t : Lean.Elab.Visibility) β motive Lean.Elab.Visibility.public β (Nat.hasNotBit 4 t.ctorIdx β motive t) β motive t
|
CategoryTheory.LocalizerMorphism.homMap_comp
|
Mathlib.CategoryTheory.Localization.HomEquiv
|
β {Cβ : Type u_2} {Cβ : Type u_3} {Dβ : Type u_5} {Dβ : Type u_6} [inst : CategoryTheory.Category.{v_2, u_2} Cβ]
[inst_1 : CategoryTheory.Category.{v_3, u_3} Cβ] [inst_2 : CategoryTheory.Category.{v_5, u_5} Dβ]
[inst_3 : CategoryTheory.Category.{v_6, u_6} Dβ] {Wβ : CategoryTheory.MorphismProperty Cβ}
{Wβ : CategoryTheory.MorphismProperty Cβ} (Ξ¦ : CategoryTheory.LocalizerMorphism Wβ Wβ)
(Lβ : CategoryTheory.Functor Cβ Dβ) [inst_4 : Lβ.IsLocalization Wβ] (Lβ : CategoryTheory.Functor Cβ Dβ)
[inst_5 : Lβ.IsLocalization Wβ] {X Y Z : Cβ} (f : Lβ.obj X βΆ Lβ.obj Y) (g : Lβ.obj Y βΆ Lβ.obj Z),
Ξ¦.homMap Lβ Lβ (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (Ξ¦.homMap Lβ Lβ f) (Ξ¦.homMap Lβ Lβ g)
|
CochainComplex.HomComplex.Cochain.ofHom_v
|
Mathlib.Algebra.Homology.HomotopyCategory.HomComplex
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C β€} (Ο : F βΆ G) (p : β€), (CochainComplex.HomComplex.Cochain.ofHom Ο).v p p β― = Ο.f p
|
_private.Mathlib.Data.Nat.Log.0.Nat.log.go_spec._simp_1_4
|
Mathlib.Data.Nat.Log
|
β {n : β}, (1 β€ n) = (n β 0)
|
RootPairing.EmbeddedG2.mem_span_of_mem_allRoots
|
Mathlib.LinearAlgebra.RootSystem.Finite.G2
|
β {ΞΉ : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ΞΉ R M N)
[inst_5 : P.EmbeddedG2] [Finite ΞΉ] [CharZero R] [IsDomain R] {x : M},
x β RootPairing.EmbeddedG2.allRoots P β
x β Submodule.span β€ {RootPairing.EmbeddedG2.longRoot P, RootPairing.EmbeddedG2.shortRoot P}
|
Batteries.RBNode.Balanced.below.casesOn
|
Batteries.Data.RBMap.Basic
|
β {Ξ± : Type u_1} {motive : (a : Batteries.RBNode Ξ±) β (a_1 : Batteries.RBColor) β (a_2 : β) β a.Balanced a_1 a_2 β Prop}
{motive_1 :
{a : Batteries.RBNode Ξ±} β
{a_1 : Batteries.RBColor} β {a_2 : β} β (t : a.Balanced a_1 a_2) β Batteries.RBNode.Balanced.below t β Prop}
{a : Batteries.RBNode Ξ±} {a_1 : Batteries.RBColor} {a_2 : β} {t : a.Balanced a_1 a_2}
(t_1 : Batteries.RBNode.Balanced.below t),
motive_1 β― β― β
(β {x : Batteries.RBNode Ξ±} {n : β} {y : Batteries.RBNode Ξ±} {v : Ξ±} (a : x.Balanced Batteries.RBColor.black n)
(a_3 : y.Balanced Batteries.RBColor.black n) (ih : Batteries.RBNode.Balanced.below a)
(a_ih : motive x Batteries.RBColor.black n a) (ih_1 : Batteries.RBNode.Balanced.below a_3)
(a_ih_1 : motive y Batteries.RBColor.black n a_3), motive_1 β― β―) β
(β {x : Batteries.RBNode Ξ±} {cβ : Batteries.RBColor} {n : β} {y : Batteries.RBNode Ξ±} {cβ : Batteries.RBColor}
{v : Ξ±} (a : x.Balanced cβ n) (a_3 : y.Balanced cβ n) (ih : Batteries.RBNode.Balanced.below a)
(a_ih : motive x cβ n a) (ih_1 : Batteries.RBNode.Balanced.below a_3) (a_ih_1 : motive y cβ n a_3),
motive_1 β― β―) β
motive_1 t t_1
|
CategoryTheory.ProjectiveResolution.ofComplex._proof_3
|
Mathlib.CategoryTheory.Abelian.Projective.Resolution
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Xβ Xβ : C}
(f : Xβ βΆ Xβ), CategoryTheory.Limits.HasKernel f
|
Algebra.Etale.comp
|
Mathlib.RingTheory.Etale.Basic
|
β (R : Type u) (A : Type v) (B : Type u_1) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [IsScalarTower R A B] [Algebra.Etale R A]
[Algebra.Etale A B], Algebra.Etale R B
|
EuclideanGeometry.eq_of_dist_eq_of_dist_eq_of_finrank_eq_two
|
Mathlib.Geometry.Euclidean.Basic
|
β {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V] [inst_2 : MetricSpace P]
[NormedAddTorsor V P] [FiniteDimensional β V],
Module.finrank β V = 2 β
β {cβ cβ pβ pβ p : P} {rβ rβ : β},
cβ β cβ β
pβ β pβ β
dist pβ cβ = rβ β
dist pβ cβ = rβ β dist p cβ = rβ β dist pβ cβ = rβ β dist pβ cβ = rβ β dist p cβ = rβ β p = pβ β¨ p = pβ
|
Lean.Doc.Parser.InList.mk._flat_ctor
|
Lean.DocString.Parser
|
β β Lean.Doc.Parser.OrderedListType β Lean.Doc.Parser.UnorderedListType β Lean.Doc.Parser.InList
|
AddCircle.liftIoc_zero_continuous
|
Mathlib.Topology.Instances.AddCircle.Defs
|
β {π : Type u_1} {B : Type u_2} [inst : AddCommGroup π] [inst_1 : LinearOrder π] [inst_2 : IsOrderedAddMonoid π] {p : π}
[hp : Fact (0 < p)] [inst_3 : Archimedean π] [inst_4 : TopologicalSpace π] [OrderTopology π]
[inst_6 : TopologicalSpace B] {f : π β B},
f 0 = f p β ContinuousOn f (Set.Icc 0 p) β Continuous (AddCircle.liftIoc p 0 f)
|
List.mem_attach
|
Init.Data.List.Attach
|
β {Ξ± : Type u_1} (l : List Ξ±) (x : { x // x β l }), x β l.attach
|
ODE.FunSpace.mk.congr_simp
|
Mathlib.Analysis.ODE.PicardLindelof
|
β {E : Type u_1} [inst : NormedAddCommGroup E] {tmin tmax : β} {tβ : β(Set.Icc tmin tmax)} {xβ : E} {r L : NNReal}
(toFun toFun_1 : β(Set.Icc tmin tmax) β E) (e_toFun : toFun = toFun_1) (lipschitzWith : LipschitzWith L toFun)
(mem_closedBallβ : toFun tβ β Metric.closedBall xβ βr),
{ toFun := toFun, lipschitzWith := lipschitzWith, mem_closedBallβ := mem_closedBallβ } =
{ toFun := toFun_1, lipschitzWith := β―, mem_closedBallβ := β― }
|
RingHom.codomain_trivial_iff_range_trivial
|
Mathlib.Algebra.Ring.Hom.Defs
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} {x : NonAssocSemiring Ξ±} {x_1 : NonAssocSemiring Ξ²} (f : Ξ± β+* Ξ²),
0 = 1 β β (x_2 : Ξ±), f x_2 = 0
|
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastMul._proof_1
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul
|
β {w : β}, Β¬w = 0 β Β¬0 < w β False
|
CategoryTheory.Limits.CatCospanTransformMorphism.left_coherence_assoc
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform
|
β {A : Type uβ} {B : Type uβ} {C : Type uβ} {A' : Type uβ} {B' : Type uβ
} {C' : Type uβ}
[inst : CategoryTheory.Category.{vβ, uβ} A] [inst_1 : CategoryTheory.Category.{vβ, uβ} B]
[inst_2 : CategoryTheory.Category.{vβ, uβ} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{vβ, uβ} A'] [inst_4 : CategoryTheory.Category.{vβ
, uβ
} B']
[inst_5 : CategoryTheory.Category.{vβ, uβ} C'] {F' : CategoryTheory.Functor A' B'} {G' : CategoryTheory.Functor C' B'}
{Ο Ο' : CategoryTheory.Limits.CatCospanTransform F G F' G'}
(self : CategoryTheory.Limits.CatCospanTransformMorphism Ο Ο') {Z : CategoryTheory.Functor A B'}
(h : Ο'.left.comp F' βΆ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso F Ο.left Ο.base F').hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight self.left F') h) =
CategoryTheory.CategoryStruct.comp (F.whiskerLeft self.base)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso F Ο'.left Ο'.base F').hom h)
|
_private.Lean.Meta.Tactic.Grind.Action.0.Lean.Meta.Grind.Action.orElse.eq_1
|
Lean.Meta.Tactic.Grind.Action
|
β (x y : Lean.Meta.Grind.Action) (goal : Lean.Meta.Grind.Goal) (kna kp : Lean.Meta.Grind.ActionCont),
x.orElse y goal kna kp = x goal (fun goal => y goal kna kp) kp
|
FinTopCat.of
|
Mathlib.Topology.Category.FinTopCat
|
(X : Type u) β [Fintype X] β [TopologicalSpace X] β FinTopCat
|
Real.le_arcsin_iff_sin_le
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse
|
β {x y : β}, x β Set.Icc (-(Real.pi / 2)) (Real.pi / 2) β y β Set.Icc (-1) 1 β (x β€ Real.arcsin y β Real.sin x β€ y)
|
CategoryTheory.Square.Hom
|
Mathlib.CategoryTheory.Square
|
{C : Type u} β [inst : CategoryTheory.Category.{v, u} C] β CategoryTheory.Square C β CategoryTheory.Square C β Type v
|
RatFunc.instValuedWithZeroMultiplicativeInt._proof_4
|
Mathlib.FieldTheory.RatFunc.AsPolynomial
|
β (K : Type u_1) [inst : Field K], IsFractionRing (Polynomial K) (RatFunc K)
|
Finset.instIsReflSubset
|
Mathlib.Data.Finset.Defs
|
β {Ξ± : Type u_1}, IsRefl (Finset Ξ±) fun x1 x2 => x1 β x2
|
CentroidHom.centerToCentroidCenter._proof_6
|
Mathlib.Algebra.Ring.CentroidHom
|
β {Ξ± : Type u_1} [inst : NonUnitalNonAssocSemiring Ξ±] (z : β₯(NonUnitalSubsemiring.center Ξ±)) (b c : Ξ±),
βz * (b * c) = βz * b * c
|
Nat.Partition.mk
|
Mathlib.Combinatorics.Enumerative.Partition.Basic
|
{n : β} β (parts : Multiset β) β (β {i : β}, i β parts β 0 < i) β parts.sum = n β n.Partition
|
Lean.Meta.Grind.AC.ACM.Context.mk.inj
|
Lean.Meta.Tactic.Grind.AC.Util
|
β {opId opId_1 : β}, { opId := opId } = { opId := opId_1 } β opId = opId_1
|
spectrum.invβ_mem
|
Mathlib.Algebra.Algebra.Spectrum.Basic
|
β {R : Type u} {A : Type v} [inst : Semifield R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : AΛ£},
r β spectrum R βaβ»ΒΉ β rβ»ΒΉ β spectrum R βa
|
DirectLimit.instDivisionRing._proof_5
|
Mathlib.Algebra.Colimit.DirectLimit
|
β {ΞΉ : Type u_1} [inst : Preorder ΞΉ] {G : ΞΉ β Type u_2} {T : β¦i j : ΞΉβ¦ β i β€ j β Type u_3}
{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 : Nonempty ΞΉ]
[inst_5 : (i : ΞΉ) β DivisionRing (G i)] [inst_6 : β (i j : ΞΉ) (h : i β€ j), RingHomClass (T h) (G i) (G j)]
(a : DirectLimit G f), Ring.zsmul 0 a = 0
|
SemidirectProduct.inl._proof_1
|
Mathlib.GroupTheory.SemidirectProduct
|
β {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {Ο : G β* MulAut N} (x y : N),
β¨x * y, 1β© = β¨x, 1β© * β¨y, 1β©
|
Std.Iterators.Types.ULiftIterator.ctorIdx
|
Init.Data.Iterators.Combinators.Monadic.ULift
|
{Ξ± : Type u} β
{m : Type u β Type u'} β
{n : Type (max u v) β Type v'} β
{Ξ² : Type u} β
{lift : β¦Ξ³ : Type uβ¦ β m Ξ³ β Std.Iterators.ULiftT n Ξ³} β Std.Iterators.Types.ULiftIterator Ξ± m n Ξ² lift β β
|
intervalIntegral.integral_mono_on
|
Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic
|
β {f g : β β β} {a b : β} {ΞΌ : MeasureTheory.Measure β},
a β€ b β
IntervalIntegrable f ΞΌ a b β
IntervalIntegrable g ΞΌ a b β
(β x β Set.Icc a b, f x β€ g x) β β« (u : β) in a..b, f u βΞΌ β€ β« (u : β) in a..b, g u βΞΌ
|
Filter.comap_cofinite_le
|
Mathlib.Order.Filter.Cofinite
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} (f : Ξ± β Ξ²), Filter.comap f Filter.cofinite β€ Filter.cofinite
|
Lean.Parser.Command.eoi._regBuiltin.Lean.Parser.Command.eoi.parenthesizer_7
|
Lean.Parser.Command
|
IO Unit
|
List.isEqv.match_1
|
Init.Data.List.Basic
|
{Ξ± : Type u_1} β
(motive : List Ξ± β List Ξ± β (Ξ± β Ξ± β Bool) β Sort u_2) β
(x x_1 : List Ξ±) β
(x_2 : Ξ± β Ξ± β Bool) β
((x : Ξ± β Ξ± β Bool) β motive [] [] x) β
((a : Ξ±) β (as : List Ξ±) β (b : Ξ±) β (bs : List Ξ±) β (eqv : Ξ± β Ξ± β Bool) β motive (a :: as) (b :: bs) eqv) β
((x x_3 : List Ξ±) β (x_4 : Ξ± β Ξ± β Bool) β motive x x_3 x_4) β motive x x_1 x_2
|
Geometry.SimplicialComplex.faces_bot
|
Mathlib.Analysis.Convex.SimplicialComplex.Basic
|
β {π : Type u_1} {E : Type u_2} [inst : Ring π] [inst_1 : PartialOrder π] [inst_2 : AddCommGroup E]
[inst_3 : Module π E], β₯.faces = β
|
Subring.instInfSet
|
Mathlib.Algebra.Ring.Subring.Basic
|
{R : Type u} β [inst : Ring R] β InfSet (Subring R)
|
Lean.Lsp.instFromJsonLocation.fromJson
|
Lean.Data.Lsp.Basic
|
Lean.Json β Except String Lean.Lsp.Location
|
Aesop.ForwardRuleMatch.foldHypsM
|
Aesop.Forward.Match
|
{M : Type u_1 β Type u_2} β {Ο : Type u_1} β [Monad M] β (Ο β Lean.FVarId β M Ο) β Ο β Aesop.ForwardRuleMatch β M Ο
|
Lean.Meta.LazyDiscrTree.ImportData.casesOn
|
Lean.Meta.LazyDiscrTree
|
{motive : Lean.Meta.LazyDiscrTree.ImportData β Sort u} β
(t : Lean.Meta.LazyDiscrTree.ImportData) β
((errors : IO.Ref (Array Lean.Meta.LazyDiscrTree.ImportFailure)) β motive { errors := errors }) β motive t
|
_private.Mathlib.Data.Option.NAry.0.Option.map_mapβ_distrib_right._proof_1_1
|
Mathlib.Data.Option.NAry
|
β {Ξ± : Type u_3} {Ξ² : Type u_4} {Ξ³ : Type u_2} {Ξ΄ : Type u_1} {f : Ξ± β Ξ² β Ξ³} {a : Option Ξ±} {b : Option Ξ²}
{Ξ²' : Type u_5} {g : Ξ³ β Ξ΄} {f' : Ξ± β Ξ²' β Ξ΄} {g' : Ξ² β Ξ²'},
(β (a : Ξ±) (b : Ξ²), g (f a b) = f' a (g' b)) β Option.map g (Option.mapβ f a b) = Option.mapβ f' a (Option.map g' b)
|
Lean.Meta.Grind.Arith.Cutsat.DvdSolution.mk
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.Search
|
β€ β β€ β Lean.Meta.Grind.Arith.Cutsat.DvdSolution
|
AlgEquiv.ofBijective_symm_apply_apply
|
Mathlib.Algebra.Algebra.Equiv
|
β {R : Type uR} {Aβ : Type uAβ} {Aβ : Type uAβ} [inst : CommSemiring R] [inst_1 : Semiring Aβ] [inst_2 : Semiring Aβ]
[inst_3 : Algebra R Aβ] [inst_4 : Algebra R Aβ] (f : Aβ ββ[R] Aβ) (hf : Function.Bijective βf) (x : Aβ),
(AlgEquiv.ofBijective f hf).symm (f x) = x
|
Vector.emptyWithCapacity._proof_1
|
Init.Data.Vector.Basic
|
β {Ξ± : Type u_1}, #[].size = 0
|
Set.Nonempty.pow
|
Mathlib.Algebra.Group.Pointwise.Set.Basic
|
β {Ξ± : Type u_2} [inst : Monoid Ξ±] {s : Set Ξ±}, s.Nonempty β β {n : β}, (s ^ n).Nonempty
|
Finsupp.mapRange.addMonoidHom_apply
|
Mathlib.Algebra.Group.Finsupp
|
β {ΞΉ : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (f : M β+ N)
(g : ΞΉ ββ M), (Finsupp.mapRange.addMonoidHom f) g = Finsupp.mapRange βf β― g
|
QuaternionAlgebra.natCast_imI
|
Mathlib.Algebra.Quaternion
|
β {R : Type u_3} {cβ cβ cβ : R} [inst : AddCommGroupWithOne R] (n : β), (βn).imI = 0
|
NonUnitalNonAssocCommSemiring.toNonUnitalNonAssocSemiring
|
Mathlib.Algebra.Ring.Defs
|
{Ξ± : Type u} β [self : NonUnitalNonAssocCommSemiring Ξ±] β NonUnitalNonAssocSemiring Ξ±
|
Lean.Elab.DefKind.example.sizeOf_spec
|
Lean.Elab.DefView
|
sizeOf Lean.Elab.DefKind.example = 1
|
Lean.Grind.OrderedRing.pos_intCast_of_pos
|
Init.Grind.Ordered.Ring
|
β {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [Std.LawfulOrderLT R]
[inst_4 : Std.IsPreorder R] [Lean.Grind.OrderedRing R] (a : β€), 0 < a β 0 < βa
|
ZeroAtInftyContinuousMap.instNonUnitalNonAssocSemiring._proof_1
|
Mathlib.Topology.ContinuousMap.ZeroAtInfty
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : TopologicalSpace Ξ±] [inst_1 : TopologicalSpace Ξ²]
[inst_2 : NonUnitalNonAssocSemiring Ξ²], Function.Injective fun f => βf
|
PUnit.lcm_eq
|
Mathlib.Algebra.GCDMonoid.PUnit
|
β {x y : PUnit.{u_1 + 1}}, lcm x y = PUnit.unit
|
Metric.thickening_subset_cthickening_of_le
|
Mathlib.Topology.MetricSpace.Thickening
|
β {Ξ± : Type u} [inst : PseudoEMetricSpace Ξ±] {Ξ΄β Ξ΄β : β},
Ξ΄β β€ Ξ΄β β β (E : Set Ξ±), Metric.thickening Ξ΄β E β Metric.cthickening Ξ΄β E
|
Equiv.Perm.IsCycle.sameCycle
|
Mathlib.GroupTheory.Perm.Cycle.Basic
|
β {Ξ± : Type u_2} {f : Equiv.Perm Ξ±} {x y : Ξ±}, f.IsCycle β f x β x β f y β y β f.SameCycle x y
|
IsAdicComplete.StrictMono.liftRingHom._proof_4
|
Mathlib.RingTheory.AdicCompletion.RingHom
|
β {a : β β β}, StrictMono a β β {m : β}, a m β€ a (m + 1)
|
MeasureTheory.SimpleFunc.instRing
|
Mathlib.MeasureTheory.Function.SimpleFunc
|
{Ξ± : Type u_1} β {Ξ² : Type u_2} β [inst : MeasurableSpace Ξ±] β [Ring Ξ²] β Ring (MeasureTheory.SimpleFunc Ξ± Ξ²)
|
Rep.FiniteCyclicGroup.moduleCatChainComplex._proof_1
|
Mathlib.RepresentationTheory.Homological.FiniteCyclic
|
β {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep k G) (g : G),
CategoryTheory.CategoryStruct.comp A.norm.hom (A.applyAsHom g - CategoryTheory.CategoryStruct.id A).hom = 0
|
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_trivial_trivial._simp_1_1
|
Mathlib.NumberTheory.JacobiSum.Basic
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {s t : Finset Ξ±} {a : Ξ±}, (a β s \ t) = (a β s β§ a β t)
|
SymAlg.unsym_ne_zero_iff
|
Mathlib.Algebra.Symmetrized
|
β {Ξ± : Type u_1} [inst : Zero Ξ±] (a : Ξ±Λ’ΚΈα΅), SymAlg.unsym a β 0 β a β 0
|
IsCoveringMap.monodromy
|
Mathlib.Topology.Homotopy.Lifting
|
{E : Type u_1} β
{X : Type u_2} β
[inst : TopologicalSpace E] β
[inst_1 : TopologicalSpace X] β
{p : E β X} β IsCoveringMap p β {x y : X} β Path.Homotopic.Quotient x y β β(p β»ΒΉ' {x}) β β(p β»ΒΉ' {y})
|
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.mainCore.match_1
|
Lean.Meta.Tactic.Simp.Main
|
(motive : Lean.Meta.Simp.Result Γ Lean.Meta.Simp.State β Sort u_1) β
(__discr : Lean.Meta.Simp.Result Γ Lean.Meta.Simp.State) β
((r : Lean.Meta.Simp.Result) β (s : Lean.Meta.Simp.State) β motive (r, s)) β motive __discr
|
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.mk
|
Lean.Server.Logging
|
Std.Time.ZonedDateTime β
Lean.JsonRpc.MessageDirection β Lean.JsonRpc.MessageKind β Lean.JsonRpc.Message β Lean.Server.Logging.LogEntryβ
|
LieModule.maxTrivLinearMapEquivLieModuleHom._proof_7
|
Mathlib.Algebra.Lie.Abelian
|
β {R : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_2} [inst : CommRing R] [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] (F : M βββ
R,Lβ N), { toLinearMap := βF, map_lie' := β― } = F
|
BitVec.getMsbD_srem
|
Init.Data.BitVec.Bitblast
|
β {w i : β} {x y : BitVec w},
(x.srem y).getMsbD i =
match x.msb, y.msb with
| false, false => (x % y).getMsbD i
| false, true => (x % -y).getMsbD i
| true, false => (-(-x % y)).getMsbD i
| true, true => (-(-x % -y)).getMsbD i
|
LinearMap.proj_surjective
|
Mathlib.LinearAlgebra.Pi
|
β {R : Type u} {ΞΉ : Type x} [inst : Semiring R] {Ο : ΞΉ β Type i} [inst_1 : (i : ΞΉ) β AddCommMonoid (Ο i)]
[inst_2 : (i : ΞΉ) β Module R (Ο i)] (i : ΞΉ), Function.Surjective β(LinearMap.proj i)
|
_private.Mathlib.Analysis.Meromorphic.NormalForm.0.MeromorphicOn.toMeromorphicNFOn_eq_self_on_nhdsNE._simp_1_2
|
Mathlib.Analysis.Meromorphic.NormalForm
|
β {Ξ± : Type u} (s : Set Ξ±) (x : Ξ±), (x β sαΆ) = (x β s)
|
FirstOrder.Language.ElementaryEmbedding.comp_apply
|
Mathlib.ModelTheory.ElementaryMaps
|
β {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : L.Structure M] [inst_1 : L.Structure N]
[inst_2 : L.Structure P] (g : L.ElementaryEmbedding N P) (f : L.ElementaryEmbedding M N) (x : M),
(g.comp f) x = g (f x)
|
sizeOf_default
|
Init.SizeOf
|
β {Ξ± : Sort u_1} (n : Ξ±), sizeOf n = 0
|
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.exists_Gamma_le_conj._simp_1_6
|
Mathlib.NumberTheory.ModularForms.CongruenceSubgroups
|
β {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (M : Matrix n n β€),
(M.map fun x => βx).det = βM.det
|
_private.Mathlib.Order.Filter.Tendsto.0.Filter.Tendsto.if._simp_1_1
|
Mathlib.Order.Filter.Tendsto
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β Ξ²} {lβ : Filter Ξ±} {lβ : Filter Ξ²},
Filter.Tendsto f lβ lβ = β s β lβ, f β»ΒΉ' s β lβ
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.