name
string | module
string | type
string |
|---|---|---|
IsAdicComplete.toIsPrecomplete
|
Mathlib.RingTheory.AdicCompletion.Basic
|
β {R : Type u_1} {inst : CommRing R} {I : Ideal R} {M : Type u_4} {inst_1 : AddCommGroup M} {inst_2 : Module R M}
[self : IsAdicComplete I M], IsPrecomplete I M
|
CategoryTheory.RegularMono._sizeOf_1
|
Mathlib.CategoryTheory.Limits.Shapes.RegularMono
|
{C : Type uβ} β
{inst : CategoryTheory.Category.{vβ, uβ} C} β {X Y : C} β {f : X βΆ Y} β [SizeOf C] β CategoryTheory.RegularMono f β β
|
FirstOrder.Language.PartialEquiv.mk.inj
|
Mathlib.ModelTheory.PartialEquiv
|
β {L : FirstOrder.Language} {M : Type w} {N : Type w'} {inst : L.Structure M} {inst_1 : L.Structure N}
{dom : L.Substructure M} {cod : L.Substructure N} {toEquiv : L.Equiv β₯dom β₯cod} {dom_1 : L.Substructure M}
{cod_1 : L.Substructure N} {toEquiv_1 : L.Equiv β₯dom_1 β₯cod_1},
{ dom := dom, cod := cod, toEquiv := toEquiv } = { dom := dom_1, cod := cod_1, toEquiv := toEquiv_1 } β
dom = dom_1 β§ cod = cod_1 β§ toEquiv β toEquiv_1
|
Condensed.locallyConstantIsoFinYoneda
|
Mathlib.Condensed.Discrete.Colimit
|
(F : CategoryTheory.Functor Profiniteα΅α΅ (Type (u + 1))) β
FintypeCat.toProfinite.op.comp
(Condensed.locallyConstantPresheaf
(F.obj (FintypeCat.toProfinite.op.obj (Opposite.op { carrier := PUnit.{u + 1}, str := PUnit.fintype })))) β
Condensed.finYoneda F
|
CategoryTheory.Limits.Concrete.initial_of_empty_of_reflects
|
Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C β C β Type u_1} {CC : C β Type w}
[inst_1 : (X Y : C) β FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Functor.empty C) (CategoryTheory.forget C)] (X : C),
IsEmpty (CategoryTheory.ToType X) β Nonempty (CategoryTheory.Limits.IsInitial X)
|
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.IsCycles.other_adj_of_adj._simp_1_1
|
Mathlib.Combinatorics.SimpleGraph.Matching
|
β {V : Type u} (G : SimpleGraph V) (v w : V), G.Adj v w = (w β G.neighborSet v)
|
AddCommGroup.toDistribLattice.eq_1
|
Mathlib.Algebra.Order.Group.Lattice
|
β (Ξ± : Type u_2) [inst : Lattice Ξ±] [inst_1 : AddCommGroup Ξ±] [inst_2 : AddLeftMono Ξ±],
AddCommGroup.toDistribLattice Ξ± = { toLattice := inst, le_sup_inf := β― }
|
Aesop.instInhabitedMVarClusterData.default
|
Aesop.Tree.Data
|
{a a_1 : Type} β Aesop.MVarClusterData a a_1
|
Lean.Elab.Term.SyntheticMVarKind.typeClass.inj
|
Lean.Elab.Term.TermElabM
|
β {extraErrorMsg? extraErrorMsg?_1 : Option Lean.MessageData},
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg? =
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg?_1 β
extraErrorMsg? = extraErrorMsg?_1
|
Lean.PrefixTreeNode.below_2
|
Lean.Data.PrefixTree
|
{Ξ± : Type u} β
{Ξ² : Type v} β
{cmp : Ξ± β Ξ± β Ordering} β
{motive_1 : Lean.PrefixTreeNode Ξ± Ξ² cmp β Sort u_1} β
{motive_2 : Std.TreeMap.Raw Ξ± (Lean.PrefixTreeNode Ξ± Ξ² cmp) cmp β Sort u_1} β
{motive_3 : Std.DTreeMap.Raw Ξ± (fun x => Lean.PrefixTreeNode Ξ± Ξ² cmp) cmp β Sort u_1} β
{motive_4 : (Std.DTreeMap.Internal.Impl Ξ± fun x => Lean.PrefixTreeNode Ξ± Ξ² cmp) β Sort u_1} β
Std.DTreeMap.Raw Ξ± (fun x => Lean.PrefixTreeNode Ξ± Ξ² cmp) cmp β
Sort (max (max (u + 1) ((max u v) + 1)) u_1)
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._simp_1_2
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {instOrd : Ord Ξ±} {a b : Ξ±}, (compare a b β Ordering.eq) = ((a == b) = false)
|
Mathlib.Notation3.MatchState.noConfusion
|
Mathlib.Util.Notation3
|
{P : Sort u} β {x1 x2 : Mathlib.Notation3.MatchState} β x1 = x2 β Mathlib.Notation3.MatchState.noConfusionType P x1 x2
|
_private.Mathlib.Algebra.Polynomial.Degree.Units.0.Polynomial.isUnit_iff.match_1_1
|
Mathlib.Algebra.Polynomial.Degree.Units
|
β {R : Type u_1} [inst : Semiring R] {p : Polynomial R} (motive : (β r, IsUnit r β§ Polynomial.C r = p) β Prop)
(x : β r, IsUnit r β§ Polynomial.C r = p), (β (w : R) (hr : IsUnit w) (hrp : Polynomial.C w = p), motive β―) β motive x
|
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.DeprecationInfo.mk.noConfusion
|
Mathlib.Tactic.Linter.FindDeprecations
|
(P : Sort u) β
(module decl : Lean.Name) β
(rgStart rgStop : Lean.Position) β
(since : String) β
(module' decl' : Lean.Name) β
(rgStart' rgStop' : Lean.Position) β
(since' : String) β
{ module := module, decl := decl, rgStart := rgStart, rgStop := rgStop, since := since } =
{ module := module', decl := decl', rgStart := rgStart', rgStop := rgStop', since := since' } β
(module = module' β decl = decl' β rgStart = rgStart' β rgStop = rgStop' β since = since' β P) β P
|
CategoryTheory.Functor.IsRepresentedBy.representableBy
|
Mathlib.CategoryTheory.RepresentedBy
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{F : CategoryTheory.Functor Cα΅α΅ (Type w)} β
{X : C} β {x : F.obj (Opposite.op X)} β F.IsRepresentedBy x β F.RepresentableBy X
|
integrable_cexp_quadratic'
|
Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform
|
β {b : β},
b.re < 0 β β (c d : β), MeasureTheory.Integrable (fun x => Complex.exp (b * βx ^ 2 + c * βx + d)) MeasureTheory.volume
|
Lean.Doc.Inline.emph.injEq
|
Lean.DocString.Types
|
β {i : Type u} (content content_1 : Array (Lean.Doc.Inline i)),
(Lean.Doc.Inline.emph content = Lean.Doc.Inline.emph content_1) = (content = content_1)
|
CategoryTheory.Functor.toPrefunctor
|
Mathlib.CategoryTheory.Functor.Basic
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
{D : Type uβ} β [inst_1 : CategoryTheory.Category.{vβ, uβ} D] β CategoryTheory.Functor C D β C β₯€q D
|
Lean.Meta.saveState
|
Lean.Meta.Basic
|
Lean.MetaM Lean.Meta.SavedState
|
AffineSubspace.map_bot
|
Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic
|
β {k : Type u_1} {Vβ : Type u_2} {Pβ : Type u_3} {Vβ : Type u_4} {Pβ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup Vβ] [inst_2 : Module k Vβ] [inst_3 : AddTorsor Vβ Pβ] [inst_4 : AddCommGroup Vβ]
[inst_5 : Module k Vβ] [inst_6 : AddTorsor Vβ Pβ] (f : Pβ βα΅[k] Pβ), AffineSubspace.map f β₯ = β₯
|
Lean.Constructor.mk.injEq
|
Lean.Declaration
|
β (name : Lean.Name) (type : Lean.Expr) (name_1 : Lean.Name) (type_1 : Lean.Expr),
({ name := name, type := type } = { name := name_1, type := type_1 }) = (name = name_1 β§ type = type_1)
|
Filter.eventually_bind._simp_1
|
Mathlib.Order.Filter.Map
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Filter Ξ±} {m : Ξ± β Filter Ξ²} {p : Ξ² β Prop},
(βαΆ (y : Ξ²) in f.bind m, p y) = βαΆ (x : Ξ±) in f, βαΆ (y : Ξ²) in m x, p y
|
Irrational.of_mul_ratCast
|
Mathlib.NumberTheory.Real.Irrational
|
β (q : β) {x : β}, Irrational (x * βq) β Irrational x
|
Set.Finite.cast_ncard_eq
|
Mathlib.Data.Set.Card
|
β {Ξ± : Type u_1} {s : Set Ξ±}, s.Finite β βs.ncard = s.encard
|
LinearMap.transvection.comp_of_left_eq
|
Mathlib.LinearAlgebra.Transvection
|
β {R : Type u_1} {V : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid V] [inst_2 : Module R V]
{f : Module.Dual R V} {v w : V},
f w = 0 β LinearMap.transvection f v ββ LinearMap.transvection f w = LinearMap.transvection f (v + w)
|
ENNReal.mul_eq_left
|
Mathlib.Data.ENNReal.Operations
|
β {a b : ENNReal}, a β 0 β a β β€ β (a * b = a β b = 1)
|
Equiv.piOptionEquivProd_apply
|
Mathlib.Logic.Equiv.Basic
|
β {Ξ± : Type u_10} {Ξ² : Option Ξ± β Type u_9} (f : (a : Option Ξ±) β Ξ² a),
Equiv.piOptionEquivProd f = (f none, fun a => f (some a))
|
MeasureTheory.ae_eq_comp
|
Mathlib.MeasureTheory.Measure.Restrict
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} {Ξ΄ : Type u_4} {m0 : MeasurableSpace Ξ±} [inst : MeasurableSpace Ξ²]
{ΞΌ : MeasureTheory.Measure Ξ±} {f : Ξ± β Ξ²} {g g' : Ξ² β Ξ΄},
AEMeasurable f ΞΌ β g =α΅[MeasureTheory.Measure.map f ΞΌ] g' β g β f =α΅[ΞΌ] g' β f
|
ByteArray.ofFn
|
Batteries.Data.ByteArray
|
{n : β} β (Fin n β UInt8) β ByteArray
|
TestFunction.toBoundedContinuousFunctionCLM._proof_17
|
Mathlib.Analysis.Distribution.TestFunction
|
β (π : Type u_3) [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace β E] {Ξ© : TopologicalSpace.Opens E} {F : Type u_1} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace β F] [inst_5 : NormedSpace π F] {n : ββ} [inst_6 : Algebra β π] [inst_7 : IsScalarTower β π F]
(x : π) (x_1 : TestFunction Ξ© F n), β C, β (x_2 y : E), dist ((x β’ x_1) x_2) ((x β’ x_1) y) β€ C
|
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.IsCyclotomicExtension.eq_self_sdiff_zero._simp_1_1
|
Mathlib.NumberTheory.Cyclotomic.Basic
|
β {a b c : Prop}, ((a β§ b) β§ c) = (a β§ b β§ c)
|
IsCyclotomicExtension.Rat.Three.lambda_pow_four_dvd_cube_add_one_of_dvd_add_one
|
Mathlib.NumberTheory.NumberField.Cyclotomic.Three
|
β {K : Type u_1} [inst : Field K] {ΞΆ : K} (hΞΆ : IsPrimitiveRoot ΞΆ 3) [inst_1 : NumberField K]
[IsCyclotomicExtension {3} β K] {x : NumberField.RingOfIntegers K},
hΞΆ.toInteger - 1 β£ x + 1 β (hΞΆ.toInteger - 1) ^ 4 β£ x ^ 3 + 1
|
IsManifold.recOn
|
Mathlib.Geometry.Manifold.IsManifold.Basic
|
{π : Type u_1} β
[inst : NontriviallyNormedField π] β
{E : Type u_2} β
[inst_1 : NormedAddCommGroup E] β
[inst_2 : NormedSpace π E] β
{H : Type u_3} β
[inst_3 : TopologicalSpace H] β
{I : ModelWithCorners π E H} β
{n : WithTop ββ} β
{M : Type u_4} β
[inst_4 : TopologicalSpace M] β
[inst_5 : ChartedSpace H M] β
{motive : IsManifold I n M β Sort u} β
(t : IsManifold I n M) β
([toHasGroupoid : HasGroupoid M (contDiffGroupoid n I)] β motive β―) β motive t
|
_auto._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.3472188799._hygCtx._hyg.82
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital
|
Lean.Syntax
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_extractLsb'_eq_extractLsb'._simp_1_1
|
Init.Data.BitVec.Lemmas
|
β {Ξ± : Sort u_1} {p : Prop} [inst : Decidable p] {x y : Ξ±}, ((if p then x else y) = x) = (Β¬p β y = x)
|
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AddAndFinalizeContext.indFVars
|
Lean.Elab.MutualInductive
|
Lean.Elab.Command.AddAndFinalizeContextβ β Array Lean.Expr
|
TopModuleCat.instAddCommGroupHom
|
Mathlib.Algebra.Category.ModuleCat.Topology.Basic
|
(R : Type u) β [inst : Ring R] β [inst_1 : TopologicalSpace R] β {X Y : TopModuleCat R} β AddCommGroup (X βΆ Y)
|
Finset.subset_mulSpan._simp_3
|
Mathlib.Combinatorics.Additive.Dissociation
|
β {Ξ± : Type u_1} [inst : CommGroup Ξ±] [inst_1 : DecidableEq Ξ±] [inst_2 : Fintype Ξ±] {s : Finset Ξ±},
(s β s.mulSpan) = True
|
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Array.0.Std.Iterators.ArrayIterator.stepAsHetT_iterFromIdxM._simp_1_3
|
Std.Data.Iterators.Lemmas.Producers.Monadic.Array
|
β {Ξ± : Type u_1} [inst : LE Ξ±] {x y : Ξ±}, (x β₯ y) = (y β€ x)
|
Filter.covariant_vadd
|
Mathlib.Order.Filter.Pointwise
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : VAdd Ξ± Ξ²],
CovariantClass (Filter Ξ±) (Filter Ξ²) (fun x1 x2 => x1 +α΅₯ x2) fun x1 x2 => x1 β€ x2
|
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {instOrd : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} [inst : Std.TransOrd Ξ±]
(h : t.WF) {k km kme : Ξ±} (hkme : (Std.DTreeMap.Internal.Impl.erase k t β―).impl.minKey? = some kme),
t.minKey?.get β― = km β (compare km kme).isLE = true
|
grade_strictMono
|
Mathlib.Order.Grade
|
β {π : Type u_1} {Ξ± : Type u_3} [inst : Preorder π] [inst_1 : Preorder Ξ±] [inst_2 : GradeOrder π Ξ±],
StrictMono (grade π)
|
Vector.eraseIdx_set_lt
|
Init.Data.Vector.Erase
|
β {Ξ± : Type u_1} {n : β} {xs : Vector Ξ± n} {i : β} {w : i < n} {j : β} {a : Ξ±} (h : j < i),
(xs.set i a w).eraseIdx j β― = (xs.eraseIdx j β―).set (i - 1) a β―
|
Action.FunctorCategoryEquivalence.functor_map_app
|
Mathlib.CategoryTheory.Action.Basic
|
β {V : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {X Y : Action V G}
(f : X βΆ Y) (x : CategoryTheory.SingleObj G), (Action.FunctorCategoryEquivalence.functor.map f).app x = f.hom
|
FirstOrder.Language.age
|
Mathlib.ModelTheory.Fraisse
|
(L : FirstOrder.Language) β (M : Type w) β [L.Structure M] β Set (CategoryTheory.Bundled L.Structure)
|
ContinuousMap.zero_comp
|
Mathlib.Topology.ContinuousMap.Algebra
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} [inst : TopologicalSpace Ξ±] [inst_1 : TopologicalSpace Ξ²]
[inst_2 : TopologicalSpace Ξ³] [inst_3 : Zero Ξ³] (g : C(Ξ±, Ξ²)), ContinuousMap.comp 0 g = 0
|
Std.Do.PredTrans.pure._proof_1
|
Std.Do.PredTrans
|
β {ps : Std.Do.PostShape} {Ξ± : Type u_1} (a : Ξ±) (Qβ Qβ : Std.Do.PostCond Ξ± ps), Qβ.1 a β§ Qβ.1 a β£β’β Qβ.1 a β§ Qβ.1 a
|
Positive.instPowSubtypeLtOfNatNat_mathlib._proof_1
|
Mathlib.Algebra.Order.Positive.Ring
|
β {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (x : { x // 0 < x }) (n : β),
0 < βx ^ n
|
_private.Mathlib.Tactic.MkIffOfInductiveProp.0.Mathlib.Tactic.MkIff.select.match_5
|
Mathlib.Tactic.MkIffOfInductiveProp
|
(motive : β β β β Sort u_1) β
(m n : β) β
(Unit β motive 0 0) β
((n : β) β motive 0 n.succ) β ((m n : β) β motive m.succ n.succ) β ((x x_1 : β) β motive x x_1) β motive m n
|
NNRat.nndist_eq._simp_1
|
Mathlib.Topology.Instances.Rat
|
β (p q : ββ₯0), nndist βp βq = nndist p q
|
List.Sublist.tail
|
Init.Data.List.Sublist
|
β {Ξ± : Type u_1} {lβ lβ : List Ξ±}, lβ.Sublist lβ β lβ.tail.Sublist lβ.tail
|
Β«term_<|_Β»
|
Init.Notation
|
Lean.TrailingParserDescr
|
CategoryTheory.Under.map.eq_1
|
Mathlib.CategoryTheory.Comma.Over.Basic
|
β {T : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} T] {X Y : T} (f : X βΆ Y),
CategoryTheory.Under.map f =
CategoryTheory.Comma.mapLeft (CategoryTheory.Functor.id T) (CategoryTheory.Discrete.natTrans fun x => f)
|
Lean.Compiler.LCNF.Simp.FunDeclInfoMap.format
|
Lean.Compiler.LCNF.Simp.FunDeclInfo
|
Lean.Compiler.LCNF.Simp.FunDeclInfoMap β Lean.Compiler.LCNF.CompilerM Std.Format
|
smul_nonneg_iff_neg_imp_nonpos
|
Mathlib.Algebra.Order.Module.Defs
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Ring Ξ±] [inst_1 : LinearOrder Ξ±] [IsStrictOrderedRing Ξ±]
[inst_3 : AddCommGroup Ξ²] [inst_4 : LinearOrder Ξ²] [IsOrderedAddMonoid Ξ²] [inst_6 : Module Ξ± Ξ²]
[PosSMulStrictMono Ξ± Ξ²] {a : Ξ±} {b : Ξ²}, 0 β€ a β’ b β (a < 0 β b β€ 0) β§ (b < 0 β a β€ 0)
|
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.hasLimit_cospan_forget_of_right'
|
Mathlib.Geometry.RingedSpace.OpenImmersion
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X βΆ Z)
(g : Y βΆ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
CategoryTheory.Limits.HasLimit
(CategoryTheory.Limits.cospan
(((CategoryTheory.Limits.cospan g f).comp AlgebraicGeometry.SheafedSpace.forgetToPresheafedSpace).map
CategoryTheory.Limits.WalkingCospan.Hom.inl)
(((CategoryTheory.Limits.cospan g f).comp AlgebraicGeometry.SheafedSpace.forgetToPresheafedSpace).map
CategoryTheory.Limits.WalkingCospan.Hom.inr))
|
if_true_right._simp_1
|
Init.PropLemmas
|
β {p q : Prop} [h : Decidable p], (if p then q else True) = (p β q)
|
ENat.forall_natCast_le_iff_le
|
Mathlib.Data.ENat.Basic
|
β {m n : ββ}, (β (a : β), βa β€ m β βa β€ n) β m β€ n
|
CategoryTheory.Idempotents.KaroubiKaroubi.equivalence._proof_1
|
Mathlib.CategoryTheory.Idempotents.KaroubiKaroubi
|
β (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Idempotents.toKaroubi (CategoryTheory.Idempotents.Karoubi C)).map
((CategoryTheory.Idempotents.KaroubiKaroubi.unitIso C).hom.app X))
((CategoryTheory.Idempotents.KaroubiKaroubi.counitIso C).hom.app
((CategoryTheory.Idempotents.toKaroubi (CategoryTheory.Idempotents.Karoubi C)).obj X)) =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Idempotents.toKaroubi (CategoryTheory.Idempotents.Karoubi C)).obj X)
|
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_33
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Basic
|
β (n : β), Std.Tactic.BVDecide.BVUnOp.clz = Std.Tactic.BVDecide.BVUnOp.rotateRight n β False
|
Std.Iterators.Iter.step_drop
|
Std.Data.Iterators.Lemmas.Combinators.Drop
|
β {Ξ± Ξ² : Type u_1} [inst : Std.Iterators.Iterator Ξ± Id Ξ²] {n : β} {it : Std.Iter Ξ²},
(Std.Iterators.Iter.drop n it).step =
match it.step with
| β¨Std.Iterators.IterStep.yield it' out, hβ© =>
match n with
| 0 => Std.Iterators.PlausibleIterStep.yield (Std.Iterators.Iter.drop 0 it') out β―
| k.succ => Std.Iterators.PlausibleIterStep.skip (Std.Iterators.Iter.drop k it') β―
| β¨Std.Iterators.IterStep.skip it', hβ© => Std.Iterators.PlausibleIterStep.skip (Std.Iterators.Iter.drop n it') β―
| β¨Std.Iterators.IterStep.done, hβ© => Std.Iterators.PlausibleIterStep.done β―
|
Plausible.Testable.mk
|
Plausible.Testable
|
{p : Prop} β (Plausible.Configuration β Bool β Plausible.Gen (Plausible.TestResult p)) β Plausible.Testable p
|
Complex.arg_of_im_pos
|
Mathlib.Analysis.SpecialFunctions.Complex.Arg
|
β {z : β}, 0 < z.im β z.arg = Real.arccos (z.re / βzβ)
|
Nat.dfold_zero._proof_7
|
Init.Data.Nat.Fold
|
0 β€ 0
|
Finpartition.instMin._simp_5
|
Mathlib.Order.Partition.Finpartition
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {s : Finset Ξ±} {t : Finset Ξ²} {p : Ξ± Γ Ξ²}, (p β s ΓΛ’ t) = (p.1 β s β§ p.2 β t)
|
Ideal.comap_map_mk
|
Mathlib.RingTheory.Ideal.Quotient.Operations
|
β {R : Type u} [inst : Ring R] {I J : Ideal R} [inst_1 : I.IsTwoSided],
I β€ J β Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J
|
prodXSubSMul.eval
|
Mathlib.Algebra.Polynomial.GroupRingAction
|
β (G : Type u_2) [inst : Group G] [inst_1 : Fintype G] (R : Type u_3) [inst_2 : CommRing R]
[inst_3 : MulSemiringAction G R] (x : R), Polynomial.eval x (prodXSubSMul G R x) = 0
|
QuotientGroup.instSeminormedCommGroup._proof_4
|
Mathlib.Analysis.Normed.Group.Quotient
|
β {M : Type u_1} [inst : SeminormedCommGroup M] (S : Subgroup M) (x y : M β§Έ S),
PseudoMetricSpace.edist x y = ENNReal.ofReal (dist x y)
|
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sum'_isBasis_iff._simp_1_2
|
Mathlib.Combinatorics.Matroid.Sum
|
β {Ξ± : Type u_3} {Ξ² : Type u_4} {M : Matroid Ξ±} (f : Ξ± β Ξ²) {I X : Set Ξ²},
(M.mapEquiv f).IsBasis I X = M.IsBasis (βf.symm '' I) (βf.symm '' X)
|
Set.InjOn.eq_iff
|
Mathlib.Data.Set.Function
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {s : Set Ξ±} {f : Ξ± β Ξ²} {x y : Ξ±}, Set.InjOn f s β x β s β y β s β (f x = f y β x = y)
|
CategoryTheory.Limits.image.fac
|
Mathlib.CategoryTheory.Limits.Shapes.Images
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X βΆ Y)
[inst_1 : CategoryTheory.Limits.HasImage f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f) (CategoryTheory.Limits.image.ΞΉ f) = f
|
DomAddAct.instAddCommMonoidOfAddOpposite
|
Mathlib.GroupTheory.GroupAction.DomAct.Basic
|
{M : Type u_1} β [AddCommMonoid Mα΅α΅α΅] β AddCommMonoid Mα΅α΅α΅
|
Dioph._aux_Mathlib_NumberTheory_Dioph___unexpand_Dioph_le_dioph_1
|
Mathlib.NumberTheory.Dioph
|
Lean.PrettyPrinter.Unexpander
|
Metric.PiNatEmbed.recOn
|
Mathlib.Topology.MetricSpace.PiNat
|
{ΞΉ : Type u_2} β
{X : Type u_5} β
{Y : ΞΉ β Type u_6} β
{f : (i : ΞΉ) β X β Y i} β
{motive : Metric.PiNatEmbed X Y f β Sort u} β
(t : Metric.PiNatEmbed X Y f) β ((ofPiNat : X) β motive { ofPiNat := ofPiNat }) β motive t
|
jacobiSym.mul_right'
|
Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol
|
β (a : β€) {bβ bβ : β}, bβ β 0 β bβ β 0 β jacobiSym a (bβ * bβ) = jacobiSym a bβ * jacobiSym a bβ
|
TopCommRingCat.hasForgetToTopCat
|
Mathlib.Topology.Category.TopCommRingCat
|
CategoryTheory.HasForgetβ TopCommRingCat TopCat
|
Equiv.Perm.coe_pow._simp_1
|
Mathlib.Algebra.Group.End
|
β {Ξ± : Type u_4} (f : Equiv.Perm Ξ±) (n : β), (βf)^[n] = β(f ^ n)
|
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.SimpM.run.match_1
|
Lean.Meta.Tactic.Simp.Types
|
{Ξ± : Type} β
(motive : Ξ± Γ Lean.Meta.Simp.State β Sort u_1) β
(__discr : Ξ± Γ Lean.Meta.Simp.State) β ((r : Ξ±) β (s : Lean.Meta.Simp.State) β motive (r, s)) β motive __discr
|
CategoryTheory.ShiftMkCore.casesOn
|
Mathlib.CategoryTheory.Shift.Basic
|
{C : Type u} β
{A : Type u_1} β
[inst : CategoryTheory.Category.{v, u} C] β
[inst_1 : AddMonoid A] β
{motive : CategoryTheory.ShiftMkCore C A β Sort u_2} β
(t : CategoryTheory.ShiftMkCore C A) β
((F : A β CategoryTheory.Functor C C) β
(zero : F 0 β
CategoryTheory.Functor.id C) β
(add : (n m : A) β F (n + m) β
(F n).comp (F m)) β
(assoc_hom_app :
β (mβ mβ mβ : A) (X : C),
CategoryTheory.CategoryStruct.comp ((add (mβ + mβ) mβ).hom.app X)
((F mβ).map ((add mβ mβ).hom.app X)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom β―)
(CategoryTheory.CategoryStruct.comp ((add mβ (mβ + mβ)).hom.app X)
((add mβ mβ).hom.app ((F mβ).obj X)))) β
(zero_add_hom_app :
β (n : A) (X : C),
(add 0 n).hom.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom β―)
((F n).map (zero.inv.app X))) β
(add_zero_hom_app :
β (n : A) (X : C),
(add n 0).hom.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom β―)
(zero.inv.app ((F n).obj X))) β
motive
{ F := F, zero := zero, add := add, assoc_hom_app := assoc_hom_app,
zero_add_hom_app := zero_add_hom_app, add_zero_hom_app := add_zero_hom_app }) β
motive t
|
Batteries.Tactic.PrintPrefixConfig.imported._default
|
Batteries.Tactic.PrintPrefix
|
Bool
|
Qq.unpackParensIdent
|
Qq.Match
|
Lean.Syntax β Option Lean.Syntax
|
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triangle_counting'._simp_1_4
|
Mathlib.Combinatorics.SimpleGraph.Triangle.Counting
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {p : Ξ± Γ Ξ² β Prop}, (β (x : Ξ± Γ Ξ²), p x) = β (a : Ξ±) (b : Ξ²), p (a, b)
|
Homeomorph.funUnique_apply
|
Mathlib.Topology.Homeomorph.Lemmas
|
β (ΞΉ : Type u_7) (X : Type u_8) [inst : Unique ΞΉ] [inst_1 : TopologicalSpace X],
β(Homeomorph.funUnique ΞΉ X) = fun f => f default
|
Finmap.lookup_eq_none
|
Mathlib.Data.Finmap
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} [inst : DecidableEq Ξ±] {a : Ξ±} {s : Finmap Ξ²}, Finmap.lookup a s = none β a β s
|
Lean.Elab.Info.format
|
Lean.Elab.InfoTree.Main
|
Lean.Elab.ContextInfo β Lean.Elab.Info β IO Std.Format
|
Int64.toISize_xor
|
Init.Data.SInt.Bitwise
|
β (a b : Int64), (a ^^^ b).toISize = a.toISize ^^^ b.toISize
|
CategoryTheory.Limits.coprod.inl_snd_assoc
|
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct X Y] {Z : C} (h : Y βΆ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.snd X Y) h) =
CategoryTheory.CategoryStruct.comp 0 h
|
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.restrict_fixedField._simp_1_6
|
Mathlib.FieldTheory.Galois.Infinite
|
β {Ξ± : Type u} (x : Ξ±) (a b : Set Ξ±), (x β a β© b) = (x β a β§ x β b)
|
Bool.not_eq_eq_eq_not
|
Init.SimpLemmas
|
β {a b : Bool}, (!a) = b β a = !b
|
MeasureTheory.OuterMeasure.map._proof_1
|
Mathlib.MeasureTheory.OuterMeasure.Operations
|
IsScalarTower ENNReal ENNReal ENNReal
|
MeasureTheory.Measure.restrict_apply_self
|
Mathlib.MeasureTheory.Measure.Restrict
|
β {Ξ± : Type u_2} {m0 : MeasurableSpace Ξ±} (ΞΌ : MeasureTheory.Measure Ξ±) (s : Set Ξ±), (ΞΌ.restrict s) s = ΞΌ s
|
Array.filter_empty
|
Init.Data.Array.Lemmas
|
β {Ξ± : Type u_1} {p : Ξ± β Bool}, Array.filter p #[] = #[]
|
_private.Plausible.Gen.0.Plausible.Gen.permutationOf._proof_7
|
Plausible.Gen
|
β {Ξ± : Type u_1} (ys : List Ξ±), Β¬0 β€ ys.length β False
|
_private.Mathlib.Analysis.Normed.Unbundled.SpectralNorm.0.spectralNorm.spectralMulAlgNorm_eq_of_mem_roots._simp_1_3
|
Mathlib.Analysis.Normed.Unbundled.SpectralNorm
|
β {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, p.IsRoot a = (Polynomial.eval a p = 0)
|
HurwitzZeta.hasSum_int_oddKernel
|
Mathlib.NumberTheory.LSeries.HurwitzZetaOdd
|
β (a : β) {x : β},
0 < x β HasSum (fun n => (βn + a) * Real.exp (-Real.pi * (βn + a) ^ 2 * x)) (HurwitzZeta.oddKernel (βa) x)
|
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.eraseDecl.match_1
|
Lean.Meta.Tactic.Grind.Theorems
|
(motive : Option (Array Lean.Name) β Sort u_1) β
(__do_lift : Option (Array Lean.Name)) β
((eqns : Array Lean.Name) β motive (some eqns)) β ((x : Option (Array Lean.Name)) β motive x) β motive __do_lift
|
CategoryTheory.PreZeroHypercover.pullbackCoverOfLeftIsoPullbackβ._proof_3
|
Mathlib.CategoryTheory.Sites.Hypercover.Zero
|
β {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} (E : CategoryTheory.PreZeroHypercover X)
{Y Z : C} (f : X βΆ Z) (g : Y βΆ Z) [inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : β (i : E.Iβ), CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.fst f g) (E.f i)]
[inst_3 : β (i : E.Iβ), CategoryTheory.Limits.HasPullback (E.f i) (CategoryTheory.Limits.pullback.fst f g)]
(i : (E.pullbackCoverOfLeft f g).Iβ),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.pullbackRightPullbackFstIso f g (E.f i)).symm βͺβ«
CategoryTheory.Limits.pullbackSymmetry (E.f i) (CategoryTheory.Limits.pullback.fst f g)).hom
((CategoryTheory.PreZeroHypercover.pullbackβ (CategoryTheory.Limits.pullback.fst f g) E).f
((Equiv.refl (E.pullbackCoverOfLeft f g).Iβ) i)) =
(E.pullbackCoverOfLeft f g).f i
|
Algebra.Extension.noConfusion
|
Mathlib.RingTheory.Extension.Basic
|
{R : Type u} β
{S : Type v} β
[inst : CommRing R] β
[inst_1 : CommRing S] β
[inst_2 : Algebra R S] β
{P : Sort u_1} β {x1 x2 : Algebra.Extension R S} β x1 = x2 β Algebra.Extension.noConfusionType P x1 x2
|
Lean.Omega.Fin.lt_of_not_le
|
Init.Omega.Int
|
β {n : β} {i j : Fin n}, Β¬i β€ j β j < i
|
CategoryTheory.Limits.coproductIsCoproduct'._proof_2
|
Mathlib.CategoryTheory.Limits.Shapes.Products
|
β {Ξ± : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete Ξ±) C)
[inst_1 : CategoryTheory.Limits.HasCoproduct fun j => X.obj { as := j }] (s : CategoryTheory.Limits.Cocone X)
(m : (CategoryTheory.Limits.Sigma.cocone X).pt βΆ s.pt),
(β (j : CategoryTheory.Discrete Ξ±),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.Sigma.cocone X).ΞΉ.app j) m = s.ΞΉ.app j) β
m = CategoryTheory.Limits.Sigma.desc fun j => s.ΞΉ.app { as := j }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.