name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
CategoryTheory.Functor.OplaxMonoidal.instIsIsoΞ·
|
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type uβ} [inst_2 : CategoryTheory.Category.{vβ, uβ} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] [CategoryTheory.Limits.PreservesFiniteProducts F],
CategoryTheory.IsIso (CategoryTheory.Functor.OplaxMonoidal.Ξ· F)
|
CompactExhaustion.mk.inj
|
Mathlib.Topology.Compactness.SigmaCompact
|
β {X : Type u_4} {inst : TopologicalSpace X} {toFun : β β Set X} {isCompact' : β (n : β), IsCompact (toFun n)}
{subset_interior_succ' : β (n : β), toFun n β interior (toFun (n + 1))} {iUnion_eq' : β n, toFun n = Set.univ}
{toFun_1 : β β Set X} {isCompact'_1 : β (n : β), IsCompact (toFun_1 n)}
{subset_interior_succ'_1 : β (n : β), toFun_1 n β interior (toFun_1 (n + 1))}
{iUnion_eq'_1 : β n, toFun_1 n = Set.univ},
{ toFun := toFun, isCompact' := isCompact', subset_interior_succ' := subset_interior_succ',
iUnion_eq' := iUnion_eq' } =
{ toFun := toFun_1, isCompact' := isCompact'_1, subset_interior_succ' := subset_interior_succ'_1,
iUnion_eq' := iUnion_eq'_1 } β
toFun = toFun_1
|
Fin.shiftLeft
|
Init.Data.Fin.Basic
|
{n : β} β Fin n β Fin n β Fin n
|
Matrix.uniqueEquiv_symm_apply
|
Mathlib.LinearAlgebra.Matrix.Unique
|
β {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : Unique m] [inst_1 : Unique n] (a : A),
Matrix.uniqueEquiv.symm a = Matrix.of fun x x_1 => a
|
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux._simp_1_3
|
Mathlib.Analysis.Normed.Lp.PiLp
|
β (p : True β Prop), (β (x : True), p x) = p True.intro
|
Mathlib.Tactic.Abel._aux_Mathlib_Tactic_Abel___macroRules_Mathlib_Tactic_Abel_abel1!_1
|
Mathlib.Tactic.Abel
|
Lean.Macro
|
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_inv_assoc
|
Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor
|
β {B : Type uβ} [inst : CategoryTheory.Bicategory B] {C : Type uβ} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a βΆ b) {Z : F.obj a βΆ F.obj b}
(h : CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.CategoryStruct.id b)) βΆ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (F.mapId b).inv) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor (F.map f)).hom
(CategoryTheory.CategoryStruct.comp (F.mapβ (CategoryTheory.Bicategory.rightUnitor f).inv)
(CategoryTheory.CategoryStruct.comp (F.mapComp f (CategoryTheory.CategoryStruct.id b)).hom h))
|
IntermediateField.exists_algHom_of_splits_of_aeval
|
Mathlib.FieldTheory.Extension
|
β {F : Type u_1} {E : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K],
(β (s : E), IsIntegral F s β§ (Polynomial.map (algebraMap F K) (minpoly F s)).Splits) β
β {x : E} {y : K}, (Polynomial.aeval y) (minpoly F x) = 0 β β Ο, Ο x = y
|
Finset.nontrivial_iff_ne_singleton
|
Mathlib.Data.Finset.Insert
|
β {Ξ± : Type u_1} {s : Finset Ξ±} {a : Ξ±}, a β s β (s.Nontrivial β s β {a})
|
PartOrdEmb.dual._proof_1
|
Mathlib.Order.Category.PartOrdEmb
|
β (X : PartOrdEmb),
PartOrdEmb.ofHom (PartOrdEmb.Hom.hom (CategoryTheory.CategoryStruct.id X)).dual =
CategoryTheory.CategoryStruct.id { carrier := (βX)α΅α΅, str := OrderDual.instPartialOrder βX }
|
pure_le_nhds
|
Mathlib.Topology.Neighborhoods
|
β {X : Type u} [inst : TopologicalSpace X], pure β€ nhds
|
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._simp_1_5
|
Init.Data.BitVec.Bitblast
|
β {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p β q)
|
Lean.Elab.Term.MutualClosure.FixPoint.run
|
Lean.Elab.MutualDef
|
Array Lean.FVarId β Lean.Elab.Term.MutualClosure.UsedFVarsMap β Lean.Elab.Term.MutualClosure.UsedFVarsMap
|
NonemptyFinLinOrd.ofHom
|
Mathlib.Order.Category.NonemptyFinLinOrd
|
{X Y : Type u} β
[inst : Nonempty X] β
[inst_1 : LinearOrder X] β
[inst_2 : Fintype X] β
[inst_3 : Nonempty Y] β
[inst_4 : LinearOrder Y] β [inst_5 : Fintype Y] β (X βo Y) β (NonemptyFinLinOrd.of X βΆ NonemptyFinLinOrd.of Y)
|
Ideal.under_under
|
Mathlib.RingTheory.Ideal.Over
|
β {A : Type u_2} [inst : CommSemiring A] {B : Type u_3} [inst_1 : CommSemiring B] {C : Type u_4} [inst_2 : Semiring C]
[inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C] [IsScalarTower A B C] (π : Ideal C),
Ideal.under A (Ideal.under B π) = Ideal.under A π
|
_private.Init.Data.Int.LemmasAux.0.Int.min_assoc._proof_1_1
|
Init.Data.Int.LemmasAux
|
β (a b c : β€), Β¬min (min a b) c = min a (min b c) β False
|
List.infix_filter_iff
|
Init.Data.List.Sublist
|
β {Ξ± : Type u_1} {p : Ξ± β Bool} {lβ lβ : List Ξ±}, lβ <:+: List.filter p lβ β β l, l <:+: lβ β§ lβ = List.filter p l
|
Std.Do.SPred.true_intro
|
Std.Do.SPred.DerivedLaws
|
β {Οs : List (Type u)} {P : Std.Do.SPred Οs}, P β’β βTrueβ
|
_private.Mathlib.Tactic.Abel.0.Mathlib.Tactic.Abel.addG.match_1
|
Mathlib.Tactic.Abel
|
(motive : Lean.Name β Sort u_1) β
(x : Lean.Name) β ((p : Lean.Name) β (s : String) β motive (p.str s)) β ((n : Lean.Name) β motive n) β motive x
|
BoxIntegral.Box.Ioo_subset_coe
|
Mathlib.Analysis.BoxIntegral.Box.Basic
|
β {ΞΉ : Type u_1} (I : BoxIntegral.Box ΞΉ), BoxIntegral.Box.Ioo I β βI
|
FormalMultilinearSeries.coeff_eq_zero
|
Mathlib.Analysis.Calculus.FormalMultilinearSeries
|
β {π : Type u} {E : Type v} [inst : NontriviallyNormedField π] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {p : FormalMultilinearSeries π π E} {n : β}, p.coeff n = 0 β p n = 0
|
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_5.splitter
|
Std.Data.DTreeMap.Internal.Balancing
|
{Ξ± : Type u_1} β
{Ξ² : Ξ± β Type u_2} β
(rs : β) β
(k : Ξ±) β
(v : Ξ² k) β
(l r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
(motive :
(l_1 : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
l_1.Balanced β
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond l_1.size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size β
Sort u_3) β
(l_1 : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
(hlb : l_1.Balanced) β
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond l_1.size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) β
((hlb : Std.DTreeMap.Internal.Impl.leaf.Balanced) β
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond Std.DTreeMap.Internal.Impl.leaf.size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) β
motive Std.DTreeMap.Internal.Impl.leaf hlb hlr) β
((ls : β) β
(lk : Ξ±) β
(lv : Ξ² lk) β
(ll lr : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced) β
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) β
motive (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr) hlb hlr) β
motive l_1 hlb hlr
|
Subsemigroup.range_subtype
|
Mathlib.Algebra.Group.Subsemigroup.Operations
|
β {M : Type u_1} [inst : Mul M] (s : Subsemigroup M), (MulMemClass.subtype s).srange = s
|
_private.Mathlib.Algebra.Star.NonUnitalSubalgebra.0.NonUnitalStarAlgebra.mem_iInf._simp_1_2
|
Mathlib.Algebra.Star.NonUnitalSubalgebra
|
β {Ξ± : Type u_1} {ΞΉ : Sort u_4} {f : ΞΉ β Ξ±} {p : Ξ± β Prop}, (β a β Set.range f, p a) = β (i : ΞΉ), p (f i)
|
Lean.Meta.instInhabitedUnificationHints.default
|
Lean.Meta.UnificationHint
|
Lean.Meta.UnificationHints
|
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_6
|
Mathlib.Data.List.Basic
|
β {ΞΉ : Type u_1} (l : List ΞΉ) (n : β), (List.take n l).length + 1 β€ l.length β (List.take n l).length < l.length
|
[email protected]._hygCtx._hyg.47
|
Mathlib.MeasureTheory.Measure.Real
|
Lean.Syntax
|
Lean.Omega.LinearCombo.coordinate_eval_0
|
Init.Omega.LinearCombo
|
β {a0 : β€} {t : List β€}, (Lean.Omega.LinearCombo.coordinate 0).eval (Lean.Omega.Coeffs.ofList (a0 :: t)) = a0
|
ProofWidgets.instFromJsonRpcEncodablePacket.fromJson._@.ProofWidgets.Presentation.Expr.1937505173._hygCtx._hyg.17
|
ProofWidgets.Presentation.Expr
|
Lean.Json β Except String ProofWidgets.RpcEncodablePacketβ
|
AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.isLocallyFraction
|
Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf
|
{A : Type u_1} β
{Ο : Type u_2} β
[inst : CommRing A] β
[inst_1 : SetLike Ο A] β
[inst_2 : AddSubgroupClass Ο A] β
(π : β β Ο) β
[inst_3 : GradedRing π] β
TopCat.LocalPredicate fun x => HomogeneousLocalization.AtPrime π x.asHomogeneousIdeal.toIdeal
|
List.eq_nil_of_map_eq_nil
|
Init.Data.List.Lemmas
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β Ξ²} {l : List Ξ±}, List.map f l = [] β l = []
|
Lean.Elab.ContextInfo.parentDecl?._default
|
Lean.Elab.InfoTree.Types
|
Option Lean.Name
|
CategoryTheory.OplaxFunctor.comp
|
Mathlib.CategoryTheory.Bicategory.Functor.Oplax
|
{B : Type uβ} β
[inst : CategoryTheory.Bicategory B] β
{C : Type uβ} β
[inst_1 : CategoryTheory.Bicategory C] β
{D : Type uβ} β
[inst_2 : CategoryTheory.Bicategory D] β
CategoryTheory.OplaxFunctor B C β CategoryTheory.OplaxFunctor C D β CategoryTheory.OplaxFunctor B D
|
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.msgToInteractive.match_3
|
Lean.Widget.InteractiveDiagnostic
|
(motive : Lean.Widget.EmbedFmtβ β Sort u_1) β
(x : Lean.Widget.EmbedFmtβΒΉ) β
((ctx : Lean.Elab.ContextInfo) β
(infos : Std.TreeMap β Lean.Elab.Info compare) β motive (Lean.Widget.EmbedFmt.codeβ ctx infos)) β
((ctx : Lean.Elab.ContextInfo) β
(lctx : Lean.LocalContext) β (g : Lean.MVarId) β motive (Lean.Widget.EmbedFmt.goalβ ctx lctx g)) β
((wi : Lean.Widget.WidgetInstance) β (alt : Std.Format) β motive (Lean.Widget.EmbedFmt.widgetβ wi alt)) β
((cls : Lean.Name) β
(msg : Std.Format) β
(collapsed : Bool) β
(children : Lean.Widget.StrictOrLazy (Array Std.Format) (Array Lean.MessageData)) β
motive (Lean.Widget.EmbedFmt.traceβ cls msg collapsed children)) β
(Unit β motive Lean.Widget.EmbedFmt.ignoreTagsβ) β motive x
|
Associates.FactorSet.prod
|
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet
|
{Ξ± : Type u_1} β [inst : CancelCommMonoidWithZero Ξ±] β Associates.FactorSet Ξ± β Associates Ξ±
|
List.length_product
|
Mathlib.Data.List.ProdSigma
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} (lβ : List Ξ±) (lβ : List Ξ²), (lβ ΓΛ’ lβ).length = lβ.length * lβ.length
|
FirstOrder.Language.IsRelational
|
Mathlib.ModelTheory.Basic
|
FirstOrder.Language β Prop
|
Submodule.map.congr_simp
|
Mathlib.Algebra.Module.Submodule.Map
|
β {R : Type u_1} {Rβ : Type u_3} {M : Type u_5} {Mβ : Type u_7} [inst : Semiring R] [inst_1 : Semiring Rβ]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid Mβ] [inst_4 : Module R M] [inst_5 : Module Rβ Mβ]
{Οββ Οββ_1 : R β+* Rβ} (e_Οββ : Οββ = Οββ_1) [inst_6 : RingHomSurjective Οββ] {F : Type u_9} [inst_7 : FunLike F M Mβ]
[inst_8 : SemilinearMapClass F Οββ M Mβ] (f f_1 : F),
f = f_1 β β (p p_1 : Submodule R M), p = p_1 β Submodule.map f p = Submodule.map f_1 p_1
|
CategoryTheory.ShortComplex.moduleCat_exact_iff
|
Mathlib.Algebra.Homology.ShortComplex.ModuleCat
|
β {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
S.Exact β
β (xβ : βS.Xβ),
(CategoryTheory.ConcreteCategory.hom S.g) xβ = 0 β β xβ, (CategoryTheory.ConcreteCategory.hom S.f) xβ = xβ
|
CategoryTheory.IsCofiltered.nonempty
|
Mathlib.CategoryTheory.Filtered.Basic
|
β {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.IsCofiltered C], Nonempty C
|
[email protected]._hygCtx._hyg.3
|
Lean.Widget.Basic
|
TypeName Lean.Elab.InfoWithCtx
|
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate.noConfusionType
|
Lean.Meta.Tactic.Grind.Split
|
Sort u β Lean.Meta.Grind.SplitCandidateβ β Lean.Meta.Grind.SplitCandidateβ β Sort u
|
AddMonoidHom.precompEquiv
|
Mathlib.Algebra.Group.Equiv.Basic
|
{Ξ± : Type u_19} β
{Ξ² : Type u_20} β
[inst : AddMonoid Ξ±] β
[inst_1 : AddMonoid Ξ²] β Ξ± β+ Ξ² β (Ξ³ : Type u_21) β [inst_2 : AddMonoid Ξ³] β (Ξ² β+ Ξ³) β (Ξ± β+ Ξ³)
|
CategoryTheory.Retract.op_i
|
Mathlib.CategoryTheory.Retract
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Retract X Y), h.op.i = h.r.op
|
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Rawβ.isHashSelf_filterMapβ._simp_1_2
|
Std.Data.DHashMap.Internal.WF
|
β {Ξ± : Type u_1} {b : Ξ±} {Ξ±_1 : Type u_2} {x : Option Ξ±_1} {f : Ξ±_1 β Ξ±},
(Option.map f x = some b) = β a, x = some a β§ f a = b
|
Std.DHashMap.isEmpty_insertMany_list
|
Std.Data.DHashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.DHashMap Ξ± Ξ²} [EquivBEq Ξ±] [LawfulHashable Ξ±]
{l : List ((a : Ξ±) Γ Ξ² a)}, (m.insertMany l).isEmpty = (m.isEmpty && l.isEmpty)
|
CategoryTheory.Limits.spanExt_inv_app_left
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z X' Y' Z' : C} (iX : X β
X') (iY : Y β
Y') (iZ : Z β
Z')
{f : X βΆ Y} {g : X βΆ Z} {f' : X' βΆ Y'} {g' : X' βΆ Z'}
(wf : CategoryTheory.CategoryStruct.comp iX.hom f' = CategoryTheory.CategoryStruct.comp f iY.hom)
(wg : CategoryTheory.CategoryStruct.comp iX.hom g' = CategoryTheory.CategoryStruct.comp g iZ.hom),
(CategoryTheory.Limits.spanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingSpan.left = iY.inv
|
CategoryTheory.IsAccessibleCategory.rec
|
Mathlib.CategoryTheory.Presentable.LocallyPresentable
|
{C : Type u} β
[hC : CategoryTheory.Category.{v, u} C] β
{motive : CategoryTheory.IsAccessibleCategory.{w, v, u} C β Sort u_1} β
((exists_cardinal : β ΞΊ, β (x : Fact ΞΊ.IsRegular), CategoryTheory.IsCardinalAccessibleCategory C ΞΊ) β motive β―) β
(t : CategoryTheory.IsAccessibleCategory.{w, v, u} C) β motive t
|
IntermediateField.isIntegral_iff
|
Mathlib.FieldTheory.IntermediateField.Algebraic
|
β {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {S : IntermediateField K L}
{x : β₯S}, IsIntegral K x β IsIntegral K βx
|
[email protected]._hygCtx._hyg.46
|
Mathlib.MeasureTheory.Measure.Real
|
Lean.Syntax
|
Lean.PrettyPrinter.Parenthesizer.ident.parenthesizer._regBuiltin.Lean.PrettyPrinter.Parenthesizer.ident.parenthesizer_1
|
Lean.Parser
|
IO Unit
|
AlgebraicGeometry.Scheme.IdealSheafData.support_antitone
|
Mathlib.AlgebraicGeometry.IdealSheaf.Basic
|
β {X : AlgebraicGeometry.Scheme}, Antitone AlgebraicGeometry.Scheme.IdealSheafData.support
|
CategoryTheory.CatCenter.localizationRingHom
|
Mathlib.CategoryTheory.Center.Localization
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
{D : Type uβ} β
[inst_1 : CategoryTheory.Category.{vβ, uβ} D] β
(L : CategoryTheory.Functor C D) β
(W : CategoryTheory.MorphismProperty C) β
[L.IsLocalization W] β
[inst_3 : CategoryTheory.Preadditive C] β
[inst_4 : CategoryTheory.Preadditive D] β
[L.Additive] β CategoryTheory.CatCenter C β+* CategoryTheory.CatCenter D
|
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary._proof_3
|
Std.Time.Date.ValidDate
|
β {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : β€), acc + 1 - acc = 1
|
Std.DHashMap.Internal.Rawβ.insertIfNew_equiv_congr
|
Std.Data.DHashMap.Internal.RawLemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] (mβ mβ : Std.DHashMap.Internal.Rawβ Ξ± Ξ²)
[EquivBEq Ξ±] [LawfulHashable Ξ±],
(βmβ).WF β (βmβ).WF β (βmβ).Equiv βmβ β β {k : Ξ±} {v : Ξ² k}, (β(mβ.insertIfNew k v)).Equiv β(mβ.insertIfNew k v)
|
IsCompact.locallyCompactSpace_of_mem_nhds_of_group
|
Mathlib.Topology.Algebra.Group.Pointwise
|
β {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {K : Set G},
IsCompact K β β {x : G}, K β nhds x β LocallyCompactSpace G
|
ringChar.of_eq
|
Mathlib.Algebra.CharP.Defs
|
β {R : Type u_1} [inst : NonAssocSemiring R] {p : β}, ringChar R = p β CharP R p
|
WittVector.poly_eq_of_wittPolynomial_bind_eq
|
Mathlib.RingTheory.WittVector.IsPoly
|
β (p : β) [Fact (Nat.Prime p)] (f g : β β MvPolynomial β β€),
(β (n : β), (MvPolynomial.bindβ f) (wittPolynomial p β€ n) = (MvPolynomial.bindβ g) (wittPolynomial p β€ n)) β f = g
|
TwoSidedIdeal.orderIsoIsTwoSided_symm_apply
|
Mathlib.RingTheory.TwoSidedIdeal.Operations
|
β {R : Type u_1} [inst : Ring R] (I : { I // I.IsTwoSided }),
(RelIso.symm TwoSidedIdeal.orderIsoIsTwoSided) I =
have this := β―;
(βI).toTwoSided
|
IsPreconnected.eq_one_or_eq_neg_one_of_sq_eq
|
Mathlib.Topology.Algebra.Field
|
β {Ξ± : Type u_2} {π : Type u_3} {f : Ξ± β π} {S : Set Ξ±} [inst : TopologicalSpace Ξ±] [inst_1 : TopologicalSpace π]
[T1Space π] [inst_3 : Ring π] [NoZeroDivisors π],
IsPreconnected S β ContinuousOn f S β Set.EqOn (f ^ 2) 1 S β Set.EqOn f 1 S β¨ Set.EqOn f (-1) S
|
Fin.preimage_natAdd_uIoc_natAdd
|
Mathlib.Order.Interval.Set.Fin
|
β {n : β} (m : β) (i j : Fin n), Fin.natAdd m β»ΒΉ' Set.uIoc (Fin.natAdd m i) (Fin.natAdd m j) = Set.uIoc i j
|
FirstOrder.Language.Substructure.closure_induction
|
Mathlib.ModelTheory.Substructures
|
β {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {s : Set M} {p : M β Prop} {x : M},
x β (FirstOrder.Language.Substructure.closure L).toFun s β
(β x β s, p x) β (β {n : β} (f : L.Functions n), FirstOrder.Language.ClosedUnder f (setOf p)) β p x
|
CategoryTheory.CartesianClosed.uncurry
|
Mathlib.CategoryTheory.Monoidal.Closed.Cartesian
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] β
{X Y A : C} β
[inst_2 : CategoryTheory.Exponentiable A] β
(Y βΆ A βΉ X) β (CategoryTheory.MonoidalCategoryStruct.tensorObj A Y βΆ X)
|
Set.preimage_const
|
Mathlib.Data.Set.Image
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} (b : Ξ²) (s : Set Ξ²) [inst : Decidable (b β s)],
(fun x => b) β»ΒΉ' s = if b β s then Set.univ else β
|
Multiset.union_le_iff
|
Mathlib.Data.Multiset.UnionInter
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {s t u : Multiset Ξ±}, s βͺ t β€ u β s β€ u β§ t β€ u
|
genericPoint_specializes
|
Mathlib.Topology.Sober
|
β {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] [inst_1 : QuasiSober Ξ±] [inst_2 : IrreducibleSpace Ξ±] (x : Ξ±),
genericPoint Ξ± β€³ x
|
Mathlib.Meta.NormNum.Result.toSimpResult.match_1
|
Mathlib.Tactic.NormNum.Result
|
{u : Lean.Level} β
{Ξ± : Q(Type u)} β
{e : Q(Β«$Ξ±Β»)} β
(motive : (e' : Q(Β«$Ξ±Β»)) Γ Q(Β«$eΒ» = Β«$e'Β») β Sort u_1) β
(x : (e' : Q(Β«$Ξ±Β»)) Γ Q(Β«$eΒ» = Β«$e'Β»)) β
((expr : Q(Β«$Ξ±Β»)) β (proof? : Q(Β«$eΒ» = Β«$exprΒ»)) β motive β¨expr, proof?β©) β motive x
|
Nimber.toOrdinal_symm_eq
|
Mathlib.SetTheory.Nimber.Basic
|
Nimber.toOrdinal.symm = Ordinal.toNimber
|
Filter.HasBasis.inf_neBot_iff
|
Mathlib.Order.Filter.Bases.Basic
|
β {Ξ± : Type u_1} {ΞΉ : Sort u_4} {l l' : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±},
l.HasBasis p s β ((l β l').NeBot β β β¦i : ΞΉβ¦, p i β β β¦s' : Set Ξ±β¦, s' β l' β (s i β© s').Nonempty)
|
BialgEquiv.ofAlgEquiv._proof_7
|
Mathlib.RingTheory.Bialgebra.Equiv
|
β {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Bialgebra R A] [inst_4 : Bialgebra R B] (f : A ββ[R] B),
(Algebra.TensorProduct.map βf βf).comp (Bialgebra.comulAlgHom R A) = (Bialgebra.comulAlgHom R B).comp βf β
TensorProduct.map { toFun := f.toFun, map_add' := β―, map_smul' := β― }
{ toFun := f.toFun, map_add' := β―, map_smul' := β― } ββ
CoalgebraStruct.comul =
CoalgebraStruct.comul ββ { toFun := f.toFun, map_add' := β―, map_smul' := β― }
|
CategoryTheory.Functor.PreservesRightHomologyOf.mk._flat_ctor
|
Mathlib.Algebra.Homology.ShortComplex.PreservesHomology
|
β {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Category.{u_4, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {F : CategoryTheory.Functor C D}
[inst_4 : F.PreservesZeroMorphisms] {S : CategoryTheory.ShortComplex C},
(β (h : S.RightHomologyData), h.IsPreservedBy F) β F.PreservesRightHomologyOf S
|
Matroid.mapSetEmbedding_indep_iff'
|
Mathlib.Combinatorics.Matroid.Map
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {M : Matroid Ξ±} {f : βM.E βͺ Ξ²} {I : Set Ξ²},
(M.mapSetEmbedding f).Indep I β β Iβ, M.Indep (Subtype.val '' Iβ) β§ I = βf '' Iβ
|
Topology.IsEmbedding.comapUniformSpace
|
Mathlib.Topology.UniformSpace.UniformEmbedding
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β
[inst : TopologicalSpace Ξ±] β [u : UniformSpace Ξ²] β (f : Ξ± β Ξ²) β Topology.IsEmbedding f β UniformSpace Ξ±
|
_private.Mathlib.NumberTheory.DirichletCharacter.Orthogonality.0.DirichletCharacter.sum_char_inv_mul_char_eq._simp_1_1
|
Mathlib.NumberTheory.DirichletCharacter.Orthogonality
|
β {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y)
|
Nat.add_mod_add_ite
|
Mathlib.Data.Nat.ModEq
|
β (a b c : β), ((a + b) % c + if c β€ a % c + b % c then c else 0) = a % c + b % c
|
Algebra.idealMap._proof_1
|
Mathlib.RingTheory.Ideal.Maps
|
β {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : Semiring S] [inst_2 : Algebra R S] (I : Ideal R),
β x β I, (algebraMap R S) x β Ideal.map (algebraMap R S) I
|
_private.Mathlib.RingTheory.WittVector.TeichmullerSeries.0.WittVector._aux_Mathlib_RingTheory_WittVector_TeichmullerSeries___unexpand_WittVector_1
|
Mathlib.RingTheory.WittVector.TeichmullerSeries
|
Lean.PrettyPrinter.Unexpander
|
Finset.toRight_union
|
Mathlib.Data.Finset.Sum
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {u v : Finset (Ξ± β Ξ²)} [inst : DecidableEq Ξ±] [inst_1 : DecidableEq Ξ²],
(u βͺ v).toRight = u.toRight βͺ v.toRight
|
HasSum.mul_of_nonarchimedean
|
Mathlib.Topology.Algebra.InfiniteSum.Nonarchimedean
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : UniformSpace R] [IsUniformAddGroup R]
[NonarchimedeanRing R] {f : Ξ± β R} {g : Ξ² β R} {a b : R},
HasSum f a β HasSum g b β HasSum (fun i => f i.1 * g i.2) (a * b)
|
Asymptotics.isEquivalent_of_tendsto_one
|
Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : NormedField Ξ²] {u v : Ξ± β Ξ²} {l : Filter Ξ±},
(βαΆ (x : Ξ±) in l, v x = 0 β u x = 0) β Filter.Tendsto (u / v) l (nhds 1) β Asymptotics.IsEquivalent l u v
|
Lean.Compiler.LCNF.CSE.State.noConfusion
|
Lean.Compiler.LCNF.CSE
|
{P : Sort u} β {x1 x2 : Lean.Compiler.LCNF.CSE.State} β x1 = x2 β Lean.Compiler.LCNF.CSE.State.noConfusionType P x1 x2
|
Aesop.Queue.mk._flat_ctor
|
Aesop.Search.Queue.Class
|
{Q : Type} β BaseIO Q β (Q β Array Aesop.GoalRef β BaseIO Q) β (Q β BaseIO (Option Aesop.GoalRef Γ Q)) β Aesop.Queue Q
|
TopologicalSpace.Clopens.coe_inf
|
Mathlib.Topology.Sets.Closeds
|
β {Ξ± : Type u_2} [inst : TopologicalSpace Ξ±] (s t : TopologicalSpace.Clopens Ξ±), β(s β t) = βs β© βt
|
Lean.Elab.Term.StructInst.FieldLHS.fieldIndex.injEq
|
Lean.Elab.StructInst
|
β (ref : Lean.Syntax) (idx : β) (ref_1 : Lean.Syntax) (idx_1 : β),
(Lean.Elab.Term.StructInst.FieldLHS.fieldIndex ref idx = Lean.Elab.Term.StructInst.FieldLHS.fieldIndex ref_1 idx_1) =
(ref = ref_1 β§ idx = idx_1)
|
SimpleGraph.center_top
|
Mathlib.Combinatorics.SimpleGraph.Diam
|
β {Ξ± : Type u_1}, β€.center = Set.univ
|
CategoryTheory.RetractArrow.map_i_left
|
Mathlib.CategoryTheory.Retract
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{X Y Z W : C} {f : X βΆ Y} {g : Z βΆ W} (h : CategoryTheory.RetractArrow f g) (F : CategoryTheory.Functor C D),
(h.map F).i.left = F.map h.i.left
|
_private.Mathlib.Data.Int.Interval.0.Finset.Ioc_succ_succ._simp_1_2
|
Mathlib.Data.Int.Interval
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {s : Finset Ξ±} {a b : Ξ±}, (a β insert b s) = (a = b β¨ a β s)
|
Finset.filter_subset._simp_1
|
Mathlib.Data.Finset.Filter
|
β {Ξ± : Type u_1} (p : Ξ± β Prop) [inst : DecidablePred p] (s : Finset Ξ±), (Finset.filter p s β s) = True
|
SheafOfModules.hom_ext_iff
|
Mathlib.Algebra.Category.ModuleCat.Sheaf
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} {X Y : SheafOfModules R} {f g : X βΆ Y}, f = g β f.val = g.val
|
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α΅α΅α΅
|
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
|
MeasureTheory.LevyProkhorov.levyProkhorovDist_metricSpace_probabilityMeasure._simp_1
|
Mathlib.MeasureTheory.Measure.LevyProkhorovMetric
|
β (x : ENNReal), (x.toReal = 0) = (x = 0 β¨ x = β€)
|
MeasurableSpace.DynkinSystem.instPartialOrder._proof_3
|
Mathlib.MeasureTheory.PiSystem
|
β {Ξ± : Type u_1} (a b : MeasurableSpace.DynkinSystem Ξ±), a β€ b β§ Β¬b β€ a β a β€ b β§ Β¬b β€ a
|
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 β Ξ±
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.