name
string | module
string | type
string |
|---|---|---|
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
|
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 Ξ±
|
[email protected]._hygCtx._hyg.45
|
Mathlib.Probability.Independence.Basic
|
Lean.Syntax
|
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_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat}
(Ξ± : F βΆ G) (X : CategoryTheory.Grothendieck F),
CategoryTheory.CategoryStruct.comp (Ξ±.app X.base) (G.map (CategoryTheory.CategoryStruct.id X).base) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.id X).base) (Ξ±.app X.base)
|
_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
|
{Ξ± : Type u_1} β {P : Sort u} β {x1 x2 : Dvd Ξ±} β x1 = x2 β Dvd.noConfusionType P x1 x2
|
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] (a : RatFunc K), a * 0 = 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
|
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
|
HomologicalComplex.natIsoSc'_inv_app_Οβ
|
Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
|
β (C : Type u_1) [inst : CategoryTheory.Category.{u_3, 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} β
[inst : String.Slice.Pattern.ToForwardSearcher Ο Ο] β (s : String.Slice) β Ο β Std.Iter String.Slice
|
IsPredArchimedean.findAtom
|
Mathlib.Order.SuccPred.Tree
|
{Ξ± : Type u_1} β
[inst : PartialOrder Ξ±] β [inst_1 : PredOrder Ξ±] β [IsPredArchimedean Ξ±] β [OrderBot Ξ±] β [DecidableEq Ξ±] β Ξ± β Ξ±
|
Lean.Meta.Match.InjectionAnyResult.ctorElim
|
Lean.Meta.Match.MatchEqs
|
{motive : Lean.Meta.Match.InjectionAnyResult β Sort u} β
(ctorIdx : β) β
(t : Lean.Meta.Match.InjectionAnyResult) β
ctorIdx = t.ctorIdx β Lean.Meta.Match.InjectionAnyResult.ctorElimType ctorIdx β motive t
|
_private.Init.PropLemmas.0.decidable_of_bool._proof_1
|
Init.PropLemmas
|
β {a : Prop}, (true = true β a) β a
|
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.{u_3, u_1} J]
[inst_1 : CategoryTheory.Category.{u_4, 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'
|
_auto._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.4133207676._hygCtx._hyg.51
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital
|
Lean.Syntax
|
Lean.Lsp.FileChangeType.ctorIdx
|
Lean.Data.Lsp.Workspace
|
Lean.Lsp.FileChangeType β β
|
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
|
AddCommGroup.divisibleByIntOfSMulTopEqTop._proof_5
|
Mathlib.GroupTheory.Divisible
|
β (A : Type u_1) [inst : AddCommGroup A] (H : β {n : β€}, n β 0 β n β’ β€ = β€) {n : β€} (a : A),
n β 0 β (n β’ if hn : n = 0 then 0 else Exists.choose β―) = a
|
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)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.