name
string | module
string | type
string |
|---|---|---|
Polynomial.instIsJacobsonRing
|
Mathlib.RingTheory.Jacobson.Ring
|
β {R : Type u_1} [inst : CommRing R] [IsJacobsonRing R], IsJacobsonRing (Polynomial R)
|
fintypeNodupList._simp_3
|
Mathlib.Data.Fintype.List
|
β {Ξ± : Type u_1} {a : Ξ±} {s : Multiset Ξ±} {nd : s.Nodup}, (a β { val := s, nodup := nd }) = (a β s)
|
LinearMap.ofIsComplProdEquiv._proof_2
|
Mathlib.LinearAlgebra.Projection
|
β {E : Type u_2} [inst : AddCommGroup E] {F : Type u_1} [inst_1 : AddCommGroup F] {Rβ : Type u_3} [inst_2 : CommRing Rβ]
[inst_3 : Module Rβ E] [inst_4 : Module Rβ F] {p q : Submodule Rβ E} (h : IsCompl p q)
(Ο : (β₯p ββ[Rβ] F) Γ (β₯q ββ[Rβ] F)),
(((LinearMap.ofIsComplProd h).toFun Ο).domRestrict p, ((LinearMap.ofIsComplProd h).toFun Ο).domRestrict q) = Ο
|
IsRelPrime.neg_right
|
Mathlib.RingTheory.Coprime.Basic
|
β {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y β IsRelPrime x (-y)
|
Mathlib.Tactic.BicategoryLike.IsoLift.mk._flat_ctor
|
Mathlib.Tactic.CategoryTheory.Coherence.Datatypes
|
Mathlib.Tactic.BicategoryLike.MorβIso β Lean.Expr β Mathlib.Tactic.BicategoryLike.IsoLift
|
Representation.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice.match_1
|
Mathlib.RepresentationTheory.Submodule
|
β {k : Type u_2} {G : Type u_3} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (Ο : Representation k G V) (motive : β₯Ο.invtSubmodule β Prop) (x : β₯Ο.invtSubmodule),
(β (p : Submodule k V) (hp : p β Ο.invtSubmodule), motive β¨p, hpβ©) β motive x
|
Equiv.Perm.IsCycle.zpowersEquivSupport.congr_simp
|
Mathlib.GroupTheory.Perm.Cycle.Basic
|
β {Ξ± : Type u_2} [inst : DecidableEq Ξ±] [inst_1 : Fintype Ξ±] {Ο : Equiv.Perm Ξ±} (hΟ : Ο.IsCycle),
hΟ.zpowersEquivSupport = hΟ.zpowersEquivSupport
|
ModelWithCorners.continuous_invFun
|
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] (self : ModelWithCorners π E H),
Continuous self.invFun
|
Std.TreeMap.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem
|
Std.Data.TreeMap.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {t : Std.TreeMap Ξ± Unit cmp} [Std.TransCmp cmp] {l : List Ξ±} {k k' : Ξ±},
cmp k k' = Ordering.eq β
k β t β List.Pairwise (fun a b => Β¬cmp a b = Ordering.eq) l β k β l β (t.insertManyIfNewUnit l).getKey? k' = some k
|
AlgEquiv.autCongr_trans
|
Mathlib.Algebra.Algebra.Equiv
|
β {R : Type uR} {Aβ : Type uAβ} {Aβ : Type uAβ} {Aβ : Type uAβ} [inst : CommSemiring R] [inst_1 : Semiring Aβ]
[inst_2 : Semiring Aβ] [inst_3 : Semiring Aβ] [inst_4 : Algebra R Aβ] [inst_5 : Algebra R Aβ] [inst_6 : Algebra R Aβ]
(Ο : Aβ ββ[R] Aβ) (Ο : Aβ ββ[R] Aβ), Ο.autCongr.trans Ο.autCongr = (Ο.trans Ο).autCongr
|
Set.image_subset_iff
|
Mathlib.Data.Set.Image
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {s : Set Ξ±} {t : Set Ξ²} {f : Ξ± β Ξ²}, f '' s β t β s β f β»ΒΉ' t
|
AlgebraicGeometry.Scheme.Opens.fromSpecStalkOfMem_toSpecΞ_assoc
|
Mathlib.AlgebraicGeometry.Stalk
|
β {X : AlgebraicGeometry.Scheme} (U : X.Opens) (x : β₯X) (hxU : x β U) {Z : AlgebraicGeometry.Scheme}
(h : AlgebraicGeometry.Spec (X.presheaf.obj (Opposite.op U)) βΆ Z),
CategoryTheory.CategoryStruct.comp (U.fromSpecStalkOfMem x hxU) (CategoryTheory.CategoryStruct.comp U.toSpecΞ h) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (X.presheaf.germ U x hxU)) h
|
ISize
|
Init.Data.SInt.Basic
|
Type
|
ContinuousMap.Homotopy.affine_apply
|
Mathlib.Topology.Homotopy.Affine
|
β {X : Type u_1} {E : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : IsTopologicalAddGroup E] [inst_4 : Module β E] [inst_5 : ContinuousSMul β E] (f g : C(X, E))
(x : βunitInterval Γ X), (ContinuousMap.Homotopy.affine f g) x = (AffineMap.lineMap (f x.2) (g x.2)) βx.1
|
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.constrToProp.match_3
|
Lean.Meta.MkIffOfInductiveProp
|
(motive : Option β Γ Lean.Expr β Sort u_1) β
(__discr : Option β Γ Lean.Expr) β ((n : Option β) β (r : Lean.Expr) β motive (n, r)) β motive __discr
|
TensorProduct.Neg.aux
|
Mathlib.LinearAlgebra.TensorProduct.Basic
|
(R : Type u_1) β
[inst : CommSemiring R] β
{M : Type u_2} β
{N : Type u_3} β
[inst_1 : AddCommGroup M] β
[inst_2 : AddCommMonoid N] β
[inst_3 : Module R M] β [inst_4 : Module R N] β TensorProduct R M N ββ[R] TensorProduct R M N
|
CategoryTheory.eqToIso
|
Mathlib.CategoryTheory.EqToHom
|
{C : Type uβ} β [inst : CategoryTheory.Category.{vβ, uβ} C] β {X Y : C} β X = Y β (X β
Y)
|
Lean.Elab.instInhabitedDefView
|
Lean.Elab.DefView
|
Inhabited Lean.Elab.DefView
|
ZMod.charZero
|
Mathlib.Data.ZMod.Basic
|
CharZero (ZMod 0)
|
ENNReal.tendsto_inv_iff
|
Mathlib.Topology.Instances.ENNReal.Lemmas
|
β {Ξ± : Type u_1} {f : Filter Ξ±} {m : Ξ± β ENNReal} {a : ENNReal},
Filter.Tendsto (fun x => (m x)β»ΒΉ) f (nhds aβ»ΒΉ) β Filter.Tendsto m f (nhds a)
|
Besicovitch.SatelliteConfig.mk.inj
|
Mathlib.MeasureTheory.Covering.Besicovitch
|
β {Ξ± : Type u_1} {inst : MetricSpace Ξ±} {N : β} {Ο : β} {c : Fin N.succ β Ξ±} {r : Fin N.succ β β}
{rpos : β (i : Fin N.succ), 0 < r i}
{h : Pairwise fun i j => r i β€ dist (c i) (c j) β§ r j β€ Ο * r i β¨ r j β€ dist (c j) (c i) β§ r i β€ Ο * r j}
{hlast : β i < Fin.last N, r i β€ dist (c i) (c (Fin.last N)) β§ r (Fin.last N) β€ Ο * r i}
{inter : β i < Fin.last N, dist (c i) (c (Fin.last N)) β€ r i + r (Fin.last N)} {c_1 : Fin N.succ β Ξ±}
{r_1 : Fin N.succ β β} {rpos_1 : β (i : Fin N.succ), 0 < r_1 i}
{h_1 :
Pairwise fun i j =>
r_1 i β€ dist (c_1 i) (c_1 j) β§ r_1 j β€ Ο * r_1 i β¨ r_1 j β€ dist (c_1 j) (c_1 i) β§ r_1 i β€ Ο * r_1 j}
{hlast_1 : β i < Fin.last N, r_1 i β€ dist (c_1 i) (c_1 (Fin.last N)) β§ r_1 (Fin.last N) β€ Ο * r_1 i}
{inter_1 : β i < Fin.last N, dist (c_1 i) (c_1 (Fin.last N)) β€ r_1 i + r_1 (Fin.last N)},
{ c := c, r := r, rpos := rpos, h := h, hlast := hlast, inter := inter } =
{ c := c_1, r := r_1, rpos := rpos_1, h := h_1, hlast := hlast_1, inter := inter_1 } β
c = c_1 β§ r = r_1
|
ProbabilityTheory.Kernel.withDensity_rnDeriv_of_subset_mutuallySingularSetSlice
|
Mathlib.Probability.Kernel.RadonNikodym
|
β {Ξ± : Type u_1} {Ξ³ : Type u_2} {mΞ± : MeasurableSpace Ξ±} {mΞ³ : MeasurableSpace Ξ³} {ΞΊ Ξ· : ProbabilityTheory.Kernel Ξ± Ξ³}
[hΞ±Ξ³ : MeasurableSpace.CountableOrCountablyGenerated Ξ± Ξ³] [ProbabilityTheory.IsFiniteKernel ΞΊ]
[inst : ProbabilityTheory.IsFiniteKernel Ξ·] {a : Ξ±} {s : Set Ξ³},
s β ΞΊ.mutuallySingularSetSlice Ξ· a β ((Ξ·.withDensity (ΞΊ.rnDeriv Ξ·)) a) s = 0
|
Hindman.FS.brecOn
|
Mathlib.Combinatorics.Hindman
|
β {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) β (a_1 : M) β Hindman.FS a a_1 β Prop}
{a : Stream' M} {a_1 : M} (t : Hindman.FS a a_1),
(β (a : Stream' M) (a_2 : M) (t : Hindman.FS a a_2), Hindman.FS.below t β motive a a_2 t) β motive a a_1 t
|
Lean.PersistentHashMap.Entry.ctorElimType
|
Lean.Data.PersistentHashMap
|
{Ξ± : Type u} β
{Ξ² : Type v} β
{Ο : Type w} β
{motive : Lean.PersistentHashMap.Entry Ξ± Ξ² Ο β Sort u_1} β
β β Sort (max 1 u_1 (imax (u + 1) (v + 1) u_1) (imax (w + 1) u_1))
|
SimpleGraph.TripartiteFromTriangles.Graph.inββ_iff._simp_1
|
Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {t : Finset (Ξ± Γ Ξ² Γ Ξ³)} {b : Ξ²} {c : Ξ³},
(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.inβ c) (Sum3.inβ b) = β a, (a, b, c) β t
|
GradeMinOrder.recOn
|
Mathlib.Order.Grade
|
{π : Type u_5} β
{Ξ± : Type u_6} β
[inst : Preorder π] β
[inst_1 : Preorder Ξ±] β
{motive : GradeMinOrder π Ξ± β Sort u} β
(t : GradeMinOrder π Ξ±) β
([toGradeOrder : GradeOrder π Ξ±] β
(isMin_grade : β β¦a : Ξ±β¦, IsMin a β IsMin (GradeOrder.grade a)) β
motive { toGradeOrder := toGradeOrder, isMin_grade := isMin_grade }) β
motive t
|
Aesop.RulePatternIndex.recOn
|
Aesop.Index.RulePattern
|
{motive : Aesop.RulePatternIndex β Sort u} β
(t : Aesop.RulePatternIndex) β
((tree : Lean.Meta.DiscrTree Aesop.RulePatternIndex.Entry) β
(isEmpty : Bool) β motive { tree := tree, isEmpty := isEmpty }) β
motive t
|
CategoryTheory.GrothendieckTopology.instIsGeneratedByOneHypercovers
|
Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C),
J.IsGeneratedByOneHypercovers
|
_private.Mathlib.Order.OrderIsoNat.0.RelEmbedding.wellFounded_iff_isEmpty.match_1_1
|
Mathlib.Order.OrderIsoNat
|
β {Ξ± : Type u_1} {r : Ξ± β Ξ± β Prop} (motive : WellFounded r β Prop) (x : WellFounded r),
(β (h : β (a : Ξ±), Acc r a), motive β―) β motive x
|
Polynomial.Chebyshev.S_two_mul_complex_cosh
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev
|
β (ΞΈ : β) (n : β€),
Polynomial.eval (2 * Complex.cosh ΞΈ) (Polynomial.Chebyshev.S β n) * Complex.sinh ΞΈ = Complex.sinh ((βn + 1) * ΞΈ)
|
NumberField.InfinitePlace.embedding_of_isReal_apply
|
Mathlib.NumberTheory.NumberField.InfinitePlace.Basic
|
β {K : Type u_2} [inst : Field K] {w : NumberField.InfinitePlace K} (hw : w.IsReal) (x : K),
β((NumberField.InfinitePlace.embedding_of_isReal hw) x) = w.embedding x
|
Std.HashMap.contains_keysArray
|
Std.Data.HashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.HashMap Ξ± Ξ²} [EquivBEq Ξ±] [LawfulHashable Ξ±]
{k : Ξ±}, m.keysArray.contains k = m.contains k
|
ContinuousInv.measurableInv
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
|
β {Ξ³ : Type u_3} [inst : TopologicalSpace Ξ³] [inst_1 : MeasurableSpace Ξ³] [BorelSpace Ξ³] [inst_3 : Inv Ξ³]
[ContinuousInv Ξ³], MeasurableInv Ξ³
|
Homotopy.compLeftId
|
Mathlib.Algebra.Homology.Homotopy
|
{ΞΉ : Type u_1} β
{V : Type u} β
[inst : CategoryTheory.Category.{v, u} V] β
[inst_1 : CategoryTheory.Preadditive V] β
{c : ComplexShape ΞΉ} β
{C D : HomologicalComplex V c} β
{f : D βΆ D} β
Homotopy f (CategoryTheory.CategoryStruct.id D) β
(g : C βΆ D) β Homotopy (CategoryTheory.CategoryStruct.comp g f) g
|
CategoryTheory.Join.mapWhiskerRight_rightUnitor_hom
|
Mathlib.CategoryTheory.Join.Pseudofunctor
|
β {A : Type u_1} {B : Type u_2} (C : Type u_3) [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]
(F : CategoryTheory.Functor A B),
CategoryTheory.Join.mapWhiskerRight F.rightUnitor.hom (CategoryTheory.Functor.id C) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Join.mapCompLeft C F (CategoryTheory.Functor.id B)).hom
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Join.mapPair F (CategoryTheory.Functor.id C)).whiskerLeft CategoryTheory.Join.mapPairId.hom)
(CategoryTheory.Join.mapPair F (CategoryTheory.Functor.id C)).rightUnitor.hom)
|
Std.TreeMap.Raw._sizeOf_inst
|
Std.Data.TreeMap.Raw.Basic
|
(Ξ± : Type u) β
(Ξ² : Type v) β
(cmp : autoParam (Ξ± β Ξ± β Ordering) _autoβ) β [SizeOf Ξ±] β [SizeOf Ξ²] β SizeOf (Std.TreeMap.Raw Ξ± Ξ² cmp)
|
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid.eq_1
|
Mathlib.Algebra.Order.Hom.Monoid
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : AddCommMonoid Ξ±] [inst_1 : PartialOrder Ξ±] [inst_2 : AddCommMonoid Ξ²]
[inst_3 : PartialOrder Ξ²] [inst_4 : IsOrderedAddMonoid Ξ²],
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid =
{
add := fun f g =>
let __src := βf + βg;
{ toAddMonoidHom := __src, monotone' := β― } }
|
CategoryTheory.Limits.opProdIsoCoprod_inv_inl
|
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {A B : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct A B],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opProdIsoCoprod A B).inv.unop
CategoryTheory.Limits.coprod.inl.unop =
CategoryTheory.Limits.prod.fst
|
TopologicalSpace.IsTopologicalBasis.isOpen_iff
|
Mathlib.Topology.Bases
|
β {Ξ± : Type u} [t : TopologicalSpace Ξ±] {s : Set Ξ±} {b : Set (Set Ξ±)},
TopologicalSpace.IsTopologicalBasis b β (IsOpen s β β a β s, β t β b, a β t β§ t β s)
|
AddCon.addMonoid._proof_1
|
Mathlib.GroupTheory.Congruence.Defs
|
β {M : Type u_1} [inst : AddMonoid M] (c : AddCon M), Function.Surjective Quotient.mk''
|
SimpleGraph.bot_adj
|
Mathlib.Combinatorics.SimpleGraph.Basic
|
β {V : Type u} (v w : V), β₯.Adj v w β False
|
Subring.mem_pointwise_smul_iff_inv_smul_mem
|
Mathlib.Algebra.Ring.Subring.Pointwise
|
β {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] {a : M}
{S : Subring R} {x : R}, x β a β’ S β aβ»ΒΉ β’ x β S
|
CategoryTheory.Grp.hom_one
|
Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (H : CategoryTheory.Grp C) [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.MonObj.one.hom = CategoryTheory.MonObj.one
|
Aesop.Hyp.mk
|
Aesop.Forward.State
|
Option Lean.FVarId β Aesop.Substitution β Aesop.Hyp
|
TypeVec.splitFun
|
Mathlib.Data.TypeVec
|
{n : β} β
{Ξ± : TypeVec.{u_1} (n + 1)} β {Ξ±' : TypeVec.{u_2} (n + 1)} β Ξ±.drop.Arrow Ξ±'.drop β (Ξ±.last β Ξ±'.last) β Ξ±.Arrow Ξ±'
|
Lean.Elab.CommandContextInfo.mk.injEq
|
Lean.Elab.InfoTree.Types
|
β (env : Lean.Environment) (fileMap : Lean.FileMap) (mctx : Lean.MetavarContext) (options : Lean.Options)
(currNamespace : Lean.Name) (openDecls : List Lean.OpenDecl) (ngen : Lean.NameGenerator) (env_1 : Lean.Environment)
(fileMap_1 : Lean.FileMap) (mctx_1 : Lean.MetavarContext) (options_1 : Lean.Options) (currNamespace_1 : Lean.Name)
(openDecls_1 : List Lean.OpenDecl) (ngen_1 : Lean.NameGenerator),
({ env := env, fileMap := fileMap, mctx := mctx, options := options, currNamespace := currNamespace,
openDecls := openDecls, ngen := ngen } =
{ env := env_1, fileMap := fileMap_1, mctx := mctx_1, options := options_1, currNamespace := currNamespace_1,
openDecls := openDecls_1, ngen := ngen_1 }) =
(env = env_1 β§
fileMap = fileMap_1 β§
mctx = mctx_1 β§ options = options_1 β§ currNamespace = currNamespace_1 β§ openDecls = openDecls_1 β§ ngen = ngen_1)
|
PowerSeries.coeff_pow
|
Mathlib.RingTheory.PowerSeries.Basic
|
β {R : Type u_2} [inst : CommSemiring R] (k n : β) (Ο : PowerSeries R),
(PowerSeries.coeff n) (Ο ^ k) =
β l β (Finset.range k).finsuppAntidiag n, β i β Finset.range k, (PowerSeries.coeff (l i)) Ο
|
fderivWithin_inter
|
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 t : Set E}, t β nhds x β fderivWithin π f (s β© t) x = fderivWithin π f s x
|
_private.Mathlib.Order.Category.BoolAlg.0.BoolAlg.Hom.mk.injEq
|
Mathlib.Order.Category.BoolAlg
|
β {X Y : BoolAlg} (hom' hom'_1 : BoundedLatticeHom βX βY), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1)
|
LieDerivation.instModule.congr_simp
|
Mathlib.Algebra.Lie.Derivation.Basic
|
β {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] {S : Type u_4}
[inst_7 : Semiring S] [inst_8 : Module S M] [inst_9 : SMulCommClass R S M]
[inst_10 : LieDerivation.SMulBracketCommClass S L M], LieDerivation.instModule = LieDerivation.instModule
|
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.levelMVarToParam
|
Lean.Elab.MutualInductive
|
List Lean.InductiveType β Option Lean.LMVarId β Lean.Elab.TermElabM (List Lean.InductiveType)
|
_private.Mathlib.Geometry.Manifold.VectorBundle.Hom.0.ContMDiffWithinAt.clm_bundle_apply._simp_1_1
|
Mathlib.Geometry.Manifold.VectorBundle.Hom
|
β {π : Type u_1} {B : Type u_2} {Fβ : Type u_3} {Fβ : Type u_4} {M : Type u_5} {n : WithTop ββ} {Eβ : B β Type u_6}
{Eβ : B β Type u_7} [inst : NontriviallyNormedField π] [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)]
[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)] {EB : Type u_8} [inst_13 : NormedAddCommGroup EB]
[inst_14 : NormedSpace π EB] {HB : Type u_9} [inst_15 : TopologicalSpace HB] {IB : ModelWithCorners π EB HB}
[inst_16 : TopologicalSpace B] [inst_17 : ChartedSpace HB B] {EM : Type u_10} [inst_18 : NormedAddCommGroup EM]
[inst_19 : NormedSpace π EM] {HM : Type u_11} [inst_20 : TopologicalSpace HM] {IM : ModelWithCorners π EM HM}
[inst_21 : TopologicalSpace M] [inst_22 : ChartedSpace HM M] [inst_23 : FiberBundle Fβ Eβ]
[inst_24 : VectorBundle π Fβ Eβ] [inst_25 : FiberBundle Fβ Eβ] [inst_26 : VectorBundle π Fβ Eβ]
[inst_27 : β (x : B), IsTopologicalAddGroup (Eβ x)] [inst_28 : β (x : B), ContinuousSMul π (Eβ x)]
(f : M β Bundle.TotalSpace (Fβ βL[π] Fβ) fun b => Eβ b βL[π] Eβ b) {s : Set M} {xβ : M},
ContMDiffWithinAt IM (IB.prod (modelWithCornersSelf π (Fβ βL[π] Fβ))) n f s xβ =
(ContMDiffWithinAt IM IB n (fun x => (f x).proj) s xβ β§
ContMDiffWithinAt IM (modelWithCornersSelf π (Fβ βL[π] Fβ)) n
(fun x => ContinuousLinearMap.inCoordinates Fβ Eβ Fβ Eβ β― β― β― β― β―) s xβ)
|
Std.ExtHashSet.contains_of_contains_insert'
|
Std.Data.ExtHashSet.Lemmas
|
β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.ExtHashSet Ξ±} [inst : EquivBEq Ξ±] [inst_1 : LawfulHashable Ξ±]
{k a : Ξ±}, (m.insert k).contains a = true β Β¬((k == a) = true β§ m.contains k = false) β m.contains a = true
|
AddCommGrpCat.epi_iff_range_eq_top
|
Mathlib.Algebra.Category.Grp.EpiMono
|
β {A B : AddCommGrpCat} (f : A βΆ B), CategoryTheory.Epi f β (AddCommGrpCat.Hom.hom f).range = β€
|
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.archimedean_iff_nat_le.match_1_1
|
Mathlib.Algebra.Order.Archimedean.Basic
|
β {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] (x : K) (motive : (β n, x β€ βn) β Prop) (x_1 : β n, x β€ βn),
(β (n : β) (h : x β€ βn), motive β―) β motive x_1
|
Lean.Elab.Visibility.private.elim
|
Lean.Elab.DeclModifiers
|
{motive : Lean.Elab.Visibility β Sort u} β
(t : Lean.Elab.Visibility) β t.ctorIdx = 1 β motive Lean.Elab.Visibility.private β motive t
|
Finset.Icc_ofDual
|
Mathlib.Order.Interval.Finset.Defs
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] [inst_1 : LocallyFiniteOrder Ξ±] (a b : Ξ±α΅α΅),
Finset.Icc (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Icc b a)
|
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.div_max_sq_ge_one._simp_1_4
|
Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] (a : Ξ±), (a β€ a) = True
|
DoubleCoset.eq_of_not_disjoint
|
Mathlib.GroupTheory.DoubleCoset
|
β {G : Type u_1} [inst : Group G] {H K : Subgroup G} {a b : G},
Β¬Disjoint (DoubleCoset.doubleCoset a βH βK) (DoubleCoset.doubleCoset b βH βK) β
DoubleCoset.doubleCoset a βH βK = DoubleCoset.doubleCoset b βH βK
|
Mathlib.Tactic.Bicategory.naturality_inv
|
Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence
|
β {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {p : a βΆ b} {f g : b βΆ c} {pf : a βΆ c} {Ξ· : f β
g}
(Ξ·_f : CategoryTheory.CategoryStruct.comp p f β
pf) (Ξ·_g : CategoryTheory.CategoryStruct.comp p g β
pf),
CategoryTheory.Bicategory.whiskerLeftIso p Ξ· βͺβ« Ξ·_g = Ξ·_f β
CategoryTheory.Bicategory.whiskerLeftIso p Ξ·.symm βͺβ« Ξ·_f = Ξ·_g
|
ISize.div_self
|
Init.Data.SInt.Lemmas
|
β {a : ISize}, a / a = if a = 0 then 0 else 1
|
Affine.Simplex.altitudeFoot_mem_affineSpan_image_compl
|
Mathlib.Geometry.Euclidean.Altitude
|
β {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) (i : Fin (n + 1)),
s.altitudeFoot i β affineSpan β (s.points '' {i}αΆ)
|
One.toOfNat1.hcongr_2
|
Mathlib.GroupTheory.CoprodI
|
β (Ξ± Ξ±' : Type u_1), Ξ± = Ξ±' β β (inst : One Ξ±) (inst' : One Ξ±'), inst β inst' β One.toOfNat1 β One.toOfNat1
|
CategoryTheory.RetractArrow.left_i
|
Mathlib.CategoryTheory.Retract
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X βΆ Y} {g : Z βΆ W}
(h : CategoryTheory.RetractArrow f g), h.left.i = h.i.left
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Search.0.Lean.Meta.Grind.Arith.Cutsat.CooperSplit.assert.match_1
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.Search
|
(motive : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr β Sort u_1) β
(cβ? : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) β
((cβ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) β motive (some cβ)) β
((x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) β motive x) β motive cβ?
|
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_5
|
Mathlib.CategoryTheory.Limits.Types.Multiequalizer
|
β {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_3))
(s : βI.multicospan.sections) {j j' : CategoryTheory.Limits.WalkingMulticospan J} (f : j βΆ j'),
I.multicospan.map f
(match j with
| CategoryTheory.Limits.WalkingMulticospan.left i =>
{ val := fun i => βs (CategoryTheory.Limits.WalkingMulticospan.left i), property := β― }.val i
| CategoryTheory.Limits.WalkingMulticospan.right j =>
I.fst j
({ val := fun i => βs (CategoryTheory.Limits.WalkingMulticospan.left i), property := β― }.val (J.fst j))) =
match j' with
| CategoryTheory.Limits.WalkingMulticospan.left i =>
{ val := fun i => βs (CategoryTheory.Limits.WalkingMulticospan.left i), property := β― }.val i
| CategoryTheory.Limits.WalkingMulticospan.right j =>
I.fst j ({ val := fun i => βs (CategoryTheory.Limits.WalkingMulticospan.left i), property := β― }.val (J.fst j))
|
Std.ExtTreeSet.self_le_max?_insert
|
Std.Data.ExtTreeSet.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {t : Std.ExtTreeSet Ξ± cmp} [inst : Std.TransCmp cmp] {k kmi : Ξ±},
(t.insert k).max?.get β― = kmi β (cmp k kmi).isLE = true
|
_private.Batteries.Data.Fin.Lemmas.0.Fin.exists_eq_some_of_findSome?_eq_some._proof_1_1
|
Batteries.Data.Fin.Lemmas
|
β {n : β} {Ξ± : Type u_1} {x : Ξ±} {f : Fin n β Option Ξ±}, Fin.findSome? f = some x β β i, f i = some x
|
_private.Mathlib.LinearAlgebra.TensorAlgebra.Basic.0.TensorAlgebra.wrapped._proof_1._@.Mathlib.LinearAlgebra.TensorAlgebra.Basic.4207585102._hygCtx._hyg.2
|
Mathlib.LinearAlgebra.TensorAlgebra.Basic
|
TensorAlgebra.definitionβ = TensorAlgebra.definitionβ
|
DirectSum.Decomposition.casesOn
|
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] β
{β³ : ΞΉ β Ο} β
{motive : DirectSum.Decomposition β³ β Sort u} β
(t : DirectSum.Decomposition β³) β
((decompose' : M β DirectSum ΞΉ fun i => β₯(β³ i)) β
(left_inv : Function.LeftInverse (β(DirectSum.coeAddMonoidHom β³)) decompose') β
(right_inv : Function.RightInverse (β(DirectSum.coeAddMonoidHom β³)) decompose') β
motive { decompose' := decompose', left_inv := left_inv, right_inv := right_inv }) β
motive t
|
Lean.Expr.ensureHasNoMVars
|
Mathlib.Lean.Expr.Basic
|
Lean.Expr β Lean.MetaM Unit
|
Std.DTreeMap.Internal.Impl.Const.entryAtIdx?.eq_def
|
Std.Data.DTreeMap.Internal.Model
|
β {Ξ± : Type u} {Ξ² : Type v} (x : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) (x_1 : β),
Std.DTreeMap.Internal.Impl.Const.entryAtIdx? x x_1 =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.leaf, x => none
| Std.DTreeMap.Internal.Impl.inner size k v l r, n =>
match compare n l.size with
| Ordering.lt => Std.DTreeMap.Internal.Impl.Const.entryAtIdx? l n
| Ordering.eq => some (k, v)
| Ordering.gt => Std.DTreeMap.Internal.Impl.Const.entryAtIdx? r (n - l.size - 1)
|
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.elim
|
Mathlib.Tactic.CategoryTheory.Coherence.Datatypes
|
{motive : Mathlib.Tactic.BicategoryLike.StructuralAtom β Sort u} β
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) β
t.ctorIdx = 3 β
((e : Lean.Expr) β
(f : Mathlib.Tactic.BicategoryLike.Morβ) β motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f)) β
motive t
|
UInt8._sizeOf_inst
|
Init.SizeOf
|
SizeOf UInt8
|
Int.reduceNeg._regBuiltin.Int.reduceNeg.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.2123988823._hygCtx._hyg.22
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int
|
IO Unit
|
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffOn_iff_target._simp_1_1
|
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}
{n : WithTop ββ} [IsManifold I n M] [IsManifold I' n M'],
ContMDiffOn I I' n f s =
(ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(extChartAt I x).symm)
((extChartAt I x).target β© β(extChartAt I x).symm β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source)))
|
_private.Mathlib.Data.Set.Finite.Basic.0.Finset.exists.match_1_3
|
Mathlib.Data.Set.Finite.Basic
|
β {Ξ± : Type u_1} {p : Finset Ξ± β Prop} (motive : (β s, β (hs : s.Finite), p hs.toFinset) β Prop)
(x : β s, β (hs : s.Finite), p hs.toFinset),
(β (s : Set Ξ±) (hs : s.Finite) (hs' : p hs.toFinset), motive β―) β motive x
|
UnitAddTorus.mFourierLp._proof_7
|
Mathlib.Analysis.Fourier.AddCircleMulti
|
β {d : Type u_1}, CompactSpace (d β UnitAddCircle)
|
IsAbsoluteValue.abv_nonneg
|
Mathlib.Algebra.Order.AbsoluteValue.Basic
|
β {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R] (abv : R β S)
[IsAbsoluteValue abv] (x : R), 0 β€ abv x
|
EReal.coe_ennreal_le_coe_ennreal_iff._simp_1
|
Mathlib.Data.EReal.Basic
|
β {x y : ENNReal}, (βx β€ βy) = (x β€ y)
|
CategoryTheory.nerveFunctor.full
|
Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction
|
CategoryTheory.nerveFunctor.Full
|
CategoryTheory.Presieve.BindStruct.hg
|
Mathlib.CategoryTheory.Sites.Sieves
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {X : C} {S : CategoryTheory.Presieve X}
{R : β¦Y : Cβ¦ β β¦f : Y βΆ Xβ¦ β S f β CategoryTheory.Presieve Y} {Z : C} {h : Z βΆ X} (self : S.BindStruct R h),
R β― self.g
|
ModuleCat.monModuleEquivalenceAlgebraForget._proof_5
|
Mathlib.CategoryTheory.Monoidal.Internal.Module
|
β {R : Type u_1} [inst : CommRing R] (A : CategoryTheory.Mon (ModuleCat R)),
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom { toFun := id, map_add' := β―, map_smul' := β― })
(ModuleCat.ofHom { toFun := id, map_add' := β―, map_smul' := β― }) =
CategoryTheory.CategoryStruct.id
((ModuleCat.MonModuleEquivalenceAlgebra.functor.comp (CategoryTheory.forgetβ (AlgCat R) (ModuleCat R))).obj A)
|
CategoryTheory.Limits.prod.mapIso_hom
|
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
(f : W β
Y) (g : X β
Z), (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_of_msb_false._simp_1_1
|
Init.Data.BitVec.Lemmas
|
β {p : Prop} [h : Decidable p], (false = decide p) = Β¬p
|
Lean.Server.Snapshots.Snapshot.recOn
|
Lean.Server.Snapshots
|
{motive : Lean.Server.Snapshots.Snapshot β Sort u} β
(t : Lean.Server.Snapshots.Snapshot) β
((stx : Lean.Syntax) β
(mpState : Lean.Parser.ModuleParserState) β
(cmdState : Lean.Elab.Command.State) β motive { stx := stx, mpState := mpState, cmdState := cmdState }) β
motive t
|
AddLocalization.liftOnβ_mk
|
Mathlib.GroupTheory.MonoidLocalization.Basic
|
β {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M β β₯S β M β β₯S β p)
(H :
β {a a' : M} {b b' : β₯S} {c c' : M} {d d' : β₯S},
(AddLocalization.r S) (a, b) (a', b') β (AddLocalization.r S) (c, d) (c', d') β f a b c d = f a' b' c' d')
(a c : M) (b d : β₯S), (AddLocalization.mk a b).liftOnβ (AddLocalization.mk c d) f H = f a b c d
|
CategoryTheory.Functor.Monoidal.whiskerLeft_app_snd
|
Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory
|
β {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{u_5, u_1} J]
[inst_1 : CategoryTheory.Category.{u_6, u_2} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(Fβ : CategoryTheory.Functor J C) {Fβ Fβ' : CategoryTheory.Functor J C} (g : Fβ βΆ Fβ') (j : J),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategoryStruct.whiskerLeft Fβ g).app j)
(CategoryTheory.SemiCartesianMonoidalCategory.snd (Fβ.obj j) (Fβ'.obj j)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.snd (Fβ.obj j) (Fβ.obj j))
(g.app j)
|
Polynomial.map_evalRingHom_eval
|
Mathlib.Algebra.Polynomial.Bivariate
|
β {R : Type u_1} [inst : CommSemiring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p
|
Units.isOpenMap_val
|
Mathlib.Analysis.Normed.Ring.Units
|
β {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], IsOpenMap Units.val
|
IsSemisimpleModule.recOn
|
Mathlib.RingTheory.SimpleModule.Basic
|
{R : Type u_2} β
[inst : Ring R] β
{M : Type u_4} β
[inst_1 : AddCommGroup M] β
[inst_2 : Module R M] β
{motive : IsSemisimpleModule R M β Sort u} β
(t : IsSemisimpleModule R M) β
([toComplementedLattice : ComplementedLattice (Submodule R M)] β motive β―) β motive t
|
Pi.instSub
|
Mathlib.Algebra.Notation.Pi.Defs
|
{ΞΉ : Type u_1} β {G : ΞΉ β Type u_4} β [(i : ΞΉ) β Sub (G i)] β Sub ((i : ΞΉ) β G i)
|
Set.Definable.compl
|
Mathlib.ModelTheory.Definability
|
β {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {Ξ± : Type uβ} {s : Set (Ξ± β M)},
A.Definable L s β A.Definable L sαΆ
|
Module.addCommMonoidToAddCommGroup._proof_9
|
Mathlib.Algebra.Module.NatInt
|
β (R : Type u_2) {M : Type u_1} [inst : Ring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (z : β) (a : M),
β(Int.negSucc z) β’ a = -1 β’ ββ(z + 1) β’ a
|
left_subset_compRel
|
Mathlib.Topology.UniformSpace.Defs
|
β {Ξ± : Type ua} {s t : SetRel Ξ± Ξ±}, idRel β t β s β s.comp t
|
Std.DHashMap.get?_eq_some_getD
|
Std.Data.DHashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.DHashMap Ξ± Ξ²} [inst : LawfulBEq Ξ±] {a : Ξ±}
{fallback : Ξ² a}, a β m β m.get? a = some (m.getD a fallback)
|
Finset.sup_eq_sSup_image
|
Mathlib.Data.Finset.Lattice.Fold
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : CompleteLattice Ξ²] (s : Finset Ξ±) (f : Ξ± β Ξ²), s.sup f = sSup (f '' βs)
|
Std.Iterators.Iter.takeWhile_eq
|
Std.Data.Iterators.Lemmas.Combinators.TakeWhile
|
β {Ξ± Ξ² : Type u_1} [Std.Iterators.Iterator Ξ± Id Ξ²] {P : Ξ² β Bool} {it : Std.Iter Ξ²},
Std.Iterators.Iter.takeWhile P it = (Std.Iterators.IterM.takeWhile P it.toIterM).toIter
|
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier
|
Mathlib.Algebra.Category.MonCat.Basic
|
CategoryTheory.ConcreteCategory AddCommMonCat fun x1 x2 => βx1 β+ βx2
|
_private.Mathlib.Probability.Distributions.Exponential.0.ProbabilityTheory.cdf_expMeasure_eq._simp_1_3
|
Mathlib.Probability.Distributions.Exponential
|
β {Ξ± : Type u} [inst : AddGroup Ξ±] [inst_1 : LE Ξ±] [AddLeftMono Ξ±] {a : Ξ±}, (-a β€ 0) = (0 β€ a)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.