name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
AddCon.pi.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {ι : Type u_4} {f : ι → Type u_5} [inst : (i : ι) → Add (f i)] (C : (i : ι) → AddCon (f i)),
AddCon.pi C = { toSetoid := piSetoid, add' := ⋯ } |
CategoryTheory.ShortComplex.Homotopy.rec | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ₁ φ₂ : S₁ ⟶ S₂} →
{motive : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ → Sort u} →
((h₀ : S₁.X₁ ⟶ S₂.X₁) →
(h₀_f : CategoryTheory.CategoryStruct.comp h₀ S₂.f = 0) →
(h₁ : S₁.X₂ ⟶ S₂.X₁) →
(h₂ : S₁.X₃ ⟶ S₂.X₂) →
(h₃ : S₁.X₃ ⟶ S₂.X₃) →
(g_h₃ : CategoryTheory.CategoryStruct.comp S₁.g h₃ = 0) →
(comm₁ : φ₁.τ₁ = CategoryTheory.CategoryStruct.comp S₁.f h₁ + h₀ + φ₂.τ₁) →
(comm₂ :
φ₁.τ₂ =
CategoryTheory.CategoryStruct.comp S₁.g h₂ +
CategoryTheory.CategoryStruct.comp h₁ S₂.f +
φ₂.τ₂) →
(comm₃ : φ₁.τ₃ = h₃ + CategoryTheory.CategoryStruct.comp h₂ S₂.g + φ₂.τ₃) →
motive
{ h₀ := h₀, h₀_f := h₀_f, h₁ := h₁, h₂ := h₂, h₃ := h₃, g_h₃ := g_h₃, comm₁ := comm₁,
comm₂ := comm₂, comm₃ := comm₃ }) →
(t : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂) → motive t |
PEquiv.injective_of_forall_isSome | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} {f : α ≃. β}, (∀ (a : α), (f a).isSome = true) → Function.Injective ⇑f |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj_ε | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommMon C),
CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj A) =
CategoryTheory.MonObj.one |
List.sum | Init.Data.List.Basic | {α : Type u_1} → [Add α] → [Zero α] → List α → α |
HomotopyGroup.commGroup._proof_2 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} [inst : Nontrivial N], ∃ y, y ≠ Classical.arbitrary N |
Set.Finite.induction_on_subset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {motive : (s : Set α) → s.Finite → Prop} (s : Set α) (hs : s.Finite),
motive ∅ ⋯ →
(∀ {a : α} {t : Set α}, a ∈ s → ∀ (hts : t ⊆ s), a ∉ t → motive t ⋯ → motive (insert a t) ⋯) → motive s hs |
Lean.Meta.Simp.Result.mk.noConfusion | Lean.Meta.Tactic.Simp.Types | {P : Sort u} →
{expr : Lean.Expr} →
{proof? : Option Lean.Expr} →
{cache : Bool} →
{expr' : Lean.Expr} →
{proof?' : Option Lean.Expr} →
{cache' : Bool} →
{ expr := expr, proof? := proof?, cache := cache } =
{ expr := expr', proof? := proof?', cache := cache' } →
(expr = expr' → proof? = proof?' → cache = cache' → P) → P |
_private.Init.Data.String.Lemmas.Iterate.0.String.Model.revPositionsFrom._proof_1 | Init.Data.String.Lemmas.Iterate | ∀ {s : String}, WellFounded (invImage (fun x => x.down) String.Pos.instWellFoundedRelationDown).1 |
_private.Lean.ImportingFlag.0.Lean.initFn._@.Lean.ImportingFlag.2251799370._hygCtx._hyg.2 | Lean.ImportingFlag | IO (IO.Ref Bool) |
CategoryTheory.MonObj.one_associator | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N P : C}
[inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] [inst_4 : CategoryTheory.MonObj P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.MonObj.one CategoryTheory.MonObj.one))
CategoryTheory.MonObj.one))
(CategoryTheory.MonoidalCategoryStruct.associator M N P).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.MonObj.one
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.MonObj.one CategoryTheory.MonObj.one))) |
Array.reverse_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : α → α_1 → α_2} {as : Array α} {bs : Array α_1},
as.size = bs.size → (Array.zipWith f as bs).reverse = Array.zipWith f as.reverse bs.reverse |
LinearPMap.inverse_apply_eq | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {f : E →ₗ.[R] F},
f.toFun.ker = ⊥ → ∀ {y : ↥f.inverse.domain} {x : ↥f.domain}, ↑f x = ↑y → ↑f.inverse y = ↑x |
Lean.MonadCache.noConfusionType | Lean.Util.MonadCache | Sort u →
{α β : Type} →
{m : Type → Type} → Lean.MonadCache α β m → {α' β' : Type} → {m' : Type → Type} → Lean.MonadCache α' β' m' → Sort u |
Lean.Parser.Command.versoCommentBody.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer |
Polynomial.resultant_add_mul_right | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g p : Polynomial R) (m n : ℕ),
p.natDegree + m ≤ n → f.natDegree ≤ m → f.resultant (g + f * p) m n = f.resultant g m n |
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan._proof_7 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
{X_1 Y_1 Z_1 : CategoryTheory.Limits.PushoutCocone f g} (f_1 : X_1 ⟶ Y_1) (g_1 : Y_1 ⟶ Z_1),
{ hom := CategoryTheory.Under.homMk (CategoryTheory.CategoryStruct.comp f_1 g_1).hom ⋯, w := ⋯ } =
CategoryTheory.CategoryStruct.comp { hom := CategoryTheory.Under.homMk f_1.hom ⋯, w := ⋯ }
{ hom := CategoryTheory.Under.homMk g_1.hom ⋯, w := ⋯ } |
_private.Init.Data.Iterators.Consumers.Access.0.Std.Iter.atIdxSlow?.match_3.eq_2 | Init.Data.Iterators.Consumers.Access | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β) (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(property : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.Iter β) →
(out : β) →
(property : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, property⟩)
(h_2 :
(it' : Std.Iter β) →
(property : it.IsPlausibleStep (Std.IterStep.skip it')) → motive ⟨Std.IterStep.skip it', property⟩)
(h_3 : (property : it.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, property⟩),
(match ⟨Std.IterStep.skip it', property⟩ with
| ⟨Std.IterStep.yield it' out, property⟩ => h_1 it' out property
| ⟨Std.IterStep.skip it', property⟩ => h_2 it' property
| ⟨Std.IterStep.done, property⟩ => h_3 property) =
h_2 it' property |
_private.Init.Data.Order.FactoriesExtra.0.DecidableLE.ofOrd._simp_3 | Init.Data.Order.FactoriesExtra | ∀ {α : Type u} {inst : Ord α} {inst_1 : LE α} [self : Std.LawfulOrderOrd α] (a b : α),
((compare a b).isLE = true) = (a ≤ b) |
Subgroup.coe_subgroupOf | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), ↑(H.subgroupOf K) = ⇑K.subtype ⁻¹' ↑H |
ProfiniteGrp.ProfiniteCompletion.adjunction._proof_2 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {X' X : GrpCat} {Y : ProfiniteGrp.{u_1}} (f : X' ⟶ X)
(g : X ⟶ (CategoryTheory.forget₂ ProfiniteGrp.{u_1} GrpCat).obj Y),
(ProfiniteGrp.ProfiniteCompletion.homEquiv X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (ProfiniteGrp.profiniteCompletion.map f)
((ProfiniteGrp.ProfiniteCompletion.homEquiv X Y).symm g) |
NonUnitalStarSubalgebra.coe_add | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : Star A] (S : NonUnitalStarSubalgebra R A) (x y : ↥S), ↑(x + y) = ↑x + ↑y |
inv_add_inv | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : Semifield K] {a b : K}, a ≠ 0 → b ≠ 0 → a⁻¹ + b⁻¹ = (a + b) / (a * b) |
IsDedekindDomain.HeightOneSpectrum.instAlgebraSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers._proof_6 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ (R : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_1) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R)
(x : ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v)),
{ toFun := fun r => ⟨↑((algebraMap R K) r), ⋯⟩, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ } r * x =
x * { toFun := fun r => ⟨↑((algebraMap R K) r), ⋯⟩, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ } r |
Polynomial.shiftedLegendre | Mathlib.RingTheory.Polynomial.ShiftedLegendre | ℕ → Polynomial ℤ |
ENat.top_sub_one | Mathlib.Data.ENat.Basic | ⊤ - 1 = ⊤ |
KaehlerDifferential.derivationQuotKerTotal._proof_5 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
((KaehlerDifferential.kerTotal R S).mkQ fun₀ | 1 => 1) = 0 |
AlgebraicGeometry.IsClosedImmersion.comp_iff | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {g : Y ⟶ Z} [AlgebraicGeometry.IsClosedImmersion g],
AlgebraicGeometry.IsClosedImmersion (CategoryTheory.CategoryStruct.comp f g) ↔ AlgebraicGeometry.IsClosedImmersion f |
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (U : ↑X.affineOpens), ↑U ∈ X.affineOpens |
ContDiffMapSupportedIn.coe_of_support_subset | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} {f : E → F} (hf : ContDiff ℝ (↑n) f)
(hsupp : Function.support f ⊆ ↑K) (a : E), (ContDiffMapSupportedIn.of_support_subset hf hsupp) a = f a |
MulActionHom.instCoeTCOfMulActionSemiHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{F : Type u_8} [inst_2 : FunLike F X Y] [inst_3 : MulActionSemiHomClass F φ X Y],
MulActionHom.instCoeTCOfMulActionSemiHomClass = { coe := MulActionSemiHomClass.toMulActionHom } |
Bundle.Trivialization.zeroSection | Mathlib.Topology.VectorBundle.Basic | ∀ (R : Type u_1) {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_7 : (x : B) → TopologicalSpace (E x)] [FiberBundle F E] (e : Bundle.Trivialization F Bundle.TotalSpace.proj)
[Bundle.Trivialization.IsLinear R e] {x : B}, x ∈ e.baseSet → ↑e (Bundle.zeroSection F E x) = (x, 0) |
AddAction.fixedPoints | Mathlib.GroupTheory.GroupAction.Defs | (M : Type u_1) → (α : Type u_3) → [inst : AddMonoid M] → [AddAction M α] → Set α |
finite_mulSupport_of_finprod_ne_one | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M}, ∏ᶠ (i : α), f i ≠ 1 → (Function.mulSupport f).Finite |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {ka : ℤ} {ca? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr} {kb : ℕ}
{cb? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr} {ka_1 : ℤ} {ca?_1 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr}
{kb_1 : ℕ} {cb?_1 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr},
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow ka ca? kb cb? =
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow ka_1 ca?_1 kb_1 cb?_1 →
ka = ka_1 ∧ ca? = ca?_1 ∧ kb = kb_1 ∧ cb? = cb?_1 |
Mathlib.Tactic.ModCases.IntMod.proveOnModCases | Mathlib.Tactic.ModCases | {u : Lean.Level} →
(n : Q(ℕ)) →
(a : Q(ℤ)) →
(b : Q(ℕ)) →
(p : Q(Sort u)) →
Lean.MetaM (Q(Mathlib.Tactic.ModCases.IntMod.OnModCases «$n» «$a» «$b» «$p») × List Lean.MVarId) |
NormedAddCommGroup.toSeminormedAddCommGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} → [NormedAddCommGroup E] → SeminormedAddCommGroup E |
PadicInt.modPart | Mathlib.NumberTheory.Padics.RingHoms | ℕ → ℚ → ℤ |
Polynomial.card_roots_le_map | Mathlib.Algebra.Polynomial.Roots | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : IsDomain A] [inst_3 : IsDomain B]
{p : Polynomial A} {f : A →+* B}, Polynomial.map f p ≠ 0 → p.roots.card ≤ (Polynomial.map f p).roots.card |
Lean.Compiler.LCNF.CacheAuxDeclResult.ctorElim | Lean.Compiler.LCNF.AuxDeclCache | {motive : Lean.Compiler.LCNF.CacheAuxDeclResult → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Compiler.LCNF.CacheAuxDeclResult) →
ctorIdx = t.ctorIdx → Lean.Compiler.LCNF.CacheAuxDeclResult.ctorElimType ctorIdx → motive t |
mul_invOf_cancel_right | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] (a b : α) [inst_1 : Invertible b], a * b * ⅟b = a |
MonoidHom.coe_mrangeRestrict | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {N : Type u_5} [inst_1 : MulOneClass N] (f : M →* N) (x : M),
↑(f.mrangeRestrict x) = f x |
CategoryTheory.Limits.pullbackPullbackRightIsPullback._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} 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 f₃ f₄]
[inst_3 :
CategoryTheory.Limits.HasPullback f₁
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f₃ f₄) f₂)],
CategoryTheory.Limits.IsLimit
((CategoryTheory.Limits.PullbackCone.mk (CategoryTheory.Limits.pullback.fst f₁ f₂)
(CategoryTheory.Limits.pullback.snd f₁ f₂) ⋯).pasteVert
(CategoryTheory.Limits.PullbackCone.mk
(CategoryTheory.Limits.pullback.lift
(CategoryTheory.Limits.pullback.fst f₁
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f₃ f₄) f₂))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd f₁
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f₃ f₄) f₂))
(CategoryTheory.Limits.pullback.fst f₃ f₄))
⋯)
(CategoryTheory.Limits.pullback.snd f₁
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f₃ f₄) f₂))
⋯)
⋯) =
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.PullbackCone.mk
(CategoryTheory.Limits.pullback.fst f₁
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f₃ f₄) f₂))
(CategoryTheory.Limits.pullback.snd f₁
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f₃ f₄) f₂))
⋯) |
Std.DTreeMap.Internal.Impl.ExplorationStep.casesOn | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{k : α → Ordering} →
{motive : Std.DTreeMap.Internal.Impl.ExplorationStep α β k → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl.ExplorationStep α β k) →
((a : α) →
(a_1 : k a = Ordering.lt) →
(a_2 : β a) →
(a_3 : List ((a : α) × β a)) →
motive (Std.DTreeMap.Internal.Impl.ExplorationStep.lt a a_1 a_2 a_3)) →
((a : List ((a : α) × β a)) →
(a_1 : Std.DTreeMap.Internal.Cell α β k) →
(a_2 : List ((a : α) × β a)) → motive (Std.DTreeMap.Internal.Impl.ExplorationStep.eq a a_1 a_2)) →
((a : List ((a : α) × β a)) →
(a_1 : α) →
(a_2 : k a_1 = Ordering.gt) →
(a_3 : β a_1) → motive (Std.DTreeMap.Internal.Impl.ExplorationStep.gt a a_1 a_2 a_3)) →
motive t |
FreeAlgebra.instNoZeroDivisors | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] [NoZeroDivisors R], NoZeroDivisors (FreeAlgebra R X) |
CategoryTheory.Comma.mapLeftId | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
CategoryTheory.Comma.mapLeft R (CategoryTheory.CategoryStruct.id L) ≅
CategoryTheory.Functor.id (CategoryTheory.Comma L R) |
Batteries.RBNode.balLeft.match_4.congr_eq_1 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (motive : Batteries.RBNode α → Sort u_2) (l : Batteries.RBNode α)
(h_1 :
(a : Batteries.RBNode α) →
(x : α) → (b : Batteries.RBNode α) → motive (Batteries.RBNode.node Batteries.RBColor.red a x b))
(h_2 : (l : Batteries.RBNode α) → motive l) (a : Batteries.RBNode α) (x : α) (b : Batteries.RBNode α),
l = Batteries.RBNode.node Batteries.RBColor.red a x b →
(match l with
| Batteries.RBNode.node Batteries.RBColor.red a x b => h_1 a x b
| l => h_2 l) ≍
h_1 a x b |
_private.Mathlib.Combinatorics.Enumerative.Catalan.0.gosperCatalan | Mathlib.Combinatorics.Enumerative.Catalan | ℕ → ℕ → ℚ |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementFun.visitLambda | Mathlib.Tactic.Translate.Core | Mathlib.Tactic.Translate.TranslateData →
Lean.Expr →
optParam (Array Lean.Expr) #[] → optParam Lean.LocalContext { } → Mathlib.Tactic.Translate.ReplacementM Lean.Expr |
Lean.Lsp.TextDocumentClientCapabilities.completion? | Lean.Data.Lsp.Capabilities | Lean.Lsp.TextDocumentClientCapabilities → Option Lean.Lsp.CompletionClientCapabilities |
List.replaceIf | Mathlib.Data.List.Defs | {α : Type u_1} → List α → List Bool → List α → List α |
MonCat.FilteredColimits.colimitCocone._proof_2 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J] ⦃X Y : J⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (MonCat.FilteredColimits.coconeMorphism F Y) =
CategoryTheory.CategoryStruct.comp (MonCat.FilteredColimits.coconeMorphism F X)
(((CategoryTheory.Functor.const J).obj (MonCat.FilteredColimits.colimit F)).map f) |
LieEquiv.left_inv | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {L' : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (self : L ≃ₗ⁅R⁆ L'),
Function.LeftInverse self.invFun (↑self.toLieHom).toFun |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.recOn | Lean.Elab.Tactic.Do.Attr | {motive : Lean.Elab.Tactic.Do.SpecAttr.SpecProof → Sort u} →
(t : Lean.Elab.Tactic.Do.SpecAttr.SpecProof) →
((declName : Lean.Name) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecProof.global declName)) →
((fvarId : Lean.FVarId) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local fvarId)) →
((id : Lean.Name) →
(ref : Lean.Syntax) →
(proof : Lean.Expr) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecProof.stx id ref proof)) →
motive t |
CategoryTheory.SingleFunctors.postcompIsoOfIso_hom_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {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] {A : Type u_5}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : CategoryTheory.SingleFunctors C D A) {G G' : CategoryTheory.Functor D E} (e : G ≅ G') [inst_6 : G.CommShift A]
[inst_7 : G'.CommShift A] [inst_8 : CategoryTheory.NatTrans.CommShift e.hom A] (a : A) (X : C),
((F.postcompIsoOfIso e).hom.hom a).app X = e.hom.app ((F.functor a).obj X) |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_22 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (j k : ℕ),
k + 1 ≤ (head :: tail).length → (head :: tail).length + 1 ≤ tail.length → k < tail.length |
IsometryEquiv.subRight_apply | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricVAdd Gᵃᵒᵖ G] (c b : G),
(IsometryEquiv.subRight c) b = b - c |
PresheafOfModules.Derivation.d_one | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor Dᵒᵖ CommRingCat}
{M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {φ : S ⟶ F.op.comp R}
(d : M.Derivation φ) (X : Dᵒᵖ), d.d 1 = 0 |
MonoidHom.submonoidComap_surjective_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (N' : Submonoid N),
Function.Surjective ⇑f → Function.Surjective ⇑(f.submonoidComap N') |
AddSubmonoidClass.subtype | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_1} →
{A : Type u_3} → [inst : AddZeroClass M] → [inst_1 : SetLike A M] → [hA : AddSubmonoidClass A M] → (S' : A) → ↥S' →+ M |
UInt8.add_right_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt8), a + -a = 0 |
Lean.Meta.getIntrosSize._unsafe_rec | Lean.Meta.Tactic.Intro | Lean.Expr → ℕ |
InnerProductSpace.laplacianWithin.congr_simp | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] (f f_1 : E → F),
f = f_1 →
∀ (s s_1 : Set E),
s = s_1 →
∀ (a a_1 : E), a = a_1 → InnerProductSpace.laplacianWithin f s a = InnerProductSpace.laplacianWithin f_1 s_1 a_1 |
Finsupp.lsingle_apply | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : α) (b : M), (Finsupp.lsingle a) b = fun₀ | a => b |
Function.Injective.cancelMonoid.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : Pow M₁ ℕ] [inst_3 : CancelMonoid M₂]
(f : M₁ → M₂) (hf : Function.Injective f) (one : f 1 = 1) (mul : ∀ (x y : M₁), f (x * y) = f x * f y)
(npow : ∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n),
Function.Injective.cancelMonoid f hf one mul npow =
{ toLeftCancelMonoid := Function.Injective.leftCancelMonoid f hf one mul npow, toIsRightCancelMul := ⋯ } |
Homeomorph.piSplitAt | Mathlib.Topology.Homeomorph.Lemmas | {ι : Type u_7} →
[DecidableEq ι] →
(i : ι) →
(Y : ι → Type u_8) →
[inst : (j : ι) → TopologicalSpace (Y j)] → ((j : ι) → Y j) ≃ₜ Y i × ((j : { j // j ≠ i }) → Y ↑j) |
QuotientAddGroup.preimage_mk_zero | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (N : AddSubgroup α), QuotientAddGroup.mk ⁻¹' {↑0} = ↑N |
_private.Lean.Meta.GeneralizeVars.0.Lean.Meta.getFVarSetToGeneralize.match_1 | Lean.Meta.GeneralizeVars | (motive : MProd Lean.FVarIdSet Lean.FVarIdSet → Sort u_1) →
(r : MProd Lean.FVarIdSet Lean.FVarIdSet) → ((r s : Lean.FVarIdSet) → motive ⟨r, s⟩) → motive r |
DihedralGroup.Product | Mathlib.GroupTheory.CommutingProbability | List ℕ → Type |
HahnSeries.finiteArchimedeanClassOrderIsoLex._proof_3 | Mathlib.RingTheory.HahnSeries.Lex | ∀ (Γ : Type u_1) (R : Type u_2) [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[inst_3 : IsOrderedAddMonoid R],
(↑(HahnSeries.finiteArchimedeanClassOrderHomLex Γ R)).comp ↑(HahnSeries.finiteArchimedeanClassOrderHomInvLex Γ R) =
OrderHom.id |
_private.Mathlib.Analysis.InnerProductSpace.LinearPMap.0.LinearPMap.graph_adjoint_toLinearPMap_eq_adjoint._simp_1_2 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ |
Lean.MetavarContext.UnivMVarParamResult.recOn | Lean.MetavarContext | {motive : Lean.MetavarContext.UnivMVarParamResult → Sort u} →
(t : Lean.MetavarContext.UnivMVarParamResult) →
((mctx : Lean.MetavarContext) →
(newParamNames : Array Lean.Name) →
(nextParamIdx : ℕ) →
(expr : Lean.Expr) →
motive { mctx := mctx, newParamNames := newParamNames, nextParamIdx := nextParamIdx, expr := expr }) →
motive t |
Std.TreeMap.recOn | Std.Data.TreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive : Std.TreeMap α β cmp → Sort u_1} →
(t : Std.TreeMap α β cmp) → ((inner : Std.DTreeMap α (fun x => β) cmp) → motive { inner := inner }) → motive t |
Array.append_ne_empty_of_left_ne_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, xs ≠ #[] → xs ++ ys ≠ #[] |
Set.image2_union_inter_subset_union | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s s' : Set α} {t t' : Set β},
Set.image2 f (s ∪ s') (t ∩ t') ⊆ Set.image2 f s t ∪ Set.image2 f s' t' |
Nat.factorial_eq_one._simp_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ {n : ℕ}, (n.factorial = 1) = (n ≤ 1) |
Lean.Lsp.SymbolKind.key.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.key = 1 |
CommGrpCat.coyoneda_obj_obj_coe | Mathlib.Algebra.Category.Grp.Yoneda | ∀ (M : CommGrpCatᵒᵖ) (N : CommGrpCat), ↑((CommGrpCat.coyoneda.obj M).obj N) = (↑(Opposite.unop M) →* ↑N) |
CompleteLat.instConcreteCategoryCompleteLatticeHomCarrier._proof_4 | Mathlib.Order.Category.CompleteLat | ∀ {X Y Z : CompleteLat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X), (CategoryTheory.CategoryStruct.comp f g) x = g (f x) |
TopologicalSpace.Opens.comap_comp | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (g : C(β, γ)) (f : C(α, β)),
TopologicalSpace.Opens.comap (g.comp f) = (TopologicalSpace.Opens.comap f).comp (TopologicalSpace.Opens.comap g) |
CategoryTheory.NatTrans.Equifibered.whiskerLeft | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equifibered | ∀ {J : Type u_1} {K : Type u_2} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_3} C] [inst_2 : CategoryTheory.Category.{v_3, u_2} K]
{F G : CategoryTheory.Functor J C} {α : F ⟶ G},
CategoryTheory.NatTrans.Equifibered α →
∀ (H : CategoryTheory.Functor K J), CategoryTheory.NatTrans.Equifibered (H.whiskerLeft α) |
GeneralizedBooleanAlgebra.toNonUnitalCommRing._proof_7 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (a : α), symmDiff ⊥ a = a |
_private.Mathlib.Algebra.Group.WithOne.Defs.0.WithZero.unzero.match_1.splitter | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u_1} →
(motive : (x : WithZero α) → x ≠ 0 → Sort u_2) →
(x : WithZero α) → (x_1 : x ≠ 0) → ((x : α) → (x_2 : ↑x ≠ 0) → motive (some x) x_2) → motive x x_1 |
Lean.Compiler.LCNF.Code.inc.injEq | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (fvarId : Lean.FVarId) (n : ℕ) (check persistent : Bool)
(k : Lean.Compiler.LCNF.Code pu)
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_11) (fvarId_1 : Lean.FVarId)
(n_1 : ℕ) (check_1 persistent_1 : Bool) (k_1 : Lean.Compiler.LCNF.Code pu)
(h_1 : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_11),
(Lean.Compiler.LCNF.Code.inc fvarId n check persistent k h =
Lean.Compiler.LCNF.Code.inc fvarId_1 n_1 check_1 persistent_1 k_1 h_1) =
(fvarId = fvarId_1 ∧ n = n_1 ∧ check = check_1 ∧ persistent = persistent_1 ∧ k = k_1) |
AddMonoidAlgebra.mapDomainAddEquiv._proof_3 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_1) {M : Type u_3} {N : Type u_2} [inst : Semiring R] [inst_1 : Add M] [inst_2 : Add N] (e : M ≃ N)
(x y : AddMonoidAlgebra R M),
AddMonoidAlgebra.mapDomain (⇑e) (x + y) = AddMonoidAlgebra.mapDomain (⇑e) x + AddMonoidAlgebra.mapDomain (⇑e) y |
CategoryTheory.MorphismProperty.Over.homMk | Mathlib.CategoryTheory.MorphismProperty.Comma | {T : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} T] →
{P Q : CategoryTheory.MorphismProperty T} →
{X : T} →
[inst_1 : Q.IsMultiplicative] →
{A B : P.Over Q X} →
(f : A.left ⟶ B.left) →
autoParam (CategoryTheory.CategoryStruct.comp f B.hom = A.hom)
CategoryTheory.MorphismProperty.Over.homMk._auto_1 →
autoParam (Q f) CategoryTheory.MorphismProperty.Over.homMk._auto_3 → (A ⟶ B) |
CategoryTheory.FreeBicategory.bicategory._proof_7 | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u_1} [inst : Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g')
(h : c ⟶ d),
Quot.map (CategoryTheory.FreeBicategory.Hom₂.whisker_right h) ⋯
(Quot.map (CategoryTheory.FreeBicategory.Hom₂.whisker_left f) ⋯ η) =
CategoryTheory.CategoryStruct.comp
{ hom := Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator f g h),
inv := Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator_inv f g h),
hom_inv_id := ⋯, inv_hom_id := ⋯ }.hom
(CategoryTheory.CategoryStruct.comp
(Quot.map (CategoryTheory.FreeBicategory.Hom₂.whisker_left f) ⋯
(Quot.map (CategoryTheory.FreeBicategory.Hom₂.whisker_right h) ⋯ η))
{ hom := Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator f g' h),
inv := Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator_inv f g' h),
hom_inv_id := ⋯, inv_hom_id := ⋯ }.inv) |
MeasurableEquiv.IicProdIoc._proof_5 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] [inst_2 : DecidableLE ι] {X : ι → Type u_2}
[inst_3 : LocallyFiniteOrderBot ι] [inst_4 : (i : ι) → MeasurableSpace (X i)] {a b : ι} (hab : a ≤ b),
Measurable
⇑{ toFun := fun x i => if h : ↑i ≤ a then x.1 ⟨↑i, ⋯⟩ else x.2 ⟨↑i, ⋯⟩,
invFun := fun x => (fun i => x ⟨↑i, ⋯⟩, fun i => x ⟨↑i, ⋯⟩), left_inv := ⋯, right_inv := ⋯ }.symm |
Std.Internal.List.getValueCastD_filter_not_contains_of_containsKey_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α} {k : α}
{fallback : β k},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.getValueCastD k (List.filter (fun p => !l₂.contains p.fst) l₁) fallback = fallback |
_private.Init.Data.List.MapIdx.0.List.mapIdx_eq_replicate_iff._simp_1_1 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {a : α} {n : ℕ} {l : List α}, (l = List.replicate n a) = (l.length = n ∧ ∀ b ∈ l, b = a) |
rightAddCoset_mem_rightAddCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] (s : AddSubgroup α) {a : α}, a ∈ s → AddOpposite.op a +ᵥ ↑s = ↑s |
Lean.Order.FlatOrder.rel.refl | Init.Internal.Order.Basic | ∀ {α : Sort u} {b : α} {x : Lean.Order.FlatOrder b}, x.rel x |
HasFDerivAt.const_mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {𝔸 : Type u_5} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸] {a : E → 𝔸}
{a' : E →L[𝕜] 𝔸}, HasFDerivAt a a' x → ∀ (b : 𝔸), HasFDerivAt (fun y => b * a y) (b • a') x |
Lean.Elab.InfoTree.node.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} →
{i : Lean.Elab.Info} →
{children : Lean.PersistentArray Lean.Elab.InfoTree} →
{i' : Lean.Elab.Info} →
{children' : Lean.PersistentArray Lean.Elab.InfoTree} →
Lean.Elab.InfoTree.node i children = Lean.Elab.InfoTree.node i' children' →
(i = i' → children = children' → P) → P |
MvPowerSeries.isWeightedHomogeneous_weightedHomogeneousComponent | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) (f : MvPowerSeries σ R) (p : ℕ),
MvPowerSeries.IsWeightedHomogeneous w ((MvPowerSeries.weightedHomogeneousComponent w p) f) p |
exists_pos_rat_lt | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {K : Type u_4} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [Archimedean K] {x : K},
0 < x → ∃ q, 0 < q ∧ ↑q < x |
NonUnitalStarAlgHomClass.map_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | Lean.Syntax |
AddSubgroup.isComplement'_top_right._simp_1 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.IsComplement' ⊤ = (H = ⊥) |
CategoryTheory.Limits.Cocone.equivStructuredArrow_unitIso | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor J C),
(CategoryTheory.Limits.Cocone.equivStructuredArrow F).unitIso =
CategoryTheory.NatIso.ofComponents CategoryTheory.Limits.Cocones.eta ⋯ |
CategoryTheory.MonoOver.image._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} [inst_1 : CategoryTheory.Limits.HasImages C]
{g : CategoryTheory.Over X}, CategoryTheory.Mono (CategoryTheory.Limits.image.ι g.hom) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.