name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Lean.Widget.MsgEmbed.brecOn_3.eq
|
Lean.Widget.InteractiveDiagnostic
|
β {motive_1 : Lean.Widget.MsgEmbed β Sort u} {motive_2 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed β Sort u}
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) β
Sort u}
{motive_4 : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed) β Sort u}
{motive_5 : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed) β Sort u}
(t : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) (F_1 : (t : Lean.Widget.MsgEmbed) β t.below β motive_1 t)
(F_2 : (t : Lean.Widget.TaggedText Lean.Widget.MsgEmbed) β Lean.Widget.MsgEmbed.below_1 t β motive_2 t)
(F_3 :
(t :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren)) β
Lean.Widget.MsgEmbed.below_2 t β motive_3 t)
(F_4 : (t : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) β Lean.Widget.MsgEmbed.below_3 t β motive_4 t)
(F_5 : (t : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) β Lean.Widget.MsgEmbed.below_4 t β motive_5 t),
Lean.Widget.MsgEmbed.brecOn_3 t F_1 F_2 F_3 F_4 F_5 = F_4 t (Lean.Widget.MsgEmbed.brecOn_3.go t F_1 F_2 F_3 F_4 F_5).2
|
ProbabilityTheory.Kernel.instIsFiniteKernelWithDensityRnDeriv
|
Mathlib.Probability.Kernel.RadonNikodym
|
β {Ξ± : Type u_1} {Ξ³ : Type u_2} {mΞ± : MeasurableSpace Ξ±} {mΞ³ : MeasurableSpace Ξ³} {ΞΊ Ξ· : ProbabilityTheory.Kernel Ξ± Ξ³}
[hΞ±Ξ³ : MeasurableSpace.CountableOrCountablyGenerated Ξ± Ξ³] [hΞΊ : ProbabilityTheory.IsFiniteKernel ΞΊ]
[inst : ProbabilityTheory.IsFiniteKernel Ξ·], ProbabilityTheory.IsFiniteKernel (Ξ·.withDensity (ΞΊ.rnDeriv Ξ·))
|
contDiffAt_fun_id
|
Mathlib.Analysis.Calculus.ContDiff.Basic
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {n : WithTop ββ} {x : E}, ContDiffAt π n (fun x => x) x
|
TopCat.GlueData.recOn
|
Mathlib.Topology.Gluing
|
{motive : TopCat.GlueData β Sort u} β
(t : TopCat.GlueData) β
((toGlueData : CategoryTheory.GlueData TopCat) β
(f_open :
β (i j : toGlueData.J),
Topology.IsOpenEmbedding β(CategoryTheory.ConcreteCategory.hom (toGlueData.f i j))) β
motive { toGlueData := toGlueData, f_open := f_open }) β
motive t
|
NonUnitalSubringClass.toNonUnitalNonAssocRing._proof_2
|
Mathlib.RingTheory.NonUnitalSubring.Defs
|
β {R : Type u_2} {S : Type u_1} [inst : NonUnitalNonAssocRing R] [inst_1 : SetLike S R]
[hSR : NonUnitalSubringClass S R], ZeroMemClass S R
|
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.isMulFreimanIso_two._simp_1_1
|
Mathlib.Combinatorics.Additive.FreimanHom
|
β {Ξ± : Type u_1} {s : Multiset Ξ±}, (s.card = 2) = β x y, s = {x, y}
|
ModuleCat.instModuleCarrierMkOfSMul'._proof_3
|
Mathlib.Algebra.Category.ModuleCat.Basic
|
β {R : Type u_2} [inst : Ring R] {A : AddCommGrpCat} (Ο : R β+* CategoryTheory.End A) (x x_1 : R)
(x_2 : β(ModuleCat.mkOfSMul' Ο)), (x + x_1) β’ x_2 = x β’ x_2 + x_1 β’ x_2
|
GrpTypeEquivalenceGrp.functor
|
Mathlib.CategoryTheory.Monoidal.Internal.Types.Grp_
|
CategoryTheory.Functor (CategoryTheory.Grp (Type u)) GrpCat
|
Aesop.RuleTac.ofTacticSyntax
|
Aesop.RuleTac.Basic
|
(Aesop.RuleTacInput β Lean.MetaM Lean.Syntax.Tactic) β Aesop.RuleTac
|
ZMod.val.eq_2
|
Mathlib.Data.ZMod.Basic
|
β (n : β), ZMod.val = Fin.val
|
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessState.recOn
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums
|
{motive : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessStateβ β Sort u} β
(t : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessStateβΒΉ) β
((hyps : Array Lean.Meta.Hypothesis) β (seen : Std.HashSet Lean.Expr) β motive { hyps := hyps, seen := seen }) β
motive t
|
MeasureTheory.Integrable.aefinStronglyMeasurable
|
Mathlib.MeasureTheory.Function.StronglyMeasurable.Lp
|
β {Ξ± : Type u_1} {G : Type u_2} {m0 : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} [inst : NormedAddCommGroup G]
{f : Ξ± β G}, MeasureTheory.Integrable f ΞΌ β MeasureTheory.AEFinStronglyMeasurable f ΞΌ
|
Function.Injective.cancelCommMonoid._proof_3
|
Mathlib.Algebra.Group.InjSurj
|
β {Mβ : Type u_1} {Mβ : Type u_2} [inst : Mul Mβ] [inst_1 : One Mβ] [inst_2 : Pow Mβ β] [inst_3 : CancelCommMonoid Mβ]
(f : Mβ β Mβ) (hf : Function.Injective f) (one : f 1 = 1) (mul : β (x y : Mβ), f (x * y) = f x * f y)
(npow : β (x : Mβ) (n : β), f (x ^ n) = f x ^ n) (x : Mβ), Monoid.npow 0 x = 1
|
Subalgebra.map_topologicalClosure_le
|
Mathlib.Topology.Algebra.Algebra
|
β {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : IsTopologicalSemiring A] [inst_8 : IsTopologicalSemiring B] (f : A βA[R] B) (s : Subalgebra R A),
Subalgebra.map (βf) s.topologicalClosure β€ (Subalgebra.map f.toAlgHom s).topologicalClosure
|
Int.gcd_dvd_gcd_mul_right_right
|
Init.Data.Int.Gcd
|
β (a b c : β€), a.gcd b β£ a.gcd (b * c)
|
Plausible.Shrinkable.mk._flat_ctor
|
Plausible.Sampleable
|
{Ξ± : Type u} β (Ξ± β List Ξ±) β Plausible.Shrinkable Ξ±
|
MeasureTheory.JordanDecomposition.instSMul
|
Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan
|
{Ξ± : Type u_1} β [inst : MeasurableSpace Ξ±] β SMul NNReal (MeasureTheory.JordanDecomposition Ξ±)
|
Finset.sum_Ioc_by_parts
|
Mathlib.Algebra.BigOperators.Module
|
β {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : β β R) (g : β β M)
{m n : β},
m < n β
β i β Finset.Ioc m n, f i β’ g i =
f n β’ β i β Finset.range (n + 1), g i - f (m + 1) β’ β i β Finset.range (m + 1), g i -
β i β Finset.Ioc m (n - 1), (f (i + 1) - f i) β’ β i β Finset.range (i + 1), g i
|
SetTheory.PGame.nimZeroRelabelling
|
Mathlib.SetTheory.Game.Nim
|
(SetTheory.PGame.nim 0).Relabelling 0
|
CompleteLinearOrder.toCompletelyDistribLattice
|
Mathlib.Order.CompleteBooleanAlgebra
|
{Ξ± : Type u} β [CompleteLinearOrder Ξ±] β CompletelyDistribLattice Ξ±
|
_private.Init.Data.Array.Lemmas.0.Array.all_eq_true_iff_forall_mem._simp_1_3
|
Init.Data.Array.Lemmas
|
β {Ξ± : Type u} {a : Ξ±} {as : Array Ξ±}, (a β as) = (a β as.toList)
|
Lean.Meta.Tactic.TryThis.addSuggestion
|
Lean.Meta.Tactic.TryThis
|
Lean.Syntax β
Lean.Meta.Tactic.TryThis.Suggestion β
optParam (Option Lean.Syntax) none β
optParam String "Try this:" β
optParam (Option String) none β
optParam Lean.Meta.Hint.DiffGranularity Lean.Meta.Hint.DiffGranularity.none β Lean.CoreM Unit
|
Std.Rcc.eq_succMany?_of_toList_eq_append_cons
|
Init.Data.Range.Polymorphic.Lemmas
|
β {Ξ± : Type u} {r : Std.Rcc Ξ±} [inst : LE Ξ±] [inst_1 : DecidableLE Ξ±] [inst_2 : Std.PRange.UpwardEnumerable Ξ±]
[inst_3 : Std.PRange.LawfulUpwardEnumerable Ξ±] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE Ξ±]
[inst_5 : Std.Rxc.IsAlwaysFinite Ξ±] {pref suff : List Ξ±} {cur : Ξ±} (h : r.toList = pref ++ cur :: suff),
cur = (Std.PRange.succMany? pref.length r.lower).get β―
|
CategoryTheory.Comon.Mon_OpOpToComonObj
|
Mathlib.CategoryTheory.Monoidal.Comon_
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
[inst_1 : CategoryTheory.MonoidalCategory C] β CategoryTheory.Mon Cα΅α΅ β CategoryTheory.Comon C
|
List.modify.eq_1
|
Init.Data.List.Impl
|
β {Ξ± : Type u} (l : List Ξ±) (i : β) (f : Ξ± β Ξ±), l.modify i f = l.modifyTailIdx i (List.modifyHead f)
|
HeytAlg.mk.noConfusion
|
Mathlib.Order.Category.HeytAlg
|
{P : Sort u} β
{carrier : Type u_1} β
{str : HeytingAlgebra carrier} β
{carrier' : Type u_1} β
{str' : HeytingAlgebra carrier'} β
{ carrier := carrier, str := str } = { carrier := carrier', str := str' } β
(carrier = carrier' β str β str' β P) β P
|
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.one_lt_rpow._simp_1_1
|
Mathlib.Analysis.SpecialFunctions.Pow.NNReal
|
β {p : NNReal}, (1 < βp) = (1 < p)
|
Equiv.Perm.IsThreeCycle.inv_iff
|
Mathlib.GroupTheory.Perm.Cycle.Type
|
β {Ξ± : Type u_1} [inst : Fintype Ξ±] [inst_1 : DecidableEq Ξ±] {f : Equiv.Perm Ξ±}, fβ»ΒΉ.IsThreeCycle β f.IsThreeCycle
|
le_iff_exists_sup
|
Mathlib.Order.Lattice
|
β {Ξ± : Type u} [inst : SemilatticeSup Ξ±] {a b : Ξ±}, a β€ b β β c, b = a β c
|
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.ValidFor.valid.match_1_1
|
Batteries.Data.String.Lemmas
|
β {l r : List Char} (motive : (x : String.Legacy.Iterator) β String.Legacy.Iterator.ValidFor l r x β Prop)
(x : String.Legacy.Iterator) (x_1 : String.Legacy.Iterator.ValidFor l r x),
(β (a : Unit), motive { s := String.ofList (l.reverseAux r), i := { byteIdx := String.utf8Len l } } β―) β motive x x_1
|
Lean.Elab.Command.PreElabHeaderResult.mk.injEq
|
Lean.Elab.MutualInductive
|
β (view : Lean.Elab.Command.InductiveView) (levelNames : List Lean.Name) (numParams : β) (type : Lean.Expr)
(origParams : Array Lean.Expr) (view_1 : Lean.Elab.Command.InductiveView) (levelNames_1 : List Lean.Name)
(numParams_1 : β) (type_1 : Lean.Expr) (origParams_1 : Array Lean.Expr),
({ view := view, levelNames := levelNames, numParams := numParams, type := type, origParams := origParams } =
{ view := view_1, levelNames := levelNames_1, numParams := numParams_1, type := type_1,
origParams := origParams_1 }) =
(view = view_1 β§ levelNames = levelNames_1 β§ numParams = numParams_1 β§ type = type_1 β§ origParams = origParams_1)
|
WeakFEPair._sizeOf_inst
|
Mathlib.NumberTheory.LSeries.AbstractFuncEq
|
(E : Type u_1) β {inst : NormedAddCommGroup E} β {inst_1 : NormedSpace β E} β [SizeOf E] β SizeOf (WeakFEPair E)
|
_private.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.0.Asymptotics.IsEquivalent.smul._simp_1_9
|
Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
|
β {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : β), (βn + 1 = 0) = False
|
Filter.lift_neBot_iff
|
Mathlib.Order.Filter.Lift
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Filter Ξ±} {g : Set Ξ± β Filter Ξ²},
Monotone g β ((f.lift g).NeBot β β s β f, (g s).NeBot)
|
MonadFinally.casesOn
|
Init.Control.Except
|
{m : Type u β Type v} β
{motive : MonadFinally m β Sort u_1} β
(t : MonadFinally m) β
((tryFinally' : {Ξ± Ξ² : Type u} β m Ξ± β (Option Ξ± β m Ξ²) β m (Ξ± Γ Ξ²)) β motive { tryFinally' := tryFinally' }) β
motive t
|
Std.ExtDHashMap.insert.congr_simp
|
Std.Data.ExtDHashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} [inst : EquivBEq Ξ±] [inst_1 : LawfulHashable Ξ±]
(m m_1 : Std.ExtDHashMap Ξ± Ξ²), m = m_1 β β (a : Ξ±) (b b_1 : Ξ² a), b = b_1 β m.insert a b = m_1.insert a b_1
|
Batteries.RBNode.any
|
Batteries.Data.RBMap.Basic
|
{Ξ± : Type u_1} β (Ξ± β Bool) β Batteries.RBNode Ξ± β Bool
|
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.mem_jacobson_iff.match_1_5
|
Mathlib.RingTheory.Jacobson.Ideal
|
β {R : Type u_1} [inst : Ring R] {I : Ideal R} {x : R} (y : R)
(motive : (β M, M.IsMaximal β§ I β Ideal.span {y * x + 1} β€ M) β Prop)
(x_1 : β M, M.IsMaximal β§ I β Ideal.span {y * x + 1} β€ M),
(β (M : Ideal R) (hm1 : M.IsMaximal) (hm2 : I β Ideal.span {y * x + 1} β€ M), motive β―) β motive x_1
|
Ideal.comap_idβ
|
Mathlib.RingTheory.Ideal.Maps
|
β {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (I : Ideal S),
Ideal.comap (AlgHom.id R S) I = I
|
MeasureTheory.AEEqFun.coeFn_sup
|
Mathlib.MeasureTheory.Function.AEEqFun
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : MeasurableSpace Ξ±] {ΞΌ : MeasureTheory.Measure Ξ±} [inst_1 : TopologicalSpace Ξ²]
[inst_2 : SemilatticeSup Ξ²] [inst_3 : ContinuousSup Ξ²] (f g : Ξ± ββ[ΞΌ] Ξ²), β(f β g) =α΅[ΞΌ] fun x => βf x β βg x
|
USize.toNat_ofNatTruncate_of_le
|
Init.Data.UInt.Lemmas
|
β {n : β}, USize.size β€ n β (USize.ofNatTruncate n).toNat = USize.size - 1
|
ZNum.cmp.match_1
|
Mathlib.Data.Num.Basic
|
(motive : ZNum β ZNum β Sort u_1) β
(x x_1 : ZNum) β
(Unit β motive ZNum.zero ZNum.zero) β
((a b : PosNum) β motive (ZNum.pos a) (ZNum.pos b)) β
((a b : PosNum) β motive (ZNum.neg a) (ZNum.neg b)) β
((a : PosNum) β (x : ZNum) β motive (ZNum.pos a) x) β
((a : PosNum) β (x : ZNum) β motive (ZNum.neg a) x) β
((x : ZNum) β (a : PosNum) β motive x (ZNum.pos a)) β
((x : ZNum) β (a : PosNum) β motive x (ZNum.neg a)) β motive x x_1
|
Lean.Expr.mvar
|
Lean.Expr
|
Lean.MVarId β Lean.Expr
|
Multiset.rec._proof_1
|
Mathlib.Data.Multiset.ZeroCons
|
β {Ξ± : Type u_2} {C : Multiset Ξ± β Sort u_1} (C_cons : (a : Ξ±) β (m : Multiset Ξ±) β C m β C (a ::β m)) {a : Ξ±}
{l l' : List Ξ±} {b : C β¦lβ§} {b' : C β¦l'β§}, l.Perm l' β b β b' β C_cons a β¦lβ§ b β C_cons a β¦l'β§ b'
|
Lean.Meta.SimpTheorems
|
Lean.Meta.Tactic.Simp.SimpTheorems
|
Type
|
DFA.casesOn
|
Mathlib.Computability.DFA
|
{Ξ± : Type u} β
{Ο : Type v} β
{motive : DFA Ξ± Ο β Sort u_1} β
(t : DFA Ξ± Ο) β
((step : Ο β Ξ± β Ο) β
(start : Ο) β (accept : Set Ο) β motive { step := step, start := start, accept := accept }) β
motive t
|
FreeAbelianGroup.lift_add_apply
|
Mathlib.GroupTheory.FreeAbelianGroup
|
β {Ξ± : Type u} {G : Type u_1} [inst : AddCommGroup G] (f g : Ξ± β G) (a : FreeAbelianGroup Ξ±),
(FreeAbelianGroup.lift (f + g)) a = (FreeAbelianGroup.lift f) a + (FreeAbelianGroup.lift g) a
|
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.isIgnoredArg.match_1
|
Mathlib.Lean.Meta.RefinedDiscrTree.Encode
|
(motive : Lean.BinderInfo β Sort u_1) β
(binderInfo : Lean.BinderInfo) β
(Unit β motive Lean.BinderInfo.instImplicit) β
(Unit β motive Lean.BinderInfo.implicit) β
(Unit β motive Lean.BinderInfo.strictImplicit) β (Unit β motive Lean.BinderInfo.default) β motive binderInfo
|
Submodule.module'._proof_1
|
Mathlib.Algebra.Module.Submodule.Defs
|
β {S : Type u_3} {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p : Submodule R M) [inst_2 : Semiring S] [inst_3 : SMul S R] [inst_4 : Module S M] [inst_5 : IsScalarTower S R M]
(x : β₯p.toSubMulAction), 1 β’ x = x
|
_private.Lean.DocString.Markdown.0.Lean.Doc.trimLeft.go.match_1
|
Lean.DocString.Markdown
|
{i : Type u_1} β
(motive : String Γ Lean.Doc.Inline i β Sort u_2) β
(x : String Γ Lean.Doc.Inline i) β ((pre : String) β (post : Lean.Doc.Inline i) β motive (pre, post)) β motive x
|
Matrix.toBilin_comp
|
Mathlib.LinearAlgebra.Matrix.BilinearForm
|
β {Rβ : Type u_1} {Mβ : Type u_2} [inst : CommSemiring Rβ] [inst_1 : AddCommMonoid Mβ] [inst_2 : Module Rβ Mβ]
{n : Type u_5} {o : Type u_6} [inst_3 : Fintype n] [inst_4 : Fintype o] [inst_5 : DecidableEq n]
(b : Module.Basis n Rβ Mβ) {Mβ' : Type u_7} [inst_6 : AddCommMonoid Mβ'] [inst_7 : Module Rβ Mβ']
(c : Module.Basis o Rβ Mβ') [inst_8 : DecidableEq o] (M : Matrix n n Rβ) (P Q : Matrix n o Rβ),
((Matrix.toBilin b) M).comp ((Matrix.toLin c b) P) ((Matrix.toLin c b) Q) = (Matrix.toBilin c) (P.transpose * M * Q)
|
CategoryTheory.Functor.obj.instComonObj._proof_3
|
Mathlib.CategoryTheory.Monoidal.Comon_
|
β {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D] (A : C)
[inst_4 : CategoryTheory.ComonObj A] (F : CategoryTheory.Functor C D) [inst_5 : F.OplaxMonoidal],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.ComonObj.comul)
(CategoryTheory.Functor.OplaxMonoidal.Ξ΄ F A A))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj A)
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.ComonObj.comul)
(CategoryTheory.Functor.OplaxMonoidal.Ξ΄ F A A))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.ComonObj.comul)
(CategoryTheory.Functor.OplaxMonoidal.Ξ΄ F A A))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.ComonObj.comul)
(CategoryTheory.Functor.OplaxMonoidal.Ξ΄ F A A))
(F.obj A))
(CategoryTheory.MonoidalCategoryStruct.associator (F.obj A) (F.obj A) (F.obj A)).hom)
|
Fintype.expect_equiv
|
Mathlib.Algebra.BigOperators.Expect
|
β {ΞΉ : Type u_1} {ΞΊ : Type u_2} {M : Type u_3} [inst : Fintype ΞΉ] [inst_1 : Fintype ΞΊ] [inst_2 : AddCommMonoid M]
[inst_3 : Module ββ₯0 M] (e : ΞΉ β ΞΊ) (f : ΞΉ β M) (g : ΞΊ β M),
(β (i : ΞΉ), f i = g (e i)) β (Finset.univ.expect fun i => f i) = Finset.univ.expect fun i => g i
|
Turing.PartrecToTM2.Cont'.halt.elim
|
Mathlib.Computability.TMToPartrec
|
{motive : Turing.PartrecToTM2.Cont' β Sort u} β
(t : Turing.PartrecToTM2.Cont') β t.ctorIdx = 0 β motive Turing.PartrecToTM2.Cont'.halt β motive t
|
Except.emoji
|
Batteries.Lean.Except
|
{Ξ΅ : Type u_1} β {Ξ± : Type u_2} β Except Ξ΅ Ξ± β String
|
Subring.coe_prod
|
Mathlib.Algebra.Ring.Subring.Basic
|
β {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] (s : Subring R) (t : Subring S), β(s.prod t) = βs ΓΛ’ βt
|
ZMod.val.eq_1
|
Mathlib.Data.ZMod.Basic
|
ZMod.val = Int.natAbs
|
_private.Mathlib.Util.SleepHeartbeats.0._aux_Mathlib_Util_SleepHeartbeats___elabRules_tacticSleep_heartbeats__1.match_1
|
Mathlib.Util.SleepHeartbeats
|
(motive : Option β β Sort u_1) β (x : Option β) β (Unit β motive none) β ((m : β) β motive (some m)) β motive x
|
StarAlgebra.elemental.instCompleteSpaceSubtypeMemStarSubalgebra
|
Mathlib.Topology.Algebra.StarSubalgebra
|
β (R : Type u_1) [inst : CommSemiring R] [inst_1 : StarRing R] {A : Type u_4} [inst_2 : UniformSpace A]
[CompleteSpace A] [inst_4 : Semiring A] [inst_5 : StarRing A] [inst_6 : IsTopologicalSemiring A]
[inst_7 : ContinuousStar A] [inst_8 : Algebra R A] [inst_9 : StarModule R A] (x : A),
CompleteSpace β₯(StarAlgebra.elemental R x)
|
QuasiErgodic.smul_measure
|
Mathlib.Dynamics.Ergodic.Ergodic
|
β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {f : Ξ± β Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} {R : Type u_2}
[inst : SMul R ENNReal] [inst_1 : IsScalarTower R ENNReal ENNReal],
QuasiErgodic f ΞΌ β β (c : R), QuasiErgodic f (c β’ ΞΌ)
|
SkewMonoidAlgebra.coeff_one_one
|
Mathlib.Algebra.SkewMonoidAlgebra.Basic
|
β {k : Type u_1} {G : Type u_2} [inst : One G] [inst_1 : AddMonoidWithOne k], SkewMonoidAlgebra.coeff 1 1 = 1
|
Std.ExtDTreeMap.Const.contains_alter
|
Std.Data.ExtDTreeMap.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {Ξ² : Type v} {t : Std.ExtDTreeMap Ξ± (fun x => Ξ²) cmp} [inst : Std.TransCmp cmp]
{k k' : Ξ±} {f : Option Ξ² β Option Ξ²},
(Std.ExtDTreeMap.Const.alter t k f).contains k' =
if cmp k k' = Ordering.eq then (f (Std.ExtDTreeMap.Const.get? t k)).isSome else t.contains k'
|
ContinuousLinearEquiv.map_nhds_eq
|
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_4} [inst_4 : TopologicalSpace Mβ]
[inst_5 : AddCommMonoid Mβ] {Mβ : Type u_5} [inst_6 : TopologicalSpace Mβ] [inst_7 : AddCommMonoid Mβ]
[inst_8 : Module Rβ Mβ] [inst_9 : Module Rβ Mβ] (e : Mβ βSL[Οββ] Mβ) (x : Mβ), Filter.map (βe) (nhds x) = nhds (e x)
|
Matrix.PosDef.posDef_sqrt
|
Mathlib.Analysis.Matrix.Order
|
β {π : Type u_1} {n : Type u_2} [inst : RCLike π] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Matrix n n π},
M.PosDef β (CFC.sqrt M).PosDef
|
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.casesMatch.mkMotiveAndRefls
|
Lean.Meta.Tactic.Grind.CasesMatch
|
Lean.MVarId β Lean.Expr β Lean.Meta.MatcherApp β Lean.MetaM (Lean.Expr Γ Array Lean.Expr)
|
Set.monotone_mem._simp_1
|
Mathlib.Order.UpperLower.Basic
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {s : Set Ξ±}, (Monotone fun x => x β s) = IsUpperSet s
|
Nat.or_mod_two_pow
|
Init.Data.Nat.Bitwise.Lemmas
|
β {a b n : β}, (a ||| b) % 2 ^ n = a % 2 ^ n ||| b % 2 ^ n
|
Nat.log_eq_iff
|
Mathlib.Data.Nat.Log
|
β {b m n : β}, m β 0 β¨ 1 < b β§ n β 0 β (Nat.log b n = m β b ^ m β€ n β§ n < b ^ (m + 1))
|
_private.Mathlib.Algebra.Lie.Sl2.0.IsSl2Triple.HasPrimitiveVectorWith.pow_toEnd_f_ne_zero_of_eq_nat._simp_1_1
|
Mathlib.Algebra.Lie.Sl2
|
β {Ξ± : Type u} [inst : AddCommMonoid Ξ±] [Subsingleton (AddUnits Ξ±)] {a b : Ξ±}, (a + b = 0) = (a = 0 β§ b = 0)
|
SeparationQuotient.instCommGroup._proof_9
|
Mathlib.Topology.Algebra.SeparationQuotient.Basic
|
β {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : IsTopologicalGroup G] (x : G) (n : β€),
SeparationQuotient.mk (x ^ n) = SeparationQuotient.mk x ^ n
|
Ordinal.zero_CNF
|
Mathlib.SetTheory.Ordinal.CantorNormalForm
|
β {o : Ordinal.{u_1}}, o β 0 β Ordinal.CNF 0 o = [(0, o)]
|
isNilpotent_iff_zero_mem_powers
|
Mathlib.RingTheory.Nilpotent.Lemmas
|
β {R : Type u_1} [inst : Monoid R] [inst_1 : Zero R] {x : R}, IsNilpotent x β 0 β Submonoid.powers x
|
Lean.Grind.OrderedRing.mul_pos
|
Init.Grind.Ordered.Ring
|
β {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPreorder R]
[Lean.Grind.OrderedRing R] {a b : R}, 0 < a β 0 < b β 0 < a * b
|
false_of_ne
|
Init.Core
|
β {Ξ± : Sort u} {a : Ξ±}, a β a β False
|
OpenNormalAddSubgroup.instLatticeOfContinuousAdd._proof_3
|
Mathlib.Topology.Algebra.OpenSubgroup
|
β {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : ContinuousAdd G]
(a b c : OpenNormalAddSubgroup G), a β€ c β b β€ c β SemilatticeSup.sup a b β€ c
|
TopCat.GlueData._sizeOf_1
|
Mathlib.Topology.Gluing
|
TopCat.GlueData β β
|
_private.Mathlib.CategoryTheory.Monoidal.Preadditive.0.CategoryTheory.rightDistributor_assoc._simp_1_2
|
Mathlib.CategoryTheory.Monoidal.Preadditive
|
β {C : Type u} [π : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {W X Y Z : C}
(f : W βΆ X) (g : X βΆ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom f (CategoryTheory.CategoryStruct.id Z))
(CategoryTheory.MonoidalCategoryStruct.tensorHom g (CategoryTheory.CategoryStruct.id Z)) =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.comp f g)
(CategoryTheory.CategoryStruct.id Z)
|
CategoryTheory.Limits.ReflectsFilteredColimits
|
Mathlib.CategoryTheory.Limits.Preserves.Filtered
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
{D : Type uβ} β [inst_1 : CategoryTheory.Category.{vβ, uβ} D] β CategoryTheory.Functor C D β Prop
|
hasFDerivAt_iff_tendsto
|
Mathlib.Analysis.Calculus.FDeriv.Basic
|
β {π : 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}
{f' : E βL[π] F} {x : E},
HasFDerivAt f f' x β Filter.Tendsto (fun x' => βx' - xββ»ΒΉ * βf x' - f x - f' (x' - x)β) (nhds x) (nhds 0)
|
Aesop.Strategy.noConfusion
|
Aesop.Options.Public
|
{P : Sort vβ} β {x y : Aesop.Strategy} β x = y β Aesop.Strategy.noConfusionType P x y
|
SymmetricPower.mk._proof_2
|
Mathlib.LinearAlgebra.TensorPower.Symmetric
|
β (R ΞΉ : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : R)
(x_1 : PiTensorProduct R fun x => M),
(β(addConGen (SymmetricPower.Rel R ΞΉ M)).mk').toFun (x β’ x_1) =
(β(addConGen (SymmetricPower.Rel R ΞΉ M)).mk').toFun (x β’ x_1)
|
Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.GrindCnstr.isValue.formatter_7
|
Lean.Meta.Tactic.Grind.Parser
|
IO Unit
|
_private.Init.Data.BitVec.Bitblast.0.BitVec.resRec_of_clz_le._proof_1_1
|
Init.Data.BitVec.Bitblast
|
β {w : β} {x : BitVec w} {y : BitVec w}, 1 < w β Β¬w - 1 - y.clz.toNat β€ w - 1 β False
|
CategoryTheory.GradedObject.total
|
Mathlib.CategoryTheory.GradedObject
|
(Ξ² : Type) β
(C : Type u) β
[inst : CategoryTheory.Category.{v, u} C] β
[CategoryTheory.Limits.HasCoproducts C] β CategoryTheory.Functor (CategoryTheory.GradedObject Ξ² C) C
|
CategoryTheory.Limits.colimit.pre
|
Mathlib.CategoryTheory.Limits.HasLimits
|
{J : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} J] β
{K : Type uβ} β
[inst_1 : CategoryTheory.Category.{vβ, uβ} K] β
{C : Type u} β
[inst_2 : CategoryTheory.Category.{v, u} C] β
(F : CategoryTheory.Functor J C) β
[inst_3 : CategoryTheory.Limits.HasColimit F] β
(E : CategoryTheory.Functor K J) β
[inst_4 : CategoryTheory.Limits.HasColimit (E.comp F)] β
CategoryTheory.Limits.colimit (E.comp F) βΆ CategoryTheory.Limits.colimit F
|
Std.Time.OffsetX.hourMinute.elim
|
Std.Time.Format.Basic
|
{motive : Std.Time.OffsetX β Sort u} β
(t : Std.Time.OffsetX) β t.ctorIdx = 1 β motive Std.Time.OffsetX.hourMinute β motive t
|
Rat.toNNRat_le_toNNRat_iff._simp_1
|
Mathlib.Data.NNRat.Defs
|
β {p q : β}, 0 β€ p β (q.toNNRat β€ p.toNNRat) = (q β€ p)
|
SetTheory.PGame.Impartial.equiv_zero_iff_le
|
Mathlib.SetTheory.Game.Impartial
|
β (G : SetTheory.PGame) [G.Impartial], G β 0 β G β€ 0
|
HomotopicalAlgebra.PathObject.instIsCofibrantPOfIsVeryGood
|
Mathlib.AlgebraicTopology.ModelCategory.PathObject
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.PathObject A)
[inst_2 : HomotopicalAlgebra.CategoryWithFibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithCofibrations C]
[(HomotopicalAlgebra.cofibrations C).IsStableUnderComposition] [inst_5 : CategoryTheory.Limits.HasBinaryProduct A A]
[inst_6 : CategoryTheory.Limits.HasInitial C] [HomotopicalAlgebra.IsCofibrant A] [P.IsVeryGood],
HomotopicalAlgebra.IsCofibrant P.P
|
MLList.thunk
|
Batteries.Data.MLList.Basic
|
{m : Type u_1 β Type u_1} β {Ξ± : Type u_1} β (Unit β MLList m Ξ±) β MLList m Ξ±
|
Std.ExtDTreeMap.Const.get?_insertMany_list.match_1
|
Std.Data.ExtDTreeMap.Lemmas
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β (motive : Ξ± Γ Ξ² β Sort u_3) β (x : Ξ± Γ Ξ²) β ((a : Ξ±) β (b : Ξ²) β motive (a, b)) β motive x
|
Int32.toNatClampNeg_ofNat_of_lt
|
Init.Data.SInt.Lemmas
|
β {n : β}, n < 2 ^ 31 β (Int32.ofNat n).toNatClampNeg = n
|
Std.DTreeMap.Internal.Impl.insertMany._proof_1
|
Std.Data.DTreeMap.Internal.Operations
|
β {Ξ± : Type u_1} {Ξ² : Ξ± β Type u_2} [inst : Ord Ξ±] (t : Std.DTreeMap.Internal.Impl Ξ± Ξ²),
t.Balanced β β (r : t.IteratedInsertionInto), (βr).Balanced
|
IsGalois.of_card_aut_eq_finrank
|
Mathlib.FieldTheory.Galois.Basic
|
β (F : Type u_1) [inst : Field F] (E : Type u_2) [inst_1 : Field E] [inst_2 : Algebra F E] [FiniteDimensional F E],
Nat.card Gal(E/F) = Module.finrank F E β IsGalois F E
|
Ideal.rootsOfUnityMapQuot._proof_2
|
Mathlib.NumberTheory.NumberField.Ideal.Basic
|
β {K : Type u_1} [inst : Field K] (I : Ideal (NumberField.RingOfIntegers K)), I.IsTwoSided
|
Finset.empty_covBy_singleton._simp_1
|
Mathlib.Data.Finset.Grade
|
β {Ξ± : Type u_1} (a : Ξ±), (β
β {a}) = True
|
Polynomial.aroots_C_mul
|
Mathlib.Algebra.Polynomial.Roots
|
β {S : Type v} {T : Type w} [inst : CommRing T] [inst_1 : CommRing S] [inst_2 : IsDomain S] [inst_3 : Algebra T S]
[NoZeroSMulDivisors T S] {a : T} (p : Polynomial T), a β 0 β (Polynomial.C a * p).aroots S = p.aroots S
|
Mathlib.Tactic.Ring.evalPowNat._unsafe_rec
|
Mathlib.Tactic.Ring.Basic
|
{u : Lean.Level} β
{Ξ± : Q(Type u)} β
(sΞ± : Q(CommSemiring Β«$Ξ±Β»)) β
{a : Q(Β«$Ξ±Β»)} β
Mathlib.Tactic.Ring.ExSum sΞ± a β
(n : Q(β)) β Lean.MetaM (Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExSum sΞ±) q(Β«$aΒ» ^ Β«$nΒ»))
|
_private.Init.Data.Array.OfFn.0.Array.ofFn.go.eq_2
|
Init.Data.Array.OfFn
|
β {Ξ± : Type u} {n : β} (f : Fin n β Ξ±) (acc : Array Ξ±) (x_2 : 0 β€ n), Array.ofFn.goβ f acc 0 x_2 = acc
|
BotHom.dual_id
|
Mathlib.Order.Hom.Bounded
|
β {Ξ± : Type u_2} [inst : LE Ξ±] [inst_1 : OrderBot Ξ±], BotHom.dual (BotHom.id Ξ±) = TopHom.id Ξ±α΅α΅
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.