name
string | module
string | type
string |
|---|---|---|
Mathlib.Tactic.ITauto.Proof.orImpL.sizeOf_spec
|
Mathlib.Tactic.ITauto
|
β (p : Mathlib.Tactic.ITauto.Proof), sizeOf p.orImpL = 1 + sizeOf p
|
Dense.eq_of_inner_right
|
Mathlib.Analysis.InnerProductSpace.Projection.Submodule
|
β {π : Type u_1} {E : Type u_2} [inst : RCLike π] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
{K : Submodule π E} {x y : E}, Dense βK β (β (v : β₯K), inner π (βv) x = inner π (βv) y) β x = y
|
FermatLastTheoremForThreeGen.Solution.toSolution'
|
Mathlib.NumberTheory.FLT.Three
|
{K : Type u_1} β
[inst : Field K] β
{ΞΆ : K} β
{hΞΆ : IsPrimitiveRoot ΞΆ 3} β FermatLastTheoremForThreeGen.Solution hΞΆ β FermatLastTheoremForThreeGen.Solution' hΞΆ
|
iteratedDerivWithin_add
|
Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace π F] {n : β} {x : π} {s : Set π},
x β s β
UniqueDiffOn π s β
β {f g : π β F},
ContDiffWithinAt π (βn) f s x β
ContDiffWithinAt π (βn) g s x β
iteratedDerivWithin n (f + g) s x = iteratedDerivWithin n f s x + iteratedDerivWithin n g s x
|
MeasureTheory.lintegral_def
|
Mathlib.MeasureTheory.Integral.Lebesgue.Basic
|
β {Ξ± : Type u_4} {m : MeasurableSpace Ξ±} (ΞΌ : MeasureTheory.Measure Ξ±) (f : Ξ± β ENNReal),
MeasureTheory.lintegral ΞΌ f = β¨ g, β¨ (_ : βg β€ f), g.lintegral ΞΌ
|
Polynomial.Splits.X_pow
|
Mathlib.Algebra.Polynomial.Factors
|
β {R : Type u_1} [inst : Semiring R] (n : β), (Polynomial.X ^ n).Splits
|
Lean.Compiler.LCNF.Phase.le_refl._simp_1
|
Lean.Compiler.LCNF.PassManager
|
β (p : Lean.Compiler.LCNF.Phase), (p β€ p) = True
|
ENNReal.continuousAt_const_mul
|
Mathlib.Topology.Instances.ENNReal.Lemmas
|
β {a b : ENNReal}, a β β€ β¨ b β 0 β ContinuousAt (fun x => a * x) b
|
DirectSum.Decomposition.mk.noConfusion
|
Mathlib.Algebra.DirectSum.Decomposition
|
{ΞΉ : Type u_1} β
{M : Type u_3} β
{Ο : Type u_4} β
[inst : DecidableEq ΞΉ] β
[inst_1 : AddCommMonoid M] β
[inst_2 : SetLike Ο M] β
[inst_3 : AddSubmonoidClass Ο M] β
{β³ : ΞΉ β Ο} β
(P : Sort u) β
(decompose' : M β DirectSum ΞΉ fun i => β₯(β³ i)) β
(left_inv : Function.LeftInverse (β(DirectSum.coeAddMonoidHom β³)) decompose') β
(right_inv : Function.RightInverse (β(DirectSum.coeAddMonoidHom β³)) decompose') β
(decompose'' : M β DirectSum ΞΉ fun i => β₯(β³ i)) β
(left_inv' : Function.LeftInverse (β(DirectSum.coeAddMonoidHom β³)) decompose'') β
(right_inv' : Function.RightInverse (β(DirectSum.coeAddMonoidHom β³)) decompose'') β
{ decompose' := decompose', left_inv := left_inv, right_inv := right_inv } =
{ decompose' := decompose'', left_inv := left_inv', right_inv := right_inv' } β
(decompose' = decompose'' β P) β P
|
intervalIntegral.FTCFilter.le_nhds
|
Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus
|
β {a : outParam β} (outer : Filter β) {inner : outParam (Filter β)} [self : intervalIntegral.FTCFilter a outer inner],
inner β€ nhds a
|
Mathlib.Meta.Positivity.evalNNRealSqrt
|
Mathlib.Data.Real.Sqrt
|
Mathlib.Meta.Positivity.PositivityExt
|
Submonoid.units._proof_2
|
Mathlib.Algebra.Group.Submonoid.Units
|
β {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : MΛ£},
x β (Submonoid.comap (Units.coeHom M) S β (Submonoid.comap (Units.coeHom M) S)β»ΒΉ).carrier β
xβ»ΒΉ β β(Submonoid.comap (Units.coeHom M) S) β§ xβ»ΒΉ β β(Submonoid.comap (Units.coeHom M) S)β»ΒΉ
|
Order.isPredLimitRecOn_pred_of_not_isMin
|
Mathlib.Order.SuccPred.Limit
|
β {Ξ± : Type u_1} {b : Ξ±} {motive : Ξ± β Sort u_2} [inst : LinearOrder Ξ±] [inst_1 : PredOrder Ξ±]
(isMax : (a : Ξ±) β IsMax a β motive a) (pred : (a : Ξ±) β Β¬IsMin a β motive (Order.pred a))
(isPredLimit : (a : Ξ±) β Order.IsPredLimit a β motive a) (hb : Β¬IsMin b),
Order.isPredLimitRecOn (Order.pred b) isMax pred isPredLimit = pred b hb
|
CategoryTheory.ObjectProperty.isSeparating_unop_iff
|
Mathlib.CategoryTheory.Generator.Basic
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] (P : CategoryTheory.ObjectProperty Cα΅α΅),
P.unop.IsSeparating β P.IsCoseparating
|
Std.DTreeMap.Internal.Impl.get?β_eq_getValueCast?
|
Std.Data.DTreeMap.Internal.WF.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} [inst : Ord Ξ±] [inst_1 : Std.TransOrd Ξ±] [inst_2 : Std.LawfulEqOrd Ξ±] [inst_3 : BEq Ξ±]
[inst_4 : Std.LawfulBEqOrd Ξ±] {k : Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²},
t.Ordered β t.get?β k = Std.Internal.List.getValueCast? k t.toListModel
|
MeasureTheory.SignedMeasure.null_of_totalVariation_zero
|
Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan
|
β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±] (s : MeasureTheory.SignedMeasure Ξ±) {i : Set Ξ±},
s.totalVariation i = 0 β βs i = 0
|
Module.Free.chooseBasis._proof_1
|
Mathlib.LinearAlgebra.FreeModule.Basic
|
β (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M], Nonempty (Module.Basis (ββ―.choose) R M)
|
Affine.Simplex.excenterWeights_compl
|
Mathlib.Geometry.Euclidean.Incenter
|
β {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : β} [inst_4 : NeZero n] (s : Affine.Simplex β P n) (signs : Finset (Fin (n + 1))),
s.excenterWeights signsαΆ = s.excenterWeights signs
|
_private.Mathlib.NumberTheory.SumFourSquares.0.Int.sq_add_sq_of_two_mul_sq_add_sq._simp_1_1
|
Mathlib.NumberTheory.SumFourSquares
|
β {Ξ± : Type u_2} [inst : Semiring Ξ±] {a : Ξ±}, (2 β£ a) = Even a
|
Representation.Coinvariants.hom_ext_iff
|
Mathlib.RepresentationTheory.Coinvariants
|
β {k : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommRing k] [inst_1 : Monoid G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
{Ο : Representation k G V} {f g : Ο.Coinvariants ββ[k] W},
f = g β f ββ Representation.Coinvariants.mk Ο = g ββ Representation.Coinvariants.mk Ο
|
ValuativeRel.IsRankLeOne.mk
|
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
|
β {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R],
Nonempty (ValuativeRel.RankLeOneStruct R) β ValuativeRel.IsRankLeOne R
|
Function.Antiperiodic.funext'
|
Mathlib.Algebra.Ring.Periodic
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β Ξ²} {c : Ξ±} [inst : Add Ξ±] [inst_1 : InvolutiveNeg Ξ²],
Function.Antiperiodic f c β (fun x => -f (x + c)) = f
|
Array.getElem?_zip_eq_some
|
Init.Data.Array.Zip
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {as : Array Ξ±} {bs : Array Ξ²} {z : Ξ± Γ Ξ²} {i : β},
(as.zip bs)[i]? = some z β as[i]? = some z.1 β§ bs[i]? = some z.2
|
Std.TreeMap.Raw.maxKey!_insert
|
Std.Data.TreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.TreeMap.Raw Ξ± Ξ² cmp} [Std.TransCmp cmp]
[inst : Inhabited Ξ±],
t.WF β β {k : Ξ±} {v : Ξ²}, (t.insert k v).maxKey! = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k'
|
FirstOrder.Language.PartialEquiv.mk.injEq
|
Mathlib.ModelTheory.PartialEquiv
|
β {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(dom : L.Substructure M) (cod : L.Substructure N) (toEquiv : L.Equiv β₯dom β₯cod) (dom_1 : L.Substructure M)
(cod_1 : L.Substructure N) (toEquiv_1 : L.Equiv β₯dom_1 β₯cod_1),
({ dom := dom, cod := cod, toEquiv := toEquiv } = { dom := dom_1, cod := cod_1, toEquiv := toEquiv_1 }) =
(dom = dom_1 β§ cod = cod_1 β§ toEquiv β toEquiv_1)
|
CategoryTheory.Functor.whiskeringRight._proof_1
|
Mathlib.CategoryTheory.Whiskering
|
β (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (E : Type u_6) [inst_2 : CategoryTheory.Category.{u_5, u_6} E]
(H : CategoryTheory.Functor D E) (X : CategoryTheory.Functor C D),
CategoryTheory.Functor.whiskerRight (CategoryTheory.CategoryStruct.id X) H =
CategoryTheory.CategoryStruct.id (X.comp H)
|
Std.TreeMap.keys.eq_1
|
Std.Data.TreeSet.Iterator
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} (t : Std.TreeMap Ξ± Ξ² cmp), t.keys = t.inner.keys
|
ProbabilityTheory.iIndepFun.indepFun_finset_sum_of_not_memβ
|
Mathlib.Probability.Independence.Basic
|
β {Ξ© : Type u_1} {ΞΉ : Type u_2} {_mΞ© : MeasurableSpace Ξ©} {ΞΌ : MeasureTheory.Measure Ξ©} {Ξ² : Type u_10}
{m : MeasurableSpace Ξ²} [inst : AddCommMonoid Ξ²] [MeasurableAddβ Ξ²] {f : ΞΉ β Ξ© β Ξ²},
ProbabilityTheory.iIndepFun f ΞΌ β
(β (i : ΞΉ), AEMeasurable (f i) ΞΌ) β
β {s : Finset ΞΉ} {i : ΞΉ}, i β s β ProbabilityTheory.IndepFun (β j β s, f j) (f i) ΞΌ
|
List.unattach_append
|
Init.Data.List.Attach
|
β {Ξ± : Type u_1} {p : Ξ± β Prop} {lβ lβ : List { x // p x }}, (lβ ++ lβ).unattach = lβ.unattach ++ lβ.unattach
|
TopologicalSpace.Opens.coe_eq_univ._simp_1
|
Mathlib.Topology.Sets.Opens
|
β {Ξ± : Type u_2} [inst : TopologicalSpace Ξ±] {U : TopologicalSpace.Opens Ξ±}, (βU = Set.univ) = (U = β€)
|
AddMonoidAlgebra.sup_support_list_prod_le
|
Mathlib.Algebra.MonoidAlgebra.Degree
|
β {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : SemilatticeSup B] [inst_1 : OrderBot B] [inst_2 : Semiring R]
[inst_3 : AddMonoid A] [inst_4 : AddMonoid B] [AddLeftMono B] [AddRightMono B] {degb : A β B},
degb 0 β€ 0 β
(β (a b : A), degb (a + b) β€ degb a + degb b) β
β (l : List (AddMonoidAlgebra R A)), l.prod.support.sup degb β€ (List.map (fun f => f.support.sup degb) l).sum
|
Primrec.fst
|
Mathlib.Computability.Primrec
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : Primcodable Ξ±] [inst_1 : Primcodable Ξ²], Primrec Prod.fst
|
_private.Mathlib.Data.List.InsertIdx.0.List.take_eraseIdx_eq_take_of_le._proof_1_1
|
Mathlib.Data.List.InsertIdx
|
β {Ξ± : Type u_1} (l : List Ξ±) (i j : β), i β€ j β (List.take i (l.eraseIdx j)).length = (List.take i l).length
|
Mathlib.Linter.linter.upstreamableDecl.private
|
Mathlib.Tactic.Linter.UpstreamableDecl
|
Lean.Option Bool
|
QuadraticMap.proj_apply
|
Mathlib.LinearAlgebra.QuadraticForm.Basic
|
β {R : Type u_3} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] {n : Type u_9} (i j : n) (x : n β A),
(QuadraticMap.proj i j) x = x i * x j
|
UInt8.xor_right_inj
|
Init.Data.UInt.Bitwise
|
β {a b : UInt8} (c : UInt8), c ^^^ a = c ^^^ b β a = b
|
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.instInhabitedStartsWithResult
|
Lean.Meta.Tactic.Grind.AC.Seq
|
Inhabited Lean.Grind.AC.StartsWithResultβ
|
AbsoluteValue.casesOn
|
Mathlib.Algebra.Order.AbsoluteValue.Basic
|
{R : Type u_5} β
{S : Type u_6} β
[inst : Semiring R] β
[inst_1 : Semiring S] β
[inst_2 : PartialOrder S] β
{motive : AbsoluteValue R S β Sort u} β
(t : AbsoluteValue R S) β
((toMulHom : R ββ* S) β
(nonneg' : β (x : R), 0 β€ toMulHom.toFun x) β
(eq_zero' : β (x : R), toMulHom.toFun x = 0 β x = 0) β
(add_le' : β (x y : R), toMulHom.toFun (x + y) β€ toMulHom.toFun x + toMulHom.toFun y) β
motive { toMulHom := toMulHom, nonneg' := nonneg', eq_zero' := eq_zero', add_le' := add_le' }) β
motive t
|
Aesop.GoalId.mk
|
Aesop.Tree.Data
|
β β Aesop.GoalId
|
Lean.mkPropEq
|
Lean.Expr
|
Lean.Expr β Lean.Expr β Lean.Expr
|
Lean.Elab.Term.elabWaitIfContainsMVar._regBuiltin.Lean.Elab.Term.elabWaitIfContainsMVar_1
|
Lean.Elab.BuiltinTerm
|
IO Unit
|
CochainComplex.HomComplex.Ξ΄_comp_zero_cochain
|
Mathlib.Algebra.Homology.HomotopyCategory.HomComplex
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G K : CochainComplex C β€} {nβ : β€} (zβ : CochainComplex.HomComplex.Cochain F G nβ)
(zβ : CochainComplex.HomComplex.Cochain G K 0) (mβ : β€) (hβ : nβ + 1 = mβ),
CochainComplex.HomComplex.Ξ΄ nβ mβ (zβ.comp zβ β―) =
zβ.comp (CochainComplex.HomComplex.Ξ΄ 0 1 zβ) hβ + (CochainComplex.HomComplex.Ξ΄ nβ mβ zβ).comp zβ β―
|
CompTriple.instIsIdId
|
Mathlib.Logic.Function.CompTypeclasses
|
β {M : Type u_1}, CompTriple.IsId id
|
SimpleGraph.Walk.support_concat
|
Mathlib.Combinatorics.SimpleGraph.Walks.Operations
|
β {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w),
(p.concat h).support = p.support.concat w
|
left_lt_sup._simp_3
|
Mathlib.Order.Lattice
|
β {Ξ± : Type u} [inst : SemilatticeSup Ξ±] {a b : Ξ±}, (a < a β b) = Β¬b β€ a
|
CategoryTheory.Limits.pullbackConeOfRightIso_Ο_app_none
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X βΆ Z) (g : Y βΆ Z)
[inst_1 : CategoryTheory.IsIso g], (CategoryTheory.Limits.pullbackConeOfRightIso f g).Ο.app none = f
|
List.Vector.snoc.eq_1
|
Mathlib.Data.Vector.Snoc
|
β {Ξ± : Type u_1} {n : β} (xs : List.Vector Ξ± n) (x : Ξ±), xs.snoc x = xs ++ x ::α΅₯ List.Vector.nil
|
Finsupp.equivMapDomain.eq_1
|
Mathlib.Data.Finsupp.Basic
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {M : Type u_5} [inst : Zero M] (f : Ξ± β Ξ²) (l : Ξ± ββ M),
Finsupp.equivMapDomain f l =
{ support := Finset.map f.toEmbedding l.support, toFun := fun a => l (f.symm a), mem_support_toFun := β― }
|
AlgHom.ext
|
Mathlib.Algebra.Algebra.Hom
|
β {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {Οβ Οβ : A ββ[R] B}, (β (x : A), Οβ x = Οβ x) β Οβ = Οβ
|
Associated.instIsTrans
|
Mathlib.Algebra.GroupWithZero.Associated
|
β {M : Type u_1} [inst : Monoid M], IsTrans M Associated
|
IsFiniteLength.brecOn
|
Mathlib.RingTheory.FiniteLength
|
β {R : Type u_1} [inst : Ring R]
{motive : (M : Type u_2) β [inst_1 : AddCommGroup M] β [inst_2 : Module R M] β IsFiniteLength R M β Prop}
{M : Type u_2} {inst_1 : AddCommGroup M} {inst_2 : Module R M} (t : IsFiniteLength R M),
(β (M : Type u_2) [inst_3 : AddCommGroup M] [inst_4 : Module R M] (t : IsFiniteLength R M),
IsFiniteLength.below t β motive M t) β
motive M t
|
Int.ModEq.of_mul_right
|
Mathlib.Data.Int.ModEq
|
β {n a b : β€} (m : β€), a β‘ b [ZMOD n * m] β a β‘ b [ZMOD n]
|
Std.Notify.wait
|
Std.Sync.Notify
|
Std.Notify β IO (Std.Internal.IO.Async.AsyncTask Unit)
|
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_id._simp_1_1
|
Mathlib.CategoryTheory.Bicategory.CatEnriched
|
β {Ξ± : Sort u_1} (a b : Ξ±), (a = b) = (a β b)
|
Matrix.mulVec_surjective_iff_isUnit
|
Mathlib.LinearAlgebra.Matrix.NonsingularInverse
|
β {m : Type u} [inst : DecidableEq m] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Fintype m] {A : Matrix m m R},
Function.Surjective A.mulVec β IsUnit A
|
_private.Mathlib.Data.Nat.Factorization.PrimePow.0.isPrimePow_iff_card_primeFactors_eq_one._simp_1_2
|
Mathlib.Data.Nat.Factorization.PrimePow
|
β (n : β), n.primeFactors = n.factorization.support
|
exterior_eq_iff_isOpen
|
Mathlib.Topology.AlexandrovDiscrete
|
β {Ξ± : Type u_3} [inst : TopologicalSpace Ξ±] [AlexandrovDiscrete Ξ±] {s : Set Ξ±}, nhdsKer s = s β IsOpen s
|
StrictConvexSpace.of_norm_add_ne_two
|
Mathlib.Analysis.Convex.StrictConvexSpace
|
β {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E],
(β β¦x y : Eβ¦, βxβ = 1 β βyβ = 1 β x β y β βx + yβ β 2) β StrictConvexSpace β E
|
CompHausLike.LocallyConstant.adjunction
|
Mathlib.Condensed.Discrete.LocallyConstant
|
(P : TopCat β Prop) β
[β (S : CompHausLike P) (p : βS.toTop β Prop), CompHausLike.HasProp P (Subtype p)] β
[inst : CompHausLike.HasProp P PUnit.{u + 1}] β
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P] β
[inst_2 : CompHausLike.HasExplicitPullbacks P] β
(hs :
β β¦X Y : CompHausLike Pβ¦ (f : X βΆ Y),
CategoryTheory.EffectiveEpi f β Function.Surjective β(CategoryTheory.ConcreteCategory.hom f)) β
[CompHausLike.HasExplicitFiniteCoproducts P] β
CompHausLike.LocallyConstant.functor P hs β£
(CategoryTheory.sheafSections (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w))).obj
(Opposite.op (CompHausLike.of P PUnit.{u + 1}))
|
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.pderiv_inr_universalFactorizationMap_X._proof_1_9
|
Mathlib.RingTheory.Polynomial.UniversalFactorizationRing
|
β (n k : β) (i : Fin k) (j : Fin n), βi β€ βj β β (a b : β), a + b = βj β Β¬(a = βj - βi β§ b = βi) β b < k β b β βi
|
Int.subNatNat_sub
|
Init.Data.Int.Lemmas
|
β {n m : β}, n β€ m β β (k : β), Int.subNatNat (m - n) k = Int.subNatNat m (k + n)
|
Manifold.Β«_aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termHasMFDerivAt%_______1Β»
|
Mathlib.Geometry.Manifold.Notation
|
Lean.Elab.Term.TermElab
|
Ordinal.veblen_left_monotone
|
Mathlib.SetTheory.Ordinal.Veblen
|
β (o : Ordinal.{u_1}), Monotone fun x => Ordinal.veblen x o
|
Ideal.primeHeight_eq_ringKrullDim_iff
|
Mathlib.RingTheory.Ideal.Height
|
β {R : Type u_1} [inst : CommRing R] [FiniteRingKrullDim R] [inst_2 : IsLocalRing R] {I : Ideal R} [inst_3 : I.IsPrime],
βI.primeHeight = ringKrullDim R β I = IsLocalRing.maximalIdeal R
|
Aesop.EqualUpToIdsM.Context._sizeOf_1
|
Aesop.Util.EqualUpToIds
|
Aesop.EqualUpToIdsM.Context β β
|
CategoryTheory.Lax.LaxTrans.StrongCore.mk.inj
|
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax
|
β {B : Type uβ} {inst : CategoryTheory.Bicategory B} {C : Type uβ} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {Ξ· : F βΆ G}
{naturality :
{a b : B} β
(f : a βΆ b) β
CategoryTheory.CategoryStruct.comp (Ξ·.app a) (G.map f) β
CategoryTheory.CategoryStruct.comp (F.map f) (Ξ·.app b)}
{naturality_hom :
autoParam (β {a b : B} (f : a βΆ b), (naturality f).hom = Ξ·.naturality f)
CategoryTheory.Lax.LaxTrans.StrongCore.naturality_hom._autoParam}
{naturality_1 :
{a b : B} β
(f : a βΆ b) β
CategoryTheory.CategoryStruct.comp (Ξ·.app a) (G.map f) β
CategoryTheory.CategoryStruct.comp (F.map f) (Ξ·.app b)}
{naturality_hom_1 :
autoParam (β {a b : B} (f : a βΆ b), (naturality_1 f).hom = Ξ·.naturality f)
CategoryTheory.Lax.LaxTrans.StrongCore.naturality_hom._autoParam},
{ naturality := naturality, naturality_hom := naturality_hom } =
{ naturality := naturality_1, naturality_hom := naturality_hom_1 } β
naturality = naturality_1
|
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_11
|
Batteries.Data.List.Lemmas
|
β {Ξ± : Type u_1} {i : β} {xs : List Ξ±} {x : Ξ±} [inst : BEq Ξ±],
i + 1 β€ (List.filter (fun x_1 => x_1 == x) xs).length β i < (List.filter (fun x_1 => x_1 == x) xs).length
|
AddConstMap.instMonoid
|
Mathlib.Algebra.AddConstMap.Basic
|
{G : Type u_1} β [inst : Add G] β {a : G} β Monoid (AddConstMap G G a a)
|
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_principal._simp_1_2
|
Mathlib.Order.Filter.Basic
|
β {Ξ± : Sort u_1} {p : Ξ± β Prop}, (Β¬β (x : Ξ±), p x) = β x, Β¬p x
|
AlternatingMap.mkContinuousAlternating._proof_6
|
Mathlib.Analysis.Normed.Module.Alternating.Basic
|
β {π : Type u_6} {E : Type u_1} {F : Type u_3} {G : Type u_4} {ΞΉ : Type u_2} [inst : NontriviallyNormedField π]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace π E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace π F] [inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace π G] [inst_7 : Fintype ΞΉ]
{ΞΉ' : Type u_5} [inst_8 : Fintype ΞΉ'] (f : E [β^ΞΉ]ββ[π] F [β^ΞΉ']ββ[π] G) (C : β)
(H : β (mβ : ΞΉ β E) (mβ : ΞΉ' β F), β(f mβ) mββ β€ (C * β i, βmβ iβ) * β i, βmβ iβ) (v : ΞΉ β E) (i j : ΞΉ),
v i = v j β i β j β (f v).mkContinuous (C * β i, βv iβ) β― = 0
|
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.applyAltStx
|
Lean.Elab.Tactic.Induction
|
Lean.Meta.ElimInfo β
Lean.Syntax β
β β
Array Lean.FVarId β
Array Lean.FVarId β
Array (Lean.Ident Γ Lean.FVarId) β
Array (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot) β
Array Lean.Syntax β β β Lean.Syntax β Lean.Elab.Tactic.ElimApp.Alt β Lean.Elab.Tactic.TacticM PUnit.{1}
|
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.Iterators.IterM.step_mapM.match_1_1
|
Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap
|
β {Ξ± Ξ² : Type u_1} {m : Type u_1 β Type u_2} {n : Type u_1 β Type u_3} [inst : Std.Iterators.Iterator Ξ± m Ξ²]
{it : Std.IterM m Ξ²} {Ξ³ : Type u_1} {f : Ξ² β n Ξ³} [inst_1 : Monad n] [inst_2 : MonadLiftT m n]
(motive : (Std.Iterators.IterM.mapM f it).internalState.inner.Step β Prop)
(x : (Std.Iterators.IterM.mapM f it).internalState.inner.Step),
(β (it' : Std.IterM m Ξ²) (out : Ξ²)
(h : (Std.Iterators.IterM.mapM f it).internalState.inner.IsPlausibleStep (Std.Iterators.IterStep.yield it' out)),
motive β¨Std.Iterators.IterStep.yield it' out, hβ©) β
(β (it' : Std.IterM m Ξ²)
(h : (Std.Iterators.IterM.mapM f it).internalState.inner.IsPlausibleStep (Std.Iterators.IterStep.skip it')),
motive β¨Std.Iterators.IterStep.skip it', hβ©) β
(β (h : (Std.Iterators.IterM.mapM f it).internalState.inner.IsPlausibleStep Std.Iterators.IterStep.done),
motive β¨Std.Iterators.IterStep.done, hβ©) β
motive x
|
Finset.compls_inter
|
Mathlib.Data.Finset.Sups
|
β {Ξ± : Type u_2} [inst : BooleanAlgebra Ξ±] [inst_1 : DecidableEq Ξ±] (s t : Finset Ξ±),
(s β© t).compls = s.compls β© t.compls
|
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.CFC.exists_measure_nnrpow_eq_integral_cfcβ_rpowIntegrandββ._proof_1_6
|
Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation
|
β (A : Type u_1) [inst : NonUnitalNormedRing A] [inst_1 : NormedSpace β A] [inst_2 : PartialOrder A]
[NonnegSpectrumClass β A] {p : NNReal} (ΞΌ : MeasureTheory.Measure β),
(β x β Set.Ici 0,
MeasureTheory.IntegrableOn (fun t => ((fun a => βa) p).rpowIntegrandββ t x) (Set.Ioi 0) ΞΌ β§
x ^ (fun a => βa) p = β« (t : β) in Set.Ioi 0, ((fun a => βa) p).rpowIntegrandββ t x βΞΌ) β
β (a : A),
0 β€ a β
Nontrivial A β
0 < βp β
0 β€ sSup (quasispectrum β a) β
ContinuousOn (Function.uncurry fun t => (βp).rpowIntegrandββ t) (Set.Ioi 0 ΓΛ’ quasispectrum β a) β
(βα΅ (t : β) βΞΌ.restrict (Set.Ioi 0),
β z β quasispectrum β a,
β(fun t => (βp).rpowIntegrandββ t) t zβ β€
(fun t => β(fun t => (βp).rpowIntegrandββ t) t (sSup (quasispectrum β a))β) t) β
MeasureTheory.HasFiniteIntegral
(fun t => β(fun t => (βp).rpowIntegrandββ t) t (sSup (quasispectrum β a))β)
(ΞΌ.restrict (Set.Ioi 0)) β
(βα΅ (x : β) βΞΌ.restrict (Set.Ioi 0), (βp).rpowIntegrandββ x 0 = 0) β
β r β quasispectrum β a, r β Set.Ici 0
|
add_neg_lt_iff_lt_add
|
Mathlib.Algebra.Order.Group.Unbundled.Basic
|
β {Ξ± : Type u} [inst : AddGroup Ξ±] [inst_1 : LT Ξ±] [AddRightStrictMono Ξ±] {a b c : Ξ±}, a + -b < c β a < c + b
|
instHasColimitsCommAlgCat
|
Mathlib.Algebra.Category.CommAlgCat.Basic
|
β {R : Type u} [inst : CommRing R], CategoryTheory.Limits.HasColimits (CommAlgCat R)
|
BoundedLatticeHom.toInfTopHom._proof_1
|
Mathlib.Order.Hom.BoundedLattice
|
β {Ξ± : Type u_2} {Ξ² : Type u_1} [inst : Lattice Ξ±] [inst_1 : Lattice Ξ²] [inst_2 : BoundedOrder Ξ±]
[inst_3 : BoundedOrder Ξ²] (f : BoundedLatticeHom Ξ± Ξ²) (a b : Ξ±), f.toFun (a β b) = f.toFun a β f.toFun b
|
BitVec.toInt_not
|
Init.Data.BitVec.Lemmas
|
β {w : β} {x : BitVec w}, (~~~x).toInt = (2 ^ w - 1 - βx.toNat).bmod (2 ^ w)
|
CategoryTheory.MorphismProperty.colimitsOfShape_discrete_le_llp_rlp
|
Mathlib.CategoryTheory.MorphismProperty.LiftingProperty
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C) (J : Type w),
T.colimitsOfShape (CategoryTheory.Discrete J) β€ T.rlp.llp
|
_private.Lean.Elab.Deriving.Nonempty.0.Lean.Elab.Deriving.initFn._@.Lean.Elab.Deriving.Nonempty.1889502729._hygCtx._hyg.2
|
Lean.Elab.Deriving.Nonempty
|
IO Unit
|
String.toList.eq_1
|
Init.Data.String.Basic
|
β (s : String), s.toList = (String.Internal.toArray s).toList
|
SchwartzMap.evalCLM._proof_3
|
Mathlib.Analysis.Distribution.SchwartzSpace
|
β {π : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup F] [inst_1 : NormedField π] [inst_2 : NormedSpace π F],
ContinuousConstSMul π F
|
CoxeterMatrix.ext
|
Mathlib.GroupTheory.Coxeter.Matrix
|
β {B : Type u_1} {x y : CoxeterMatrix B}, x.M = y.M β x = y
|
Invertible.mulRight
|
Mathlib.Algebra.Group.Invertible.Basic
|
{Ξ± : Type u} β [inst : Monoid Ξ±] β (a : Ξ±) β {b : Ξ±} β Invertible b β Invertible a β Invertible (a * b)
|
Multiset.right_notMem_Ioo
|
Mathlib.Order.Interval.Multiset
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] [inst_1 : LocallyFiniteOrder Ξ±] {a b : Ξ±}, b β Multiset.Ioo a b
|
_private.Lean.Server.FileWorker.SetupFile.0.Lean.Server.FileWorker.runLakeSetupFile._sparseCasesOn_1
|
Lean.Server.FileWorker.SetupFile
|
{motive : Lean.Lsp.DependencyBuildMode β Sort u} β
(t : Lean.Lsp.DependencyBuildMode) β motive Lean.Lsp.DependencyBuildMode.never β (t.ctorIdx β 2 β motive t) β motive t
|
WeierstrassCurve.coe_variableChange_Ξ'
|
Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange
|
β {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], β(C β’ W).Ξ' = βC.uβ»ΒΉ ^ 12 * βW.Ξ'
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearRupUnits
|
Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation
|
{n : β} β Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n β Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n
|
instDecidableEqZNum.decEq._proof_10
|
Mathlib.Data.Num.Basic
|
β (a b : PosNum), Β¬a = b β ZNum.neg a = ZNum.neg b β False
|
AbstractCompletion.closure_range
|
Mathlib.Topology.UniformSpace.AbstractCompletion
|
β {Ξ± : Type uΞ±} [inst : UniformSpace Ξ±] (pkg : AbstractCompletion.{vΞ±, uΞ±} Ξ±), closure (Set.range pkg.coe) = Set.univ
|
Lean.KVMap.entries
|
Lean.Data.KVMap
|
Lean.KVMap β List (Lean.Name Γ Lean.DataValue)
|
ULift.leftCancelMonoid.eq_1
|
Mathlib.Algebra.Group.ULift
|
β {Ξ± : Type u} [inst : LeftCancelMonoid Ξ±],
ULift.leftCancelMonoid = Function.Injective.leftCancelMonoid βEquiv.ulift β― β― β― β―
|
Aesop.LocalRuleSet.simprocsArray
|
Aesop.RuleSet
|
Aesop.LocalRuleSet β Array (Lean.Name Γ Lean.Meta.Simprocs)
|
isTotallyDisconnected_iff_lt
|
Mathlib.Topology.Order.IntermediateValue
|
β {Ξ± : Type u} [inst : ConditionallyCompleteLinearOrder Ξ±] [inst_1 : TopologicalSpace Ξ±] [OrderTopology Ξ±]
[DenselyOrdered Ξ±] {s : Set Ξ±}, IsTotallyDisconnected s β β x β s, β y β s, x < y β β z β s, z β Set.Ioo x y
|
LieModule.chainTop
|
Mathlib.Algebra.Lie.Weights.Chain
|
{R : Type u_1} β
{L : Type u_2} β
[inst : CommRing R] β
[inst_1 : LieRing L] β
[inst_2 : LieAlgebra R L] β
{M : Type u_3} β
[inst_3 : AddCommGroup M] β
[inst_4 : Module R M] β
[inst_5 : LieRingModule L M] β
[inst_6 : LieModule R L M] β
[inst_7 : LieRing.IsNilpotent L] β
[IsAddTorsionFree R] β
[NoZeroSMulDivisors R M] β
[IsNoetherian R M] β (L β R) β LieModule.Weight R L M β LieModule.Weight R L M
|
_private.Aesop.RPINF.0.Aesop.rpinfRaw.go
|
Aesop.RPINF
|
Lean.Expr β Aesop.BaseM Lean.Expr
|
_private.Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin.0.ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux._proof_10
|
Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin
|
β {π : Type u_1} [inst : NontriviallyNormedField π], RingHomCompTriple (RingHom.id π) (RingHom.id π) (RingHom.id π)
|
groupHomology.chainsβToCoinvariantsKer
|
Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree
|
{k G : Type u} β
[inst : CommRing k] β
[inst_1 : Group G] β
(A : Rep k G) β ModuleCat.of k (G ββ βA.V) βΆ ModuleCat.of k β₯(Representation.Coinvariants.ker A.Ο)
|
FreeSimplexQuiver.homRel.Ξ΄_comp_Ξ΄
|
Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic
|
β {n : β} {i j : Fin (n + 2)},
i β€ j β
FreeSimplexQuiver.homRel
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i.castSucc)))
|
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.wβ
|
Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X βΆ Y} {f : F.obj β₯ βΆ X}
{g : c.pt βΆ Y} {j : J} (self : CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct c p f g j),
CategoryTheory.CategoryStruct.comp self.f' p = CategoryTheory.CategoryStruct.comp (c.ΞΉ.app j) g
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.