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
MeasureTheory.Adapted.stronglyMeasurable_stoppedProcess_of_discrete
Mathlib.Probability.Process.Stopping
βˆ€ {Ξ© : Type u_1} {Ξ² : Type u_2} {ΞΉ : Type u_3} {m : MeasurableSpace Ξ©} [inst : TopologicalSpace Ξ²] [TopologicalSpace.PseudoMetrizableSpace Ξ²] [inst_2 : Nonempty ΞΉ] [inst_3 : LinearOrder ΞΉ] [inst_4 : TopologicalSpace ΞΉ] [SecondCountableTopology ΞΉ] [OrderTopology ΞΉ] [inst_7 : MeasurableSpace ΞΉ] [BorelSpace ΞΉ] {f : MeasureTheory.Filtration ΞΉ m} {u : ΞΉ β†’ Ξ© β†’ Ξ²} {Ο„ : Ξ© β†’ WithTop ΞΉ} [DiscreteTopology ΞΉ], MeasureTheory.Adapted f u β†’ MeasureTheory.IsStoppingTime f Ο„ β†’ βˆ€ (n : ΞΉ), MeasureTheory.StronglyMeasurable (MeasureTheory.stoppedProcess u Ο„ n)
algebraMap_smul
Mathlib.Algebra.Algebra.Basic
βˆ€ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : Semiring A] [inst_2 : Algebra R A] {M : Type u_3} [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [IsScalarTower R A M] (r : R) (m : M), (algebraMap R A) r β€’ m = r β€’ m
pi_generateFrom_eq_finite
Mathlib.Topology.Constructions
βˆ€ {ΞΉ : Type u_5} {X : ΞΉ β†’ Type u_9} {g : (a : ΞΉ) β†’ Set (Set (X a))} [Finite ΞΉ], (βˆ€ (a : ΞΉ), ⋃₀ g a = Set.univ) β†’ Pi.topologicalSpace = TopologicalSpace.generateFrom {t | βˆƒ s, (βˆ€ (a : ΞΉ), s a ∈ g a) ∧ t = Set.univ.pi s}
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_11
Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper
βˆ€ {R : Type u_1} [inst : CommRing R] {K : Type u_5} [inst_1 : CommRing K] [inst_2 : Algebra R K] [IsFractionRing R K] {a b : R}, (↑a = ↑b) = (a = b)
TwoSidedIdeal.asIdealOpposite
Mathlib.RingTheory.TwoSidedIdeal.Operations
{R : Type u_1} β†’ [inst : Ring R] β†’ TwoSidedIdeal R β†’o Ideal Rᡐᡒᡖ
Mathlib.Meta.NormNum.evalIsSquareRat
Mathlib.Tactic.NormNum.IsSquare
Mathlib.Meta.NormNum.NormNumExt
Std.MaxEqOr
Init.Data.Order.Classes
(Ξ± : Type u) β†’ [Max Ξ±] β†’ Prop
BitVec.ofInt_iSizeToInt
Init.Data.SInt.Lemmas
βˆ€ (x : ISize), BitVec.ofInt System.Platform.numBits x.toInt = x.toBitVec
Btw.rec
Mathlib.Order.Circular
{Ξ± : Type u_1} β†’ {motive : Btw Ξ± β†’ Sort u} β†’ ((btw : Ξ± β†’ Ξ± β†’ Ξ± β†’ Prop) β†’ motive { btw := btw }) β†’ (t : Btw Ξ±) β†’ motive t
MeasurableSpace.DynkinSystem.instPartialOrder._proof_3
Mathlib.MeasureTheory.PiSystem
βˆ€ {Ξ± : Type u_1} (x x_1 x_2 : MeasurableSpace.DynkinSystem Ξ±), x ≀ x_1 β†’ x_1 ≀ x_2 β†’ x ≀ x_2
Std.DTreeMap.Internal.Impl.getKey._sunfold
Std.Data.DTreeMap.Internal.Queries
{Ξ± : Type u} β†’ {Ξ² : Ξ± β†’ Type v} β†’ [inst : Ord Ξ±] β†’ (t : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ (k : Ξ±) β†’ Std.DTreeMap.Internal.Impl.contains k t = true β†’ Ξ±
Lean.Meta.Grind.AC.DiseqCnstrProof.erase_dup
Lean.Meta.Tactic.Grind.AC.Types
Lean.Meta.Grind.AC.DiseqCnstr β†’ Lean.Meta.Grind.AC.DiseqCnstrProof
Sum.swap_swap_eq
Init.Data.Sum.Lemmas
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2}, Sum.swap ∘ Sum.swap = id
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_382
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital
Lean.Syntax
UniformSpace.hausdorff
Mathlib.Topology.UniformSpace.Closeds
(Ξ± : Type u_1) β†’ [UniformSpace Ξ±] β†’ UniformSpace (Set Ξ±)
Sum.getRight_eq_getRight?
Mathlib.Data.Sum.Basic
βˆ€ {Ξ± : Type u} {Ξ² : Type v} {x : Ξ± βŠ• Ξ²} (h₁ : x.isRight = true) (hβ‚‚ : x.getRight?.isSome = true), x.getRight h₁ = x.getRight?.get hβ‚‚
Submodule.instDiv._proof_1
Mathlib.Algebra.Algebra.Operations
βˆ€ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (I J : Submodule R A) {a b : A}, a ∈ {x | βˆ€ y ∈ J, x * y ∈ I} β†’ b ∈ {x | βˆ€ y ∈ J, x * y ∈ I} β†’ βˆ€ y ∈ J, (a + b) * y ∈ I
SeminormedCommGroup
Mathlib.Analysis.Normed.Group.Basic
Type u_8 β†’ Type u_8
Computability.Β«term_≑ᡀ_Β»
Mathlib.Computability.TuringDegree
Lean.TrailingParserDescr
Vector.push_inj_left
Init.Data.Vector.Lemmas
βˆ€ {Ξ± : Type u_1} {n : β„•} {a : Ξ±} {xs ys : Vector Ξ± n}, xs.push a = ys.push a ↔ xs = ys
Lean.mkPtrSet
Lean.Util.PtrSet
{Ξ± : Type} β†’ optParam β„• 64 β†’ Lean.PtrSet Ξ±
Subtype.forall_set_subtype
Mathlib.Data.Set.Image
βˆ€ {Ξ± : Type u_1} {t : Set Ξ±} (p : Set Ξ± β†’ Prop), (βˆ€ (s : Set ↑t), p (Subtype.val '' s)) ↔ βˆ€ s βŠ† t, p s
Lean.Widget.GetGoToLocationParams.noConfusionType
Lean.Server.FileWorker.WidgetRequests
Sort u β†’ Lean.Widget.GetGoToLocationParams β†’ Lean.Widget.GetGoToLocationParams β†’ Sort u
SimpleGraph.Subgraph.botIso._proof_2
Mathlib.Combinatorics.SimpleGraph.Subgraph
βˆ€ {V : Type u_1} {G : SimpleGraph V} (x : ↑βŠ₯.verts), (False.elim β‹―).elim = x
CategoryTheory.Grothendieck.map._proof_2
Mathlib.CategoryTheory.Grothendieck
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat} (Ξ± : F ⟢ G) (X : CategoryTheory.Grothendieck F), { base := (CategoryTheory.CategoryStruct.id X).base, fiber := CategoryTheory.CategoryStruct.comp ((CategoryTheory.eqToHom β‹―).toNatTrans.app X.fiber) ((Ξ±.app X.base).toFunctor.map (CategoryTheory.CategoryStruct.id X).fiber) } = CategoryTheory.CategoryStruct.id { base := X.base, fiber := (Ξ±.app X.base).toFunctor.obj X.fiber }
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.isSeparated._simp_5
Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper
βˆ€ {R S T : CommRingCat} (f : R ⟢ S) (g : S ⟢ T), CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map g) (AlgebraicGeometry.Spec.map f) = AlgebraicGeometry.Spec.map (CategoryTheory.CategoryStruct.comp f g)
Turing.TM1to0.trAux._sunfold
Mathlib.Computability.PostTuringMachine
{Ξ“ : Type u_1} β†’ {Ξ› : Type u_2} β†’ {Οƒ : Type u_3} β†’ (M : Ξ› β†’ Turing.TM1.Stmt Ξ“ Ξ› Οƒ) β†’ Ξ“ β†’ Turing.TM1.Stmt Ξ“ Ξ› Οƒ β†’ Οƒ β†’ Turing.TM1to0.Ξ›' M Γ— Turing.TM0.Stmt Ξ“
ContinuousAlternatingMap.piLIE._proof_6
Mathlib.Analysis.Normed.Module.Alternating.Basic
βˆ€ (π•œ : Type u_1) [inst : NontriviallyNormedField π•œ] {ΞΉ' : Type u_2} {F : ΞΉ' β†’ Type u_3} [inst_1 : (i' : ΞΉ') β†’ SeminormedAddCommGroup (F i')] [inst_2 : (i' : ΞΉ') β†’ NormedSpace π•œ (F i')], SMulCommClass π•œ π•œ ((i : ΞΉ') β†’ F i)
Function.IsFixedPt.eq_1
Mathlib.Order.OmegaCompletePartialOrder
βˆ€ {Ξ± : Type u₁} (f : Ξ± β†’ Ξ±) (x : Ξ±), Function.IsFixedPt f x = (f x = x)
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Empty.0.Std.Iterators.IterM.DefaultConsumers.forIn'_eq_match_step.match_3.splitter
Std.Data.Iterators.Lemmas.Producers.Monadic.Empty
{Ξ± Ξ² : Type u_1} β†’ {m : Type u_1 β†’ Type u_2} β†’ [inst : Std.Iterators.Iterator Ξ± m Ξ²] β†’ {it : Std.IterM m Ξ²} β†’ (motive : it.Step β†’ Sort u_3) β†’ (x : it.Step) β†’ ((it' : Std.IterM m Ξ²) β†’ (out : Ξ²) β†’ (h : it.IsPlausibleStep (Std.Iterators.IterStep.yield it' out)) β†’ motive ⟨Std.Iterators.IterStep.yield it' out, h⟩) β†’ ((it' : Std.IterM m Ξ²) β†’ (h : it.IsPlausibleStep (Std.Iterators.IterStep.skip it')) β†’ motive ⟨Std.Iterators.IterStep.skip it', h⟩) β†’ ((property : it.IsPlausibleStep Std.Iterators.IterStep.done) β†’ motive ⟨Std.Iterators.IterStep.done, property⟩) β†’ motive x
Dvd.noConfusion
Init.Prelude
{P : Sort u} β†’ {Ξ± : Type u_1} β†’ {t : Dvd Ξ±} β†’ {Ξ±' : Type u_1} β†’ {t' : Dvd Ξ±'} β†’ Ξ± = Ξ±' β†’ t ≍ t' β†’ Dvd.noConfusionType P t t'
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁.elim
Lean.Meta.Tactic.Grind.Arith.Cutsat.Types
{motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof β†’ Sort u} β†’ (t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) β†’ t.ctorIdx = 9 β†’ ((c : Lean.Meta.Grind.Arith.Cutsat.CooperSplit) β†’ motive_7 (Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁ c)) β†’ motive_7 t
Std.TreeSet.Raw.maxD_eq_iff_mem_and_forall
Std.Data.TreeSet.Raw.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.TreeSet.Raw Ξ± cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp], t.WF β†’ t.isEmpty = false β†’ βˆ€ {km fallback : Ξ±}, t.maxD fallback = km ↔ km ∈ t ∧ βˆ€ k ∈ t, (cmp k km).isLE = true
CompactlySupportedContinuousMap.instInf._proof_2
Mathlib.Topology.ContinuousMap.CompactlySupported
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : TopologicalSpace Ξ±] [inst_1 : SemilatticeInf Ξ²] [inst_2 : Zero Ξ²] [inst_3 : TopologicalSpace Ξ²] (f g : CompactlySupportedContinuousMap Ξ± Ξ²), HasCompactSupport (⇑f βŠ“ ⇑g)
_private.Mathlib.Algebra.Algebra.Bilinear.0.LinearMap.pow_mulLeft.match_1_1
Mathlib.Algebra.Algebra.Bilinear
βˆ€ (motive : β„• β†’ Prop) (n : β„•), (βˆ€ (a : Unit), motive 0) β†’ (βˆ€ (n : β„•), motive n.succ) β†’ motive n
FiniteArchimedeanClass.lift_mk
Mathlib.Algebra.Order.Archimedean.Class
βˆ€ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {Ξ± : Type u_2} (f : { a // a β‰  0 } β†’ Ξ±) (h : βˆ€ (a b : { a // a β‰  0 }), FiniteArchimedeanClass.mk ↑a β‹― = FiniteArchimedeanClass.mk ↑b β‹― β†’ f a = f b) {a : M} (ha : a β‰  0), FiniteArchimedeanClass.lift f h (FiniteArchimedeanClass.mk a ha) = f ⟨a, ha⟩
FirstOrder.Language.Sentence.cardGe.eq_1
Mathlib.ModelTheory.Semantics
βˆ€ (L : FirstOrder.Language) (n : β„•), FirstOrder.Language.Sentence.cardGe L n = (List.foldr (fun x1 x2 => x1 βŠ“ x2) ⊀ (List.map (fun ij => (((FirstOrder.Language.var ∘ Sum.inr) ij.1).bdEqual ((FirstOrder.Language.var ∘ Sum.inr) ij.2)).not) (List.filter (fun ij => decide (ij.1 β‰  ij.2)) (List.finRange n Γ—Λ’ List.finRange n)))).exs
Subsemigroup.instCompleteLattice._proof_14
Mathlib.Algebra.Group.Subsemigroup.Basic
βˆ€ {M : Type u_1} [inst : Mul M] (s : Set (Subsemigroup M)), βˆ€ a ∈ s, sInf s ≀ a
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.instEncodableS
Mathlib.Tactic.DeriveEncodable
Encodable Mathlib.Deriving.Encodable.S✝
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.entryAtIdx?.match_1.eq_1
Std.Data.DTreeMap.Internal.Model
βˆ€ (motive : Ordering β†’ Sort u_1) (h_1 : Unit β†’ motive Ordering.lt) (h_2 : Unit β†’ motive Ordering.eq) (h_3 : Unit β†’ motive Ordering.gt), (match Ordering.lt with | Ordering.lt => h_1 () | Ordering.eq => h_2 () | Ordering.gt => h_3 ()) = h_1 ()
Turing.PartrecToTM2.moveβ‚‚
Mathlib.Computability.TMToPartrec
(Turing.PartrecToTM2.Ξ“' β†’ Bool) β†’ Turing.PartrecToTM2.K' β†’ Turing.PartrecToTM2.K' β†’ Turing.PartrecToTM2.Ξ›' β†’ Turing.PartrecToTM2.Ξ›'
Mathlib.Notation3.mkScopedMatcher
Mathlib.Util.Notation3
Lean.Name β†’ Lean.Name β†’ Lean.Term β†’ Array Lean.Name β†’ OptionT Lean.Elab.TermElabM (List Mathlib.Notation3.DelabKey Γ— Lean.Term)
_private.Mathlib.Algebra.Lie.Weights.Cartan.0.LieAlgebra.mem_zeroRootSubalgebra._simp_1_1
Mathlib.Algebra.Lie.Weights.Cartan
βˆ€ {R : Type u_2} {L : Type u_3} (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] [inst_7 : LieRing.IsNilpotent L] (Ο‡ : L β†’ R) (m : M), (m ∈ LieModule.genWeightSpace M Ο‡) = βˆ€ (x : L), βˆƒ k, (((LieModule.toEnd R L M) x - Ο‡ x β€’ 1) ^ k) m = 0
Lean.Parser.Term.subst.parenthesizer
Lean.Parser.Term
Lean.PrettyPrinter.Parenthesizer
Ideal.map_sup_comap_of_surjective
Mathlib.RingTheory.Ideal.Maps
βˆ€ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F) [inst_3 : RingHomClass F R S], Function.Surjective ⇑f β†’ βˆ€ (I J : Ideal S), Ideal.map f (Ideal.comap f I βŠ” Ideal.comap f J) = I βŠ” J
Homeomorph.mulRight
Mathlib.Topology.Algebra.Group.Basic
{G : Type w} β†’ [inst : TopologicalSpace G] β†’ [inst_1 : Group G] β†’ [ContinuousMul G] β†’ G β†’ G β‰ƒβ‚œ G
Turing.TM2to1.trStmts₁.eq_3
Mathlib.Computability.TuringMachine
βˆ€ {K : Type u_1} {Ξ“ : K β†’ Type u_2} {Ξ› : Type u_3} {Οƒ : Type u_4} (k : K) (f : Οƒ β†’ Option (Ξ“ k) β†’ Οƒ) (q : Turing.TM2.Stmt Ξ“ Ξ› Οƒ), Turing.TM2to1.trStmts₁ (Turing.TM2.Stmt.pop k f q) = {Turing.TM2to1.Ξ›'.go k (Turing.TM2to1.StAct.pop f) q, Turing.TM2to1.Ξ›'.ret q} βˆͺ Turing.TM2to1.trStmts₁ q
Module.DirectLimit.of._proof_3
Mathlib.Algebra.Colimit.Module
βˆ€ (R : Type u_3) [inst : Semiring R] (ΞΉ : Type u_1) [inst_1 : Preorder ΞΉ] (G : ΞΉ β†’ Type u_2) [inst_2 : DecidableEq ΞΉ] [inst_3 : (i : ΞΉ) β†’ AddCommMonoid (G i)] [inst_4 : (i : ΞΉ) β†’ Module R (G i)] (f : (i j : ΞΉ) β†’ i ≀ j β†’ G i β†’β‚—[R] G j) (x : R) (x_1 : DirectSum ΞΉ G), (↑(Module.DirectLimit.moduleCon f).mk').toFun (x β€’ x_1) = (↑(Module.DirectLimit.moduleCon f).mk').toFun (x β€’ x_1)
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave'_1
Init.Tactics
Lean.Macro
Real.analyticOn_cos
Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
βˆ€ {s : Set ℝ}, AnalyticOn ℝ Real.cos s
Subgroup.rightCosetEquivSubgroup
Mathlib.GroupTheory.Coset.Basic
{Ξ± : Type u_1} β†’ [inst : Group Ξ±] β†’ {s : Subgroup Ξ±} β†’ (g : Ξ±) β†’ ↑(MulOpposite.op g β€’ ↑s) ≃ β†₯s
Batteries.RBNode.Balanced.below.black
Batteries.Data.RBMap.Basic
βˆ€ {Ξ± : Type u_1} {motive : (a : Batteries.RBNode Ξ±) β†’ (a_1 : Batteries.RBColor) β†’ (a_2 : β„•) β†’ a.Balanced a_1 a_2 β†’ Prop} {x : Batteries.RBNode Ξ±} {c₁ : Batteries.RBColor} {n : β„•} {y : Batteries.RBNode Ξ±} {cβ‚‚ : Batteries.RBColor} {v : Ξ±} (a : x.Balanced c₁ n) (a_1 : y.Balanced cβ‚‚ n), Batteries.RBNode.Balanced.below a β†’ motive x c₁ n a β†’ Batteries.RBNode.Balanced.below a_1 β†’ motive y cβ‚‚ n a_1 β†’ Batteries.RBNode.Balanced.below β‹―
RatFunc.instCommRing._proof_5
Mathlib.FieldTheory.RatFunc.Basic
βˆ€ (K : Type u_1) [inst : CommRing K], Nat.unaryCast 0 = Nat.unaryCast 0
Set.pi.eq_1
Mathlib.Data.Set.Prod
βˆ€ {ΞΉ : Type u_1} {Ξ± : ΞΉ β†’ Type u_2} (s : Set ΞΉ) (t : (i : ΞΉ) β†’ Set (Ξ± i)), s.pi t = {f | βˆ€ i ∈ s, f i ∈ t i}
_private.Mathlib.RingTheory.Ideal.Height.0.Ideal.sup_primeHeight_of_maximal_eq_ringKrullDim._proof_1_2
Mathlib.RingTheory.Ideal.Height
βˆ€ {R : Type u_1} [inst : CommRing R], Ideal.IsMaximal βŠ₯ β†’ Ideal.IsPrime βŠ₯
_private.Init.Data.List.Lemmas.0.List.map_eq_nil_iff.match_1_1
Init.Data.List.Lemmas
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β†’ Ξ²} (motive : (l : List Ξ±) β†’ List.map f l = [] β†’ Prop) (l : List Ξ±) (x : List.map f l = []), (βˆ€ (x : List.map f [] = []), motive [] x) β†’ motive l x
Complex.HadamardThreeLines.norm_invInterpStrip
Mathlib.Analysis.Complex.Hadamard
βˆ€ {E : Type u_1} [inst : NormedAddCommGroup E] (f : β„‚ β†’ E) (z : β„‚) {Ξ΅ : ℝ}, Ξ΅ > 0 β†’ β€–Complex.HadamardThreeLines.invInterpStrip f z Ξ΅β€– = (Ξ΅ + Complex.HadamardThreeLines.sSupNormIm f 0) ^ (z.re - 1) * (Ξ΅ + Complex.HadamardThreeLines.sSupNormIm f 1) ^ (-z.re)
_private.Init.Meta.Defs.0.Lean.Syntax.getTailInfo?.match_1
Init.Meta.Defs
(motive : Lean.Syntax β†’ Sort u_1) β†’ (x : Lean.Syntax) β†’ ((info : Lean.SourceInfo) β†’ (val : String) β†’ motive (Lean.Syntax.atom info val)) β†’ ((info : Lean.SourceInfo) β†’ (rawVal : Substring.Raw) β†’ (val : Lean.Name) β†’ (preresolved : List Lean.Syntax.Preresolved) β†’ motive (Lean.Syntax.ident info rawVal val preresolved)) β†’ ((kind : Lean.SyntaxNodeKind) β†’ (args : Array Lean.Syntax) β†’ motive (Lean.Syntax.node Lean.SourceInfo.none kind args)) β†’ ((info : Lean.SourceInfo) β†’ (kind : Lean.SyntaxNodeKind) β†’ (args : Array Lean.Syntax) β†’ motive (Lean.Syntax.node info kind args)) β†’ ((x : Lean.Syntax) β†’ motive x) β†’ motive x
Set.ncard_lt_card
Mathlib.Data.Set.Card
βˆ€ {Ξ± : Type u_1} {s : Set Ξ±} [Finite Ξ±], s β‰  Set.univ β†’ s.ncard < Nat.card Ξ±
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra.0.IntermediateField.algebraAdjoinAdjoin.instIsFractionRingSubtypeMemSubalgebraAdjoinAdjoin.match_3
Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra
βˆ€ (F : Type u_2) [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E) (motive : β†₯(IntermediateField.adjoin F S) β†’ Prop) (x : β†₯(IntermediateField.adjoin F S)), (βˆ€ (val : E) (h : val ∈ IntermediateField.adjoin F S), motive ⟨val, h⟩) β†’ motive x
CompHausLike.LocallyConstant.counitAppAppImage
Mathlib.Condensed.Discrete.LocallyConstant
{P : TopCat β†’ Prop} β†’ [inst : βˆ€ (S : CompHausLike P) (p : ↑S.toTop β†’ Prop), CompHausLike.HasProp P (Subtype p)] β†’ {S : CompHausLike P} β†’ {Y : CategoryTheory.Functor (CompHausLike P)α΅’α΅– (Type (max u w))} β†’ [inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] β†’ (f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (CompHausLike.of P PUnit.{u + 1})))) β†’ (a : Function.Fiber ⇑f) β†’ Y.obj (Opposite.op (CompHausLike.LocallyConstant.fiber f a))
Finsupp.optionElim
Mathlib.Data.Finsupp.Option
{Ξ± : Type u_1} β†’ {M : Type u_2} β†’ [inst : Zero M] β†’ M β†’ (Ξ± β†’β‚€ M) β†’ Option Ξ± β†’β‚€ M
Lean.Meta.Grind.Order.modify'
Lean.Meta.Tactic.Grind.Order.Types
(Lean.Meta.Grind.Order.State β†’ Lean.Meta.Grind.Order.State) β†’ Lean.Meta.Grind.GoalM Unit
_private.Lean.Compiler.IR.SimpCase.0.Lean.IR.maxOccs.match_1
Lean.Compiler.IR.SimpCase
(motive : MProd β„• Lean.IR.Alt β†’ Sort u_1) β†’ (r : MProd β„• Lean.IR.Alt) β†’ ((max : β„•) β†’ (maxAlt : Lean.IR.Alt) β†’ motive ⟨max, maxAlt⟩) β†’ motive r
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkAndThenSeq._sunfold
Lean.Meta.Tactic.Grind.Split
List (Lean.TSyntax `grind) β†’ Lean.CoreM (Lean.TSyntax `grind)
Lean.Level.imax.injEq
Lean.Level
βˆ€ (a a_1 a_2 a_3 : Lean.Level), (a.imax a_1 = a_2.imax a_3) = (a = a_2 ∧ a_1 = a_3)
FreeAddMonoid.lift_restrict
Mathlib.Algebra.FreeMonoid.Basic
βˆ€ {Ξ± : Type u_1} {M : Type u_4} [inst : AddMonoid M] (f : FreeAddMonoid Ξ± β†’+ M), FreeAddMonoid.lift (⇑f ∘ FreeAddMonoid.of) = f
Nat.map_add_toList_ric
Init.Data.Range.Polymorphic.NatLemmas
βˆ€ {n k : β„•}, List.map (fun x => x + k) (*...=n).toList = (k...=n + k).toList
CoxeterMatrix.E₆._proof_2
Mathlib.GroupTheory.Coxeter.Matrix
βˆ€ (i : Fin 6), !![1, 2, 3, 2, 2, 2; 2, 1, 2, 3, 2, 2; 3, 2, 1, 3, 2, 2; 2, 3, 3, 1, 3, 2; 2, 2, 2, 3, 1, 3; 2, 2, 2, 2, 3, 1] i i = 1
_private.Mathlib.Order.CompleteLattice.Basic.0.iInf_eq_bot._simp_1_1
Mathlib.Order.CompleteLattice.Basic
βˆ€ {Ξ± : Type u_1} {ΞΉ : Sort u_4} [inst : InfSet Ξ±] {f : ΞΉ β†’ Ξ±}, iInf f = sInf (Set.range f)
MeasureTheory.measurable_cylinderEvents_iff
Mathlib.MeasureTheory.Constructions.Cylinders
βˆ€ {Ξ± : Type u_1} {ΞΉ : Type u_2} {X : ΞΉ β†’ Type u_3} {mΞ± : MeasurableSpace Ξ±} [m : (i : ΞΉ) β†’ MeasurableSpace (X i)] {Ξ” : Set ΞΉ} {g : Ξ± β†’ (i : ΞΉ) β†’ X i}, Measurable g ↔ βˆ€ ⦃i : ι⦄, i ∈ Ξ” β†’ Measurable fun a => g a i
Quiver.Path.getElem_vertices_zero._proof_1
Mathlib.Combinatorics.Quiver.Path.Vertices
βˆ€ {V : Type u_1} [inst : Quiver V] {a b : V} (p : Quiver.Path a b), 0 < p.vertices.length
HomologicalComplex.natIsoSc'_inv_app_Ο„β‚‚
Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
βˆ€ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {ΞΉ : Type u_2} (c : ComplexShape ΞΉ) (i j k : ΞΉ) (hi : c.prev j = i) (hk : c.next j = k) (X : HomologicalComplex C c), ((HomologicalComplex.natIsoSc' C c i j k hi hk).inv.app X).Ο„β‚‚ = CategoryTheory.CategoryStruct.id (X.X j)
isStarProjection_iff_eq_starProjection_range
Mathlib.Analysis.InnerProductSpace.Adjoint
βˆ€ {π•œ : Type u_1} {E : Type u_2} [inst : RCLike π•œ] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π•œ E] [inst_3 : CompleteSpace E] {p : E β†’L[π•œ] E}, IsStarProjection p ↔ βˆƒ (x : (LinearMap.range p).HasOrthogonalProjection), p = (LinearMap.range p).starProjection
ContinuousLinearMap.IsPositive.isSelfAdjoint
Mathlib.Analysis.InnerProductSpace.Positive
βˆ€ {π•œ : Type u_1} {E : Type u_2} [inst : RCLike π•œ] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π•œ E] [inst_3 : CompleteSpace E] {T : E β†’L[π•œ] E}, T.IsPositive β†’ IsSelfAdjoint T
_private.Mathlib.LinearAlgebra.Dual.Defs.0.LinearMap.range_dualMap_dual_eq_span_singleton.match_1_3
Mathlib.LinearAlgebra.Dual.Defs
βˆ€ {R : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R M₁] (f m : Module.Dual R M₁) (motive : (βˆƒ a, a β€’ f = m) β†’ Prop) (x : βˆƒ a, a β€’ f = m), (βˆ€ (r : R) (hr : r β€’ f = m), motive β‹―) β†’ motive x
Ordinal.uniqueIioOne._proof_1
Mathlib.SetTheory.Ordinal.Basic
βˆ€ (a : ↑(Set.Iio 1)), a = ⟨0, β‹―βŸ©
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Adjunction_Basic___unexpand_CategoryTheory_Bicategory_Adjunction_1
Mathlib.CategoryTheory.Bicategory.Adjunction.Basic
Lean.PrettyPrinter.Unexpander
Equiv.permCongrHom_symm
Mathlib.Algebra.Group.End
βˆ€ {Ξ± : Type u_4} {Ξ² : Type u_5} (e : Ξ± ≃ Ξ²), e.permCongrHom.symm = e.symm.permCongrHom
ZMod.prime_ne_zero
Mathlib.Data.ZMod.ValMinAbs
βˆ€ (p q : β„•) [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)], p β‰  q β†’ ↑q β‰  0
CategoryTheory.ComposableArrows.Mk₁.obj
Mathlib.CategoryTheory.ComposableArrows.Basic
{C : Type u_1} β†’ C β†’ C β†’ Fin 2 β†’ C
String.Slice.splitInclusive
Init.Data.String.Slice
{ρ : Type} β†’ {Οƒ : String.Slice β†’ Type} β†’ (s : String.Slice) β†’ (pat : ρ) β†’ [inst : String.Slice.Pattern.ToForwardSearcher pat Οƒ] β†’ Std.Iter String.Slice
IsPredArchimedean.findAtom
Mathlib.Order.SuccPred.Tree
{Ξ± : Type u_1} β†’ [inst : PartialOrder Ξ±] β†’ [inst_1 : PredOrder Ξ±] β†’ [IsPredArchimedean Ξ±] β†’ [OrderBot Ξ±] β†’ [DecidableEq Ξ±] β†’ Ξ± β†’ Ξ±
Polynomial.leadingCoeffHom
Mathlib.Algebra.Polynomial.Degree.Operations
{R : Type u} β†’ [inst : Semiring R] β†’ [NoZeroDivisors R] β†’ Polynomial R β†’* R
WittVector.equiv._proof_1
Mathlib.RingTheory.WittVector.Compare
βˆ€ (p : β„•) [hp : Fact (Nat.Prime p)] (x y : WittVector p (ZMod p)), (WittVector.toPadicInt p) (x * y) = (WittVector.toPadicInt p) x * (WittVector.toPadicInt p) y
list_sum_pow_char
Mathlib.Algebra.CharP.Lemmas
βˆ€ {R : Type u_3} [inst : CommSemiring R] (p : β„•) [ExpChar R p] (l : List R), l.sum ^ p = (List.map (fun x => x ^ p) l).sum
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_obj_g
Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence
βˆ€ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J] [inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)), ((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C).obj F).g = F.whiskerLeft CategoryTheory.ShortComplex.Ο€β‚‚Toπ₃
SSet.horn₃₂.desc._proof_1
Mathlib.AlgebraicTopology.SimplicialSet.HornColimits
(SSet.horn 3 2).MulticoequalizerDiagram (fun j => SSet.stdSimplex.face {↑j}ᢜ) fun j k => SSet.stdSimplex.face {↑j, ↑k}ᢜ
Submodule.annihilator_mono
Mathlib.RingTheory.Ideal.Maps
βˆ€ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N P : Submodule R M}, N ≀ P β†’ P.annihilator ≀ N.annihilator
instDecidableEqProd._proof_2
Init.Core
βˆ€ {Ξ± : Type u_2} {Ξ² : Type u_1} (a : Ξ±) (b : Ξ²) (a' : Ξ±) (b' : Ξ²), Β¬b = b' β†’ (a, b) = (a', b') β†’ False
Std.ExtDTreeMap.maxKeyD_insertIfNew
Std.Data.ExtDTreeMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.ExtDTreeMap Ξ± Ξ² cmp} [inst : Std.TransCmp cmp] {k : Ξ±} {v : Ξ² k} {fallback : Ξ±}, (t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k'
NormedAddGroupHom.Equalizer.lift.congr_simp
Mathlib.Analysis.Normed.Group.Hom
βˆ€ {V : Type u_1} {W : Type u_2} {V₁ : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W] [inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W} (Ο† Ο†_1 : NormedAddGroupHom V₁ V) (e_Ο† : Ο† = Ο†_1) (h : f.comp Ο† = g.comp Ο†), NormedAddGroupHom.Equalizer.lift Ο† h = NormedAddGroupHom.Equalizer.lift Ο†_1 β‹―
_private.Mathlib.RingTheory.IntegralClosure.Algebra.Ideal.0.Polynomial.exists_monic_aeval_eq_zero_forall_mem_of_mem_map._proof_1_2
Mathlib.RingTheory.IntegralClosure.Algebra.Ideal
βˆ€ {R : Type u_1} [inst : CommRing R] (p : Polynomial R), βˆ€ i < p.natDegree, p.natDegree - i β‰  0
Lean.Meta.Grind.AttrKind.cases.sizeOf_spec
Lean.Meta.Tactic.Grind.Attr
βˆ€ (eager : Bool), sizeOf (Lean.Meta.Grind.AttrKind.cases eager) = 1 + sizeOf eager
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift.0.Std.Iterators.IterM.DefaultConsumers.toArrayMapped_eq_match_step.match_1.eq_3
Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift
βˆ€ {Ξ± Ξ² : Type u_1} {m : Type u_1 β†’ Type u_2} (motive : Std.Iterators.IterStep (Std.IterM m Ξ²) Ξ² β†’ Sort u_3) (h_1 : (it' : Std.IterM m Ξ²) β†’ (out : Ξ²) β†’ motive (Std.Iterators.IterStep.yield it' out)) (h_2 : (it' : Std.IterM m Ξ²) β†’ motive (Std.Iterators.IterStep.skip it')) (h_3 : Unit β†’ motive Std.Iterators.IterStep.done), (match Std.Iterators.IterStep.done with | Std.Iterators.IterStep.yield it' out => h_1 it' out | Std.Iterators.IterStep.skip it' => h_2 it' | Std.Iterators.IterStep.done => h_3 ()) = h_3 ()
Convex.uniformContinuous_gauge
Mathlib.Analysis.Convex.Gauge
βˆ€ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E}, Convex ℝ s β†’ s ∈ nhds 0 β†’ UniformContinuous (gauge s)
DFinsupp.subset_support_tsub
Mathlib.Data.DFinsupp.Order
βˆ€ {ΞΉ : Type u_1} {Ξ± : ΞΉ β†’ Type u_2} [inst : (i : ΞΉ) β†’ AddCommMonoid (Ξ± i)] [inst_1 : (i : ΞΉ) β†’ PartialOrder (Ξ± i)] [inst_2 : βˆ€ (i : ΞΉ), CanonicallyOrderedAdd (Ξ± i)] [inst_3 : (i : ΞΉ) β†’ Sub (Ξ± i)] [inst_4 : βˆ€ (i : ΞΉ), OrderedSub (Ξ± i)] {f g : Ξ β‚€ (i : ΞΉ), Ξ± i} [inst_5 : DecidableEq ΞΉ] [inst_6 : (i : ΞΉ) β†’ (x : Ξ± i) β†’ Decidable (x β‰  0)], f.support \ g.support βŠ† (f - g).support
IsLocallyConstant.iff_is_const
Mathlib.Topology.LocallyConstant.Basic
βˆ€ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [PreconnectedSpace X] {f : X β†’ Y}, IsLocallyConstant f ↔ βˆ€ (x y : X), f x = f y
_private.Mathlib.Data.List.Basic.0.List.foldr_ext._simp_1_4
Mathlib.Data.List.Basic
βˆ€ {Ξ± : Sort u_1} {p : Ξ± β†’ Prop} {a' : Ξ±}, (βˆ€ (a : Ξ±), a = a' β†’ p a) = p a'
Lean.Lsp.FileChangeType.ctorIdx
Lean.Data.Lsp.Workspace
Lean.Lsp.FileChangeType β†’ β„•