name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Trivialization.pullback._proof_1
|
Mathlib.Topology.FiberBundle.Constructions
|
β {B : Type u_3} {F : Type u_2} {E : B β Type u_5} {B' : Type u_1} [inst : TopologicalSpace B']
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : TopologicalSpace F] [inst_3 : TopologicalSpace B]
{K : Type u_4} [inst_4 : FunLike K B' B] [ContinuousMapClass K B' B] (e : Trivialization F Bundle.TotalSpace.proj)
(f : K), IsOpen ((βf β»ΒΉ' e.baseSet) ΓΛ’ Set.univ)
|
FundamentalGroupoid.instIsEmpty
|
Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic
|
β (X : Type u_3) [IsEmpty X], IsEmpty (FundamentalGroupoid X)
|
signedDist_vadd_right_swap
|
Mathlib.Geometry.Euclidean.SignedDist
|
β {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v w : V) (p q : P), ((signedDist v) p) (w +α΅₯ q) = ((signedDist v) (-w +α΅₯ p)) q
|
hasFDerivAt_inv
|
Mathlib.Analysis.Calculus.Deriv.Inv
|
β {π : Type u} [inst : NontriviallyNormedField π] {x : π},
x β 0 β HasFDerivAt (fun x => xβ»ΒΉ) (ContinuousLinearMap.smulRight 1 (-(x ^ 2)β»ΒΉ)) x
|
DenselyOrdered.rec
|
Mathlib.Order.Basic
|
{Ξ± : Type u_5} β
[inst : LT Ξ±] β
{motive : DenselyOrdered Ξ± β Sort u} β
((dense : β (aβ aβ : Ξ±), aβ < aβ β β a, aβ < a β§ a < aβ) β motive β―) β (t : DenselyOrdered Ξ±) β motive t
|
Pi.orderedSMul
|
Mathlib.Algebra.Order.Module.OrderedSMul
|
β {ΞΉ : Type u_1} {π : Type u_2} [inst : Semifield π] [inst_1 : PartialOrder π] [IsStrictOrderedRing π]
[PosMulReflectLT π] {M : ΞΉ β Type u_6} [inst_4 : (i : ΞΉ) β AddCommMonoid (M i)]
[inst_5 : (i : ΞΉ) β PartialOrder (M i)] [inst_6 : (i : ΞΉ) β MulActionWithZero π (M i)]
[β (i : ΞΉ), OrderedSMul π (M i)], OrderedSMul π ((i : ΞΉ) β M i)
|
_private.Mathlib.Lean.Expr.Basic.0.Lean.Name.fromComponents.go._unsafe_rec
|
Mathlib.Lean.Expr.Basic
|
Lean.Name β List Lean.Name β Lean.Name
|
Turing.ToPartrec.Cfg.ctorIdx
|
Mathlib.Computability.TMConfig
|
Turing.ToPartrec.Cfg β β
|
Nat.shiftLeft'._unsafe_rec
|
Mathlib.Data.Nat.Bits
|
Bool β β β β β β
|
_private.Init.Data.SInt.Lemmas.0.Int64.lt_iff_le_and_ne._simp_1_2
|
Init.Data.SInt.Lemmas
|
β {x y : Int64}, (x β€ y) = (x.toInt β€ y.toInt)
|
Mathlib.Tactic.BicategoryLike.AtomIso.mk.sizeOf_spec
|
Mathlib.Tactic.CategoryTheory.Coherence.Datatypes
|
β (e : Lean.Expr) (src tgt : Mathlib.Tactic.BicategoryLike.Morβ),
sizeOf { e := e, src := src, tgt := tgt } = 1 + sizeOf e + sizeOf src + sizeOf tgt
|
CategoryTheory.Bicategory.RightLift.mk
|
Mathlib.CategoryTheory.Bicategory.Extension
|
{B : Type u} β
[inst : CategoryTheory.Bicategory B] β
{a b c : B} β
{f : b βΆ a} β
{g : c βΆ a} β
(h : c βΆ b) β (CategoryTheory.CategoryStruct.comp h f βΆ g) β CategoryTheory.Bicategory.RightLift f g
|
Submodule.mem_adjoint_iff
|
Mathlib.Analysis.InnerProductSpace.LinearPMap
|
β {π : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike π] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace π E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace π F]
(g : Submodule π (E Γ F)) (x : F Γ E),
x β g.adjoint β β (a : E) (b : F), (a, b) β g β inner π b x.1 - inner π a x.2 = 0
|
CategoryTheory.Functor.pointwiseLeftKanExtensionCompIsoOfPreserves_fac_app
|
Mathlib.CategoryTheory.Functor.KanExtension.Preserves
|
β {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B)
(L : CategoryTheory.Functor A C) [inst_4 : G.PreservesPointwiseLeftKanExtension F L]
[inst_5 : L.HasPointwiseLeftKanExtension F] (a : A),
CategoryTheory.CategoryStruct.comp ((L.pointwiseLeftKanExtensionUnit (F.comp G)).app a)
((G.pointwiseLeftKanExtensionCompIsoOfPreserves F L).inv.app (L.obj a)) =
G.map ((L.pointwiseLeftKanExtensionUnit F).app a)
|
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.termProj
|
Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme
|
Lean.ParserDescr
|
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_12
|
Mathlib.Data.Fin.SuccPred
|
β {n : β} (j : Fin (n + 1)) (k : Fin n), βk + 1 < βj β Β¬βk < βj β βk + 1 = βk + 1 + 1
|
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic.0.tacticEval_simp
|
Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic
|
Lean.ParserDescr
|
Stream'.WSeq.ofList_cons
|
Mathlib.Data.WSeq.Basic
|
β {Ξ± : Type u} (a : Ξ±) (l : List Ξ±), β(a :: l) = Stream'.WSeq.cons a βl
|
_private.Mathlib.NumberTheory.Divisors.0.Int.mul_mem_zero_one_two_three_four_iff._simp_1_1
|
Mathlib.NumberTheory.Divisors
|
β {x y z : β€}, z β 0 β (x * y = z) = ((x, y) β z.divisorsAntidiag)
|
CompareReals.compareEquiv
|
Mathlib.Topology.UniformSpace.CompareReals
|
CompareReals.Bourbakiβ βα΅€ β
|
Lean.Options.getInPattern
|
Lean.Data.Options
|
Lean.Options β Bool
|
StandardEtalePair.instEtaleRing
|
Mathlib.RingTheory.Etale.StandardEtale
|
β {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R), Algebra.Etale R P.Ring
|
MulSemiringActionHom.map_mul'
|
Mathlib.GroupTheory.GroupAction.Hom
|
β {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {Ο : M β* N} {R : Type u_10} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_12} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S]
(self : R ββ+*[Ο] S) (x y : R), self.toFun (x * y) = self.toFun x * self.toFun y
|
EstimatorData.improve
|
Mathlib.Deprecated.Estimator
|
{Ξ± : Type u_1} β (a : Thunk Ξ±) β {Ξ΅ : Type u_3} β [self : EstimatorData a Ξ΅] β Ξ΅ β Option Ξ΅
|
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.ProtocolExtensionKind.ctorIdx
|
Lean.Server.ProtocolOverview
|
Lean.Server.Overview.ProtocolExtensionKindβ β β
|
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.MvPolynomial.schwartz_zippel_sup_sum._simp_1_5
|
Mathlib.Algebra.MvPolynomial.SchwartzZippel
|
β (p : Prop), (p β¨ Β¬p) = True
|
NonUnitalStarAlgHom.mk
|
Mathlib.Algebra.Star.StarAlgHom
|
{R : Type u_1} β
{A : Type u_2} β
{B : Type u_3} β
[inst : Monoid R] β
[inst_1 : NonUnitalNonAssocSemiring A] β
[inst_2 : DistribMulAction R A] β
[inst_3 : Star A] β
[inst_4 : NonUnitalNonAssocSemiring B] β
[inst_5 : DistribMulAction R B] β
[inst_6 : Star B] β
(toNonUnitalAlgHom : A βββ[R] B) β
(β (a : A), toNonUnitalAlgHom.toFun (star a) = star (toNonUnitalAlgHom.toFun a)) β A ββββ[R] B
|
ContinuousOrderHom._sizeOf_inst
|
Mathlib.Topology.Order.Hom.Basic
|
(Ξ± : Type u_6) β
(Ξ² : Type u_7) β
{inst : Preorder Ξ±} β
{inst_1 : Preorder Ξ²} β
{inst_2 : TopologicalSpace Ξ±} β {inst_3 : TopologicalSpace Ξ²} β [SizeOf Ξ±] β [SizeOf Ξ²] β SizeOf (Ξ± βCo Ξ²)
|
Std.DTreeMap.isEmpty_toList
|
Std.Data.DTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.DTreeMap Ξ± Ξ² cmp}, t.toList.isEmpty = t.isEmpty
|
_private.Mathlib.Data.Int.Init.0.Int.le_induction_down._proof_1_3
|
Mathlib.Data.Int.Init
|
β {m : β€} {motive : (n : β€) β n β€ m β Prop} (k : β€), m β€ k β β (hle' : k + 1 β€ m), motive (k + 1) hle'
|
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.toTriangle._simp_5
|
Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {s : Finset Ξ±} {a b : Ξ±}, (a β insert b s) = (a = b β¨ a β s)
|
Real.geom_mean_le_arith_mean3_weighted
|
Mathlib.Analysis.MeanInequalities
|
β {wβ wβ wβ pβ pβ pβ : β},
0 β€ wβ β
0 β€ wβ β
0 β€ wβ β 0 β€ pβ β 0 β€ pβ β 0 β€ pβ β wβ + wβ + wβ = 1 β pβ ^ wβ * pβ ^ wβ * pβ ^ wβ β€ wβ * pβ + wβ * pβ + wβ * pβ
|
AddMonCat.HasLimits.limitConeIsLimit._proof_5
|
Mathlib.Algebra.Category.MonCat.Limits
|
β {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddMonCat)
(s : CategoryTheory.Limits.Cone F) (x y : βs.1) {j j' : J} (f : j βΆ j'),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.forget AddMonCat).mapCone s).Ο.app j)
((F.comp (CategoryTheory.forget AddMonCat)).map f) (x + y) =
((CategoryTheory.forget AddMonCat).mapCone s).Ο.app j' (x + y)
|
AddMonoidHom.mulOp._proof_4
|
Mathlib.Algebra.Group.Equiv.Opposite
|
β {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M β+ N) (x y : Mα΅α΅α΅),
(MulOpposite.op β βf β MulOpposite.unop) (x + y) =
(MulOpposite.op β βf β MulOpposite.unop) x + (MulOpposite.op β βf β MulOpposite.unop) y
|
CategoryTheory.comp_eqToHom_iff
|
Mathlib.CategoryTheory.EqToHom
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {X Y Y' : C} (p : Y = Y') (f : X βΆ Y) (g : X βΆ Y'),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom p) = g β
f = CategoryTheory.CategoryStruct.comp g (CategoryTheory.eqToHom β―)
|
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.foundLine
|
Init.Data.Format.Basic
|
Std.Format.SpaceResultβ β Bool
|
Ordinal.isNormal_veblen_zero
|
Mathlib.SetTheory.Ordinal.Veblen
|
Ordinal.IsNormal fun x => Ordinal.veblen x 0
|
instContinuousSMulTangentSpace
|
Mathlib.Geometry.Manifold.IsManifold.Basic
|
β {π : 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] (_x : M), ContinuousSMul π (TangentSpace I _x)
|
Cardinal.lift_sSup
|
Mathlib.SetTheory.Cardinal.Basic
|
β {s : Set Cardinal.{u_1}}, BddAbove s β Cardinal.lift.{u, u_1} (sSup s) = sSup (Cardinal.lift.{u, u_1} '' s)
|
_private.Mathlib.Order.ModularLattice.0.strictMono_inf_prod_sup.match_1_1
|
Mathlib.Order.ModularLattice
|
β {Ξ± : Type u_1} [inst : Lattice Ξ±] {z : Ξ±} (_x _y : Ξ±)
(motive : (fun x => (x β z, x β z)) _y β€ (fun x => (x β z, x β z)) _x β Prop)
(x : (fun x => (x β z, x β z)) _y β€ (fun x => (x β z, x β z)) _x),
(β (inf_le : ((fun x => (x β z, x β z)) _y).1 β€ ((fun x => (x β z, x β z)) _x).1)
(sup_le : ((fun x => (x β z, x β z)) _y).2 β€ ((fun x => (x β z, x β z)) _x).2), motive β―) β
motive x
|
Lean.Parser.Term.letOpts.formatter
|
Lean.Parser.Term
|
Lean.PrettyPrinter.Formatter
|
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimage
|
Mathlib.RingTheory.AdicCompletion.Exactness
|
{R : Type u} β
[inst : CommRing R] β
{I : Ideal R} β
{M : Type v} β
[inst_1 : AddCommGroup M] β
[inst_2 : Module R M] β
{N : Type w} β
[inst_3 : AddCommGroup N] β
[inst_4 : Module R N] β
{f : M ββ[R] N} β
Function.Surjective βf β (x : AdicCompletion.AdicCauchySequence I N) β (n : β) β β(βf β»ΒΉ' {βx n})
|
CategoryTheory.Cat.equivOfIso._proof_3
|
Mathlib.CategoryTheory.Category.Cat
|
β {C D : CategoryTheory.Cat} (Ξ³ : C β
D), Ξ³.inv.toFunctor.comp Ξ³.hom.toFunctor = CategoryTheory.Functor.id βD
|
Finsupp.subtypeDomain_sub
|
Mathlib.Data.Finsupp.Basic
|
β {Ξ± : Type u_1} {G : Type u_8} [inst : AddGroup G] {p : Ξ± β Prop} {v v' : Ξ± ββ G},
Finsupp.subtypeDomain p (v - v') = Finsupp.subtypeDomain p v - Finsupp.subtypeDomain p v'
|
Std.HashMap.Raw.WF.filterMap
|
Std.Data.HashMap.AdditionalOperations
|
β {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {m : Std.HashMap.Raw Ξ± Ξ²}
{f : Ξ± β Ξ² β Option Ξ³}, m.WF β (Std.HashMap.Raw.filterMap f m).WF
|
Std.TreeMap.getKey_minKey!
|
Std.Data.TreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.TreeMap Ξ± Ξ² cmp} [Std.TransCmp cmp] [inst : Inhabited Ξ±]
{hc : t.minKey! β t}, t.getKey t.minKey! hc = t.minKey!
|
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.bindMutVarsFromTuple.go._sunfold
|
Lean.Elab.Do.Basic
|
Lean.Elab.Do.DoElabM Lean.Expr β
List Lean.Name β Lean.FVarId β Lean.Expr β Array Lean.Expr β Lean.Elab.Do.DoElabM Lean.Expr
|
MonoidHom.toOneHom_coe
|
Mathlib.Algebra.Group.Hom.Defs
|
β {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N] (f : M β* N), ββf = βf
|
IsAddUnit.add_right_cancel
|
Mathlib.Algebra.Group.Units.Basic
|
β {M : Type u_1} [inst : AddMonoid M] {a b c : M}, IsAddUnit b β a + b = c + b β a = c
|
_private.Batteries.Data.MLList.Basic.0.MLList.ofArray.go._unsafe_rec
|
Batteries.Data.MLList.Basic
|
{m : Type β Type} β {Ξ± : Type} β Array Ξ± β β β MLList m Ξ±
|
OrderDual.ofDual_le_ofDual
|
Mathlib.Order.Synonym
|
β {Ξ± : Type u_1} [inst : LE Ξ±] {a b : Ξ±α΅α΅}, OrderDual.ofDual a β€ OrderDual.ofDual b β b β€ a
|
List.append_eq
|
Init.Data.List.Basic
|
β {Ξ± : Type u} {as bs : List Ξ±}, as.append bs = as ++ bs
|
fderivWithin_of_mem_nhds
|
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}
{x : E} {s : Set E}, s β nhds x β fderivWithin π f s x = fderiv π f x
|
RingHom.Finite.finiteType
|
Mathlib.RingTheory.FiniteType
|
β {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] {f : A β+* B}, f.Finite β f.FiniteType
|
_private.Mathlib.Algebra.DirectSum.Internal.0.listProd_apply_eq_zero._simp_1_2
|
Mathlib.Algebra.DirectSum.Internal
|
β {Ξ± : Sort u_1} {p q : Ξ± β Prop} {a' : Ξ±}, (β (a : Ξ±), a = a' β¨ q a β p a) = (p a' β§ β (a : Ξ±), q a β p a)
|
_private.Mathlib.GroupTheory.Coset.Basic.0.Subgroup.quotientiInfSubgroupOfEmbedding._simp_3
|
Mathlib.GroupTheory.Coset.Basic
|
β {G : Type u_1} [inst : Group G] {H K : Subgroup G} {h : β₯K}, (h β H.subgroupOf K) = (βh β H)
|
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkSize.go.match_1
|
Lean.Meta.Tactic.Grind.EMatch
|
(motive : Lean.Expr β Sort u_1) β
(e : Lean.Expr) β
((binderName : Lean.Name) β
(d b : Lean.Expr) β (binderInfo : Lean.BinderInfo) β motive (Lean.Expr.forallE binderName d b binderInfo)) β
((binderName : Lean.Name) β
(binderType b : Lean.Expr) β
(binderInfo : Lean.BinderInfo) β motive (Lean.Expr.lam binderName binderType b binderInfo)) β
((declName : Lean.Name) β
(type v b : Lean.Expr) β (nondep : Bool) β motive (Lean.Expr.letE declName type v b nondep)) β
((data : Lean.MData) β (e : Lean.Expr) β motive (Lean.Expr.mdata data e)) β
((typeName : Lean.Name) β (idx : β) β (e : Lean.Expr) β motive (Lean.Expr.proj typeName idx e)) β
((fn arg : Lean.Expr) β motive (fn.app arg)) β ((x : Lean.Expr) β motive x) β motive e
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.map_fst_toList_eq_keys._simp_1_2
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {instOrd : Ord Ξ±} {a b : Ξ±}, (compare a b β Ordering.eq) = ((a == b) = false)
|
Std.DHashMap.Raw.Const.get?_inter_of_not_mem_right
|
Std.Data.DHashMap.RawLemmas
|
β {Ξ± : Type u} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {Ξ² : Type v} {mβ mβ : Std.DHashMap.Raw Ξ± fun x => Ξ²} [EquivBEq Ξ±]
[LawfulHashable Ξ±], mβ.WF β mβ.WF β β {k : Ξ±}, k β mβ β Std.DHashMap.Raw.Const.get? (mβ β© mβ) k = none
|
Subalgebra.perfectClosure
|
Mathlib.FieldTheory.PurelyInseparable.Basic
|
(R : Type u_1) β
(A : Type u_2) β
[inst : CommSemiring R] β
[inst_1 : CommSemiring A] β [inst_2 : Algebra R A] β (p : β) β [ExpChar A p] β Subalgebra R A
|
Int.modEq_sub_modulus_mul_iff
|
Mathlib.Data.Int.ModEq
|
β {n a b c : β€}, a β‘ b - n * c [ZMOD n] β a β‘ b [ZMOD n]
|
ProbabilityTheory.Kernel.iIndepFun.compβ
|
Mathlib.Probability.Independence.Kernel.IndepFun
|
β {Ξ± : Type u_1} {Ξ© : Type u_2} {ΞΉ : Type u_3} {mΞ± : MeasurableSpace Ξ±} {mΞ© : MeasurableSpace Ξ©}
{ΞΊ : ProbabilityTheory.Kernel Ξ± Ξ©} {ΞΌ : MeasureTheory.Measure Ξ±} {Ξ² : ΞΉ β Type u_8} {Ξ³ : ΞΉ β Type u_9}
{mΞ² : (i : ΞΉ) β MeasurableSpace (Ξ² i)} {mΞ³ : (i : ΞΉ) β MeasurableSpace (Ξ³ i)} {f : (i : ΞΉ) β Ξ© β Ξ² i},
ProbabilityTheory.Kernel.iIndepFun f ΞΊ ΞΌ β
β (g : (i : ΞΉ) β Ξ² i β Ξ³ i),
(β (i : ΞΉ), AEMeasurable (f i) (ΞΌ.bind βΞΊ)) β
(β (i : ΞΉ), AEMeasurable (g i) (MeasureTheory.Measure.map (f i) (ΞΌ.bind βΞΊ))) β
ProbabilityTheory.Kernel.iIndepFun (fun i => g i β f i) ΞΊ ΞΌ
|
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.List.0.Std.Iterators.ListIterator.stepAsHetT_iterM._simp_1_6
|
Std.Data.Iterators.Lemmas.Producers.Monadic.List
|
β {Ξ± : Type w} {x y : Std.Iterators.ListIterator Ξ±}, (x = y) = (x.list = y.list)
|
Submodule.map._proof_1
|
Mathlib.Algebra.Module.Submodule.Map
|
β {R : Type u_4} {Rβ : Type u_5} {M : Type u_2} {Mβ : Type u_1} [inst : Semiring R] [inst_1 : Semiring Rβ]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid Mβ] [inst_4 : Module R M] [inst_5 : Module Rβ Mβ] {Οββ : R β+* Rβ}
[RingHomSurjective Οββ] {F : Type u_3} [inst_7 : FunLike F M Mβ] [SemilinearMapClass F Οββ M Mβ] (f : F)
(p : Submodule R M) (c : Rβ) {x : Mβ}, x β βf '' βp β c β’ x β βf '' βp
|
Std.Do.Spec.forIn'_list._proof_5
|
Std.Do.Triple.SpecLemmas
|
β {Ξ± : Type u_1} {xs : List Ξ±}, xs ++ [] = xs
|
Std.TreeMap.Raw.minKeyD_insert
|
Std.Data.TreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.TreeMap.Raw Ξ± Ξ² cmp} [Std.TransCmp cmp],
t.WF β
β {k : Ξ±} {v : Ξ²} {fallback : Ξ±},
(t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k'
|
hasFDerivWithinAt_pi'
|
Mathlib.Analysis.Calculus.FDeriv.Prod
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {x : E} {s : Set E} {ΞΉ : Type u_6} [Fintype ΞΉ] {F' : ΞΉ β Type u_7}
[inst_4 : (i : ΞΉ) β NormedAddCommGroup (F' i)] [inst_5 : (i : ΞΉ) β NormedSpace π (F' i)] {Ξ¦ : E β (i : ΞΉ) β F' i}
{Ξ¦' : E βL[π] (i : ΞΉ) β F' i},
HasFDerivWithinAt Ξ¦ Ξ¦' s x β β (i : ΞΉ), HasFDerivWithinAt (fun x => Ξ¦ x i) ((ContinuousLinearMap.proj i).comp Ξ¦') s x
|
Functor.map_unit
|
Init.Control.Lawful.Basic
|
β {f : Type u_1 β Type u_2} [inst : Functor f] [LawfulFunctor f] {a : f PUnit.{u_1 + 1}},
(fun x => PUnit.unit) <$> a = a
|
Sym.filterNe._proof_1
|
Mathlib.Data.Sym.Basic
|
β {Ξ± : Type u_1} {n : β} (m : Sym Ξ± n), (βm).card < n + 1
|
Lean.IR.Expr.proj.elim
|
Lean.Compiler.IR.Basic
|
{motive : Lean.IR.Expr β Sort u} β
(t : Lean.IR.Expr) β t.ctorIdx = 3 β ((i : β) β (x : Lean.IR.VarId) β motive (Lean.IR.Expr.proj i x)) β motive t
|
SkewMonoidAlgebra.noConfusion
|
Mathlib.Algebra.SkewMonoidAlgebra.Basic
|
{P : Sort u} β
{k : Type u_1} β
{G : Type u_2} β
{inst : Zero k} β
{t : SkewMonoidAlgebra k G} β
{k' : Type u_1} β
{G' : Type u_2} β
{inst' : Zero k'} β
{t' : SkewMonoidAlgebra k' G'} β
k = k' β G = G' β inst β inst' β t β t' β SkewMonoidAlgebra.noConfusionType P t t'
|
Vector.getElem?_append_right
|
Init.Data.Vector.Lemmas
|
β {Ξ± : Type u_1} {n m i : β} {xs : Vector Ξ± n} {ys : Vector Ξ± m}, n β€ i β (xs ++ ys)[i]? = ys[i - n]?
|
Lean.Level.collectMVars
|
Lean.Level
|
Lean.Level β optParam Lean.LMVarIdSet β
β Lean.LMVarIdSet
|
NormedAddTorsor
|
Mathlib.Analysis.Normed.Group.AddTorsor
|
(V : outParam (Type u_1)) β (P : Type u_2) β [SeminormedAddCommGroup V] β [PseudoMetricSpace P] β Type (max u_1 u_2)
|
SubMulAction.instSMulSubtypeMem._proof_1
|
Mathlib.GroupTheory.GroupAction.SubMulAction
|
β {R : Type u_2} {M : Type u_1} [inst : SMul R M] (p : SubMulAction R M) (c : R) (x : β₯p), c β’ βx β p
|
ΟCPO._sizeOf_1
|
Mathlib.Order.Category.OmegaCompletePartialOrder
|
ΟCPO β β
|
IsAlgebraic.smul
|
Mathlib.RingTheory.Algebraic.Integral
|
β {R : Type u_1} {A : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a β β (r : R), IsAlgebraic R (r β’ a)
|
Quiver.Path.nil
|
Mathlib.Combinatorics.Quiver.Path
|
{V : Type u} β [inst : Quiver V] β {a : V} β Quiver.Path a a
|
_private.Init.Data.List.Impl.0.List.zipWith_eq_zipWithTR.go
|
Init.Data.List.Impl
|
β (Ξ± : Type u_3) (Ξ² : Type u_2) (Ξ³ : Type u_1) (f : Ξ± β Ξ² β Ξ³) (as : List Ξ±) (bs : List Ξ²) (acc : Array Ξ³),
List.zipWithTR.goβ f as bs acc = acc.toList ++ List.zipWith f as bs
|
WeierstrassCurve.Projective.Point.mk.inj
|
Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point
|
β {R : Type r} {inst : CommRing R} {W' : WeierstrassCurve.Projective R}
{point : WeierstrassCurve.Projective.PointClass R} {nonsingular : W'.NonsingularLift point}
{point_1 : WeierstrassCurve.Projective.PointClass R} {nonsingular_1 : W'.NonsingularLift point_1},
{ point := point, nonsingular := nonsingular } = { point := point_1, nonsingular := nonsingular_1 } β point = point_1
|
LinearMap.IsIdempotentElem.isSymmetric_iff_isOrtho_range_ker
|
Mathlib.Analysis.InnerProductSpace.Symmetric
|
β {π : Type u_1} {E : Type u_2} [inst : RCLike π] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
{T : E ββ[π] E}, IsIdempotentElem T β (T.IsSymmetric β LinearMap.range T β LinearMap.ker T)
|
dist_le_range_sum_dist
|
Mathlib.Topology.MetricSpace.Pseudo.Basic
|
β {Ξ± : Type u} [inst : PseudoMetricSpace Ξ±] (f : β β Ξ±) (n : β),
dist (f 0) (f n) β€ β i β Finset.range n, dist (f i) (f (i + 1))
|
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_inst
|
Mathlib.Tactic.FunProp.Theorems
|
SizeOf Mathlib.Meta.FunProp.LambdaTheorems
|
CStarMatrix.ofMatrixRingEquiv._proof_2
|
Mathlib.Analysis.CStarAlgebra.CStarMatrix
|
β {n : Type u_1} {A : Type u_2} [inst : Semiring A] (x x_1 : Matrix n n A),
CStarMatrix.ofMatrix.toFun (x + x_1) = CStarMatrix.ofMatrix.toFun (x + x_1)
|
PiTensorProduct.mapMultilinear_apply
|
Mathlib.LinearAlgebra.PiTensorProduct
|
β {ΞΉ : Type u_1} (R : Type u_4) [inst : CommSemiring R] (s : ΞΉ β Type u_7) [inst_1 : (i : ΞΉ) β AddCommMonoid (s i)]
[inst_2 : (i : ΞΉ) β Module R (s i)] (t : ΞΉ β Type u_11) [inst_3 : (i : ΞΉ) β AddCommMonoid (t i)]
[inst_4 : (i : ΞΉ) β Module R (t i)] (f : (i : ΞΉ) β s i ββ[R] t i),
(PiTensorProduct.mapMultilinear R s t) f = PiTensorProduct.map f
|
Β«term_=_Β»
|
Init.Notation
|
Lean.TrailingParserDescr
|
CategoryTheory.Over.prodLeftIsoPullback_hom_fst_assoc
|
Mathlib.CategoryTheory.Limits.Constructions.Over.Products
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.Limits.HasPullback Y.hom Z.hom] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
{Z_1 : C} (h : Y.left βΆ Z_1),
CategoryTheory.CategoryStruct.comp (Y.prodLeftIsoPullback Z).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst Y.hom Z.hom) h) =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst.left h
|
_private.Init.Data.List.Perm.0.List.reverse_perm.match_1_1
|
Init.Data.List.Perm
|
β {Ξ± : Type u_1} (motive : List Ξ± β Prop) (x : List Ξ±),
(β (a : Unit), motive []) β (β (a : Ξ±) (l : List Ξ±), motive (a :: l)) β motive x
|
Matrix.det_of_mem_unitary
|
Mathlib.LinearAlgebra.UnitaryGroup
|
β {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {Ξ± : Type v} [inst_2 : CommRing Ξ±] [inst_3 : StarRing Ξ±]
{A : Matrix n n Ξ±}, A β Matrix.unitaryGroup n Ξ± β A.det β unitary Ξ±
|
instAB4AddCommGrpCat
|
Mathlib.Algebra.Category.Grp.AB
|
CategoryTheory.AB4 AddCommGrpCat
|
ContinuousAt.lineMap
|
Mathlib.Topology.Algebra.Affine
|
β {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : AddCommGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : Ring R]
[inst_6 : Module R V] [inst_7 : TopologicalSpace R] [ContinuousSMul R V] {X : Type u_6} [inst_9 : TopologicalSpace X]
{fβ fβ : X β P} {g : X β R} {x : X},
ContinuousAt fβ x β
ContinuousAt fβ x β ContinuousAt g x β ContinuousAt (fun x => (AffineMap.lineMap (fβ x) (fβ x)) (g x)) x
|
AddMonoidAlgebra.le_infDegree_mul
|
Mathlib.Algebra.MonoidAlgebra.Degree
|
β {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
[inst_3 : AddZeroClass A] [inst_4 : Add T] [AddLeftMono T] [AddRightMono T] (D : A ββ+ T)
(f g : AddMonoidAlgebra R A),
AddMonoidAlgebra.infDegree (βD) f + AddMonoidAlgebra.infDegree (βD) g β€ AddMonoidAlgebra.infDegree (βD) (f * g)
|
Lean.Elab.Term.Quotation.elabQuot._@.Lean.Elab.Quotation.1964439861._hygCtx._hyg.3
|
Lean.Elab.Quotation
|
Lean.Elab.Term.TermElab
|
Std.Iterators.IterM.inductSteps._unsafe_rec
|
Init.Data.Iterators.Lemmas.Monadic.Basic
|
{Ξ± : Type u_1} β
{m : Type u_1 β Type u_2} β
{Ξ² : Type u_1} β
[inst : Std.Iterators.Iterator Ξ± m Ξ²] β
[Std.Iterators.Finite Ξ± m] β
(motive : Std.IterM m Ξ² β Sort x) β
((it : Std.IterM m Ξ²) β
({it' : Std.IterM m Ξ²} β
{out : Ξ²} β it.IsPlausibleStep (Std.Iterators.IterStep.yield it' out) β motive it') β
({it' : Std.IterM m Ξ²} β it.IsPlausibleStep (Std.Iterators.IterStep.skip it') β motive it') β
motive it) β
(it : Std.IterM m Ξ²) β motive it
|
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_5
|
Mathlib.Data.Int.Interval
|
β (a b x : β€), a β€ x β§ x β€ b β Β¬((x - a).toNat < (b + 1 - a).toNat β§ a + β(x - a).toNat = x) β False
|
instCompleteLatticeStructureGroupoid._proof_7
|
Mathlib.Geometry.Manifold.ChartedSpace
|
β {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), b β€ SemilatticeSup.sup a b
|
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_3
|
Mathlib.RingTheory.Nilpotent.Exp
|
β (nβ nβ : β), max nβ nβ + 1 + (max nβ nβ + 1) β€ 2 * max nβ nβ + 1 + 1
|
_private.Lean.Meta.Tactic.ExposeNames.0.Lean.Meta.getLCtxWithExposedNames
|
Lean.Meta.Tactic.ExposeNames
|
Lean.MetaM Lean.LocalContext
|
List.cons.inj
|
Init.Core
|
β {Ξ± : Type u} {head : Ξ±} {tail : List Ξ±} {head_1 : Ξ±} {tail_1 : List Ξ±},
head :: tail = head_1 :: tail_1 β head = head_1 β§ tail = tail_1
|
Empty.borelSpace
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
|
BorelSpace Empty
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.