name
string | module
string | type
string |
|---|---|---|
CategoryTheory.Pretriangulated.invRotateIsoRotateRotateShiftFunctorNegOne
|
Mathlib.CategoryTheory.Triangulated.TriangleShift
|
(C : Type u) β
[inst : CategoryTheory.Category.{v, u} C] β
[inst_1 : CategoryTheory.Preadditive C] β
[inst_2 : CategoryTheory.HasShift C β€] β
[β (n : β€), (CategoryTheory.shiftFunctor C n).Additive] β
CategoryTheory.Pretriangulated.invRotate C β
(CategoryTheory.Pretriangulated.rotate C).comp
((CategoryTheory.Pretriangulated.rotate C).comp
(CategoryTheory.Pretriangulated.Triangle.shiftFunctor C (-1)))
|
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle.0.CochainComplex.HomComplex.Cochain.Ξ΄_fromSingleMk._proof_1_3
|
Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle
|
β {p q n : β€}, p + n = q β β (n' q' : β€), p + n' = q' β Β¬q + 1 = q' β Β¬n + 1 = n'
|
_private.Mathlib.Topology.Instances.AddCircle.DenseSubgroup.0.dense_addSubgroupClosure_pair_iff._simp_1_8
|
Mathlib.Topology.Instances.AddCircle.DenseSubgroup
|
β {Gβ : Type u_3} [inst : GroupWithZero Gβ] {a : Gβ} (n : β€), a β 0 β (a ^ n = 0) = False
|
ContinuousAlternatingMap.piLinearEquiv._proof_4
|
Mathlib.Topology.Algebra.Module.Alternating.Basic
|
β {A : Type u_1} {M : Type u_2} {ΞΉ : Type u_4} [inst : Semiring A] [inst_1 : AddCommMonoid M]
[inst_2 : TopologicalSpace M] [inst_3 : Module A M] {ΞΉ' : Type u_5} {M' : ΞΉ' β Type u_3}
[inst_4 : (i : ΞΉ') β AddCommMonoid (M' i)] [inst_5 : (i : ΞΉ') β TopologicalSpace (M' i)]
[inst_6 : β (i : ΞΉ'), ContinuousAdd (M' i)] [inst_7 : (i : ΞΉ') β Module A (M' i)]
(x x_1 : (i : ΞΉ') β M [β^ΞΉ]βL[A] M' i),
ContinuousAlternatingMap.piEquiv.toFun (x + x_1) = ContinuousAlternatingMap.piEquiv.toFun (x + x_1)
|
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStripββ'._simp_1_6
|
Mathlib.Analysis.Complex.Hadamard
|
β {Ξ± : Type u} {Ξ² : Type v} (f : Ξ± β Ξ²) (s : Set Ξ±) (y : Ξ²), (y β f '' s) = β x β s, f x = y
|
BiheytingHom.comp_apply
|
Mathlib.Order.Heyting.Hom
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} {Ξ³ : Type u_4} [inst : BiheytingAlgebra Ξ±] [inst_1 : BiheytingAlgebra Ξ²]
[inst_2 : BiheytingAlgebra Ξ³] (f : BiheytingHom Ξ² Ξ³) (g : BiheytingHom Ξ± Ξ²) (a : Ξ±), (f.comp g) a = f (g a)
|
ValuativeRel.IsRankLeOne
|
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
|
(R : Type u_1) β [inst : CommRing R] β [ValuativeRel R] β Prop
|
QuadraticMap.Isometry.proj_apply
|
Mathlib.LinearAlgebra.QuadraticForm.Prod
|
β {ΞΉ : Type u_1} {R : Type u_2} {P : Type u_7} {Mα΅’ : ΞΉ β Type u_8} [inst : CommSemiring R]
[inst_1 : (i : ΞΉ) β AddCommMonoid (Mα΅’ i)] [inst_2 : AddCommMonoid P] [inst_3 : (i : ΞΉ) β Module R (Mα΅’ i)]
[inst_4 : Module R P] [inst_5 : Fintype ΞΉ] [inst_6 : DecidableEq ΞΉ] (i : ΞΉ) (Q : QuadraticMap R (Mα΅’ i) P)
(f : (x : ΞΉ) β Mα΅’ x), (QuadraticMap.Isometry.proj i Q) f = f i
|
_private.Aesop.Tree.AddRapp.0.Aesop.copyGoals.match_1
|
Aesop.Tree.AddRapp
|
(motive : Aesop.ForwardState Γ Array Aesop.ForwardRuleMatch β Sort u_1) β
(__discr : Aesop.ForwardState Γ Array Aesop.ForwardRuleMatch) β
((forwardState : Aesop.ForwardState) β (ms : Array Aesop.ForwardRuleMatch) β motive (forwardState, ms)) β
motive __discr
|
BitVec.setWidth_eq_append_extractLsb'
|
Init.Data.BitVec.Lemmas
|
β {v : β} {x : BitVec v} {w : β}, BitVec.setWidth w x = BitVec.cast β― (0#(w - v) ++ BitVec.extractLsb' 0 (min v w) x)
|
List.Nodup.product
|
Mathlib.Data.List.Nodup
|
β {Ξ± : Type u} {Ξ² : Type v} {lβ : List Ξ±} {lβ : List Ξ²}, lβ.Nodup β lβ.Nodup β (lβ ΓΛ’ lβ).Nodup
|
LinearMap.BilinForm.IsAlt.ortho_comm
|
Mathlib.LinearAlgebra.BilinearForm.Orthogonal
|
β {Rβ : Type u_3} {Mβ : Type u_4} [inst : CommRing Rβ] [inst_1 : AddCommGroup Mβ] [inst_2 : Module Rβ Mβ]
{Bβ : LinearMap.BilinForm Rβ Mβ}, Bβ.IsAlt β β {x y : Mβ}, Bβ.IsOrtho x y β Bβ.IsOrtho y x
|
BoundedContinuousFunction.toContinuousMapAddHom
|
Mathlib.Topology.ContinuousMap.Bounded.Basic
|
(Ξ± : Type u) β
(R : Type u_2) β
[inst : TopologicalSpace Ξ±] β
[inst_1 : PseudoMetricSpace R] β
[inst_2 : AddMonoid R] β
[inst_3 : BoundedAdd R] β [inst_4 : ContinuousAdd R] β BoundedContinuousFunction Ξ± R β+ C(Ξ±, R)
|
CategoryTheory.BiconeHom.decidableEq._proof_4
|
Mathlib.CategoryTheory.Limits.Bicones
|
β (J : Type u_1) (j : J),
CategoryTheory.Bicone.left = CategoryTheory.Bicone.diagram j β
Bool.rec False True (CategoryTheory.Bicone.left.ctorIdx.beq (CategoryTheory.Bicone.diagram j).ctorIdx)
|
_private.Init.Data.SInt.Lemmas.0.Int64.lt_or_lt_of_ne._simp_1_2
|
Init.Data.SInt.Lemmas
|
β {x y : Int64}, (x = y) = (x.toInt = y.toInt)
|
CategoryTheory.ULiftHom.equiv._proof_1
|
Mathlib.CategoryTheory.Category.ULift
|
β {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (x : C),
(CategoryTheory.Functor.id C).obj x = (CategoryTheory.Functor.id C).obj x
|
_private.Mathlib.CategoryTheory.Limits.IndYoneda.0.CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_Ο._simp_1_2
|
Mathlib.CategoryTheory.Limits.IndYoneda
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X βΆ Y) (g : Y βΆ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g)
|
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.Split.generalizeMatchPropDiscrs.match_3
|
Lean.Meta.Tactic.Split
|
(motive : MProd (Array Lean.Expr) Lean.MVarId β Sort u_1) β
(r : MProd (Array Lean.Expr) Lean.MVarId) β
((discrs' : Array Lean.Expr) β (mvarId : Lean.MVarId) β motive β¨discrs', mvarIdβ©) β motive r
|
_private.Batteries.Tactic.Trans.0.Batteries.Tactic._aux_Batteries_Tactic_Trans___elabRules_Batteries_Tactic_tacticTrans____1.match_1
|
Batteries.Tactic.Trans
|
(motive : Option (Lean.Expr Γ List Lean.MVarId) β Sort u_1) β
(t'? : Option (Lean.Expr Γ List Lean.MVarId)) β
((fst : Lean.Expr) β (gs' : List Lean.MVarId) β motive (some (fst, gs'))) β
((x : Option (Lean.Expr Γ List Lean.MVarId)) β motive x) β motive t'?
|
Lean.Parser.ModuleParserState.noConfusionType
|
Lean.Parser.Module
|
Sort u β Lean.Parser.ModuleParserState β Lean.Parser.ModuleParserState β Sort u
|
Submodule.mem_span_set'
|
Mathlib.LinearAlgebra.Finsupp.LinearCombination
|
β {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : M}
{s : Set M}, m β Submodule.span R s β β n f g, β i, f i β’ β(g i) = m
|
Std.Do.Spec.pure
|
Std.Do.Triple.SpecLemmas
|
β {m : Type u β Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps] {Ξ± : Type u} {a : Ξ±}
{Q : Std.Do.PostCond Ξ± ps}, β¦Q.1 aβ¦ pure a β¦Qβ¦
|
MulOpposite.instNatCast
|
Mathlib.Algebra.Ring.Opposite
|
{R : Type u_1} β [NatCast R] β NatCast Rα΅α΅α΅
|
Lean.Elab.DelabTermInfo.noConfusionType
|
Lean.Elab.InfoTree.Types
|
Sort u β Lean.Elab.DelabTermInfo β Lean.Elab.DelabTermInfo β Sort u
|
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq.0.Lean.Meta.Grind.Arith.Linear.updateDiseqs
|
Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq
|
β€ β
Lean.Grind.Linarith.Var β
Lean.Meta.Grind.Arith.Linear.EqCnstr β Lean.Grind.Linarith.Var β Lean.Meta.Grind.Arith.Linear.LinearM Unit
|
_private.Mathlib.Topology.Order.MonotoneContinuity.0.continuousWithinAt_left_of_monotoneOn_of_exists_between.match_1_1
|
Mathlib.Topology.Order.MonotoneContinuity
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : LinearOrder Ξ²] {f : Ξ± β Ξ²} {s : Set Ξ±} {a : Ξ±} (b : Ξ²α΅α΅)
(motive : (β c β s, f c β Set.Ioo b (f a)) β Prop) (x : β c β s, f c β Set.Ioo b (f a)),
(β (c : Ξ±) (hcs : c β s) (hcb : b < f c) (hca : f c < f a), motive β―) β motive x
|
Batteries.BinomialHeap.Imp.Heap.merge._unary._proof_3
|
Batteries.Data.BinomialHeap.Basic
|
β {Ξ± : Type u_1} (sβ : Batteries.BinomialHeap.Imp.Heap Ξ±) (rβ : β) (aβ : Ξ±) (nβ : Batteries.BinomialHeap.Imp.HeapNode Ξ±)
(tβ : Batteries.BinomialHeap.Imp.Heap Ξ±) (h : sβ = Batteries.BinomialHeap.Imp.Heap.cons rβ aβ nβ tβ)
(sβ : Batteries.BinomialHeap.Imp.Heap Ξ±) (rβ : β) (aβ : Ξ±) (nβ : Batteries.BinomialHeap.Imp.HeapNode Ξ±)
(tβ : Batteries.BinomialHeap.Imp.Heap Ξ±) (h_1 : sβ = Batteries.BinomialHeap.Imp.Heap.cons rβ aβ nβ tβ),
(invImage (fun x => PSigma.casesOn x fun a a_1 => a.length + a_1.length) sizeOfWFRel).1 β¨sβ, tββ©
β¨namedPattern sβ (Batteries.BinomialHeap.Imp.Heap.cons rβ aβ nβ tβ) h,
namedPattern sβ (Batteries.BinomialHeap.Imp.Heap.cons rβ aβ nβ tβ) h_1β©
|
_private.Mathlib.Algebra.Ring.SumsOfSquares.0.Subsemiring.closure_isSquare._simp_1_1
|
Mathlib.Algebra.Ring.SumsOfSquares
|
β {T : Type u_2} [inst : CommSemiring T], Subsemiring.closure {x | IsSquare x} = (Submonoid.square T).subsemiringClosure
|
AffineEquiv.linearHom._proof_2
|
Mathlib.LinearAlgebra.AffineSpace.AffineEquiv
|
β {k : Type u_1} {Pβ : Type u_2} {Vβ : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup Vβ] [inst_2 : Module k Vβ]
[inst_3 : AddTorsor Vβ Pβ] (x x_1 : Pβ βα΅[k] Pβ), (x * x_1).linear = (x * x_1).linear
|
Mathlib.Tactic.CC.CCNormalizer.rec
|
Mathlib.Tactic.CC.Datatypes
|
{motive : Mathlib.Tactic.CC.CCNormalizer β Sort u} β
((normalize : Lean.Expr β Lean.MetaM Lean.Expr) β motive { normalize := normalize }) β
(t : Mathlib.Tactic.CC.CCNormalizer) β motive t
|
Lean.AddErrorMessageContext.casesOn
|
Lean.Exception
|
{m : Type β Type} β
{motive : Lean.AddErrorMessageContext m β Sort u} β
(t : Lean.AddErrorMessageContext m) β
((add : Lean.Syntax β Lean.MessageData β m (Lean.Syntax Γ Lean.MessageData)) β motive { add := add }) β motive t
|
Pi.constRingHom._proof_4
|
Mathlib.Algebra.Ring.Pi
|
β (Ξ± : Type u_1) (Ξ² : Type u_2) [inst : NonAssocSemiring Ξ²] (x y : Ξ²),
(ββ(Pi.ringHom fun x => RingHom.id Ξ²)).toFun (x + y) =
(ββ(Pi.ringHom fun x => RingHom.id Ξ²)).toFun x + (ββ(Pi.ringHom fun x => RingHom.id Ξ²)).toFun y
|
InfHom.dual._proof_3
|
Mathlib.Order.Hom.Lattice
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Min Ξ±] [inst_1 : Min Ξ²] (x : InfHom Ξ± Ξ²),
{ toFun := β{ toFun := βx, map_sup' := β― }, map_inf' := β― } =
{ toFun := β{ toFun := βx, map_sup' := β― }, map_inf' := β― }
|
_private.Mathlib.Data.List.Nodup.0.List.Nodup.ne_singleton_iff._simp_1_2
|
Mathlib.Data.List.Nodup
|
β {a b c : Prop}, (a β§ (b β¨ c)) = (a β§ b β¨ a β§ c)
|
CochainComplex.shiftEval_inv_app
|
Mathlib.Algebra.Homology.HomotopyCategory.Shift
|
β (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n i i' : β€)
(hi : n + i = i') (X : CochainComplex C β€),
(CochainComplex.shiftEval C n i i' hi).inv.app X = (HomologicalComplex.XIsoOfEq X β―).inv
|
NonUnitalStarAlgHom.codRestrict._proof_1
|
Mathlib.Algebra.Star.NonUnitalSubalgebra
|
β {F : Type u_4} {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R]
[inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : Module R B] [inst_6 : Star B] [inst_7 : FunLike F A B] [inst_8 : NonUnitalAlgHomClass F R A B]
[StarHomClass F A B] (f : F) (S : NonUnitalStarSubalgebra R B) (hf : β (x : A), f x β S) (a : A),
(NonUnitalAlgHom.codRestrict f S.toNonUnitalSubalgebra hf).toFun (star a) =
star ((NonUnitalAlgHom.codRestrict f S.toNonUnitalSubalgebra hf).toFun a)
|
BitVec.ofNat_sub_ofNat_of_le
|
Init.Data.BitVec.Lemmas
|
β {w : β} (x y : β), y < 2 ^ w β y β€ x β BitVec.ofNat w x - BitVec.ofNat w y = BitVec.ofNat w (x - y)
|
Algebra.mem_adjoin_of_map_mul
|
Mathlib.Algebra.Algebra.Subalgebra.Lattice
|
β (R : Type uR) {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {s : Set A} {x : A} {f : A ββ[R] B},
(β (aβ aβ : A), f (aβ * aβ) = f aβ * f aβ) β x β Algebra.adjoin R s β f x β Algebra.adjoin R (βf '' (s βͺ {1}))
|
ContinuousMap.HomotopyWith.instFunLike
|
Mathlib.Topology.Homotopy.Basic
|
{X : Type u} β
{Y : Type v} β
[inst : TopologicalSpace X] β
[inst_1 : TopologicalSpace Y] β
{fβ fβ : C(X, Y)} β {P : C(X, Y) β Prop} β FunLike (fβ.HomotopyWith fβ P) (βunitInterval Γ X) Y
|
Matrix.replicateCol_zero
|
Mathlib.LinearAlgebra.Matrix.RowCol
|
β {m : Type u_2} {Ξ± : Type v} {ΞΉ : Type u_6} [inst : Zero Ξ±], Matrix.replicateCol ΞΉ 0 = 0
|
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith.disjoint_iff_ne._simp_1_6
|
Mathlib.GroupTheory.FreeGroup.Orbit
|
β {a b : Prop}, (Β¬(a β§ b)) = (a β Β¬b)
|
FirstOrder.Language.Hom.homClass
|
Mathlib.ModelTheory.Basic
|
β {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N],
L.HomClass (L.Hom M N) M N
|
MonCat.Colimits.monoidColimitType._proof_1
|
Mathlib.Algebra.Category.MonCat.Colimits
|
β {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat)
(x x' : MonCat.Colimits.Prequotient F),
x β x' β β (y x_1 : MonCat.Colimits.Prequotient F), y β x_1 β x.mul y β x'.mul x_1
|
Thunk.fn
|
Init.Core
|
{Ξ± : Type u} β Thunk Ξ± β Unit β Ξ±
|
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.counitIso._proof_1
|
Mathlib.CategoryTheory.Monoidal.CommMon_
|
β (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (F : CategoryTheory.CommMon C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one (CategoryTheory.CategoryStruct.id F.X))
(CategoryTheory.CategoryStruct.id F.X) =
CategoryTheory.MonObj.one
|
_private.Mathlib.Combinatorics.Derangements.Finite.0.card_derangements_fin_eq_numDerangements._proof_1_1
|
Mathlib.Combinatorics.Derangements.Finite
|
β (n : β), (β m < n + 1 + 1, Fintype.card β(derangements (Fin m)) = numDerangements m) β n + 1 < n + 1 + 1
|
PFunctor.W
|
Mathlib.Data.PFunctor.Univariate.Basic
|
PFunctor.{uA, uB} β Type (max uA uB)
|
_private.Mathlib.Topology.Filter.0.Filter.sInter_nhds._simp_1_1
|
Mathlib.Topology.Filter
|
β {Ξ± : Type u} {s : Set Ξ±} {f : Filter Ξ±}, (f β€ Filter.principal s) = (s β f)
|
CategoryTheory.LocalizerMorphism.LeftResolution.Hom.ext_iff
|
Mathlib.CategoryTheory.Localization.Resolution
|
β {Cβ : Type u_1} {Cβ : Type u_2} {inst : CategoryTheory.Category.{u_5, u_1} Cβ}
{inst_1 : CategoryTheory.Category.{u_6, u_2} Cβ} {Wβ : CategoryTheory.MorphismProperty Cβ}
{Wβ : CategoryTheory.MorphismProperty Cβ} {Ξ¦ : CategoryTheory.LocalizerMorphism Wβ Wβ} {Xβ : Cβ}
{L L' : Ξ¦.LeftResolution Xβ} {x y : L.Hom L'}, x = y β x.f = y.f
|
BooleanRing.mul_one_add_self
|
Mathlib.Algebra.Ring.BooleanRing
|
β {Ξ± : Type u_1} [inst : BooleanRing Ξ±] (a : Ξ±), a * (1 + a) = 0
|
CategoryTheory.Functor.Monoidal.toUnit_Ξ΅
|
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.Monoidal] (X : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit (F.obj X))
(CategoryTheory.Functor.LaxMonoidal.Ξ΅ F) =
F.map (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X)
|
Filter.rcomap'_sets
|
Mathlib.Order.Filter.Partial
|
β {Ξ± : Type u} {Ξ² : Type v} (r : SetRel Ξ± Ξ²) (f : Filter Ξ²),
(Filter.rcomap' r f).sets = SetRel.image {(s, t) | r.preimage s β t} f.sets
|
Set.image2_iInter_subset_right
|
Mathlib.Data.Set.Lattice.Image
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {ΞΉ : Sort u_5} (f : Ξ± β Ξ² β Ξ³) (s : Set Ξ±) (t : ΞΉ β Set Ξ²),
Set.image2 f s (β i, t i) β β i, Set.image2 f s (t i)
|
Lean.Compiler.LCNF.Probe.filterByUnreach
|
Lean.Compiler.LCNF.Probing
|
(Lean.Expr β Lean.Compiler.LCNF.CompilerM Bool) β
Lean.Compiler.LCNF.Probe Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Decl
|
AddMonoidHom.mulRightβ._proof_2
|
Mathlib.Algebra.Ring.Associator
|
β {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (x y : R),
AddMonoidHom.mul.comprβ (AddMonoidHom.mulLeft (x + y)) =
AddMonoidHom.mul.comprβ (AddMonoidHom.mulLeft x) + AddMonoidHom.mul.comprβ (AddMonoidHom.mulLeft y)
|
_private.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.0.wrapped._proof_1._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.588747923._hygCtx._hyg.2
|
Mathlib.MeasureTheory.Measure.Typeclasses.Finite
|
@definitionβ = @definitionβ
|
SimpleGraph.Walk.getVert_comp_val_eq_get_support
|
Mathlib.Combinatorics.SimpleGraph.Walks.Traversal
|
β {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.getVert β Fin.val = p.support.get
|
UniformSpace.Completion.isDenseInducing_coe
|
Mathlib.Topology.UniformSpace.Completion
|
β {Ξ± : Type u_1} [inst : UniformSpace Ξ±], IsDenseInducing UniformSpace.Completion.coe'
|
instFinitePresentationForall
|
Mathlib.Algebra.Module.FinitePresentation
|
β {R : Type u_1} [inst : Ring R] {ΞΉ : Type u_2} [Finite ΞΉ], Module.FinitePresentation R (ΞΉ β R)
|
AffineIsometry.norm_map
|
Mathlib.Analysis.Normed.Affine.Isometry
|
β {π : Type u_1} {V : Type u_2} {Vβ : Type u_5} {P : Type u_10} {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β] (self : P βα΅β±[π] Pβ) (x : V), βself.linear xβ = βxβ
|
Lean.IR.CollectMaps.collectDecl
|
Lean.Compiler.IR.EmitUtil
|
Lean.IR.Decl β Lean.IR.CollectMaps.Collector
|
Finset.instGradeMinOrder_nat
|
Mathlib.Data.Finset.Grade
|
{Ξ± : Type u_1} β GradeMinOrder β (Finset Ξ±)
|
ZeroAtInftyContinuousMap.instFunLike
|
Mathlib.Topology.ContinuousMap.ZeroAtInfty
|
{Ξ± : Type u} β
{Ξ² : Type v} β
[inst : TopologicalSpace Ξ±] β
[inst_1 : TopologicalSpace Ξ²] β [inst_2 : Zero Ξ²] β FunLike (ZeroAtInftyContinuousMap Ξ± Ξ²) Ξ± Ξ²
|
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.dvdTight.sizeOf_spec
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.Types
|
β (cβ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) (cβ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.dvdTight cβ cβ) = 1 + sizeOf cβ + sizeOf cβ
|
ValuationRing.commGroupWithZero._proof_9
|
Mathlib.RingTheory.Valuation.ValuationRing
|
β (A : Type u_1) [inst : CommRing A] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra A K]
(a b : ValuationRing.ValueGroup A K), a / b = a / b
|
HOrElse.ctorIdx
|
Init.Prelude
|
{Ξ± : Type u} β {Ξ² : Type v} β {Ξ³ : outParam (Type w)} β HOrElse Ξ± Ξ² Ξ³ β β
|
AddCon.comap_eq
|
Mathlib.GroupTheory.Congruence.Hom
|
β {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {c : AddCon M} {f : N β+ M},
AddCon.comap βf β― c = AddCon.ker (c.mk'.comp f)
|
Finmap.insert
|
Mathlib.Data.Finmap
|
{Ξ± : Type u} β {Ξ² : Ξ± β Type v} β [DecidableEq Ξ±] β (a : Ξ±) β Ξ² a β Finmap Ξ² β Finmap Ξ²
|
Std.Internal.List.Const.getValueD_filter
|
Std.Data.Internal.List.Associative
|
β {Ξ± : Type u} {Ξ² : Type v} [inst : BEq Ξ±] [EquivBEq Ξ±] {fallback : Ξ²} {f : Ξ± β Ξ² β Bool} {l : List ((_ : Ξ±) Γ Ξ²)},
Std.Internal.List.DistinctKeys l β
β {k : Ξ±},
Std.Internal.List.getValueD k (List.filter (fun p => f p.fst p.snd) l) fallback =
((Std.Internal.List.getValue? k l).pfilter fun v h => f (Std.Internal.List.getKey k l β―) v).getD fallback
|
Matrix.nondegenerate_iff_det_ne_zero
|
Mathlib.LinearAlgebra.Matrix.ToLinearEquiv
|
β {n : Type u_1} [inst : Fintype n] {A : Type u_4} [inst_1 : DecidableEq n] [inst_2 : CommRing A] [IsDomain A]
{M : Matrix n n A}, M.Nondegenerate β M.det β 0
|
AlgebraicGeometry.StructureSheaf.const_mul
|
Mathlib.AlgebraicGeometry.StructureSheaf
|
β (R : Type u) [inst : CommRing R] (fβ fβ gβ gβ : R)
(U : TopologicalSpace.Opens β(AlgebraicGeometry.PrimeSpectrum.Top R)) (huβ : β x β U, gβ β x.asIdeal.primeCompl)
(huβ : β x β U, gβ β x.asIdeal.primeCompl),
AlgebraicGeometry.StructureSheaf.const R fβ gβ U huβ * AlgebraicGeometry.StructureSheaf.const R fβ gβ U huβ =
AlgebraicGeometry.StructureSheaf.const R (fβ * fβ) (gβ * gβ) U β―
|
IsCoercive.continuousLinearEquivOfBilin
|
Mathlib.Analysis.InnerProductSpace.LaxMilgram
|
{V : Type u} β
[inst : NormedAddCommGroup V] β
[inst_1 : InnerProductSpace β V] β [CompleteSpace V] β {B : V βL[β] V βL[β] β} β IsCoercive B β V βL[β] V
|
HasSubset.Subset.trans
|
Mathlib.Order.RelClasses
|
β {Ξ± : Type u} [inst : HasSubset Ξ±] [IsTrans Ξ± fun x1 x2 => x1 β x2] {a b c : Ξ±}, a β b β b β c β a β c
|
Units.mul_right_inj
|
Mathlib.Algebra.Group.Units.Basic
|
β {Ξ± : Type u} [inst : Monoid Ξ±] (a : Ξ±Λ£) {b c : Ξ±}, βa * b = βa * c β b = c
|
Derivation.liftOfSurjective.congr_simp
|
Mathlib.RingTheory.Derivation.Basic
|
β {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : CommRing M]
[inst_3 : Algebra R A] [inst_4 : Algebra R M] {F : Type u_4} [inst_5 : FunLike F A M] [inst_6 : AlgHomClass F R A M]
{f f_1 : F} (e_f : f = f_1) (hf : Function.Surjective βf) β¦d d_1 : Derivation R A Aβ¦ (e_d : d = d_1)
(hd : β (x : A), f x = 0 β f (d x) = 0), Derivation.liftOfSurjective hf hd = Derivation.liftOfSurjective β― β―
|
RingTheory.LinearMap._aux_Mathlib_Algebra_Algebra_Bilinear___macroRules_RingTheory_LinearMap_termΞΌ_1
|
Mathlib.Algebra.Algebra.Bilinear
|
Lean.Macro
|
ProbabilityTheory.Kernel.borelMarkovFromReal.congr_simp
|
Mathlib.Probability.Kernel.Disintegration.StandardBorel
|
β {Ξ± : Type u_1} {mΞ± : MeasurableSpace Ξ±} (Ξ© : Type u_5) [inst : Nonempty Ξ©] [inst_1 : MeasurableSpace Ξ©]
[inst_2 : StandardBorelSpace Ξ©] (Ξ· Ξ·_1 : ProbabilityTheory.Kernel Ξ± β),
Ξ· = Ξ·_1 β ProbabilityTheory.Kernel.borelMarkovFromReal Ξ© Ξ· = ProbabilityTheory.Kernel.borelMarkovFromReal Ξ© Ξ·_1
|
Equiv.pemptyArrowEquivPUnit
|
Mathlib.Logic.Equiv.Defs
|
(Ξ± : Sort u_1) β (PEmpty.{u_2} β Ξ±) β PUnit.{u}
|
CategoryTheory.Cat.FreeRefl.lift
|
Mathlib.CategoryTheory.Category.ReflQuiv
|
{V : Type u_1} β
[inst : CategoryTheory.ReflQuiver V] β
{D : Type u_2} β
[inst_1 : CategoryTheory.Category.{u_4, u_2} D] β
V β₯€rq D β CategoryTheory.Functor (CategoryTheory.Cat.FreeRefl V) D
|
PerfectClosure.instNeg
|
Mathlib.FieldTheory.PerfectClosure
|
(K : Type u) β
[inst : CommRing K] β (p : β) β [inst_1 : Fact (Nat.Prime p)] β [inst_2 : CharP K p] β Neg (PerfectClosure K p)
|
CategoryTheory.LocalizerMorphism.RightResolution._sizeOf_1
|
Mathlib.CategoryTheory.Localization.Resolution
|
{Cβ : Type u_1} β
{Cβ : Type u_2} β
{inst : CategoryTheory.Category.{u_5, u_1} Cβ} β
{inst_1 : CategoryTheory.Category.{u_6, u_2} Cβ} β
{Wβ : CategoryTheory.MorphismProperty Cβ} β
{Wβ : CategoryTheory.MorphismProperty Cβ} β
{Ξ¦ : CategoryTheory.LocalizerMorphism Wβ Wβ} β
{Xβ : Cβ} β
[SizeOf Cβ] β
[SizeOf Cβ] β
[β¦X Y : Cββ¦ β (x : X βΆ Y) β SizeOf (Wβ x)] β
[β¦X Y : Cββ¦ β (x : X βΆ Y) β SizeOf (Wβ x)] β Ξ¦.RightResolution Xβ β β
|
AddSubsemigroup.coe_op
|
Mathlib.Algebra.Group.Subsemigroup.MulOpposite
|
β {M : Type u_2} [inst : Add M] (x : AddSubsemigroup M), βx.op = AddOpposite.unop β»ΒΉ' βx
|
Polynomial.mapRingHom_comp_C
|
Mathlib.Algebra.Polynomial.Eval.Defs
|
β {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R β+* S),
(Polynomial.mapRingHom f).comp Polynomial.C = Polynomial.C.comp f
|
CategoryTheory.instBicategoryMonoidalSingleObj._proof_6
|
Mathlib.CategoryTheory.Bicategory.SingleObj
|
β (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{a b c : CategoryTheory.MonoidalSingleObj C} {f g h : C} (Ξ· : f βΆ g) (ΞΈ : g βΆ h) (i : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.CategoryStruct.comp Ξ· ΞΈ) i =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight Ξ· i)
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ΞΈ i)
|
_private.Init.Data.List.Basic.0.List.getLastD.match_1.eq_1
|
Init.Data.List.Basic
|
β {Ξ± : Type u_1} (motive : List Ξ± β Ξ± β Sort u_2) (aβ : Ξ±) (h_1 : (aβ : Ξ±) β motive [] aβ)
(h_2 : (a : Ξ±) β (as : List Ξ±) β (x : Ξ±) β motive (a :: as) x),
(match [], aβ with
| [], aβ => h_1 aβ
| a :: as, x => h_2 a as x) =
h_1 aβ
|
Aesop.Script.Tactic.sTactic?
|
Aesop.Script.Tactic
|
Aesop.Script.Tactic β Option Aesop.Script.STactic
|
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.recommendedSpellingByNameExt.match_1
|
Lean.Parser.Term.Doc
|
(motive : Lean.Parser.Term.Doc.RecommendedSpelling Γ Array Lean.Name β Sort u_1) β
(x : Lean.Parser.Term.Doc.RecommendedSpelling Γ Array Lean.Name) β
((rec : Lean.Parser.Term.Doc.RecommendedSpelling) β (xs : Array Lean.Name) β motive (rec, xs)) β motive x
|
Real.convexOn_log_Gamma
|
Mathlib.Analysis.SpecialFunctions.Gamma.BohrMollerup
|
ConvexOn β (Set.Ioi 0) (Real.log β Real.Gamma)
|
Array.beq_eq_decide
|
Init.Data.Array.DecidableEq
|
β {Ξ± : Type u_1} [inst : BEq Ξ±] (xs ys : Array Ξ±),
(xs == ys) = if h : xs.size = ys.size then decide (β (i : β) (h' : i < xs.size), (xs[i] == ys[i]) = true) else false
|
CategoryTheory.Localization.Monoidal.functorCoreMonoidalOfComp
|
Mathlib.CategoryTheory.Localization.Monoidal.Functor
|
{C : Type u_1} β
{D : Type u_2} β
{E : Type u_3} β
[inst : CategoryTheory.Category.{u_4, u_1} C] β
[inst_1 : CategoryTheory.Category.{u_5, u_2} D] β
[inst_2 : CategoryTheory.Category.{u_6, u_3} E] β
[inst_3 : CategoryTheory.MonoidalCategory C] β
[inst_4 : CategoryTheory.MonoidalCategory D] β
[inst_5 : CategoryTheory.MonoidalCategory E] β
(L : CategoryTheory.Functor C D) β
(W : CategoryTheory.MorphismProperty C) β
[L.IsLocalization W] β
[L.Monoidal] β
(F : CategoryTheory.Functor D E) β
(G : CategoryTheory.Functor C E) β
[G.Monoidal] β
[W.ContainsIdentities] β [CategoryTheory.Localization.Lifting L W G F] β F.CoreMonoidal
|
Subgroup.Commensurable.eq_1
|
Mathlib.GroupTheory.Commensurable
|
β {G : Type u_1} [inst : Group G] (H K : Subgroup G), H.Commensurable K = (H.relIndex K β 0 β§ K.relIndex H β 0)
|
Unitization.instNonAssocRing._proof_9
|
Mathlib.Algebra.Algebra.Unitization
|
β {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : NonUnitalNonAssocRing A] [inst_2 : Module R A] (n : β),
(βn).castDef = (βn).castDef
|
LinearIsometry.strictConvexSpace_range
|
Mathlib.Analysis.Convex.LinearIsometry
|
β {π : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedField π] [inst_1 : PartialOrder π]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace π E] [inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace π F]
[StrictConvexSpace π E] (e : E ββα΅’[π] F), StrictConvexSpace π β₯(LinearMap.range e)
|
monotoneOn_of_le_add_one
|
Mathlib.Algebra.Order.SuccPred
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : PartialOrder Ξ±] [inst_1 : Preorder Ξ²] [inst_2 : Add Ξ±] [inst_3 : One Ξ±]
[inst_4 : SuccAddOrder Ξ±] [IsSuccArchimedean Ξ±] {s : Set Ξ±} {f : Ξ± β Ξ²},
s.OrdConnected β (β (a : Ξ±), Β¬IsMax a β a β s β a + 1 β s β f a β€ f (a + 1)) β MonotoneOn f s
|
ContinuousAlternatingMap.ofSubsingleton_toAlternatingMap
|
Mathlib.Topology.Algebra.Module.Alternating.Basic
|
β (R : Type u_1) (M : Type u_2) (N : Type u_4) {ΞΉ : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : Subsingleton ΞΉ] (i : ΞΉ) (f : M βL[R] N),
((ContinuousAlternatingMap.ofSubsingleton R M N i) f).toAlternatingMap = (AlternatingMap.ofSubsingleton R M N i) βf
|
Filter.bliminf_or_le_inf_aux_right._simp_1
|
Mathlib.Order.LiminfLimsup
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : CompleteLattice Ξ±] {f : Filter Ξ²} {p q : Ξ² β Prop} {u : Ξ² β Ξ±},
((Filter.bliminf u f fun x => p x β¨ q x) β€ Filter.bliminf u f q) = True
|
definition._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2
|
Mathlib.Analysis.InnerProductSpace.PiL2
|
{ΞΉ : Type u_1} β
{π : Type u_3} β
[inst : RCLike π] β
{E : Type u_4} β
[inst_1 : NormedAddCommGroup E] β
[inst_2 : InnerProductSpace π E] β
[Fintype ΞΉ] β
[FiniteDimensional π E] β
{n : β} β
Module.finrank π E = n β
[inst_5 : DecidableEq ΞΉ] β
{V : ΞΉ β Submodule π E} β
DirectSum.IsInternal V β
(OrthogonalFamily π (fun i => β₯(V i)) fun i => (V i).subtypeβα΅’) β
(i : ΞΉ) Γ Fin (Module.finrank π β₯(V i)) β Fin n
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.EqCnstr.collectDecVars.match_1
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof
|
(motive : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof β Sort u_1) β
(x : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) β
((a zero : Lean.Expr) β motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core0 a zero)) β
((a b : Lean.Expr) β
(pβ pβ : Int.Linear.Poly) β motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core a b pβ pβ)) β
((e : Lean.Expr) β (p : Int.Linear.Poly) β motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defn e p)) β
((h : Lean.Expr) β
(x : Int.Linear.Var) β
(e' : Int.Linear.Expr) β motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNat h x e')) β
((e : Lean.Expr) β
(p : Int.Linear.Poly) β
(re : Lean.Meta.Grind.Arith.CommRing.RingExpr) β
(rp : Lean.Grind.CommRing.Poly) β
(p' : Int.Linear.Poly) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnCommRing e p re rp p')) β
((h : Lean.Expr) β
(x : Int.Linear.Var) β
(e' : Int.Linear.Expr) β
(p : Int.Linear.Poly) β
(re : Lean.Meta.Grind.Arith.CommRing.RingExpr) β
(rp : Lean.Grind.CommRing.Poly) β
(p' : Int.Linear.Poly) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNatCommRing h x e' p re rp p')) β
((a b toIntThm : Lean.Expr) β
(lhs rhs : Int.Linear.Expr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.coreToInt a b toIntThm lhs rhs)) β
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
(e : Lean.Meta.Grind.Arith.CommRing.RingExpr) β
(p : Lean.Grind.CommRing.Poly) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.commRingNorm c e p)) β
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.reorder c)) β
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.norm c)) β
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.divCoeffs c)) β
((k : β€) β
(y? : Option Int.Linear.Var) β
(c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.div k y? c)) β
((k : β€) β
(y? : Option Int.Linear.Var) β
(c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod k y? c)) β
((x : Int.Linear.Var) β
(cβ cβ : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.subst x cβ cβ)) β
((cβ cβ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe cβ cβ)) β
((a? : Option Lean.Expr) β
(cs : Array (Lean.Expr Γ β€ Γ Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mul a? cs)) β
((ka : β€) β
(ca? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
(kb : β) β
(cb? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr) β
motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow ka ca? kb cb?)) β
motive x
|
ProofWidgets.RpcEncodablePacket.Β«_@Β».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusion
|
ProofWidgets.Component.Basic
|
{P : Sort u} β
{x1 x2 : ProofWidgets.RpcEncodablePacketβ} β
x1 = x2 β
ProofWidgets.RpcEncodablePacket.Β«_@Β».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusionType P x1
x2
|
Lean.guardMsgsPositions
|
Init.Notation
|
Lean.ParserDescr
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.