name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Nat.recDiagAux_succ_succ
|
Batteries.Data.Nat.Lemmas
|
β {motive : β β β β Sort u_1} (zero_left : (n : β) β motive 0 n) (zero_right : (m : β) β motive m 0)
(succ_succ : (m n : β) β motive m n β motive (m + 1) (n + 1)) (m n : β),
Nat.recDiagAux zero_left zero_right succ_succ (m + 1) (n + 1) =
succ_succ m n (Nat.recDiagAux zero_left zero_right succ_succ m n)
|
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_11
|
Mathlib.RingTheory.LittleWedderburn
|
β {D : Type u_1} [inst : DivisionRing D] {R : Subring D} [inst_1 : Fintype D] [inst_2 : DecidableEq D]
[inst_3 : DecidablePred fun x => x β R] (q : ββ₯0) (a : β₯R), DivisionRing.nnqsmul q a = βq * a
|
_private.Mathlib.CategoryTheory.Limits.Opposites.0.CategoryTheory.Limits.limitOpIsoOpColimit_hom_comp_ΞΉ._simp_1_1
|
Mathlib.CategoryTheory.Limits.Opposites
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (Ξ± : X β
Y) {f : X βΆ Z} {g : Y βΆ Z},
(CategoryTheory.CategoryStruct.comp Ξ±.hom g = f) = (g = CategoryTheory.CategoryStruct.comp Ξ±.inv f)
|
Lean.Elab.Command.Structure.checkValidFieldModifier
|
Lean.Elab.Structure
|
Lean.Elab.Modifiers β Lean.Elab.TermElabM Unit
|
LipschitzWith.compLp
|
Mathlib.MeasureTheory.Function.LpSpace.Basic
|
{Ξ± : Type u_1} β
{E : Type u_4} β
{F : Type u_5} β
{m : MeasurableSpace Ξ±} β
{p : ENNReal} β
{ΞΌ : MeasureTheory.Measure Ξ±} β
[inst : NormedAddCommGroup E] β
[inst_1 : NormedAddCommGroup F] β
{g : E β F} β
{c : NNReal} β LipschitzWith c g β g 0 = 0 β β₯(MeasureTheory.Lp E p ΞΌ) β β₯(MeasureTheory.Lp F p ΞΌ)
|
FormalMultilinearSeries.leftInv._proof_30
|
Mathlib.Analysis.Analytic.Inverse
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E], ContinuousConstSMul π E
|
_private.Init.Data.Array.Lemmas.0.Array.range.eq_1
|
Init.Data.Array.Lemmas
|
β (n : β), Array.range n = Array.ofFn fun i => βi
|
List.merge_of_le
|
Init.Data.List.Sort.Lemmas
|
β {Ξ± : Type u_1} {le : Ξ± β Ξ± β Bool} {xs ys : List Ξ±},
(β (a b : Ξ±), a β xs β b β ys β le a b = true) β xs.merge ys le = xs ++ ys
|
Std.TreeMap.Raw.Equiv.getEntryLT?_eq
|
Std.Data.TreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.TreeMap.Raw Ξ± Ξ² cmp} [Std.TransCmp cmp] {k : Ξ±},
tβ.WF β tβ.WF β tβ.Equiv tβ β tβ.getEntryLT? k = tβ.getEntryLT? k
|
CategoryTheory.StrictlyUnitaryLaxFunctorCore.mapβ_comp
|
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary
|
β {B : Type uβ} [inst : CategoryTheory.Bicategory B] {C : Type uβ} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) {a b : B} {f g h : a βΆ b} (Ξ· : f βΆ g) (ΞΈ : g βΆ h),
self.mapβ (CategoryTheory.CategoryStruct.comp Ξ· ΞΈ) = CategoryTheory.CategoryStruct.comp (self.mapβ Ξ·) (self.mapβ ΞΈ)
|
Lean.Parser.Tactic.quot
|
Lean.Parser.Term
|
Lean.Parser.Parser
|
ContinuousMultilinearMap.currySumEquiv._proof_10
|
Mathlib.Analysis.Normed.Module.Multilinear.Curry
|
β (π : Type u_1) (ΞΉ : Type u_2) (ΞΉ' : Type u_3) (G : Type u_4) (G' : Type u_5) [inst : Fintype ΞΉ] [inst_1 : Fintype ΞΉ']
[inst_2 : NontriviallyNormedField π] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace π G]
[inst_5 : NormedAddCommGroup G'] [inst_6 : NormedSpace π G'] (f : ContinuousMultilinearMap π (fun x => G) G'),
βf.currySum.mkContinuousMultilinear βfβ β―β β€ βfβ
|
Std.TreeSet.Raw.toList_roc
|
Std.Data.TreeSet.Raw.Slice
|
β {Ξ± : Type u} (cmp : autoParam (Ξ± β Ξ± β Ordering) _autoβ) [Std.TransCmp cmp] {t : Std.TreeSet.Raw Ξ± cmp},
t.WF β
β {lowerBound upperBound : Ξ±},
Std.Slice.toList (Std.Roc.Sliceable.mkSlice t lowerBound<...=upperBound) =
List.filter (fun e => decide ((cmp e lowerBound).isGT = true β§ (cmp e upperBound).isLE = true)) t.toList
|
contMDiffOn_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'} {s : Set M},
ContMDiffOn I I' 0 f s β ContinuousOn f s
|
Fintype
|
Mathlib.Data.Fintype.Defs
|
Type u_4 β Type u_4
|
Subalgebra.val._proof_5
|
Mathlib.Algebra.Algebra.Subalgebra.Basic
|
β {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (x : R), β((algebraMap R β₯S) x) = β((algebraMap R β₯S) x)
|
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.isType2Type._sparseCasesOn_2
|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze
|
{motive : Lean.Expr β Sort u} β
(t : Lean.Expr) β ((u : Lean.Level) β motive (Lean.Expr.sort u)) β (t.ctorIdx β 3 β motive t) β motive t
|
Rat.instNormedField
|
Mathlib.Analysis.Normed.Field.Lemmas
|
NormedField β
|
sqrt_one_add_norm_sq_le
|
Mathlib.Analysis.SpecialFunctions.JapaneseBracket
|
β {E : Type u_1} [inst : NormedAddCommGroup E] (x : E), β(1 + βxβ ^ 2) β€ 1 + βxβ
|
instAddUInt32
|
Init.Data.UInt.Basic
|
Add UInt32
|
_private.Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact.0.AlgebraicGeometry.instHasAffinePropertyQuasiCompactCompactSpaceCarrierCarrierCommRingCat._simp_2
|
Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact
|
β {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s = CompactSpace βs
|
div_right_injective
|
Mathlib.Algebra.Group.Basic
|
β {G : Type u_3} [inst : Group G] {b : G}, Function.Injective fun a => b / a
|
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow._proof_1_3
|
Init.Data.Nat.Bitwise.Lemmas
|
β {n m : β}, m < n β Β¬m β€ n β False
|
Prod.mk_le_mk._simp_1
|
Mathlib.Order.Basic
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : LE Ξ±] [inst_1 : LE Ξ²] {aβ aβ : Ξ±} {bβ bβ : Ξ²},
((aβ, bβ) β€ (aβ, bβ)) = (aβ β€ aβ β§ bβ β€ bβ)
|
_private.Init.Data.UInt.Lemmas.0.UInt32.ofNat_mul._simp_1_1
|
Init.Data.UInt.Lemmas
|
β (a : β) (b : UInt32), (UInt32.ofNat a = b) = (a % 2 ^ 32 = b.toNat)
|
Lean.FileMap.lineStart
|
Lean.Data.Position
|
Lean.FileMap β β β String.Pos.Raw
|
SimpleGraph.isNIndepSet_iff
|
Mathlib.Combinatorics.SimpleGraph.Clique
|
β {Ξ± : Type u_1} (G : SimpleGraph Ξ±) (n : β) (s : Finset Ξ±), G.IsNIndepSet n s β G.IsIndepSet βs β§ s.card = n
|
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_natAdd_Icc._simp_1_1
|
Mathlib.Order.Interval.Finset.Fin
|
β {Ξ± : Type u_1} {sβ sβ : Finset Ξ±}, (sβ = sβ) = (βsβ = βsβ)
|
CategoryTheory.Functor.LaxMonoidal.ΞΌ_whiskerRight_comp_ΞΌ_assoc
|
Mathlib.CategoryTheory.Monoidal.Functor
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type uβ}
[inst_2 : CategoryTheory.Category.{vβ, uβ} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z) βΆ
Z_1),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Functor.LaxMonoidal.ΞΌ F X Y) (F.obj Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.ΞΌ F (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (CategoryTheory.Functor.LaxMonoidal.ΞΌ F Y Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.ΞΌ F X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z))
(CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv) h)))
|
Nat.gcd_sub_right_right_of_dvd
|
Init.Data.Nat.Gcd
|
β {m k : β} (n : β), k β€ m β n β£ k β n.gcd (m - k) = n.gcd m
|
Trivialization.pullback._proof_1
|
Mathlib.Topology.FiberBundle.Constructions
|
β {B : Type u_4} {F : Type u_2} {E : B β Type u_3} {B' : Type u_1} [inst : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_1 : TopologicalSpace F] [inst_2 : TopologicalSpace B] {K : Type u_5} [inst_3 : FunLike K B' B]
(e : Trivialization F Bundle.TotalSpace.proj) (f : K),
β x β Bundle.Pullback.lift βf β»ΒΉ' e.source,
(x.proj, (βe (Bundle.Pullback.lift (βf) x)).2) β (βf β»ΒΉ' e.baseSet) ΓΛ’ Set.univ
|
CategoryTheory.CategoryOfElements.fromStructuredArrow._proof_5
|
Mathlib.CategoryTheory.Elements
|
β {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (F : CategoryTheory.Functor C (Type u_2))
{X Y Z : CategoryTheory.StructuredArrow PUnit.{u_2 + 1} F} (f : X βΆ Y) (g : Y βΆ Z),
β¨(CategoryTheory.CategoryStruct.comp f g).right, β―β© = CategoryTheory.CategoryStruct.comp β¨f.right, β―β© β¨g.right, β―β©
|
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.{u_6, u_1} A]
[inst_1 : CategoryTheory.Category.{u_7, u_2} B] [inst_2 : CategoryTheory.Category.{u_8, u_3} C]
[inst_3 : CategoryTheory.Category.{u_5, 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 : β} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
βj < βi β Β¬βk < βi - 1 β βk + 1 < βj β Β¬βk < βj β Β¬βk + 1 < βi β β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
|
[email protected]._hygCtx._hyg.23
|
Lean.Elab.DocString.Builtin
|
TypeName Lean.Doc.Data.Option
|
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
|
_auto._@.Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat.2043895517._hygCtx._hyg.52
|
Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat
|
Lean.Syntax
|
_private.Mathlib.Data.Int.Init.0.Int.le_induction_down._proof_1_3
|
Mathlib.Data.Int.Init
|
β {m : β€} {motive : (n : β€) β n β€ m β Prop},
(β (n : β€) (hmn : n β€ m), motive n hmn β motive (n - 1) β―) β
β (n k : β€), m β€ k β (β (hmn : k β€ m), motive k hmn) β β (hle' : k + 1 β€ m), motive (k + 1) hle'
|
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_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : Mα΅α΅α΅ β+ Nα΅α΅α΅) (x y : M),
MulOpposite.unop ((βf β MulOpposite.op) (x + y)) =
MulOpposite.unop
{ unop' := (MulOpposite.unop β βf β MulOpposite.op) x + (MulOpposite.unop β βf β MulOpposite.op) 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})
|
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.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)
|
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_3} [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β}
{F : Type u_1} [inst_6 : FunLike F M Mβ] [SemilinearMapClass F Οββ M Mβ], AddMonoidHomClass F M Mβ
|
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 : β} [inst : DecidableEq Ξ±] (a : Ξ±) (m : Sym Ξ± n), Multiset.count a βm < 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
|
{k : Type u_1} β
{G : Type u_2} β
[inst : Zero k] β
{P : Sort u} β {x1 x2 : SkewMonoidAlgebra k G} β x1 = x2 β SkewMonoidAlgebra.noConfusionType P x1 x2
|
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]?
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.