name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
GroupLike.val_inj._simp_1
|
Mathlib.RingTheory.Coalgebra.GroupLike
|
β {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] {a b : GroupLike R A}, (βa = βb) = (a = b)
|
Lean.Meta.mkSizeOfFns
|
Lean.Meta.SizeOf
|
Lean.Name β Lean.MetaM (Array Lean.Name Γ Lean.NameMap Lean.Name)
|
skewAdjointLieSubalgebra
|
Mathlib.Algebra.Lie.SkewAdjoint
|
{R : Type u} β
{M : Type v} β
[inst : CommRing R] β
[inst_1 : AddCommGroup M] β [inst_2 : Module R M] β LinearMap.BilinForm R M β LieSubalgebra R (Module.End R M)
|
forall_gt_imp_ne_iff_le
|
Mathlib.Order.Basic
|
β {Ξ± : Type u_2} [inst : LinearOrder Ξ±] {a b : Ξ±}, (β (c : Ξ±), a < c β c β b) β b β€ a
|
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.instDecidableEqLiteral.decEq._proof_1
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec
|
β (a : β) (a_1 : BitVec a), { n := a, value := a_1 } = { n := a, value := a_1 }
|
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.List.getValue?_filter_containsKey._simp_1_2
|
Std.Data.Internal.List.Associative
|
β {Ξ± : Type u_1} {x : Option Ξ±} {Ξ±_1 : Type u_2} {f : Ξ± β Ξ±_1}, (Option.map f x = none) = (x = none)
|
Lean.Meta.Grind.AC.MonadGetStruct.noConfusion
|
Lean.Meta.Tactic.Grind.AC.Util
|
{P : Sort u} β
{m : Type β Type} β
{t : Lean.Meta.Grind.AC.MonadGetStruct m} β
{m' : Type β Type} β
{t' : Lean.Meta.Grind.AC.MonadGetStruct m'} β
m = m' β t β t' β Lean.Meta.Grind.AC.MonadGetStruct.noConfusionType P t t'
|
BitVec.reduceGetMsb
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec
|
Lean.Meta.Simp.DSimproc
|
MulOpposite.isCancelMulZero_iff
|
Mathlib.Algebra.GroupWithZero.Opposite
|
β {Ξ± : Type u_1} [inst : Mul Ξ±] [inst_1 : Zero Ξ±], IsCancelMulZero Ξ±α΅α΅α΅ β IsCancelMulZero Ξ±
|
Submodule.mem_sSup
|
Mathlib.LinearAlgebra.Span.Defs
|
β {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{s : Set (Submodule R M)} {m : M}, m β sSup s β β (N : Submodule R M), (β p β s, p β€ N) β m β N
|
CategoryTheory.MorphismProperty.multiplicativeClosure.below.casesOn
|
Mathlib.CategoryTheory.MorphismProperty.Composition
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
{motive : β¦X Y : Cβ¦ β (x : X βΆ Y) β W.multiplicativeClosure x β Prop}
{motive_1 :
{X Y : C} β
{x : X βΆ Y} β
(t : W.multiplicativeClosure x) β CategoryTheory.MorphismProperty.multiplicativeClosure.below t β Prop}
{X Y : C} {x : X βΆ Y} {t : W.multiplicativeClosure x}
(t_1 : CategoryTheory.MorphismProperty.multiplicativeClosure.below t),
(β {x y : C} (f : x βΆ y) (hf : W f), motive_1 β― β―) β
(β (x : C), motive_1 β― β―) β
(β {x y z : C} (f : x βΆ y) (g : y βΆ z) (hf : W.multiplicativeClosure f) (hg : W g)
(ih : CategoryTheory.MorphismProperty.multiplicativeClosure.below hf) (hf_ih : motive f hf), motive_1 β― β―) β
motive_1 t t_1
|
Aesop.UnsafeQueueEntry.instToString.match_1
|
Aesop.Tree.UnsafeQueue
|
(motive : Aesop.UnsafeQueueEntry β Sort u_1) β
(x : Aesop.UnsafeQueueEntry) β
((r : Aesop.IndexMatchResult Aesop.UnsafeRule) β motive (Aesop.UnsafeQueueEntry.unsafeRule r)) β
((r : Aesop.PostponedSafeRule) β motive (Aesop.UnsafeQueueEntry.postponedSafeRule r)) β motive x
|
ContinuousMultilinearMap.smulRightL._proof_2
|
Mathlib.Analysis.Normed.Module.Multilinear.Basic
|
β (π : Type u_4) {ΞΉ : Type u_1} (E : ΞΉ β Type u_2) (G : Type u_3) [inst : NontriviallyNormedField π]
[inst_1 : (i : ΞΉ) β SeminormedAddCommGroup (E i)] [inst_2 : (i : ΞΉ) β NormedSpace π (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace π G] [inst_5 : Fintype ΞΉ]
(f : ContinuousMultilinearMap π E π) (x y : G), f.smulRight (x + y) = f.smulRight x + f.smulRight y
|
modelWithCornersEuclideanQuadrant
|
Mathlib.Geometry.Manifold.Instances.Real
|
(n : β) β ModelWithCorners β (EuclideanSpace β (Fin n)) (EuclideanQuadrant n)
|
ModularForm.trace
|
Mathlib.NumberTheory.ModularForms.NormTrace
|
{π’ : Subgroup (GL (Fin 2) β)} β
(β : Subgroup (GL (Fin 2) β)) β
{F : Type u_1} β
F β
[inst : FunLike F UpperHalfPlane β] β
{k : β€} β [π’.IsFiniteRelIndex β] β [ModularFormClass F π’ k] β ModularForm β k
|
CompleteOrthogonalIdempotents.ringEquivOfIsMulCentral._proof_3
|
Mathlib.RingTheory.Idempotents
|
β {R : Type u_1} {I : Type u_2} {e : I β R} [inst : Semiring R] (r : R) (i : I), β y, e i * y * e i = e i * r * e i
|
CommMonCat.forgetβ_map_ofHom
|
Mathlib.Algebra.Category.MonCat.Basic
|
β {X Y : Type u} [inst : CommMonoid X] [inst_1 : CommMonoid Y] (f : X β* Y),
(CategoryTheory.forgetβ CommMonCat MonCat).map (CommMonCat.ofHom f) = MonCat.ofHom f
|
Lean.Parser.Term.doHave._regBuiltin.Lean.Parser.Term.doHave_1
|
Lean.Parser.Do
|
IO Unit
|
Lean.Doc.Part.below_2
|
Lean.DocString.Types
|
{i : Type u} β
{b : Type v} β
{p : Type w} β
{motive_1 : Lean.Doc.Part i b p β Sort u_1} β
{motive_2 : Array (Lean.Doc.Part i b p) β Sort u_1} β
{motive_3 : List (Lean.Doc.Part i b p) β Sort u_1} β
List (Lean.Doc.Part i b p) β Sort (max ((max (max u v) w) + 1) u_1)
|
MeasureTheory.setToFun_mono_left'
|
Mathlib.MeasureTheory.Integral.SetToL1
|
β {Ξ± : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E] {m : MeasurableSpace Ξ±}
{ΞΌ : MeasureTheory.Measure Ξ±} {G'' : Type u_8} [inst_2 : NormedAddCommGroup G''] [inst_3 : PartialOrder G'']
[OrderClosedTopology G''] [IsOrderedAddMonoid G''] [inst_6 : NormedSpace β G''] [inst_7 : CompleteSpace G'']
{T T' : Set Ξ± β E βL[β] G''} {C C' : β} (hT : MeasureTheory.DominatedFinMeasAdditive ΞΌ T C)
(hT' : MeasureTheory.DominatedFinMeasAdditive ΞΌ T' C'),
(β (s : Set Ξ±), MeasurableSet s β ΞΌ s < β€ β β (x : E), (T s) x β€ (T' s) x) β
β (f : Ξ± β E), MeasureTheory.setToFun ΞΌ T hT f β€ MeasureTheory.setToFun ΞΌ T' hT' f
|
PNat.instSuccAddOrder
|
Mathlib.Data.PNat.Order
|
SuccAddOrder β+
|
contMDiff_zero_iff
|
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'},
ContMDiff I I' 0 f β Continuous f
|
UniformSpaceCat.instFunLike
|
Mathlib.Topology.Category.UniformSpace
|
(X : UniformSpaceCat) β (Y : UniformSpaceCat) β FunLike { f // UniformContinuous f } X.carrier Y.carrier
|
_private.Mathlib.Topology.Order.DenselyOrdered.0.comap_coe_Ioi_nhdsGT.match_1_1
|
Mathlib.Topology.Order.DenselyOrdered
|
β {Ξ± : Type u_1} [inst : LinearOrder Ξ±] (a : Ξ±) (motive : (Set.Ioi a).Nonempty β Prop) (x : (Set.Ioi a).Nonempty),
(β (x : Ξ±) (hx : x β Set.Ioi a), motive β―) β motive x
|
Nat.log_le_clog._simp_1
|
Mathlib.Data.Nat.Log
|
β (b n : β), (Nat.log b n β€ Nat.clog b n) = True
|
dvd_differentIdeal_iff
|
Mathlib.RingTheory.DedekindDomain.Different
|
β {A : Type u_1} {B : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[IsDedekindDomain A] [inst_5 : IsDedekindDomain B] [inst_6 : NoZeroSMulDivisors A B] [Module.Finite A B]
[Algebra.IsSeparable (FractionRing A) (FractionRing B)] {P : Ideal B} [inst_9 : P.IsPrime],
P β£ differentIdeal A B β Β¬Algebra.IsUnramifiedAt A P
|
WType.toList.match_1
|
Mathlib.Data.W.Constructions
|
(Ξ³ : Type u_1) β
(motive : WType (WType.ListΞ² Ξ³) β Sort u_2) β
(x : WType (WType.ListΞ² Ξ³)) β
((f : WType.ListΞ² Ξ³ WType.ListΞ±.nil β WType (WType.ListΞ² Ξ³)) β motive (WType.mk WType.ListΞ±.nil f)) β
((hd : Ξ³) β
(f : WType.ListΞ² Ξ³ (WType.ListΞ±.cons hd) β WType (WType.ListΞ² Ξ³)) β
motive (WType.mk (WType.ListΞ±.cons hd) f)) β
motive x
|
_private.Aesop.Util.Basic.0.Aesop.filterTrieM.go.match_3
|
Aesop.Util.Basic
|
{Ξ± : Type} β
(motive : Lean.Meta.DiscrTree.Key Γ Lean.Meta.DiscrTree.Trie Ξ± β Sort u_1) β
(x : Lean.Meta.DiscrTree.Key Γ Lean.Meta.DiscrTree.Trie Ξ±) β
((key : Lean.Meta.DiscrTree.Key) β (t : Lean.Meta.DiscrTree.Trie Ξ±) β motive (key, t)) β motive x
|
Lean.Server.Test.Runner.Client.InfoPopup.ctorIdx
|
Lean.Server.Test.Runner
|
Lean.Server.Test.Runner.Client.InfoPopup β β
|
Aesop.ElabM.Context.casesOn
|
Aesop.ElabM
|
{motive : Aesop.ElabM.Context β Sort u} β
(t : Aesop.ElabM.Context) β
((parsePriorities : Bool) β (goal : Lean.MVarId) β motive { parsePriorities := parsePriorities, goal := goal }) β
motive t
|
Lean.MessageData.withContext
|
Lean.Message
|
Lean.MessageDataContext β Lean.MessageData β Lean.MessageData
|
CategoryTheory.Mon.hom_one
|
Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_
|
β {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Mon C) [inst_3 : CategoryTheory.IsCommMonObj M.X],
CategoryTheory.MonObj.one.hom = CategoryTheory.MonObj.one
|
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.mkOfLe.match_1.splitter
|
Mathlib.AlgebraicTopology.SimplexCategory.Basic
|
(motive : Fin (1 + 1) β Sort u_1) β (x : Fin (1 + 1)) β (Unit β motive 0) β (Unit β motive 1) β motive x
|
_private.Lean.Elab.DocString.0.Lean.Doc.builtinElabName.match_1
|
Lean.Elab.DocString
|
(motive : Lean.Name β Sort u_1) β
(n : Lean.Name) β ((str : String) β motive (Lean.Name.anonymous.str str)) β ((x : Lean.Name) β motive x) β motive n
|
Std.DHashMap.Internal.Rawβ.getKey?_eq_some_iff
|
Std.Data.DHashMap.Internal.RawLemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} (m : Std.DHashMap.Internal.Rawβ Ξ± Ξ²) [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] [EquivBEq Ξ±]
[LawfulHashable Ξ±], (βm).WF β β {k k' : Ξ±}, m.getKey? k = some k' β β (h : m.contains k = true), m.getKey k h = k'
|
_private.Lean.AddDecl.0.Lean.addDecl._sparseCasesOn_10
|
Lean.AddDecl
|
{Ξ± : Type u} β
{motive : List Ξ± β Sort u_1} β (t : List Ξ±) β motive [] β (Nat.hasNotBit 1 t.ctorIdx β motive t) β motive t
|
HomologicalComplex.mapBifunctor.hom_ext_iff
|
Mathlib.Algebra.Homology.Bifunctor
|
β {Cβ : Type u_1} {Cβ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} Cβ]
[inst_1 : CategoryTheory.Category.{v_2, u_2} Cβ] [inst_2 : CategoryTheory.Category.{v_3, u_3} D] {Iβ : Type u_4}
{Iβ : Type u_5} {J : Type u_6} {cβ : ComplexShape Iβ} {cβ : ComplexShape Iβ}
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms Cβ] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms Cβ]
[inst_5 : CategoryTheory.Preadditive D] {Kβ : HomologicalComplex Cβ cβ} {Kβ : HomologicalComplex Cβ cβ}
{F : CategoryTheory.Functor Cβ (CategoryTheory.Functor Cβ D)} [inst_6 : F.PreservesZeroMorphisms]
[inst_7 : β (Xβ : Cβ), (F.obj Xβ).PreservesZeroMorphisms] {c : ComplexShape J} [inst_8 : TotalComplexShape cβ cβ c]
[inst_9 : Kβ.HasMapBifunctor Kβ F c] [inst_10 : DecidableEq J] {Y : D} {j : J}
{f g : (Kβ.mapBifunctor Kβ F c).X j βΆ Y},
f = g β
β (iβ : Iβ) (iβ : Iβ) (h : cβ.Ο cβ c (iβ, iβ) = j),
CategoryTheory.CategoryStruct.comp (Kβ.ΞΉMapBifunctor Kβ F c iβ iβ j h) f =
CategoryTheory.CategoryStruct.comp (Kβ.ΞΉMapBifunctor Kβ F c iβ iβ j h) g
|
StieltjesFunction.measurable_measure
|
Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes
|
β {Ξ± : Type u_1} {x : MeasurableSpace Ξ±} {f : Ξ± β StieltjesFunction β},
(β (q : β), Measurable fun a => β(f a) q) β
(β (a : Ξ±), Filter.Tendsto (β(f a)) Filter.atBot (nhds 0)) β
(β (a : Ξ±), Filter.Tendsto (β(f a)) Filter.atTop (nhds 1)) β Measurable fun a => (f a).measure
|
OrderMonoidWithZeroHom.toMonoidWithZeroHom_mk
|
Mathlib.Algebra.Order.Hom.MonoidWithZero
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} {hΞ± : Preorder Ξ±} {hΞ±' : MulZeroOneClass Ξ±} {hΞ² : Preorder Ξ²} {hΞ²' : MulZeroOneClass Ξ²}
(f : Ξ± β*β Ξ²) (hf : Monotone βf), β{ toMonoidWithZeroHom := f, monotone' := hf } = f
|
_private.Batteries.Tactic.Trans.0.Batteries.Tactic.initFn.match_7._@.Batteries.Tactic.Trans.2247956323._hygCtx._hyg.2
|
Batteries.Tactic.Trans
|
(motive : Array Lean.Expr Γ Array Lean.BinderInfo Γ Lean.Expr β Sort u_1) β
(__discr : Array Lean.Expr Γ Array Lean.BinderInfo Γ Lean.Expr) β
((xs : Array Lean.Expr) β (fst : Array Lean.BinderInfo) β (targetTy : Lean.Expr) β motive (xs, fst, targetTy)) β
motive __discr
|
_private.Mathlib.MeasureTheory.Group.Integral.0.MeasureTheory.integral_eq_zero_of_mul_right_eq_neg._simp_1_2
|
Mathlib.MeasureTheory.Group.Integral
|
β {Ξ± : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace β G] {m : MeasurableSpace Ξ±}
{ΞΌ : MeasureTheory.Measure Ξ±} (f : Ξ± β G), -β« (a : Ξ±), f a βΞΌ = β« (a : Ξ±), -f a βΞΌ
|
mem_leftCoset_leftCoset
|
Mathlib.GroupTheory.Coset.Basic
|
β {Ξ± : Type u_1} [inst : Monoid Ξ±] (s : Submonoid Ξ±) {a : Ξ±}, a β’ βs = βs β a β s
|
Real.geom_mean_le_arith_mean4_weighted
|
Mathlib.Analysis.MeanInequalities
|
β {wβ wβ wβ wβ pβ pβ pβ pβ : β},
0 β€ wβ β
0 β€ wβ β
0 β€ wβ β
0 β€ wβ β
0 β€ pβ β
0 β€ pβ β
0 β€ pβ β
0 β€ pβ β
wβ + wβ + wβ + wβ = 1 β pβ ^ wβ * pβ ^ wβ * pβ ^ wβ * pβ ^ wβ β€ wβ * pβ + wβ * pβ + wβ * pβ + wβ * pβ
|
addSubgroupOfIdempotent._proof_3
|
Mathlib.GroupTheory.OrderOfElement
|
β {G : Type u_1} [inst : AddGroup G] [inst_1 : Finite G] (S : Set G) (hS1 : S.Nonempty) (hS2 : S + S = S) {a : G},
a β S β -a β addSubmonoidOfIdempotent S hS1 hS2
|
groupCohomology.instEpiModuleCatH2Ο
|
Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree
|
β {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G), CategoryTheory.Epi (groupCohomology.H2Ο A)
|
CategoryTheory.StrictlyUnitaryPseudofunctorCore.mapβ_whisker_right._autoParam
|
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary
|
Lean.Syntax
|
TwoSidedIdeal.coe_equivMatricesOver_symm_apply
|
Mathlib.LinearAlgebra.Matrix.Ideal
|
β {R : Type u_1} {n : Type u_2} [inst : NonAssocRing R] [inst_1 : Fintype n] [inst_2 : Nonempty n]
[inst_3 : DecidableEq n] (I : TwoSidedIdeal (Matrix n n R)) (i j : n),
β(TwoSidedIdeal.equivMatrix.symm I) = {x | β N β I, N i j = x}
|
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent.noConfusion
|
Lean.Meta.Tactic.Grind.AC.Types
|
{P : Sort u} β
{x : Lean.Grind.AC.Var} β
{cβ : Lean.Meta.Grind.AC.EqCnstr} β
{x' : Lean.Grind.AC.Var} β
{cβ' : Lean.Meta.Grind.AC.EqCnstr} β
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x cβ =
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x' cβ' β
(x = x' β cβ = cβ' β P) β P
|
_private.Mathlib.Algebra.ContinuedFractions.Computation.Approximations.0.GenContFract.sub_convs_eq._simp_1_1
|
Mathlib.Algebra.ContinuedFractions.Computation.Approximations
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] (a : Ξ±), (a β€ a) = True
|
AlgEquiv.ofInjectiveField._proof_1
|
Mathlib.Algebra.Algebra.Subalgebra.Basic
|
β {R : Type u_3} [inst : CommSemiring R] {E : Type u_1} {F : Type u_2} [inst_1 : DivisionRing E] [inst_2 : Semiring F]
[Nontrivial F] [inst_4 : Algebra R E] [inst_5 : Algebra R F] (f : E ββ[R] F), Function.Injective βf.toRingHom
|
Sum.map_bijective
|
Mathlib.Data.Sum.Basic
|
β {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type u_1} {Ξ΄ : Type u_2} {f : Ξ± β Ξ³} {g : Ξ² β Ξ΄},
Function.Bijective (Sum.map f g) β Function.Bijective f β§ Function.Bijective g
|
SetTheory.PGame.InvTy.leftβ.inj
|
Mathlib.SetTheory.Game.Basic
|
β {l r : Type u} {a : l} {a_1 : SetTheory.PGame.InvTy l r true} {a_2 : l} {a_3 : SetTheory.PGame.InvTy l r true},
SetTheory.PGame.InvTy.leftβ a a_1 = SetTheory.PGame.InvTy.leftβ a_2 a_3 β a = a_2 β§ a_1 = a_3
|
Set.chainHeight_eq_top_iff
|
Mathlib.Order.Height
|
β {Ξ± : Type u_1} (s : Set Ξ±) (r : Ξ± β Ξ± β Prop), s.chainHeight r = β€ β β (n : β), β t β s, t.encard = βn β§ IsChain r t
|
SubAddAction.ofStabilizer.conjMap._proof_5
|
Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer
|
β {G : Type u_1} [inst : AddGroup G] {Ξ± : Type u_2} [inst_1 : AddAction G Ξ±] {g : G} {a b : Ξ±} (hg : b = g +α΅₯ a)
(x : β₯(AddAction.stabilizer G a)) (x_1 : β₯(SubAddAction.ofStabilizer G a)),
β¨g +α΅₯ β(x +α΅₯ x_1), β―β© = (AddAction.stabilizerEquivStabilizer hg) x +α΅₯ β¨g +α΅₯ βx_1, β―β©
|
_private.Init.Data.UInt.Bitwise.0.UInt8.xor_eq_zero_iff._simp_1_1
|
Init.Data.UInt.Bitwise
|
β {a b : UInt8}, (a = b) = (a.toBitVec = b.toBitVec)
|
Lean.Elab.CompletionInfo.option.inj
|
Lean.Elab.InfoTree.Types
|
β {stx stx_1 : Lean.Syntax}, Lean.Elab.CompletionInfo.option stx = Lean.Elab.CompletionInfo.option stx_1 β stx = stx_1
|
CategoryTheory.ShortComplex.LeftHomologyData.copy._proof_1
|
Mathlib.Algebra.Homology.ShortComplex.LeftHomology
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {K' : C} (eK : K' β
h.K),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp eK.hom h.i) S.g = 0
|
Lean.Expr.name?
|
Lean.Util.Recognizers
|
Lean.Expr β Option Lean.Name
|
CochainComplex.of._proof_3
|
Mathlib.Algebra.Homology.HomologicalComplex
|
β {V : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
{Ξ± : Type u_1} [inst_2 : AddRightCancelSemigroup Ξ±] [inst_3 : One Ξ±] [inst_4 : DecidableEq Ξ±] (X : Ξ± β V)
(d : (n : Ξ±) β X n βΆ X (n + 1)),
(β (n : Ξ±), CategoryTheory.CategoryStruct.comp (d n) (d (n + 1)) = 0) β
β (i j k : Ξ±),
(ComplexShape.up Ξ±).Rel i j β
(ComplexShape.up Ξ±).Rel j k β
CategoryTheory.CategoryStruct.comp
(if h : i + 1 = j then CategoryTheory.CategoryStruct.comp (d i) (CategoryTheory.eqToHom β―) else 0)
(if h : j + 1 = k then CategoryTheory.CategoryStruct.comp (d j) (CategoryTheory.eqToHom β―) else 0) =
0
|
_private.Mathlib.RingTheory.WittVector.StructurePolynomial.0.wittStructureRat_vars._proof_1_5
|
Mathlib.RingTheory.WittVector.StructurePolynomial
|
β {idx : Type u_1} (n k : β) (i : idx), β j < k + 1, k β Finset.range (n + 1) β (i, j).2 < n + 1
|
Measurable.coe_real_ereal
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Real
|
β {Ξ± : Type u_1} {mΞ± : MeasurableSpace Ξ±} {f : Ξ± β β}, Measurable f β Measurable fun x => β(f x)
|
NFA.evalFrom_append
|
Mathlib.Computability.NFA
|
β {Ξ± : Type u} {Ο : Type v} (M : NFA Ξ± Ο) (S : Set Ο) (x y : List Ξ±),
M.evalFrom S (x ++ y) = M.evalFrom (M.evalFrom S x) y
|
Monoid.Coprod.fst
|
Mathlib.GroupTheory.Coprod.Basic
|
{M : Type u_1} β {N : Type u_2} β [inst : Monoid M] β [inst_1 : Monoid N] β Monoid.Coprod M N β* M
|
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.ContDiffWithinAt.congr_of_eventuallyEq.match_1_1
|
Mathlib.Analysis.Calculus.ContDiff.Defs
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {s : Set E}
{f : E β F} {x : E} (motive : (n : WithTop ββ) β ContDiffWithinAt π n f s x β Prop) (n : WithTop ββ)
(h : ContDiffWithinAt π n f s x),
(β (h : ContDiffWithinAt π β€ f s x), motive none h) β
(β (n : ββ) (h : ContDiffWithinAt π (βn) f s x), motive (some n) h) β motive n h
|
CategoryTheory.Sheaf.instCreatesLimitFunctorOppositeSheafToPresheaf._proof_3
|
Mathlib.CategoryTheory.Sites.Limits
|
β {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{D : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} D] {K : Type u_6}
[inst_2 : CategoryTheory.Category.{u_5, u_6} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape K D]
(F : CategoryTheory.Functor K (CategoryTheory.Sheaf J D))
(E : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.sheafToPresheaf J D))) (hE : CategoryTheory.Limits.IsLimit E)
(S : CategoryTheory.Limits.Cone F)
(m : S.pt βΆ { pt := { val := E.pt, cond := β― }, Ο := { app := fun x => { val := E.Ο.app x }, naturality := β― } }.pt),
(β (j : K),
CategoryTheory.CategoryStruct.comp m
({ pt := { val := E.pt, cond := β― }, Ο := { app := fun x => { val := E.Ο.app x }, naturality := β― } }.Ο.app
j) =
S.Ο.app j) β
m = { val := hE.lift ((CategoryTheory.sheafToPresheaf J D).mapCone S) }
|
ProfiniteGrp.coe_comp
|
Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic
|
β {X Y Z : ProfiniteGrp.{u_1}} (f : X βΆ Y) (g : Y βΆ Z),
β(ProfiniteGrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g)) =
β(ProfiniteGrp.Hom.hom g) β β(ProfiniteGrp.Hom.hom f)
|
Option.toArray_pmap
|
Init.Data.Option.Attach
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {p : Ξ± β Prop} {o : Option Ξ±} {f : (a : Ξ±) β p a β Ξ²} (h : β (a : Ξ±), o = some a β p a),
(Option.pmap f o h).toArray = Array.map (fun x => f βx β―) o.attach.toArray
|
IntermediateField.extendScalars_self
|
Mathlib.FieldTheory.IntermediateField.Adjoin.Defs
|
β {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L] (F : IntermediateField K L),
IntermediateField.extendScalars β― = β₯
|
noConfusionTypeEnum
|
Init.Core
|
{Ξ± : Sort u} β {Ξ² : Sort v} β [inst : DecidableEq Ξ²] β (Ξ± β Ξ²) β Sort w β Ξ± β Ξ± β Sort w
|
Subfield.extendScalars.orderIso._proof_5
|
Mathlib.FieldTheory.IntermediateField.Basic
|
β {L : Type u_1} [inst : Field L] (F : Subfield L) (E : IntermediateField (β₯F) L) (x : L) (hx : x β F),
(algebraMap (β₯F) L) β¨x, hxβ© β E
|
Lean.Lsp.SemanticTokenType.leanSorryLike
|
Lean.Data.Lsp.LanguageFeatures
|
Lean.Lsp.SemanticTokenType
|
Std.DTreeMap.Raw.Const.mem_iff_isSome_get?
|
Std.Data.DTreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {Ξ² : Type v} {t : Std.DTreeMap.Raw Ξ± (fun x => Ξ²) cmp} [Std.TransCmp cmp],
t.WF β β {a : Ξ±}, a β t β (Std.DTreeMap.Raw.Const.get? t a).isSome = true
|
Mathlib.Tactic.Ring.evalAddOverlap._proof_1
|
Mathlib.Tactic.Ring.Basic
|
β {u : Lean.Level} {Ξ± : Q(Type u)} (aβ bβ : Q(Β«$Ξ±Β»)), Β«$aβΒ» =Q Β«$bβΒ»
|
_private.Mathlib.LinearAlgebra.Matrix.Transvection.0.Matrix.Pivot.listTransvecCol_mul_last_col._simp_1_7
|
Mathlib.LinearAlgebra.Matrix.Transvection
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] (a : Ξ±), (a β€ a) = True
|
ZetaAsymptotics.zeta_limit_aux1
|
Mathlib.NumberTheory.Harmonic.ZetaAsymp
|
β {s : β}, 1 < s β β' (n : β), 1 / (βn + 1) ^ s - 1 / (s - 1) = 1 - s * ZetaAsymptotics.term_tsum s
|
Std.Internal.Async.IO.AsyncWrite.mk.noConfusion
|
Std.Internal.Async.IO
|
{Ξ± Ξ² : Type} β
{P : Sort u} β
{write : Ξ± β Ξ² β Std.Internal.IO.Async.Async Unit} β
{writeAll : Ξ± β Array Ξ² β Std.Internal.IO.Async.Async Unit} β
{flush : Ξ± β Std.Internal.IO.Async.Async Unit} β
{write' : Ξ± β Ξ² β Std.Internal.IO.Async.Async Unit} β
{writeAll' : Ξ± β Array Ξ² β Std.Internal.IO.Async.Async Unit} β
{flush' : Ξ± β Std.Internal.IO.Async.Async Unit} β
{ write := write, writeAll := writeAll, flush := flush } =
{ write := write', writeAll := writeAll', flush := flush' } β
(write β write' β writeAll β writeAll' β flush β flush' β P) β P
|
Subfield.copy._proof_6
|
Mathlib.Algebra.Field.Subfield.Defs
|
β {K : Type u_1} [inst : DivisionRing K] (S : Subfield K) (s : Set K), s = βS β β x β s, xβ»ΒΉ β s
|
Lean.IR.EmitLLVM.emitDel
|
Lean.Compiler.IR.EmitLLVM
|
{llvmctx : LLVM.Context} β LLVM.Builder llvmctx β Lean.IR.VarId β Lean.IR.EmitLLVM.M llvmctx Unit
|
List.max?_eq_some_iff'
|
Init.Data.List.Nat.Basic
|
β {a : β} {xs : List β}, xs.max? = some a β a β xs β§ β b β xs, b β€ a
|
PiTensorProduct.reindex_trans
|
Mathlib.LinearAlgebra.PiTensorProduct
|
β {ΞΉ : Type u_1} {ΞΉβ : Type u_2} {ΞΉβ : Type u_3} {R : Type u_4} [inst : CommSemiring R] {s : ΞΉ β Type u_7}
[inst_1 : (i : ΞΉ) β AddCommMonoid (s i)] [inst_2 : (i : ΞΉ) β Module R (s i)] (e : ΞΉ β ΞΉβ) (e' : ΞΉβ β ΞΉβ),
PiTensorProduct.reindex R s e βͺβ«β PiTensorProduct.reindex R (fun i => s (e.symm i)) e' =
PiTensorProduct.reindex R s (e.trans e')
|
_private.Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop.0.Std.Iterators.IteratorLoop.finiteForIn'.eq_1
|
Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop
|
β {m : Type w β Type w'} {n : Type x β Type x'} {Ξ± Ξ² : Type w} [inst : Std.Iterators.Iterator Ξ± m Ξ²]
[inst_1 : Std.Iterators.IteratorLoop Ξ± m n] [inst_2 : Monad n]
(lift : (Ξ³ : Type w) β (Ξ΄ : Type x) β (Ξ³ β n Ξ΄) β m Ξ³ β n Ξ΄),
Std.Iterators.IteratorLoop.finiteForIn' lift =
{
forIn' := fun {Ξ³} it init f =>
Std.Iterators.IteratorLoop.forIn lift Ξ³ (fun x x_1 x_2 => True) it init fun x1 x2 x3 => do
let __do_lift β f x1 x2 x3
pure β¨__do_lift, trivialβ© }
|
Polynomial.Gal.instUniqueOfFactSplits
|
Mathlib.FieldTheory.PolynomialGaloisGroup
|
{F : Type u_1} β [inst : Field F] β (p : Polynomial F) β [h : Fact p.Splits] β Unique p.Gal
|
Matroid.loopyOn_isBasis_iff
|
Mathlib.Combinatorics.Matroid.Constructions
|
β {Ξ± : Type u_1} {E I X : Set Ξ±}, (Matroid.loopyOn E).IsBasis I X β I = β
β§ X β E
|
_private.Mathlib.Order.Antichain.0.IsMaxAntichain.nonempty_iff._simp_1_1
|
Mathlib.Order.Antichain
|
β {Ξ± : Type u} {s : Set Ξ±}, (Β¬s.Nonempty) = (s = β
)
|
EsakiaHom.toPseudoEpimorphism
|
Mathlib.Topology.Order.Hom.Esakia
|
{Ξ± : Type u_2} β
{Ξ² : Type u_3} β
[inst : TopologicalSpace Ξ±] β
[inst_1 : Preorder Ξ±] β
[inst_2 : TopologicalSpace Ξ²] β [inst_3 : Preorder Ξ²] β EsakiaHom Ξ± Ξ² β PseudoEpimorphism Ξ± Ξ²
|
IndepMatroid.ofFinitaryCardAugment_E
|
Mathlib.Combinatorics.Matroid.IndepAxioms
|
β {Ξ± : Type u_1} (E : Set Ξ±) (Indep : Set Ξ± β Prop) (indep_empty : Indep β
)
(indep_subset : β β¦I J : Set Ξ±β¦, Indep J β I β J β Indep I)
(indep_aug :
β β¦I J : Set Ξ±β¦, Indep I β I.Finite β Indep J β J.Finite β I.ncard < J.ncard β β e β J, e β I β§ Indep (insert e I))
(indep_compact : β (I : Set Ξ±), (β J β I, J.Finite β Indep J) β Indep I)
(subset_ground : β (I : Set Ξ±), Indep I β I β E),
(IndepMatroid.ofFinitaryCardAugment E Indep indep_empty indep_subset indep_aug indep_compact subset_ground).E = E
|
ZLattice.sum_piFinset_Icc_rpow_le
|
Mathlib.Algebra.Module.ZLattice.Summable
|
β {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E] [inst_2 : FiniteDimensional β E]
{L : Submodule β€ E} [inst_3 : DiscreteTopology β₯L] {ΞΉ : Type u_3} [inst_4 : Fintype ΞΉ] [inst_5 : DecidableEq ΞΉ]
(b : Module.Basis ΞΉ β€ β₯L) {d : β},
d = Fintype.card ΞΉ β
β (n : β),
β r < -βd,
β p β Fintype.piFinset fun x => Finset.Icc (-βn) βn, ββ i, p i β’ b iβ ^ r β€
2 * βd * 3 ^ (d - 1) * ZLattice.normBound b ^ r * β' (k : β), βk ^ (βd - 1 + r)
|
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.eq_5
|
Mathlib.ModelTheory.Encoding
|
β {L : FirstOrder.Language} {Ξ± : Type u_3} (motive : (x : β) β L.BoundedFormula Ξ± x β Sort u_4) (x : β)
(Ο : L.BoundedFormula Ξ± (x + 1)) (h_1 : (n : β) β motive n FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : β) β (tβ tβ : L.Term (Ξ± β Fin x)) β motive x (FirstOrder.Language.BoundedFormula.equal tβ tβ))
(h_3 :
(n l : β) β
(R : L.Relations l) β (ts : Fin l β L.Term (Ξ± β Fin n)) β motive n (FirstOrder.Language.BoundedFormula.rel R ts))
(h_4 : (x : β) β (Οβ Οβ : L.BoundedFormula Ξ± x) β motive x (Οβ.imp Οβ))
(h_5 : (x : β) β (Ο : L.BoundedFormula Ξ± (x + 1)) β motive x Ο.all),
(match x, Ο.all with
| n, FirstOrder.Language.BoundedFormula.falsum => h_1 n
| x, FirstOrder.Language.BoundedFormula.equal tβ tβ => h_2 x tβ tβ
| n, FirstOrder.Language.BoundedFormula.rel R ts => h_3 n l R ts
| x, Οβ.imp Οβ => h_4 x Οβ Οβ
| x, Ο.all => h_5 x Ο) =
h_5 x Ο
|
Lean.Elab.instInhabitedDefViewElabHeaderData.default
|
Lean.Elab.DefView
|
Lean.Elab.DefViewElabHeaderData
|
CochainComplex.mappingCone.mapOfHomotopy
|
Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated
|
{C : Type u_1} β
[inst : CategoryTheory.Category.{v_1, u_1} C] β
[inst_1 : CategoryTheory.Preadditive C] β
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] β
{Kβ Lβ Kβ Lβ : CochainComplex C β€} β
{Οβ : Kβ βΆ Lβ} β
{Οβ : Kβ βΆ Lβ} β
{a : Kβ βΆ Kβ} β
{b : Lβ βΆ Lβ} β
Homotopy (CategoryTheory.CategoryStruct.comp Οβ b) (CategoryTheory.CategoryStruct.comp a Οβ) β
(CochainComplex.mappingCone Οβ βΆ CochainComplex.mappingCone Οβ)
|
DivisionRing.nnratCast_def
|
Mathlib.Algebra.Field.Defs
|
β {K : Type u_2} [self : DivisionRing K] (q : ββ₯0), βq = βq.num / βq.den
|
IsLocalization.noZeroDivisors
|
Mathlib.RingTheory.Localization.Defs
|
β {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] [NoZeroDivisors R], NoZeroDivisors S
|
Std.OrientedCmp.not_isGE_of_gt
|
Init.Data.Order.Ord
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} [Std.OrientedCmp cmp] {a b : Ξ±}, cmp a b = Ordering.gt β Β¬(cmp b a).isGE = true
|
CategoryTheory.Localization.liftβNatIso.eq_1
|
Mathlib.CategoryTheory.Localization.Monoidal.Braided
|
β {Cβ : Type u_1} {Cβ : Type u_2} {Dβ : Type u_3} {Dβ : Type u_4} {E : Type u_5}
[inst : CategoryTheory.Category.{v_1, u_1} Cβ] [inst_1 : CategoryTheory.Category.{v_2, u_2} Cβ]
[inst_2 : CategoryTheory.Category.{v_3, u_3} Dβ] [inst_3 : CategoryTheory.Category.{v_4, u_4} Dβ]
[inst_4 : CategoryTheory.Category.{v_5, u_5} E] (Lβ : CategoryTheory.Functor Cβ Dβ)
(Lβ : CategoryTheory.Functor Cβ Dβ) (Wβ : CategoryTheory.MorphismProperty Cβ)
(Wβ : CategoryTheory.MorphismProperty Cβ) [inst_5 : Lβ.IsLocalization Wβ] [inst_6 : Lβ.IsLocalization Wβ]
[inst_7 : Wβ.ContainsIdentities] [inst_8 : Wβ.ContainsIdentities]
(Fβ Fβ : CategoryTheory.Functor Cβ (CategoryTheory.Functor Cβ E))
(Fβ' Fβ' : CategoryTheory.Functor Dβ (CategoryTheory.Functor Dβ E))
[inst_9 : CategoryTheory.Localization.Liftingβ Lβ Lβ Wβ Wβ Fβ Fβ']
[inst_10 : CategoryTheory.Localization.Liftingβ Lβ Lβ Wβ Wβ Fβ Fβ'] (e : Fβ β
Fβ),
CategoryTheory.Localization.liftβNatIso Lβ Lβ Wβ Wβ Fβ Fβ Fβ' Fβ' e =
{ hom := CategoryTheory.Localization.liftβNatTrans Lβ Lβ Wβ Wβ Fβ Fβ Fβ' Fβ' e.hom,
inv := CategoryTheory.Localization.liftβNatTrans Lβ Lβ Wβ Wβ Fβ Fβ Fβ' Fβ' e.inv, hom_inv_id := β―,
inv_hom_id := β― }
|
Continuous.cfcβ_nnreal._auto_1
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity
|
Lean.Syntax
|
Std.Time.Modifier.Z
|
Std.Time.Format.Basic
|
Std.Time.OffsetZ β Std.Time.Modifier
|
Lean.Lsp.instToJsonInlayHintKind.match_1
|
Lean.Data.Lsp.LanguageFeatures
|
(motive : Lean.Lsp.InlayHintKind β Sort u_1) β
(x : Lean.Lsp.InlayHintKind) β
(Unit β motive Lean.Lsp.InlayHintKind.type) β (Unit β motive Lean.Lsp.InlayHintKind.parameter) β motive x
|
differentiableAt_add_const_iff._simp_1
|
Mathlib.Analysis.Calculus.FDeriv.Add
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {f : E β F}
{x : E} (c : F), DifferentiableAt π (fun y => f y + c) x = DifferentiableAt π f x
|
Lean.Meta.Occurrences.rec
|
Init.MetaTypes
|
{motive : Lean.Meta.Occurrences β Sort u} β
motive Lean.Meta.Occurrences.all β
((idxs : List β) β motive (Lean.Meta.Occurrences.pos idxs)) β
((idxs : List β) β motive (Lean.Meta.Occurrences.neg idxs)) β (t : Lean.Meta.Occurrences) β motive t
|
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Basic.0.MeasureTheory.le_iInf_lintegral._simp_1_1
|
Mathlib.MeasureTheory.Integral.Lebesgue.Basic
|
β {Ξ± : Type u_8} {Ξ² : Ξ± β Type u_9} {ΞΉ : Sort u_10} [inst : (i : Ξ±) β InfSet (Ξ² i)] {f : ΞΉ β (a : Ξ±) β Ξ² a} {a : Ξ±},
β¨
i, f i a = (β¨
i, f i) a
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.