name
string | module
string | type
string |
|---|---|---|
ContinuousMultilinearMap.norm_iteratedFDerivComponent_le
|
Mathlib.Analysis.Normed.Module.Multilinear.Basic
|
β {π : Type u} {ΞΉ : Type v} {Eβ : ΞΉ β Type wEβ} {G : Type wG} [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 ΞΉ] {Ξ± : Type u_1}
[inst_6 : Fintype Ξ±] (f : ContinuousMultilinearMap π Eβ G) {s : Set ΞΉ} (e : Ξ± β βs)
[inst_7 : DecidablePred fun x => x β s] (x : (i : ΞΉ) β Eβ i),
β(f.iteratedFDerivComponent e) fun x_1 => x βx_1β β€ βfβ * βxβ ^ (Fintype.card ΞΉ - Fintype.card Ξ±)
|
small_iff
|
Mathlib.Logic.Small.Defs
|
β (Ξ± : Type v), Small.{w, v} Ξ± β β S, Nonempty (Ξ± β S)
|
_private.Mathlib.Algebra.Order.Star.Basic.0.MulOpposite.instStarOrderedRing._simp_1
|
Mathlib.Algebra.Order.Star.Basic
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {ΞΉ : Sort u_4} (g : Ξ± β Ξ²) (f : ΞΉ β Ξ±), g '' Set.range f = Set.range fun x => g (f x)
|
Mathlib.Tactic.Widget.homType?
|
Mathlib.Tactic.Widget.CommDiag
|
Lean.Expr β Option (Lean.Expr Γ Lean.Expr)
|
MulActionWithZero.toMulAction
|
Mathlib.Algebra.GroupWithZero.Action.Defs
|
{Mβ : Type u_2} β
{A : Type u_7} β {inst : MonoidWithZero Mβ} β {inst_1 : Zero A} β [self : MulActionWithZero Mβ A] β MulAction Mβ A
|
Vector.set._proof_1
|
Init.Data.Vector.Basic
|
β {Ξ± : Type u_1} {n : β} (xs : Vector Ξ± n), β i < n, i < xs.toArray.size
|
Mathlib.Tactic.CC.EntryExpr.noConfusionType
|
Mathlib.Tactic.CC.Datatypes
|
Sort u β Mathlib.Tactic.CC.EntryExpr β Mathlib.Tactic.CC.EntryExpr β Sort u
|
subset_refl
|
Mathlib.Order.RelClasses
|
β {Ξ± : Type u} [inst : HasSubset Ξ±] [IsRefl Ξ± fun x1 x2 => x1 β x2] (a : Ξ±), a β a
|
Lean.Meta.Grind.AC.instInhabitedEqCnstr
|
Lean.Meta.Tactic.Grind.AC.Types
|
Inhabited Lean.Meta.Grind.AC.EqCnstr
|
MeromorphicOn.mono_set
|
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 β β {V : Set π}, V β U β MeromorphicOn f V
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst._proof_4
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const
|
β {w : β}, β curr β€ w, Β¬curr < w β curr = w
|
Lean.Meta.Config.assignSyntheticOpaque
|
Lean.Meta.Basic
|
Lean.Meta.Config β Bool
|
IO.Error.permissionDenied.inj
|
Init.System.IOError
|
β {filename : Option String} {osCode : UInt32} {details : String} {filename_1 : Option String} {osCode_1 : UInt32}
{details_1 : String},
IO.Error.permissionDenied filename osCode details = IO.Error.permissionDenied filename_1 osCode_1 details_1 β
filename = filename_1 β§ osCode = osCode_1 β§ details = details_1
|
Fin.natAdd_natAdd
|
Init.Data.Fin.Lemmas
|
β (m n : β) {p : β} (i : Fin p), Fin.natAdd m (Fin.natAdd n i) = Fin.cast β― (Fin.natAdd (m + n) i)
|
AnalyticWithinAt.exists_hasFTaylorSeriesUpToOn
|
Mathlib.Analysis.Calculus.FDeriv.Analytic
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {f : E β F} {x : E}
{s : Set E} [CompleteSpace F] (n : WithTop ββ),
AnalyticWithinAt π f s x β
β u β nhdsWithin x (insert x s), β p, HasFTaylorSeriesUpToOn n f p u β§ β (i : β), AnalyticOn π (fun x => p x i) u
|
MeasureTheory.AEEqFun.coeFn_posPart
|
Mathlib.MeasureTheory.Function.AEEqFun
|
β {Ξ± : Type u_1} {Ξ³ : Type u_3} [inst : MeasurableSpace Ξ±] {ΞΌ : MeasureTheory.Measure Ξ±} [inst_1 : TopologicalSpace Ξ³]
[inst_2 : LinearOrder Ξ³] [inst_3 : OrderClosedTopology Ξ³] [inst_4 : Zero Ξ³] (f : Ξ± ββ[ΞΌ] Ξ³),
βf.posPart =α΅[ΞΌ] fun a => max (βf a) 0
|
CategoryTheory.Bicategory.leftUnitor
|
Mathlib.CategoryTheory.Bicategory.Basic
|
{B : Type u} β
[self : CategoryTheory.Bicategory B] β
{a b : B} β (f : a βΆ b) β CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f β
f
|
CategoryTheory.shiftFunctorAdd'.eq_1
|
Mathlib.CategoryTheory.Shift.Basic
|
β (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (i j k : A) (h : i + j = k),
CategoryTheory.shiftFunctorAdd' C i j k h = CategoryTheory.eqToIso β― βͺβ« CategoryTheory.shiftFunctorAdd C i j
|
DivisibleHull.mk_add_mk
|
Mathlib.GroupTheory.DivisibleHull
|
β {M : Type u_1} [inst : AddCommMonoid M] {m1 m2 : M} {s1 s2 : β+},
DivisibleHull.mk m1 s1 + DivisibleHull.mk m2 s2 = DivisibleHull.mk (βs2 β’ m1 + βs1 β’ m2) (s1 * s2)
|
MulActionHom.instCommSemiring
|
Mathlib.GroupTheory.GroupAction.Hom
|
{M : Type u_2} β
{N : Type u_3} β
{X : Type u_4} β
{Y : Type u_5} β
{Ο : M β N} β
[inst : SMul M X] β
[inst_1 : Monoid N] β
[inst_2 : CommSemiring Y] β [inst_3 : MulSemiringAction N Y] β CommSemiring (X ββ[Ο] Y)
|
LawfulBitraversable.mk
|
Mathlib.Control.Bitraversable.Basic
|
β {t : Type u β Type u β Type u} [inst : Bitraversable t] [toLawfulBifunctor : LawfulBifunctor t],
(β {Ξ± Ξ² : Type u} (x : t Ξ± Ξ²), bitraverse pure pure x = pure x) β
(β {F G : Type u β Type u} [inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F]
[LawfulApplicative G] {Ξ± Ξ±' Ξ² Ξ²' Ξ³ Ξ³' : Type u} (f : Ξ² β F Ξ³) (f' : Ξ²' β F Ξ³') (g : Ξ± β G Ξ²) (g' : Ξ±' β G Ξ²')
(x : t Ξ± Ξ±'),
bitraverse (Functor.Comp.mk β Functor.map f β g) (Functor.Comp.mk β Functor.map f' β g') x =
Functor.Comp.mk (bitraverse f f' <$> bitraverse g g' x)) β
(β {Ξ± Ξ±' Ξ² Ξ²' : Type u} (f : Ξ± β Ξ²) (f' : Ξ±' β Ξ²') (x : t Ξ± Ξ±'),
bitraverse (pure β f) (pure β f') x = pure (bimap f f' x)) β
(β {F G : Type u β Type u} [inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F]
[LawfulApplicative G] (Ξ· : ApplicativeTransformation F G) {Ξ± Ξ±' Ξ² Ξ²' : Type u} (f : Ξ± β F Ξ²)
(f' : Ξ±' β F Ξ²') (x : t Ξ± Ξ±'),
(fun {Ξ±} => Ξ·.app Ξ±) (bitraverse f f' x) =
bitraverse ((fun {Ξ±} => Ξ·.app Ξ±) β f) ((fun {Ξ±} => Ξ·.app Ξ±) β f') x) β
LawfulBitraversable t
|
unitary.linearIsometryEquiv_coe_symm_apply
|
Mathlib.Analysis.InnerProductSpace.Adjoint
|
β {π : Type u_1} [inst : RCLike π] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace π H]
[inst_3 : CompleteSpace H] (e : H ββα΅’[π] H),
β(Unitary.linearIsometryEquiv.symm e) =
β{ toLinearEquiv := e.toLinearEquiv, continuous_toFun := β―, continuous_invFun := β― }
|
CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso
|
Mathlib.CategoryTheory.Triangulated.Opposite.Triangle
|
(C : Type u_1) β
[inst : CategoryTheory.Category.{u_2, u_1} C] β
[inst_1 : CategoryTheory.HasShift C β€] β
CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)α΅α΅ β
(CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).comp
(CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse C)
|
_private.Mathlib.Algebra.Module.ZLattice.Summable.0.ZLattice.sum_piFinset_Icc_rpow_le._proof_1_11
|
Mathlib.Algebra.Module.ZLattice.Summable
|
β {ΞΉ : Type u_1} [Fintype ΞΉ] (k : β), Β¬2 * k + 3 β€ 3 * (k + 1) β False
|
NonUnitalRingHom.rangeRestrict_surjective
|
Mathlib.RingTheory.NonUnitalSubring.Basic
|
β {R : Type u} {S : Type v} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (f : R ββ+* S),
Function.Surjective βf.rangeRestrict
|
LowerSet.sdiff_lt_left._simp_1
|
Mathlib.Order.UpperLower.Closure
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {s : LowerSet Ξ±} {t : Set Ξ±}, (s.sdiff t < s) = Β¬Disjoint (βs) t
|
GrpCat.instCreatesLimitsOfSizeUliftFunctor._proof_1
|
Mathlib.Algebra.Category.Grp.Ulift
|
β {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {x : CategoryTheory.Functor J GrpCat},
CategoryTheory.Limits.HasLimit x
|
WType._sizeOf_1
|
Mathlib.Data.W.Basic
|
{Ξ± : Type u_1} β {Ξ² : Ξ± β Type u_2} β [SizeOf Ξ±] β [(a : Ξ±) β SizeOf (Ξ² a)] β WType Ξ² β β
|
CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetObj._proof_6
|
Mathlib.CategoryTheory.Limits.Constructions.Filtered
|
β {Ξ± : Type u_1} {X Y Z : (Finset (CategoryTheory.Discrete Ξ±))α΅α΅} (f : X βΆ Y) (g : Y βΆ Z) (y : β₯(Opposite.unop Z)),
βy β Opposite.unop X
|
Function.LeftInverse.rightInverse_of_surjective
|
Mathlib.Logic.Function.Basic
|
β {Ξ± : Sort u_1} {Ξ² : Sort u_2} {f : Ξ± β Ξ²} {g : Ξ² β Ξ±},
Function.LeftInverse f g β Function.Surjective g β Function.RightInverse f g
|
real_inner_I_smul_self
|
Mathlib.Analysis.InnerProductSpace.Basic
|
β (π : Type u_1) {E : Type u_2} [inst : RCLike π] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
(x : E), inner β x (RCLike.I β’ x) = 0
|
BooleanSubalgebra.map._proof_3
|
Mathlib.Order.BooleanSubalgebra
|
β {Ξ± : Type u_2} {Ξ² : Type u_1} [inst : BooleanAlgebra Ξ±] [inst_1 : BooleanAlgebra Ξ²] (f : BoundedLatticeHom Ξ± Ξ²)
(L : BooleanSubalgebra Ξ±) {a : Ξ²}, a β βf '' βL β aαΆ β βf '' βL
|
CategoryTheory.sectionsFunctorNatIsoCoyoneda
|
Mathlib.CategoryTheory.Yoneda
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
(X : Type (max uβ uβ)) β
[Unique X] β
CategoryTheory.Functor.sectionsFunctor C β
CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.Functor.const C).obj X))
|
WithOne
|
Mathlib.Algebra.Group.WithOne.Defs
|
Type u_1 β Type u_1
|
Representation.free
|
Mathlib.RepresentationTheory.Basic
|
(k : Type u_6) β
(G : Type u_7) β [inst : CommSemiring k] β [inst_1 : Monoid G] β (Ξ± : Type u_8) β Representation k G (Ξ± ββ G ββ k)
|
Lean.Parser.Tactic.Grind.mbtc
|
Init.Grind.Interactive
|
Lean.ParserDescr
|
Primrec.subtype_val_iff
|
Mathlib.Computability.Primrec
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Primcodable Ξ±] [inst_1 : Primcodable Ξ²] {p : Ξ² β Prop}
[inst_2 : DecidablePred p] {hp : PrimrecPred p} {f : Ξ± β Subtype p}, (Primrec fun a => β(f a)) β Primrec f
|
Lean.Grind.CommRing.Poly.mulMonC.go
|
Init.Grind.Ring.CommSolver
|
β€ β Lean.Grind.CommRing.Mon β β β Lean.Grind.CommRing.Poly β Lean.Grind.CommRing.Poly
|
_private.Init.Data.Nat.Power2.0.Nat.nextPowerOfTwo.go._unary.eq_def
|
Init.Data.Nat.Power2
|
β (n : β) (_x : (power : β) Γ' power > 0),
Nat.nextPowerOfTwo.go._unaryβ n _x =
PSigma.casesOn _x fun power h => if power < n then Nat.nextPowerOfTwo.go._unaryβΒΉ n β¨power * 2, β―β© else power
|
Equiv.simpleGraph._proof_1
|
Mathlib.Combinatorics.SimpleGraph.Maps
|
β {V : Type u_1} {W : Type u_2} (e : V β W) (x : SimpleGraph V), SimpleGraph.comap (βe.symm β βe) x = x
|
Std.DHashMap.Raw.Const.all_eq_false_iff_exists_mem_get
|
Std.Data.DHashMap.RawLemmas
|
β {Ξ± : Type u} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {Ξ² : Type v} {m : Std.DHashMap.Raw Ξ± fun x => Ξ²} [LawfulBEq Ξ±]
{p : Ξ± β Ξ² β Bool}, m.WF β (m.all p = false β β a, β (h : a β m), p a (Std.DHashMap.Raw.Const.get m a h) = false)
|
Lean.Elab.Tactic.ElimApp.Result.motive
|
Lean.Elab.Tactic.Induction
|
Lean.Elab.Tactic.ElimApp.Result β Lean.MVarId
|
ModularForm.coe_eq_zero_iff._simp_1
|
Mathlib.NumberTheory.ModularForms.Basic
|
β {Ξ : Subgroup (GL (Fin 2) β)} {k : β€} (f : ModularForm Ξ k), (βf = 0) = (f = 0)
|
Submodule.subtypeβα΅’_toContinuousLinearMap
|
Mathlib.Analysis.Normed.Operator.LinearIsometry
|
β {E : Type u_5} [inst : SeminormedAddCommGroup E] {R' : Type u_11} [inst_1 : Ring R'] [inst_2 : Module R' E]
(p : Submodule R' E), p.subtypeβα΅’.toContinuousLinearMap = p.subtypeL
|
Differential.logDeriv.eq_1
|
Mathlib.FieldTheory.Differential.Basic
|
β {R : Type u_1} [inst : Field R] [inst_1 : Differential R] (a : R), Differential.logDeriv a = aβ² / a
|
Array.toList_mapFinIdxM
|
Init.Data.Array.MapIdx
|
β {m : Type u_1 β Type u_2} {Ξ± : Type u_3} {Ξ² : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : Array Ξ±}
{f : (i : β) β Ξ± β i < xs.size β m Ξ²}, Array.toList <$> xs.mapFinIdxM f = xs.toList.mapFinIdxM f
|
IsCompact.exists_isGLB
|
Mathlib.Topology.Order.Compact
|
β {Ξ± : Type u_2} [inst : LinearOrder Ξ±] [inst_1 : TopologicalSpace Ξ±] [ClosedIicTopology Ξ±] {s : Set Ξ±},
IsCompact s β s.Nonempty β β x β s, IsGLB s x
|
_private.Init.Data.Nat.Basic.0.Nat.exists_eq_succ_of_ne_zero.match_1_1
|
Init.Data.Nat.Basic
|
β (motive : (x : β) β x β 0 β Prop) (x : β) (x_1 : x β 0), (β (n : β) (x : n + 1 β 0), motive n.succ x) β motive x x_1
|
CategoryTheory.ShortComplex.SnakeInput.Hom.comp
|
Mathlib.Algebra.Homology.ShortComplex.SnakeLemma
|
{C : Type u_1} β
[inst : CategoryTheory.Category.{u_2, u_1} C] β
[inst_1 : CategoryTheory.Abelian C] β
{Sβ Sβ Sβ : CategoryTheory.ShortComplex.SnakeInput C} β Sβ.Hom Sβ β Sβ.Hom Sβ β Sβ.Hom Sβ
|
CategoryTheory.ReflPrefunctor.Β«_aux_Mathlib_Combinatorics_Quiver_ReflQuiver___macroRules_CategoryTheory_ReflPrefunctor_term_β₯€rq__1Β»
|
Mathlib.Combinatorics.Quiver.ReflQuiver
|
Lean.Macro
|
Nat.Pseudoperfect.eq_1
|
Mathlib.NumberTheory.FactorisationProperties
|
β (n : β), n.Pseudoperfect = (0 < n β§ β s β n.properDivisors, β i β s, i = n)
|
SetTheory.PGame.leftResponse._proof_1
|
Mathlib.SetTheory.PGame.Order
|
β {x : SetTheory.PGame}, 0 β€ x β β (j : x.RightMoves), β i, 0 β€ (x.moveRight j).moveLeft i
|
Finset.smul_sum
|
Mathlib.Algebra.BigOperators.GroupWithZero.Action
|
β {M : Type u_1} {N : Type u_2} {Ξ³ : Type u_3} [inst : AddCommMonoid N] [inst_1 : DistribSMul M N] {r : M} {f : Ξ³ β N}
{s : Finset Ξ³}, r β’ β x β s, f x = β x β s, r β’ f x
|
OrderMonoidIso.val_inv_unitsWithZero_symm_apply
|
Mathlib.Algebra.Order.Hom.MonoidWithZero
|
β {Ξ± : Type u_6} [inst : Group Ξ±] [inst_1 : Preorder Ξ±] (a : Ξ±), β(OrderMonoidIso.unitsWithZero.symm a)β»ΒΉ = (βa)β»ΒΉ
|
ContMDiffOn.clm_bundle_applyβ
|
Mathlib.Geometry.Manifold.VectorBundle.Hom
|
β {π : Type u_1} {B : Type u_2} {Fβ : Type u_3} {Fβ : Type u_4} {Fβ : Type u_5} {M : Type u_6}
[inst : NontriviallyNormedField π] {n : WithTop ββ} {Eβ : B β Type u_7} [inst_1 : (x : B) β AddCommGroup (Eβ x)]
[inst_2 : (x : B) β Module π (Eβ x)] [inst_3 : NormedAddCommGroup Fβ] [inst_4 : NormedSpace π Fβ]
[inst_5 : TopologicalSpace (Bundle.TotalSpace Fβ Eβ)] [inst_6 : (x : B) β TopologicalSpace (Eβ x)] {Eβ : B β Type u_8}
[inst_7 : (x : B) β AddCommGroup (Eβ x)] [inst_8 : (x : B) β Module π (Eβ x)] [inst_9 : NormedAddCommGroup Fβ]
[inst_10 : NormedSpace π Fβ] [inst_11 : TopologicalSpace (Bundle.TotalSpace Fβ Eβ)]
[inst_12 : (x : B) β TopologicalSpace (Eβ x)] {Eβ : B β Type u_9} [inst_13 : (x : B) β AddCommGroup (Eβ x)]
[inst_14 : (x : B) β Module π (Eβ x)] [inst_15 : NormedAddCommGroup Fβ] [inst_16 : NormedSpace π Fβ]
[inst_17 : TopologicalSpace (Bundle.TotalSpace Fβ Eβ)] [inst_18 : (x : B) β TopologicalSpace (Eβ x)] {EB : Type u_10}
[inst_19 : NormedAddCommGroup EB] [inst_20 : NormedSpace π EB] {HB : Type u_11} [inst_21 : TopologicalSpace HB]
{IB : ModelWithCorners π EB HB} [inst_22 : TopologicalSpace B] [inst_23 : ChartedSpace HB B] {EM : Type u_12}
[inst_24 : NormedAddCommGroup EM] [inst_25 : NormedSpace π EM] {HM : Type u_13} [inst_26 : TopologicalSpace HM]
{IM : ModelWithCorners π EM HM} [inst_27 : TopologicalSpace M] [inst_28 : ChartedSpace HM M]
[inst_29 : FiberBundle Fβ Eβ] [inst_30 : VectorBundle π Fβ Eβ] [inst_31 : FiberBundle Fβ Eβ]
[inst_32 : VectorBundle π Fβ Eβ] [inst_33 : FiberBundle Fβ Eβ] [inst_34 : β―], β―
|
CategoryTheory.Limits.BinaryCofan.isColimitMk._proof_2
|
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y W : C} {inl : X βΆ W} {inr : Y βΆ W}
(desc : (s : CategoryTheory.Limits.BinaryCofan X Y) β W βΆ s.pt),
(β (s : CategoryTheory.Limits.BinaryCofan X Y) (m : W βΆ s.pt),
CategoryTheory.CategoryStruct.comp inl m = s.inl β
CategoryTheory.CategoryStruct.comp inr m = s.inr β m = desc s) β
β (s : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y))
(m : (CategoryTheory.Limits.BinaryCofan.mk inl inr).pt βΆ s.pt),
(β (j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.BinaryCofan.mk inl inr).ΞΉ.app j) m = s.ΞΉ.app j) β
m = desc s
|
Finsupp.lsingle_range_le_ker_lapply
|
Mathlib.LinearAlgebra.Finsupp.Span
|
β {Ξ± : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(s t : Set Ξ±), Disjoint s t β β¨ a β s, LinearMap.range (Finsupp.lsingle a) β€ β¨
a β t, LinearMap.ker (Finsupp.lapply a)
|
CategoryTheory.ShortComplex.homMk_Οβ
|
Mathlib.Algebra.Homology.ShortComplex.Basic
|
β {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{Sβ Sβ : CategoryTheory.ShortComplex C} (Οβ : Sβ.Xβ βΆ Sβ.Xβ) (Οβ : Sβ.Xβ βΆ Sβ.Xβ) (Οβ : Sβ.Xβ βΆ Sβ.Xβ)
(commββ : CategoryTheory.CategoryStruct.comp Οβ Sβ.f = CategoryTheory.CategoryStruct.comp Sβ.f Οβ)
(commββ : CategoryTheory.CategoryStruct.comp Οβ Sβ.g = CategoryTheory.CategoryStruct.comp Sβ.g Οβ),
(CategoryTheory.ShortComplex.homMk Οβ Οβ Οβ commββ commββ).Οβ = Οβ
|
Matroid.IsCircuit.eq_fundCircuit_of_subset
|
Mathlib.Combinatorics.Matroid.Circuit
|
β {Ξ± : Type u_1} {M : Matroid Ξ±} {C I : Set Ξ±} {e : Ξ±},
M.IsCircuit C β M.Indep I β C β insert e I β C = M.fundCircuit e I
|
LieDerivation.exp_map_apply
|
Mathlib.Algebra.Lie.Derivation.Basic
|
β {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieAlgebra β L] (D : LieDerivation R L L) (h : IsNilpotent βD) (l : L), (D.exp h) l = (IsNilpotent.exp βD) l
|
Lean.Elab.Structural.EqnInfo._sizeOf_1
|
Lean.Elab.PreDefinition.Structural.Eqns
|
Lean.Elab.Structural.EqnInfo β β
|
MonadReaderOf.read
|
Init.Prelude
|
{Ο : semiOutParam (Type u)} β {m : Type u β Type v} β [self : MonadReaderOf Ο m] β m Ο
|
Asymptotics.transIsEquivalentIsLittleO
|
Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β
{Ξ²β : Type u_3} β
[inst : NormedAddCommGroup Ξ²] β
[inst_1 : Norm Ξ²β] β
{l : Filter Ξ±} β Trans (Asymptotics.IsEquivalent l) (Asymptotics.IsLittleO l) (Asymptotics.IsLittleO l)
|
CategoryTheory.PreOneHypercover.cylinder_X
|
Mathlib.CategoryTheory.Sites.Hypercover.Homotopy
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (i : E.Iβ) Γ F.Iβ (f.sβ i) (g.sβ i)),
(CategoryTheory.PreOneHypercover.cylinder f g).X p = CategoryTheory.PreOneHypercover.cylinderX f g p.snd
|
CategoryTheory.CostructuredArrow.ΞΉCompGrothendieckPrecompFunctorToCommaCompFst_hom_app
|
Mathlib.CategoryTheory.Comma.StructuredArrow.Functor
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
{E : Type uβ} [inst_2 : CategoryTheory.Category.{vβ, uβ} E] (L : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor E D) (X : E) (X_1 : β((R.comp (CategoryTheory.CostructuredArrow.functor L)).obj X)),
(CategoryTheory.CostructuredArrow.ΞΉCompGrothendieckPrecompFunctorToCommaCompFst L R X).hom.app X_1 =
CategoryTheory.CategoryStruct.id X_1.left
|
Homeomorph.ext
|
Mathlib.Topology.Homeomorph.Defs
|
β {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {h h' : X ββ Y},
(β (x : X), h x = h' x) β h = h'
|
Std.DHashMap.Internal.Rawβ.Const.getKeyD_filter
|
Std.Data.DHashMap.Internal.RawLemmas
|
β {Ξ± : Type u} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {Ξ² : Type v} (m : Std.DHashMap.Internal.Rawβ Ξ± fun x => Ξ²)
[inst_2 : EquivBEq Ξ±] [inst_3 : LawfulHashable Ξ±] {f : Ξ± β Ξ² β Bool} {k fallback : Ξ±} (h : (βm).WF),
(Std.DHashMap.Internal.Rawβ.filter f m).getKeyD k fallback =
((m.getKey? k).pfilter fun x h' => f x (Std.DHashMap.Internal.Rawβ.Const.get m x β―)).getD fallback
|
Submodule.IsLattice.smul
|
Mathlib.Algebra.Module.Lattice
|
β {R : Type u_1} [inst : CommRing R] (A : Type u_2) [inst_1 : CommRing A] [inst_2 : Algebra R A] {V : Type u_3}
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : Module A V] [inst_6 : IsScalarTower R A V]
(M : Submodule R V) [Submodule.IsLattice A M] (a : AΛ£), Submodule.IsLattice A (a β’ M)
|
TensorProduct.mapOfCompatibleSMul
|
Mathlib.LinearAlgebra.TensorProduct.Basic
|
(R : Type u_1) β
[inst : CommSemiring R] β
(A : Type u_6) β
(M : Type u_7) β
(N : Type u_8) β
[inst_1 : AddCommMonoid M] β
[inst_2 : AddCommMonoid N] β
[inst_3 : Module R M] β
[inst_4 : Module R N] β
[inst_5 : CommSemiring A] β
[inst_6 : Module A M] β
[inst_7 : Module A N] β
[inst_8 : SMulCommClass R A M] β
[TensorProduct.CompatibleSMul R A M N] β TensorProduct A M N ββ[A] TensorProduct R M N
|
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.pow_sub_le_descFactorial.match_1_1
|
Mathlib.Data.Nat.Factorial.Basic
|
β (motive : β β Prop) (x : β), (β (a : Unit), motive 0) β (β (k : β), motive k.succ) β motive x
|
BitVec.toNat_shiftConcat_eq_of_lt
|
Init.Data.BitVec.Lemmas
|
β {w : β} {x : BitVec w} {b : Bool} {k : β}, k < w β x.toNat < 2 ^ k β (x.shiftConcat b).toNat = x.toNat * 2 + b.toNat
|
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_3
|
Mathlib.CategoryTheory.Limits.Types.Multiequalizer
|
β {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_3))
(x : I.sections) (r : J.R),
I.multicospan.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst r)
(ββ¨fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => x.val i
| CategoryTheory.Limits.WalkingMulticospan.right j => I.fst j (x.val (J.fst j)),
β―β©
(CategoryTheory.Limits.WalkingMulticospan.left (J.fst r))) =
I.snd r
(ββ¨fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => x.val i
| CategoryTheory.Limits.WalkingMulticospan.right j => I.fst j (x.val (J.fst j)),
β―β©
(CategoryTheory.Limits.WalkingMulticospan.left (J.snd r)))
|
MeasureTheory.ComplexMeasure.absolutelyContinuous_ennreal_iff
|
Mathlib.MeasureTheory.Measure.Complex
|
β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} (c : MeasureTheory.ComplexMeasure Ξ±)
(ΞΌ : MeasureTheory.VectorMeasure Ξ± ENNReal),
MeasureTheory.VectorMeasure.AbsolutelyContinuous c ΞΌ β
MeasureTheory.VectorMeasure.AbsolutelyContinuous (MeasureTheory.ComplexMeasure.re c) ΞΌ β§
MeasureTheory.VectorMeasure.AbsolutelyContinuous (MeasureTheory.ComplexMeasure.im c) ΞΌ
|
IsSymmetricRel.iInter
|
Mathlib.Topology.UniformSpace.Defs
|
β {Ξ± : Type ua} {ΞΉ : Sort u_1} {U : ΞΉ β SetRel Ξ± Ξ±}, (β (i : ΞΉ), IsSymmetricRel (U i)) β IsSymmetricRel (β i, U i)
|
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.JoinPointFinder.removeCandidatesInArg
|
Lean.Compiler.LCNF.JoinPoints
|
Lean.Compiler.LCNF.Arg β Lean.Compiler.LCNF.JoinPointFinder.FindM Unit
|
Polynomial.zero_of_eval_zero
|
Mathlib.Algebra.Polynomial.Roots
|
β {R : Type u} [inst : CommRing R] [IsDomain R] [Infinite R] (p : Polynomial R),
(β (x : R), Polynomial.eval x p = 0) β p = 0
|
[email protected]._hygCtx._hyg.2
|
Mathlib.Algebra.RingQuot
|
(S : Type uS) β
[inst : CommSemiring S] β
{A : Type uA} β [inst_1 : Semiring A] β [inst_2 : Algebra S A] β (s : A β A β Prop) β A ββ[S] RingQuot s
|
Set.NPow
|
Mathlib.Algebra.Group.Pointwise.Set.Basic
|
{Ξ± : Type u_2} β [One Ξ±] β [Mul Ξ±] β Pow (Set Ξ±) β
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault.elim
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic
|
{motive : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind β Sort u} β
(t : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind) β
t.ctorIdx = 1 β
((info : Lean.InductiveVal) β
(ctors : Array Lean.ConstructorVal) β
motive (Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault info ctors)) β
motive t
|
Finset.one_le_divConst_self
|
Mathlib.Combinatorics.Additive.DoublingConst
|
β {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {A : Finset G}, A.Nonempty β 1 β€ A.divConst A
|
Lean.Meta.StructProjDecl._sizeOf_inst
|
Lean.Meta.Structure
|
SizeOf Lean.Meta.StructProjDecl
|
OpenPartialHomeomorph.ofSet_symm
|
Mathlib.Topology.OpenPartialHomeomorph.IsImage
|
β {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (hs : IsOpen s),
(OpenPartialHomeomorph.ofSet s hs).symm = OpenPartialHomeomorph.ofSet s hs
|
Std.Time.Database.TZdb.inst.match_1
|
Std.Time.Zoned.Database.TZdb
|
(motive : Option String β Sort u_1) β
(env : Option String) β ((path : String) β motive (some path)) β ((x : Option String) β motive x) β motive env
|
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedHomogeneousComponent_finsupp._simp_1_2
|
Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
|
β {Ξ± : Sort u_1} {p : Ξ± β Prop}, (Β¬β x, p x) = β (x : Ξ±), Β¬p x
|
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.closure_iUnion._simp_1_1
|
Mathlib.Topology.LocallyFinite
|
β {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (x β closure s) = (nhdsWithin x s).NeBot
|
Std.Time.ZonedDateTime.toPlainDateTime
|
Std.Time.Zoned.ZonedDateTime
|
Std.Time.ZonedDateTime β Std.Time.PlainDateTime
|
Multiset.decidableEq._proof_2
|
Mathlib.Data.Multiset.Defs
|
β {Ξ± : Type u_1} (x x_1 : List Ξ±), β¦xβ§ = β¦x_1β§ β x β x_1
|
gcd_same
|
Mathlib.Algebra.GCDMonoid.Basic
|
β {Ξ± : Type u_1} [inst : CancelCommMonoidWithZero Ξ±] [inst_1 : NormalizedGCDMonoid Ξ±] (a : Ξ±), gcd a a = normalize a
|
Lean.Elab.InlayHintTextEdit.recOn
|
Lean.Elab.InfoTree.InlayHints
|
{motive : Lean.Elab.InlayHintTextEdit β Sort u} β
(t : Lean.Elab.InlayHintTextEdit) β
((range : Lean.Syntax.Range) β (newText : String) β motive { range := range, newText := newText }) β motive t
|
NormedAddGroupHom.coeAddHom_apply
|
Mathlib.Analysis.Normed.Group.Hom
|
β {Vβ : Type u_2} {Vβ : Type u_3} [inst : SeminormedAddCommGroup Vβ] [inst_1 : SeminormedAddCommGroup Vβ]
(a : NormedAddGroupHom Vβ Vβ) (a_1 : Vβ), NormedAddGroupHom.coeAddHom a a_1 = a a_1
|
_private.Lean.Meta.DiscrTree.0.Lean.Meta.DiscrTree.getMatchKeyRootFor._sparseCasesOn_1
|
Lean.Meta.DiscrTree
|
{motive : Lean.Expr β Sort u} β
(t : Lean.Expr) β
((a : Lean.Literal) β motive (Lean.Expr.lit a)) β
((fvarId : Lean.FVarId) β motive (Lean.Expr.fvar fvarId)) β
((mvarId : Lean.MVarId) β motive (Lean.Expr.mvar mvarId)) β
((typeName : Lean.Name) β (idx : β) β (struct : Lean.Expr) β motive (Lean.Expr.proj typeName idx struct)) β
((binderName : Lean.Name) β
(binderType body : Lean.Expr) β
(binderInfo : Lean.BinderInfo) β motive (Lean.Expr.forallE binderName binderType body binderInfo)) β
((declName : Lean.Name) β (us : List Lean.Level) β motive (Lean.Expr.const declName us)) β
(t.ctorIdx β 9 β
t.ctorIdx β 1 β t.ctorIdx β 2 β t.ctorIdx β 11 β t.ctorIdx β 7 β t.ctorIdx β 4 β motive t) β
motive t
|
CategoryTheory.ShortComplex.Exact.epi_f
|
Mathlib.Algebra.Homology.ShortComplex.Exact
|
β {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.Exact β S.g = 0 β CategoryTheory.Epi S.f
|
bddAbove_Ioc
|
Mathlib.Order.Bounds.Basic
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {a b : Ξ±}, BddAbove (Set.Ioc a b)
|
Mathlib.Tactic.CC.CCM.getEqcLambdas
|
Mathlib.Tactic.CC.Addition
|
Lean.Expr β optParam (Array Lean.Expr) #[] β Mathlib.Tactic.CC.CCM (Array Lean.Expr)
|
CochainComplex.HomComplex.leftHomologyData'_Ο
|
Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C β€) (n m p : β€) (hm : n + 1 = m) (hp : m + 1 = p),
(CochainComplex.HomComplex.leftHomologyData' K L n m p hm hp).Ο =
AddCommGrpCat.ofHom (CochainComplex.HomComplex.CohomologyClass.mkAddMonoidHom K L m)
|
HomologicalComplex.shortComplexFunctor'._proof_5
|
Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
|
β (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ΞΉ : Type u_3} (c : ComplexShape ΞΉ) (i j k : ΞΉ) {X Y Z : HomologicalComplex C c} (f : X βΆ Y) (g : Y βΆ Z),
{ Οβ := (CategoryTheory.CategoryStruct.comp f g).f i, Οβ := (CategoryTheory.CategoryStruct.comp f g).f j,
Οβ := (CategoryTheory.CategoryStruct.comp f g).f k, commββ := β―, commββ := β― } =
CategoryTheory.CategoryStruct.comp { Οβ := f.f i, Οβ := f.f j, Οβ := f.f k, commββ := β―, commββ := β― }
{ Οβ := g.f i, Οβ := g.f j, Οβ := g.f k, commββ := β―, commββ := β― }
|
Measurable.lmarginal
|
Mathlib.MeasureTheory.Integral.Marginal
|
β {Ξ΄ : Type u_1} {X : Ξ΄ β Type u_3} [inst : (i : Ξ΄) β MeasurableSpace (X i)] (ΞΌ : (i : Ξ΄) β MeasureTheory.Measure (X i))
[inst_1 : DecidableEq Ξ΄] {s : Finset Ξ΄} {f : ((i : Ξ΄) β X i) β ENNReal} [β (i : Ξ΄), MeasureTheory.SigmaFinite (ΞΌ i)],
Measurable f β Measurable (β«β―β«β»_s, f βΞΌ)
|
MeasureTheory.Measure.toSphere_apply_aux
|
Mathlib.MeasureTheory.Constructions.HaarToSphere
|
β {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E] [inst_2 : MeasurableSpace E]
(ΞΌ : MeasureTheory.Measure E) (s : Set β(Metric.sphere 0 1)) (r : β(Set.Ioi 0)),
ΞΌ (Subtype.val '' (β(homeomorphUnitSphereProd E) β»ΒΉ' s ΓΛ’ Set.Iio r)) = ΞΌ (Set.Ioo 0 βr β’ Subtype.val '' s)
|
CoalgHom.End._proof_3
|
Mathlib.RingTheory.Coalgebra.Hom
|
β {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] (x : A ββc[R] A), x * 1 = x
|
InitialSeg.total
|
Mathlib.Order.InitialSeg
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β
(r : Ξ± β Ξ± β Prop) β (s : Ξ² β Ξ² β Prop) β [IsWellOrder Ξ± r] β [IsWellOrder Ξ² s] β InitialSeg r s β InitialSeg s r
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.