name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Lean.Level.collectMVars
|
Lean.Level
|
Lean.Level β optParam Lean.LMVarIdSet β
β Lean.LMVarIdSet
|
NormedAddTorsor
|
Mathlib.Analysis.Normed.Group.AddTorsor
|
(V : outParam (Type u_1)) β (P : Type u_2) β [SeminormedAddCommGroup V] β [PseudoMetricSpace P] β Type (max u_1 u_2)
|
SubMulAction.instSMulSubtypeMem._proof_1
|
Mathlib.GroupTheory.GroupAction.SubMulAction
|
β {R : Type u_2} {M : Type u_1} [inst : SMul R M] (p : SubMulAction R M) (c : R) (x : β₯p), c β’ βx β p
|
ΟCPO._sizeOf_1
|
Mathlib.Order.Category.OmegaCompletePartialOrder
|
ΟCPO β β
|
IsAlgebraic.smul
|
Mathlib.RingTheory.Algebraic.Integral
|
β {R : Type u_1} {A : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a β β (r : R), IsAlgebraic R (r β’ a)
|
Quiver.Path.nil
|
Mathlib.Combinatorics.Quiver.Path
|
{V : Type u} β [inst : Quiver V] β {a : V} β Quiver.Path a a
|
_private.Init.Data.List.Impl.0.List.zipWith_eq_zipWithTR.go
|
Init.Data.List.Impl
|
β (Ξ± : Type u_3) (Ξ² : Type u_2) (Ξ³ : Type u_1) (f : Ξ± β Ξ² β Ξ³) (as : List Ξ±) (bs : List Ξ²) (acc : Array Ξ³),
List.zipWithTR.goβ f as bs acc = acc.toList ++ List.zipWith f as bs
|
WeierstrassCurve.Projective.Point.mk.inj
|
Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point
|
β {R : Type r} {inst : CommRing R} {W' : WeierstrassCurve.Projective R}
{point : WeierstrassCurve.Projective.PointClass R} {nonsingular : W'.NonsingularLift point}
{point_1 : WeierstrassCurve.Projective.PointClass R} {nonsingular_1 : W'.NonsingularLift point_1},
{ point := point, nonsingular := nonsingular } = { point := point_1, nonsingular := nonsingular_1 } β point = point_1
|
LinearMap.IsIdempotentElem.isSymmetric_iff_isOrtho_range_ker
|
Mathlib.Analysis.InnerProductSpace.Symmetric
|
β {π : Type u_1} {E : Type u_2} [inst : RCLike π] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
{T : E ββ[π] E}, IsIdempotentElem T β (T.IsSymmetric β LinearMap.range T β LinearMap.ker T)
|
dist_le_range_sum_dist
|
Mathlib.Topology.MetricSpace.Pseudo.Basic
|
β {Ξ± : Type u} [inst : PseudoMetricSpace Ξ±] (f : β β Ξ±) (n : β),
dist (f 0) (f n) β€ β i β Finset.range n, dist (f i) (f (i + 1))
|
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_inst
|
Mathlib.Tactic.FunProp.Theorems
|
SizeOf Mathlib.Meta.FunProp.LambdaTheorems
|
CStarMatrix.ofMatrixRingEquiv._proof_2
|
Mathlib.Analysis.CStarAlgebra.CStarMatrix
|
β {n : Type u_1} {A : Type u_2} [inst : Semiring A] (x x_1 : Matrix n n A),
CStarMatrix.ofMatrix.toFun (x + x_1) = CStarMatrix.ofMatrix.toFun (x + x_1)
|
PiTensorProduct.mapMultilinear_apply
|
Mathlib.LinearAlgebra.PiTensorProduct
|
β {ΞΉ : Type u_1} (R : Type u_4) [inst : CommSemiring R] (s : ΞΉ β Type u_7) [inst_1 : (i : ΞΉ) β AddCommMonoid (s i)]
[inst_2 : (i : ΞΉ) β Module R (s i)] (t : ΞΉ β Type u_11) [inst_3 : (i : ΞΉ) β AddCommMonoid (t i)]
[inst_4 : (i : ΞΉ) β Module R (t i)] (f : (i : ΞΉ) β s i ββ[R] t i),
(PiTensorProduct.mapMultilinear R s t) f = PiTensorProduct.map f
|
Β«term_=_Β»
|
Init.Notation
|
Lean.TrailingParserDescr
|
CategoryTheory.Over.prodLeftIsoPullback_hom_fst_assoc
|
Mathlib.CategoryTheory.Limits.Constructions.Over.Products
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.Limits.HasPullback Y.hom Z.hom] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
{Z_1 : C} (h : Y.left βΆ Z_1),
CategoryTheory.CategoryStruct.comp (Y.prodLeftIsoPullback Z).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst Y.hom Z.hom) h) =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst.left h
|
CategoryTheory.StructuredArrow.post._proof_5
|
Mathlib.CategoryTheory.Comma.StructuredArrow.Basic
|
β {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {B : Type u_3} [inst_2 : CategoryTheory.Category.{u_1, u_3} B] (S : C)
(F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) {X Y Z : CategoryTheory.StructuredArrow S F}
(f : X βΆ Y) (g : Y βΆ Z),
CategoryTheory.StructuredArrow.homMk (CategoryTheory.CategoryStruct.comp f g).right β― =
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.homMk f.right β―)
(CategoryTheory.StructuredArrow.homMk g.right β―)
|
_private.Init.Data.List.Perm.0.List.reverse_perm.match_1_1
|
Init.Data.List.Perm
|
β {Ξ± : Type u_1} (motive : List Ξ± β Prop) (x : List Ξ±),
(β (a : Unit), motive []) β (β (a : Ξ±) (l : List Ξ±), motive (a :: l)) β motive x
|
Matrix.det_of_mem_unitary
|
Mathlib.LinearAlgebra.UnitaryGroup
|
β {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {Ξ± : Type v} [inst_2 : CommRing Ξ±] [inst_3 : StarRing Ξ±]
{A : Matrix n n Ξ±}, A β Matrix.unitaryGroup n Ξ± β A.det β unitary Ξ±
|
instAB4AddCommGrpCat
|
Mathlib.Algebra.Category.Grp.AB
|
CategoryTheory.AB4 AddCommGrpCat
|
ContinuousAt.lineMap
|
Mathlib.Topology.Algebra.Affine
|
β {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : AddCommGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : Ring R]
[inst_6 : Module R V] [inst_7 : TopologicalSpace R] [ContinuousSMul R V] {X : Type u_6} [inst_9 : TopologicalSpace X]
{fβ fβ : X β P} {g : X β R} {x : X},
ContinuousAt fβ x β
ContinuousAt fβ x β ContinuousAt g x β ContinuousAt (fun x => (AffineMap.lineMap (fβ x) (fβ x)) (g x)) x
|
AddMonoidAlgebra.le_infDegree_mul
|
Mathlib.Algebra.MonoidAlgebra.Degree
|
β {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
[inst_3 : AddZeroClass A] [inst_4 : Add T] [AddLeftMono T] [AddRightMono T] (D : A ββ+ T)
(f g : AddMonoidAlgebra R A),
AddMonoidAlgebra.infDegree (βD) f + AddMonoidAlgebra.infDegree (βD) g β€ AddMonoidAlgebra.infDegree (βD) (f * g)
|
Lean.Elab.Term.Quotation.elabQuot._@.Lean.Elab.Quotation.1964439861._hygCtx._hyg.3
|
Lean.Elab.Quotation
|
Lean.Elab.Term.TermElab
|
Std.Iterators.IterM.inductSteps._unsafe_rec
|
Init.Data.Iterators.Lemmas.Monadic.Basic
|
{Ξ± : Type u_1} β
{m : Type u_1 β Type u_2} β
{Ξ² : Type u_1} β
[inst : Std.Iterators.Iterator Ξ± m Ξ²] β
[Std.Iterators.Finite Ξ± m] β
(motive : Std.IterM m Ξ² β Sort x) β
((it : Std.IterM m Ξ²) β
({it' : Std.IterM m Ξ²} β
{out : Ξ²} β it.IsPlausibleStep (Std.Iterators.IterStep.yield it' out) β motive it') β
({it' : Std.IterM m Ξ²} β it.IsPlausibleStep (Std.Iterators.IterStep.skip it') β motive it') β
motive it) β
(it : Std.IterM m Ξ²) β motive it
|
instCompleteLatticeStructureGroupoid._proof_7
|
Mathlib.Geometry.Manifold.ChartedSpace
|
β {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), b β€ SemilatticeSup.sup a b
|
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_3
|
Mathlib.RingTheory.Nilpotent.Exp
|
β (nβ nβ : β), max nβ nβ + 1 + (max nβ nβ + 1) β€ 2 * max nβ nβ + 1 + 1
|
_auto._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.3967049005._hygCtx._hyg.82
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital
|
Lean.Syntax
|
_private.Lean.Meta.Tactic.ExposeNames.0.Lean.Meta.getLCtxWithExposedNames
|
Lean.Meta.Tactic.ExposeNames
|
Lean.MetaM Lean.LocalContext
|
List.cons.inj
|
Init.Core
|
β {Ξ± : Type u} {head : Ξ±} {tail : List Ξ±} {head_1 : Ξ±} {tail_1 : List Ξ±},
head :: tail = head_1 :: tail_1 β head = head_1 β§ tail = tail_1
|
Empty.borelSpace
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
|
BorelSpace Empty
|
QuaternionAlgebra.Basis.k_compHom
|
Mathlib.Algebra.QuaternionBasis
|
β {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {cβ cβ cβ : R} (q : QuaternionAlgebra.Basis A cβ cβ cβ) (F : A ββ[R] B),
(q.compHom F).k = F q.k
|
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_53
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr
|
β (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w w_1 n : β) (h : w = w_1 * n)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (expr : aig_1.RefVec w_1)
(haig : aig.decls.size β€ { aig := aig_1, vec := expr }.aig.decls.size),
(ββ¨{ aig := aig_1, vec := expr }, haigβ©).aig.decls.size β€
(Std.Tactic.BVDecide.BVExpr.bitblast.blastReplicate (ββ¨{ aig := aig_1, vec := expr }, haigβ©).aig
{ w := w_1, n := n, inner := expr, h := h }).aig.decls.size
|
Std.Time.Month.Ordinal.january
|
Std.Time.Date.Unit.Month
|
Std.Time.Month.Ordinal
|
Aesop.RuleResult.ctorIdx
|
Aesop.Search.Expansion
|
Aesop.RuleResult β β
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd._proof_4
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add
|
β {w : β}, β curr < w, curr + 1 β€ w
|
CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono'._proof_4
|
Mathlib.Algebra.Homology.ShortComplex.LeftHomology
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{Sβ Sβ : CategoryTheory.ShortComplex C} (Ο : Sβ βΆ Sβ) (h : Sβ.LeftHomologyData) [inst_2 : CategoryTheory.IsIso Ο.Οβ]
{W' : C} (x : W' βΆ Sβ.Xβ) (hx : CategoryTheory.CategoryStruct.comp x Sβ.g = 0) (b : W' βΆ h.K),
CategoryTheory.CategoryStruct.comp b (CategoryTheory.CategoryStruct.comp h.i (CategoryTheory.inv Ο.Οβ)) = x β
b = h.liftK (CategoryTheory.CategoryStruct.comp x Ο.Οβ) β―
|
Subsemiring.instTop._proof_2
|
Mathlib.Algebra.Ring.Subsemiring.Defs
|
β {R : Type u_1} [inst : NonAssocSemiring R], 0 β β€.carrier
|
_private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.mem_finsetInf._simp_1_2
|
Mathlib.Algebra.Module.Submodule.Lattice
|
β {Ξ± : Type u} {ΞΉ : Sort v} {x : Ξ±} {s : ΞΉ β Set Ξ±}, (x β β i, s i) = β (i : ΞΉ), x β s i
|
RootPairing.Hom.comp._proof_3
|
Mathlib.LinearAlgebra.RootSystem.Hom
|
β {ΞΉ : Type u_1} {R : Type u_4} {M : Type u_3} {N : Type u_10} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ΞΉβ : Type u_6} {Mβ : Type u_5} {Nβ : Type u_7}
{ΞΉβ : Type u_8} {Mβ : Type u_2} {Nβ : Type u_9} [inst_5 : AddCommGroup Mβ] [inst_6 : Module R Mβ]
[inst_7 : AddCommGroup Nβ] [inst_8 : Module R Nβ] [inst_9 : AddCommGroup Mβ] [inst_10 : Module R Mβ]
[inst_11 : AddCommGroup Nβ] [inst_12 : Module R Nβ] {P : RootPairing ΞΉ R M N} {Pβ : RootPairing ΞΉβ R Mβ Nβ}
{Pβ : RootPairing ΞΉβ R Mβ Nβ} (g : Pβ.Hom Pβ) (f : P.Hom Pβ),
β(g.weightMap ββ f.weightMap) β βP.root = βPβ.root β β(f.indexEquiv.trans g.indexEquiv)
|
SchwartzMap.compCLM._proof_3
|
Mathlib.Analysis.Distribution.SchwartzSpace
|
β (π : Type u_4) {D : Type u_3} {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace β F] [inst_4 : RCLike π] [inst_5 : NormedSpace π F]
[inst_6 : SMulCommClass β π F] {g : D β E} (x : π) (x_1 : SchwartzMap E F) (x_2 : D),
(β(x β’ x_1) β g) x_2 = (β(x β’ x_1) β g) x_2
|
CategoryTheory.MorphismProperty.precoverage_monotone
|
Mathlib.CategoryTheory.Sites.MorphismProperty
|
β {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {P Q : CategoryTheory.MorphismProperty C},
P β€ Q β P.precoverage β€ Q.precoverage
|
RingHom.formallyEtale_algebraMap
|
Mathlib.RingTheory.Etale.Basic
|
β {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(algebraMap R S).FormallyEtale β Algebra.FormallyEtale R S
|
Order.Ideal.coe_sup_eq
|
Mathlib.Order.Ideal
|
β {P : Type u_1} [inst : DistribLattice P] {I J : Order.Ideal P}, β(I β J) = {x | β i β I, β j β J, x = i β j}
|
ContinuousMultilinearMap.smulRight_apply
|
Mathlib.Topology.Algebra.Module.Multilinear.Basic
|
β {R : Type u} {ΞΉ : Type v} {Mβ : ΞΉ β Type wβ} {Mβ : Type wβ} [inst : CommSemiring R]
[inst_1 : (i : ΞΉ) β AddCommMonoid (Mβ i)] [inst_2 : AddCommMonoid Mβ] [inst_3 : (i : ΞΉ) β Module R (Mβ i)]
[inst_4 : Module R Mβ] [inst_5 : TopologicalSpace R] [inst_6 : (i : ΞΉ) β TopologicalSpace (Mβ i)]
[inst_7 : TopologicalSpace Mβ] [inst_8 : ContinuousSMul R Mβ] (f : ContinuousMultilinearMap R Mβ R) (z : Mβ)
(a : (i : ΞΉ) β Mβ i), (f.smulRight z) a = f a β’ z
|
Int.negOnePow_two_mul_add_one
|
Mathlib.Algebra.Ring.NegOnePow
|
β (n : β€), (2 * n + 1).negOnePow = -1
|
Lean.Server.Watchdog.CallHierarchyItemData
|
Lean.Server.Watchdog
|
Type
|
Std.Time.FormatPart.noConfusionType
|
Std.Time.Format.Basic
|
Sort u β Std.Time.FormatPart β Std.Time.FormatPart β Sort u
|
Nat.testBit_ofBits_lt
|
Batteries.Data.Nat.Lemmas
|
β {n : β} (f : Fin n β Bool) (i : β) (h : i < n), (Nat.ofBits f).testBit i = f β¨i, hβ©
|
HahnSeries.leadingCoeff_abs
|
Mathlib.RingTheory.HahnSeries.Lex
|
β {Ξ : Type u_1} {R : Type u_2} [inst : LinearOrder Ξ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[IsOrderedAddMonoid R] (x : Lex (HahnSeries Ξ R)), (ofLex |x|).leadingCoeff = |(ofLex x).leadingCoeff|
|
isOpenMap_sigmaMk
|
Mathlib.Topology.Constructions
|
β {ΞΉ : Type u_5} {Ο : ΞΉ β Type u_7} [inst : (i : ΞΉ) β TopologicalSpace (Ο i)] {i : ΞΉ}, IsOpenMap (Sigma.mk i)
|
SimpleGraph.TripartiteFromTriangles.NoAccidental.mk._flat_ctor
|
Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {t : Finset (Ξ± Γ Ξ² Γ Ξ³)},
(β β¦a a' : Ξ±β¦ β¦b b' : Ξ²β¦ β¦c c' : Ξ³β¦, (a', b, c) β t β (a, b', c) β t β (a, b, c') β t β a = a' β¨ b = b' β¨ c = c') β
SimpleGraph.TripartiteFromTriangles.NoAccidental t
|
Int64.right_eq_add
|
Init.Data.SInt.Lemmas
|
β {a b : Int64}, b = a + b β a = 0
|
Std.TreeMap.Raw.mem_union_of_left
|
Std.Data.TreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.TreeMap.Raw Ξ± Ξ² cmp} [Std.TransCmp cmp],
tβ.WF β tβ.WF β β {k : Ξ±}, k β tβ β k β tβ βͺ tβ
|
_private.Mathlib.Computability.TuringMachine.0.Turing.TM2.stepAux.match_1.splitter
|
Mathlib.Computability.TuringMachine
|
{K : Type u_1} β
{Ξ : K β Type u_2} β
{Ξ : Type u_3} β
{Ο : Type u_4} β
(motive : Turing.TM2.Stmt Ξ Ξ Ο β Ο β ((k : K) β List (Ξ k)) β Sort u_5) β
(x : Turing.TM2.Stmt Ξ Ξ Ο) β
(x_1 : Ο) β
(x_2 : (k : K) β List (Ξ k)) β
((k : K) β
(f : Ο β Ξ k) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.push k f q) v S) β
((k : K) β
(f : Ο β Option (Ξ k) β Ο) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.peek k f q) v S) β
((k : K) β
(f : Ο β Option (Ξ k) β Ο) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.pop k f q) v S) β
((a : Ο β Ο) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.load a q) v S) β
((f : Ο β Bool) β
(qβ qβ : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.branch f qβ qβ) v S) β
((f : Ο β Ξ) β (v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.goto f) v S) β
((v : Ο) β (S : (k : K) β List (Ξ k)) β motive Turing.TM2.Stmt.halt v S) β motive x x_1 x_2
|
CompletelyDistribLattice.top_sdiff
|
Mathlib.Order.CompleteBooleanAlgebra
|
β {Ξ± : Type u} [self : CompletelyDistribLattice Ξ±] (a : Ξ±), β€ \ a = οΏ’a
|
IsInvariantSubring.toMulSemiringAction._proof_1
|
Mathlib.Algebra.Ring.Action.Invariant
|
β (M : Type u_2) {R : Type u_1} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (S : Subring R)
[IsInvariantSubring M S] (m : M) (x : β₯S), m β’ βx β S
|
Lean.Widget.GetInteractiveDiagnosticsParams.mk.sizeOf_spec
|
Lean.Server.FileWorker.WidgetRequests
|
β (lineRange? : Option Lean.Lsp.LineRange), sizeOf { lineRange? := lineRange? } = 1 + sizeOf lineRange?
|
Std.Net.SocketAddress
|
Std.Net.Addr
|
Type
|
IsClosedMap.specializingMap
|
Mathlib.Topology.Inseparable
|
β {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X β Y},
IsClosedMap f β SpecializingMap f
|
CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc_comp_assoc
|
Mathlib.CategoryTheory.Abelian.Projective.Resolution
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
{P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex βΆ Q.complex)
(n : β) (g : P.complex.X n βΆ Q.complex.X (n + 1)) (g' : P.complex.X (n + 1) βΆ Q.complex.X (n + 2))
(w :
f.f (n + 1) =
CategoryTheory.CategoryStruct.comp (P.complex.d (n + 1) n) g +
CategoryTheory.CategoryStruct.comp g' (Q.complex.d (n + 2) (n + 1)))
{Z_1 : C} (h : Q.complex.X (n + 2) βΆ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc f n g g' w)
(CategoryTheory.CategoryStruct.comp (Q.complex.d (n + 3) (n + 2)) h) =
CategoryTheory.CategoryStruct.comp
(f.f (n + 2) - CategoryTheory.CategoryStruct.comp (P.complex.d (n + 2) (n + 1)) g') h
|
CategoryTheory.Functor.IsEventuallyConstantFrom.isIso_ΞΉ_of_isColimit'
|
Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant
|
β {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] {F : CategoryTheory.Functor J C} {iβ : J},
F.IsEventuallyConstantFrom iβ β
β [CategoryTheory.IsFiltered J] {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(j : J) (ΞΉ : iβ βΆ j), CategoryTheory.IsIso (c.ΞΉ.app j)
|
_private.Lean.Syntax.0.Lean.Syntax.findStack?.go.match_3
|
Lean.Syntax
|
(motive : Option (Option Lean.Syntax.Stack) β Sort u_1) β
(x : Option (Option Lean.Syntax.Stack)) β
(Unit β motive none) β ((a : Option Lean.Syntax.Stack) β motive (some a)) β motive x
|
[email protected]._hygCtx._hyg.7
|
Lean.Parser.Extension
|
Lean.Syntax
|
PUnit.inv_eq
|
Mathlib.Algebra.Group.PUnit
|
β (x : PUnit.{u_1 + 1}), xβ»ΒΉ = PUnit.unit
|
CategoryTheory.Functor.mapCoconeβ_pt
|
Mathlib.CategoryTheory.Limits.Preserves.Bifunctor
|
β {Jβ : Type u_1} {Jβ : Type u_2} [inst : CategoryTheory.Category.{u_6, u_1} Jβ]
[inst_1 : CategoryTheory.Category.{u_7, u_2} Jβ] {Cβ : Type u_3} {Cβ : Type u_4} {C : Type u_5}
[inst_2 : CategoryTheory.Category.{u_8, u_3} Cβ] [inst_3 : CategoryTheory.Category.{u_9, u_4} Cβ]
[inst_4 : CategoryTheory.Category.{u_10, u_5} C] (G : CategoryTheory.Functor Cβ (CategoryTheory.Functor Cβ C))
{Kβ : CategoryTheory.Functor Jβ Cβ} {Kβ : CategoryTheory.Functor Jβ Cβ} (cβ : CategoryTheory.Limits.Cocone Kβ)
(cβ : CategoryTheory.Limits.Cocone Kβ), (G.mapCoconeβ cβ cβ).pt = (G.obj cβ.pt).obj cβ.pt
|
CauSeq.equiv_lim
|
Mathlib.Algebra.Order.CauSeq.Completion
|
β {Ξ± : Type u_1} [inst : Field Ξ±] [inst_1 : LinearOrder Ξ±] [inst_2 : IsStrictOrderedRing Ξ±] {Ξ² : Type u_2}
[inst_3 : Ring Ξ²] {abv : Ξ² β Ξ±} [inst_4 : IsAbsoluteValue abv] [inst_5 : CauSeq.IsComplete Ξ² abv] (s : CauSeq Ξ² abv),
s β CauSeq.const abv s.lim
|
MontelSpace.rec
|
Mathlib.Analysis.LocallyConvex.Montel
|
{π : Type u_4} β
{E : Type u_5} β
[inst : SeminormedRing π] β
[inst_1 : Zero E] β
[inst_2 : SMul π E] β
[inst_3 : TopologicalSpace E] β
{motive : MontelSpace π E β Sort u} β
((heine_borel : β (s : Set E), IsClosed s β Bornology.IsVonNBounded π s β IsCompact s) β motive β―) β
(t : MontelSpace π E) β motive t
|
Subgroup.pi
|
Mathlib.Algebra.Group.Subgroup.Basic
|
{Ξ· : Type u_7} β
{f : Ξ· β Type u_8} β [inst : (i : Ξ·) β Group (f i)] β Set Ξ· β ((i : Ξ·) β Subgroup (f i)) β Subgroup ((i : Ξ·) β f i)
|
Set.zero_notMem_sub_iff
|
Mathlib.Algebra.Group.Pointwise.Set.Basic
|
β {Ξ± : Type u_2} [inst : AddGroup Ξ±] {s t : Set Ξ±}, 0 β s - t β Disjoint s t
|
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processImplicitArg
|
Lean.Elab.App
|
Lean.Name β Lean.Elab.Term.ElabAppArgs.M Lean.Expr
|
List.Subset.antisymm_of_sortedLT
|
Mathlib.Data.List.Sort
|
β {Ξ± : Type u_1} [inst : PartialOrder Ξ±] {lβ lβ : List Ξ±}, lβ β lβ β lβ β lβ β lβ.SortedLT β lβ.SortedLT β lβ = lβ
|
Aesop.GoalWithMVars.recOn
|
Aesop.Script.GoalWithMVars
|
{motive : Aesop.GoalWithMVars β Sort u} β
(t : Aesop.GoalWithMVars) β
((goal : Lean.MVarId) β (mvars : Std.HashSet Lean.MVarId) β motive { goal := goal, mvars := mvars }) β motive t
|
Std.ExtDTreeMap.getKey?_maxKey
|
Std.Data.ExtDTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.ExtDTreeMap Ξ± Ξ² cmp} [inst : Std.TransCmp cmp]
{he : t β β
}, t.getKey? (t.maxKey he) = some (t.maxKey he)
|
Concept.extent_sup
|
Mathlib.Order.Concept
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} {r : Ξ± β Ξ² β Prop} (c d : Concept Ξ± Ξ² r),
(c β d).extent = lowerPolar r (c.intent β© d.intent)
|
SimpleGraph.Subgraph._sizeOf_1
|
Mathlib.Combinatorics.SimpleGraph.Subgraph
|
{V : Type u} β {G : SimpleGraph V} β [SizeOf V] β G.Subgraph β β
|
Function.Surjective.addAction._proof_1
|
Mathlib.Algebra.Group.Action.Defs
|
β {M : Type u_2} {Ξ± : Type u_3} {Ξ² : Type u_1} [inst : AddMonoid M] [inst_1 : AddAction M Ξ±] [inst_2 : VAdd M Ξ²]
(f : Ξ± β Ξ²),
Function.Surjective f β
(β (c : M) (x : Ξ±), f (c +α΅₯ x) = c +α΅₯ f x) β β (a a_1 : M) (y : Ξ²), (a + a_1) +α΅₯ y = a +α΅₯ a_1 +α΅₯ y
|
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitDeclAux.match_1
|
Lean.Compiler.IR.EmitLLVM
|
(motive : Lean.IR.Decl β Sort u_1) β
(d : Lean.IR.Decl) β
((f : Lean.IR.FunId) β
(xs : Array Lean.IR.Param) β
(t : Lean.IR.IRType) β
(b : Lean.IR.FnBody) β (info : Lean.IR.DeclInfo) β motive (Lean.IR.Decl.fdecl f xs t b info)) β
((x : Lean.IR.Decl) β motive x) β motive d
|
Matrix.center_eq_range
|
Mathlib.Data.Matrix.Basis
|
β {n : Type u_3} (R : Type u_5) [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommSemiring R],
Set.center (Matrix n n R) = Set.range β(Matrix.scalar n)
|
AddMonoidHom.range_eq_top_of_surjective
|
Mathlib.Algebra.Group.Subgroup.Ker
|
β {G : Type u_1} [inst : AddGroup G] {N : Type u_7} [inst_1 : AddGroup N] (f : G β+ N),
Function.Surjective βf β f.range = β€
|
Real.convergent_zero
|
Mathlib.NumberTheory.DiophantineApproximation.Basic
|
β (ΞΎ : β), ΞΎ.convergent 0 = ββΞΎβ
|
CategoryTheory.Bicategory.conjugateIsoEquiv_apply_inv
|
Mathlib.CategoryTheory.Bicategory.Adjunction.Mate
|
β {B : Type u} [inst : CategoryTheory.Bicategory B] {c d : B} {lβ lβ : c βΆ d} {rβ rβ : d βΆ c}
(adjβ : CategoryTheory.Bicategory.Adjunction lβ rβ) (adjβ : CategoryTheory.Bicategory.Adjunction lβ rβ) (Ξ± : lβ β
lβ),
((CategoryTheory.Bicategory.conjugateIsoEquiv adjβ adjβ) Ξ±).inv =
(CategoryTheory.Bicategory.conjugateEquiv adjβ adjβ) Ξ±.inv
|
mapsTo_gaugeRescale_closure
|
Mathlib.Analysis.Convex.GaugeRescale
|
β {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module β E] [inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousSMul β E] {s t : Set E},
Convex β s β s β nhds 0 β Convex β t β 0 β t β Absorbent β t β Set.MapsTo (gaugeRescale s t) (closure s) (closure t)
|
Std.HashMap.mem_alter_of_beq
|
Std.Data.HashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.HashMap Ξ± Ξ²} [EquivBEq Ξ±] [LawfulHashable Ξ±]
{k k' : Ξ±} {f : Option Ξ² β Option Ξ²}, (k == k') = true β (k' β m.alter k f β (f m[k]?).isSome = true)
|
Monotone.forall
|
Mathlib.Order.BoundedOrder.Monotone
|
β {Ξ± : Type u} {Ξ² : Type v} [inst : Preorder Ξ±] {P : Ξ² β Ξ± β Prop},
(β (x : Ξ²), Monotone (P x)) β Monotone fun y => β (x : Ξ²), P x y
|
Std.Time.Duration.mk._flat_ctor
|
Std.Time.Duration
|
(second : Std.Time.Second.Offset) β
(nano : Std.Time.Nanosecond.Span) β second.val β₯ 0 β§ βnano β₯ 0 β¨ second.val β€ 0 β§ βnano β€ 0 β Std.Time.Duration
|
FBinopElab.instInhabitedSRec
|
Mathlib.Tactic.FBinop
|
Inhabited FBinopElab.SRec
|
CategoryTheory.Meq.congr_apply
|
Mathlib.CategoryTheory.Sites.ConcreteSheafification
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D] {FD : D β D β Type u_1} {CD : D β Type t}
[inst_2 : (X Y : D) β FunLike (FD X Y) (CD X) (CD Y)] [inst_3 : CategoryTheory.ConcreteCategory D FD] {X : C}
{P : CategoryTheory.Functor Cα΅α΅ D} {S : J.Cover X} (x : CategoryTheory.Meq P S) {Y : C} {f g : Y βΆ X} (h : f = g)
(hf : (βS).arrows f), βx { Y := Y, f := f, hf := hf } = βx { Y := Y, f := g, hf := β― }
|
Homotopy.equivSubZero._proof_7
|
Mathlib.Algebra.Homology.Homotopy
|
β {ΞΉ : Type u_1} {V : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ΞΉ} {C D : HomologicalComplex V c} {f g : C βΆ D} (x : Homotopy (f - g) 0) (x_1 x_2 : ΞΉ),
Β¬c.Rel x_2 x_1 β { hom := fun i j => x.hom i j, zero := β―, comm := β― }.hom x_1 x_2 = 0
|
Std.ExtDHashMap.get_union_of_not_mem_left
|
Std.Data.ExtDHashMap.Lemmas
|
β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {Ξ² : Ξ± β Type v} {mβ mβ : Std.ExtDHashMap Ξ± Ξ²} [inst : LawfulBEq Ξ±]
{k : Ξ±} (not_mem : k β mβ) {h' : k β mβ βͺ mβ}, (mβ βͺ mβ).get k h' = mβ.get k β―
|
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core
|
Lean.Meta.Tactic.Grind.Arith.Linear.Types
|
Lean.Expr β
Lean.Expr β
Lean.Meta.Grind.Arith.Linear.LinExpr β
Lean.Meta.Grind.Arith.Linear.LinExpr β Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof
|
CategoryTheory.Bicategory.Adjunction.mk.injEq
|
Mathlib.CategoryTheory.Bicategory.Adjunction.Basic
|
β {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a βΆ b} {g : b βΆ a}
(unit : CategoryTheory.CategoryStruct.id a βΆ CategoryTheory.CategoryStruct.comp f g)
(counit : CategoryTheory.CategoryStruct.comp g f βΆ CategoryTheory.CategoryStruct.id b)
(left_triangle :
autoParam
(CategoryTheory.Bicategory.leftZigzag unit counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor f).hom
(CategoryTheory.Bicategory.rightUnitor f).inv)
CategoryTheory.Bicategory.Adjunction.left_triangle._autoParam)
(right_triangle :
autoParam
(CategoryTheory.Bicategory.rightZigzag unit counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).hom
(CategoryTheory.Bicategory.leftUnitor g).inv)
CategoryTheory.Bicategory.Adjunction.right_triangle._autoParam)
(unit_1 : CategoryTheory.CategoryStruct.id a βΆ CategoryTheory.CategoryStruct.comp f g)
(counit_1 : CategoryTheory.CategoryStruct.comp g f βΆ CategoryTheory.CategoryStruct.id b)
(left_triangle_1 :
autoParam
(CategoryTheory.Bicategory.leftZigzag unit_1 counit_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor f).hom
(CategoryTheory.Bicategory.rightUnitor f).inv)
CategoryTheory.Bicategory.Adjunction.left_triangle._autoParam)
(right_triangle_1 :
autoParam
(CategoryTheory.Bicategory.rightZigzag unit_1 counit_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).hom
(CategoryTheory.Bicategory.leftUnitor g).inv)
CategoryTheory.Bicategory.Adjunction.right_triangle._autoParam),
({ unit := unit, counit := counit, left_triangle := left_triangle, right_triangle := right_triangle } =
{ unit := unit_1, counit := counit_1, left_triangle := left_triangle_1, right_triangle := right_triangle_1 }) =
(unit = unit_1 β§ counit = counit_1)
|
Mathlib.Tactic.ITauto.Proof.em
|
Mathlib.Tactic.ITauto
|
Bool β Lean.Name β Mathlib.Tactic.ITauto.Proof
|
Lean.IR.UnreachableBranches.instReprValue.repr
|
Lean.Compiler.IR.ElimDeadBranches
|
Lean.IR.UnreachableBranches.Value β β β Std.Format
|
Finset.isPWO_sup
|
Mathlib.Order.WellFoundedSet
|
β {ΞΉ : Type u_1} {Ξ± : Type u_2} [inst : Preorder Ξ±] (s : Finset ΞΉ) {f : ΞΉ β Set Ξ±},
(s.sup f).IsPWO β β i β s, (f i).IsPWO
|
Lean.NameMapExtension.find?
|
Batteries.Lean.NameMapAttribute
|
{Ξ± : Type} β Lean.NameMapExtension Ξ± β Lean.Environment β Lean.Name β Option Ξ±
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natAbs.sizeOf_spec
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr
|
sizeOf Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natAbsβ = 1
|
CategoryTheory.ComonObj.comul
|
Mathlib.CategoryTheory.Monoidal.Comon_
|
{C : Type uβ} β
{inst : CategoryTheory.Category.{vβ, uβ} C} β
{inst_1 : CategoryTheory.MonoidalCategory C} β
{X : C} β [self : CategoryTheory.ComonObj X] β X βΆ CategoryTheory.MonoidalCategoryStruct.tensorObj X X
|
PointedCone.mem_closure
|
Mathlib.Analysis.Convex.Cone.Closure
|
β {π : Type u_1} [inst : Semiring π] [inst_1 : PartialOrder π] [inst_2 : IsOrderedRing π] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module π E]
[inst_7 : ContinuousConstSMul π E] {K : PointedCone π E} {a : E}, a β K.closure β a β closure βK
|
Continuous.fourier_inversion
|
Mathlib.Analysis.Fourier.Inversion
|
β {V : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V]
[inst_2 : MeasurableSpace V] [inst_3 : BorelSpace V] [inst_4 : FiniteDimensional β V] [inst_5 : NormedAddCommGroup E]
[inst_6 : NormedSpace β E] {f : V β E} [CompleteSpace E],
Continuous f β
MeasureTheory.Integrable f MeasureTheory.volume β
MeasureTheory.Integrable (FourierTransform.fourier f) MeasureTheory.volume β
FourierTransformInv.fourierInv (FourierTransform.fourier f) = f
|
SeparationQuotient.instRing._proof_12
|
Mathlib.Topology.Algebra.SeparationQuotient.Basic
|
β {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R] (x : R),
SeparationQuotient.mk (-x) = -SeparationQuotient.mk x
|
Prod.instBornology._proof_1
|
Mathlib.Topology.Bornology.Constructions
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Bornology Ξ±] [inst_1 : Bornology Ξ²],
(Bornology.cobounded Ξ±).coprod (Bornology.cobounded Ξ²) β€ Filter.cofinite
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.