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
Lean.Meta.Ext.isExtTheorem
Lean.Meta.Tactic.Ext
Lean.Name β†’ Lean.CoreM Bool
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.balance2.match_1.eq_3
Batteries.Data.RBMap.WF
βˆ€ {Ξ± : Type u_1} (motive : Batteries.RBNode Ξ± β†’ Ξ± β†’ Batteries.RBNode Ξ± β†’ Sort u_2) (a : Batteries.RBNode Ξ±) (x : Ξ±) (b : Batteries.RBNode Ξ±) (h_1 : (a : Batteries.RBNode Ξ±) β†’ (x : Ξ±) β†’ (b : Batteries.RBNode Ξ±) β†’ (y : Ξ±) β†’ (c : Batteries.RBNode Ξ±) β†’ (z : Ξ±) β†’ (d : Batteries.RBNode Ξ±) β†’ motive a x (Batteries.RBNode.node Batteries.RBColor.red b y (Batteries.RBNode.node Batteries.RBColor.red c z d))) (h_2 : (a : Batteries.RBNode Ξ±) β†’ (x : Ξ±) β†’ (b : Batteries.RBNode Ξ±) β†’ (y : Ξ±) β†’ (c : Batteries.RBNode Ξ±) β†’ (z : Ξ±) β†’ (d : Batteries.RBNode Ξ±) β†’ motive a x (Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red b y c) z d)) (h_3 : (a : Batteries.RBNode Ξ±) β†’ (x : Ξ±) β†’ (b : Batteries.RBNode Ξ±) β†’ motive a x b), (βˆ€ (b_1 : Batteries.RBNode Ξ±) (y : Ξ±) (c : Batteries.RBNode Ξ±) (z : Ξ±) (d : Batteries.RBNode Ξ±), b = Batteries.RBNode.node Batteries.RBColor.red b_1 y (Batteries.RBNode.node Batteries.RBColor.red c z d) β†’ False) β†’ (βˆ€ (b_1 : Batteries.RBNode Ξ±) (y : Ξ±) (c : Batteries.RBNode Ξ±) (z : Ξ±) (d : Batteries.RBNode Ξ±), b = Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red b_1 y c) z d β†’ False) β†’ (match a, x, b with | a, x, Batteries.RBNode.node Batteries.RBColor.red b y (Batteries.RBNode.node Batteries.RBColor.red c z d) => h_1 a x b y c z d | a, x, Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red b y c) z d => h_2 a x b y c z d | a, x, b => h_3 a x b) = h_3 a x b
MeasureTheory.Measure.setIntegral_toReal_rnDeriv_eq_withDensity
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym
βˆ€ {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {ΞΌ Ξ½ : MeasureTheory.Measure Ξ±} [MeasureTheory.SigmaFinite ΞΌ] [MeasureTheory.SFinite Ξ½] (s : Set Ξ±), ∫ (x : Ξ±) in s, (ΞΌ.rnDeriv Ξ½ x).toReal βˆ‚Ξ½ = (Ξ½.withDensity (ΞΌ.rnDeriv Ξ½)).real s
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Alt.setBody.match_1
Lean.Compiler.IR.Basic
(motive : Lean.IR.Alt β†’ Lean.IR.FnBody β†’ Sort u_1) β†’ (x : Lean.IR.Alt) β†’ (x_1 : Lean.IR.FnBody) β†’ ((c : Lean.IR.CtorInfo) β†’ (b b_1 : Lean.IR.FnBody) β†’ motive (Lean.IR.Alt.ctor c b) b_1) β†’ ((b b_1 : Lean.IR.FnBody) β†’ motive (Lean.IR.Alt.default b) b_1) β†’ motive x x_1
Lean.Try.Config.harder._default
Init.Try
Bool
Subsemigroup.comap_comap
Mathlib.Algebra.Group.Subsemigroup.Operations
βˆ€ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Mul M] [inst_1 : Mul N] [inst_2 : Mul P] (S : Subsemigroup P) (g : N β†’β‚™* P) (f : M β†’β‚™* N), Subsemigroup.comap f (Subsemigroup.comap g S) = Subsemigroup.comap (g.comp f) S
Std.TreeSet.ofList_singleton
Std.Data.TreeSet.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {k : Ξ±}, Std.TreeSet.ofList [k] cmp = βˆ….insert k
CategoryTheory.ActionCategory.stabilizerIsoEnd_symm_apply
Mathlib.CategoryTheory.Action
βˆ€ (M : Type u_1) [inst : Monoid M] {X : Type u} [inst_1 : MulAction M X] (x : X) (f : CategoryTheory.End ⟨(), x⟩), (CategoryTheory.ActionCategory.stabilizerIsoEnd M x).symm f = f
CategoryTheory.StructuredArrow.instFaithfulObjCompPost
Mathlib.CategoryTheory.Comma.StructuredArrow.Basic
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type uβ‚‚} [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} D] {B : Type uβ‚„} [inst_2 : CategoryTheory.Category.{vβ‚„, uβ‚„} B] (S : C) (F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D), (CategoryTheory.StructuredArrow.post S F G).Faithful
Lean.Meta.Simp.Diagnostics.mk.noConfusion
Lean.Meta.Tactic.Simp.Types
{P : Sort u} β†’ {usedThmCounter triedThmCounter : Lean.PHashMap Lean.Meta.Origin β„•} β†’ {congrThmCounter : Lean.PHashMap Lean.Name β„•} β†’ {thmsWithBadKeys : Lean.PArray Lean.Meta.SimpTheorem} β†’ {usedThmCounter' triedThmCounter' : Lean.PHashMap Lean.Meta.Origin β„•} β†’ {congrThmCounter' : Lean.PHashMap Lean.Name β„•} β†’ {thmsWithBadKeys' : Lean.PArray Lean.Meta.SimpTheorem} β†’ { usedThmCounter := usedThmCounter, triedThmCounter := triedThmCounter, congrThmCounter := congrThmCounter, thmsWithBadKeys := thmsWithBadKeys } = { usedThmCounter := usedThmCounter', triedThmCounter := triedThmCounter', congrThmCounter := congrThmCounter', thmsWithBadKeys := thmsWithBadKeys' } β†’ (usedThmCounter = usedThmCounter' β†’ triedThmCounter = triedThmCounter' β†’ congrThmCounter = congrThmCounter' β†’ thmsWithBadKeys = thmsWithBadKeys' β†’ P) β†’ P
PresheafOfModules.wellPowered
Mathlib.Algebra.Category.ModuleCat.Presheaf.Generator
βˆ€ {Cβ‚€ : Type u} [inst : CategoryTheory.SmallCategory Cβ‚€] (Rβ‚€ : CategoryTheory.Functor Cβ‚€α΅’α΅– RingCat), CategoryTheory.WellPowered.{u, u, u + 1} (PresheafOfModules Rβ‚€)
QuaternionAlgebra.mk
Mathlib.Algebra.Quaternion
{R : Type u_1} β†’ {a b c : R} β†’ R β†’ R β†’ R β†’ R β†’ QuaternionAlgebra R a b c
Lean.Lsp.CodeActionParams.mk.sizeOf_spec
Lean.Data.Lsp.CodeActions
βˆ€ (toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams) (toPartialResultParams : Lean.Lsp.PartialResultParams) (textDocument : Lean.Lsp.TextDocumentIdentifier) (range : Lean.Lsp.Range) (context : Lean.Lsp.CodeActionContext), sizeOf { toWorkDoneProgressParams := toWorkDoneProgressParams, toPartialResultParams := toPartialResultParams, textDocument := textDocument, range := range, context := context } = 1 + sizeOf toWorkDoneProgressParams + sizeOf toPartialResultParams + sizeOf textDocument + sizeOf range + sizeOf context
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances.0.cfc_complex_eq_real._simp_1_1
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances
βˆ€ {K : Type u_1} [inst : RCLike K] {z : K}, ((starRingEnd K) z = z) = (↑(RCLike.re z) = z)
HurwitzZeta.hurwitzEvenFEPair._proof_1
Mathlib.NumberTheory.LSeries.HurwitzZetaEven
(1 + 1).AtLeastTwo
CategoryTheory.Functor.descOfIsLeftKanExtension.congr_simp
Mathlib.CategoryTheory.Functor.KanExtension.Basic
βˆ€ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D] (F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} (Ξ± Ξ±_1 : F ⟢ L.comp F') (e_Ξ± : Ξ± = Ξ±_1) [inst_3 : F'.IsLeftKanExtension Ξ±] (G : CategoryTheory.Functor D H) (Ξ² Ξ²_1 : F ⟢ L.comp G), Ξ² = Ξ²_1 β†’ F'.descOfIsLeftKanExtension Ξ± G Ξ² = F'.descOfIsLeftKanExtension Ξ±_1 G Ξ²_1
Primrec.nat_bodd
Mathlib.Computability.Primrec
Primrec Nat.bodd
Std.Internal.IO.Async.EAsync.instMonadLiftBaseIO
Std.Internal.Async.Basic
{Ξ΅ : Type} β†’ MonadLift BaseIO (Std.Internal.IO.Async.EAsync Ξ΅)
_private.Mathlib.Analysis.Analytic.Basic.0.AnalyticWithinAt.congr_set._simp_1_1
Mathlib.Analysis.Analytic.Basic
βˆ€ {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] {a : Ξ±} {s : Set Ξ±}, (s ∈ nhdsWithin a s) = True
NonUnitalSubsemiring.mem_iInf
Mathlib.RingTheory.NonUnitalSubsemiring.Basic
βˆ€ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {ΞΉ : Sort u_1} {S : ΞΉ β†’ NonUnitalSubsemiring R} {x : R}, x ∈ β¨… i, S i ↔ βˆ€ (i : ΞΉ), x ∈ S i
DoubleCentralizer.instModule._proof_1
Mathlib.Analysis.CStarAlgebra.Multiplier
βˆ€ {π•œ : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField π•œ] [inst_1 : NonUnitalNormedRing A] [inst_2 : NormedSpace π•œ A] [inst_3 : SMulCommClass π•œ A A] [inst_4 : IsScalarTower π•œ A A] {S : Type u_3} [inst_5 : Semiring S] [inst_6 : Module S A] [inst_7 : SMulCommClass π•œ S A] [inst_8 : ContinuousConstSMul S A] [inst_9 : IsScalarTower S A A] [inst_10 : SMulCommClass S A A] (_x : S) (_y : DoubleCentralizer π•œ A), DoubleCentralizer.toProdHom (_x β€’ _y) = DoubleCentralizer.toProdHom (_x β€’ _y)
CategoryTheory.Classifier.pullback_Ο‡_obj_mk_truth
Mathlib.CategoryTheory.Topos.Classifier
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] (π’ž : CategoryTheory.Classifier C) {Z X : C} (i : Z ⟢ X) [inst_2 : CategoryTheory.Mono i], (CategoryTheory.Subobject.pullback (π’ž.Ο‡ i)).obj π’ž.truth_as_subobject = CategoryTheory.Subobject.mk i
PowerBasis.ofAdjoinEqTop_gen
Mathlib.RingTheory.Adjoin.PowerBasis
βˆ€ {K : Type u_1} {S : Type u_2} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S] {x : S} (hx : IsIntegral K x) (hx' : Algebra.adjoin K {x} = ⊀), (PowerBasis.ofAdjoinEqTop hx hx').gen = x
MulHom.mk.inj
Mathlib.Algebra.Group.Hom.Defs
βˆ€ {M : Type u_10} {N : Type u_11} {inst : Mul M} {inst_1 : Mul N} {toFun : M β†’ N} {map_mul' : βˆ€ (x y : M), toFun (x * y) = toFun x * toFun y} {toFun_1 : M β†’ N} {map_mul'_1 : βˆ€ (x y : M), toFun_1 (x * y) = toFun_1 x * toFun_1 y}, { toFun := toFun, map_mul' := map_mul' } = { toFun := toFun_1, map_mul' := map_mul'_1 } β†’ toFun = toFun_1
MeasureTheory.AEStronglyMeasurable.pow
Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : TopologicalSpace Ξ²] {m mβ‚€ : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} {f : Ξ± β†’ Ξ²} [inst_1 : Monoid Ξ²] [ContinuousMul Ξ²], MeasureTheory.AEStronglyMeasurable f ΞΌ β†’ βˆ€ (n : β„•), MeasureTheory.AEStronglyMeasurable (f ^ n) ΞΌ
_private.Mathlib.Algebra.Group.Int.Even.0.Int.even_iff._simp_1_3
Mathlib.Algebra.Group.Int.Even
βˆ€ (n : β„€), n + n = 2 * n
ProbabilityTheory.setIntegral_compProd_univ_left
Mathlib.Probability.Kernel.Composition.IntegralCompProd
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {E : Type u_4} {mΞ± : MeasurableSpace Ξ±} {mΞ² : MeasurableSpace Ξ²} {mΞ³ : MeasurableSpace Ξ³} [inst : NormedAddCommGroup E] {a : Ξ±} {ΞΊ : ProbabilityTheory.Kernel Ξ± Ξ²} [ProbabilityTheory.IsSFiniteKernel ΞΊ] {Ξ· : ProbabilityTheory.Kernel (Ξ± Γ— Ξ²) Ξ³} [ProbabilityTheory.IsSFiniteKernel Ξ·] [inst_3 : NormedSpace ℝ E] (f : Ξ² Γ— Ξ³ β†’ E) {t : Set Ξ³}, MeasurableSet t β†’ MeasureTheory.IntegrableOn f (Set.univ Γ—Λ’ t) ((ΞΊ.compProd Ξ·) a) β†’ ∫ (z : Ξ² Γ— Ξ³) in Set.univ Γ—Λ’ t, f z βˆ‚(ΞΊ.compProd Ξ·) a = ∫ (x : Ξ²), ∫ (y : Ξ³) in t, f (x, y) βˆ‚Ξ· (a, x) βˆ‚ΞΊ a
Lean.Server.Test.Runner.Client.instToJsonStrictOrLazy
Lean.Server.Test.Runner
{Ξ± Ξ² : Type} β†’ [Lean.ToJson Ξ±] β†’ [Lean.ToJson Ξ²] β†’ Lean.ToJson (Lean.Server.Test.Runner.Client.StrictOrLazy Ξ± Ξ²)
Lean.Widget.instToJsonRpcEncodablePacket._@.Lean.Widget.UserWidget.629054736._hygCtx._hyg.34
Lean.Widget.UserWidget
Lean.ToJson Lean.Widget.RpcEncodablePacket✝
DFinsupp.le_iff'
Mathlib.Data.DFinsupp.Order
βˆ€ {ΞΉ : Type u_1} {Ξ± : ΞΉ β†’ Type u_2} [inst : (i : ΞΉ) β†’ AddCommMonoid (Ξ± i)] [inst_1 : (i : ΞΉ) β†’ PartialOrder (Ξ± i)] [βˆ€ (i : ΞΉ), CanonicallyOrderedAdd (Ξ± i)] [inst_3 : DecidableEq ΞΉ] [inst_4 : (i : ΞΉ) β†’ (x : Ξ± i) β†’ Decidable (x β‰  0)] {f g : Ξ β‚€ (i : ΞΉ), Ξ± i} {s : Finset ΞΉ}, f.support βŠ† s β†’ (f ≀ g ↔ βˆ€ i ∈ s, f i ≀ g i)
DirectSum.coeAlgHom._proof_2
Mathlib.Algebra.DirectSum.Internal
βˆ€ {ΞΉ : Type u_3} {S : Type u_2} {R : Type u_1} [inst : AddMonoid ΞΉ] [inst_1 : CommSemiring S] [inst_2 : Semiring R] [inst_3 : Algebra S R] (A : ΞΉ β†’ Submodule S R) [inst_4 : SetLike.GradedMonoid A] {i j : ΞΉ} (x : β†₯(A i)) (x_1 : β†₯(A j)), (A (i + j)).subtype (GradedMonoid.GMul.mul x x_1) = (A (i + j)).subtype (GradedMonoid.GMul.mul x x_1)
_private.Mathlib.GroupTheory.CosetCover.0.Subgroup.leftCoset_cover_filter_FiniteIndex_aux.match_1_3
Mathlib.GroupTheory.CosetCover
βˆ€ {G : Type u_1} [inst : Group G] {ΞΉ : Type u_2} {H : ΞΉ β†’ Subgroup G} {s : Finset ΞΉ} (t : (i : ΞΉ) β†’ i ∈ s β†’ (H i).FiniteIndex β†’ Finset β†₯(H i)) (j : ΞΉ) (hj : j ∈ s) (hjfi : (H j).FiniteIndex) (motive : (t j hj hjfi).Nonempty β†’ Prop) (x : (t j hj hjfi).Nonempty), (βˆ€ (x : β†₯(H j)) (hx : x ∈ t j hj hjfi), motive β‹―) β†’ motive x
String.Internal._aux_Init_Data_String_Grind___macroRules_String_Internal_tacticOrder_1
Init.Data.String.Grind
Lean.Macro
Matrix.BlockTriangular.det_fintype
Mathlib.LinearAlgebra.Matrix.Block
βˆ€ {Ξ± : Type u_1} {m : Type u_3} {R : Type v} {M : Matrix m m R} {b : m β†’ Ξ±} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m] [inst_3 : DecidableEq Ξ±] [inst_4 : Fintype Ξ±] [inst_5 : LinearOrder Ξ±], M.BlockTriangular b β†’ M.det = ∏ k, (M.toSquareBlock b k).det
CategoryTheory.CategoryOfElements.map._proof_3
Mathlib.CategoryTheory.Elements
βˆ€ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {F₁ Fβ‚‚ : CategoryTheory.Functor C (Type u_1)} (Ξ± : F₁ ⟢ Fβ‚‚) {X Y Z : F₁.Elements} (f : X ⟢ Y) (g : Y ⟢ Z), βŸ¨β†‘(CategoryTheory.CategoryStruct.comp f g), β‹―βŸ© = CategoryTheory.CategoryStruct.comp βŸ¨β†‘f, β‹―βŸ© βŸ¨β†‘g, β‹―βŸ©
Subgroup.map
Mathlib.Algebra.Group.Subgroup.Map
{G : Type u_1} β†’ [inst : Group G] β†’ {N : Type u_5} β†’ [inst_1 : Group N] β†’ (G β†’* N) β†’ Subgroup G β†’ Subgroup N
FractionalIdeal.mem_coeIdeal_of_mem
Mathlib.RingTheory.FractionalIdeal.Basic
βˆ€ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P] {x : R} {I : Ideal R}, x ∈ I β†’ (algebraMap R P) x ∈ ↑I
Module.annihilator_finsupp
Mathlib.RingTheory.Ideal.Maps
βˆ€ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ΞΉ : Type u_4} [Nonempty ΞΉ], Module.annihilator R (ΞΉ β†’β‚€ M) = Module.annihilator R M
Int.mul_neg_of_pos_of_neg
Init.Data.Int.Order
βˆ€ {a b : β„€}, 0 < a β†’ b < 0 β†’ a * b < 0
CategoryTheory.Limits.Multifork.toPiFork_Ο€_app_one
Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d), (CategoryTheory.Limits.Multifork.toPiFork hc hd K).Ο€.app CategoryTheory.Limits.WalkingParallelPair.one = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.IsLimit.desc hc K.ΞΉ) (I.fstPiMapOfIsLimit c hd)
CategoryTheory.yonedaMon_naturality
Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] {M N X Y : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] (Ξ± : CategoryTheory.yonedaMonObj M ⟢ CategoryTheory.yonedaMonObj N) (f : X ⟢ Y) (g : Y ⟢ M), (CategoryTheory.ConcreteCategory.hom (Ξ±.app (Opposite.op X))) (CategoryTheory.CategoryStruct.comp f g) = CategoryTheory.CategoryStruct.comp f ((CategoryTheory.ConcreteCategory.hom (Ξ±.app (Opposite.op Y))) g)
CircularPreorder.mk._flat_ctor
Mathlib.Order.Circular
{Ξ± : Type u_1} β†’ (btw sbtw : Ξ± β†’ Ξ± β†’ Ξ± β†’ Prop) β†’ (βˆ€ (a : Ξ±), btw a a a) β†’ (βˆ€ {a b c : Ξ±}, btw a b c β†’ btw b c a) β†’ autoParam (βˆ€ {a b c : Ξ±}, sbtw a b c ↔ btw a b c ∧ Β¬btw c b a) CircularPreorder.sbtw_iff_btw_not_btw._autoParam β†’ (βˆ€ {a b c d : Ξ±}, sbtw a b c β†’ sbtw b d c β†’ sbtw a d c) β†’ CircularPreorder Ξ±
CategoryTheory.Limits.preservesFiniteColimits_leftOp
Mathlib.CategoryTheory.Limits.Preserves.Opposites
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type uβ‚‚} [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} D] (F : CategoryTheory.Functor C Dα΅’α΅–) [CategoryTheory.Limits.PreservesFiniteLimits F], CategoryTheory.Limits.PreservesFiniteColimits F.leftOp
fintypeToFinBoolAlgOp._proof_7
Mathlib.Order.Category.FinBoolAlg
βˆ€ {X Y : FintypeCat} (f : X ⟢ Y), (CompleteLatticeHom.setPreimage f) ⊀ = ⊀
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.Split.generalizeMatchDiscrs.mkNewTarget
Lean.Meta.Tactic.Split
Lean.Name β†’ Array Lean.Expr β†’ Lean.Meta.MatcherInfo β†’ β„• β†’ Array Lean.Expr β†’ Array Lean.Expr β†’ IO.Ref Bool β†’ Lean.Expr β†’ Lean.MetaM Lean.Expr
Std.DTreeMap.Const.get?_ofList_of_mem
Std.Data.DTreeMap.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {Ξ² : Type v} [Std.TransCmp cmp] {l : List (Ξ± Γ— Ξ²)} {k k' : Ξ±}, cmp k k' = Ordering.eq β†’ βˆ€ {v : Ξ²}, List.Pairwise (fun a b => Β¬cmp a.1 b.1 = Ordering.eq) l β†’ (k, v) ∈ l β†’ Std.DTreeMap.Const.get? (Std.DTreeMap.Const.ofList l cmp) k' = some v
Ordinal.toNatOrdinal_min
Mathlib.SetTheory.Ordinal.NaturalOps
βˆ€ (a b : Ordinal.{u_1}), Ordinal.toNatOrdinal (min a b) = min (Ordinal.toNatOrdinal a) (Ordinal.toNatOrdinal b)
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.r.match_1.splitter
Init.Grind.Module.Envelope
(Ξ± : Type u_1) β†’ (motive : Ξ± Γ— Ξ± β†’ Ξ± Γ— Ξ± β†’ Sort u_2) β†’ (x x_1 : Ξ± Γ— Ξ±) β†’ ((a b c d : Ξ±) β†’ motive (a, b) (c, d)) β†’ motive x x_1
WittVector.inverseCoeff.congr_simp
Mathlib.RingTheory.WittVector.DiscreteValuationRing
βˆ€ {p : β„•} [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : CommRing k] [inst_1 : CharP k p] (a a_1 : kΛ£), a = a_1 β†’ βˆ€ (A A_1 : WittVector p k), A = A_1 β†’ βˆ€ (a_2 a_3 : β„•), a_2 = a_3 β†’ WittVector.inverseCoeff a A a_2 = WittVector.inverseCoeff a_1 A_1 a_3
Stream'.Seq.get?_cons_succ
Mathlib.Data.Seq.Defs
βˆ€ {Ξ± : Type u} (a : Ξ±) (s : Stream'.Seq Ξ±) (n : β„•), (Stream'.Seq.cons a s).get? (n + 1) = s.get? n
multilinearCurryLeftEquiv_symm_apply
Mathlib.LinearAlgebra.Multilinear.Curry
βˆ€ (R : Type uR) {n : β„•} (M : Fin n.succ β†’ Type v) (Mβ‚‚ : Type vβ‚‚) [inst : CommSemiring R] [inst_1 : (i : Fin n.succ) β†’ AddCommMonoid (M i)] [inst_2 : AddCommMonoid Mβ‚‚] [inst_3 : (i : Fin n.succ) β†’ Module R (M i)] [inst_4 : Module R Mβ‚‚] (f : M 0 β†’β‚—[R] MultilinearMap R (fun i => M i.succ) Mβ‚‚), (multilinearCurryLeftEquiv R M Mβ‚‚).symm f = f.uncurryLeft
_private.Mathlib.MeasureTheory.OuterMeasure.AE.0.MeasureTheory.union_ae_eq_right._simp_1_1
Mathlib.MeasureTheory.OuterMeasure.AE
βˆ€ {Ξ± : Type u} {Ξ² : Type v} [inst : PartialOrder Ξ²] {l : Filter Ξ±} {f g : Ξ± β†’ Ξ²}, (f =αΆ [l] g) = (f ≀ᢠ[l] g ∧ g ≀ᢠ[l] f)
CategoryTheory.WithInitial.ofCommaObject._proof_1
Mathlib.CategoryTheory.WithTerminal.Basic
βˆ€ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] {D : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} D] (c : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D))) (x y : C) (f : x ⟢ y), CategoryTheory.CategoryStruct.comp (c.hom.app x) (c.right.map f) = c.hom.app y
CategoryTheory.Limits.asEmptyCone._proof_3
Mathlib.CategoryTheory.Limits.Shapes.IsTerminal
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) ⦃X_1 Y : CategoryTheory.Discrete PEmpty.{1}⦄ (f : X_1 ⟢ Y), CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const (CategoryTheory.Discrete PEmpty.{1})).obj X).map f) (id (CategoryTheory.Discrete.casesOn Y fun as => β‹―.elim)) = CategoryTheory.CategoryStruct.comp (id (CategoryTheory.Discrete.casesOn X_1 fun as => β‹―.elim)) ((CategoryTheory.Functor.empty C).map f)
lowerClosure_mul_distrib
Mathlib.Algebra.Order.UpperLower
βˆ€ {Ξ± : Type u_1} [inst : CommGroup Ξ±] [inst_1 : PartialOrder Ξ±] [inst_2 : IsOrderedMonoid Ξ±] (s t : Set Ξ±), lowerClosure (s * t) = lowerClosure s * lowerClosure t
CategoryTheory.Oplax.StrongTrans.Modification.equivOplax_apply
Mathlib.CategoryTheory.Bicategory.Modification.Oplax
βˆ€ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type uβ‚‚} [inst_1 : CategoryTheory.Bicategory C] {F G : CategoryTheory.OplaxFunctor B C} {Ξ· ΞΈ : F ⟢ G} (Ξ“ : CategoryTheory.Oplax.OplaxTrans.Modification (CategoryTheory.Oplax.StrongTrans.toOplax Ξ·) (CategoryTheory.Oplax.StrongTrans.toOplax ΞΈ)), CategoryTheory.Oplax.StrongTrans.Modification.equivOplax Ξ“ = CategoryTheory.Oplax.StrongTrans.Modification.mkOfOplax Ξ“
Std.Internal.List.getValueD_insertListConst_of_contains_eq_false
Std.Data.Internal.List.Associative
βˆ€ {Ξ± : Type u} {Ξ² : Type v} [inst : BEq Ξ±] [PartialEquivBEq Ξ±] {l : List ((_ : Ξ±) Γ— Ξ²)} {toInsert : List (Ξ± Γ— Ξ²)} {k : Ξ±} {fallback : Ξ²}, (List.map Prod.fst toInsert).contains k = false β†’ Std.Internal.List.getValueD k (Std.Internal.List.insertListConst l toInsert) fallback = Std.Internal.List.getValueD k l fallback
Β«termβˆƒ_,_Β»
Init.NotationExtra
Lean.ParserDescr
TopCat.Presheaf.pullbackObjObjOfImageOpen
Mathlib.Topology.Sheaves.Presheaf
{C : Type u} β†’ [inst : CategoryTheory.Category.{v, u} C] β†’ [inst_1 : CategoryTheory.Limits.HasColimits C] β†’ {X Y : TopCat} β†’ (f : X ⟢ Y) β†’ (β„± : TopCat.Presheaf C Y) β†’ (U : TopologicalSpace.Opens ↑X) β†’ (H : IsOpen (⇑(CategoryTheory.ConcreteCategory.hom f) '' ↑U)) β†’ ((TopCat.Presheaf.pullback C f).obj β„±).obj (Opposite.op U) β‰… β„±.obj (Opposite.op { carrier := ⇑(CategoryTheory.ConcreteCategory.hom f) '' ↑U, is_open' := H })
Antitone.add_const
Mathlib.Algebra.Order.Monoid.Unbundled.Basic
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Add Ξ±] [inst_1 : Preorder Ξ±] [inst_2 : Preorder Ξ²] {f : Ξ² β†’ Ξ±} [AddRightMono Ξ±], Antitone f β†’ βˆ€ (a : Ξ±), Antitone fun x => f x + a
_private.Mathlib.Algebra.Lie.Weights.Killing.0.LieAlgebra.IsKilling.mem_sl2SubalgebraOfRoot_iff.match_1_4
Mathlib.Algebra.Lie.Weights.Killing
βˆ€ {K : Type u_1} {L : Type u_2} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L] {e f x : L} (ce cf : K) (motive : (βˆƒ c₁ cβ‚‚ c₃, x = c₁ β€’ ce β€’ e + cβ‚‚ β€’ cf β€’ f + c₃ β€’ ⁅ce β€’ e, cf β€’ f⁆) β†’ Prop) (x_1 : βˆƒ c₁ cβ‚‚ c₃, x = c₁ β€’ ce β€’ e + cβ‚‚ β€’ cf β€’ f + c₃ β€’ ⁅ce β€’ e, cf β€’ f⁆), (βˆ€ (c₁ cβ‚‚ c₃ : K) (hx : x = c₁ β€’ ce β€’ e + cβ‚‚ β€’ cf β€’ f + c₃ β€’ ⁅ce β€’ e, cf β€’ f⁆), motive β‹―) β†’ motive x_1
CategoryTheory.Mon.instIsCommMonObj
Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] [inst_2 : CategoryTheory.BraidedCategory C] {M : CategoryTheory.Mon C} [inst_3 : CategoryTheory.IsCommMonObj M.X], CategoryTheory.IsCommMonObj M
Ideal.map_ofList
Mathlib.RingTheory.Regular.RegularSequence
βˆ€ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R β†’+* S) (rs : List R), Ideal.map f (Ideal.ofList rs) = Ideal.ofList (List.map (⇑f) rs)
Lean.Server.FileWorker.EditableDocumentCore.initSnap
Lean.Server.FileWorker.Utils
Lean.Server.FileWorker.EditableDocumentCore β†’ Lean.Language.Lean.InitialSnapshot
CategoryTheory.IsCardinalFiltered.max._proof_1
Mathlib.CategoryTheory.Presentable.IsCardinalFiltered
βˆ€ {ΞΊ : Cardinal.{u_1}} {K : Type u_2}, HasCardinalLT K ΞΊ β†’ HasCardinalLT (CategoryTheory.Arrow (CategoryTheory.Discrete K)) ΞΊ
_private.Init.Data.String.Iterator.0.String.Pos.Raw.get?.match_1.eq_1
Init.Data.String.Iterator
βˆ€ (motive : String β†’ String.Pos.Raw β†’ Sort u_1) (s : String) (p : String.Pos.Raw) (h_1 : (s : String) β†’ (p : String.Pos.Raw) β†’ motive s p), (match s, p with | s, p => h_1 s p) = h_1 s p
Flag.instMulActionOrderIso
Mathlib.Algebra.Order.Group.Action.Flag
{Ξ± : Type u_1} β†’ [inst : Preorder Ξ±] β†’ MulAction (Ξ± ≃o Ξ±) (Flag Ξ±)
ContDiff.differentiable_deriv_two
Mathlib.Analysis.Calculus.ContDiff.Basic
βˆ€ {π•œ : Type u_1} [inst : NontriviallyNormedField π•œ] {F : Type uF} [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace π•œ F] {fβ‚‚ : π•œ β†’ F}, ContDiff π•œ 2 fβ‚‚ β†’ Differentiable π•œ (deriv fβ‚‚)
TopologicalSpace.PositiveCompacts.instOrderTopOfCompactSpaceOfNonempty._proof_2
Mathlib.Topology.Sets.Compacts
βˆ€ {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] [inst_1 : CompactSpace Ξ±] [inst_2 : Nonempty Ξ±], β†‘βŠ€ = β†‘βŠ€
List.lookmap_id'
Mathlib.Data.List.Lookmap
βˆ€ {Ξ± : Type u_1} (f : Ξ± β†’ Option Ξ±), (βˆ€ (a b : Ξ±), b ∈ f a β†’ a = b) β†’ βˆ€ (l : List Ξ±), List.lookmap f l = l
PosNum.testBit.eq_def
Mathlib.Data.Num.Lemmas
βˆ€ (x : PosNum) (x_1 : β„•), x.testBit x_1 = match x, x_1 with | PosNum.one, 0 => true | PosNum.one, x => false | a.bit0, 0 => false | p.bit0, n.succ => p.testBit n | a.bit1, 0 => true | p.bit1, n.succ => p.testBit n
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_1
Mathlib.Algebra.Divisibility.Prod
βˆ€ {Ξ± : Type u_1} [inst : Semigroup Ξ±] {a b : Ξ±}, (a ∣ b) = βˆƒ c, b = a * c
CategoryTheory.Limits.BinaryBicone.inrCokernelCofork
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.CokernelCofork c.inr
Lean.Meta.Grind.EMatchTheoremConstraint.isValue.elim
Lean.Meta.Tactic.Grind.EMatchTheorem
{motive : Lean.Meta.Grind.EMatchTheoremConstraint β†’ Sort u} β†’ (t : Lean.Meta.Grind.EMatchTheoremConstraint) β†’ t.ctorIdx = 6 β†’ ((bvarIdx : β„•) β†’ (strict : Bool) β†’ motive (Lean.Meta.Grind.EMatchTheoremConstraint.isValue bvarIdx strict)) β†’ motive t
Matroid.fundCircuit
Mathlib.Combinatorics.Matroid.Circuit
{Ξ± : Type u_1} β†’ Matroid Ξ± β†’ Ξ± β†’ Set Ξ± β†’ Set Ξ±
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.funProp._sparseCasesOn_1
Mathlib.Tactic.FunProp.Core
{motive : Lean.Expr β†’ Sort u} β†’ (t : Lean.Expr) β†’ ((declName : Lean.Name) β†’ (type value body : Lean.Expr) β†’ (nondep : Bool) β†’ motive (Lean.Expr.letE declName type value body nondep)) β†’ ((binderName : Lean.Name) β†’ (binderType body : Lean.Expr) β†’ (binderInfo : Lean.BinderInfo) β†’ motive (Lean.Expr.forallE binderName binderType body binderInfo)) β†’ ((data : Lean.MData) β†’ (expr : Lean.Expr) β†’ motive (Lean.Expr.mdata data expr)) β†’ (Nat.hasNotBit 1408 t.ctorIdx β†’ motive t) β†’ motive t
MvPolynomial.renameEquiv
Mathlib.Algebra.MvPolynomial.Rename
{Οƒ : Type u_1} β†’ {Ο„ : Type u_2} β†’ (R : Type u_4) β†’ [inst : CommSemiring R] β†’ Οƒ ≃ Ο„ β†’ MvPolynomial Οƒ R ≃ₐ[R] MvPolynomial Ο„ R
CategoryTheory.LocalizerMorphism.smallHomMap'._proof_3
Mathlib.CategoryTheory.Localization.SmallHom
βˆ€ {C₁ : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C₁] {W₁ : CategoryTheory.MorphismProperty C₁} {Cβ‚‚ : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} Cβ‚‚] {Wβ‚‚ : CategoryTheory.MorphismProperty Cβ‚‚} (Ξ¦ : CategoryTheory.LocalizerMorphism W₁ Wβ‚‚) {Y : C₁} {Y' : Cβ‚‚} [CategoryTheory.Localization.HasSmallLocalizedHom Wβ‚‚ Y' Y'] (eY : Ξ¦.functor.obj Y β‰… Y'), CategoryTheory.Localization.HasSmallLocalizedHom Wβ‚‚ (Ξ¦.functor.obj Y) Y'
CategoryTheory.ShortComplex.HomologyData.recOn
Mathlib.Algebra.Homology.ShortComplex.Homology
{C : Type u} β†’ [inst : CategoryTheory.Category.{v, u} C] β†’ [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] β†’ {S : CategoryTheory.ShortComplex C} β†’ {motive : S.HomologyData β†’ Sort u_1} β†’ (t : S.HomologyData) β†’ ((left : S.LeftHomologyData) β†’ (right : S.RightHomologyData) β†’ (iso : left.H β‰… right.H) β†’ (comm : CategoryTheory.CategoryStruct.comp left.Ο€ (CategoryTheory.CategoryStruct.comp iso.hom right.ΞΉ) = CategoryTheory.CategoryStruct.comp left.i right.p) β†’ motive { left := left, right := right, iso := iso, comm := comm }) β†’ motive t
Std.DTreeMap.Internal.Impl.getEntry?.eq_def
Std.Data.DTreeMap.Internal.Model
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} [inst : Ord Ξ±] (t : Std.DTreeMap.Internal.Impl Ξ± Ξ²) (k : Ξ±), t.getEntry? k = match t with | Std.DTreeMap.Internal.Impl.leaf => none | Std.DTreeMap.Internal.Impl.inner size k' v' l r => match compare k k' with | Ordering.lt => l.getEntry? k | Ordering.gt => r.getEntry? k | Ordering.eq => some ⟨k', v'⟩
AlgebraicGeometry.Scheme.affineOpens.eq_1
Mathlib.AlgebraicGeometry.Morphisms.Affine
βˆ€ (X : AlgebraicGeometry.Scheme), X.affineOpens = {U | AlgebraicGeometry.IsAffineOpen U}
AddChar.zmod_char_primitive_of_eq_one_only_at_zero
Mathlib.NumberTheory.LegendreSymbol.AddCharacter
βˆ€ {C : Type v} [inst : CommMonoid C] (n : β„•) (ψ : AddChar (ZMod n) C), (βˆ€ (a : ZMod n), ψ a = 1 β†’ a = 0) β†’ ψ.IsPrimitive
quasispectrum.preimage_algebraMap
Mathlib.Algebra.Algebra.Spectrum.Quasispectrum
βˆ€ (S : Type u_3) {R : Type u_4} {A : Type u_5} [inst : Semifield R] [inst_1 : Field S] [inst_2 : NonUnitalRing A] [inst_3 : Algebra R S] [inst_4 : Module S A] [IsScalarTower S A A] [SMulCommClass S A A] [inst_7 : Module R A] [IsScalarTower R S A] {a : A}, ⇑(algebraMap R S) ⁻¹' quasispectrum S a = quasispectrum R a
Std.DTreeMap.Equiv.getEntryLT_eq.match_1
Std.Data.DTreeMap.Lemmas
βˆ€ {Ξ± : Type u_1} {Ξ² : Ξ± β†’ Type u_2} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t₁ : Std.DTreeMap Ξ± Ξ² cmp} {k : Ξ±} (x : Ξ±) (motive : x ∈ t₁ ∧ cmp x k = Ordering.lt β†’ Prop) (x_1 : x ∈ t₁ ∧ cmp x k = Ordering.lt), (βˆ€ (h₁ : x ∈ t₁) (hβ‚‚ : cmp x k = Ordering.lt), motive β‹―) β†’ motive x_1
Lean.JsonRpc.RequestID._sizeOf_1
Lean.Data.JsonRpc
Lean.JsonRpc.RequestID β†’ β„•
Mathlib.Tactic.Push.push
Mathlib.Tactic.Push
Mathlib.Tactic.Push.Config β†’ Option Lean.Meta.Simp.Discharge β†’ Mathlib.Tactic.Push.Head β†’ Lean.Elab.Tactic.Location β†’ optParam Bool true β†’ Lean.Elab.Tactic.TacticM Unit
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ediv_zero.match_1_1
Init.Data.Int.DivMod.Bootstrap
βˆ€ (motive : β„€ β†’ Prop) (x : β„€), (βˆ€ (a : β„•), motive (Int.ofNat a)) β†’ (βˆ€ (a : β„•), motive (Int.negSucc a)) β†’ motive x
ISize.ofIntLE.congr_simp
Init.Data.SInt.Lemmas
βˆ€ (i i_1 : β„€) (e_i : i = i_1) (_hl : ISize.minValue.toInt ≀ i) (_hr : i ≀ ISize.maxValue.toInt), ISize.ofIntLE i _hl _hr = ISize.ofIntLE i_1 β‹― β‹―
Lean.Compiler.LCNF.NormFVarResult.erased.sizeOf_spec
Lean.Compiler.LCNF.CompilerM
sizeOf Lean.Compiler.LCNF.NormFVarResult.erased = 1
SimpleGraph.lapMatrix_mulVec_eq_zero_iff_forall_reachable
Mathlib.Combinatorics.SimpleGraph.LapMatrix
βˆ€ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) [inst_1 : DecidableRel G.Adj] [inst_2 : DecidableEq V] {x : V β†’ ℝ}, (SimpleGraph.lapMatrix ℝ G).mulVec x = 0 ↔ βˆ€ (i j : V), G.Reachable i j β†’ x i = x j
CategoryTheory.Monad.ForgetCreatesColimits.liftedCocone
Mathlib.CategoryTheory.Monad.Limits
{C : Type u₁} β†’ [inst : CategoryTheory.Category.{v₁, u₁} C] β†’ {T : CategoryTheory.Monad C} β†’ {J : Type u} β†’ [inst_1 : CategoryTheory.Category.{v, u} J] β†’ {D : CategoryTheory.Functor J T.Algebra} β†’ (c : CategoryTheory.Limits.Cocone (D.comp T.forget)) β†’ CategoryTheory.Limits.IsColimit c β†’ [CategoryTheory.Limits.PreservesColimit (D.comp T.forget) T.toFunctor] β†’ [CategoryTheory.Limits.PreservesColimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor] β†’ CategoryTheory.Limits.Cocone D
sdiff_inf_distrib
Mathlib.Order.Heyting.Basic
βˆ€ {Ξ± : Type u_2} [inst : GeneralizedCoheytingAlgebra Ξ±] (a b c : Ξ±), a \ (b βŠ“ c) = a \ b βŠ” a \ c
GenContFract.first_den_eq
Mathlib.Algebra.ContinuedFractions.Translations
βˆ€ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K] {gp : GenContFract.Pair K}, g.s.get? 0 = some gp β†’ g.dens 1 = gp.b
orderBornology
Mathlib.Topology.Order.Bornology
{Ξ± : Type u_1} β†’ [Lattice Ξ±] β†’ [Nonempty Ξ±] β†’ Bornology Ξ±
SimpleGraph.Walk.IsHamiltonianCycle.mk._flat_ctor
Mathlib.Combinatorics.SimpleGraph.Hamiltonian
βˆ€ {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {G : SimpleGraph Ξ±} {a : Ξ±} {p : G.Walk a a}, p.edges.Nodup β†’ p β‰  SimpleGraph.Walk.nil β†’ p.support.tail.Nodup β†’ p.tail.IsHamiltonian β†’ p.IsHamiltonianCycle
_private.Init.Data.Array.Erase.0.Array.exists_erase_eq.match_1_1
Init.Data.Array.Erase
βˆ€ {Ξ± : Type u_1} [inst : BEq Ξ±] {a : Ξ±} {xs : Array Ξ±} (motive : (βˆƒ a_1 ys zs, (βˆ€ b ∈ ys, Β¬(a == b) = true) ∧ (a == a_1) = true ∧ xs = ys.push a_1 ++ zs ∧ xs.eraseP (BEq.beq a) = ys ++ zs) β†’ Prop) (x : βˆƒ a_1 ys zs, (βˆ€ b ∈ ys, Β¬(a == b) = true) ∧ (a == a_1) = true ∧ xs = ys.push a_1 ++ zs ∧ xs.eraseP (BEq.beq a) = ys ++ zs), (βˆ€ (w : Ξ±) (ys zs : Array Ξ±) (h₁ : βˆ€ b ∈ ys, Β¬(a == b) = true) (e : (a == w) = true) (hβ‚‚ : xs = ys.push w ++ zs) (h₃ : xs.eraseP (BEq.beq a) = ys ++ zs), motive β‹―) β†’ motive x
_private.Mathlib.CategoryTheory.Presentable.OrthogonalReflection.0.CategoryTheory.OrthogonalReflection.isIso_toSucc_iff._simp_1_1
Mathlib.CategoryTheory.Presentable.OrthogonalReflection
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C} [inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁] [inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.objβ‚‚] {X Y : C} (f : X ⟢ Y) (hf : W f) (g : X ⟢ Z) {Z_1 : C} (h : ∐ CategoryTheory.OrthogonalReflection.D₁.objβ‚‚ ⟢ Z_1), CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ΞΉRight f hf g) h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ΞΉLeft f hf g) (CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.t W Z) h)
_private.Mathlib.NumberTheory.LSeries.RiemannZeta.0.two_mul_riemannZeta_eq_tsum_int_inv_pow_of_even._proof_1_1
Mathlib.NumberTheory.LSeries.RiemannZeta
βˆ€ {k : β„•}, 2 ≀ k β†’ Β¬k = 0
Lean.Meta.Grind.EMatch.SearchState._sizeOf_1
Lean.Meta.Tactic.Grind.EMatch
Lean.Meta.Grind.EMatch.SearchState β†’ β„•
IterateMulAct.instMeasurableSpace
Mathlib.MeasureTheory.MeasurableSpace.Instances
{Ξ± : Type u_1} β†’ {f : Ξ± β†’ Ξ±} β†’ MeasurableSpace (IterateMulAct f)