name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl._proof_4 | Mathlib.Analysis.Normed.Module.Complemented | ∀ {𝕜 : Type u_4} {E : Type u_1} {F : Type u_3} {G : Type u_2} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (f : E →L[𝕜] F) (g : E →L[𝕜] G),
Continuous fun x => (f x, ↑g x) |
Lean.Elab.InlayHintInfo.label | Lean.Elab.InfoTree.InlayHints | Lean.Elab.InlayHintInfo → Lean.Elab.InlayHintLabel |
Set.indicator_pi_one_apply | Mathlib.Algebra.BigOperators.GroupWithZero.Finset | ∀ {ι : Type u_1} {M₀ : Type u_4} {α : ι → Type u_5} [inst : CommMonoidWithZero M₀] (s : Finset ι)
(t : (i : ι) → Set (α i)) (f : (i : ι) → α i), ((↑s).pi t).indicator 1 f = ∏ i ∈ s, (t i).indicator 1 (f i) |
Nat.eq_zero_of_two_mul_le | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, 2 * n ≤ n → n = 0 |
CategoryTheory.Abelian.Ext.hom | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.HasExt C] →
{X Y : C} →
[inst_3 : HasDerivedCategory C] →
{a : ℕ} →
CategoryTheory.Abelian.Ext X Y a →
CategoryTheory.ShiftedHom ((DerivedCategory.singleFunctor C 0).obj X)
((DerivedCategory.singleFunctor C 0).obj Y) ↑a |
Std.DTreeMap.Internal.Impl.maxKey!.induct_unfolding | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Inhabited α] (motive : Std.DTreeMap.Internal.Impl α β → α → Prop),
motive Std.DTreeMap.Internal.Impl.leaf
(panicWithPosWithDecl "Std.Data.DTreeMap.Internal.Queries" "Std.DTreeMap.Internal.Impl.maxKey!" 436 13
"Map is empty") →
(∀ (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β),
motive (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf) k) →
(∀ (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β) (size_1 : ℕ) (k_1 : α) (v_1 : β k_1)
(l_1 r : Std.DTreeMap.Internal.Impl α β),
motive (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)
(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r).maxKey! →
motive (Std.DTreeMap.Internal.Impl.inner size k v l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r))
(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r).maxKey!) →
∀ (a : Std.DTreeMap.Internal.Impl α β), motive a a.maxKey! |
Std.CancellationContext.token | Std.Sync.CancellationContext | Std.CancellationContext → Std.CancellationToken |
Equiv.Perm.disjoint_iff_eq_or_eq | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {f g : Equiv.Perm α}, f.Disjoint g ↔ ∀ (x : α), f x = x ∨ g x = x |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_11 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (res : Lean.Name) (acc : String) (ucount : ℕ) (hp₀ : ¬p₀ = s.endPos),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p res => p) fun _x =>
PSigma.casesOn _x fun p₀ res => PSigma.casesOn res fun res acc => PSigma.casesOn acc fun acc ucount => p₀)
String.Pos.instWellFoundedRelation).1
(PSum.inr (PSum.inr ⟨p₀.next hp₀, ⟨res, ⟨(acc.pushn '_' (ucount / 2)).push (p₀.get hp₀), 0⟩⟩⟩))
(PSum.inr (PSum.inr ⟨p₀, ⟨res, ⟨acc, ucount⟩⟩⟩)) |
ProbabilityTheory.Kernel.integral_congr_ae₂ | Mathlib.Probability.Kernel.Integral | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
{E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f g : α → β → E}
{μ : MeasureTheory.Measure α},
(∀ᵐ (a : α) ∂μ, f a =ᵐ[κ a] g a) → ∫ (a : α), ∫ (b : β), f a b ∂κ a ∂μ = ∫ (a : α), ∫ (b : β), g a b ∂κ a ∂μ |
CategoryTheory.ComposableArrows.homMk₄_app_four | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 4}
(app₀ : f.obj' 0 _proof_353✝ ⟶ g.obj' 0 _proof_353✝¹) (app₁ : f.obj' 1 _proof_354✝ ⟶ g.obj' 1 _proof_354✝¹)
(app₂ : f.obj' 2 _proof_355✝ ⟶ g.obj' 2 _proof_355✝¹) (app₃ : f.obj' 3 _proof_356✝ ⟶ g.obj' 3 _proof_356✝¹)
(app₄ : f.obj' 4 _proof_357✝ ⟶ g.obj' 4 _proof_357✝¹)
(w₀ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proof_354✝²)
app₁ =
CategoryTheory.CategoryStruct.comp app₀
(g.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proof_354✝³))
_auto_397✝)
(w₁ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 1 2 _proof_238✝ _proof_355✝²) app₂ =
CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 _proof_238✝¹ _proof_355✝³))
_auto_399✝)
(w₂ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 2 3 _proof_291✝ _proof_356✝²) app₃ =
CategoryTheory.CategoryStruct.comp app₂ (g.map' 2 3 _proof_291✝¹ _proof_356✝³))
_auto_401✝)
(w₃ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 3 4 _proof_356✝⁴ _proof_357✝²) app₄ =
CategoryTheory.CategoryStruct.comp app₃ (g.map' 3 4 _proof_356✝⁵ _proof_357✝³))
_auto_403✝),
(CategoryTheory.ComposableArrows.homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app
⟨4, CategoryTheory.ComposableArrows.homMk₄._proof_5⟩ =
app₄ |
Real.arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ℝ → ℝ |
Subring.coe_intCast | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : Ring R] (s : Subring R) (n : ℤ), ↑↑n = ↑n |
MeasureTheory.self_subset_generateSetAlgebra | Mathlib.MeasureTheory.SetAlgebra | ∀ {α : Type u_1} {𝒜 : Set (Set α)}, 𝒜 ⊆ MeasureTheory.generateSetAlgebra 𝒜 |
Polynomial.coeff_zero_eq_prod_roots_of_monic_of_splits | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R],
f.Splits → f.Monic → f.coeff 0 = (-1) ^ f.natDegree * f.roots.prod |
NormedField.completeSpace_iff_isComplete_closedBall | Mathlib.Analysis.Normed.Field.Lemmas | ∀ {K : Type u_4} [inst : NormedField K], CompleteSpace K ↔ IsComplete (Metric.closedBall 0 1) |
AffineEquiv.ext_on | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] {V₂ : Type u_8} {P₂ : Type u_9} [inst_4 : AddCommGroup V₂] [inst_5 : Module k V₂]
[inst_6 : AddTorsor V₂ P₂] {s : Set P₁},
affineSpan k s = ⊤ → ∀ (T₁ T₂ : P₁ ≃ᵃ[k] P₂), Set.EqOn (⇑T₁) (⇑T₂) s → T₁ = T₂ |
pow_div_pow_eventuallyEq_atTop | Mathlib.Analysis.Asymptotics.SpecificAsymptotics | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {p q : ℕ},
(fun x => x ^ p / x ^ q) =ᶠ[Filter.atTop] fun x => x ^ (↑p - ↑q) |
Std.HashMap.isEmpty_union | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
(m₁ ∪ m₂).isEmpty = (m₁.isEmpty && m₂.isEmpty) |
MeasureTheory.Measure.ae_ae_of_ae_comp | Mathlib.Probability.Kernel.Composition.MeasureComp | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{κ : ProbabilityTheory.Kernel α β} {p : β → Prop},
(∀ᵐ (ω : β) ∂μ.bind ⇑κ, p ω) → ∀ᵐ (ω' : α) ∂μ, ∀ᵐ (ω : β) ∂κ ω', p ω |
Ultrafilter._sizeOf_inst | Mathlib.Order.Filter.Ultrafilter.Defs | (α : Type u_2) → [SizeOf α] → SizeOf (Ultrafilter α) |
CategoryTheory.Functor.LaxMonoidal.comp._proof_6 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCategory E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [inst_6 : F.LaxMonoidal] [inst_7 : G.LaxMonoidal]
(X : C),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor ((F.comp G).obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε G)
(G.map (CategoryTheory.Functor.LaxMonoidal.ε F)))
((F.comp G).obj X))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.μ G (F.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
(F.obj X))
(G.map (CategoryTheory.Functor.LaxMonoidal.μ F (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) X)))
((F.comp G).map (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom)) |
Lean.Elab.Term.expandShow | Lean.Elab.BuiltinNotation | Lean.Macro |
_private.Mathlib.NumberTheory.ModularForms.NormTrace.0.term𝒬 | Mathlib.NumberTheory.ModularForms.NormTrace | Lean.ParserDescr |
_private.Mathlib.Logic.Denumerable.0.Nat.Subtype.ofNat.match_1.eq_2 | Mathlib.Logic.Denumerable | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n |
_private.Init.Data.List.Sublist.0.List.append_subset._simp_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, (l₁ ⊆ l₂) = ∀ {a : α}, a ∈ l₁ → a ∈ l₂ |
oneLePart_eq_self._simp_2 | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a : α}, (a⁺ᵐ = a) = (1 ≤ a) |
birkhoffAverage_one' | Mathlib.Dynamics.BirkhoffSum.Average | ∀ (R : Type u_1) {α : Type u_2} {M : Type u_3} [inst : DivisionSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (f : α → α) (g : α → M), birkhoffAverage R f g 1 = g |
Lean.Elab.Term.expandTermFor | Lean.Elab.Do.Switch | Lean.Macro |
_private.Mathlib.Analysis.SpecialFunctions.Log.NegMulLog.0.Real.strictConvexOn_mul_log._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ∀ {α : Type u_1} [inst : Preorder α] {a : α} [NoMinOrder α], (Set.Iio a).Nonempty = True |
Std.Time.Awareness.only.inj | Std.Time.Format.Basic | ∀ {a a_1 : Std.Time.TimeZone}, Std.Time.Awareness.only a = Std.Time.Awareness.only a_1 → a = a_1 |
Std.DTreeMap.Internal.Impl.Const.size_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).size =
if k ∈ t ∧ (f (Std.DTreeMap.Internal.Impl.Const.get? t k)).isNone = true then t.size - 1
else if k ∉ t ∧ (f (Std.DTreeMap.Internal.Impl.Const.get? t k)).isSome = true then t.size + 1 else t.size |
Nat.one_lt_radical_iff | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ}, 1 < UniqueFactorizationMonoid.radical n ↔ 1 < n |
RingHom.comp | Mathlib.Algebra.Ring.Hom.Defs | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
{x : NonAssocSemiring α} →
{x_1 : NonAssocSemiring β} → {x_2 : NonAssocSemiring γ} → (β →+* γ) → (α →+* β) → α →+* γ |
Sublattice.copy._proof_2 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (L : Sublattice α) (s : Set α), s = ↑L → InfClosed s |
CategoryTheory.StrongMono.iff_of_arrow_iso | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g), CategoryTheory.StrongMono f ↔ CategoryTheory.StrongMono g |
LieModule.toEnd_pow_lie | Mathlib.Algebra.Lie.OfAssociative | ∀ (R : Type u) {L : Type v} {M : Type w} [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] (x y : L)
(z : M) (n : ℕ),
((LieModule.toEnd R L M) x ^ n) ⁅y, z⁆ =
∑ ij ∈ Finset.antidiagonal n,
n.choose ij.1 • ⁅((LieAlgebra.ad R L) x ^ ij.1) y, ((LieModule.toEnd R L M) x ^ ij.2) z⁆ |
_private.Lean.Meta.Match.MatcherApp.Basic.0.Lean.Meta.matchMatcherApp?.match_7 | Lean.Meta.Match.MatcherApp.Basic | (motive : Lean.ConstantInfo → Sort u_1) →
(__discr : Lean.ConstantInfo) →
((info : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo info)) →
((x : Lean.ConstantInfo) → motive x) → motive __discr |
expNegInvGlue.zero_iff_nonpos._simp_1 | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ∀ {x : ℝ}, (expNegInvGlue x = 0) = (x ≤ 0) |
LinearMap.rank_le_range | Mathlib.LinearAlgebra.Dimension.LinearMap | ∀ {K : Type u} {V : Type v} {V' : Type v'} [inst : Ring K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V'] [inst_4 : Module K V'] (f : V →ₗ[K] V'), f.rank ≤ Module.rank K V' |
List.Pairwise.below.rec | Init.Data.List.Basic | ∀ {α : Type u} {R : α → α → Prop} {motive : (a : List α) → List.Pairwise R a → Prop}
{motive_1 : {a : List α} → (t : List.Pairwise R a) → List.Pairwise.below t → Prop},
motive_1 ⋯ ⋯ →
(∀ {a : α} {l : List α} (a_1 : ∀ a' ∈ l, R a a') (a_2 : List.Pairwise R l) (ih : List.Pairwise.below a_2)
(a_ih : motive l a_2), motive_1 a_2 ih → motive_1 ⋯ ⋯) →
∀ {a : List α} {t : List.Pairwise R a} (t_1 : List.Pairwise.below t), motive_1 t t_1 |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.dvd_gcd_iff.match_1_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (a b c : α) (motive : a ∣ b ∧ a ∣ c → Prop) (x : a ∣ b ∧ a ∣ c),
(∀ (hab : a ∣ b) (hac : a ∣ c), motive ⋯) → motive x |
CategoryTheory.hasLeftDualOfEquivalence | Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence | {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] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
[F.Monoidal] →
{G : CategoryTheory.Functor D C} →
(F ⊣ G) →
[F.IsEquivalence] → (X : C) → [CategoryTheory.HasLeftDual (F.obj X)] → CategoryTheory.HasLeftDual X |
Set.Sized.upShadow | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {r : ℕ},
Set.Sized r ↑𝒜 → Set.Sized (r + 1) ↑𝒜.upShadow |
MeasurableSMul₂.measurable_smul | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} {inst : SMul M α} {inst_1 : MeasurableSpace M} {inst_2 : MeasurableSpace α}
[self : MeasurableSMul₂ M α], Measurable (Function.uncurry fun x1 x2 => x1 • x2) |
CategoryTheory.Core.functorToCore._proof_2 | Mathlib.CategoryTheory.Core | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : Type u_4} [inst_1 : CategoryTheory.Groupoid G]
(F : CategoryTheory.Functor G C) {X Y : G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.Groupoid.inv f)) =
CategoryTheory.CategoryStruct.id { of := F.obj X }.of |
LinearMap.instFunLike._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_2} {M₃ : Type u_1} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
(f g : M →ₛₗ[σ] M₃), (fun f => f.toFun) f = (fun f => f.toFun) g → f = g |
CategoryTheory.Limits.punitCoconeIsColimit._proof_4 | Mathlib.CategoryTheory.Limits.Unit | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J]
{F : CategoryTheory.Functor J (CategoryTheory.Discrete PUnit.{u_2 + 1})} {c : CategoryTheory.Limits.Cocone F}
(s : CategoryTheory.Limits.Cocone F) (m : c.pt ⟶ s.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp (c.ι.app j) m = s.ι.app j) → m = CategoryTheory.eqToHom ⋯ |
NonUnitalSubalgebra.map_toSubmodule | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {F : Type v'} {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : NonUnitalNonAssocSemiring B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : FunLike F A B]
[inst_6 : NonUnitalAlgHomClass F R A B] {S : NonUnitalSubalgebra R A} {f : F},
(NonUnitalSubalgebra.map f S).toSubmodule = Submodule.map (LinearMapClass.linearMap f) S.toSubmodule |
CategoryTheory.Limits.pullbackPullbackLeftIsPullback._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X₁ X₂ X₃ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₁)
(f₃ : X₂ ⟶ Y₂) (f₄ : X₃ ⟶ Y₂) [inst_1 : CategoryTheory.Limits.HasPullback f₁ f₂]
[inst_2 :
CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f₁ f₂) f₃)
f₄],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f₁ f₂) f₃) f₄)
(CategoryTheory.Limits.pullback.snd f₁ f₂))
f₃ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd f₁ f₂) f₃) f₄)
f₄ |
RingCat.Hom.noConfusion | Mathlib.Algebra.Category.Ring.Basic | {P : Sort u_1} →
{R S : RingCat} →
{t : R.Hom S} → {R' S' : RingCat} → {t' : R'.Hom S'} → R = R' → S = S' → t ≍ t' → RingCat.Hom.noConfusionType P t t' |
Lean.Meta.mkAbsurd | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr |
RootPairing._sizeOf_inst | Mathlib.LinearAlgebra.RootSystem.Defs | (ι : 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} → [SizeOf ι] → [SizeOf R] → [SizeOf M] → [SizeOf N] → SizeOf (RootPairing ι R M N) |
RingConGen.Rel.mul | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] {r : R → R → Prop} {w x y z : R},
RingConGen.Rel r w x → RingConGen.Rel r y z → RingConGen.Rel r (w * y) (x * z) |
_private.Mathlib.Data.Set.Insert.0.Set.setOf_mem_list_eq_replicate._simp_1_4 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {a : α} {n : ℕ} {l : List α}, (l = List.replicate n a) = (l.length = n ∧ ∀ b ∈ l, b = a) |
_private.Mathlib.GroupTheory.ArchimedeanDensely.0.LinearOrderedCommGroup.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete._simp_1_1 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulLeftMono α] [MulRightMono α] {a b : α}, (a⁻¹ ≤ b) = (b⁻¹ ≤ a) |
ComputablePred.halting_problem_not_re | Mathlib.Computability.Halting | ∀ (n : ℕ), ¬REPred fun c => ¬(c.eval n).Dom |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.forIn'_toList.aux | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {ρ : Type u} {α : Type v} {γ : Type x} {m : Type x → Type x'} [Monad m] {x : Membership α ρ}
[inst : ForIn' m ρ α inferInstance] {r s : ρ} {init : γ} {f : (a : α) → a ∈ r → γ → m (ForInStep γ)} (h : r = s),
forIn' r init f = forIn' s init fun a h' acc => f a ⋯ acc |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryToUnit._proof_10 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ⦃X_1 Y : CategoryTheory.Over X⦄ (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Over X)).map f_1)
(CategoryTheory.Over.homMk
(CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id (CategoryTheory.Over X)).obj Y).left) Y.hom)
⋯) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.homMk
(CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id (CategoryTheory.Over X)).obj X_1).left) X_1.hom)
⋯)
(((CategoryTheory.Over.map f).comp
{ obj := fun Y => CategoryTheory.Over.mk (CategoryTheory.SemiCartesianMonoidalCategory.snd Y.left X),
map := fun {Y Z} g =>
CategoryTheory.Over.homMk (CategoryTheory.MonoidalCategoryStruct.whiskerRight g.left X) ⋯,
map_id := ⋯, map_comp := ⋯ }).map
f_1) |
LinearEquiv.domMulActCongrRight._proof_4 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {S : Type u_1} {R₁ : Type u_2} {R₁' : Type u_3} {R₂' : Type u_7} {M₁ : Type u_4} {M₁' : Type u_5} {M₂' : Type u_6}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8 : Module R₂' M₂'] {σ₁'₂' : R₁' →+* R₂'} {σ₂'₁' : R₂' →+* R₁'} {σ₁₁' : R₁ →+* R₁'} {σ₁₂' : R₁ →+* R₂'}
[inst_9 : RingHomInvPair σ₁'₂' σ₂'₁'] [inst_10 : RingHomInvPair σ₂'₁' σ₁'₂']
[inst_11 : RingHomCompTriple σ₁₁' σ₁'₂' σ₁₂'] [inst_12 : Semiring S] [inst_13 : Module S M₁]
[inst_14 : SMulCommClass R₁ S M₁] [inst_15 : RingHomCompTriple σ₁₂' σ₂'₁' σ₁₁'] (e₂ : M₁' ≃ₛₗ[σ₁'₂'] M₂') (b : Sᵈᵐᵃ)
(x : M₁ →ₛₗ[σ₁₁'] M₁'),
((LinearEquiv.refl R₁ M₁).arrowCongrAddEquiv e₂).toFun (b • x) =
(RingHom.id Sᵈᵐᵃ) b • ((LinearEquiv.refl R₁ M₁).arrowCongrAddEquiv e₂).toFun x |
_private.Init.Data.Nat.Fold.0.Nat.dfold.loop._proof_3 | Init.Data.Nat.Fold | ∀ (n m : ℕ), n - m.succ ≤ n |
RatFunc.valuedRatFunc._proof_1 | Mathlib.FieldTheory.RatFunc.AsPolynomial | IsOrderedMonoid (Multiplicative ℤ) |
Poly.instAddCommGroup._proof_6 | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} (n : ℕ) (x : Poly α), nsmulRec (n + 1) x = nsmulRec n x + x |
Aesop.UnfoldRule.instHashable | Aesop.Rule | Hashable Aesop.UnfoldRule |
MeasureTheory.integral_pos_iff_support_of_nonneg | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
0 ≤ f → MeasureTheory.Integrable f μ → (0 < ∫ (x : α), f x ∂μ ↔ 0 < μ (Function.support f)) |
CategoryTheory.Oplax.OplaxTrans.Modification.id._proof_2 | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (η : F ⟶ G) {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map f) (CategoryTheory.CategoryStruct.id (η.app b))) (η.naturality f) =
CategoryTheory.CategoryStruct.comp (η.naturality f)
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.CategoryStruct.id (η.app a)) (G.map f)) |
Fin.preimage_castLE_uIoc_castLE | Mathlib.Order.Interval.Set.Fin | ∀ {m n : ℕ} (i j : Fin m) (h : m ≤ n), Fin.castLE h ⁻¹' Set.uIoc (Fin.castLE h i) (Fin.castLE h j) = Set.uIoc i j |
MulEquiv.map_finprod_mem | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} {N : Type u_6} [inst : CommMonoid M] [inst_1 : CommMonoid N] (g : M ≃* N) (f : α → M)
{s : Set α}, s.Finite → g (∏ᶠ (i : α) (_ : i ∈ s), f i) = ∏ᶠ (i : α) (_ : i ∈ s), g (f i) |
_private.Mathlib.NumberTheory.FLT.Polynomial.0.fermatLastTheoremWith'_polynomial._simp_1_3 | Mathlib.NumberTheory.FLT.Polynomial | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] [inst_2 : UniqueFactorizationMonoid α]
{x y : α},
x ≠ 0 →
y ≠ 0 → (x ∣ y) = (UniqueFactorizationMonoid.normalizedFactors x ≤ UniqueFactorizationMonoid.normalizedFactors y) |
AlgebraicGeometry.ValuativeCriterion | Mathlib.AlgebraicGeometry.ValuativeCriterion | CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme |
Lean.AsyncConstantInfo.mk | Lean.Environment | Lean.Name → Lean.ConstantKind → Task Lean.ConstantVal → Task Lean.ConstantInfo → Lean.AsyncConstantInfo |
SeminormedGroup.mem_closure_iff | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : SeminormedGroup E] {s : Set E} {a : E},
a ∈ closure s ↔ ∀ (ε : ℝ), 0 < ε → ∃ b ∈ s, ‖a⁻¹ * b‖ < ε |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn.edge._simp_10 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
_private.Mathlib.RingTheory.WittVector.DiscreteValuationRing.0.WittVector.inverseCoeff.match_1._arg_pusher | Mathlib.RingTheory.WittVector.DiscreteValuationRing | ∀ (motive : ℕ → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x) (rel : ℕ → α → Prop) (x : ℕ)
(h_1 : Unit → ((y : α) → rel 0 y → β y) → motive 0) (h_2 : (n : ℕ) → ((y : α) → rel n.succ y → β y) → motive n.succ),
((match (motive := (x : ℕ) → ((y : α) → rel x y → β y) → motive x) x with
| 0 => fun x => h_1 a x
| n.succ => fun x => h_2 n x)
fun y h => f y) =
match x with
| 0 => h_1 a fun y h => f y
| n.succ => h_2 n fun y h => f y |
SeminormedAddCommGroup.mk.noConfusion | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
{P : Sort u} →
{toNorm : Norm E} →
{toAddCommGroup : AddCommGroup E} →
{toPseudoMetricSpace : PseudoMetricSpace E} →
{dist_eq : autoParam (∀ (x y : E), dist x y = ‖-x + y‖) SeminormedAddCommGroup.dist_eq._autoParam} →
{toNorm' : Norm E} →
{toAddCommGroup' : AddCommGroup E} →
{toPseudoMetricSpace' : PseudoMetricSpace E} →
{dist_eq' : autoParam (∀ (x y : E), dist x y = ‖-x + y‖) SeminormedAddCommGroup.dist_eq._autoParam} →
{ toNorm := toNorm, toAddCommGroup := toAddCommGroup, toPseudoMetricSpace := toPseudoMetricSpace,
dist_eq := dist_eq } =
{ toNorm := toNorm', toAddCommGroup := toAddCommGroup',
toPseudoMetricSpace := toPseudoMetricSpace', dist_eq := dist_eq' } →
(toNorm ≍ toNorm' →
toAddCommGroup ≍ toAddCommGroup' → toPseudoMetricSpace ≍ toPseudoMetricSpace' → P) →
P |
AlgCat.instBraidedModuleCatForget₂AlgHomCarrierLinearMapIdCarrier._proof_1 | Mathlib.Algebra.Category.AlgCat.Symmetric | ∀ {R : Type u_1} [inst : CommRing R] (X Y : AlgCat R),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.forget₂ (AlgCat R) (ModuleCat R)) X Y)
((CategoryTheory.forget₂ (AlgCat R) (ModuleCat R)).map (β_ X Y).hom) =
CategoryTheory.CategoryStruct.comp
(β_ ((CategoryTheory.forget₂ (AlgCat R) (ModuleCat R)).obj X)
((CategoryTheory.forget₂ (AlgCat R) (ModuleCat R)).obj Y)).hom
(CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.forget₂ (AlgCat R) (ModuleCat R)) Y X) |
List.IsZeckendorfRep.sum_fib_lt | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ {n : ℕ} {l : List ℕ}, l.IsZeckendorfRep → (∀ a ∈ (l ++ [0]).head?, a < n) → (List.map Nat.fib l).sum < Nat.fib n |
supsSupHom_apply | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} [inst : CompleteLattice α] (x : α × α), supsSupHom x = x.1 ⊔ x.2 |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.map_sym_eq_piAntidiag._simp_1_1 | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α] {n : ℕ} {m : Sym α n}, (m ∈ s.sym n) = ∀ a ∈ m, a ∈ s |
HasStrictDerivAt.sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {f : ℝ → ℝ} {f' x : ℝ}, HasStrictDerivAt f f' x → HasStrictDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x |
SemilatticeSup.mk'._proof_1 | Mathlib.Order.Lattice | ∀ {α : Type u_1} [inst : Max α],
(∀ (a b c : α), a ⊔ b ⊔ c = a ⊔ (b ⊔ c)) → ∀ (a b c : α), a ⊔ b = b → b ⊔ c = c → a ⊔ c = c |
Nat.sqrt.iter_sq_le | Mathlib.Data.Nat.Sqrt | ∀ (n guess : ℕ), Nat.sqrt.iter n guess * Nat.sqrt.iter n guess ≤ n |
Sublocale.mk_le_mk._simp_1 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (carrier₁ carrier₂ : Set X) (sInf_mem'₁ : ∀ s ⊆ carrier₁, sInf s ∈ carrier₁)
(sInf_mem'₂ : ∀ s ⊆ carrier₂, sInf s ∈ carrier₂) (himp_mem'₁ : ∀ (a b : X), b ∈ carrier₁ → a ⇨ b ∈ carrier₁)
(himp_mem'₂ : ∀ (a b : X), b ∈ carrier₂ → a ⇨ b ∈ carrier₂),
({ carrier := carrier₁, sInf_mem' := sInf_mem'₁, himp_mem' := himp_mem'₁ } ≤
{ carrier := carrier₂, sInf_mem' := sInf_mem'₂, himp_mem' := himp_mem'₂ }) =
(carrier₁ ⊆ carrier₂) |
CategoryTheory.η_app | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.MonoidalCategory D] [inst_4 : CategoryTheory.MonoidalCategory E]
(L : CategoryTheory.Functor D E) [inst_5 : L.OplaxMonoidal] (X : C),
(CategoryTheory.Functor.OplaxMonoidal.η ((CategoryTheory.Functor.whiskeringRight C D E).obj L)).app X =
CategoryTheory.Functor.OplaxMonoidal.η L |
USize.xor_assoc | Init.Data.UInt.Bitwise | ∀ (a b c : USize), a ^^^ b ^^^ c = a ^^^ (b ^^^ c) |
Aesop.GoalKind.preNorm | Aesop.Stats.Basic | Aesop.GoalKind |
InitialSeg.mk.noConfusion | Mathlib.Order.InitialSeg | {α : Type u_4} →
{β : Type u_5} →
{r : α → α → Prop} →
{s : β → β → Prop} →
{P : Sort u} →
{toRelEmbedding : r ↪r s} →
{mem_range_of_rel' : ∀ (a : α) (b : β), s b (toRelEmbedding a) → b ∈ Set.range ⇑toRelEmbedding} →
{toRelEmbedding' : r ↪r s} →
{mem_range_of_rel'' : ∀ (a : α) (b : β), s b (toRelEmbedding' a) → b ∈ Set.range ⇑toRelEmbedding'} →
{ toRelEmbedding := toRelEmbedding, mem_range_of_rel' := mem_range_of_rel' } =
{ toRelEmbedding := toRelEmbedding', mem_range_of_rel' := mem_range_of_rel'' } →
(toRelEmbedding ≍ toRelEmbedding' → P) → P |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.floor_add_nsmul_self | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι] {x : ι → ℕ}
{i : ↑(IsProperLinearSet.basisSet✝ hs)} {n : ℕ},
IsProperLinearSet.floor✝ hs (x + n • ↑i) i = IsProperLinearSet.floor✝¹ hs x i + ↑n |
_private.Std.Time.Notation.0.Std.Time.convertPlainTime | Std.Time.Notation | Std.Time.PlainTime → Lean.MacroM (Lean.TSyntax `term) |
Prod.instIsOrderBornology | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} [inst : Bornology α] [inst_1 : Preorder α] [IsOrderBornology α] {β : Type u_2} [inst_3 : Preorder β]
[inst_4 : Bornology β] [IsOrderBornology β], IsOrderBornology (α × β) |
IsCompact.exists_mapClusterPt_of_frequently | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} {ι : Type u_1} [inst : TopologicalSpace X] {s : Set X} {l : Filter ι} {f : ι → X},
IsCompact s → (∃ᶠ (x : ι) in l, f x ∈ s) → ∃ a ∈ s, MapClusterPt a l f |
Lean.Meta.Sym.Internal.AlphaShareBuilderM | Lean.Meta.Sym.AlphaShareBuilder | Type → Type |
CategoryTheory.Functor.leftDerivedZeroIsoSelf_inv_hom_id_app_assoc | Mathlib.CategoryTheory.Abelian.LeftDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasProjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
[inst_6 : CategoryTheory.Limits.PreservesFiniteColimits F] (X : C) {Z : D} (h : F.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.leftDerivedZeroIsoSelf.inv.app X)
(CategoryTheory.CategoryStruct.comp (F.fromLeftDerivedZero.app X) h) =
h |
Commute.symm | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Mul S] {a b : S}, Commute a b → Commute b a |
_private.Mathlib.LinearAlgebra.Matrix.Circulant.0.Matrix.Fin.transpose_circulant.match_1_1 | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x |
_private.Mathlib.Algebra.Homology.LocalCohomology.0.localCohomology.idealPowersToSelfLERadical._simp_1 | Mathlib.Algebra.Homology.LocalCohomology | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True |
star_nnratCast | Mathlib.Algebra.Star.Rat | ∀ {R : Type u_1} [inst : DivisionSemiring R] [inst_1 : StarRing R] (q : ℚ≥0), star ↑q = ↑q |
CategoryTheory.Enriched.FunctorCategory.functorEnriched_id_comp_assoc | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] {J : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] (F₁ F₂ : CategoryTheory.Functor J C)
[inst_5 : CategoryTheory.Enriched.FunctorCategory.HasFunctorEnrichedHom V F₁ F₂]
[inst_6 : CategoryTheory.Enriched.FunctorCategory.HasFunctorEnrichedHom V F₁ F₁] {Z : CategoryTheory.Functor J V}
(h : CategoryTheory.Enriched.FunctorCategory.functorEnrichedHom V F₁ F₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
(CategoryTheory.Enriched.FunctorCategory.functorEnrichedHom V F₁ F₂)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Enriched.FunctorCategory.functorEnrichedId V F₁)
(CategoryTheory.Enriched.FunctorCategory.functorEnrichedHom V F₁ F₂))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Enriched.FunctorCategory.functorEnrichedComp V F₁ F₁ F₂)
h)) =
h |
Lean.Meta.Grind.SymbolPriorityEntry.mk._flat_ctor | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Name → ℕ → Lean.Meta.Grind.SymbolPriorityEntry |
GroupLike.toUnits._proof_1 | Mathlib.RingTheory.HopfAlgebra.GroupLike | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A],
{ val := ↑1, inv := (HopfAlgebraStruct.antipode R) ↑1, val_inv := ⋯, inv_val := ⋯ } = 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.