name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
CategoryTheory.ShortComplex.Exact.epi_f
|
Mathlib.Algebra.Homology.ShortComplex.Exact
|
β {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.Exact β S.g = 0 β CategoryTheory.Epi S.f
|
bddAbove_Ioc
|
Mathlib.Order.Bounds.Basic
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {a b : Ξ±}, BddAbove (Set.Ioc a b)
|
Mathlib.Tactic.CC.CCM.getEqcLambdas
|
Mathlib.Tactic.CC.Addition
|
Lean.Expr β optParam (Array Lean.Expr) #[] β Mathlib.Tactic.CC.CCM (Array Lean.Expr)
|
CochainComplex.HomComplex.leftHomologyData'_Ο
|
Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C β€) (n m p : β€) (hm : n + 1 = m) (hp : m + 1 = p),
(CochainComplex.HomComplex.leftHomologyData' K L n m p hm hp).Ο =
AddCommGrpCat.ofHom (CochainComplex.HomComplex.CohomologyClass.mkAddMonoidHom K L m)
|
HomologicalComplex.shortComplexFunctor'._proof_5
|
Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
|
β (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ΞΉ : Type u_3} (c : ComplexShape ΞΉ) (i j k : ΞΉ) {X Y Z : HomologicalComplex C c} (f : X βΆ Y) (g : Y βΆ Z),
{ Οβ := (CategoryTheory.CategoryStruct.comp f g).f i, Οβ := (CategoryTheory.CategoryStruct.comp f g).f j,
Οβ := (CategoryTheory.CategoryStruct.comp f g).f k, commββ := β―, commββ := β― } =
CategoryTheory.CategoryStruct.comp { Οβ := f.f i, Οβ := f.f j, Οβ := f.f k, commββ := β―, commββ := β― }
{ Οβ := g.f i, Οβ := g.f j, Οβ := g.f k, commββ := β―, commββ := β― }
|
Measurable.lmarginal
|
Mathlib.MeasureTheory.Integral.Marginal
|
β {Ξ΄ : Type u_1} {X : Ξ΄ β Type u_3} [inst : (i : Ξ΄) β MeasurableSpace (X i)] (ΞΌ : (i : Ξ΄) β MeasureTheory.Measure (X i))
[inst_1 : DecidableEq Ξ΄] {s : Finset Ξ΄} {f : ((i : Ξ΄) β X i) β ENNReal} [β (i : Ξ΄), MeasureTheory.SigmaFinite (ΞΌ i)],
Measurable f β Measurable (β«β―β«β»_s, f βΞΌ)
|
MeasureTheory.Measure.toSphere_apply_aux
|
Mathlib.MeasureTheory.Constructions.HaarToSphere
|
β {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E] [inst_2 : MeasurableSpace E]
(ΞΌ : MeasureTheory.Measure E) (s : Set β(Metric.sphere 0 1)) (r : β(Set.Ioi 0)),
ΞΌ (Subtype.val '' (β(homeomorphUnitSphereProd E) β»ΒΉ' s ΓΛ’ Set.Iio r)) = ΞΌ (Set.Ioo 0 βr β’ Subtype.val '' s)
|
CoalgHom.End._proof_3
|
Mathlib.RingTheory.Coalgebra.Hom
|
β {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] (x x_1 x_2 : A ββc[R] A), x * x_1 * x_2 = x * x_1 * x_2
|
InitialSeg.total
|
Mathlib.Order.InitialSeg
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β
(r : Ξ± β Ξ± β Prop) β (s : Ξ² β Ξ² β Prop) β [IsWellOrder Ξ± r] β [IsWellOrder Ξ² s] β InitialSeg r s β InitialSeg s r
|
Set.unit._proof_4
|
Mathlib.RingTheory.DedekindDomain.SInteger
|
β {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R))
(K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (x : KΛ£),
x β {x | β v β S, (IsDedekindDomain.HeightOneSpectrum.valuation K v) βx = 1} β
x β β(β¨
v, β¨
(_ : v β S), (IsDedekindDomain.HeightOneSpectrum.valuation K v).valuationSubring.unitGroup)
|
Polynomial.instIsJacobsonRing
|
Mathlib.RingTheory.Jacobson.Ring
|
β {R : Type u_1} [inst : CommRing R] [IsJacobsonRing R], IsJacobsonRing (Polynomial R)
|
fintypeNodupList._simp_3
|
Mathlib.Data.Fintype.List
|
β {Ξ± : Type u_1} {a : Ξ±} {s : Multiset Ξ±} {nd : s.Nodup}, (a β { val := s, nodup := nd }) = (a β s)
|
LinearMap.ofIsComplProdEquiv._proof_2
|
Mathlib.LinearAlgebra.Projection
|
β {Rβ : Type u_1} [inst : CommRing Rβ], RingHomInvPair (RingHom.id Rβ) (RingHom.id Rβ)
|
IsRelPrime.neg_right
|
Mathlib.RingTheory.Coprime.Basic
|
β {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y β IsRelPrime x (-y)
|
Mathlib.Tactic.BicategoryLike.IsoLift.mk._flat_ctor
|
Mathlib.Tactic.CategoryTheory.Coherence.Datatypes
|
Mathlib.Tactic.BicategoryLike.MorβIso β Lean.Expr β Mathlib.Tactic.BicategoryLike.IsoLift
|
Representation.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice.match_1
|
Mathlib.RepresentationTheory.Submodule
|
β {k : Type u_2} {G : Type u_3} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (Ο : Representation k G V) (motive : β₯Ο.invtSubmodule β Prop) (x : β₯Ο.invtSubmodule),
(β (p : Submodule k V) (hp : p β Ο.invtSubmodule), motive β¨p, hpβ©) β motive x
|
Equiv.Perm.IsCycle.zpowersEquivSupport.congr_simp
|
Mathlib.GroupTheory.Perm.Cycle.Basic
|
β {Ξ± : Type u_2} [inst : DecidableEq Ξ±] [inst_1 : Fintype Ξ±] {Ο : Equiv.Perm Ξ±} (hΟ : Ο.IsCycle),
hΟ.zpowersEquivSupport = hΟ.zpowersEquivSupport
|
ModelWithCorners.continuous_invFun
|
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] (self : ModelWithCorners π E H),
Continuous self.invFun
|
Std.TreeMap.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem
|
Std.Data.TreeMap.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {t : Std.TreeMap Ξ± Unit cmp} [Std.TransCmp cmp] {l : List Ξ±} {k k' : Ξ±},
cmp k k' = Ordering.eq β
k β t β List.Pairwise (fun a b => Β¬cmp a b = Ordering.eq) l β k β l β (t.insertManyIfNewUnit l).getKey? k' = some k
|
AlgEquiv.autCongr_trans
|
Mathlib.Algebra.Algebra.Equiv
|
β {R : Type uR} {Aβ : Type uAβ} {Aβ : Type uAβ} {Aβ : Type uAβ} [inst : CommSemiring R] [inst_1 : Semiring Aβ]
[inst_2 : Semiring Aβ] [inst_3 : Semiring Aβ] [inst_4 : Algebra R Aβ] [inst_5 : Algebra R Aβ] [inst_6 : Algebra R Aβ]
(Ο : Aβ ββ[R] Aβ) (Ο : Aβ ββ[R] Aβ), Ο.autCongr.trans Ο.autCongr = (Ο.trans Ο).autCongr
|
Set.image_subset_iff
|
Mathlib.Data.Set.Image
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {s : Set Ξ±} {t : Set Ξ²} {f : Ξ± β Ξ²}, f '' s β t β s β f β»ΒΉ' t
|
AlgebraicGeometry.Scheme.Opens.fromSpecStalkOfMem_toSpecΞ_assoc
|
Mathlib.AlgebraicGeometry.Stalk
|
β {X : AlgebraicGeometry.Scheme} (U : X.Opens) (x : β₯X) (hxU : x β U) {Z : AlgebraicGeometry.Scheme}
(h : AlgebraicGeometry.Spec (X.presheaf.obj (Opposite.op U)) βΆ Z),
CategoryTheory.CategoryStruct.comp (U.fromSpecStalkOfMem x hxU) (CategoryTheory.CategoryStruct.comp U.toSpecΞ h) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (X.presheaf.germ U x hxU)) h
|
ISize
|
Init.Data.SInt.Basic
|
Type
|
ContinuousMap.Homotopy.affine_apply
|
Mathlib.Topology.Homotopy.Affine
|
β {X : Type u_1} {E : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : IsTopologicalAddGroup E] [inst_4 : Module β E] [inst_5 : ContinuousSMul β E] (f g : C(X, E))
(x : βunitInterval Γ X), (ContinuousMap.Homotopy.affine f g) x = (AffineMap.lineMap (f x.2) (g x.2)) βx.1
|
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.constrToProp.match_3
|
Lean.Meta.MkIffOfInductiveProp
|
(motive : Option β Γ Lean.Expr β Sort u_1) β
(__discr : Option β Γ Lean.Expr) β ((n : Option β) β (r : Lean.Expr) β motive (n, r)) β motive __discr
|
TensorProduct.Neg.aux
|
Mathlib.LinearAlgebra.TensorProduct.Basic
|
(R : Type u_1) β
[inst : CommSemiring R] β
{M : Type u_2} β
{N : Type u_3} β
[inst_1 : AddCommGroup M] β
[inst_2 : AddCommMonoid N] β
[inst_3 : Module R M] β [inst_4 : Module R N] β TensorProduct R M N ββ[R] TensorProduct R M N
|
CategoryTheory.eqToIso
|
Mathlib.CategoryTheory.EqToHom
|
{C : Type uβ} β [inst : CategoryTheory.Category.{vβ, uβ} C] β {X Y : C} β X = Y β (X β
Y)
|
Lean.Elab.instInhabitedDefView
|
Lean.Elab.DefView
|
Inhabited Lean.Elab.DefView
|
SSet.prodStdSimplex.objEquiv._proof_1
|
Mathlib.AlgebraicTopology.SimplicialSet.ProdStdSimplex
|
β {p q n : β}
(x :
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj (SimplexCategory.mk p))
(SSet.stdSimplex.obj (SimplexCategory.mk q))).obj
(Opposite.op (SimplexCategory.mk n))),
(SSet.stdSimplex.objEquiv.symm
(SimplexCategory.Hom.mk
(OrderHom.fst.comp
(match x with
| (x, y) =>
(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv x)).prod
(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv y))))),
SSet.stdSimplex.objEquiv.symm
(SimplexCategory.Hom.mk
(OrderHom.snd.comp
(match x with
| (x, y) =>
(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv x)).prod
(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv y)))))) =
x
|
ZMod.charZero
|
Mathlib.Data.ZMod.Basic
|
CharZero (ZMod 0)
|
ENNReal.tendsto_inv_iff
|
Mathlib.Topology.Instances.ENNReal.Lemmas
|
β {Ξ± : Type u_1} {f : Filter Ξ±} {m : Ξ± β ENNReal} {a : ENNReal},
Filter.Tendsto (fun x => (m x)β»ΒΉ) f (nhds aβ»ΒΉ) β Filter.Tendsto m f (nhds a)
|
Besicovitch.SatelliteConfig.mk.inj
|
Mathlib.MeasureTheory.Covering.Besicovitch
|
β {Ξ± : Type u_1} {inst : MetricSpace Ξ±} {N : β} {Ο : β} {c : Fin N.succ β Ξ±} {r : Fin N.succ β β}
{rpos : β (i : Fin N.succ), 0 < r i}
{h : Pairwise fun i j => r i β€ dist (c i) (c j) β§ r j β€ Ο * r i β¨ r j β€ dist (c j) (c i) β§ r i β€ Ο * r j}
{hlast : β i < Fin.last N, r i β€ dist (c i) (c (Fin.last N)) β§ r (Fin.last N) β€ Ο * r i}
{inter : β i < Fin.last N, dist (c i) (c (Fin.last N)) β€ r i + r (Fin.last N)} {c_1 : Fin N.succ β Ξ±}
{r_1 : Fin N.succ β β} {rpos_1 : β (i : Fin N.succ), 0 < r_1 i}
{h_1 :
Pairwise fun i j =>
r_1 i β€ dist (c_1 i) (c_1 j) β§ r_1 j β€ Ο * r_1 i β¨ r_1 j β€ dist (c_1 j) (c_1 i) β§ r_1 i β€ Ο * r_1 j}
{hlast_1 : β i < Fin.last N, r_1 i β€ dist (c_1 i) (c_1 (Fin.last N)) β§ r_1 (Fin.last N) β€ Ο * r_1 i}
{inter_1 : β i < Fin.last N, dist (c_1 i) (c_1 (Fin.last N)) β€ r_1 i + r_1 (Fin.last N)},
{ c := c, r := r, rpos := rpos, h := h, hlast := hlast, inter := inter } =
{ c := c_1, r := r_1, rpos := rpos_1, h := h_1, hlast := hlast_1, inter := inter_1 } β
c = c_1 β§ r = r_1
|
ProbabilityTheory.Kernel.withDensity_rnDeriv_of_subset_mutuallySingularSetSlice
|
Mathlib.Probability.Kernel.RadonNikodym
|
β {Ξ± : Type u_1} {Ξ³ : Type u_2} {mΞ± : MeasurableSpace Ξ±} {mΞ³ : MeasurableSpace Ξ³} {ΞΊ Ξ· : ProbabilityTheory.Kernel Ξ± Ξ³}
[hΞ±Ξ³ : MeasurableSpace.CountableOrCountablyGenerated Ξ± Ξ³] [ProbabilityTheory.IsFiniteKernel ΞΊ]
[inst : ProbabilityTheory.IsFiniteKernel Ξ·] {a : Ξ±} {s : Set Ξ³},
s β ΞΊ.mutuallySingularSetSlice Ξ· a β ((Ξ·.withDensity (ΞΊ.rnDeriv Ξ·)) a) s = 0
|
Hindman.FS.brecOn
|
Mathlib.Combinatorics.Hindman
|
β {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) β (a_1 : M) β Hindman.FS a a_1 β Prop}
{a : Stream' M} {a_1 : M} (t : Hindman.FS a a_1),
(β (a : Stream' M) (a_2 : M) (t : Hindman.FS a a_2), Hindman.FS.below t β motive a a_2 t) β motive a a_1 t
|
Lean.PersistentHashMap.Entry.ctorElimType
|
Lean.Data.PersistentHashMap
|
{Ξ± : Type u} β
{Ξ² : Type v} β
{Ο : Type w} β
{motive : Lean.PersistentHashMap.Entry Ξ± Ξ² Ο β Sort u_1} β
β β Sort (max 1 u_1 (imax (u + 1) (v + 1) u_1) (imax (w + 1) u_1))
|
SimpleGraph.TripartiteFromTriangles.Graph.inββ_iff._simp_1
|
Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {t : Finset (Ξ± Γ Ξ² Γ Ξ³)} {b : Ξ²} {c : Ξ³},
(SimpleGraph.TripartiteFromTriangles.graph t).Adj (Sum3.inβ c) (Sum3.inβ b) = β a, (a, b, c) β t
|
GradeMinOrder.recOn
|
Mathlib.Order.Grade
|
{π : Type u_5} β
{Ξ± : Type u_6} β
[inst : Preorder π] β
[inst_1 : Preorder Ξ±] β
{motive : GradeMinOrder π Ξ± β Sort u} β
(t : GradeMinOrder π Ξ±) β
([toGradeOrder : GradeOrder π Ξ±] β
(isMin_grade : β β¦a : Ξ±β¦, IsMin a β IsMin (GradeOrder.grade a)) β
motive { toGradeOrder := toGradeOrder, isMin_grade := isMin_grade }) β
motive t
|
Aesop.RulePatternIndex.recOn
|
Aesop.Index.RulePattern
|
{motive : Aesop.RulePatternIndex β Sort u} β
(t : Aesop.RulePatternIndex) β
((tree : Lean.Meta.DiscrTree Aesop.RulePatternIndex.Entry) β
(isEmpty : Bool) β motive { tree := tree, isEmpty := isEmpty }) β
motive t
|
CategoryTheory.GrothendieckTopology.instIsGeneratedByOneHypercovers
|
Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C),
J.IsGeneratedByOneHypercovers
|
_private.Mathlib.Order.OrderIsoNat.0.RelEmbedding.wellFounded_iff_isEmpty.match_1_1
|
Mathlib.Order.OrderIsoNat
|
β {Ξ± : Type u_1} {r : Ξ± β Ξ± β Prop} (motive : WellFounded r β Prop) (x : WellFounded r),
(β (h : β (a : Ξ±), Acc r a), motive β―) β motive x
|
Polynomial.Chebyshev.S_two_mul_complex_cosh
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Basic
|
β (ΞΈ : β) (n : β€),
Polynomial.eval (2 * Complex.cosh ΞΈ) (Polynomial.Chebyshev.S β n) * Complex.sinh ΞΈ = Complex.sinh ((βn + 1) * ΞΈ)
|
NumberField.InfinitePlace.embedding_of_isReal_apply
|
Mathlib.NumberTheory.NumberField.InfinitePlace.Basic
|
β {K : Type u_2} [inst : Field K] {w : NumberField.InfinitePlace K} (hw : w.IsReal) (x : K),
β((NumberField.InfinitePlace.embedding_of_isReal hw) x) = w.embedding x
|
Std.HashMap.contains_keysArray
|
Std.Data.HashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.HashMap Ξ± Ξ²} [EquivBEq Ξ±] [LawfulHashable Ξ±]
{k : Ξ±}, m.keysArray.contains k = m.contains k
|
ContinuousInv.measurableInv
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
|
β {Ξ³ : Type u_3} [inst : TopologicalSpace Ξ³] [inst_1 : MeasurableSpace Ξ³] [BorelSpace Ξ³] [inst_3 : Inv Ξ³]
[ContinuousInv Ξ³], MeasurableInv Ξ³
|
Homotopy.compLeftId
|
Mathlib.Algebra.Homology.Homotopy
|
{ΞΉ : Type u_1} β
{V : Type u} β
[inst : CategoryTheory.Category.{v, u} V] β
[inst_1 : CategoryTheory.Preadditive V] β
{c : ComplexShape ΞΉ} β
{C D : HomologicalComplex V c} β
{f : D βΆ D} β
Homotopy f (CategoryTheory.CategoryStruct.id D) β
(g : C βΆ D) β Homotopy (CategoryTheory.CategoryStruct.comp g f) g
|
CategoryTheory.Join.mapWhiskerRight_rightUnitor_hom
|
Mathlib.CategoryTheory.Join.Pseudofunctor
|
β {A : Type u_1} {B : Type u_2} (C : Type u_3) [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(F : CategoryTheory.Functor A B),
CategoryTheory.Join.mapWhiskerRight F.rightUnitor.hom (CategoryTheory.Functor.id C) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Join.mapCompLeft C F (CategoryTheory.Functor.id B)).hom
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Join.mapPair F (CategoryTheory.Functor.id C)).whiskerLeft CategoryTheory.Join.mapPairId.hom)
(CategoryTheory.Join.mapPair F (CategoryTheory.Functor.id C)).rightUnitor.hom)
|
Std.TreeMap.Raw._sizeOf_inst
|
Std.Data.TreeMap.Raw.Basic
|
(Ξ± : Type u) β
(Ξ² : Type v) β
(cmp : autoParam (Ξ± β Ξ± β Ordering) Std.TreeMap.Raw._auto_1) β
[SizeOf Ξ±] β [SizeOf Ξ²] β SizeOf (Std.TreeMap.Raw Ξ± Ξ² cmp)
|
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid.eq_1
|
Mathlib.Algebra.Order.Hom.Monoid
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : AddCommMonoid Ξ±] [inst_1 : PartialOrder Ξ±] [inst_2 : AddCommMonoid Ξ²]
[inst_3 : PartialOrder Ξ²] [inst_4 : IsOrderedAddMonoid Ξ²],
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid =
{
add := fun f g =>
let __src := βf + βg;
{ toAddMonoidHom := __src, monotone' := β― } }
|
CategoryTheory.Limits.opProdIsoCoprod_inv_inl
|
Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {A B : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct A B],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.opProdIsoCoprod A B).inv.unop
CategoryTheory.Limits.coprod.inl.unop =
CategoryTheory.Limits.prod.fst
|
TopologicalSpace.IsTopologicalBasis.isOpen_iff
|
Mathlib.Topology.Bases
|
β {Ξ± : Type u} [t : TopologicalSpace Ξ±] {s : Set Ξ±} {b : Set (Set Ξ±)},
TopologicalSpace.IsTopologicalBasis b β (IsOpen s β β a β s, β t β b, a β t β§ t β s)
|
AddCon.addMonoid._proof_1
|
Mathlib.GroupTheory.Congruence.Defs
|
β {M : Type u_1} [inst : AddMonoid M] (c : AddCon M), Function.Surjective Quotient.mk''
|
SimpleGraph.bot_adj
|
Mathlib.Combinatorics.SimpleGraph.Basic
|
β {V : Type u} (v w : V), β₯.Adj v w β False
|
Subring.mem_pointwise_smul_iff_inv_smul_mem
|
Mathlib.Algebra.Ring.Subring.Pointwise
|
β {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] {a : M}
{S : Subring R} {x : R}, x β a β’ S β aβ»ΒΉ β’ x β S
|
CategoryTheory.Grp.hom_one
|
Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (H : CategoryTheory.Grp C) [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.MonObj.one.hom = CategoryTheory.MonObj.one
|
Aesop.Hyp.mk
|
Aesop.Forward.State
|
Option Lean.FVarId β Aesop.Substitution β Aesop.Hyp
|
TypeVec.splitFun
|
Mathlib.Data.TypeVec
|
{n : β} β
{Ξ± : TypeVec.{u_1} (n + 1)} β {Ξ±' : TypeVec.{u_2} (n + 1)} β Ξ±.drop.Arrow Ξ±'.drop β (Ξ±.last β Ξ±'.last) β Ξ±.Arrow Ξ±'
|
Lean.Elab.CommandContextInfo.mk.injEq
|
Lean.Elab.InfoTree.Types
|
β (env : Lean.Environment) (cmdEnv? : Option Lean.Environment) (fileMap : Lean.FileMap) (mctx : Lean.MetavarContext)
(options : Lean.Options) (currNamespace : Lean.Name) (openDecls : List Lean.OpenDecl) (ngen : Lean.NameGenerator)
(env_1 : Lean.Environment) (cmdEnv?_1 : Option Lean.Environment) (fileMap_1 : Lean.FileMap)
(mctx_1 : Lean.MetavarContext) (options_1 : Lean.Options) (currNamespace_1 : Lean.Name)
(openDecls_1 : List Lean.OpenDecl) (ngen_1 : Lean.NameGenerator),
({ env := env, cmdEnv? := cmdEnv?, fileMap := fileMap, mctx := mctx, options := options,
currNamespace := currNamespace, openDecls := openDecls, ngen := ngen } =
{ env := env_1, cmdEnv? := cmdEnv?_1, fileMap := fileMap_1, mctx := mctx_1, options := options_1,
currNamespace := currNamespace_1, openDecls := openDecls_1, ngen := ngen_1 }) =
(env = env_1 β§
cmdEnv? = cmdEnv?_1 β§
fileMap = fileMap_1 β§
mctx = mctx_1 β§
options = options_1 β§ currNamespace = currNamespace_1 β§ openDecls = openDecls_1 β§ ngen = ngen_1)
|
PowerSeries.coeff_pow
|
Mathlib.RingTheory.PowerSeries.Basic
|
β {R : Type u_2} [inst : CommSemiring R] (k n : β) (Ο : PowerSeries R),
(PowerSeries.coeff n) (Ο ^ k) =
β l β (Finset.range k).finsuppAntidiag n, β i β Finset.range k, (PowerSeries.coeff (l i)) Ο
|
fderivWithin_inter
|
Mathlib.Analysis.Calculus.FDeriv.Basic
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {f : E β F}
{x : E} {s t : Set E}, t β nhds x β fderivWithin π f (s β© t) x = fderivWithin π f s x
|
_private.Mathlib.Order.Category.BoolAlg.0.BoolAlg.Hom.mk.injEq
|
Mathlib.Order.Category.BoolAlg
|
β {X Y : BoolAlg} (hom' hom'_1 : BoundedLatticeHom βX βY), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1)
|
LieDerivation.instModule.congr_simp
|
Mathlib.Algebra.Lie.Derivation.Basic
|
β {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] {S : Type u_4}
[inst_7 : Semiring S] [inst_8 : Module S M] [inst_9 : SMulCommClass R S M]
[inst_10 : LieDerivation.SMulBracketCommClass S L M], LieDerivation.instModule = LieDerivation.instModule
|
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.levelMVarToParam
|
Lean.Elab.MutualInductive
|
List Lean.InductiveType β Option Lean.LMVarId β Lean.Elab.TermElabM (List Lean.InductiveType)
|
_private.Mathlib.Geometry.Manifold.VectorBundle.Hom.0.ContMDiffWithinAt.clm_bundle_apply._simp_1_1
|
Mathlib.Geometry.Manifold.VectorBundle.Hom
|
β {π : Type u_1} {B : Type u_2} {Fβ : Type u_3} {Fβ : Type u_4} {M : Type u_5} {n : WithTop ββ} {Eβ : B β Type u_6}
{Eβ : B β Type u_7} [inst : NontriviallyNormedField π] [inst_1 : (x : B) β AddCommGroup (Eβ x)]
[inst_2 : (x : B) β Module π (Eβ x)] [inst_3 : NormedAddCommGroup Fβ] [inst_4 : NormedSpace π Fβ]
[inst_5 : TopologicalSpace (Bundle.TotalSpace Fβ Eβ)] [inst_6 : (x : B) β TopologicalSpace (Eβ x)]
[inst_7 : (x : B) β AddCommGroup (Eβ x)] [inst_8 : (x : B) β Module π (Eβ x)] [inst_9 : NormedAddCommGroup Fβ]
[inst_10 : NormedSpace π Fβ] [inst_11 : TopologicalSpace (Bundle.TotalSpace Fβ Eβ)]
[inst_12 : (x : B) β TopologicalSpace (Eβ x)] {EB : Type u_8} [inst_13 : NormedAddCommGroup EB]
[inst_14 : NormedSpace π EB] {HB : Type u_9} [inst_15 : TopologicalSpace HB] {IB : ModelWithCorners π EB HB}
[inst_16 : TopologicalSpace B] [inst_17 : ChartedSpace HB B] {EM : Type u_10} [inst_18 : NormedAddCommGroup EM]
[inst_19 : NormedSpace π EM] {HM : Type u_11} [inst_20 : TopologicalSpace HM] {IM : ModelWithCorners π EM HM}
[inst_21 : TopologicalSpace M] [inst_22 : ChartedSpace HM M] [inst_23 : FiberBundle Fβ Eβ]
[inst_24 : VectorBundle π Fβ Eβ] [inst_25 : FiberBundle Fβ Eβ] [inst_26 : VectorBundle π Fβ Eβ]
[inst_27 : β (x : B), IsTopologicalAddGroup (Eβ x)] [inst_28 : β (x : B), ContinuousSMul π (Eβ x)]
(f : M β Bundle.TotalSpace (Fβ βL[π] Fβ) fun b => Eβ b βL[π] Eβ b) {s : Set M} {xβ : M},
ContMDiffWithinAt IM (IB.prod (modelWithCornersSelf π (Fβ βL[π] Fβ))) n f s xβ =
(ContMDiffWithinAt IM IB n (fun x => (f x).proj) s xβ β§
ContMDiffWithinAt IM (modelWithCornersSelf π (Fβ βL[π] Fβ)) n
(fun x => ContinuousLinearMap.inCoordinates Fβ Eβ Fβ Eβ β― β― β― β― β―) s xβ)
|
Std.ExtHashSet.contains_of_contains_insert'
|
Std.Data.ExtHashSet.Lemmas
|
β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.ExtHashSet Ξ±} [inst : EquivBEq Ξ±] [inst_1 : LawfulHashable Ξ±]
{k a : Ξ±}, (m.insert k).contains a = true β Β¬((k == a) = true β§ m.contains k = false) β m.contains a = true
|
AddCommGrpCat.epi_iff_range_eq_top
|
Mathlib.Algebra.Category.Grp.EpiMono
|
β {A B : AddCommGrpCat} (f : A βΆ B), CategoryTheory.Epi f β (AddCommGrpCat.Hom.hom f).range = β€
|
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.archimedean_iff_nat_le.match_1_1
|
Mathlib.Algebra.Order.Archimedean.Basic
|
β {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] (x : K) (motive : (β n, x β€ βn) β Prop) (x_1 : β n, x β€ βn),
(β (n : β) (h : x β€ βn), motive β―) β motive x_1
|
Lean.Elab.Visibility.private.elim
|
Lean.Elab.DeclModifiers
|
{motive : Lean.Elab.Visibility β Sort u} β
(t : Lean.Elab.Visibility) β t.ctorIdx = 1 β motive Lean.Elab.Visibility.private β motive t
|
Finset.Icc_ofDual
|
Mathlib.Order.Interval.Finset.Defs
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] [inst_1 : LocallyFiniteOrder Ξ±] (a b : Ξ±α΅α΅),
Finset.Icc (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Icc b a)
|
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.div_max_sq_ge_one._simp_1_4
|
Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] (a : Ξ±), (a β€ a) = True
|
DoubleCoset.eq_of_not_disjoint
|
Mathlib.GroupTheory.DoubleCoset
|
β {G : Type u_1} [inst : Group G] {H K : Subgroup G} {a b : G},
Β¬Disjoint (DoubleCoset.doubleCoset a βH βK) (DoubleCoset.doubleCoset b βH βK) β
DoubleCoset.doubleCoset a βH βK = DoubleCoset.doubleCoset b βH βK
|
Mathlib.Tactic.Bicategory.naturality_inv
|
Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence
|
β {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {p : a βΆ b} {f g : b βΆ c} {pf : a βΆ c} {Ξ· : f β
g}
(Ξ·_f : CategoryTheory.CategoryStruct.comp p f β
pf) (Ξ·_g : CategoryTheory.CategoryStruct.comp p g β
pf),
CategoryTheory.Bicategory.whiskerLeftIso p Ξ· βͺβ« Ξ·_g = Ξ·_f β
CategoryTheory.Bicategory.whiskerLeftIso p Ξ·.symm βͺβ« Ξ·_f = Ξ·_g
|
ISize.div_self
|
Init.Data.SInt.Lemmas
|
β {a : ISize}, a / a = if a = 0 then 0 else 1
|
Affine.Simplex.altitudeFoot_mem_affineSpan_image_compl
|
Mathlib.Geometry.Euclidean.Altitude
|
β {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : β} [inst_4 : NeZero n] (s : Affine.Simplex β P n) (i : Fin (n + 1)),
s.altitudeFoot i β affineSpan β (s.points '' {i}αΆ)
|
One.toOfNat1.hcongr_2
|
Mathlib.GroupTheory.CoprodI
|
β (Ξ± Ξ±' : Type u_1), Ξ± = Ξ±' β β (inst : One Ξ±) (inst' : One Ξ±'), inst β inst' β One.toOfNat1 β One.toOfNat1
|
CategoryTheory.RetractArrow.left_i
|
Mathlib.CategoryTheory.Retract
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X βΆ Y} {g : Z βΆ W}
(h : CategoryTheory.RetractArrow f g), h.left.i = h.i.left
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Search.0.Lean.Meta.Grind.Arith.Cutsat.CooperSplit.assert.match_1
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.Search
|
(motive : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr β Sort u_1) β
(cβ? : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) β
((cβ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) β motive (some cβ)) β
((x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) β motive x) β motive cβ?
|
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_5
|
Mathlib.CategoryTheory.Limits.Types.Multiequalizer
|
β {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : βI.multicospan.sections),
β¨fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i =>
{ val := fun i => βs (CategoryTheory.Limits.WalkingMulticospan.left i), property := β― }.val i
| CategoryTheory.Limits.WalkingMulticospan.right j =>
I.fst j ({ val := fun i => βs (CategoryTheory.Limits.WalkingMulticospan.left i), property := β― }.val (J.fst j)),
β―β© =
s
|
_private.Batteries.Data.Fin.Lemmas.0.Fin.exists_eq_some_of_findSome?_eq_some._proof_1_1
|
Batteries.Data.Fin.Lemmas
|
β {n : β} {Ξ± : Type u_1} {x : Ξ±} {f : Fin n β Option Ξ±}, Fin.findSome? f = some x β β i, f i = some x
|
Std.ExtTreeSet.self_le_max?_insert
|
Std.Data.ExtTreeSet.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {t : Std.ExtTreeSet Ξ± cmp} [inst : Std.TransCmp cmp] {k kmi : Ξ±},
(t.insert k).max?.get β― = kmi β (cmp k kmi).isLE = true
|
_private.Mathlib.LinearAlgebra.TensorAlgebra.Basic.0.TensorAlgebra.wrapped._proof_1._@.Mathlib.LinearAlgebra.TensorAlgebra.Basic.4207585102._hygCtx._hyg.2
|
Mathlib.LinearAlgebra.TensorAlgebra.Basic
|
TensorAlgebra.definitionβ = TensorAlgebra.definitionβ
|
DirectSum.Decomposition.casesOn
|
Mathlib.Algebra.DirectSum.Decomposition
|
{ΞΉ : Type u_1} β
{M : Type u_3} β
{Ο : Type u_4} β
[inst : DecidableEq ΞΉ] β
[inst_1 : AddCommMonoid M] β
[inst_2 : SetLike Ο M] β
[inst_3 : AddSubmonoidClass Ο M] β
{β³ : ΞΉ β Ο} β
{motive : DirectSum.Decomposition β³ β Sort u} β
(t : DirectSum.Decomposition β³) β
((decompose' : M β DirectSum ΞΉ fun i => β₯(β³ i)) β
(left_inv : Function.LeftInverse (β(DirectSum.coeAddMonoidHom β³)) decompose') β
(right_inv : Function.RightInverse (β(DirectSum.coeAddMonoidHom β³)) decompose') β
motive { decompose' := decompose', left_inv := left_inv, right_inv := right_inv }) β
motive t
|
Lean.Expr.ensureHasNoMVars
|
Mathlib.Lean.Expr.Basic
|
Lean.Expr β Lean.MetaM Unit
|
Std.DTreeMap.Internal.Impl.Const.entryAtIdx?.eq_def
|
Std.Data.DTreeMap.Internal.Model
|
β {Ξ± : Type u} {Ξ² : Type v} (x : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) (x_1 : β),
Std.DTreeMap.Internal.Impl.Const.entryAtIdx? x x_1 =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.leaf, x => none
| Std.DTreeMap.Internal.Impl.inner size k v l r, n =>
match compare n l.size with
| Ordering.lt => Std.DTreeMap.Internal.Impl.Const.entryAtIdx? l n
| Ordering.eq => some (k, v)
| Ordering.gt => Std.DTreeMap.Internal.Impl.Const.entryAtIdx? r (n - l.size - 1)
|
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.elim
|
Mathlib.Tactic.CategoryTheory.Coherence.Datatypes
|
{motive : Mathlib.Tactic.BicategoryLike.StructuralAtom β Sort u} β
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) β
t.ctorIdx = 3 β
((e : Lean.Expr) β
(f : Mathlib.Tactic.BicategoryLike.Morβ) β motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f)) β
motive t
|
UInt8._sizeOf_inst
|
Init.SizeOf
|
SizeOf UInt8
|
Int.reduceNeg._regBuiltin.Int.reduceNeg.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.2123988823._hygCtx._hyg.22
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int
|
IO Unit
|
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffOn_iff_target._simp_1_1
|
Mathlib.Geometry.Manifold.ContMDiff.Defs
|
β {π : 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} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace π E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners π E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M β M'} {s : Set M}
{n : WithTop ββ} [IsManifold I n M] [IsManifold I' n M'],
ContMDiffOn I I' n f s =
(ContinuousOn f s β§
β (x : M) (y : M'),
ContDiffOn π n (β(extChartAt I' y) β f β β(extChartAt I x).symm)
((extChartAt I x).target β© β(extChartAt I x).symm β»ΒΉ' (s β© f β»ΒΉ' (extChartAt I' y).source)))
|
_private.Mathlib.Data.Set.Finite.Basic.0.Finset.exists.match_1_3
|
Mathlib.Data.Set.Finite.Basic
|
β {Ξ± : Type u_1} {p : Finset Ξ± β Prop} (motive : (β s, β (hs : s.Finite), p hs.toFinset) β Prop)
(x : β s, β (hs : s.Finite), p hs.toFinset),
(β (s : Set Ξ±) (hs : s.Finite) (hs' : p hs.toFinset), motive β―) β motive x
|
UnitAddTorus.mFourierLp._proof_7
|
Mathlib.Analysis.Fourier.AddCircleMulti
|
β {d : Type u_1}, CompactSpace (d β UnitAddCircle)
|
IsAbsoluteValue.abv_nonneg
|
Mathlib.Algebra.Order.AbsoluteValue.Basic
|
β {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R] (abv : R β S)
[IsAbsoluteValue abv] (x : R), 0 β€ abv x
|
EReal.coe_ennreal_le_coe_ennreal_iff._simp_1
|
Mathlib.Data.EReal.Basic
|
β {x y : ENNReal}, (βx β€ βy) = (x β€ y)
|
CategoryTheory.nerveFunctor.full
|
Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction
|
CategoryTheory.nerveFunctor.Full
|
CategoryTheory.Presieve.BindStruct.hg
|
Mathlib.CategoryTheory.Sites.Sieves
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {X : C} {S : CategoryTheory.Presieve X}
{R : β¦Y : Cβ¦ β β¦f : Y βΆ Xβ¦ β S f β CategoryTheory.Presieve Y} {Z : C} {h : Z βΆ X} (self : S.BindStruct R h),
R β― self.g
|
ModuleCat.monModuleEquivalenceAlgebraForget._proof_5
|
Mathlib.CategoryTheory.Monoidal.Internal.Module
|
β {R : Type u_1} [inst : CommRing R] (A : CategoryTheory.Mon (ModuleCat R)) (x : R)
(x_1 : β(ModuleCat.MonModuleEquivalenceAlgebra.functor.obj A)), id (x β’ x_1) = id (x β’ x_1)
|
CategoryTheory.Limits.prod.mapIso_hom
|
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
(f : W β
Y) (g : X β
Z), (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_of_msb_false._simp_1_1
|
Init.Data.BitVec.Lemmas
|
β {p : Prop} [h : Decidable p], (false = decide p) = Β¬p
|
Lean.Server.Snapshots.Snapshot.recOn
|
Lean.Server.Snapshots
|
{motive : Lean.Server.Snapshots.Snapshot β Sort u} β
(t : Lean.Server.Snapshots.Snapshot) β
((stx : Lean.Syntax) β
(mpState : Lean.Parser.ModuleParserState) β
(cmdState : Lean.Elab.Command.State) β motive { stx := stx, mpState := mpState, cmdState := cmdState }) β
motive t
|
AddLocalization.liftOnβ_mk
|
Mathlib.GroupTheory.MonoidLocalization.Basic
|
β {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M β β₯S β M β β₯S β p)
(H :
β {a a' : M} {b b' : β₯S} {c c' : M} {d d' : β₯S},
(AddLocalization.r S) (a, b) (a', b') β (AddLocalization.r S) (c, d) (c', d') β f a b c d = f a' b' c' d')
(a c : M) (b d : β₯S), (AddLocalization.mk a b).liftOnβ (AddLocalization.mk c d) f H = f a b c d
|
CategoryTheory.Functor.Monoidal.whiskerLeft_app_snd
|
Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory
|
β {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(Fβ : CategoryTheory.Functor J C) {Fβ Fβ' : CategoryTheory.Functor J C} (g : Fβ βΆ Fβ') (j : J),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategoryStruct.whiskerLeft Fβ g).app j)
(CategoryTheory.SemiCartesianMonoidalCategory.snd (Fβ.obj j) (Fβ'.obj j)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.snd (Fβ.obj j) (Fβ.obj j))
(g.app j)
|
Polynomial.map_evalRingHom_eval
|
Mathlib.Algebra.Polynomial.Bivariate
|
β {R : Type u_1} [inst : CommSemiring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.