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
NNRat.instContinuousSub
Mathlib.Topology.Instances.Rat
ContinuousSub β„šβ‰₯0
FinPartOrd.Iso.mk_inv
Mathlib.Order.Category.FinPartOrd
βˆ€ {Ξ± Ξ² : FinPartOrd} (e : ↑α.toPartOrd ≃o ↑β.toPartOrd), (FinPartOrd.Iso.mk e).inv = FinPartOrd.ofHom ↑e.symm
Std.TreeSet.Raw.min?_insert_le_self
Std.Data.TreeSet.Raw.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.TreeSet.Raw Ξ± cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k kmi : Ξ±}, (t.insert k).min?.get β‹― = kmi β†’ (cmp kmi k).isLE = true
ContinuousMap.casesOn
Mathlib.Topology.ContinuousMap.Defs
{X : Type u_1} β†’ {Y : Type u_2} β†’ [inst : TopologicalSpace X] β†’ [inst_1 : TopologicalSpace Y] β†’ {motive : C(X, Y) β†’ Sort u} β†’ (t : C(X, Y)) β†’ ((toFun : X β†’ Y) β†’ (continuous_toFun : Continuous toFun) β†’ motive { toFun := toFun, continuous_toFun := continuous_toFun }) β†’ motive t
_private.Mathlib.Topology.Instances.RatLemmas.0.Β«termβ„šβˆžΒ»
Mathlib.Topology.Instances.RatLemmas
Lean.ParserDescr
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_3
Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality
βˆ€ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal] (a : G), (↑a)⁻¹ = ↑a⁻¹
EReal.neg_eq_top_iff
Mathlib.Data.EReal.Operations
βˆ€ {x : EReal}, -x = ⊀ ↔ x = βŠ₯
ModuleCat.CoextendScalars.obj'
Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
{R : Type u₁} β†’ {S : Type uβ‚‚} β†’ [inst : Ring R] β†’ [inst_1 : Ring S] β†’ (R β†’+* S) β†’ ModuleCat R β†’ ModuleCat S
_private.Mathlib.Tactic.Push.0.Mathlib.Tactic.Push.pushNegBuiltin._sparseCasesOn_2
Mathlib.Tactic.Push
{motive : Lean.Expr β†’ Sort u} β†’ (t : Lean.Expr) β†’ ((fn arg : Lean.Expr) β†’ motive (fn.app arg)) β†’ (t.ctorIdx β‰  5 β†’ motive t) β†’ motive t
Matroid.isBasis_iff_isBasis'_subset_ground
Mathlib.Combinatorics.Matroid.Basic
βˆ€ {Ξ± : Type u_1} {M : Matroid Ξ±} {I X : Set Ξ±}, M.IsBasis I X ↔ M.IsBasis' I X ∧ X βŠ† M.E
ContinuousAffineMap.coe_const
Mathlib.Topology.Algebra.ContinuousAffineMap
βˆ€ (R : Type u_1) {V : Type u_2} {W : Type u_3} (P : Type u_4) {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W] [inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (q : Q), ⇑(ContinuousAffineMap.const R P q) = Function.const P q
Polynomial.cyclotomic.roots_eq_primitiveRoots_val
Mathlib.RingTheory.Polynomial.Cyclotomic.Roots
βˆ€ {R : Type u_1} [inst : CommRing R] {n : β„•} [inst_1 : IsDomain R] [NeZero ↑n], (Polynomial.cyclotomic n R).roots = (primitiveRoots n R).val
_private.Mathlib.Tactic.FBinop.0.FBinopElab.AnalyzeResult.maxS?._default
Mathlib.Tactic.FBinop
Option FBinopElab.SRec
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.mapGen_apply_apply_of_surjective.match_1_1
Mathlib.RingTheory.Congruence.Hom
βˆ€ {M : Type u_1} {N : Type u_2} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring N] {c : RingCon M} (f : M β†’+* N) {x y : M} (motive : (βˆƒ a b, c a b ∧ f a = f x ∧ f b = f y) β†’ Prop) (x_1 : βˆƒ a b, c a b ∧ f a = f x ∧ f b = f y), (βˆ€ (a b : M) (h₁ : c a b) (hβ‚‚ : f a = f x) (h₃ : f b = f y), motive β‹―) β†’ motive x_1
Module.FaithfullyFlat.iff_exact_iff_rTensor_exact
Mathlib.RingTheory.Flat.FaithfullyFlat.Basic
βˆ€ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], Module.FaithfullyFlat R M ↔ βˆ€ {N1 : Type (max u v)} [inst_3 : AddCommGroup N1] [inst_4 : Module R N1] {N2 : Type (max u v)} [inst_5 : AddCommGroup N2] [inst_6 : Module R N2] {N3 : Type (max u v)} [inst_7 : AddCommGroup N3] [inst_8 : Module R N3] (l12 : N1 β†’β‚—[R] N2) (l23 : N2 β†’β‚—[R] N3), Function.Exact ⇑l12 ⇑l23 ↔ Function.Exact ⇑(LinearMap.rTensor M l12) ⇑(LinearMap.rTensor M l23)
Complex.addCommGroup._proof_11
Mathlib.Data.Complex.Basic
βˆ€ (a b : β„‚), a + b = b + a
KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk._proof_2
Mathlib.NumberTheory.KummerDedekind
βˆ€ {R : Type u_1} [inst : CommRing R] {I : Ideal R} (hI : I.IsMaximal), UniqueFactorizationMonoid (Ideal (Polynomial (R β§Έ I)))
UpperSemicontinuous.inf
Mathlib.Topology.Semicontinuous
βˆ€ {Ξ± : Type u_3} {Ξ² : Type u_4} [inst : TopologicalSpace Ξ±] [inst_1 : LinearOrder Ξ²] {f g : Ξ± β†’ Ξ²}, UpperSemicontinuous f β†’ UpperSemicontinuous g β†’ UpperSemicontinuous fun x => min (f x) (g x)
Equiv.Perm.sigmaCongrRight_refl
Mathlib.Logic.Equiv.Defs
βˆ€ {Ξ± : Type u_1} {Ξ² : Ξ± β†’ Type u_2}, (Equiv.Perm.sigmaCongrRight fun a => Equiv.refl (Ξ² a)) = Equiv.refl ((a : Ξ±) Γ— Ξ² a)
UInt64.toUInt32_ofNatLT
Init.Data.UInt.Lemmas
βˆ€ {n : β„•} (hn : n < UInt64.size), (UInt64.ofNatLT n hn).toUInt32 = UInt32.ofNat n
CategoryTheory.Grp.instMonoidalCategory._proof_8
Mathlib.CategoryTheory.Monoidal.Grp_
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] [inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.Grp C} (f : X ⟢ Y), CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f (CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Grp C))) (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom f
_private.Lean.Compiler.IR.FreeVars.0.Lean.IR.MaxIndex.visitExpr
Lean.Compiler.IR.FreeVars
Lean.IR.Expr β†’ Lean.IR.MaxIndex.M Unit
ENNReal.toNNReal_zero
Mathlib.Data.ENNReal.Basic
ENNReal.toNNReal 0 = 0
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_13
Mathlib.LinearAlgebra.Goursat
βˆ€ {Ξ± : Sort u} {p : Ξ± β†’ Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2)
Aesop.PhaseSpec.safe.elim
Aesop.Builder.Basic
{motive : Aesop.PhaseSpec β†’ Sort u} β†’ (t : Aesop.PhaseSpec) β†’ t.ctorIdx = 0 β†’ ((info : Aesop.SafeRuleInfo) β†’ motive (Aesop.PhaseSpec.safe info)) β†’ motive t
Std.DTreeMap.Internal.Impl.toList_map
Std.Data.DTreeMap.Internal.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {instOrd : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} {Ξ³ : Ξ± β†’ Type w} {f : (a : Ξ±) β†’ Ξ² a β†’ Ξ³ a}, (Std.DTreeMap.Internal.Impl.map f t).toList = List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) t.toList
ContinuousLinearMap.ratio_le_opNorm
Mathlib.Analysis.Normed.Operator.Basic
βˆ€ {π•œ : Type u_1} {π•œβ‚‚ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField π•œ] [inst_3 : NontriviallyNormedField π•œβ‚‚] [inst_4 : NormedSpace π•œ E] [inst_5 : NormedSpace π•œβ‚‚ F] {σ₁₂ : π•œ β†’+* π•œβ‚‚} [RingHomIsometric σ₁₂] (f : E β†’SL[σ₁₂] F) (x : E), β€–f xβ€– / β€–xβ€– ≀ β€–fβ€–
Aesop.LocalRuleSet.mk.noConfusion
Aesop.RuleSet
(P : Sort u) β†’ (toBaseRuleSet : Aesop.BaseRuleSet) β†’ (simpTheoremsArray : Array (Lean.Name Γ— Lean.Meta.SimpTheorems)) β†’ (simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size) β†’ (simprocsArray : Array (Lean.Name Γ— Lean.Meta.Simprocs)) β†’ (simprocsArrayNonempty : 0 < simprocsArray.size) β†’ (localNormSimpRules : Array Aesop.LocalNormSimpRule) β†’ (toBaseRuleSet' : Aesop.BaseRuleSet) β†’ (simpTheoremsArray' : Array (Lean.Name Γ— Lean.Meta.SimpTheorems)) β†’ (simpTheoremsArrayNonempty' : 0 < simpTheoremsArray'.size) β†’ (simprocsArray' : Array (Lean.Name Γ— Lean.Meta.Simprocs)) β†’ (simprocsArrayNonempty' : 0 < simprocsArray'.size) β†’ (localNormSimpRules' : Array Aesop.LocalNormSimpRule) β†’ { toBaseRuleSet := toBaseRuleSet, simpTheoremsArray := simpTheoremsArray, simpTheoremsArrayNonempty := simpTheoremsArrayNonempty, simprocsArray := simprocsArray, simprocsArrayNonempty := simprocsArrayNonempty, localNormSimpRules := localNormSimpRules } = { toBaseRuleSet := toBaseRuleSet', simpTheoremsArray := simpTheoremsArray', simpTheoremsArrayNonempty := simpTheoremsArrayNonempty', simprocsArray := simprocsArray', simprocsArrayNonempty := simprocsArrayNonempty', localNormSimpRules := localNormSimpRules' } β†’ (toBaseRuleSet = toBaseRuleSet' β†’ simpTheoremsArray = simpTheoremsArray' β†’ simprocsArray = simprocsArray' β†’ localNormSimpRules = localNormSimpRules' β†’ P) β†’ P
Nonneg.nat_ceil_coe
Mathlib.Algebra.Order.Nonneg.Floor
βˆ€ {Ξ± : Type u_1} [inst : Semiring Ξ±] [inst_1 : PartialOrder Ξ±] [inst_2 : IsOrderedRing Ξ±] [inst_3 : FloorSemiring Ξ±] (a : { r // 0 ≀ r }), βŒˆβ†‘aβŒ‰β‚Š = ⌈aβŒ‰β‚Š
Std.DTreeMap.Internal.Impl.minKey?_insert!_le_minKey?
Std.Data.DTreeMap.Internal.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {instOrd : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} [inst : Std.TransOrd Ξ±] (h : t.WF) {k : Ξ±} {v : Ξ² k} {km kmi : Ξ±}, t.minKey? = some km β†’ (Std.DTreeMap.Internal.Impl.insert! k v t).minKey?.get β‹― = kmi β†’ (compare kmi km).isLE = true
Set.inclusion_inclusion
Mathlib.Data.Set.Inclusion
βˆ€ {Ξ± : Type u_1} {s t u : Set Ξ±} (hst : s βŠ† t) (htu : t βŠ† u) (x : ↑s), Set.inclusion htu (Set.inclusion hst x) = Set.inclusion β‹― x
CategoryTheory.ShortComplex.SnakeInput.Lβ‚€'_exact
Mathlib.Algebra.Homology.ShortComplex.SnakeLemma
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex.SnakeInput C), S.Lβ‚€'.Exact
Sym.coe_equivNatSumOfFintype_apply_apply
Mathlib.Data.Finsupp.Multiset
βˆ€ (Ξ± : Type u_1) [inst : DecidableEq Ξ±] (n : β„•) [inst_1 : Fintype Ξ±] (s : Sym Ξ± n) (a : Ξ±), ↑((Sym.equivNatSumOfFintype Ξ± n) s) a = Multiset.count a ↑s
Aesop.Script.STactic.ctorIdx
Aesop.Script.Tactic
Aesop.Script.STactic β†’ β„•
SemiNormedGrp.explicitCokernel
Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels
{X Y : SemiNormedGrp} β†’ (X ⟢ Y) β†’ SemiNormedGrp
Lean.Grind.Linarith.le_lt_combine_cert
Init.Grind.Ordered.Linarith
Lean.Grind.Linarith.Poly β†’ Lean.Grind.Linarith.Poly β†’ Lean.Grind.Linarith.Poly β†’ Bool
AddSubsemigroup.toSubsemigroup_closure
Mathlib.Algebra.Group.Subsemigroup.Operations
βˆ€ {A : Type u_5} [inst : Add A] (S : Set A), AddSubsemigroup.toSubsemigroup (AddSubsemigroup.closure S) = Subsemigroup.closure (⇑Multiplicative.toAdd ⁻¹' S)
Lean.Expr.containsFVar
Lean.Expr
Lean.Expr β†’ Lean.FVarId β†’ Bool
_private.Batteries.Data.Char.Basic.0.Char.of_any_eq_false_aux._proof_1_12
Batteries.Data.Char.Basic
βˆ€ {p : Char β†’ Bool} (n : β„•), n.isValidChar β†’ ((βˆ€ x ∈ List.finRange Char.minSurrogate, Β¬p (Char.ofNatAux ↑x β‹―) = true) ∧ βˆ€ x ∈ List.finRange (Char.max - Char.maxSurrogate), Β¬p (Char.ofNatAux (↑x + Char.maxSurrogate + 1) β‹―) = true) β†’ βˆ€ (hn : n < 55296), Β¬p (Char.ofNatAux β†‘βŸ¨n, hn⟩ β‹―) = true β†’ p (Char.ofNatAux n β‹―) = false
Aesop.instToJsonPhaseName.toJson
Aesop.Rule.Name
Aesop.PhaseName β†’ Lean.Json
_private.Lean.Elab.Match.0.Lean.Elab.Term.getIndexToInclude?
Lean.Elab.Match
Lean.Expr β†’ List β„• β†’ Lean.Elab.TermElabM (Option Lean.Expr)
Std.DTreeMap.Internal.Impl.toListModel_insertMin
Std.Data.DTreeMap.Internal.WF.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} [Ord Ξ±] {k : Ξ±} {v : Ξ² k} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} {h : t.Balanced}, (Std.DTreeMap.Internal.Impl.insertMin k v t h).impl.toListModel = ⟨k, v⟩ :: t.toListModel
_auto._@.Mathlib.AlgebraicTopology.SimplicialSet.CompStruct.1528653550._hygCtx._hyg.93
Mathlib.AlgebraicTopology.SimplicialSet.CompStruct
Lean.Syntax
ContinuousAffineMap._sizeOf_inst
Mathlib.Topology.Algebra.ContinuousAffineMap
(R : Type u_1) β†’ {V : Type u_2} β†’ {W : Type u_3} β†’ (P : Type u_4) β†’ (Q : Type u_5) β†’ {inst : Ring R} β†’ {inst_1 : AddCommGroup V} β†’ {inst_2 : Module R V} β†’ {inst_3 : TopologicalSpace P} β†’ {inst_4 : AddTorsor V P} β†’ {inst_5 : AddCommGroup W} β†’ {inst_6 : Module R W} β†’ {inst_7 : TopologicalSpace Q} β†’ {inst_8 : AddTorsor W Q} β†’ [SizeOf R] β†’ [SizeOf V] β†’ [SizeOf W] β†’ [SizeOf P] β†’ [SizeOf Q] β†’ SizeOf (P →ᴬ[R] Q)
MulOpposite.instNonUnitalCommCStarAlgebra._proof_1
Mathlib.Analysis.CStarAlgebra.Classes
βˆ€ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CompleteSpace Aᡐᡒᡖ
FormalMultilinearSeries.ofScalars_radius_eq_inv_of_tendsto_ENNReal
Mathlib.Analysis.Analytic.OfScalars
βˆ€ {π•œ : Type u_1} (E : Type u_2) [inst : NontriviallyNormedField π•œ] [inst_1 : NormedRing E] [inst_2 : NormedAlgebra π•œ E] (c : β„• β†’ π•œ) [NormOneClass E] {r : ENNReal}, Filter.Tendsto (fun n => ENNReal.ofReal β€–c n.succβ€– / ENNReal.ofReal β€–c nβ€–) Filter.atTop (nhds r) β†’ (FormalMultilinearSeries.ofScalars E c).radius = r⁻¹
LinearIsometryEquiv.instEquivLike._proof_1
Mathlib.Analysis.Normed.Operator.LinearIsometry
βˆ€ {R : Type u_1} {Rβ‚‚ : Type u_2} {E : Type u_3} {Eβ‚‚ : Type u_4} [inst : Semiring R] [inst_1 : Semiring Rβ‚‚] {σ₁₂ : R β†’+* Rβ‚‚} {σ₂₁ : Rβ‚‚ β†’+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] [inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup Eβ‚‚] [inst_6 : Module R E] [inst_7 : Module Rβ‚‚ Eβ‚‚] (e : E ≃ₛₗᡒ[σ₁₂] Eβ‚‚), Function.LeftInverse e.invFun (↑e.toLinearEquiv).toFun
_private.Init.Data.Iterators.Consumers.Access.0.Std.Iterators.Iter.atIdxSlow?.match_3.eq_3
Init.Data.Iterators.Consumers.Access
βˆ€ {Ξ± Ξ² : Type u_1} [inst : Std.Iterators.Iterator Ξ± Id Ξ²] (it : Std.Iter Ξ²) (motive : it.Step β†’ Sort u_2) (property : it.IsPlausibleStep Std.Iterators.IterStep.done) (h_1 : (it' : Std.Iter Ξ²) β†’ (out : Ξ²) β†’ (property : it.IsPlausibleStep (Std.Iterators.IterStep.yield it' out)) β†’ motive ⟨Std.Iterators.IterStep.yield it' out, property⟩) (h_2 : (it' : Std.Iter Ξ²) β†’ (property : it.IsPlausibleStep (Std.Iterators.IterStep.skip it')) β†’ motive ⟨Std.Iterators.IterStep.skip it', property⟩) (h_3 : (property : it.IsPlausibleStep Std.Iterators.IterStep.done) β†’ motive ⟨Std.Iterators.IterStep.done, property⟩), (match ⟨Std.Iterators.IterStep.done, property⟩ with | ⟨Std.Iterators.IterStep.yield it' out, property⟩ => h_1 it' out property | ⟨Std.Iterators.IterStep.skip it', property⟩ => h_2 it' property | ⟨Std.Iterators.IterStep.done, property⟩ => h_3 property) = h_3 property
CategoryTheory.ShortComplex.Homotopy.sub
Mathlib.Algebra.Homology.ShortComplex.Preadditive
{C : Type u_1} β†’ [inst : CategoryTheory.Category.{u_2, u_1} C] β†’ [inst_1 : CategoryTheory.Preadditive C] β†’ {S₁ Sβ‚‚ : CategoryTheory.ShortComplex C} β†’ {φ₁ Ο†β‚‚ φ₃ Ο†β‚„ : S₁ ⟢ Sβ‚‚} β†’ CategoryTheory.ShortComplex.Homotopy φ₁ Ο†β‚‚ β†’ CategoryTheory.ShortComplex.Homotopy φ₃ Ο†β‚„ β†’ CategoryTheory.ShortComplex.Homotopy (φ₁ - φ₃) (Ο†β‚‚ - Ο†β‚„)
Batteries.CodeAction.TacticCodeActionEntry.mk.inj
Batteries.CodeAction.Attr
βˆ€ {declName : Lean.Name} {tacticKinds : Array Lean.Name} {declName_1 : Lean.Name} {tacticKinds_1 : Array Lean.Name}, { declName := declName, tacticKinds := tacticKinds } = { declName := declName_1, tacticKinds := tacticKinds_1 } β†’ declName = declName_1 ∧ tacticKinds = tacticKinds_1
Finset.min'_eq_sorted_zero
Mathlib.Data.Finset.Sort
βˆ€ {Ξ± : Type u_1} [inst : LinearOrder Ξ±] {s : Finset Ξ±} {h : s.Nonempty}, s.min' h = (s.sort fun a b => a ≀ b)[0]
Finsupp.orderIsoMultiset._simp_2
Mathlib.Data.Finsupp.Multiset
βˆ€ {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {s t : Multiset Ξ±}, (s ≀ t) = βˆ€ (a : Ξ±), Multiset.count a s ≀ Multiset.count a t
RingCon.coe_zsmul._simp_1
Mathlib.RingTheory.Congruence.Defs
βˆ€ {R : Type u_1} [inst : AddGroup R] [inst_1 : Mul R] (c : RingCon R) (z : β„€) (x : R), z β€’ ↑x = ↑(z β€’ x)
Function.update_comp_eq_of_forall_ne'
Mathlib.Logic.Function.Basic
βˆ€ {Ξ± : Sort u} {Ξ² : Ξ± β†’ Sort v} [inst : DecidableEq Ξ±] {Ξ±' : Sort u_1} (g : (a : Ξ±) β†’ Ξ² a) {f : Ξ±' β†’ Ξ±} {i : Ξ±} (a : Ξ² i), (βˆ€ (x : Ξ±'), f x β‰  i) β†’ (fun j => Function.update g i a (f j)) = fun j => g (f j)
Module.Finite.exists_fin_quot_equiv
Mathlib.RingTheory.Finiteness.Cardinality
βˆ€ (R : Type u_3) (M : Type u_4) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M], βˆƒ n S, Nonempty (((Fin n β†’ R) β§Έ S) ≃ₗ[R] M)
Lean.Lsp.TextDocumentEdit.ctorIdx
Lean.Data.Lsp.Basic
Lean.Lsp.TextDocumentEdit β†’ β„•
Vector.instDecidableExistsVectorZero
Init.Data.Vector.Lemmas
{Ξ± : Type u_1} β†’ (P : Vector Ξ± 0 β†’ Prop) β†’ [Decidable (P #v[])] β†’ Decidable (βˆƒ xs, P xs)
AddCommGrpCat.hasColimit_of_small_quot
Mathlib.Algebra.Category.Grp.Colimits
βˆ€ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat) [inst_1 : DecidableEq J], Small.{w, max u w} (AddCommGrpCat.Colimits.Quot F) β†’ CategoryTheory.Limits.HasColimit F
_private.Mathlib.Topology.Inseparable.0.inseparable_prod._simp_1_2
Mathlib.Topology.Inseparable
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {f₁ fβ‚‚ : Filter Ξ±} {g₁ gβ‚‚ : Filter Ξ²} [f₁.NeBot] [g₁.NeBot], (f₁ Γ—Λ’ g₁ = fβ‚‚ Γ—Λ’ gβ‚‚) = (f₁ = fβ‚‚ ∧ g₁ = gβ‚‚)
Subsemigroup.comap_top
Mathlib.Algebra.Group.Subsemigroup.Operations
βˆ€ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (f : M β†’β‚™* N), Subsemigroup.comap f ⊀ = ⊀
MeasureTheory.SimpleFunc.instNonAssocSemiring._proof_4
Mathlib.MeasureTheory.Function.SimpleFunc
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : MeasurableSpace Ξ±] [inst_1 : NonAssocSemiring Ξ²] (a : MeasureTheory.SimpleFunc Ξ± Ξ²), 1 * a = a
CategoryTheory.linearCoyoneda._proof_3
Mathlib.CategoryTheory.Linear.Yoneda
βˆ€ (R : Type u_3) [inst : Ring R] (C : Type u_2) [inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {Y₁ Yβ‚‚ : Cα΅’α΅–} (f : Y₁ ⟢ Yβ‚‚) ⦃X Y : C⦄ (f_1 : X ⟢ Y), CategoryTheory.CategoryStruct.comp ({ obj := fun X => ModuleCat.of R (Opposite.unop Y₁ ⟢ X), map := fun {X Y} f => ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite.unop Y₁) f), map_id := β‹―, map_comp := β‹― }.map f_1) (ModuleCat.ofHom (CategoryTheory.Linear.leftComp R Y f.unop)) = CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (CategoryTheory.Linear.leftComp R X f.unop)) ({ obj := fun X => ModuleCat.of R (Opposite.unop Yβ‚‚ ⟢ X), map := fun {X Y} f => ModuleCat.ofHom (CategoryTheory.Linear.rightComp R (Opposite.unop Yβ‚‚) f), map_id := β‹―, map_comp := β‹― }.map f_1)
_private.Mathlib.RingTheory.Polynomial.Bernstein.0.bernsteinPolynomial.variance._simp_1_2
Mathlib.RingTheory.Polynomial.Bernstein
βˆ€ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c
normalize_eq_zero._simp_1
Mathlib.Algebra.GCDMonoid.Basic
βˆ€ {Ξ± : Type u_1} [inst : CancelCommMonoidWithZero Ξ±] [inst_1 : NormalizationMonoid Ξ±] {x : Ξ±}, (normalize x = 0) = (x = 0)
CategoryTheory.Functor.mapCoconeWhisker_hom_hom
Mathlib.CategoryTheory.Limits.Cones
βˆ€ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type uβ‚‚} [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} K] {C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {D : Type uβ‚„} [inst_3 : CategoryTheory.Category.{vβ‚„, uβ‚„} D] (H : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C} {E : CategoryTheory.Functor K J} {c : CategoryTheory.Limits.Cocone F}, H.mapCoconeWhisker.hom.hom = CategoryTheory.CategoryStruct.id (H.obj c.pt)
Polynomial.orderOf_root_cyclotomic_dvd
Mathlib.RingTheory.Polynomial.Cyclotomic.Basic
βˆ€ {n : β„•} (hpos : 0 < n) {p : β„•} [inst : Fact (Nat.Prime p)] {a : β„•} (hroot : (Polynomial.cyclotomic n (ZMod p)).IsRoot ((Nat.castRingHom (ZMod p)) a)), orderOf (ZMod.unitOfCoprime a β‹―) ∣ n
Equiv.setCongr
Mathlib.Logic.Equiv.Set
{Ξ± : Type u_3} β†’ {s t : Set Ξ±} β†’ s = t β†’ ↑s ≃ ↑t
_private.Mathlib.GroupTheory.SpecificGroups.Dihedral.0.instDecidableEqDihedralGroup.decEq.match_1.eq_4
Mathlib.GroupTheory.SpecificGroups.Dihedral
βˆ€ {n : β„•} (motive : DihedralGroup n β†’ DihedralGroup n β†’ Sort u_1) (a b : ZMod n) (h_1 : (a b : ZMod n) β†’ motive (DihedralGroup.r a) (DihedralGroup.r b)) (h_2 : (a a_1 : ZMod n) β†’ motive (DihedralGroup.r a) (DihedralGroup.sr a_1)) (h_3 : (a a_1 : ZMod n) β†’ motive (DihedralGroup.sr a) (DihedralGroup.r a_1)) (h_4 : (a b : ZMod n) β†’ motive (DihedralGroup.sr a) (DihedralGroup.sr b)), (match DihedralGroup.sr a, DihedralGroup.sr b with | DihedralGroup.r a, DihedralGroup.r b => h_1 a b | DihedralGroup.r a, DihedralGroup.sr a_1 => h_2 a a_1 | DihedralGroup.sr a, DihedralGroup.r a_1 => h_3 a a_1 | DihedralGroup.sr a, DihedralGroup.sr b => h_4 a b) = h_4 a b
antitone_toDual_comp_iff
Mathlib.Order.Monotone.Basic
βˆ€ {Ξ± : Type u} {Ξ² : Type v} [inst : Preorder Ξ±] [inst_1 : Preorder Ξ²] {f : Ξ± β†’ Ξ²}, Antitone (⇑OrderDual.toDual ∘ f) ↔ Monotone f
MulEquiv.piMultiplicative._proof_2
Mathlib.Algebra.Group.Equiv.TypeTags
βˆ€ {ΞΉ : Type u_2} (K : ΞΉ β†’ Type u_1) (x : (i : ΞΉ) β†’ Multiplicative (K i)), (fun i => Multiplicative.ofAdd (Multiplicative.toAdd (Multiplicative.ofAdd fun i => Multiplicative.toAdd (x i)) i)) = fun i => Multiplicative.ofAdd (Multiplicative.toAdd (Multiplicative.ofAdd fun i => Multiplicative.toAdd (x i)) i)
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Basic.0.Pi.opensMeasurableSpace_of_subsingleton._simp_2
Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [t : TopologicalSpace Ξ²] {f : Ξ± β†’ Ξ²} {s : Set Ξ±}, IsOpen s = (s ∈ Set.preimage f '' {s | IsOpen s})
_private.Init.Data.BitVec.Lemmas.0.BitVec.shiftLeft_eq_concat_of_lt._proof_1_1
Init.Data.BitVec.Lemmas
βˆ€ {w n : β„•}, βˆ€ i < w, Β¬i < n β†’ Β¬i - n < w β†’ False
ContDiffMapSupportedIn._sizeOf_inst
Mathlib.Analysis.Distribution.ContDiffMapSupportedIn
(E : Type u_2) β†’ (F : Type u_3) β†’ {inst : NormedAddCommGroup E} β†’ {inst_1 : NormedSpace ℝ E} β†’ {inst_2 : NormedAddCommGroup F} β†’ {inst_3 : NormedSpace ℝ F} β†’ (n : β„•βˆž) β†’ (K : TopologicalSpace.Compacts E) β†’ [SizeOf E] β†’ [SizeOf F] β†’ SizeOf (ContDiffMapSupportedIn E F n K)
Rep.indCoindIso
Mathlib.RepresentationTheory.FiniteIndex
{k G : Type u} β†’ [inst : CommRing k] β†’ [inst_1 : Group G] β†’ {S : Subgroup G} β†’ [DecidableRel ⇑(QuotientGroup.rightRel S)] β†’ (A : Rep k β†₯S) β†’ [S.FiniteIndex] β†’ Rep.ind S.subtype A β‰… Rep.coind S.subtype A
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.sups_aux
Mathlib.Combinatorics.SetFamily.AhlswedeZhang
βˆ€ {Ξ± : Type u_1} [inst : DistribLattice Ξ±] [inst_1 : DecidableEq Ξ±] {s t : Finset Ξ±} {a : Ξ±}, a ∈ upperClosure ↑(s ⊻ t) ↔ a ∈ upperClosure ↑s ∧ a ∈ upperClosure ↑t
Associates.instLattice.congr_simp
Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid
βˆ€ {Ξ± : Type u_1} [inst : CancelCommMonoidWithZero Ξ±] [inst_1 : UniqueFactorizationMonoid Ξ±], Associates.instLattice = Associates.instLattice
List.reverseAux_reverseAux_nil
Init.Data.List.Lemmas
βˆ€ {Ξ± : Type u_1} {as bs : List Ξ±}, (as.reverseAux bs).reverseAux [] = bs.reverseAux as
CategoryTheory.eHom_whisker_cancel_inv
Mathlib.CategoryTheory.Enriched.Ordinary.Basic
βˆ€ (V : Type u') [inst : CategoryTheory.Category.{v', u'} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] {X Y Y₁ Z : C} (Ξ± : Y β‰… Y₁), CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.eHomWhiskerLeft V X Ξ±.inv) (Y₁ ⟢[V] Z)) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft (X ⟢[V] Y) (CategoryTheory.eHomWhiskerRight V Ξ±.hom Z)) (CategoryTheory.eComp V X Y Z)) = CategoryTheory.eComp V X Y₁ Z
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.Forall.match_1.eq_1
Mathlib.Data.Fin.Tuple.Reflection
βˆ€ {Ξ± : Type u_2} (motive : (x : β„•) β†’ ((Fin x β†’ Ξ±) β†’ Prop) β†’ Sort u_1) (P : (Fin 0 β†’ Ξ±) β†’ Prop) (h_1 : (P : (Fin 0 β†’ Ξ±) β†’ Prop) β†’ motive 0 P) (h_2 : (n : β„•) β†’ (P : (Fin (n + 1) β†’ Ξ±) β†’ Prop) β†’ motive n.succ P), (match 0, P with | 0, P => h_1 P | n.succ, P => h_2 n P) = h_1 P
Module.Basis.range_extend
Mathlib.LinearAlgebra.Basis.VectorSpace
βˆ€ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V} (hs : LinearIndepOn K id s), Set.range ⇑(Module.Basis.extend hs) = hs.extend β‹―
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Meta.Grind.AC.withExprs.go.match_1.eq_2
Lean.Meta.Tactic.Grind.AC.Eq
βˆ€ (motive : List β„• β†’ List β„• β†’ Sort u_1) (x : List β„•) (h_1 : (x : List β„•) β†’ motive [] x) (h_2 : (x : List β„•) β†’ motive x []) (h_3 : (id₁ : β„•) β†’ (ids₁ : List β„•) β†’ (idβ‚‚ : β„•) β†’ (idsβ‚‚ : List β„•) β†’ motive (id₁ :: ids₁) (idβ‚‚ :: idsβ‚‚)), (x = [] β†’ False) β†’ (match x, [] with | [], x => h_1 x | x, [] => h_2 x | id₁ :: ids₁, idβ‚‚ :: idsβ‚‚ => h_3 id₁ ids₁ idβ‚‚ idsβ‚‚) = h_2 x
NonUnitalSubsemiring.prodEquiv
Mathlib.RingTheory.NonUnitalSubsemiring.Basic
{R : Type u} β†’ {S : Type v} β†’ [inst : NonUnitalNonAssocSemiring R] β†’ [inst_1 : NonUnitalNonAssocSemiring S] β†’ (s : NonUnitalSubsemiring R) β†’ (t : NonUnitalSubsemiring S) β†’ β†₯(s.prod t) ≃+* β†₯s Γ— β†₯t
Std.TreeMap.Raw.contains_iff_mem._simp_1
Std.Data.TreeMap.Raw.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.TreeMap.Raw Ξ± Ξ² cmp} {k : Ξ±}, (t.contains k = true) = (k ∈ t)
Lean.Elab.Command.InductiveElabStep2
Lean.Elab.MutualInductive
Type
Lean.Meta.Grind.AC.ProofM.State.exprDecls
Lean.Meta.Tactic.Grind.AC.Proof
Lean.Meta.Grind.AC.ProofM.State β†’ Std.HashMap Lean.Grind.AC.Expr Lean.Expr
Lean.Parser.Module.prelude
Lean.Parser.Module
Lean.Parser.Parser
Array.getElem_toList
Init.Data.Array.Basic
βˆ€ {Ξ± : Type u} {xs : Array Ξ±} {i : β„•} (h : i < xs.size), xs.toList[i] = xs[i]
Aesop.PatSubstSource.casesOn
Aesop.Forward.State
{motive : Aesop.PatSubstSource β†’ Sort u} β†’ (t : Aesop.PatSubstSource) β†’ ((fvarId : Lean.FVarId) β†’ motive (Aesop.PatSubstSource.hyp fvarId)) β†’ motive Aesop.PatSubstSource.target β†’ motive t
LieHom.mem_idealRange_iff._simp_1
Mathlib.Algebra.Lie.Ideal
βˆ€ {R : Type u} {L : Type v} {L' : Type wβ‚‚} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L'] [inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L'), f.IsIdealMorphism β†’ βˆ€ {y : L'}, (y ∈ f.idealRange) = βˆƒ x, f x = y
MeasureTheory.innerRegular_map_add_left
Mathlib.MeasureTheory.Group.Measure
βˆ€ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {ΞΌ : MeasureTheory.Measure G} [inst_3 : AddGroup G] [IsTopologicalAddGroup G] [ΞΌ.InnerRegular] (g : G), (MeasureTheory.Measure.map (fun x => g + x) ΞΌ).InnerRegular
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_of_finite._simp_1_2
Mathlib.RingTheory.Support
βˆ€ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M) (r : R), (r ∈ (R βˆ™ g).annihilator) = (r β€’ g = 0)
CategoryTheory.ObjectProperty.strictLimitsOfShape_monotone
Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P : CategoryTheory.ObjectProperty C} (J : Type u') [inst_1 : CategoryTheory.Category.{v', u'} J] {Q : CategoryTheory.ObjectProperty C}, P ≀ Q β†’ P.strictLimitsOfShape J ≀ Q.strictLimitsOfShape J
List.eraseIdx_modify_of_eq
Init.Data.List.Nat.Modify
βˆ€ {Ξ± : Type u_1} (f : Ξ± β†’ Ξ±) (i : β„•) (l : List Ξ±), (l.modify i f).eraseIdx i = l.eraseIdx i
ULift.ring._proof_3
Mathlib.Algebra.Ring.ULift
βˆ€ {R : Type u_2} [inst : Ring R] (n : β„•) (a : ULift.{u_1, u_2} R), SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a
AEMeasurable.cexp
Mathlib.MeasureTheory.Function.SpecialFunctions.Basic
βˆ€ {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} {f : Ξ± β†’ β„‚}, AEMeasurable f ΞΌ β†’ AEMeasurable (fun x => Complex.exp (f x)) ΞΌ
Lean.MonadFileMap.noConfusion
Lean.Data.Position
{m : Type β†’ Type} β†’ {P : Sort u} β†’ {x1 x2 : Lean.MonadFileMap m} β†’ x1 = x2 β†’ Lean.MonadFileMap.noConfusionType P x1 x2
Polynomial.aeval.eq_1
Mathlib.RingTheory.AdjoinRoot
βˆ€ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A), Polynomial.aeval x = Polynomial.evalβ‚‚AlgHom' (Algebra.ofId R A) x β‹―
TopCat.Presheaf.isSheaf_on_punit_iff_isTerminal
Mathlib.Topology.Sheaves.PUnit
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : TopCat.Presheaf C { carrier := PUnit.{u_1 + 1}, str := instTopologicalSpacePUnit }), F.IsSheaf ↔ Nonempty (CategoryTheory.Limits.IsTerminal (F.obj (Opposite.op βŠ₯)))
CategoryTheory.ShortComplex.homologyMap_smul
Mathlib.Algebra.Homology.ShortComplex.Linear
βˆ€ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_3, u_2} C] [inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ Sβ‚‚ : CategoryTheory.ShortComplex C} (Ο† : S₁ ⟢ Sβ‚‚) (a : R) [inst_4 : S₁.HasHomology] [inst_5 : Sβ‚‚.HasHomology], CategoryTheory.ShortComplex.homologyMap (a β€’ Ο†) = a β€’ CategoryTheory.ShortComplex.homologyMap Ο†
Nat.gcd_mul_left_sub_right
Init.Data.Nat.Gcd
βˆ€ {m n k : β„•}, n ≀ m * k β†’ m.gcd (m * k - n) = m.gcd n