name
string | module
string | type
string |
|---|---|---|
subset_tangentConeAt_prod_left
|
Mathlib.Analysis.Calculus.TangentCone.Prod
|
β {π : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField π] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {x : E} {s : Set E} {y : F}
{t : Set F}, y β closure t β β(LinearMap.inl π E F) '' tangentConeAt π s x β tangentConeAt π (s ΓΛ’ t) (x, y)
|
AlgebraicGeometry.Scheme.kerAdjunction_counit_app
|
Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme
|
β (Y : AlgebraicGeometry.Scheme) (f : (CategoryTheory.Over Y)α΅α΅),
Y.kerAdjunction.counit.app f =
(CategoryTheory.Over.homMk (AlgebraicGeometry.Scheme.Hom.toImage (Opposite.unop f).hom) β―).op
|
ZFSet.card_empty
|
Mathlib.SetTheory.ZFC.Cardinal
|
β
.card = 0
|
Subring.mem_toSubsemiring._simp_1
|
Mathlib.Algebra.Ring.Subring.Defs
|
β {R : Type u} [inst : Ring R] {s : Subring R} {x : R}, (x β s.toSubsemiring) = (x β s)
|
Lean.Syntax.ident.inj
|
Init.Core
|
β {info : Lean.SourceInfo} {rawVal : Substring.Raw} {val : Lean.Name} {preresolved : List Lean.Syntax.Preresolved}
{info_1 : Lean.SourceInfo} {rawVal_1 : Substring.Raw} {val_1 : Lean.Name}
{preresolved_1 : List Lean.Syntax.Preresolved},
Lean.Syntax.ident info rawVal val preresolved = Lean.Syntax.ident info_1 rawVal_1 val_1 preresolved_1 β
info = info_1 β§ rawVal = rawVal_1 β§ val = val_1 β§ preresolved = preresolved_1
|
CliffordAlgebra.reverse_mem_evenOdd_iff
|
Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation
|
β {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} {n : ZMod 2},
CliffordAlgebra.reverse x β CliffordAlgebra.evenOdd Q n β x β CliffordAlgebra.evenOdd Q n
|
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.rec
|
Lean.Meta.LetToHave
|
{motive : Lean.Meta.LetToHave.Stateβ β Sort u} β
((count : β) β
(results : Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Resultβ) β
motive { count := count, results := results }) β
(t : Lean.Meta.LetToHave.StateβΒΉ) β motive t
|
_private.Mathlib.Order.Filter.Bases.Finite.0.Filter.hasBasis_generate._simp_1_1
|
Mathlib.Order.Filter.Bases.Finite
|
β {Ξ± : Type u} {s : Set (Set Ξ±)} {U : Set Ξ±}, (U β Filter.generate s) = β t β s, t.Finite β§ ββ t β U
|
HahnSeries.orderTop_embDomain
|
Mathlib.RingTheory.HahnSeries.Basic
|
β {Ξ' : Type u_2} {R : Type u_3} [inst : Zero R] [inst_1 : PartialOrder Ξ'] {Ξ : Type u_5} [inst_2 : LinearOrder Ξ]
{f : Ξ βͺo Ξ'} {x : HahnSeries Ξ R}, (HahnSeries.embDomain f x).orderTop = WithTop.map (βf) x.orderTop
|
orthogonalFamily_iff_pairwise
|
Mathlib.Analysis.InnerProductSpace.Orthogonal
|
β {π : Type u_1} {E : Type u_2} [inst : RCLike π] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
{ΞΉ : Type u_4} {V : ΞΉ β Submodule π E},
(OrthogonalFamily π (fun i => β₯(V i)) fun i => (V i).subtypeβα΅’) β Pairwise (Function.onFun (fun x1 x2 => x1 β x2) V)
|
ProofWidgets.MakeEditLinkProps.ctorIdx
|
ProofWidgets.Component.MakeEditLink
|
ProofWidgets.MakeEditLinkProps β β
|
Int.zsmul_eq_mul
|
Mathlib.Algebra.Group.Int.Defs
|
β (n a : β€), n β’ a = n * a
|
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.nonIndicesFirst.match_1
|
Lean.Elab.PreDefinition.Structural.FindRecArg
|
(motive : Array Lean.Elab.Structural.RecArgInfo Γ Array Lean.Elab.Structural.RecArgInfo β Sort u_1) β
(x : Array Lean.Elab.Structural.RecArgInfo Γ Array Lean.Elab.Structural.RecArgInfo) β
((indices nonIndices : Array Lean.Elab.Structural.RecArgInfo) β motive (indices, nonIndices)) β motive x
|
MeromorphicOn.neg
|
Mathlib.Analysis.Meromorphic.Basic
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {f : π β E} {U : Set π}, MeromorphicOn f U β MeromorphicOn (-f) U
|
List.nil_lt_cons
|
Init.Data.List.Lex
|
β {Ξ± : Type u_1} [inst : LT Ξ±] (a : Ξ±) (l : List Ξ±), [] < a :: l
|
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instBEqMon.beq.match_1.eq_1
|
Init.Grind.Ring.CommSolver
|
β (motive : Lean.Grind.CommRing.Mon β Lean.Grind.CommRing.Mon β Sort u_1)
(h_1 : Unit β motive Lean.Grind.CommRing.Mon.unit Lean.Grind.CommRing.Mon.unit)
(h_2 :
(a : Lean.Grind.CommRing.Power) β
(a_1 : Lean.Grind.CommRing.Mon) β
(b : Lean.Grind.CommRing.Power) β
(b_1 : Lean.Grind.CommRing.Mon) β
motive (Lean.Grind.CommRing.Mon.mult a a_1) (Lean.Grind.CommRing.Mon.mult b b_1))
(h_3 : (x x_1 : Lean.Grind.CommRing.Mon) β motive x x_1),
(match Lean.Grind.CommRing.Mon.unit, Lean.Grind.CommRing.Mon.unit with
| Lean.Grind.CommRing.Mon.unit, Lean.Grind.CommRing.Mon.unit => h_1 ()
| Lean.Grind.CommRing.Mon.mult a a_1, Lean.Grind.CommRing.Mon.mult b b_1 => h_2 a a_1 b b_1
| x, x_1 => h_3 x x_1) =
h_1 ()
|
enorm_mul_le'
|
Mathlib.Analysis.Normed.Group.Basic
|
β {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ESeminormedMonoid E] (a b : E), βa * bββ β€ βaββ + βbββ
|
CategoryTheory.Bicategory.postcomposing._proof_2
|
Mathlib.CategoryTheory.Bicategory.Basic
|
β {B : Type u_2} [inst : CategoryTheory.Bicategory B] (a b c : B) (X : b βΆ c) β¦X_1 Y_1 : a βΆ bβ¦ (f : X_1 βΆ Y_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight f X)
(CategoryTheory.Bicategory.whiskerLeft Y_1 (CategoryTheory.CategoryStruct.id X)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft X_1 (CategoryTheory.CategoryStruct.id X))
(CategoryTheory.Bicategory.whiskerRight f X)
|
Finset.Ioi_nonempty
|
Mathlib.Order.Interval.Finset.Basic
|
β {Ξ± : Type u_2} {a : Ξ±} [inst : Preorder Ξ±] [inst_1 : LocallyFiniteOrderTop Ξ±], (Finset.Ioi a).Nonempty β Β¬IsMax a
|
ContinuousStar.rec
|
Mathlib.Topology.Algebra.Star
|
{R : Type u_1} β
[inst : TopologicalSpace R] β
[inst_1 : Star R] β
{motive : ContinuousStar R β Sort u} β
((continuous_star : Continuous star) β motive β―) β (t : ContinuousStar R) β motive t
|
ValuativeRel.valueSetoid._proof_1
|
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
|
β (R : Type u_1) [inst : CommRing R] [inst_1 : ValuativeRel R],
Equivalence fun x x_1 =>
match x with
| (x, s) =>
match x_1 with
| (y, t) => x * βt β€α΅₯ y * βs β§ y * βs β€α΅₯ x * βt
|
Std.LawfulOrderLT
|
Init.Data.Order.Classes
|
(Ξ± : Type u) β [LT Ξ±] β [LE Ξ±] β Prop
|
LinearGrowth.tendsto_atTop_of_linearGrowthInf_natCast_pos
|
Mathlib.Analysis.Asymptotics.LinearGrowth
|
β {v : β β β}, (LinearGrowth.linearGrowthInf fun n => β(v n)) β 0 β Filter.Tendsto v Filter.atTop Filter.atTop
|
IsTotallySeparated.isTotallyDisconnected
|
Mathlib.Topology.Connected.TotallyDisconnected
|
β {Ξ± : Type u} [inst : TopologicalSpace Ξ±] {s : Set Ξ±}, IsTotallySeparated s β IsTotallyDisconnected s
|
Int.reduceBdiv._regBuiltin.Int.reduceBdiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.1571464712._hygCtx._hyg.16
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int
|
IO Unit
|
LinearMap.smulRight_zero
|
Mathlib.Algebra.Module.LinearMap.End
|
β {R : Type u_1} {S : Type u_3} {M : Type u_4} {Mβ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid Mβ] [inst_3 : Module R M] [inst_4 : Module R Mβ] [inst_5 : Semiring S] [inst_6 : Module R S]
[inst_7 : Module S M] [inst_8 : IsScalarTower R S M] (f : Mβ ββ[R] S), f.smulRight 0 = 0
|
ApplicativeTransformation.mk.sizeOf_spec
|
Mathlib.Control.Traversable.Basic
|
β {F : Type u β Type v} [inst : Applicative F] {G : Type u β Type w} [inst_1 : Applicative G]
[inst_2 : (a : Type u) β SizeOf (F a)] [inst_3 : (a : Type u) β SizeOf (G a)] (app : (Ξ± : Type u) β F Ξ± β G Ξ±)
(preserves_pure' : β {Ξ± : Type u} (x : Ξ±), app Ξ± (pure x) = pure x)
(preserves_seq' : β {Ξ± Ξ² : Type u} (x : F (Ξ± β Ξ²)) (y : F Ξ±), app Ξ² (x <*> y) = app (Ξ± β Ξ²) x <*> app Ξ± y),
sizeOf { app := app, preserves_pure' := preserves_pure', preserves_seq' := preserves_seq' } = 1
|
ENNReal.eq_of_forall_nnreal_iff
|
Mathlib.Data.ENNReal.Inv
|
β {x y : ENNReal}, (β (r : NNReal), βr β€ x β βr β€ y) β x = y
|
DirectLimit.instDivisionSemiring._proof_15
|
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 : ΞΉ) β DivisionSemiring (G i)] [inst_6 : β (i j : ΞΉ) (h : i β€ j), RingHomClass (T h) (G i) (G j)]
(n : β), β(n + 1) = βn + 1
|
toLexMulEquiv.eq_1
|
Mathlib.Algebra.Order.Group.Equiv
|
β (Ξ± : Type u_1) [inst : Mul Ξ±], toLexMulEquiv Ξ± = { toEquiv := toLex, map_mul' := β― }
|
ContDiffAt.snd'
|
Mathlib.Analysis.Calculus.ContDiff.Basic
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {G : Type uG}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace π G] {n : WithTop ββ} {f : F β G} {x : E} {y : F},
ContDiffAt π n f y β ContDiffAt π n (fun x => f x.2) (x, y)
|
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell._proof_19
|
Std.Data.DTreeMap.Internal.Model
|
β {Ξ± : Type u_1} {Ξ² : Ξ± β Type u_2} (k' : Ξ±) (v' : Ξ² k'),
Std.DTreeMap.Internal.Impl.leaf.size - 1 β€
(Std.DTreeMap.Internal.Impl.inner 1 k' v' Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size
|
lp.inftyNormedRing.congr_simp
|
Mathlib.Analysis.Normed.Lp.lpSpace
|
β {I : Type u_5} {B : I β Type u_6} [inst : (i : I) β NormedRing (B i)] [inst_1 : β (i : I), NormOneClass (B i)],
lp.inftyNormedRing = lp.inftyNormedRing
|
IsSelfAdjoint.toReal_spectralRadius_eq_norm
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order
|
β {A : Type u_1} [inst : CStarAlgebra A] {a : A}, IsSelfAdjoint a β (spectralRadius β a).toReal = βaβ
|
AlgebraicGeometry.Scheme.JointlySurjective.recOn
|
Mathlib.AlgebraicGeometry.Cover.MorphismProperty
|
{K : CategoryTheory.Precoverage AlgebraicGeometry.Scheme} β
{motive : AlgebraicGeometry.Scheme.JointlySurjective K β Sort u_1} β
(t : AlgebraicGeometry.Scheme.JointlySurjective K) β
((exists_eq :
β {X : AlgebraicGeometry.Scheme},
β S β K.coverings X,
β (x : β₯X), β Y g, S g β§ x β Set.range β(CategoryTheory.ConcreteCategory.hom g.base)) β
motive β―) β
motive t
|
contMDiffWithinAt_iff_of_mem_source'
|
Mathlib.Geometry.Manifold.ContMDiff.Defs
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners π E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace π E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners π E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M β M'} {s : Set M} {x : M}
{n : WithTop ββ} [IsManifold I n M] [IsManifold I' n M'] {x' : M} {y : M'},
x' β (chartAt H x).source β
f x' β (chartAt H' y).source β
(ContMDiffWithinAt I I' n f s x' β
ContinuousWithinAt f s x' β§
ContDiffWithinAt π n (β(extChartAt I' y) β f β β(extChartAt I x).symm)
((extChartAt I x).target β© β(extChartAt I x).symm β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source))
(β(extChartAt I x) x'))
|
_private.Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt.0.SummationFilter.symmetricIcc_eq_symmetricIoo_int._proof_1_13
|
Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt
|
β (s : Set (Finset β€)),
(β a, β (b : β), a β€ b β Finset.Icc (-βb) βb β s) β
β (a : β),
(β (b : β), a β€ b β Finset.Icc (-βb) βb β s) β
β (b : β), a + 1 β€ b β β (a : β€), -βb < a β§ a < βb β -β(b - 1) β€ a β§ a β€ β(b - 1)
|
CategoryTheory.MorphismProperty.instIsStableUnderTransfiniteCompositionOfShapeFunctorFunctorCategoryOfHasIterationOfShape
|
Mathlib.CategoryTheory.MorphismProperty.FunctorCategory
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} (K : Type u')
[inst_1 : LinearOrder K] [inst_2 : SuccOrder K] [inst_3 : OrderBot K] [inst_4 : WellFoundedLT K]
[W.IsStableUnderTransfiniteCompositionOfShape K] (J : Type u'') [inst_6 : CategoryTheory.Category.{v'', u''} J]
[CategoryTheory.Limits.HasIterationOfShape K C], (W.functorCategory J).IsStableUnderTransfiniteCompositionOfShape K
|
_private.Mathlib.RingTheory.MvPowerSeries.LexOrder.0.MvPowerSeries.exists_finsupp_eq_lexOrder_of_ne_zero._simp_1_2
|
Mathlib.RingTheory.MvPowerSeries.LexOrder
|
β {Ξ± : Type u_1} {x : WithTop Ξ±}, (x β β€) = β a, βa = x
|
RingHom.mk'._proof_4
|
Mathlib.Algebra.Ring.Hom.Defs
|
β {Ξ± : Type u_2} {Ξ² : Type u_1} [inst : NonAssocSemiring Ξ±] [inst_1 : NonAssocRing Ξ²] (f : Ξ± β* Ξ²)
(map_add : β (a b : Ξ±), f (a + b) = f a + f b) (x y : Ξ±),
(β(AddMonoidHom.mk' (βf) map_add)).toFun (x + y) =
(β(AddMonoidHom.mk' (βf) map_add)).toFun x + (β(AddMonoidHom.mk' (βf) map_add)).toFun y
|
_private.Mathlib.Data.List.Basic.0.List.mem_getLast?_eq_getLast._proof_1_14
|
Mathlib.Data.List.Basic
|
β {Ξ± : Type u_1} (a b : Ξ±) (l : List Ξ±), Β¬(a :: b :: l).length - 1 = 0 β (a :: b :: l).length - 2 < (b :: l).length
|
Ring.KrullDimLE.subsingleton_primeSpectrum
|
Mathlib.RingTheory.KrullDimension.Zero
|
β (R : Type u_1) [inst : CommSemiring R] [Ring.KrullDimLE 0 R] [IsLocalRing R], Subsingleton (PrimeSpectrum R)
|
id_tensor_Ο_preserves_coequalizer_inv_colimMap_desc
|
Mathlib.CategoryTheory.Monoidal.Bimod
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
β (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, vβ, vβ, uβ, uβ}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
{X Y Z X' Y' Z' : C} (f g : X βΆ Y) (f' g' : X' βΆ Y') (p : CategoryTheory.MonoidalCategoryStruct.tensorObj Z X βΆ X')
(q : CategoryTheory.MonoidalCategoryStruct.tensorObj Z Y βΆ Y')
(wf :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z f) q =
CategoryTheory.CategoryStruct.comp p f')
(wg :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z g) q =
CategoryTheory.CategoryStruct.comp p g')
(h : Y' βΆ Z') (wh : CategoryTheory.CategoryStruct.comp f' h = CategoryTheory.CategoryStruct.comp g' h),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z (CategoryTheory.Limits.coequalizer.Ο f g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorLeft Z) f g).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimMap
(CategoryTheory.Limits.parallelPairHom (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z f)
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z g) f' g' p q wf wg))
(CategoryTheory.Limits.coequalizer.desc h wh))) =
CategoryTheory.CategoryStruct.comp q h
|
EReal.top_ne_coe._simp_1
|
Mathlib.Data.EReal.Basic
|
β (x : β), (β€ = βx) = False
|
Subsemiring.coe_prod._simp_1
|
Mathlib.Algebra.Ring.Subsemiring.Basic
|
β {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (s : Subsemiring R)
(t : Subsemiring S), βs ΓΛ’ βt = β(s.prod t)
|
QuadraticMap.zeroHomClass
|
Mathlib.LinearAlgebra.QuadraticForm.Basic
|
β {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], ZeroHomClass (QuadraticMap R M N) M N
|
Std.DTreeMap.Internal.Impl.balanceL!_pair_congr
|
Std.Data.DTreeMap.Internal.Model
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {k : Ξ±} {v : Ξ² k} {k' : Ξ±} {v' : Ξ² k'},
β¨k, vβ© = β¨k', v'β© β
β {l l' r r' : Std.DTreeMap.Internal.Impl Ξ± Ξ²},
l = l' β r = r' β Std.DTreeMap.Internal.Impl.balanceL! k v l r = Std.DTreeMap.Internal.Impl.balanceL! k' v' l' r'
|
Module.mapEvalEquiv
|
Mathlib.LinearAlgebra.Dual.Defs
|
(R : Type u_3) β
(M : Type u_4) β
[inst : CommSemiring R] β
[inst_1 : AddCommMonoid M] β
[inst_2 : Module R M] β
[Module.IsReflexive R M] β Submodule R M βo Submodule R (Module.Dual R (Module.Dual R M))
|
SimplexCategory.Ξ΄_comp_Ο_of_le
|
Mathlib.AlgebraicTopology.SimplexCategory.Basic
|
β {n : β} {i : Fin (n + 2)} {j : Fin (n + 1)},
i β€ j.castSucc β
CategoryTheory.CategoryStruct.comp (SimplexCategory.Ξ΄ i.castSucc) (SimplexCategory.Ο j.succ) =
CategoryTheory.CategoryStruct.comp (SimplexCategory.Ο j) (SimplexCategory.Ξ΄ i)
|
_private.Mathlib.Algebra.Polynomial.UnitTrinomial.0.Polynomial.isUnitTrinomial_iff'._simp_1_1
|
Mathlib.Algebra.Polynomial.UnitTrinomial
|
β {Ξ± : Type u} [inst : Monoid Ξ±] (a : Ξ±Λ£) (n : β), βa ^ n = β(a ^ n)
|
Polynomial.SplittingField.instCharZero
|
Mathlib.FieldTheory.SplittingField.Construction
|
β {K : Type v} [inst : Field K] (f : Polynomial K) [CharZero K], CharZero f.SplittingField
|
FreeGroup.isReduced_iff_reduce_eq
|
Mathlib.GroupTheory.FreeGroup.Reduce
|
β {Ξ± : Type u_1} {L : List (Ξ± Γ Bool)} [inst : DecidableEq Ξ±], FreeGroup.IsReduced L β FreeGroup.reduce L = L
|
instLTBitVec
|
Init.Prelude
|
{w : β} β LT (BitVec w)
|
PMF.uniformOfFintype_apply
|
Mathlib.Probability.Distributions.Uniform
|
β {Ξ± : Type u_1} [inst : Fintype Ξ±] [inst_1 : Nonempty Ξ±] (a : Ξ±), (PMF.uniformOfFintype Ξ±) a = (β(Fintype.card Ξ±))β»ΒΉ
|
ciSup_eq_ite
|
Mathlib.Order.ConditionallyCompleteLattice.Indexed
|
β {Ξ± : Type u_1} [inst : ConditionallyCompleteLattice Ξ±] {p : Prop} [inst_1 : Decidable p] {f : p β Ξ±},
β¨ (h : p), f h = if h : p then f h else sSup β
|
_private.Mathlib.GroupTheory.Perm.Finite.0.Equiv.Perm.disjoint_support_closure_of_disjoint_support._simp_1_2
|
Mathlib.GroupTheory.Perm.Finite
|
β {Ξ± : Type u_1} {t : Set Ξ±} {ΞΉ : Sort u_12} {s : ΞΉ β Set Ξ±}, Disjoint t (β i, s i) = β (i : ΞΉ), Disjoint t (s i)
|
CategoryTheory.Arrow.shrinkHomsEquiv._proof_4
|
Mathlib.CategoryTheory.Comma.CardinalArrow
|
β (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.LocallySmall.{u_3, u_1, u_2} C]
(x : CategoryTheory.Arrow C),
CategoryTheory.Arrow.mk ((equivShrink (x.left βΆ x.right)).symm ((equivShrink (x.left βΆ x.right)) x.hom)) = x
|
ISize.toInt_maxValue
|
Init.Data.SInt.Lemmas
|
ISize.maxValue.toInt = 2 ^ (System.Platform.numBits - 1) - 1
|
_private.Mathlib.Tactic.Find.0.Mathlib.Tactic.Find.matchHyps
|
Mathlib.Tactic.Find
|
List Lean.Expr β List Lean.Expr β List Lean.Expr β Lean.MetaM Bool
|
LaurentSeries.val_le_one_iff_eq_coe
|
Mathlib.RingTheory.LaurentSeries
|
β (K : Type u_2) [inst : Field K] (f : LaurentSeries K), Valued.v f β€ 1 β β F, (HahnSeries.ofPowerSeries β€ K) F = f
|
Lean.Lsp.DiagnosticCode
|
Lean.Data.Lsp.Diagnostics
|
Type
|
Ordnode.eraseMin._unsafe_rec
|
Mathlib.Data.Ordmap.Ordnode
|
{Ξ± : Type u_1} β Ordnode Ξ± β Ordnode Ξ±
|
UpperSet.coe_nonempty
|
Mathlib.Order.UpperLower.CompleteLattice
|
β {Ξ± : Type u_1} [inst : LE Ξ±] {s : UpperSet Ξ±}, (βs).Nonempty β s β β€
|
ContinuousMap.instRegularSpace
|
Mathlib.Topology.CompactOpen
|
β {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [RegularSpace Y],
RegularSpace C(X, Y)
|
AlgebraicTopology.DoldKan.Ξβ.Obj.map._proof_1
|
Mathlib.AlgebraicTopology.DoldKan.FunctorGamma
|
β {Ξ' Ξ : SimplexCategoryα΅α΅} (ΞΈ : Ξ βΆ Ξ') (A : SimplicialObject.Splitting.IndexSet Ξ),
CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp ΞΈ.unop A.e)
|
Std.ExtTreeMap.union_insert_right_eq_insert_union
|
Std.Data.ExtTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.ExtTreeMap Ξ± Ξ² cmp} [inst : Std.TransCmp cmp]
{p : (_ : Ξ±) Γ Ξ²}, tβ βͺ tβ.insert p.fst p.snd = (tβ βͺ tβ).insert p.fst p.snd
|
Std.ExtDHashMap.mem_modify
|
Std.Data.ExtDHashMap.Lemmas
|
β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {Ξ² : Ξ± β Type v} {m : Std.ExtDHashMap Ξ± Ξ²} [inst : LawfulBEq Ξ±] {k k' : Ξ±}
{f : Ξ² k β Ξ² k}, k' β m.modify k f β k' β m
|
LocalizedModule.instAddCommGroup._proof_2
|
Mathlib.Algebra.Module.LocalizedModule.Basic
|
β {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} [inst_1 : AddCommGroup M]
[inst_2 : Module R M] (a : LocalizedModule S M), 0 + a = a
|
CategoryTheory.MonoidalCategory.whiskerLeftIso_trans
|
Mathlib.CategoryTheory.Monoidal.Category
|
β {C : Type u} [π : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (W : C) {X Y Z : C}
(f : X β
Y) (g : Y β
Z),
CategoryTheory.MonoidalCategory.whiskerLeftIso W (f βͺβ« g) =
CategoryTheory.MonoidalCategory.whiskerLeftIso W f βͺβ« CategoryTheory.MonoidalCategory.whiskerLeftIso W g
|
List.isEmpty_reverse
|
Init.Data.List.Lemmas
|
β {Ξ± : Type u_1} {xs : List Ξ±}, xs.reverse.isEmpty = xs.isEmpty
|
CategoryTheory.ComposableArrows.homMkSucc
|
Mathlib.CategoryTheory.ComposableArrows.Basic
|
{C : Type u_1} β
[inst : CategoryTheory.Category.{u_2, u_1} C] β
{n : β} β
{F G : CategoryTheory.ComposableArrows C (n + 1)} β
(Ξ± : F.obj' 0 β― βΆ G.obj' 0 β―) β
(Ξ² : F.Ξ΄β βΆ G.Ξ΄β) β
CategoryTheory.CategoryStruct.comp (F.map' 0 1 β― β―) (CategoryTheory.ComposableArrows.app' Ξ² 0 β―) =
CategoryTheory.CategoryStruct.comp Ξ± (G.map' 0 1 β― β―) β
(F βΆ G)
|
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.IsIdempotentElem.commute_iff_of_isUnit._simp_1_4
|
Mathlib.LinearAlgebra.Projection
|
β {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {f : M ββ[R] M}
{p : Submodule R M}, (p β€ Submodule.map f p) = (p β Module.End.invtSubmodule βf.symm)
|
Ideal.quotientEquivDirectSum
|
Mathlib.LinearAlgebra.FreeModule.IdealQuotient
|
{ΞΉ : Type u_1} β
{R : Type u_2} β
{S : Type u_3} β
[inst : CommRing R] β
[inst_1 : CommRing S] β
[inst_2 : Algebra R S] β
[inst_3 : IsDomain R] β
[inst_4 : IsPrincipalIdealRing R] β
[inst_5 : IsDomain S] β
[inst_6 : Finite ΞΉ] β
(F : Type u_4) β
[inst_7 : CommRing F] β
[inst_8 : Algebra F R] β
[inst_9 : Algebra F S] β
[IsScalarTower F R S] β
(b : Module.Basis ΞΉ R S) β
{I : Ideal S} β
(hI : I β β₯) β
(S β§Έ I) ββ[F] DirectSum ΞΉ fun i => R β§Έ Ideal.span {Ideal.smithCoeffs b I hI i}
|
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.logUnassignedUsingErrorInfos.match_1
|
Lean.Elab.Term.TermElabM
|
(motive : MProd Lean.MVarIdSet (MProd (Array Lean.Elab.Term.MVarErrorInfo) Bool) β Sort u_1) β
(r : MProd Lean.MVarIdSet (MProd (Array Lean.Elab.Term.MVarErrorInfo) Bool)) β
((alreadyVisited : Lean.MVarIdSet) β
(errors : Array Lean.Elab.Term.MVarErrorInfo) β
(hasNewErrors : Bool) β motive β¨alreadyVisited, errors, hasNewErrorsβ©) β
motive r
|
CategoryTheory.Functor.DenseAt.ofIso
|
Mathlib.CategoryTheory.Functor.KanExtension.DenseAt
|
{C : Type uβ} β
{D : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
[inst_1 : CategoryTheory.Category.{vβ, uβ} D] β
{F : CategoryTheory.Functor C D} β {Y : D} β F.DenseAt Y β {Y' : D} β (Y β
Y') β F.DenseAt Y'
|
Option.merge.eq_4
|
Init.Omega.Constraint
|
β {Ξ± : Type u_1} (fn : Ξ± β Ξ± β Ξ±) (x_2 y : Ξ±), Option.merge fn (some x_2) (some y) = some (fn x_2 y)
|
Lean.Server.RequestCancellation._sizeOf_1
|
Lean.Server.RequestCancellation
|
Lean.Server.RequestCancellation β β
|
SemiRingCat.FilteredColimits.colimitCoconeIsColimit._proof_2
|
Mathlib.Algebra.Category.Ring.FilteredColimits
|
β {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : CategoryTheory.IsFiltered J] (t : CategoryTheory.Limits.Cocone F)
(x y : β(SemiRingCat.FilteredColimits.R F)),
(β(SemiRingCat.FilteredColimits.colimitCoconeIsColimit.descAddMonoidHom t)).toFun (x * y) =
(β(SemiRingCat.FilteredColimits.colimitCoconeIsColimit.descAddMonoidHom t)).toFun x *
(β(SemiRingCat.FilteredColimits.colimitCoconeIsColimit.descAddMonoidHom t)).toFun y
|
ContinuousLinearEquiv.equivLike._proof_1
|
Mathlib.Topology.Algebra.Module.Equiv
|
β {Rβ : Type u_1} {Rβ : Type u_2} [inst : Semiring Rβ] [inst_1 : Semiring Rβ] {Οββ : Rβ β+* Rβ} {Οββ : Rβ β+* Rβ}
[inst_2 : RingHomInvPair Οββ Οββ] [inst_3 : RingHomInvPair Οββ Οββ] {Mβ : Type u_3} [inst_4 : TopologicalSpace Mβ]
[inst_5 : AddCommMonoid Mβ] {Mβ : Type u_4} [inst_6 : TopologicalSpace Mβ] [inst_7 : AddCommMonoid Mβ]
[inst_8 : Module Rβ Mβ] [inst_9 : Module Rβ Mβ] (f : Mβ βSL[Οββ] Mβ),
Function.LeftInverse f.invFun (βf.toLinearEquiv).toFun
|
Lean.FindLevelMVar.main._unsafe_rec
|
Lean.Util.FindLevelMVar
|
(Lean.LMVarId β Bool) β Lean.Expr β Lean.FindLevelMVar.Visitor
|
CategoryTheory.Enriched.FunctorCategory.homEquiv_apply_Ο_assoc
|
Mathlib.CategoryTheory.Enriched.FunctorCategory
|
β (V : Type uβ) [inst : CategoryTheory.Category.{vβ, uβ} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type uβ}
[inst_2 : CategoryTheory.Category.{vβ, uβ} C] {J : Type uβ} [inst_3 : CategoryTheory.Category.{vβ, uβ} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] {Fβ Fβ : CategoryTheory.Functor J C}
[inst_5 : CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V Fβ Fβ] (Ο : Fβ βΆ Fβ) (j : J) {Z : V}
(h : (Fβ.obj j βΆ[V] Fβ.obj j) βΆ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Enriched.FunctorCategory.homEquiv V) Ο)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Enriched.FunctorCategory.enrichedHomΟ V Fβ Fβ j) h) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.eHomEquiv V) (Ο.app j)) h
|
FirstCountableTopology.frechetUrysohnSpace
|
Mathlib.Topology.Sequences
|
β {X : Type u_1} [inst : TopologicalSpace X] [FirstCountableTopology X], FrechetUrysohnSpace X
|
Int.cast_le_neg_one_of_neg
|
Mathlib.Algebra.Order.Ring.Cast
|
β {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : β€}, a < 0 β βa β€ -1
|
WithZero.instAddMonoidWithOne
|
Mathlib.Algebra.GroupWithZero.WithZero
|
{Ξ± : Type u_1} β [AddMonoidWithOne Ξ±] β AddMonoidWithOne (WithZero Ξ±)
|
DFinsupp.tsub.congr_simp
|
Mathlib.Data.DFinsupp.Order
|
β {ΞΉ : Type u_1} (Ξ± : ΞΉ β Type u_2) [inst : (i : ΞΉ) β AddCommMonoid (Ξ± i)] [inst_1 : (i : ΞΉ) β PartialOrder (Ξ± i)]
[inst_2 : β (i : ΞΉ), CanonicallyOrderedAdd (Ξ± i)] [inst_3 : (i : ΞΉ) β Sub (Ξ± i)]
[inst_4 : β (i : ΞΉ), OrderedSub (Ξ± i)], DFinsupp.tsub Ξ± = DFinsupp.tsub Ξ±
|
lt_of_mul_self_lt_mul_selfβ
|
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic
|
β {Mβ : Type u_2} [inst : MonoidWithZero Mβ] [inst_1 : LinearOrder Mβ] [PosMulStrictMono Mβ] {a b : Mβ} [MulPosMono Mβ],
0 β€ b β a * a < b * b β a < b
|
Module.piEquiv
|
Mathlib.LinearAlgebra.StdBasis
|
(ΞΉ : Type u_1) β
(R : Type u_2) β
(M : Type u_3) β
[Finite ΞΉ] β
[inst : CommSemiring R] β [inst_1 : AddCommMonoid M] β [inst_2 : Module R M] β (ΞΉ β M) ββ[R] (ΞΉ β R) ββ[R] M
|
Orientation.rotationAux._proof_1
|
Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation
|
β {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V], SMulCommClass β β V
|
ContinuousLinearMap.bilinear_hasTemperateGrowth
|
Mathlib.Analysis.Distribution.TemperateGrowth
|
β {π : Type u_1} {D : Type u_3} {E : Type u_4} {F : Type u_5} {G : Type u_6} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace β E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace β F]
[inst_4 : NontriviallyNormedField π] [NormedAlgebra β π] [inst_6 : NormedAddCommGroup D] [inst_7 : NormedSpace β D]
[inst_8 : NormedAddCommGroup G] [inst_9 : NormedSpace β G] [inst_10 : NormedSpace π F] [inst_11 : NormedSpace π G]
[inst_12 : NormedSpace π E] (B : E βL[π] F βL[π] G) {f : D β E} {g : D β F},
Function.HasTemperateGrowth f β Function.HasTemperateGrowth g β Function.HasTemperateGrowth fun x => (B (f x)) (g x)
|
Lean.Grind.ToInt.toInt.eq_1
|
Init.Data.Int.OfNat
|
β (Ξ± : Type u) {range : Lean.Grind.IntInterval} [self : Lean.Grind.ToInt Ξ± range], Lean.Grind.ToInt.toInt = self.1
|
Lean.Meta.Try.Collector.OrdSet.set
|
Lean.Meta.Tactic.Try.Collect
|
{Ξ± : Type} β [inst : Hashable Ξ±] β [inst_1 : BEq Ξ±] β Lean.Meta.Try.Collector.OrdSet Ξ± β Std.HashSet Ξ±
|
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasProd_fintype_support._simp_1_1
|
Mathlib.Topology.Algebra.InfiniteSum.Defs
|
β {Ξ± : Type u} {ΞΉ : Sort v} {x : Ξ±} {s : ΞΉ β Set Ξ±}, (x β β i, s i) = β (i : ΞΉ), x β s i
|
hasStrictDerivAt_abs
|
Mathlib.Analysis.Calculus.Deriv.Abs
|
β {x : β}, x β 0 β HasStrictDerivAt (fun x => |x|) (β(SignType.sign x)) x
|
Fin.dfoldrM.loop._sunfold
|
Batteries.Data.Fin.Basic
|
{m : Type u_1 β Type u_2} β
[Monad m] β
(n : β) β
(Ξ± : Fin (n + 1) β Type u_1) β
((i : Fin n) β Ξ± i.succ β m (Ξ± i.castSucc)) β (i : β) β (h : i < n + 1) β Ξ± β¨i, hβ© β m (Ξ± 0)
|
_private.Mathlib.Algebra.CharP.Two.0.CharP.orderOf_eq_two_iff._simp_1_2
|
Mathlib.Algebra.CharP.Two
|
β {R : Type u} [inst : Ring R] {a : R} [NoZeroDivisors R], (a ^ 2 = 1) = (a = 1 β¨ a = -1)
|
matPolyEquiv_symm_map_eval
|
Mathlib.RingTheory.MatrixPolynomialAlgebra
|
β {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(M : Polynomial (Matrix n n R)) (r : R),
(matPolyEquiv.symm M).map (Polynomial.eval r) = Polynomial.eval ((Matrix.scalar n) r) M
|
MonoidWithZero.toOppositeMulActionWithZero
|
Mathlib.Algebra.GroupWithZero.Action.Defs
|
(Mβ : Type u_2) β [inst : MonoidWithZero Mβ] β MulActionWithZero Mβα΅α΅α΅ Mβ
|
Module.Basis.dualBasis_coord_toDualEquiv_apply
|
Mathlib.LinearAlgebra.Dual.Basis
|
β {R : Type uR} {M : Type uM} {ΞΉ : Type uΞΉ} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ΞΉ] (b : Module.Basis ΞΉ R M) [inst_4 : Finite ΞΉ] (i : ΞΉ) (f : M),
(b.dualBasis.coord i) (b.toDualEquiv f) = (b.coord i) f
|
Lean.Parser.Module.module.formatter
|
Lean.Parser.Module
|
Lean.PrettyPrinter.Formatter
|
Module.Basis.noConfusionType
|
Mathlib.LinearAlgebra.Basis.Defs
|
{ΞΉ : Type u_1} β
{R : Type u_3} β
{M : Type u_6} β
[inst : Semiring R] β
[inst_1 : AddCommMonoid M] β [inst_2 : Module R M] β Sort u β Module.Basis ΞΉ R M β Module.Basis ΞΉ R M β Sort u
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.