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
Std.Sat.AIG.Decl.rec
Std.Sat.AIG.Basic
{Ξ± : Type} β†’ {motive : Std.Sat.AIG.Decl Ξ± β†’ Sort u} β†’ motive Std.Sat.AIG.Decl.false β†’ ((idx : Ξ±) β†’ motive (Std.Sat.AIG.Decl.atom idx)) β†’ ((l r : Std.Sat.AIG.Fanin) β†’ motive (Std.Sat.AIG.Decl.gate l r)) β†’ (t : Std.Sat.AIG.Decl Ξ±) β†’ motive t
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.findCompletionInfosAt.containsHoverPos
Lean.Server.Completion.CompletionInfoSelection
String.Pos.Raw β†’ Lean.Elab.CompletionInfo β†’ Bool
SeparationQuotient.instNormedAlgebra._proof_2
Mathlib.Analysis.Normed.Module.Basic
βˆ€ (π•œ : Type u_1) {E : Type u_2} [inst : NormedField π•œ] [inst_1 : SeminormedRing E] [inst_2 : NormedAlgebra π•œ E], ContinuousConstSMul π•œ E
Equiv.funSplitAt_apply
Mathlib.Logic.Equiv.Prod
βˆ€ {Ξ± : Type u_9} [inst : DecidableEq Ξ±] (i : Ξ±) (Ξ² : Type u_10) (f : (j : Ξ±) β†’ (fun a => Ξ²) j), (Equiv.funSplitAt i Ξ²) f = (f i, fun j => f ↑j)
HurwitzZeta.completedHurwitzZetaEven_zero
Mathlib.NumberTheory.LSeries.RiemannZeta
βˆ€ (s : β„‚), HurwitzZeta.completedHurwitzZetaEven 0 s = completedRiemannZeta s
Turing.PartrecToTM2.K'.elim_update_aux
Mathlib.Computability.TMToPartrec
βˆ€ {a b c d c' : List Turing.PartrecToTM2.Ξ“'}, Function.update (Turing.PartrecToTM2.K'.elim a b c d) Turing.PartrecToTM2.K'.aux c' = Turing.PartrecToTM2.K'.elim a b c' d
MeasureTheory.exp_llr
Mathlib.MeasureTheory.Measure.LogLikelihoodRatio
βˆ€ {Ξ± : Type u_1} {mΞ± : MeasurableSpace Ξ±} (ΞΌ Ξ½ : MeasureTheory.Measure Ξ±) [MeasureTheory.SigmaFinite ΞΌ], (fun x => Real.exp (MeasureTheory.llr ΞΌ Ξ½ x)) =ᡐ[Ξ½] fun x => if ΞΌ.rnDeriv Ξ½ x = 0 then 1 else (ΞΌ.rnDeriv Ξ½ x).toReal
Lean.Elab.Deriving.mkInhabitedInstanceHandler
Lean.Elab.Deriving.Inhabited
Array Lean.Name β†’ Lean.Elab.Command.CommandElabM Bool
Finset.singleton_subset_coe._simp_1
Mathlib.Data.Finset.Insert
βˆ€ {Ξ± : Type u_1} {s : Finset Ξ±} {a : Ξ±}, ({a} βŠ† ↑s) = ({a} βŠ† s)
Lean.Meta.Match.Overlaps.mk.sizeOf_spec
Lean.Meta.Match.MatcherInfo
βˆ€ (map : Std.HashMap β„• (Std.TreeSet β„• compare)), sizeOf { map := map } = 1 + sizeOf map
CategoryTheory.Limits.BinaryBicone.inlCokernelCofork_Ο€
Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts
βˆ€ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (c : CategoryTheory.Limits.BinaryBicone X Y), CategoryTheory.Limits.Cofork.Ο€ c.inlCokernelCofork = c.snd
CategoryTheory.Presheaf.IsSheaf.amalgamate_map_assoc
Mathlib.CategoryTheory.Sites.Sheaf
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type uβ‚‚} [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} A] {E : A} {X : C} {P : CategoryTheory.Functor Cα΅’α΅– A} (hP : CategoryTheory.Presheaf.IsSheaf J P) (S : J.Cover X) (x : (I : S.Arrow) β†’ E ⟢ P.obj (Opposite.op I.Y)) (hx : βˆ€ ⦃I₁ Iβ‚‚ : S.Arrow⦄ (r : I₁.Relation Iβ‚‚), CategoryTheory.CategoryStruct.comp (x I₁) (P.map r.g₁.op) = CategoryTheory.CategoryStruct.comp (x Iβ‚‚) (P.map r.gβ‚‚.op)) (I : S.Arrow) {Z : A} (h : P.obj (Opposite.op I.Y) ⟢ Z), CategoryTheory.CategoryStruct.comp (hP.amalgamate S x hx) (CategoryTheory.CategoryStruct.comp (P.map I.f.op) h) = CategoryTheory.CategoryStruct.comp (x I) h
_private.Init.Data.Range.Polymorphic.UInt.0.UInt64.instLawfulUpwardEnumerableLE._simp_1
Init.Data.Range.Polymorphic.UInt
βˆ€ {x y : BitVec 64}, Std.PRange.UpwardEnumerable.LE { toBitVec := x } { toBitVec := y } = Std.PRange.UpwardEnumerable.LE x y
Aesop.BuilderName.forward
Aesop.Rule.Name
Aesop.BuilderName
Lean.Parser.Term.doContinue
Lean.Parser.Do
Lean.Parser.Parser
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.useImplicitLambda
Lean.Elab.Term.TermElabM
Lean.Syntax β†’ Option Lean.Expr β†’ Lean.Elab.TermElabM Lean.Elab.Term.UseImplicitLambdaResult
CategoryTheory.Monad.ForgetCreatesColimits.coconePoint._proof_1
Mathlib.CategoryTheory.Monad.Limits
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} J] {D : CategoryTheory.Functor J T.Algebra} (c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c) [inst_2 : CategoryTheory.Limits.PreservesColimit (D.comp T.forget) T.toFunctor], CategoryTheory.CategoryStruct.comp (T.Ξ·.app c.pt) (CategoryTheory.Monad.ForgetCreatesColimits.lambda c t) = CategoryTheory.CategoryStruct.id c.pt
_private.Mathlib.Algebra.Group.Subsemigroup.Membership.0.AddSubsemigroup.mem_biSup_of_directedOn.match_1_1
Mathlib.Algebra.Group.Subsemigroup.Membership
βˆ€ {M : Type u_2} [inst : Add M] {ΞΉ : Type u_1} {p : ΞΉ β†’ Prop} {K : ΞΉ β†’ AddSubsemigroup M} {x : M} (motive : (βˆƒ i, p i ∧ x ∈ K i) β†’ Prop) (x_1 : βˆƒ i, p i ∧ x ∈ K i), (βˆ€ (i : ΞΉ) (hi' : p i) (hi : x ∈ K i), motive β‹―) β†’ motive x_1
Lean.Meta.CaseValuesSubgoal.noConfusion
Lean.Meta.Match.CaseValues
{P : Sort u} β†’ {t t' : Lean.Meta.CaseValuesSubgoal} β†’ t = t' β†’ Lean.Meta.CaseValuesSubgoal.noConfusionType P t t'
TensorPower.gmonoid._proof_1
Mathlib.LinearAlgebra.TensorPower.Basic
βˆ€ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (a : GradedMonoid fun i => TensorPower R i M), GradedMonoid.mk (0 β€’ a.fst) (GradedMonoid.GMonoid.gnpowRec 0 a.snd) = 1
AlgebraicGeometry.ProjIsoSpecTopComponent.ToSpec.carrier._proof_2
Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme
βˆ€ {A : Type u_1} {Οƒ : Type u_2} [inst : CommRing A] [inst_1 : SetLike Οƒ A] [inst_2 : AddSubgroupClass Οƒ A] {π’œ : β„• β†’ Οƒ} [inst_3 : GradedRing π’œ] {f : A}, Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (ProjectiveSpectrum.basicOpen π’œ f).inclusion')
Ordinal.ToType.mk._proof_3
Mathlib.SetTheory.Ordinal.Basic
βˆ€ {o : Ordinal.{u_1}} (x : ↑(Set.Iio o)), ↑x ∈ Set.Iio (Ordinal.type fun x1 x2 => x1 < x2)
List.hasDecEq.match_1
Init.Prelude
{Ξ± : Type u_1} β†’ (as bs : List Ξ±) β†’ (motive : Decidable (as = bs) β†’ Sort u_2) β†’ (x : Decidable (as = bs)) β†’ ((habs : as = bs) β†’ motive (isTrue habs)) β†’ ((nabs : Β¬as = bs) β†’ motive (isFalse nabs)) β†’ motive x
Mathlib.Linter.DupNamespaceLinter.initFn._@.Mathlib.Tactic.Linter.Lint.3996576634._hygCtx._hyg.2
Mathlib.Tactic.Linter.Lint
IO Unit
Finset.fold_const
Mathlib.Data.Finset.Fold
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {op : Ξ² β†’ Ξ² β†’ Ξ²} [hc : Std.Commutative op] [ha : Std.Associative op] {b : Ξ²} {s : Finset Ξ±} [hd : Decidable (s = βˆ…)] (c : Ξ²), op c (op b c) = op b c β†’ Finset.fold op b (fun x => c) s = if s = βˆ… then b else op b c
MonadStateOf.casesOn
Init.Prelude
{Οƒ : Type u} β†’ {m : Type u β†’ Type v} β†’ {motive : MonadStateOf Οƒ m β†’ Sort u_1} β†’ (t : MonadStateOf Οƒ m) β†’ ((get : m Οƒ) β†’ (set : Οƒ β†’ m PUnit.{u + 1}) β†’ (modifyGet : {Ξ± : Type u} β†’ (Οƒ β†’ Ξ± Γ— Οƒ) β†’ m Ξ±) β†’ motive { get := get, set := set, modifyGet := modifyGet }) β†’ motive t
SemimoduleCat.hom_ext_iff
Mathlib.Algebra.Category.ModuleCat.Semi
βˆ€ {R : Type u} [inst : Semiring R] {M N : SemimoduleCat R} {f g : M ⟢ N}, f = g ↔ SemimoduleCat.Hom.hom f = SemimoduleCat.Hom.hom g
Real.pow_mul_norm_iteratedFDeriv_fourier_le
Mathlib.Analysis.Fourier.FourierTransformDeriv
βˆ€ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β„‚ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V] [inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V] {f : V β†’ E} {K N : β„•βˆž}, ContDiff ℝ (↑N) f β†’ (βˆ€ (k n : β„•), ↑k ≀ K β†’ ↑n ≀ N β†’ MeasureTheory.Integrable (fun v => β€–vβ€– ^ k * β€–iteratedFDeriv ℝ n f vβ€–) MeasureTheory.volume) β†’ βˆ€ {k n : β„•}, ↑k ≀ K β†’ ↑n ≀ N β†’ βˆ€ (w : V), β€–wβ€– ^ n * β€–iteratedFDeriv ℝ k (FourierTransform.fourier f) wβ€– ≀ (2 * Real.pi) ^ k * (2 * ↑k + 2) ^ n * βˆ‘ p ∈ Finset.range (k + 1) Γ—Λ’ Finset.range (n + 1), ∫ (v : V), β€–vβ€– ^ p.1 * β€–iteratedFDeriv ℝ p.2 f vβ€–
ContinuousMap.toAEEqFunAddHom._proof_1
Mathlib.MeasureTheory.Function.AEEqFun
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : MeasurableSpace Ξ±] (ΞΌ : MeasureTheory.Measure Ξ±) [inst_1 : TopologicalSpace Ξ±] [inst_2 : BorelSpace Ξ±] [inst_3 : TopologicalSpace Ξ²] [inst_4 : SecondCountableTopologyEither Ξ± Ξ²] [inst_5 : TopologicalSpace.PseudoMetrizableSpace Ξ²] [inst_6 : AddGroup Ξ²] [inst_7 : IsTopologicalAddGroup Ξ²], ContinuousMap.toAEEqFun ΞΌ 0 = ContinuousMap.toAEEqFun ΞΌ 0
SzemerediRegularity.increment.congr_simp
Mathlib.Combinatorics.SimpleGraph.Regularity.Increment
βˆ€ {Ξ± : Type u_1} [inst : Fintype Ξ±] [inst_1 : DecidableEq Ξ±] {P P_1 : Finpartition Finset.univ} (e_P : P = P_1) (hP : P.IsEquipartition) (G G_1 : SimpleGraph Ξ±), G = G_1 β†’ βˆ€ {inst_2 : DecidableRel G.Adj} [inst_3 : DecidableRel G_1.Adj] (Ξ΅ Ξ΅_1 : ℝ), Ξ΅ = Ξ΅_1 β†’ SzemerediRegularity.increment hP G Ξ΅ = SzemerediRegularity.increment β‹― G_1 Ξ΅_1
SkewMonoidAlgebra.equivMapDomain._proof_1
Mathlib.Algebra.SkewMonoidAlgebra.Lift
βˆ€ {k : Type u_3} {G : Type u_2} {H : Type u_1} [inst : AddCommMonoid k] (f : G ≃ H) (l : SkewMonoidAlgebra k G) (a : H), a ∈ Finset.map f.toEmbedding l.support ↔ Β¬l.coeff (f.symm a) = 0
ArchimedeanClass.FiniteElement._proof_1
Mathlib.Algebra.Order.Ring.StandardPart
βˆ€ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [IsOrderedRing K], IsOrderedAddMonoid K
Lean.Widget.WidgetSource.mk.noConfusion
Lean.Widget.UserWidget
{P : Sort u} β†’ {sourcetext sourcetext' : String} β†’ { sourcetext := sourcetext } = { sourcetext := sourcetext' } β†’ (sourcetext = sourcetext' β†’ P) β†’ P
Trivialization.coe_coordChangeL
Mathlib.Topology.VectorBundle.Basic
βˆ€ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B β†’ Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F] [inst_2 : TopologicalSpace B] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : AddCommMonoid F] [inst_5 : Module R F] [inst_6 : (x : B) β†’ AddCommMonoid (E x)] [inst_7 : (x : B) β†’ Module R (E x)] (e e' : Trivialization F Bundle.TotalSpace.proj) [inst_8 : Trivialization.IsLinear R e] [inst_9 : Trivialization.IsLinear R e'] {b : B} (hb : b ∈ e.baseSet ∩ e'.baseSet), ⇑(Trivialization.coordChangeL R e e' b) = ⇑((Trivialization.linearEquivAt R e b β‹―).symm β‰ͺ≫ₗ Trivialization.linearEquivAt R e' b β‹―)
Lean.Grind.IntModule.OfNatModule.mk_le_mk
Init.Grind.Module.Envelope
βˆ€ {Ξ± : Type u} [inst : Lean.Grind.NatModule Ξ±] [inst_1 : LE Ξ±] [inst_2 : Std.IsPreorder Ξ±] [inst_3 : Lean.Grind.OrderedAdd Ξ±] {a₁ aβ‚‚ b₁ bβ‚‚ : Ξ±}, Lean.Grind.IntModule.OfNatModule.Q.mk (a₁, aβ‚‚) ≀ Lean.Grind.IntModule.OfNatModule.Q.mk (b₁, bβ‚‚) ↔ a₁ + bβ‚‚ ≀ aβ‚‚ + b₁
StructureGroupoid.id_mem_maximalAtlas
Mathlib.Geometry.Manifold.ChartedSpace
βˆ€ {H : Type u} [inst : TopologicalSpace H] (G : StructureGroupoid H), OpenPartialHomeomorph.refl H ∈ StructureGroupoid.maximalAtlas H G
Array.mapIdx_mapIdx
Init.Data.Array.MapIdx
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {xs : Array Ξ±} {f : β„• β†’ Ξ± β†’ Ξ²} {g : β„• β†’ Ξ² β†’ Ξ³}, Array.mapIdx g (Array.mapIdx f xs) = Array.mapIdx (fun i => g i ∘ f i) xs
_private.Mathlib.Algebra.Star.Module.0.selfAdjointPart_comp_subtype_skewAdjoint.match_1_1
Mathlib.Algebra.Star.Module
βˆ€ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R] [inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A] (motive : β†₯(skewAdjoint.submodule R A) β†’ Prop) (x : β†₯(skewAdjoint.submodule R A)), (βˆ€ (x : A) (hx : star x = -x), motive ⟨x, hx⟩) β†’ motive x
CategoryTheory.Sheaf.instPreservesFiniteLimitsFunctorOppositeSheafToPresheafOfHasFiniteLimits
Mathlib.CategoryTheory.Sites.Limits
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w} [inst_1 : CategoryTheory.Category.{w', w} D] [CategoryTheory.Limits.HasFiniteLimits D], CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.sheafToPresheaf J D)
AddCon.addSubgroup_quotientAddGroupCon
Mathlib.GroupTheory.QuotientGroup.Defs
βˆ€ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [inst_1 : H.Normal], (QuotientAddGroup.con H).addSubgroup = H
ContinuousMultilinearMap.uniformContinuous_restrictScalars
Mathlib.Topology.Algebra.Module.Multilinear.Topology
βˆ€ {π•œ : Type u_1} {ΞΉ : Type u_2} {E : ΞΉ β†’ Type u_3} {F : Type u_4} [inst : NormedField π•œ] [inst_1 : (i : ΞΉ) β†’ TopologicalSpace (E i)] [inst_2 : (i : ΞΉ) β†’ AddCommGroup (E i)] [inst_3 : (i : ΞΉ) β†’ Module π•œ (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module π•œ F] [inst_6 : UniformSpace F] [inst_7 : IsUniformAddGroup F] (π•œ' : Type u_5) [inst_8 : NontriviallyNormedField π•œ'] [inst_9 : NormedAlgebra π•œ' π•œ] [inst_10 : (i : ΞΉ) β†’ Module π•œ' (E i)] [inst_11 : βˆ€ (i : ΞΉ), IsScalarTower π•œ' π•œ (E i)] [inst_12 : Module π•œ' F] [inst_13 : IsScalarTower π•œ' π•œ F] [βˆ€ (i : ΞΉ), ContinuousSMul π•œ (E i)], UniformContinuous (ContinuousMultilinearMap.restrictScalars π•œ')
BoxIntegral.unitPartition.prepartition_isHenstock
Mathlib.Analysis.BoxIntegral.UnitPartition
βˆ€ {ΞΉ : Type u_1} (n : β„•) [inst : NeZero n] [inst_1 : Fintype ΞΉ] (B : BoxIntegral.Box ΞΉ), (BoxIntegral.unitPartition.prepartition n B).IsHenstock
LowerSet.notMem_bot._simp_1
Mathlib.Order.UpperLower.CompleteLattice
βˆ€ {Ξ± : Type u_1} [inst : LE Ξ±] {a : Ξ±}, (a ∈ βŠ₯) = False
Std.DHashMap.Equiv.constGet_eq
Std.Data.DHashMap.Lemmas
βˆ€ {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {Ξ² : Type v} {m₁ mβ‚‚ : Std.DHashMap Ξ± fun x => Ξ²} [inst : EquivBEq Ξ±] [inst_1 : LawfulHashable Ξ±] {k : Ξ±} (hk : k ∈ m₁) (h : m₁.Equiv mβ‚‚), Std.DHashMap.Const.get m₁ k hk = Std.DHashMap.Const.get mβ‚‚ k β‹―
CategoryTheory.NatTrans.removeOp._proof_2
Mathlib.CategoryTheory.Opposites
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F G : CategoryTheory.Functor C D} (Ξ± : F.op ⟢ G.op) (X Y : C) (f : X ⟢ Y), CategoryTheory.CategoryStruct.comp (G.map f) (Ξ±.app (Opposite.op Y)).unop = CategoryTheory.CategoryStruct.comp (Ξ±.app (Opposite.op X)).unop (F.map f)
Lean.Widget.RpcEncodablePacket.msg._@.Lean.Server.FileWorker.WidgetRequests.1923616455._hygCtx._hyg.1
Lean.Server.FileWorker.WidgetRequests
Lean.Widget.RpcEncodablePacket✝ β†’ Lean.Json
_private.Init.Data.String.Basic.0.String.Slice.utf8ByteSize_slice._proof_1_2
Init.Data.String.Basic
βˆ€ {s : String.Slice} {newStart newEnd : s.Pos}, Β¬s.startInclusive.offset.byteIdx + newEnd.offset.byteIdx - (s.startInclusive.offset.byteIdx + newStart.offset.byteIdx) = newEnd.offset.byteIdx - newStart.offset.byteIdx β†’ False
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit'.eq_def
Lean.Elab.DeclNameGen
βˆ€ (e : Lean.Expr) (omitTopForall : Bool), Lean.Elab.Command.NameGen.mkBaseNameCore.visit'✝ e omitTopForall = match e with | Lean.Expr.const name us => do modify fun st => { seen := Lean.Elab.Command.NameGen.MkNameState.seen✝ st, consts := (Lean.Elab.Command.NameGen.MkNameState.consts✝ st).insert name } pure (match name.eraseMacroScopes with | pre.str str => str.capitalize | x => "") | f.app x => (fun x1 x2 => x1 ++ x2) <$> Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝ f <*> Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝¹ x | Lean.Expr.forallE binderName ty body binderInfo => do let sty ← Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝² ty if (omitTopForall && sty == "") = true then Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝³ body true else (fun x => "Forall" ++ sty ++ x) <$> Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝⁴ body | Lean.Expr.sort Lean.Level.zero => pure "Prop" | Lean.Expr.sort a.succ => pure "Type" | Lean.Expr.sort u => pure "Sort" | x => pure ""
DilationEquiv.coe_one
Mathlib.Topology.MetricSpace.DilationEquiv
βˆ€ {X : Type u_1} [inst : PseudoEMetricSpace X], ⇑1 = id
Std.TreeSet.getD_diff_of_mem_right
Std.Data.TreeSet.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t₁ tβ‚‚ : Std.TreeSet Ξ± cmp} [Std.TransCmp cmp] {k fallback : Ξ±}, k ∈ tβ‚‚ β†’ (t₁ \ tβ‚‚).getD k fallback = fallback
IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_nth_roots
Mathlib.NumberTheory.Cyclotomic.Basic
βˆ€ {A : Type u} {B : Type v} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain B] {ΞΆ : B} {n : β„•} [NeZero n], IsPrimitiveRoot ΞΆ n β†’ Algebra.adjoin A ((Polynomial.cyclotomic n A).rootSet B) = Algebra.adjoin A {b | βˆƒ a ∈ {n}, a β‰  0 ∧ b ^ a = 1}
NumberField.IsCMField.complexConj_eq_self_iff
Mathlib.NumberTheory.NumberField.CMField
βˆ€ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K] [inst_3 : Algebra.IsIntegral β„š K] (x : K), (NumberField.IsCMField.complexConj K) x = x ↔ x ∈ NumberField.maximalRealSubfield K
LieAlgebra.IsKilling.disjoint_ker_weight_corootSpace
Mathlib.Algebra.Lie.Weights.Killing
βˆ€ {K : Type u_2} {L : Type u_3} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L] [inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra] [LieAlgebra.IsKilling K L] [LieModule.IsTriangularizable K (β†₯H) L] [inst_7 : CharZero K] (Ξ± : LieModule.Weight K (β†₯H) L), Disjoint LieModule.Weight.ker (LieIdeal.toLieSubalgebra K (β†₯H) (LieAlgebra.corootSpace ⇑α)).toSubmodule
List.forM_nil
Init.Data.List.Control
βˆ€ {m : Type u_1 β†’ Type u_2} {Ξ± : Type u_3} [inst : Monad m] {f : Ξ± β†’ m PUnit.{u_1 + 1}}, forM [] f = pure PUnit.unit
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse._proof_2
Mathlib.CategoryTheory.Comma.Over.Basic
βˆ€ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) {Y_1 Z : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y} (m : Y_1 ⟢ Z), CategoryTheory.CategoryStruct.comp (F.map m.left.left) Z.hom = Y_1.hom
Representation.invariants.eq_1
Mathlib.RepresentationTheory.Invariants
βˆ€ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Group G] [inst_2 : AddCommMonoid V] [inst_3 : Module k V] (ρ : Representation k G V), ρ.invariants = { carrier := {v | βˆ€ (g : G), (ρ g) v = v}, add_mem' := β‹―, zero_mem' := β‹―, smul_mem' := β‹― }
PNat.XgcdType.mk.sizeOf_spec
Mathlib.Data.PNat.Xgcd
βˆ€ (wp x y zp ap bp : β„•), sizeOf { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp } = 1 + sizeOf wp + sizeOf x + sizeOf y + sizeOf zp + sizeOf ap + sizeOf bp
CategoryTheory.ProjectiveResolution.quasiIso._autoParam
Mathlib.CategoryTheory.Preadditive.Projective.Resolution
Lean.Syntax
bihimp_comm
Mathlib.Order.SymmDiff
βˆ€ {Ξ± : Type u_2} [inst : GeneralizedHeytingAlgebra Ξ±] (a b : Ξ±), bihimp a b = bihimp b a
mul_le_mul_of_nonpos_of_nonneg'
Mathlib.Algebra.Order.Ring.Unbundled.Basic
βˆ€ {R : Type u} [inst : Semiring R] [inst_1 : Preorder R] {a b c d : R} [ExistsAddOfLE R] [PosMulMono R] [MulPosMono R] [AddRightMono R] [AddRightReflectLE R], c ≀ a β†’ b ≀ d β†’ 0 ≀ a β†’ d ≀ 0 β†’ a * b ≀ c * d
CategoryTheory.ShortComplex.Exact.isIso_imageToKernel
Mathlib.CategoryTheory.Abelian.Exact
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C), S.Exact β†’ CategoryTheory.IsIso (imageToKernel S.f S.g β‹―)
Lean.KeyedDeclsAttribute.ExtensionState.declNames
Lean.KeyedDeclsAttribute
{Ξ³ : Type} β†’ Lean.KeyedDeclsAttribute.ExtensionState Ξ³ β†’ Lean.PHashSet Lean.Name
LinearMap.mem_submoduleImage._simp_1
Mathlib.Algebra.Module.Submodule.Range
βˆ€ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_10} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {O : Submodule R M} {Ο• : β†₯O β†’β‚—[R] M'} {N : Submodule R M} {x : M'}, (x ∈ Ο•.submoduleImage N) = βˆƒ y, βˆƒ (yO : y ∈ O), y ∈ N ∧ Ο• ⟨y, yO⟩ = x
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.isFinite
Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval β†’ Bool
Lean.Server.Test.Runner.Client.InteractiveGoals.mk
Lean.Server.Test.Runner
Array Lean.Server.Test.Runner.Client.InteractiveGoal β†’ Lean.Server.Test.Runner.Client.InteractiveGoals
SimpleGraph.Walk.support_toPath_subset
Mathlib.Combinatorics.SimpleGraph.Paths
βˆ€ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v : V} (p : G.Walk u v), (↑p.toPath).support βŠ† p.support
_private.Mathlib.LinearAlgebra.Pi.0.LinearMap.pi_eq_zero._simp_1_2
Mathlib.LinearAlgebra.Pi
βˆ€ {Ξ± : Sort u} {Ξ² : Ξ± β†’ Sort v} {f g : (x : Ξ±) β†’ Ξ² x}, (f = g) = βˆ€ (x : Ξ±), f x = g x
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplex.0.CochainComplex.HomComplex.Cocycle.homOf._simp_1
Mathlib.Algebra.Homology.HomotopyCategory.HomComplex
βˆ€ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b)
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.val_assemble₁_le._proof_1_1
Init.Data.String.Decode
βˆ€ {w : UInt8}, w.toNat < 128 β†’ Β¬w.toNat ≀ 127 β†’ False
_private.Init.Data.List.Lemmas.0.List.length_pos_iff_exists_mem.match_1_1
Init.Data.List.Lemmas
βˆ€ {Ξ± : Type u_1} {l : List Ξ±} (motive : (βˆƒ a, a ∈ l) β†’ Prop) (x : βˆƒ a, a ∈ l), (βˆ€ (w : Ξ±) (h : w ∈ l), motive β‹―) β†’ motive x
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup.0.SubMulAction.fixingSubgroup_map_conj_eq._simp_1_2
Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup
βˆ€ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1)
Fin.dfoldrM.loop._unsafe_rec
Batteries.Data.Fin.Basic
{m : Type u_1 β†’ Type u_2} β†’ [Monad m] β†’ (n : β„•) β†’ (Ξ± : Fin (n + 1) β†’ Type u_1) β†’ ((i : Fin n) β†’ Ξ± i.succ β†’ m (Ξ± i.castSucc)) β†’ (i : β„•) β†’ (h : i < n + 1) β†’ Ξ± ⟨i, h⟩ β†’ m (Ξ± 0)
MeasureTheory.aecover_closedBall
Mathlib.MeasureTheory.Integral.IntegralEqImproper
βˆ€ {Ξ± : Type u_1} {ΞΉ : Type u_2} [inst : MeasurableSpace Ξ±] {ΞΌ : MeasureTheory.Measure Ξ±} {l : Filter ΞΉ} [inst_1 : PseudoMetricSpace Ξ±] [OpensMeasurableSpace Ξ±] {x : Ξ±} {r : ΞΉ β†’ ℝ}, Filter.Tendsto r l Filter.atTop β†’ MeasureTheory.AECover ΞΌ l fun i => Metric.closedBall x (r i)
BitVec.twoPow
Init.Data.BitVec.Basic
(w : β„•) β†’ β„• β†’ BitVec w
_private.Init.Data.Array.Monadic.0.Array.foldlM_filterMap.match_1.eq_1
Init.Data.Array.Monadic
βˆ€ {Ξ² : Type u_1} (motive : Option Ξ² β†’ Sort u_2) (b : Ξ²) (h_1 : (b : Ξ²) β†’ motive (some b)) (h_2 : Unit β†’ motive none), (match some b with | some b => h_1 b | none => h_2 ()) = h_1 b
LocalSubring.noConfusion
Mathlib.RingTheory.LocalRing.LocalSubring
{P : Sort u} β†’ {R : Type u_1} β†’ {inst : CommRing R} β†’ {t : LocalSubring R} β†’ {R' : Type u_1} β†’ {inst' : CommRing R'} β†’ {t' : LocalSubring R'} β†’ R = R' β†’ inst ≍ inst' β†’ t ≍ t' β†’ LocalSubring.noConfusionType P t t'
_private.Batteries.Data.String.Legacy.0.String.Legacy.posOfAux._proof_1
Batteries.Data.String.Legacy
βˆ€ (s : String) (stopPos pos : String.Pos.Raw), pos < stopPos β†’ stopPos.byteIdx - (String.Pos.Raw.next s pos).byteIdx < stopPos.byteIdx - pos.byteIdx
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.support_eq._simp_1_1
Mathlib.MeasureTheory.Function.SimpleFunc
βˆ€ {ΞΉ : Type u_1} {M : Type u_3} [inst : Zero M] {f : ΞΉ β†’ M} {x : ΞΉ}, (x ∈ Function.support f) = (f x β‰  0)
List.pop_toArray
Init.Data.List.ToArray
βˆ€ {Ξ± : Type u_1} (l : List Ξ±), l.toArray.pop = l.dropLast.toArray
groupCohomology.isoTwoCocycles_inv_comp_iCocycles
Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree
βˆ€ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G), CategoryTheory.CategoryStruct.comp (groupCohomology.isoCocyclesβ‚‚ A).inv (groupCohomology.iCocycles A 2) = CategoryTheory.CategoryStruct.comp (groupCohomology.shortComplexH2 A).moduleCatLeftHomologyData.i (groupCohomology.cochainsIsoβ‚‚ A).inv
monovaryOn_inv_left._simp_4
Mathlib.Algebra.Order.Monovary
βˆ€ {ΞΉ : Type u_1} {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : AddCommGroup Ξ±] [inst_1 : PartialOrder Ξ±] [IsOrderedAddMonoid Ξ±] [inst_3 : PartialOrder Ξ²] {s : Set ΞΉ} {f : ΞΉ β†’ Ξ±} {g : ΞΉ β†’ Ξ²}, MonovaryOn (-f) g s = AntivaryOn f g s
_private.Lean.Util.Diff.0.Lean.Diff.diff.match_3
Lean.Util.Diff
{Ξ± : Type} β†’ (motive : MProd β„• (MProd β„• (Array (Lean.Diff.Action Γ— Ξ±))) β†’ Sort u_1) β†’ (r : MProd β„• (MProd β„• (Array (Lean.Diff.Action Γ— Ξ±)))) β†’ ((i j : β„•) β†’ (out : Array (Lean.Diff.Action Γ— Ξ±)) β†’ motive ⟨i, j, out⟩) β†’ motive r
CategoryTheory.Abelian.extFunctorObj._proof_1
Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic
βˆ€ (n : β„•), n + 0 = n
_private.Mathlib.RingTheory.PolynomialAlgebra.0.PolyEquivTensor.left_inv._simp_1_3
Mathlib.RingTheory.PolynomialAlgebra
βˆ€ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A), (algebraMap R A) r * x = r β€’ x
Subgroup.toAddSubgroup._proof_2
Mathlib.Algebra.Group.Subgroup.Lattice
βˆ€ {G : Type u_1} [inst : Group G] (x : AddSubgroup (Additive G)), { toAddSubmonoid := Submonoid.toAddSubmonoid { toSubmonoid := AddSubmonoid.toSubmonoid x.toAddSubmonoid, inv_mem' := β‹― }.toSubmonoid, neg_mem' := β‹― } = x
EuclideanGeometry.orthogonalProjection.congr_simp
Mathlib.Geometry.Euclidean.Projection
βˆ€ {π•œ : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike π•œ] [inst_1 : NormedAddCommGroup V] [inst_2 : InnerProductSpace π•œ V] [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] (s : AffineSubspace π•œ P) [inst_5 : Nonempty β†₯s] [inst_6 : s.direction.HasOrthogonalProjection], EuclideanGeometry.orthogonalProjection s = EuclideanGeometry.orthogonalProjection s
Tuple.comp_sort_eq_comp_iff_monotone
Mathlib.Data.Fin.Tuple.Sort
βˆ€ {n : β„•} {Ξ± : Type u_1} [inst : LinearOrder Ξ±] {f : Fin n β†’ Ξ±} {Οƒ : Equiv.Perm (Fin n)}, f ∘ ⇑σ = f ∘ ⇑(Tuple.sort f) ↔ Monotone (f ∘ ⇑σ)
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁
Lean.Meta.Tactic.Grind.Arith.Cutsat.Types
Lean.Meta.Grind.Arith.Cutsat.CooperSplit β†’ Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.casesOn
Std.Sync.Channel
{Ξ± : Type} β†’ {motive : Std.CloseableChannel.Bounded.State✝ Ξ± β†’ Sort u} β†’ (t : Std.CloseableChannel.Bounded.State✝¹ Ξ±) β†’ ((producers : Std.Queue (IO.Promise Bool)) β†’ (consumers : Std.Queue (Std.CloseableChannel.Bounded.Consumer✝ Ξ±)) β†’ (capacity : β„•) β†’ (buf : Vector (IO.Ref (Option Ξ±)) capacity) β†’ (bufCount sendIdx : β„•) β†’ (hsend : sendIdx < capacity) β†’ (recvIdx : β„•) β†’ (hrecv : recvIdx < capacity) β†’ (closed : Bool) β†’ motive { producers := producers, consumers := consumers, capacity := capacity, buf := buf, bufCount := bufCount, sendIdx := sendIdx, hsend := hsend, recvIdx := recvIdx, hrecv := hrecv, closed := closed }) β†’ motive t
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.infsep._simp_1_3
Mathlib.Topology.MetricSpace.Infsep
βˆ€ {Ξ± : Type u} {s : Set Ξ±} {a : Ξ±} (hs : s.Finite), (a ∈ hs.toFinset) = (a ∈ s)
LinearMap.IsReflective.coroot._proof_1
Mathlib.LinearAlgebra.RootSystem.OfBilinear
βˆ€ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (B : M β†’β‚—[R] M β†’β‚—[R] R) {x : M} (hx : B.IsReflective x) (a b : M), Exists.choose β‹― = Exists.choose β‹― + Exists.choose β‹―
CompactlySupportedContinuousMap.noConfusionType
Mathlib.Topology.ContinuousMap.CompactlySupported
Sort u β†’ {Ξ± : Type u_5} β†’ {Ξ² : Type u_6} β†’ [inst : TopologicalSpace Ξ±] β†’ [inst_1 : Zero Ξ²] β†’ [inst_2 : TopologicalSpace Ξ²] β†’ CompactlySupportedContinuousMap Ξ± Ξ² β†’ {Ξ±' : Type u_5} β†’ {Ξ²' : Type u_6} β†’ [inst' : TopologicalSpace Ξ±'] β†’ [inst'_1 : Zero Ξ²'] β†’ [inst'_2 : TopologicalSpace Ξ²'] β†’ CompactlySupportedContinuousMap Ξ±' Ξ²' β†’ Sort u
Std.Broadcast.Sync.send
Std.Sync.Broadcast
{Ξ± : Type} β†’ Std.Broadcast.Sync Ξ± β†’ Ξ± β†’ IO β„•
_private.Mathlib.FieldTheory.Finite.Basic.0.FiniteField.exists_root_sum_quadratic._simp_1_2
Mathlib.FieldTheory.Finite.Basic
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : DecidableEq Ξ²] {f : Ξ± β†’ Ξ²} {s : Finset Ξ±} {b : Ξ²}, (b ∈ Finset.image f s) = βˆƒ a ∈ s, f a = b
WeierstrassCurve.Projective.add
Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point
{R : Type r} β†’ [CommRing R] β†’ WeierstrassCurve.Projective R β†’ (Fin 3 β†’ R) β†’ (Fin 3 β†’ R) β†’ Fin 3 β†’ R
List.lex_nil
Init.Data.List.Basic
βˆ€ {Ξ± : Type u} {lt : Ξ± β†’ Ξ± β†’ Bool} [inst : BEq Ξ±] {as : List Ξ±}, as.lex [] lt = false
Subring.unop_sup
Mathlib.Algebra.Ring.Subring.MulOpposite
βˆ€ {R : Type u_2} [inst : Ring R] (S₁ Sβ‚‚ : Subring Rᡐᡒᡖ), (S₁ βŠ” Sβ‚‚).unop = S₁.unop βŠ” Sβ‚‚.unop
Surreal.addCommGroup._proof_2
Mathlib.SetTheory.Surreal.Basic
βˆ€ (a : Surreal), 0 + a = a
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.declAbstractNestedProofs._sparseCasesOn_1
Mathlib.Tactic.Translate.Core
{motive : Lean.ConstantInfo β†’ Sort u} β†’ (t : Lean.ConstantInfo) β†’ ((val : Lean.DefinitionVal) β†’ motive (Lean.ConstantInfo.defnInfo val)) β†’ (Nat.hasNotBit 2 t.ctorIdx β†’ motive t) β†’ motive t
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameState.mk.injEq
Lean.Elab.DeclNameGen
βˆ€ (seen : Lean.ExprSet) (consts : Lean.NameSet) (seen_1 : Lean.ExprSet) (consts_1 : Lean.NameSet), ({ seen := seen, consts := consts } = { seen := seen_1, consts := consts_1 }) = (seen = seen_1 ∧ consts = consts_1)