name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
CategoryTheory.Adjunction.Triple.whiskerRight_rightToLeft
|
Mathlib.CategoryTheory.Adjunction.Triple
|
β {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{H : CategoryTheory.Functor C D} (t : CategoryTheory.Adjunction.Triple F G H) [inst_2 : G.Full] [inst_3 : G.Faithful],
CategoryTheory.Functor.whiskerRight t.rightToLeft G = CategoryTheory.CategoryStruct.comp t.adjβ.counit t.adjβ.unit
|
NormedAddCommGroup.ofAddDist'
|
Mathlib.Analysis.Normed.Group.Basic
|
{E : Type u_5} β
[inst : Norm E] β
[inst_1 : AddCommGroup E] β
[inst_2 : MetricSpace E] β
(β (x : E), βxβ = dist x 0) β (β (x y z : E), dist (x + z) (y + z) β€ dist x y) β NormedAddCommGroup E
|
PiLp.continuousLinearEquiv._proof_1
|
Mathlib.Analysis.Normed.Lp.PiLp
|
β (p : ENNReal) {ΞΉ : Type u_1} (Ξ² : ΞΉ β Type u_2) [inst : (i : ΞΉ) β SeminormedAddCommGroup (Ξ² i)],
Continuous WithLp.ofLp
|
_private.Mathlib.RingTheory.Polynomial.Content.0.Polynomial.content_eq_gcd_range_of_lt._simp_1_1
|
Mathlib.RingTheory.Polynomial.Content
|
β {R : Type u} {n : β} [inst : Semiring R] {p : Polynomial R}, (n β p.support) = (p.coeff n β 0)
|
_private.Batteries.Tactic.PrintDependents.0.Batteries.Tactic.CollectDependents.collect.match_1
|
Batteries.Tactic.PrintDependents
|
(motive : Option Bool β Sort u_1) β
(x : Option Bool) β ((b : Bool) β motive (some b)) β ((x : Option Bool) β motive x) β motive x
|
CategoryTheory.Equivalence.instMonoidalInverseTrans
|
Mathlib.CategoryTheory.Monoidal.Functor
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
[inst_1 : CategoryTheory.MonoidalCategory C] β
{D : Type uβ} β
[inst_2 : CategoryTheory.Category.{vβ, uβ} D] β
[inst_3 : CategoryTheory.MonoidalCategory D] β
{E : Type uβ} β
[inst_4 : CategoryTheory.Category.{vβ, uβ} E] β
[inst_5 : CategoryTheory.MonoidalCategory E] β
(e : C β D) β
[e.inverse.Monoidal] β (e' : D β E) β [e'.inverse.Monoidal] β (e.trans e').inverse.Monoidal
|
MvPowerSeries.rescaleUnit
|
Mathlib.RingTheory.PowerSeries.Substitution
|
β {R : Type u_2} [inst : CommRing R] (a : R) (f : PowerSeries R),
(MvPowerSeries.rescale (Function.const Unit a)) f = (PowerSeries.rescale a) f
|
dist_le_of_le_geometric_two_of_tendstoβ
|
Mathlib.Analysis.SpecificLimits.Basic
|
β {Ξ± : Type u_1} [inst : PseudoMetricSpace Ξ±] {C : β} {f : β β Ξ±},
(β (n : β), dist (f n) (f (n + 1)) β€ C / 2 / 2 ^ n) β
β {a : Ξ±}, Filter.Tendsto f Filter.atTop (nhds a) β dist (f 0) a β€ C
|
Ideal.quotientKerAlgEquivOfSurjective._proof_2
|
Mathlib.RingTheory.Ideal.Quotient.Operations
|
β {Rβ : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring Rβ] [inst_1 : Ring A] [inst_2 : Algebra Rβ A]
[inst_3 : Semiring B] [inst_4 : Algebra Rβ B] {f : A ββ[Rβ] B} (hf : Function.Surjective βf),
Function.RightInverse (Classical.choose β―) βf
|
Real.Angle.sin_coe
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle
|
β (x : β), (βx).sin = Real.sin x
|
CategoryTheory.tensorRightHomEquiv._proof_1
|
Mathlib.CategoryTheory.Monoidal.Rigid.Basic
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X Y Y' Z : C) [inst_2 : CategoryTheory.ExactPairing Y Y']
(f : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y βΆ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (Ξ·_ Y Y'))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Y').inv
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y'))))
Y)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Z Y' Y).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z (Ξ΅_ Y Y'))
(CategoryTheory.MonoidalCategoryStruct.rightUnitor Z).hom)) =
f
|
Differentiable.fun_mul
|
Mathlib.Analysis.Calculus.FDeriv.Mul
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {πΈ : Type u_5} [inst_3 : NormedRing πΈ] [inst_4 : NormedAlgebra π πΈ] {a b : E β πΈ},
Differentiable π a β Differentiable π b β Differentiable π fun y => a y * b y
|
TypeVec.dropFun_from_append1_drop_last
|
Mathlib.Data.TypeVec
|
β {n : β} {Ξ± : TypeVec.{u_1} (n + 1)}, TypeVec.dropFun TypeVec.fromAppend1DropLast = TypeVec.id
|
Lean.Elab.Term.getMatchAlt
|
Lean.Elab.Match
|
Lean.Syntax β Option Lean.Elab.Term.MatchAltView
|
SMulWithZero.casesOn
|
Mathlib.Algebra.GroupWithZero.Action.Defs
|
{Mβ : Type u_2} β
{A : Type u_7} β
[inst : Zero Mβ] β
[inst_1 : Zero A] β
{motive : SMulWithZero Mβ A β Sort u} β
(t : SMulWithZero Mβ A) β
([toSMulZeroClass : SMulZeroClass Mβ A] β
(zero_smul : β (m : A), 0 β’ m = 0) β
motive { toSMulZeroClass := toSMulZeroClass, zero_smul := zero_smul }) β
motive t
|
_private.Mathlib.Topology.EMetricSpace.Paracompact.0.EMetric.instParacompactSpace._simp_5
|
Mathlib.Topology.EMetricSpace.Paracompact
|
β {b a : Prop}, (β (_ : a), b) = (a β§ b)
|
Std.TreeSet.Raw.min?_eq_some_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 β β {km : Ξ±}, t.min? = some km β km β t β§ β k β t, (cmp km k).isLE = true
|
Summable.abs
|
Mathlib.Topology.Algebra.InfiniteSum.Order
|
β {ΞΉ : Type u_1} {Ξ± : Type u_3} [inst : AddCommGroup Ξ±] [inst_1 : LinearOrder Ξ±] [IsOrderedAddMonoid Ξ±]
[inst_3 : UniformSpace Ξ±] [IsUniformAddGroup Ξ±] [CompleteSpace Ξ±] {f : ΞΉ β Ξ±}, Summable f β Summable fun x => |f x|
|
Lean.Meta.Grind.EvalTactic
|
Lean.Meta.Tactic.Grind.Types
|
Type
|
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_emod.match_1_1
|
Init.Data.Int.DivMod.Lemmas
|
β (motive : β€ β Prop) (a : β€), (β (a : β), motive (Int.ofNat a)) β (β (a : β), motive (Int.negSucc a)) β motive a
|
CategoryTheory.PreGaloisCategory.GaloisCategory.getFiberFunctor
|
Mathlib.CategoryTheory.Galois.Basic
|
(C : Type uβ) β
[inst : CategoryTheory.Category.{uβ, uβ} C] β [CategoryTheory.GaloisCategory C] β CategoryTheory.Functor C FintypeCat
|
Set.prod_insert
|
Mathlib.Data.Set.Prod
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {s : Set Ξ±} {t : Set Ξ²} {b : Ξ²}, s ΓΛ’ insert b t = (fun a => (a, b)) '' s βͺ s ΓΛ’ t
|
Perfect
|
Mathlib.Topology.Perfect
|
{Ξ± : Type u_1} β [TopologicalSpace Ξ±] β Set Ξ± β Prop
|
groupHomology.chainsMap_f_single
|
Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality
|
β {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep k G} {B : Rep k H} (f : G β* H)
(Ο : A βΆ (Action.res (ModuleCat k) f).obj B) (n : β) (x : Fin n β G) (a : βA.V),
((CategoryTheory.ConcreteCategory.hom ((groupHomology.chainsMap f Ο).f n)) funβ | x => a) =
funβ | βf β x => (CategoryTheory.ConcreteCategory.hom Ο.hom) a
|
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.Β«_aux_Mathlib_MeasureTheory_Function_StronglyMeasurable_Basic___macroRules__private_Mathlib_MeasureTheory_Function_StronglyMeasurable_Basic_0_MeasureTheory_term_ββ__1Β»
|
Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
|
Lean.Macro
|
Finset.image_comm
|
Mathlib.Data.Finset.Image
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} [inst : DecidableEq Ξ²] {s : Finset Ξ±} {Ξ²' : Type u_4}
[inst_1 : DecidableEq Ξ²'] [inst_2 : DecidableEq Ξ³] {f : Ξ² β Ξ³} {g : Ξ± β Ξ²} {f' : Ξ± β Ξ²'} {g' : Ξ²' β Ξ³},
(β (a : Ξ±), f (g a) = g' (f' a)) β Finset.image f (Finset.image g s) = Finset.image g' (Finset.image f' s)
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_le_size
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add
|
β {Ξ± : Type} [inst : Hashable Ξ±] [inst_1 : DecidableEq Ξ±] {w : β} (aig : Std.Sat.AIG Ξ±) (curr : β) (hcurr : curr β€ w)
(cin : aig.Ref) (s : aig.RefVec curr) (lhs rhs : aig.RefVec w),
aig.decls.size β€ (Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go aig lhs rhs curr hcurr cin s).aig.decls.size
|
CategoryTheory.Limits.CategoricalPullback.fst
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
|
{A : Type uβ} β
{B : Type uβ} β
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} A] β
[inst_1 : CategoryTheory.Category.{vβ, uβ} B] β
[inst_2 : CategoryTheory.Category.{vβ, uβ} C] β
{F : CategoryTheory.Functor A B} β
{G : CategoryTheory.Functor C B} β CategoryTheory.Limits.CategoricalPullback F G β A
|
_private.Mathlib.Analysis.Distribution.TemperateGrowth.0.Function.HasTemperateGrowth.sub._proof_1_1
|
Mathlib.Analysis.Distribution.TemperateGrowth
|
β {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup F] {f g : E β F}, f - g = f + -g
|
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.inf_neBot_iff_frequently_left._simp_1_3
|
Mathlib.Order.Filter.Bases.Basic
|
β {a b : Prop}, (a β§ b) = (b β§ a)
|
Projectivization.Independent.mk
|
Mathlib.LinearAlgebra.Projectivization.Independence
|
β {ΞΉ : Type u_1} {K : Type u_2} {V : Type u_3} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(f : ΞΉ β V) (hf : β (i : ΞΉ), f i β 0),
LinearIndependent K f β Projectivization.Independent fun i => Projectivization.mk K (f i) β―
|
Ordinal.CNF_of_le_one
|
Mathlib.SetTheory.Ordinal.CantorNormalForm
|
β {b o : Ordinal.{u_1}}, b β€ 1 β o β 0 β Ordinal.CNF b o = [(0, o)]
|
FloorRing.gc_ceil_coe
|
Mathlib.Algebra.Order.Floor.Defs
|
β {Ξ± : Type u_4} {inst : Ring Ξ±} {inst_1 : LinearOrder Ξ±} [self : FloorRing Ξ±], GaloisConnection FloorRing.ceil Int.cast
|
inner_self_eq_one_of_norm_eq_one
|
Mathlib.Analysis.InnerProductSpace.Basic
|
β {π : Type u_1} {E : Type u_2} [inst : RCLike π] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
{x : E}, βxβ = 1 β inner π x x = 1
|
Lean.Grind.CommRing.Expr.sub.sizeOf_spec
|
Init.Grind.Ring.CommSolver
|
β (a b : Lean.Grind.CommRing.Expr), sizeOf (a.sub b) = 1 + sizeOf a + sizeOf b
|
OreLocalization.instAddGroupOreLocalization._proof_2
|
Mathlib.RingTheory.OreLocalization.Basic
|
β {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddGroup X] [inst_3 : DistribMulAction R X] (a : OreLocalization S X),
OreLocalization.zsmul 0 a = OreLocalization.zsmul 0 a
|
Lean.Meta.Rewrites.RewriteResultConfig.mk._flat_ctor
|
Lean.Meta.Tactic.Rewrites
|
Bool β
β β
β β
Lean.MVarId β
Lean.Expr β Lean.Meta.Rewrites.SideConditions β Lean.MetavarContext β Lean.Meta.Rewrites.RewriteResultConfig
|
_private.Mathlib.RingTheory.PowerSeries.Basic.0.PowerSeries.coeff_one_pow._simp_1_8
|
Mathlib.RingTheory.PowerSeries.Basic
|
β {a b c : Prop}, ((a β¨ b) β¨ c) = (a β¨ b β¨ c)
|
Lean.JsonNumber.instNeg
|
Lean.Data.Json.Basic
|
Neg Lean.JsonNumber
|
Finsupp.span_image_eq_map_linearCombination
|
Mathlib.LinearAlgebra.Finsupp.LinearCombination
|
β {Ξ± : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : Ξ± β M} (s : Set Ξ±),
Submodule.span R (v '' s) = Submodule.map (Finsupp.linearCombination R v) (Finsupp.supported R R s)
|
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.request
|
Lean.Server.ProtocolOverview
|
Lean.Server.Overview.RequestOverviewβ β Lean.Server.Overview.MessageOverviewβ
|
ByteArray.toUInt64BE!
|
Init.Data.ByteArray.Extra
|
ByteArray β UInt64
|
Mathlib.Tactic.ITauto.Proof.orInR
|
Mathlib.Tactic.ITauto
|
Mathlib.Tactic.ITauto.Proof β Mathlib.Tactic.ITauto.Proof
|
Set.finite_iff_bddAbove
|
Mathlib.Order.Interval.Finset.Defs
|
β {Ξ± : Type u_3} {s : Set Ξ±} [inst : SemilatticeSup Ξ±] [LocallyFiniteOrder Ξ±] [OrderBot Ξ±], s.Finite β BddAbove s
|
banach_steinhaus_iSup_nnnorm
|
Mathlib.Analysis.Normed.Operator.BanachSteinhaus
|
β {E : Type u_1} {F : Type u_2} {π : Type u_3} {πβ : Type u_4} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField π] [inst_3 : NontriviallyNormedField πβ]
[inst_4 : NormedSpace π E] [inst_5 : NormedSpace πβ F] {Οββ : π β+* πβ} [inst_6 : RingHomIsometric Οββ] {ΞΉ : Type u_5}
[CompleteSpace E] {g : ΞΉ β E βSL[Οββ] F}, (β (x : E), β¨ i, ββ(g i) xββ < β€) β β¨ i, ββg iββ < β€
|
RootPairing.EmbeddedG2.threeShortAddLongRoot
|
Mathlib.LinearAlgebra.RootSystem.Finite.G2
|
{ΞΉ : Type u_1} β
{R : Type u_2} β
{M : Type u_3} β
{N : Type u_4} β
[inst : CommRing R] β
[inst_1 : AddCommGroup M] β
[inst_2 : Module R M] β
[inst_3 : AddCommGroup N] β [inst_4 : Module R N] β (P : RootPairing ΞΉ R M N) β [P.EmbeddedG2] β M
|
CategoryTheory.Limits.PullbackCone.unopOpIso
|
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
{X Y Z : Cα΅α΅} β {f : X βΆ Z} β {g : Y βΆ Z} β (c : CategoryTheory.Limits.PullbackCone f g) β c.unop.op β
c
|
BoundedContinuousFunction.toContinuousMapβ._proof_4
|
Mathlib.Topology.ContinuousMap.Bounded.Normed
|
β {Ξ± : Type u_1} {Ξ³ : Type u_2} [inst : TopologicalSpace Ξ±] [inst_1 : NormedRing Ξ³]
(x x_1 : BoundedContinuousFunction Ξ± Ξ³), β(x * x_1) = β(x * x_1)
|
Lean.Meta.UnificationConstraint.mk.sizeOf_spec
|
Lean.Meta.UnificationHint
|
β (lhs rhs : Lean.Expr), sizeOf { lhs := lhs, rhs := rhs } = 1 + sizeOf lhs + sizeOf rhs
|
instUniqueEmbOfIsPurelyInseparable._proof_1
|
Mathlib.FieldTheory.PurelyInseparable.Basic
|
β (E : Type u_1) [inst : Field E], IsReduced (AlgebraicClosure E)
|
HomologicalComplex.cylinder.homotopyββ._proof_1
|
Mathlib.Algebra.Homology.HomotopyCofiber
|
β {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {ΞΉ : Type u_1}
{c : ComplexShape ΞΉ} (K : HomologicalComplex C c) [inst_2 : DecidableRel c.Rel]
[inst_3 : β (i : ΞΉ), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)]
[inst_4 :
HomologicalComplex.HasHomotopyCofiber
(CategoryTheory.Limits.biprod.lift (CategoryTheory.CategoryStruct.id K) (-CategoryTheory.CategoryStruct.id K))],
HomologicalComplex.cylinder.ΞΉβ K =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.cylinder.ΞΉβ K)
(CategoryTheory.CategoryStruct.comp (HomologicalComplex.cylinder.Ο K) (HomologicalComplex.cylinder.ΞΉβ K))
|
Lean.Elab.ContextInfo.mk.sizeOf_spec
|
Lean.Elab.InfoTree.Types
|
β (toCommandContextInfo : Lean.Elab.CommandContextInfo) (parentDecl? : Option Lean.Name)
(autoImplicits : Array Lean.Expr),
sizeOf { toCommandContextInfo := toCommandContextInfo, parentDecl? := parentDecl?, autoImplicits := autoImplicits } =
1 + sizeOf toCommandContextInfo + sizeOf parentDecl? + sizeOf autoImplicits
|
sup_inf_left
|
Mathlib.Order.Lattice
|
β {Ξ± : Type u} [inst : DistribLattice Ξ±] (a b c : Ξ±), a β b β c = (a β b) β (a β c)
|
_private.Mathlib.Data.Subtype.0.Subtype.coe_eq_iff._proof_1_1
|
Mathlib.Data.Subtype
|
β {Ξ± : Sort u_1} {p : Ξ± β Prop} {a : { a // p a }} {b : Ξ±}, βa = b β p b
|
OrderMonoidHom.casesOn
|
Mathlib.Algebra.Order.Hom.Monoid
|
{Ξ± : Type u_6} β
{Ξ² : Type u_7} β
[inst : Preorder Ξ±] β
[inst_1 : Preorder Ξ²] β
[inst_2 : MulOneClass Ξ±] β
[inst_3 : MulOneClass Ξ²] β
{motive : (Ξ± β*o Ξ²) β Sort u} β
(t : Ξ± β*o Ξ²) β
((toMonoidHom : Ξ± β* Ξ²) β
(monotone' : Monotone (βtoMonoidHom).toFun) β
motive { toMonoidHom := toMonoidHom, monotone' := monotone' }) β
motive t
|
CategoryTheory.RetractArrow.unop
|
Mathlib.CategoryTheory.Retract
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{X Y Z W : Cα΅α΅} β
{f : X βΆ Y} β {g : Z βΆ W} β CategoryTheory.RetractArrow f g β CategoryTheory.RetractArrow f.unop g.unop
|
Lean.Expr.CollectLooseBVars.State.bvars._default
|
Lean.Util.CollectLooseBVars
|
Std.HashSet β
|
Array.insertIdx_comm._proof_5
|
Init.Data.Array.InsertIdx
|
β {Ξ± : Type u_1} (b : Ξ±) {i j : β} {xs : Array Ξ±}, i β€ j β β (x : j β€ xs.size), i β€ (xs.insertIdx j b x).size
|
HomotopicalAlgebra.ModelCategory.instIsWeakFactorizationSystemTrivialCofibrationsFibrations
|
Mathlib.AlgebraicTopology.ModelCategory.Basic
|
β (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.trivialCofibrations C).IsWeakFactorizationSystem (HomotopicalAlgebra.fibrations C)
|
Aesop.instInhabitedSubstitution
|
Aesop.Forward.Substitution
|
Inhabited Aesop.Substitution
|
_private.Mathlib.RingTheory.SimpleRing.Field.0.IsSimpleRing.isField_center._simp_1_4
|
Mathlib.RingTheory.SimpleRing.Field
|
β {Ξ± : Type u} {ΞΉ : Sort u_1} {f : ΞΉ β Ξ±} {x : Ξ±}, (x β Set.range f) = β y, f y = x
|
CategoryTheory.Endofunctor.Coalgebra.Hom.comp._proof_2
|
Mathlib.CategoryTheory.Endofunctor.Algebra
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C C}
{Vβ Vβ Vβ : CategoryTheory.Endofunctor.Coalgebra F} (f : Vβ.Hom Vβ) (g : Vβ.Hom Vβ),
CategoryTheory.CategoryStruct.comp Vβ.str (F.map (CategoryTheory.CategoryStruct.comp f.f g.f)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f.f g.f) Vβ.str
|
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.IsLocal.mem_jacobson_or_exists_inv.match_1_1
|
Mathlib.RingTheory.Jacobson.Ideal
|
β {R : Type u_1} [inst : CommRing R] (x q : R) (motive : x β£ q β Prop) (x_1 : x β£ q),
(β (r : R) (hr : q = x * r), motive β―) β motive x_1
|
HomotopicalAlgebra.PrepathObject.ΞΉ_pβ_assoc
|
Mathlib.AlgebraicTopology.ModelCategory.PathObject
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (self : HomotopicalAlgebra.PrepathObject A) {Z : C}
(h : A βΆ Z), CategoryTheory.CategoryStruct.comp self.ΞΉ (CategoryTheory.CategoryStruct.comp self.pβ h) = h
|
Algebra.Generators.cotangentCompLocalizationAwayEquiv_symm_comp_inl
|
Mathlib.RingTheory.Extension.Cotangent.LocalizationAway
|
β {R : Type u_1} {S : Type u_2} {T : Type u_3} {ΞΉ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T]
[inst_6 : IsScalarTower R S T] (g : S) [inst_7 : IsLocalization.Away g T] (P : Algebra.Generators R S ΞΉ)
{x : ((Algebra.Generators.localizationAway T g).comp P).toExtension.Cotangent}
(hx :
(Algebra.Extension.Cotangent.map ((Algebra.Generators.localizationAway T g).ofComp P).toExtensionHom) x =
Algebra.Generators.cMulXSubOneCotangent T g),
β(Algebra.Generators.cotangentCompLocalizationAwayEquiv g P hx).symm ββ
LinearMap.inl T (TensorProduct S T P.toExtension.Cotangent)
(Algebra.Generators.localizationAway T g).toExtension.Cotangent =
LinearMap.liftBaseChange T
(Algebra.Extension.Cotangent.map ((Algebra.Generators.localizationAway T g).toComp P).toExtensionHom)
|
DirichletCharacter.unit_norm_eq_one
|
Mathlib.NumberTheory.DirichletCharacter.Bounds
|
β {F : Type u_1} [inst : NormedField F] {n : β} (Ο : DirichletCharacter F n) (a : (ZMod n)Λ£), βΟ βaβ = 1
|
IsAlgClosed.roots_eq_zero_iff
|
Mathlib.FieldTheory.IsAlgClosed.Basic
|
β {k : Type u} [inst : Field k] [IsAlgClosed k] {p : Polynomial k}, p.roots = 0 β p = Polynomial.C (p.coeff 0)
|
_private.Mathlib.Data.Finset.Prod.0.Finset.product_image_snd._simp_1_1
|
Mathlib.Data.Finset.Prod
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : DecidableEq Ξ²] {f : Ξ± β Ξ²} {s : Finset Ξ±} {b : Ξ²},
(b β Finset.image f s) = β a β s, f a = b
|
Lean.Meta.Ext.ExtTheorems.erased
|
Lean.Meta.Tactic.Ext
|
Lean.Meta.Ext.ExtTheorems β Lean.PHashSet Lean.Name
|
Ideal.radical_minimalPrimes
|
Mathlib.RingTheory.Ideal.MinimalPrime.Basic
|
β {R : Type u_1} [inst : CommSemiring R] {I : Ideal R}, I.radical.minimalPrimes = I.minimalPrimes
|
AddSubgroup.quotientEquivProdOfLE
|
Mathlib.GroupTheory.Coset.Basic
|
{Ξ± : Type u_1} β [inst : AddGroup Ξ±] β {s t : AddSubgroup Ξ±} β s β€ t β Ξ± β§Έ s β (Ξ± β§Έ t) Γ β₯t β§Έ s.addSubgroupOf t
|
Set.Subsingleton.isDiscrete
|
Mathlib.Topology.DiscreteSubset
|
β {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, s.Subsingleton β IsDiscrete s
|
_private.Mathlib.Topology.Order.IntermediateValue.0.isTotallyDisconnected_iff_lt._simp_1_2
|
Mathlib.Topology.Order.IntermediateValue
|
β {Ξ± : Type u} [inst : ConditionallyCompleteLinearOrder Ξ±] [inst_1 : TopologicalSpace Ξ±] [OrderTopology Ξ±]
[DenselyOrdered Ξ±] {s : Set Ξ±}, IsPreconnected s = s.OrdConnected
|
_private.Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular.0.Matrix.IsTotallyUnimodular.fromRows_unitlike._simp_1_1
|
Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {x : Ξ± β Ξ²}, (β y, x = Sum.inr y) = (x.isRight = true)
|
Mathlib.Tactic.Widget.StringDiagram.Node.rec
|
Mathlib.Tactic.Widget.StringDiagram
|
{motive : Mathlib.Tactic.Widget.StringDiagram.Node β Sort u} β
((a : Mathlib.Tactic.Widget.StringDiagram.AtomNode) β motive (Mathlib.Tactic.Widget.StringDiagram.Node.atom a)) β
((a : Mathlib.Tactic.Widget.StringDiagram.IdNode) β motive (Mathlib.Tactic.Widget.StringDiagram.Node.id a)) β
(t : Mathlib.Tactic.Widget.StringDiagram.Node) β motive t
|
Lean.Compiler.LCNF.Code.unreach.injEq
|
Lean.Compiler.LCNF.Basic
|
β (type type_1 : Lean.Expr),
(Lean.Compiler.LCNF.Code.unreach type = Lean.Compiler.LCNF.Code.unreach type_1) = (type = type_1)
|
RelIso.sumLexCongr._proof_1
|
Mathlib.Order.RelIso.Basic
|
β {Ξ±β : Type u_3} {Ξ±β : Type u_4} {Ξ²β : Type u_1} {Ξ²β : Type u_2} {rβ : Ξ±β β Ξ±β β Prop} {rβ : Ξ±β β Ξ±β β Prop}
{sβ : Ξ²β β Ξ²β β Prop} {sβ : Ξ²β β Ξ²β β Prop} (eβ : rβ βr sβ) (eβ : rβ βr sβ) (a b : Ξ±β β Ξ±β),
Sum.Lex sβ sβ ((eβ.sumCongr eβ.toEquiv) a) ((eβ.sumCongr eβ.toEquiv) b) β Sum.Lex rβ rβ a b
|
MulAction.mem_fixedPoints'
|
Mathlib.GroupTheory.GroupAction.Defs
|
β {M : Type u_1} {Ξ± : Type u_3} [inst : Monoid M] [inst_1 : MulAction M Ξ±] {a : Ξ±},
a β MulAction.fixedPoints M Ξ± β β a' β MulAction.orbit M a, a' = a
|
_private.Mathlib.Topology.Algebra.InfiniteSum.Basic.0.hasProd_prod._simp_1_5
|
Mathlib.Topology.Algebra.InfiniteSum.Basic
|
(Β¬False) = True
|
Algebra.Extension.cotangentEquiv._proof_4
|
Mathlib.RingTheory.Extension.Basic
|
β {S : Type u_1} [inst : CommRing S], RingHomInvPair (RingHom.id S) (RingHom.id S)
|
SimpleGraph.Subgraph.IsInduced
|
Mathlib.Combinatorics.SimpleGraph.Subgraph
|
{V : Type u} β {G : SimpleGraph V} β G.Subgraph β Prop
|
Std.DTreeMap.Internal.Zipper.toList
|
Std.Data.DTreeMap.Internal.Zipper
|
{Ξ± : Type u} β {Ξ² : Ξ± β Type v} β Std.DTreeMap.Internal.Zipper Ξ± Ξ² β List ((a : Ξ±) Γ Ξ² a)
|
MeromorphicOn.divisor_fun_mul
|
Mathlib.Analysis.Meromorphic.Divisor
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {U : Set π} {fβ fβ : π β π},
MeromorphicOn fβ U β
MeromorphicOn fβ U β
(β z β U, meromorphicOrderAt fβ z β β€) β
(β z β U, meromorphicOrderAt fβ z β β€) β
MeromorphicOn.divisor (fun z => fβ z * fβ z) U = MeromorphicOn.divisor fβ U + MeromorphicOn.divisor fβ U
|
Rat.num_natCast
|
Init.Data.Rat.Lemmas
|
β (n : β), (βn).num = βn
|
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.isDershowitzMannaLT_of_transGen_oneStep
|
Mathlib.Data.Multiset.DershowitzManna
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {M N : Multiset Ξ±},
Relation.TransGen Multiset.OneStepβ M N β M.IsDershowitzMannaLT N
|
MeasureTheory.SimpleFunc.piecewise_univ
|
Mathlib.MeasureTheory.Function.SimpleFunc
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : MeasurableSpace Ξ±] (f g : MeasureTheory.SimpleFunc Ξ± Ξ²),
MeasureTheory.SimpleFunc.piecewise Set.univ β― f g = f
|
Std.DHashMap.Raw.get!_alter
|
Std.Data.DHashMap.RawLemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {m : Std.DHashMap.Raw Ξ± Ξ²} [inst_2 : LawfulBEq Ξ±]
{k k' : Ξ±} [hi : Inhabited (Ξ² k')] {f : Option (Ξ² k) β Option (Ξ² k)},
m.WF β (m.alter k f).get! k' = if heq : (k == k') = true then (Option.map (cast β―) (f (m.get? k))).get! else m.get! k'
|
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_5
|
Std.Data.DTreeMap.Internal.Operations
|
Β¬0 β€ 0 + 1 β False
|
AffineIsometryEquiv.coe_mk'
|
Mathlib.Analysis.Normed.Affine.Isometry
|
β {π : Type u_1} {Vβ : Type u_3} {Vβ : Type u_5} {Pβ : Type u_8} {Pβ : Type u_11} [inst : NormedField π]
[inst_1 : SeminormedAddCommGroup Vβ] [inst_2 : NormedSpace π Vβ] [inst_3 : PseudoMetricSpace Pβ]
[inst_4 : NormedAddTorsor Vβ Pβ] [inst_5 : SeminormedAddCommGroup Vβ] [inst_6 : NormedSpace π Vβ]
[inst_7 : PseudoMetricSpace Pβ] [inst_8 : NormedAddTorsor Vβ Pβ] (e : Pβ β Pβ) (e' : Vβ ββα΅’[π] Vβ) (p : Pβ)
(h : β (p' : Pβ), e p' = e' (p' -α΅₯ p) +α΅₯ e p), β(AffineIsometryEquiv.mk' e e' p h) = e
|
CategoryTheory.Limits.WalkingReflexivePair.rec
|
Mathlib.CategoryTheory.Limits.Shapes.Reflexive
|
{motive : CategoryTheory.Limits.WalkingReflexivePair β Sort u} β
motive CategoryTheory.Limits.WalkingReflexivePair.zero β
motive CategoryTheory.Limits.WalkingReflexivePair.one β (t : CategoryTheory.Limits.WalkingReflexivePair) β motive t
|
Std.HashSet.Raw.noConfusion
|
Std.Data.HashSet.Raw
|
{P : Sort u_1} β
{Ξ± : Type u} β
{t : Std.HashSet.Raw Ξ±} β
{Ξ±' : Type u} β {t' : Std.HashSet.Raw Ξ±'} β Ξ± = Ξ±' β t β t' β Std.HashSet.Raw.noConfusionType P t t'
|
Nat.sq_mul_squarefree_of_pos'
|
Mathlib.Data.Nat.Squarefree
|
β {n : β}, 0 < n β β a b, (b + 1) ^ 2 * (a + 1) = n β§ Squarefree (a + 1)
|
Bialgebra.TensorProduct.assoc._proof_4
|
Mathlib.RingTheory.Bialgebra.TensorProduct
|
β (R : Type u_1) (S : Type u_5) (A : Type u_3) (C : Type u_2) (D : Type u_4) [inst : CommSemiring R]
[inst_1 : CommSemiring S] [inst_2 : Semiring A] [inst_3 : Bialgebra S A] [inst_4 : Algebra R A] [inst_5 : Algebra R S]
[inst_6 : IsScalarTower R S A] [inst_7 : Semiring C] [inst_8 : Semiring D] [inst_9 : Bialgebra S C]
[inst_10 : Bialgebra R D] [inst_11 : Algebra R C] [inst_12 : IsScalarTower R S C]
(x y : TensorProduct R (TensorProduct S A C) D),
(Algebra.TensorProduct.assoc R S A C D).toFun (x * y) =
(Algebra.TensorProduct.assoc R S A C D).toFun x * (Algebra.TensorProduct.assoc R S A C D).toFun y
|
BoxIntegral.TaggedPrepartition.distortion_le_of_mem
|
Mathlib.Analysis.BoxIntegral.Partition.Tagged
|
β {ΞΉ : Type u_1} {I J : BoxIntegral.Box ΞΉ} (Ο : BoxIntegral.TaggedPrepartition I) [inst : Fintype ΞΉ],
J β Ο β J.distortion β€ Ο.distortion
|
instZeroLieSubalgebra
|
Mathlib.Algebra.Lie.Subalgebra
|
(R : Type u) β
(L : Type v) β [inst : CommRing R] β [inst_1 : LieRing L] β [inst_2 : LieAlgebra R L] β Zero (LieSubalgebra R L)
|
CategoryTheory.Limits.WalkingReflexivePair.Hom.rightCompReflexion.elim
|
Mathlib.CategoryTheory.Limits.Shapes.Reflexive
|
{motive : (a a_1 : CategoryTheory.Limits.WalkingReflexivePair) β a.Hom a_1 β Sort u} β
{a a_1 : CategoryTheory.Limits.WalkingReflexivePair} β
(t : a.Hom a_1) β
t.ctorIdx = 4 β
motive CategoryTheory.Limits.WalkingReflexivePair.one CategoryTheory.Limits.WalkingReflexivePair.one
CategoryTheory.Limits.WalkingReflexivePair.Hom.rightCompReflexion β
motive a a_1 t
|
CategoryTheory.Functor.LeftExtension.postcomposeβ_obj_hom_app
|
Mathlib.CategoryTheory.Functor.KanExtension.Basic
|
β {C : Type u_1} {H : Type u_3} {D : Type u_4} {D' : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
[inst_3 : CategoryTheory.Category.{v_5, u_5} D'] (L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H)
(G : CategoryTheory.Functor H D')
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit F) ((CategoryTheory.Functor.whiskeringLeft C D H).obj L))
(X_1 : C), ((CategoryTheory.Functor.LeftExtension.postcomposeβ L F G).obj X).hom.app X_1 = G.map (X.hom.app X_1)
|
Fin.reduceCastLT._regBuiltin.Fin.reduceCastLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.3768712919._hygCtx._hyg.16
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin
|
IO Unit
|
_private.Lean.Elab.Print.0.Lean.Elab.Command.levelParamsToMessageData
|
Lean.Elab.Print
|
List Lean.Name β Lean.MessageData
|
Mathlib.Tactic.Bicategory.structuralIsoOfExpr_whiskerRight
|
Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes
|
β {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g : a βΆ b} (h : b βΆ c) (Ξ· : f βΆ g) (Ξ·' : f β
g),
Ξ·'.hom = Ξ· β (CategoryTheory.Bicategory.whiskerRightIso Ξ·' h).hom = CategoryTheory.Bicategory.whiskerRight Ξ· h
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.