Datasets:
mathlib-initiative
/
mathlib-types

Dataset card Data Studio Files
xet
Community
1
name
stringlengths
2
347
module
stringlengths
6
90
type
stringlengths
1
5.42M
GroupExtension.Equiv.trans_apply
Mathlib.GroupTheory.GroupExtension.Defs
βˆ€ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : Group N] [inst_1 : Group E] [inst_2 : Group G] {S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (equiv : S.Equiv S') {E'' : Type u_5} [inst_4 : Group E''] {S'' : GroupExtension N E'' G} (equiv' : S'.Equiv S'') (a : E), (equiv.trans equiv') a = equiv' (equiv a)
Part.elim_toOption
Mathlib.Data.Part
βˆ€ {Ξ± : Type u_4} {Ξ² : Type u_5} (a : Part Ξ±) [inst : Decidable a.Dom] (b : Ξ²) (f : Ξ± β†’ Ξ²), a.toOption.elim b f = if h : a.Dom then f (a.get h) else b
SeminormFamily.basisSets_univ_mem
Mathlib.Analysis.LocallyConvex.WithSeminorms
βˆ€ {R : Type u_1} {E : Type u_6} {ΞΉ : Type u_9} [inst : SeminormedRing R] [inst_1 : AddCommGroup E] [inst_2 : Module R E] (p : SeminormFamily R E ΞΉ), Set.univ ∈ p.basisSets
EuclideanSpace.nnnorm_single
Mathlib.Analysis.InnerProductSpace.PiL2
βˆ€ {ΞΉ : Type u_1} {π•œ : Type u_3} [inst : RCLike π•œ] [inst_1 : DecidableEq ΞΉ] [inst_2 : Fintype ΞΉ] (i : ΞΉ) (a : π•œ), β€–EuclideanSpace.single i aβ€–β‚Š = β€–aβ€–β‚Š
CategoryTheory.Limits.limitCompYonedaIsoCocone_hom_app
Mathlib.CategoryTheory.Limits.Types.Yoneda
βˆ€ {J : Type v} [inst : CategoryTheory.SmallCategory J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor J C) (X : C) (a : CategoryTheory.Limits.limit (F.op.comp (CategoryTheory.yoneda.obj X))) (j : J), ((CategoryTheory.Limits.limitCompYonedaIsoCocone F X).hom a).app j = CategoryTheory.Limits.limit.Ο€ (F.op.comp (CategoryTheory.yoneda.obj X)) (Opposite.op j) a
Std.ExtHashMap.getKeyD_alter_self
Std.Data.ExtHashMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.ExtHashMap Ξ± Ξ²} [inst : EquivBEq Ξ±] [inst_1 : LawfulHashable Ξ±] [Inhabited Ξ±] {k fallback : Ξ±} {f : Option Ξ² β†’ Option Ξ²}, (m.alter k f).getKeyD k fallback = if (f m[k]?).isSome = true then k else fallback
SemiNormedGrp.hom_id
Mathlib.Analysis.Normed.Group.SemiNormedGrp
βˆ€ {M : SemiNormedGrp}, SemiNormedGrp.Hom.hom (CategoryTheory.CategoryStruct.id M) = NormedAddGroupHom.id M.carrier
BoundedContinuousFunction.instRing._proof_18
Mathlib.Topology.ContinuousMap.Bounded.Normed
βˆ€ {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] {R : Type u_2} [inst_1 : SeminormedRing R] (a b : BoundedContinuousFunction Ξ± R), a - b = a + -b
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.nCasesProd.match_5
Lean.Meta.MkIffOfInductiveProp
(motive : Array Lean.Meta.CasesSubgoal β†’ Sort u_1) β†’ (__discr : Array Lean.Meta.CasesSubgoal) β†’ ((sg : Lean.Meta.CasesSubgoal) β†’ motive #[sg]) β†’ ((x : Array Lean.Meta.CasesSubgoal) β†’ motive x) β†’ motive __discr
TensorProduct.finsuppRight_symm_apply_single
Mathlib.LinearAlgebra.DirectSum.Finsupp
βˆ€ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3} [inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ΞΉ : Type u_4} [inst_5 : DecidableEq ΞΉ] (i : ΞΉ) (m : M) (n : N), ((TensorProduct.finsuppRight R M N ΞΉ).symm funβ‚€ | i => m βŠ—β‚œ[R] n) = m βŠ—β‚œ[R] funβ‚€ | i => n
Array.get!Internal
Init.Prelude
{Ξ± : Type u} β†’ [Inhabited Ξ±] β†’ Array Ξ± β†’ β„• β†’ Ξ±
Lean.SourceInfo.ctorIdx
Init.Prelude
Lean.SourceInfo β†’ β„•
instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._proof_7
Mathlib.Algebra.Order.GroupWithZero.Canonical
βˆ€ {Ξ± : Type u_1} [inst : LinearOrderedCommGroupWithZero Ξ±] (a : Additive Ξ±α΅’α΅ˆ), a β‰  ⊀ β†’ Additive.toMul a * (Additive.toMul a)⁻¹ = 1
EuclideanDomain.lcm
Mathlib.Algebra.EuclideanDomain.Defs
{R : Type u} β†’ [EuclideanDomain R] β†’ [DecidableEq R] β†’ R β†’ R β†’ R
NumberField.IsCMField.starRing
Mathlib.NumberTheory.NumberField.CMField
(K : Type u_1) β†’ [inst : Field K] β†’ [inst_1 : CharZero K] β†’ [NumberField.IsCMField K] β†’ [Algebra.IsIntegral β„š K] β†’ StarRing K
Real.iteratedDerivWithin_cos_Ioo
Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
βˆ€ (n : β„•) {a b x : ℝ}, x ∈ Set.Ioo a b β†’ iteratedDerivWithin n Real.cos (Set.Ioo a b) x = iteratedDeriv n Real.cos x
ModularGroup.eq_smul_self_of_mem_fdo_mem_fdo
Mathlib.NumberTheory.Modular
βˆ€ {g : Matrix.SpecialLinearGroup (Fin 2) β„€} {z : UpperHalfPlane}, z ∈ ModularGroup.fdo β†’ g β€’ z ∈ ModularGroup.fdo β†’ z = g β€’ z
MulEquiv.mk.inj
Mathlib.Algebra.Group.Equiv.Defs
βˆ€ {M : Type u_9} {N : Type u_10} {inst : Mul M} {inst_1 : Mul N} {toEquiv : M ≃ N} {map_mul' : βˆ€ (x y : M), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y} {toEquiv_1 : M ≃ N} {map_mul'_1 : βˆ€ (x y : M), toEquiv_1.toFun (x * y) = toEquiv_1.toFun x * toEquiv_1.toFun y}, { toEquiv := toEquiv, map_mul' := map_mul' } = { toEquiv := toEquiv_1, map_mul' := map_mul'_1 } β†’ toEquiv = toEquiv_1
LLVM.buildGEP2
Lean.Compiler.IR.LLVMBindings
{ctx : LLVM.Context} β†’ LLVM.Builder ctx β†’ LLVM.LLVMType ctx β†’ LLVM.Value ctx β†’ Array (LLVM.Value ctx) β†’ optParam String "" β†’ BaseIO (LLVM.Value ctx)
CategoryTheory.Limits.coneUnopOfCocone_pt
Mathlib.CategoryTheory.Limits.Cones
βˆ€ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor Jα΅’α΅– Cα΅’α΅–} (c : CategoryTheory.Limits.Cocone F), (CategoryTheory.Limits.coneUnopOfCocone c).pt = Opposite.unop c.pt
CategoryTheory.FintypeCat.Action.isConnected_iff_transitive
Mathlib.CategoryTheory.Galois.Examples
βˆ€ (G : Type u) [inst : Group G] (X : Action FintypeCat G) [Nonempty X.V.carrier], CategoryTheory.PreGaloisCategory.IsConnected X ↔ MulAction.IsPretransitive G X.V.carrier
Set.exists_min_image
Mathlib.Data.Set.Finite.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Type v} [inst : LinearOrder Ξ²] (s : Set Ξ±) (f : Ξ± β†’ Ξ²), s.Finite β†’ s.Nonempty β†’ βˆƒ a ∈ s, βˆ€ b ∈ s, f a ≀ f b
MulHom.prod_comp_prodMap
Mathlib.Algebra.Group.Prod
βˆ€ {M : Type u_3} {N : Type u_4} {P : Type u_5} {M' : Type u_6} {N' : Type u_7} [inst : Mul M] [inst_1 : Mul N] [inst_2 : Mul M'] [inst_3 : Mul N'] [inst_4 : Mul P] (f : P β†’β‚™* M) (g : P β†’β‚™* N) (f' : M β†’β‚™* M') (g' : N β†’β‚™* N'), (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.H
Std.Time.Format.Basic
Std.Time.GenericFormat.DateBuilder✝ β†’ Option Std.Time.Hour.Ordinal
ONote.opowAux2.match_1
Mathlib.SetTheory.Ordinal.Notation
(motive : ONote Γ— β„• β†’ Sort u_1) β†’ (x : ONote Γ— β„•) β†’ ((b : ONote) β†’ motive (b, 0)) β†’ ((b : ONote) β†’ (k : β„•) β†’ motive (b, k.succ)) β†’ motive x
Module.Basis.adjustToOrientation.congr_simp
Mathlib.LinearAlgebra.Orientation
βˆ€ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2} [inst_3 : AddCommGroup M] [inst_4 : Module R M] {ΞΉ : Type u_3} [inst_5 : Fintype ΞΉ] [inst_6 : DecidableEq ΞΉ] [inst_7 : Nonempty ΞΉ] (e e_1 : Module.Basis ΞΉ R M), e = e_1 β†’ βˆ€ (x x_1 : Orientation R M ΞΉ), x = x_1 β†’ e.adjustToOrientation x = e_1.adjustToOrientation x_1
MeasureTheory.IsFundamentalDomain.measure_zero_of_invariant
Mathlib.MeasureTheory.Group.FundamentalDomain
βˆ€ {G : Type u_1} {Ξ± : Type u_3} [inst : Group G] [inst_1 : MulAction G Ξ±] [inst_2 : MeasurableSpace Ξ±] {s : Set Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} [inst_3 : MeasurableSpace G] [MeasurableSMul G Ξ±] [MeasureTheory.SMulInvariantMeasure G Ξ± ΞΌ] [Countable G], MeasureTheory.IsFundamentalDomain G s ΞΌ β†’ βˆ€ (t : Set Ξ±), (βˆ€ (g : G), g β€’ t = t) β†’ ΞΌ (t ∩ s) = 0 β†’ ΞΌ t = 0
differentiable_neg
Mathlib.Analysis.Calculus.Deriv.Add
βˆ€ {π•œ : Type u} [inst : NontriviallyNormedField π•œ], Differentiable π•œ Neg.neg
CategoryTheory.Functor.Final.rec
Mathlib.CategoryTheory.Limits.Final
{C : Type u₁} β†’ [inst : CategoryTheory.Category.{v₁, u₁} C] β†’ {D : Type uβ‚‚} β†’ [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} D] β†’ {F : CategoryTheory.Functor C D} β†’ {motive : F.Final β†’ Sort u} β†’ ((out : βˆ€ (d : D), CategoryTheory.IsConnected (CategoryTheory.StructuredArrow d F)) β†’ motive β‹―) β†’ (t : F.Final) β†’ motive t
Units.val
Mathlib.Algebra.Group.Units.Defs
{Ξ± : Type u} β†’ [inst : Monoid Ξ±] β†’ Ξ±Λ£ β†’ Ξ±
_private.Init.Data.List.Find.0.List.find?_replicate_eq_none_iff._simp_1_1
Init.Data.List.Find
βˆ€ {a b : Prop}, (a ∨ b) = (Β¬a β†’ b)
CategoryTheory.PreZeroHypercover.pullbackIso
Mathlib.CategoryTheory.Sites.Hypercover.Zero
{C : Type u} β†’ [inst : CategoryTheory.Category.{v, u} C] β†’ {S T : C} β†’ (f : S ⟢ T) β†’ (E : CategoryTheory.PreZeroHypercover T) β†’ [inst_1 : βˆ€ (i : E.Iβ‚€), CategoryTheory.Limits.HasPullback f (E.f i)] β†’ [inst_2 : βˆ€ (i : E.Iβ‚€), CategoryTheory.Limits.HasPullback (E.f i) f] β†’ CategoryTheory.PreZeroHypercover.pullback₁ f E β‰… CategoryTheory.PreZeroHypercover.pullbackβ‚‚ f E
Set.iUnion_iUnion_eq_right
Mathlib.Data.Set.Lattice
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {b : Ξ²} {s : (x : Ξ²) β†’ b = x β†’ Set Ξ±}, ⋃ x, ⋃ (h : b = x), s x h = s b β‹―
Std.DHashMap.Internal.Raw.Const.get_eq
Std.Data.DHashMap.Internal.Raw
βˆ€ {Ξ± : Type u} {Ξ² : Type v} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {m : Std.DHashMap.Raw Ξ± fun x => Ξ²} {a : Ξ±} {h : a ∈ m}, Std.DHashMap.Raw.Const.get m a h = Std.DHashMap.Internal.Rawβ‚€.Const.get ⟨m, β‹―βŸ© a β‹―
Localization.partialOrder.congr_simp
Mathlib.GroupTheory.MonoidLocalization.Order
βˆ€ {Ξ± : Type u_1} [inst : CommMonoid Ξ±] [inst_1 : PartialOrder Ξ±] [inst_2 : IsOrderedCancelMonoid Ξ±] {s : Submonoid Ξ±}, Localization.partialOrder = Localization.partialOrder
toLexLinearEquiv
Mathlib.Algebra.Order.Module.Equiv
(Ξ± : Type u_1) β†’ (Ξ² : Type u_2) β†’ [inst : Semiring Ξ±] β†’ [inst_1 : AddCommMonoid Ξ²] β†’ [inst_2 : Module Ξ± Ξ²] β†’ Ξ² ≃ₗ[Ξ±] Lex Ξ²
SupHom.recOn
Mathlib.Order.Hom.Lattice
{Ξ± : Type u_6} β†’ {Ξ² : Type u_7} β†’ [inst : Max Ξ±] β†’ [inst_1 : Max Ξ²] β†’ {motive : SupHom Ξ± Ξ² β†’ Sort u} β†’ (t : SupHom Ξ± Ξ²) β†’ ((toFun : Ξ± β†’ Ξ²) β†’ (map_sup' : βˆ€ (a b : Ξ±), toFun (a βŠ” b) = toFun a βŠ” toFun b) β†’ motive { toFun := toFun, map_sup' := map_sup' }) β†’ motive t
_private.Init.Data.Vector.Lemmas.0.Vector.mem_flatten._simp_1_1
Init.Data.Vector.Lemmas
βˆ€ {Ξ± : Type u_1} {a : Ξ±} {xss : Array (Array Ξ±)}, (a ∈ xss.flatten) = βˆƒ xs ∈ xss, a ∈ xs
_private.Init.Data.Array.Basic.0.Array.findSomeRevM?.find.match_1
Init.Data.Array.Basic
{Ξ² : Type u_1} β†’ (motive : Option Ξ² β†’ Sort u_2) β†’ (r : Option Ξ²) β†’ ((val : Ξ²) β†’ motive (some val)) β†’ (Unit β†’ motive none) β†’ motive r
normalize_eq_one
Mathlib.Algebra.GCDMonoid.Basic
βˆ€ {Ξ± : Type u_1} [inst : CancelCommMonoidWithZero Ξ±] [inst_1 : NormalizationMonoid Ξ±] {x : Ξ±}, normalize x = 1 ↔ IsUnit x
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.Mathlib.Meta.Positivity.evalIntegral._proof_2
Mathlib.MeasureTheory.Integral.Bochner.Basic
βˆ€ (Ξ± : Q(Type)) (pΞ± : Q(PartialOrder Β«$Ξ±Β»)) (__defeqres : PLift (Β«$pΞ±Β» =Q Real.partialOrder)), Β«$pΞ±Β» =Q Real.partialOrder
Matrix.Semiring.smulCommClass
Mathlib.Data.Matrix.Mul
βˆ€ {n : Type u_3} {R : Type u_7} {Ξ± : Type v} [inst : NonUnitalNonAssocSemiring Ξ±] [inst_1 : Fintype n] [inst_2 : Monoid R] [inst_3 : DistribMulAction R Ξ±] [SMulCommClass R Ξ± Ξ±], SMulCommClass R (Matrix n n Ξ±) (Matrix n n Ξ±)
_private.Lean.Linter.ConstructorAsVariable.0.Lean.Linter.constructorNameAsVariable.match_1
Lean.Linter.ConstructorAsVariable
(motive : Option Lean.Expr β†’ Sort u_1) β†’ (x : Option Lean.Expr) β†’ ((t : Lean.Expr) β†’ motive (some t)) β†’ ((x : Option Lean.Expr) β†’ motive x) β†’ motive x
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.mkJmpArgsAtJp
Lean.Compiler.LCNF.Simp.JpCases
Array Lean.Compiler.LCNF.Param β†’ β„• β†’ Array Lean.Compiler.LCNF.Param β†’ Bool β†’ Array Lean.Compiler.LCNF.Arg
_private.Mathlib.Order.LiminfLimsup.0.CompleteLatticeHom.apply_limsup_iterate._simp_1_1
Mathlib.Order.LiminfLimsup
βˆ€ (n m : β„•), (n + m).succ = n + m.succ
Trivialization.map_proj_nhds
Mathlib.Topology.FiberBundle.Trivialization
βˆ€ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z β†’ B} [inst_2 : TopologicalSpace Z] (e : Trivialization F proj) {x : Z}, x ∈ e.source β†’ Filter.map proj (nhds x) = nhds (proj x)
sigmaFinsuppAddEquivDFinsupp._proof_2
Mathlib.Data.Finsupp.ToDFinsupp
βˆ€ {ΞΉ : Type u_3} {Ξ· : ΞΉ β†’ Type u_2} {N : Type u_1} [inst : AddZeroClass N], Function.RightInverse sigmaFinsuppEquivDFinsupp.invFun sigmaFinsuppEquivDFinsupp.toFun
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.cast_neg.match_1_1
Mathlib.Tactic.Ring.Basic
βˆ€ {n : β„•} {R : Type u_1} [inst : Ring R] {a : R} (motive : Mathlib.Meta.NormNum.IsInt a (Int.negOfNat n) β†’ Prop) (x : Mathlib.Meta.NormNum.IsInt a (Int.negOfNat n)), (βˆ€ (e : a = ↑(Int.negOfNat n)), motive β‹―) β†’ motive x
IsUniformAddGroup.isLeftUniformAddGroup
Mathlib.Topology.Algebra.IsUniformGroup.Defs
βˆ€ (Ξ± : Type u_1) [inst : UniformSpace Ξ±] [inst_1 : AddGroup Ξ±] [IsUniformAddGroup Ξ±], IsLeftUniformAddGroup Ξ±
Action.inv_hom_hom_assoc
Mathlib.CategoryTheory.Action.Basic
βˆ€ {V : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {M N : Action V G} (f : M β‰… N) {Z : V} (h : N.V ⟢ Z), CategoryTheory.CategoryStruct.comp f.inv.hom (CategoryTheory.CategoryStruct.comp f.hom.hom h) = h
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0._aux_Mathlib_Analysis_Complex_PhragmenLindelof___macroRules__private_Mathlib_Analysis_Complex_PhragmenLindelof_0_termExpR_1
Mathlib.Analysis.Complex.PhragmenLindelof
Lean.Macro
instCommRingCorner._proof_2
Mathlib.RingTheory.Idempotents
βˆ€ {R : Type u_1} (e : R) [inst : NonUnitalCommRing R] (a b c : β†₯(NonUnitalRing.corner e)), a * (b + c) = a * b + a * c
Complex.cpow_two
Mathlib.Analysis.SpecialFunctions.Pow.Complex
βˆ€ (x : β„‚), x ^ 2 = x ^ 2
ContinuousMultilinearMap.flipLinear._proof_9
Mathlib.Analysis.Normed.Module.Multilinear.Basic
βˆ€ {π•œ : Type u_4} {ΞΉ : Type u_2} {E : ΞΉ β†’ Type u_3} {G : Type u_5} {G' : Type u_1} [inst : NontriviallyNormedField π•œ] [inst_1 : (i : ΞΉ) β†’ SeminormedAddCommGroup (E i)] [inst_2 : (i : ΞΉ) β†’ NormedSpace π•œ (E i)] [inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace π•œ G] [inst_5 : SeminormedAddCommGroup G'] [inst_6 : NormedSpace π•œ G'] [inst_7 : Fintype ΞΉ] (f : ContinuousMultilinearMap π•œ E (G β†’L[π•œ] G')) (x : G) (m : (i : ΞΉ) β†’ E i), β€–({ toFun := fun x => { toFun := fun m => (f m) x, map_update_add' := β‹―, map_update_smul' := β‹― }, map_add' := β‹―, map_smul' := β‹― } x) mβ€– ≀ β€–fβ€– * β€–xβ€– * ∏ i, β€–m iβ€–
Lean.Elab.Tactic.ElabSimpArgsResult.mk.inj
Lean.Elab.Tactic.Simp
βˆ€ {ctx : Lean.Meta.Simp.Context} {simprocs : Lean.Meta.Simp.SimprocsArray} {simpArgs : Array (Lean.Syntax Γ— Lean.Elab.Tactic.ElabSimpArgResult)} {ctx_1 : Lean.Meta.Simp.Context} {simprocs_1 : Lean.Meta.Simp.SimprocsArray} {simpArgs_1 : Array (Lean.Syntax Γ— Lean.Elab.Tactic.ElabSimpArgResult)}, { ctx := ctx, simprocs := simprocs, simpArgs := simpArgs } = { ctx := ctx_1, simprocs := simprocs_1, simpArgs := simpArgs_1 } β†’ ctx = ctx_1 ∧ simprocs = simprocs_1 ∧ simpArgs = simpArgs_1
Lean.Core.numBinders
Lean.Meta.ExprLens
{M : Type β†’ Type} β†’ [Monad M] β†’ [Lean.MonadError M] β†’ Lean.SubExpr.Pos β†’ Lean.Expr β†’ M β„•
MeromorphicAt.update
Mathlib.Analysis.Meromorphic.Basic
βˆ€ {π•œ : Type u_1} [inst : NontriviallyNormedField π•œ] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π•œ E] [inst_3 : DecidableEq π•œ] {f : π•œ β†’ E} {z : π•œ}, MeromorphicAt f z β†’ βˆ€ (w : π•œ) (e : E), MeromorphicAt (Function.update f w e) z
_private.Mathlib.Analysis.Real.OfDigits.0.Real.ofDigits_const_last_eq_one._simp_1_6
Mathlib.Analysis.Real.OfDigits
βˆ€ {Ξ± : Type u_2} [inst : Zero Ξ±] [inst_1 : OfNat Ξ± 3] [NeZero 3], (3 = 0) = False
CategoryTheory.Limits.inl_inl_pushoutAssoc_hom_assoc
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ Xβ‚‚ X₃ Z₁ Zβ‚‚ : C} (g₁ : Z₁ ⟢ X₁) (gβ‚‚ : Z₁ ⟢ Xβ‚‚) (g₃ : Zβ‚‚ ⟢ Xβ‚‚) (gβ‚„ : Zβ‚‚ ⟢ X₃) [inst_1 : CategoryTheory.Limits.HasPushout g₁ gβ‚‚] [inst_2 : CategoryTheory.Limits.HasPushout g₃ gβ‚„] [inst_3 : CategoryTheory.Limits.HasPushout (CategoryTheory.CategoryStruct.comp g₃ (CategoryTheory.Limits.pushout.inr g₁ gβ‚‚)) gβ‚„] [inst_4 : CategoryTheory.Limits.HasPushout g₁ (CategoryTheory.CategoryStruct.comp gβ‚‚ (CategoryTheory.Limits.pushout.inl g₃ gβ‚„))] {Z : C} (h : CategoryTheory.Limits.pushout g₁ (CategoryTheory.CategoryStruct.comp gβ‚‚ (CategoryTheory.Limits.pushout.inl g₃ gβ‚„)) ⟢ Z), CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl g₁ gβ‚‚) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl (CategoryTheory.CategoryStruct.comp g₃ (CategoryTheory.Limits.pushout.inr g₁ gβ‚‚)) gβ‚„) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushoutAssoc g₁ gβ‚‚ g₃ gβ‚„).hom h)) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl g₁ (CategoryTheory.CategoryStruct.comp gβ‚‚ (CategoryTheory.Limits.pushout.inl g₃ gβ‚„))) h
_private.Lean.Meta.Tactic.Grind.Solve.0.Lean.Meta.Grind.solve._sparseCasesOn_1
Lean.Meta.Tactic.Grind.Solve
{Ξ± : Type u} β†’ {motive : List Ξ± β†’ Sort u_1} β†’ (t : List Ξ±) β†’ ((head : Ξ±) β†’ (tail : List Ξ±) β†’ motive (head :: tail)) β†’ (t.ctorIdx β‰  1 β†’ motive t) β†’ motive t
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst._proof_10
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft
βˆ€ {w : β„•}, 0 ≀ w
Lean.Compiler.LCNF.Probe.countUnique
Lean.Compiler.LCNF.Probing
{Ξ± : Type} β†’ [ToString Ξ±] β†’ [BEq Ξ±] β†’ [Hashable Ξ±] β†’ Lean.Compiler.LCNF.Probe Ξ± (Ξ± Γ— β„•)
NormedDivisionRing.nnratCast._inherited_default
Mathlib.Analysis.Normed.Field.Basic
{Ξ± : Type u_5} β†’ (β„• β†’ Ξ±) β†’ (Ξ± β†’ Ξ± β†’ Ξ±) β†’ β„šβ‰₯0 β†’ Ξ±
Filter.tendsto_ofReal_iff'
Mathlib.Analysis.Complex.Basic
βˆ€ {Ξ± : Type u_2} {π•œ : Type u_3} [inst : RCLike π•œ] {l : Filter Ξ±} {f : Ξ± β†’ ℝ} {x : ℝ}, Filter.Tendsto (fun x => ↑(f x)) l (nhds ↑x) ↔ Filter.Tendsto f l (nhds x)
Lean.Grind.AC.instBEqSeq.beq._sparseCasesOn_1
Init.Grind.AC
{motive : Lean.Grind.AC.Seq β†’ Sort u} β†’ (t : Lean.Grind.AC.Seq) β†’ ((x : Lean.Grind.AC.Var) β†’ motive (Lean.Grind.AC.Seq.var x)) β†’ (t.ctorIdx β‰  0 β†’ motive t) β†’ motive t
Lean.ToLevel.ctorIdx
Lean.ToLevel
Lean.ToLevel β†’ β„•
Lean.IR.MaxIndex.visitFnBody
Lean.Compiler.IR.FreeVars
Lean.IR.FnBody β†’ Lean.IR.MaxIndex.M Unit
Lean.Json.Β«json[_]Β»
Lean.Data.Json.Elab
Lean.ParserDescr
ExceptT.bindCont.match_1
Init.Control.Except
{Ξ΅ Ξ± : Type u_1} β†’ (motive : Except Ξ΅ Ξ± β†’ Sort u_2) β†’ (x : Except Ξ΅ Ξ±) β†’ ((a : Ξ±) β†’ motive (Except.ok a)) β†’ ((e : Ξ΅) β†’ motive (Except.error e)) β†’ motive x
CategoryTheory.FunctorToTypes.binaryProductEquiv._proof_2
Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes
βˆ€ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F G : CategoryTheory.Functor C (Type u_1)) (a : C) (x : F.obj a Γ— G.obj a), (((CategoryTheory.FunctorToTypes.binaryProductIso F G).hom.app a ((CategoryTheory.FunctorToTypes.binaryProductIso F G).inv.app a (x.1, x.2))).1, ((CategoryTheory.FunctorToTypes.binaryProductIso F G).hom.app a ((CategoryTheory.FunctorToTypes.binaryProductIso F G).inv.app a (x.1, x.2))).2) = x
Lean.ModuleSetup.mk
Lean.Setup
Lean.Name β†’ Bool β†’ Option (Array Lean.Import) β†’ Lean.NameMap Lean.ImportArtifacts β†’ Array System.FilePath β†’ Array System.FilePath β†’ Lean.LeanOptions β†’ Lean.ModuleSetup
ContinuousMap.comp.eq_1
Mathlib.Condensed.TopComparison
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} [inst : TopologicalSpace Ξ±] [inst_1 : TopologicalSpace Ξ²] [inst_2 : TopologicalSpace Ξ³] (f : C(Ξ², Ξ³)) (g : C(Ξ±, Ξ²)), f.comp g = { toFun := ⇑f ∘ ⇑g, continuous_toFun := β‹― }
LLVM.instNonemptyModule
Lean.Compiler.IR.LLVMBindings
βˆ€ {ctx : LLVM.Context}, Nonempty (LLVM.Module ctx)
Lean.Parser.parserAliases2infoRef
Lean.Parser.Extension
IO.Ref (Lean.NameMap Lean.Parser.ParserAliasInfo)
FirstOrder.Language.Substructure.mem_comap
Mathlib.ModelTheory.Substructures
βˆ€ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N] {S : L.Substructure N} {f : L.Hom M N} {x : M}, x ∈ FirstOrder.Language.Substructure.comap f S ↔ f x ∈ S
CategoryTheory.Presieve.BindStruct.hf
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), S self.f
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser.evalStatsReport?.match_4
Aesop.Frontend.Command
(motive : DoResultPR Aesop.StatsReport (Option Aesop.StatsReport) PUnit.{1} β†’ Sort u_1) β†’ (r : DoResultPR Aesop.StatsReport (Option Aesop.StatsReport) PUnit.{1}) β†’ ((a : Aesop.StatsReport) β†’ (u : PUnit.{1}) β†’ motive (DoResultPR.pure a u)) β†’ ((b : Option Aesop.StatsReport) β†’ (u : PUnit.{1}) β†’ motive (DoResultPR.return b u)) β†’ motive r
EuclideanGeometry.sin_oangle_right_mul_dist_of_oangle_eq_pi_div_two
Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle
βˆ€ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P] [inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)] {p₁ pβ‚‚ p₃ : P}, EuclideanGeometry.oangle p₁ pβ‚‚ p₃ = ↑(Real.pi / 2) β†’ (EuclideanGeometry.oangle pβ‚‚ p₃ p₁).sin * dist p₁ p₃ = dist p₁ pβ‚‚
Algebra.Generators.compLocalizationAwayAlgHom_relation_eq_zero
Mathlib.RingTheory.Extension.Cotangent.LocalizationAway
βˆ€ {R : Type u_1} {S : Type u_2} {T : Type u_3} {ΞΉ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] (g : S) [inst_7 : IsLocalization.Away g T] (P : Algebra.Generators R S ΞΉ), (Algebra.Generators.compLocalizationAwayAlgHom T g P) ((MvPolynomial.rename Sum.inr) (P.Οƒ g) * MvPolynomial.X (Sum.inl ()) - 1) = 0
SSet.coskAdj
Mathlib.AlgebraicTopology.SimplicialSet.Basic
(n : β„•) β†’ SSet.truncation n ⊣ SSet.Truncated.cosk n
CochainComplex.mappingCone.d_fst_v'
Mathlib.Algebra.Homology.HomotopyCategory.MappingCone
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {F G : CochainComplex C β„€} (Ο† : F ⟢ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber Ο†] (i j : β„€) (hij : i + 1 = j), CategoryTheory.CategoryStruct.comp ((CochainComplex.mappingCone Ο†).d (i - 1) i) ((↑(CochainComplex.mappingCone.fst Ο†)).v i j hij) = -CategoryTheory.CategoryStruct.comp ((↑(CochainComplex.mappingCone.fst Ο†)).v (i - 1) i β‹―) (F.d i j)
enorm_ne_zero
Mathlib.Analysis.Normed.Group.Basic
βˆ€ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ENormedAddMonoid E] {a : E}, β€–aβ€–β‚‘ β‰  0 ↔ a β‰  0
SSet.PtSimplex.MulStruct.mk._flat_ctor
Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct
{X : SSet} β†’ {n : β„•} β†’ {x : X.obj (Opposite.op (SimplexCategory.mk 0))} β†’ {f g fg : X.PtSimplex n x} β†’ {i : Fin n} β†’ (map : SSet.stdSimplex.obj (SimplexCategory.mk (n + 1)) ⟢ X) β†’ autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.Ξ΄ i.castSucc.castSucc) map = g.map) SSet.PtSimplex.MulStruct.Ξ΄_castSucc_castSucc_map._autoParam β†’ autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.Ξ΄ i.castSucc.succ) map = fg.map) SSet.PtSimplex.MulStruct.Ξ΄_succ_castSucc_map._autoParam β†’ autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.Ξ΄ i.succ.succ) map = f.map) SSet.PtSimplex.MulStruct.Ξ΄_succ_succ_map._autoParam β†’ autoParam (βˆ€ j < i.castSucc.castSucc, CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.Ξ΄ j) map = SSet.const x) SSet.PtSimplex.MulStruct.Ξ΄_map_of_lt._autoParam β†’ autoParam (βˆ€ (j : Fin (n + 2)), i.succ.succ < j β†’ CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.Ξ΄ j) map = SSet.const x) SSet.PtSimplex.MulStruct.Ξ΄_map_of_gt._autoParam β†’ f.MulStruct g fg i
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.mkBelowMatcher._sparseCasesOn_7
Lean.Meta.IndPredBelow
{motive : Bool β†’ Sort u} β†’ (t : Bool) β†’ motive false β†’ (t.ctorIdx β‰  0 β†’ motive t) β†’ motive t
Std.Iterators.Array.iter_equiv_iter_toList
Std.Data.Iterators.Lemmas.Producers.Array
βˆ€ {Ξ± : Type w} {array : Array Ξ±}, array.iter.Equiv array.toList.iter
ENNReal.coe_iInf._simp_1
Mathlib.Data.ENNReal.Basic
βˆ€ {ΞΉ : Sort u_3} [Nonempty ΞΉ] (f : ΞΉ β†’ NNReal), β¨… a, ↑(f a) = ↑(iInf f)
_private.Mathlib.Algebra.Ring.Divisibility.Lemmas.0.dvd_smul_of_dvd.match_1_1
Mathlib.Algebra.Ring.Divisibility.Lemmas
βˆ€ {R : Type u_1} [inst : Semigroup R] {x y : R} (motive : x ∣ y β†’ Prop) (h : x ∣ y), (βˆ€ (k : R) (hk : y = x * k), motive β‹―) β†’ motive h
_private.Mathlib.Analysis.PSeries.0.summable_schlomilch_iff_of_nonneg._simp_1_1
Mathlib.Analysis.PSeries
βˆ€ {r₁ rβ‚‚ : NNReal}, (↑r₁ ≀ ↑rβ‚‚) = (r₁ ≀ rβ‚‚)
KaehlerDifferential.quotKerTotalEquiv._proof_2
Mathlib.RingTheory.Kaehler.Basic
βˆ€ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S], KaehlerDifferential.kerTotal R S ≀ LinearMap.ker (Finsupp.linearCombination S ⇑(KaehlerDifferential.D R S))
Filter.lift_principal2
Mathlib.Order.Filter.Lift
βˆ€ {Ξ± : Type u_1} {f : Filter Ξ±}, f.lift Filter.principal = f
Commute.pow_pow_self
Mathlib.Algebra.Group.Commute.Defs
βˆ€ {M : Type u_2} [inst : Monoid M] (a : M) (m n : β„•), Commute (a ^ m) (a ^ n)
Lean.Lsp.Registration.noConfusionType
Lean.Data.Lsp.Client
Sort u β†’ Lean.Lsp.Registration β†’ Lean.Lsp.Registration β†’ Sort u
Int.natAbs_eq_iff
Init.Data.Int.Order
βˆ€ {a : β„€} {n : β„•}, a.natAbs = n ↔ a = ↑n ∨ a = -↑n
MeasureTheory.L1.setToL1'.congr_simp
Mathlib.MeasureTheory.Integral.SetToL1
βˆ€ {Ξ± : Type u_1} {E : Type u_2} {F : Type u_3} (π•œ : Type u_6) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} [inst_4 : NormedRing π•œ] [inst_5 : Module π•œ E] [inst_6 : Module π•œ F] [inst_7 : IsBoundedSMul π•œ E] [inst_8 : IsBoundedSMul π•œ F] [inst_9 : CompleteSpace F] {T T_1 : Set Ξ± β†’ E β†’L[ℝ] F} (e_T : T = T_1) {C C_1 : ℝ} (e_C : C = C_1) (hT : MeasureTheory.DominatedFinMeasAdditive ΞΌ T C) (h_smul : βˆ€ (c : π•œ) (s : Set Ξ±) (x : E), (T s) (c β€’ x) = c β€’ (T s) x), MeasureTheory.L1.setToL1' π•œ hT h_smul = MeasureTheory.L1.setToL1' π•œ β‹― β‹―
MeasureTheory.lpTrimToLpMeasSubgroup._proof_1
Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable
βˆ€ {Ξ± : Type u_2} (F : Type u_1) (p : ENNReal) [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace Ξ±} (ΞΌ : MeasureTheory.Measure Ξ±) (hm : m ≀ m0) (f : β†₯(MeasureTheory.Lp F p (ΞΌ.trim hm))), MeasureTheory.MemLp (↑↑f) p ΞΌ
RootPairing.Base.cartanMatrixIn_mul_diagonal_eq
Mathlib.LinearAlgebra.RootSystem.CartanMatrix
βˆ€ {ΞΉ : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (S : Type u_5) [inst_5 : CommRing S] [inst_6 : Algebra S R] {P : RootSystem ΞΉ R M N} [inst_7 : P.IsValuedIn S] (B : P.InvariantForm) (b : P.Base) [inst_8 : DecidableEq ΞΉ], ((RootPairing.Base.cartanMatrixIn S b).map ⇑(algebraMap S R) * Matrix.diagonal fun i => (B.form (P.root ↑i)) (P.root ↑i)) = 2 β€’ (BilinForm.toMatrix b.toWeightBasis) B.form
SimpleGraph.distribLattice._proof_7
Mathlib.Combinatorics.SimpleGraph.Basic
βˆ€ {V : Type u_1} (a b : SimpleGraph V), a ≀ SemilatticeSup.sup a b
CategoryTheory.prodOpEquiv._proof_3
Mathlib.CategoryTheory.Products.Basic
βˆ€ (C : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [inst_1 : CategoryTheory.Category.{u_4, u_2} D] (X : Cα΅’α΅– Γ— Dα΅’α΅–), (match CategoryTheory.CategoryStruct.id X with | (f, g) => Opposite.op (CategoryTheory.Prod.mkHom f.unop g.unop)) = CategoryTheory.CategoryStruct.id (match X with | (X, Y) => Opposite.op (Opposite.unop X, Opposite.unop Y))
CategoryTheory.Abelian.Ext.covariant_sequence_exact₃'
Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] [inst_2 : CategoryTheory.HasExt C] (X : C) {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact) (nβ‚€ n₁ : β„•) (h : nβ‚€ + 1 = n₁), { X₁ := AddCommGrpCat.of (CategoryTheory.Abelian.Ext X S.Xβ‚‚ nβ‚€), Xβ‚‚ := AddCommGrpCat.of (CategoryTheory.Abelian.Ext X S.X₃ nβ‚€), X₃ := AddCommGrpCat.of (CategoryTheory.Abelian.Ext X S.X₁ n₁), f := AddCommGrpCat.ofHom ((CategoryTheory.Abelian.Ext.mkβ‚€ S.g).postcomp X β‹―), g := AddCommGrpCat.ofHom (hS.extClass.postcomp X h), zero := β‹― }.Exact
Bimod.RightUnitorBimod.hom_right_act_hom'
Mathlib.CategoryTheory.Monoidal.Bimod
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Limits.HasCoequalizers C] {R S : CategoryTheory.Mon C} (P : Bimod R S) [inst_3 : βˆ€ (X : C), CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [inst_4 : βˆ€ (X : C), CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)], CategoryTheory.CategoryStruct.comp (P.tensorBimod (Bimod.regular S)).actRight (Bimod.RightUnitorBimod.hom P) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight (Bimod.RightUnitorBimod.hom P) S.X) P.actRight