name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
StarOrderedRing.nonneg_iff_spectrum_nonneg | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [ContinuousSqrt R]
[StarOrderedRing R] [inst_8 : TopologicalSpace A] [inst_9 : Ring A] [inst_10 : StarRing A] [inst_11 : PartialOrder A]
[StarOrderedRing A] [inst_13 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R A p] [NonnegSpectrumClass R A]
(a : A), autoParam (p a) StarOrderedRing.nonneg_iff_spectrum_nonneg._auto_1 → (0 ≤ a ↔ ∀ x ∈ spectrum R a, 0 ≤ x) |
ConvexCone.map.match_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_3} {M : Type u_2} {N : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N] (f : M →ₗ[R] N) (C : ConvexCone R M) (x : N)
(motive : x ∈ ⇑f '' ↑C → Prop) (x_1 : x ∈ ⇑f '' ↑C),
(∀ (x_2 : M) (hx : x_2 ∈ ↑C) (hy : f x_2 = x), motive ⋯) → motive x_1 |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.AssocList.forInStep.go.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m]
(f : (a : α) → β a → δ → m (ForInStep δ)) (x : δ) (k : α) (v : β k) (t : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.forInStep.go✝ f (Std.DHashMap.Internal.AssocList.cons k v t) x = do
let __do_lift ← f k v x
match __do_lift with
| ForInStep.done d => pure (ForInStep.done d)
| ForInStep.yield d => Std.DHashMap.Internal.AssocList.forInStep.go✝¹ f t d |
MatrixEquivTensor.toFunBilinear | Mathlib.RingTheory.MatrixAlgebra | (n : Type u_3) →
(R : Type u_5) →
(A : Type u_7) →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → A →ₗ[R] Matrix n n R →ₗ[R] Matrix n n A |
ENNReal.ofNat_lt_ofReal | Mathlib.Data.ENNReal.Real | ∀ {n : ℕ} [inst : n.AtLeastTwo] {r : ℝ}, OfNat.ofNat n < ENNReal.ofReal r ↔ OfNat.ofNat n < r |
Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Linear.Types | SizeOf Lean.Meta.Grind.Arith.Linear.EqCnstr |
Lean.Lsp.TextDocumentEdit | Lean.Data.Lsp.Basic | Type |
Measurable.sub_stronglyMeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_5} {E : Type u_6} {x : MeasurableSpace α} [inst : AddGroup E] [inst_1 : TopologicalSpace E]
[inst_2 : MeasurableSpace E] [BorelSpace E] [ContinuousAdd E] [ContinuousNeg E]
[TopologicalSpace.PseudoMetrizableSpace E] {g f : α → E},
Measurable g → MeasureTheory.StronglyMeasurable f → Measurable (g - f) |
_private.Mathlib.Topology.MetricSpace.PartitionOfUnity.0.Metric.eventually_nhds_zero_forall_closedEBall_subset._simp_1_3 | Mathlib.Topology.MetricSpace.PartitionOfUnity | ∀ {a b : Prop}, (¬a → ¬b) = (b → a) |
CategoryTheory.Functor.IsContinuous.mk | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D},
(∀ (G : CategoryTheory.Sheaf K (Type (max u₁ v₁ u₂ v₂))), CategoryTheory.Presieve.IsSheaf J (F.op.comp G.obj)) →
F.IsContinuous J K |
OrderIso.map_ciSup | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
[inst_1 : ConditionallyCompleteLattice β] [Nonempty ι] (e : α ≃o β) {f : ι → α},
BddAbove (Set.range f) → e (⨆ i, f i) = ⨆ i, e (f i) |
CategoryTheory.Functor.congr_inv_of_congr_hom | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F G : CategoryTheory.Functor C D) {X Y : C} (e : X ≅ Y) (hX : F.obj X = G.obj X) (hY : F.obj Y = G.obj Y),
F.map e.hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp (G.map e.hom) (CategoryTheory.eqToHom ⋯)) →
F.map e.inv =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp (G.map e.inv) (CategoryTheory.eqToHom ⋯)) |
Nat.floor_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R] (n : ℕ)
[inst_4 : n.AtLeastTwo], ⌊OfNat.ofNat n⌋₊ = OfNat.ofNat n |
CategoryTheory.Comonad.coalgebraPreadditive_homGroup_zsmul_f | Mathlib.CategoryTheory.Preadditive.EilenbergMoore | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C]
(U : CategoryTheory.Comonad C) [inst_2 : U.Additive] (F G : U.Coalgebra) (r : ℤ) (α : F ⟶ G), (r • α).f = r • α.f |
AffineIsometry.mk._flat_ctor | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_5} →
{P : Type u_10} →
{P₂ : Type u_11} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : NormedAddTorsor V P] →
[inst_5 : SeminormedAddCommGroup V₂] →
[inst_6 : NormedSpace 𝕜 V₂] →
[inst_7 : PseudoMetricSpace P₂] →
[inst_8 : NormedAddTorsor V₂ P₂] →
(toFun : P → P₂) →
(linear : V →ₗ[𝕜] V₂) →
(∀ (p : P) (v : V), toFun (v +ᵥ p) = linear v +ᵥ toFun p) →
(∀ (x : V), ‖linear x‖ = ‖x‖) → P →ᵃⁱ[𝕜] P₂ |
HopfAlgebraStruct.antipode | Mathlib.RingTheory.HopfAlgebra.Basic | (R : Type u) →
{A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → [self : HopfAlgebraStruct R A] → A →ₗ[R] A |
WithBot.unbot_eq_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : WithBot α} {b : α} (h : a ≠ ⊥), a.unbot h = b ↔ a = ↑b |
Option.pmap_bind_id_eq_pmap_join | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {x : Option (Option α)}
(H : ∀ (a : Option α), x = some a → ∀ (a_2 : α), a = some a_2 → p a_2),
((Option.pmap (Option.pmap f) x H).bind fun a => a) = Option.pmap f x.join ⋯ |
CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Terminal___macroRules_CategoryTheory_Limits_term⊤___1» | Mathlib.CategoryTheory.Limits.Shapes.Terminal | Lean.Macro |
Real.range_log | Mathlib.Analysis.SpecialFunctions.Log.Basic | Set.range Real.log = Set.univ |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal.0.SSet.Truncated.IsStrictSegal.hom_ext._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z) (a : F.obj X), F.map g (F.map f a) = F.map (CategoryTheory.CategoryStruct.comp f g) a |
Equiv.subtypeUnivEquiv._proof_2 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {p : α → Prop} (h : ∀ (x : α), p x) (x : Subtype p), ⟨↑x, ⋯⟩ = x |
Lean.Omega.Coeffs.findIdx? | Init.Omega.Coeffs | (ℤ → Bool) → Lean.Omega.Coeffs → Option ℕ |
CategoryTheory.Abelian.hasFiniteLimits | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C],
CategoryTheory.Limits.HasFiniteLimits C |
CompleteSublattice.mem_top._simp_1 | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {x : X}, (x ∈ ⊤) = True |
Lean.Lsp.SymbolKind.variable.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.variable = 1 |
Lean.Lsp.Ipc.CallHierarchy.noConfusion | Lean.Data.Lsp.Ipc | {P : Sort u} → {t t' : Lean.Lsp.Ipc.CallHierarchy} → t = t' → Lean.Lsp.Ipc.CallHierarchy.noConfusionType P t t' |
Lean.PersistentArray.getAux | Lean.Data.PersistentArray | {α : Type u} → [Inhabited α] → Lean.PersistentArrayNode α → USize → USize → α |
AlgebraicGeometry.IsImmersion.instMapDescScheme | Mathlib.AlgebraicGeometry.Morphisms.Immersion | ∀ {X Y S T : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) (i : S ⟶ T),
AlgebraicGeometry.IsImmersion (CategoryTheory.Limits.pullback.mapDesc f g i) |
inf_le_inf_right | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α} (c : α), b ≤ a → b ⊓ c ≤ a ⊓ c |
ArchimedeanClass.mk_add_lt_mk_left_iff._simp_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a b : M},
(ArchimedeanClass.mk (a + b) < ArchimedeanClass.mk a) = (ArchimedeanClass.mk b < ArchimedeanClass.mk a) |
Real.smul_map_diagonal_volume_pi | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] {D : ι → ℝ},
(Matrix.diagonal D).det ≠ 0 →
ENNReal.ofReal |(Matrix.diagonal D).det| •
MeasureTheory.Measure.map (⇑(Matrix.toLin' (Matrix.diagonal D))) MeasureTheory.volume =
MeasureTheory.volume |
Std.Time.DateTime.ofDaysSinceUNIXEpoch | Std.Time.Zoned.DateTime | Std.Time.Day.Offset → Std.Time.PlainTime → (tz : Std.Time.TimeZone) → Std.Time.DateTime tz |
_private.Init.Data.List.Lemmas.0.List.eq_replicate_of_mem.match_1_3 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (b : α) (l : List α) (motive : (a : α) → (b = a ∧ ∀ x ∈ l, x = a) → (∀ b_1 ∈ b :: l, b_1 = a) → Prop)
(a : α) (x : b = a ∧ ∀ x ∈ l, x = a) (H : ∀ b_1 ∈ b :: l, b_1 = a),
(∀ (H₂ : ∀ x ∈ l, x = b) (H : ∀ b_1 ∈ b :: l, b_1 = b), motive b ⋯ H) → motive a x H |
CategoryTheory.Limits.Fork.IsLimit.mk._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y}
(t : CategoryTheory.Limits.Fork f g) (lift : (s : CategoryTheory.Limits.Fork f g) → s.pt ⟶ t.pt),
(∀ (s : CategoryTheory.Limits.Fork f g), CategoryTheory.CategoryStruct.comp (lift s) t.ι = s.ι) →
∀ (s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.parallelPair f g))
(j : CategoryTheory.Limits.WalkingParallelPair),
CategoryTheory.CategoryStruct.comp (lift s) (t.π.app j) = s.π.app j |
antitone_vecEmpty._simp_1 | Mathlib.Order.Fin.Tuple | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Antitone ![a] = True |
List.mem_union_left | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} {l₁ : List α} {a : α} [inst : DecidableEq α], a ∈ l₁ → ∀ (l₂ : List α), a ∈ l₁ ∪ l₂ |
Subgroup.focalSubgroup_le | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.focalSubgroup ≤ H |
_private.Init.Meta.Defs.0.Lean.Syntax.decodeScientificLitVal?.decodeAfterExp | Init.Meta.Defs | String → String.Pos.Raw → ℕ → ℕ → Bool → ℕ → Option (ℕ × Bool × ℕ) |
Localization.le_comap_primeCompl_iff | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {P : Type u_3} [inst_1 : CommSemiring P] {I : Ideal R} [hI : I.IsPrime]
{J : Ideal P} [inst_2 : J.IsPrime] {f : R →+* P}, I.primeCompl ≤ Submonoid.comap f J.primeCompl ↔ Ideal.comap f J ≤ I |
Complex.UnitDisc.instSMulCommClass_circle_right | Mathlib.Analysis.Complex.UnitDisc.Basic | SMulCommClass Complex.UnitDisc Circle Complex.UnitDisc |
Std.ExtTreeMap.keyAtIdxD | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → ℕ → α → α |
Std.Format.MonadPrettyFormat.pushOutput | Init.Data.Format.Basic | {m : Type → Type} → [self : Std.Format.MonadPrettyFormat m] → String → m Unit |
Multiset.singleton_eq_cons_iff | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a b : α} (m : Multiset α), {a} = b ::ₘ m ↔ a = b ∧ m = 0 |
List.tailsTR | Batteries.Data.List.Basic | {α : Type u_1} → List α → List (List α) |
FGModuleCat.ulift | Mathlib.Algebra.Category.FGModuleCat.Basic | (R : Type u) → [inst : Ring R] → CategoryTheory.Functor (FGModuleCat R) (FGModuleCat R) |
Cardinal.cast_toNat_eq_iff_lt_aleph0 | Mathlib.SetTheory.Cardinal.ToNat | ∀ {c : Cardinal.{u_1}}, ↑(Cardinal.toNat c) = c ↔ c < Cardinal.aleph0 |
SignType.intCast_cast | Mathlib.Data.Sign.Basic | ∀ {α : Type u_1} [inst : AddGroupWithOne α] (s : SignType), ↑↑s = ↑s |
CategoryTheory.LiftLeftAdjoint.constructLeftAdjointObj._proof_1 | Mathlib.CategoryTheory.Adjunction.Lifting.Left | ∀ {A : Type u_2} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
{U : CategoryTheory.Functor B C} {F : CategoryTheory.Functor C B} (R : CategoryTheory.Functor A B)
(F' : CategoryTheory.Functor C A) (adj₁ : F ⊣ U) (adj₂ : F' ⊣ R.comp U)
[CategoryTheory.Limits.HasReflexiveCoequalizers A] (Y : B),
CategoryTheory.Limits.HasCoequalizer (F'.map (U.map (adj₁.counit.app Y)))
(CategoryTheory.LiftLeftAdjoint.otherMap R F' adj₁ adj₂ Y) |
RingCon.lift_surjective_of_surjective | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring P] {c : RingCon M} {f : M →+* P}
(h : c ≤ RingCon.ker f), Function.Surjective ⇑f → Function.Surjective ⇑(c.lift f h) |
_private.Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic.0.Function.locallyFinsuppWithin.logCounting_mono._simp_1_5 | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) |
_private.Init.Data.String.Basic.0.String.Pos.lt_of_lt_of_le._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {l r : s.Pos}, (l < r) = (l.offset < r.offset) |
List.IsChain.iff_of_mem_tail_imp | Mathlib.Data.List.Chain | ∀ {α : Type u} {R S : α → α → Prop} {l : List α},
(∀ (a b : α), a ∈ l → b ∈ l.tail → (R a b ↔ S a b)) → (List.IsChain R l ↔ List.IsChain S l) |
Submodule.quotientEquivOfIsCompl._proof_2 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_2} [inst : Ring R] {E : Type u_1} [inst_1 : AddCommGroup E] [inst_2 : Module R E] (p q : Submodule R E),
IsCompl p q → Function.Surjective ⇑(p.mkQ ∘ₗ q.subtype) |
CategoryTheory.MonoidalCategory.MonoidalRightAction.mk | Mathlib.CategoryTheory.Monoidal.Action.Basic | {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] →
[toMonoidalRightActionStruct : CategoryTheory.MonoidalCategory.MonoidalRightActionStruct C D] →
autoParam
(∀ {c c' : C} {d d' : D} (f : d ⟶ d') (g : c ⟶ c'),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom f g =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f c)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d' g))
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHom_def._autoParam →
autoParam
(∀ (c : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d
(CategoryTheory.CategoryStruct.id c) =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj d c))
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHomRight_id._autoParam →
autoParam
(∀ (c : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft
(CategoryTheory.CategoryStruct.id d) c =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj d c))
CategoryTheory.MonoidalCategory.MonoidalRightAction.id_actionHomLeft._autoParam →
autoParam
(∀ {c c' c'' : C} {d d' d'' : D} (f₁ : d ⟶ d') (f₂ : d' ⟶ d'') (g₁ : c ⟶ c') (g₂ : c' ⟶ c''),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom
(CategoryTheory.CategoryStruct.comp f₁ f₂) (CategoryTheory.CategoryStruct.comp g₁ g₂) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom f₁ g₁)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom f₂ g₂))
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHom_comp._autoParam →
autoParam
(∀ {d₁ d₂ : D} {c₁ c₂ c₃ c₄ : C} (f : d₁ ⟶ d₂) (g : c₁ ⟶ c₂) (h : c₃ ⟶ c₄),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom f
(CategoryTheory.MonoidalCategoryStruct.tensorHom g h))
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d₂ c₂ c₄).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d₁ c₁ c₃).hom
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom f g) h))
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionAssocIso_hom_naturality._autoParam →
autoParam
(∀ {d d' : D} (f : d ⟶ d'),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionUnitIso d).hom f =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionUnitIso d').hom)
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionUnitIso_hom_naturality._autoParam →
autoParam
(∀ {c' c'' : C} (f : c' ⟶ c'') (c : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f c) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c' c).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d f) c)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c''
c).inv))
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHomRight_whiskerRight._autoParam →
autoParam
(∀ (c : C) {c' c'' : C} (f : c' ⟶ c'') (d : D),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft c f) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c
c').hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj d c) f)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c
c'').inv))
CategoryTheory.MonoidalCategory.MonoidalRightAction.whiskerRight_actionHomLeft._autoParam →
autoParam
(∀ (c₁ c₂ c₃ : C) (d : D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d
(CategoryTheory.MonoidalCategoryStruct.associator c₁ c₂ c₃).hom)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c₁
(CategoryTheory.MonoidalCategoryStruct.tensorObj c₂ c₃)).hom
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj d c₁)
c₂ c₃).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d
(CategoryTheory.MonoidalCategoryStruct.tensorObj c₁ c₂) c₃).hom
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c₁
c₂).hom
c₃))
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHom_associator._autoParam →
autoParam
(∀ (c : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d
(CategoryTheory.MonoidalCategoryStruct.leftUnitor c).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C) c).hom
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionUnitIso
d).hom
c))
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHom_leftUnitor._autoParam →
autoParam
(∀ (c : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d
(CategoryTheory.MonoidalCategoryStruct.rightUnitor c).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionUnitIso
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj d
c)).hom)
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHom_rightUnitor._autoParam →
CategoryTheory.MonoidalCategory.MonoidalRightAction C D |
CategoryTheory.HopfObj.noConfusion | Mathlib.CategoryTheory.Monoidal.Hopf_ | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} →
{X : C} →
{t : CategoryTheory.HopfObj X} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{inst'_1 : CategoryTheory.MonoidalCategory C'} →
{inst'_2 : CategoryTheory.BraidedCategory C'} →
{X' : C'} →
{t' : CategoryTheory.HopfObj X'} →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 → X ≍ X' → t ≍ t' → CategoryTheory.HopfObj.noConfusionType P t t' |
Metric.hausdorffDist_comm | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α}, Metric.hausdorffDist s t = Metric.hausdorffDist t s |
Lean.Linter.LinterOptions._sizeOf_inst | Lean.Linter.Basic | SizeOf Lean.Linter.LinterOptions |
Submodule.mem_neg | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {g : M}
{S : Submodule R M}, g ∈ -S ↔ -g ∈ S |
_private.Mathlib.Algebra.Field.Subfield.Basic.0.Subfield.mem_map._simp_1_2 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] {f : R →+* S} {s : Subring R} {y : S},
(y ∈ Subring.map f s) = ∃ x ∈ s, f x = y |
Module.Basis.toDual_linearCombination_right | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) (f : ι →₀ R) (i : ι),
(b.toDual (b i)) ((Finsupp.linearCombination R ⇑b) f) = f i |
Lean.Elab.Term.elabTermLiftMethod | Lean.Elab.Do.Switch | Lean.Elab.Term.TermElab |
Monoid.CoprodI.FreeGroupBasis.coprodI._proof_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {X : ι → Type u_3} {G : ι → Type u_2} [inst : (i : ι) → Group (G i)]
(B : (i : ι) → FreeGroupBasis (X i) (G i)),
(FreeGroup.lift fun x => Monoid.CoprodI.of ((B x.fst) x.snd)).comp
(Monoid.CoprodI.lift fun i => (B i).lift fun x => FreeGroup.of ⟨i, x⟩) =
MonoidHom.id (Monoid.CoprodI G) |
isQuotientCoveringMap_quotientMk_of_properlyDiscontinuousSMul | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} [inst : TopologicalSpace E] {G : Type u_3} [inst_1 : Group G] [inst_2 : MulAction G E]
[ContinuousConstSMul G E] [ProperlyDiscontinuousSMul G E] [LocallyCompactSpace E] [T2Space E] [IsCancelSMul G E],
IsQuotientCoveringMap (Quotient.mk (MulAction.orbitRel G E)) G |
TopModuleCat.ker._proof_3 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N),
ContinuousSMul R ↥(↑(TopModuleCat.Hom.hom φ)).ker |
BddDistLat.mk.inj | Mathlib.Order.Category.BddDistLat | ∀ {toDistLat : DistLat} {isBoundedOrder : BoundedOrder ↑toDistLat} {toDistLat_1 : DistLat}
{isBoundedOrder_1 : BoundedOrder ↑toDistLat_1},
{ toDistLat := toDistLat, isBoundedOrder := isBoundedOrder } =
{ toDistLat := toDistLat_1, isBoundedOrder := isBoundedOrder_1 } →
toDistLat = toDistLat_1 ∧ isBoundedOrder ≍ isBoundedOrder_1 |
CategoryTheory.Functor.Initial.limitIso_inv | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [inst_2 : F.Initial] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
(G : CategoryTheory.Functor D E) [inst_4 : CategoryTheory.Limits.HasLimit G],
(CategoryTheory.Functor.Initial.limitIso F G).inv = CategoryTheory.Limits.limit.pre G F |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCongrSimpCore?.mk? | Lean.Meta.CongrTheorems | Bool → Lean.Expr → Lean.Meta.FunInfo → Array Lean.Meta.CongrArgKind → Lean.MetaM (Option Lean.Meta.CongrTheorem) |
IocProdIoc.eq_1 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] [inst_2 : DecidableLE ι] {X : ι → Type u_2}
(a b c : ι) (x : ((i : ↥(Finset.Ioc a b)) → X ↑i) × ((i : ↥(Finset.Ioc b c)) → X ↑i)) (i : ↥(Finset.Ioc a c)),
IocProdIoc a b c x i = if h : ↑i ≤ b then x.1 ⟨↑i, ⋯⟩ else x.2 ⟨↑i, ⋯⟩ |
Aesop.UnorderedArraySet | Aesop.Util.UnorderedArraySet | (α : Type u_1) → [BEq α] → Type u_1 |
tangentBundleCore._proof_4 | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {H : Type u_1} [inst : TopologicalSpace H] (M : Type u_2) [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(i : ↑(atlas H M)), IsOpen (↑i).source |
CategoryTheory.Limits.StrongEpiMonoFactorisation.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Limits.StrongEpiMonoFactorisation f → Sort u_1} →
(t : CategoryTheory.Limits.StrongEpiMonoFactorisation f) →
((toMonoFactorisation : CategoryTheory.Limits.MonoFactorisation f) →
[e_strong_epi : CategoryTheory.StrongEpi toMonoFactorisation.e] →
motive { toMonoFactorisation := toMonoFactorisation, e_strong_epi := e_strong_epi }) →
motive t |
Std.DHashMap.Internal.AssocList.getCast?._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} → [inst : BEq α] → [LawfulBEq α] → (a : α) → Std.DHashMap.Internal.AssocList α β → Option (β a) |
Rep.free_ext_iff | Mathlib.RepresentationTheory.Rep | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Monoid G] {α : Type u} {A : Rep k G} {f g : Rep.free k G α ⟶ A},
f = g ↔
∀ (i : α),
((CategoryTheory.ConcreteCategory.hom f.hom) fun₀ | i => fun₀ | 1 => 1) =
(CategoryTheory.ConcreteCategory.hom g.hom) fun₀ | i => fun₀ | 1 => 1 |
Array.attach_map_val | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} (xs : Array α) (f : α → β), Array.map (fun i => f ↑i) xs.attach = Array.map f xs |
Vector.count_push_self | Init.Data.Vector.Count | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {n : ℕ} {a : α} {xs : Vector α n},
Vector.count a (xs.push a) = Vector.count a xs + 1 |
AddHom.ENatMap | Mathlib.Data.ENat.Basic | {N : Type u_2} → [inst : Add N] → (ℕ →ₙ+ N) → ℕ∞ →ₙ+ WithTop N |
CategoryTheory.Limits.kernel | Mathlib.CategoryTheory.Limits.Shapes.Kernels | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} → (f : X ⟶ Y) → [CategoryTheory.Limits.HasKernel f] → C |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenrange_nat._simp_1_3 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.recordSimpTheorem.match_3 | Lean.Meta.Tactic.Simp.Types | (motive : Lean.Meta.Origin → Sort u_1) →
(thmId : Lean.Meta.Origin) →
((declName : Lean.Name) → (post : Bool) → motive (Lean.Meta.Origin.decl declName post)) →
((x : Lean.Meta.Origin) → motive x) → motive thmId |
Aesop.IndexingMode.below | Aesop.Index.Basic | {motive_1 : Aesop.IndexingMode → Sort u} →
{motive_2 : Array Aesop.IndexingMode → Sort u} →
{motive_3 : List Aesop.IndexingMode → Sort u} → Aesop.IndexingMode → Sort (max 1 u) |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.Key.jp.noConfusion | Lean.Compiler.LCNF.InferBorrow | {P : Sort u} →
{name : Lean.Name} →
{jpId : Lean.FVarId} →
{name' : Lean.Name} →
{jpId' : Lean.FVarId} →
Lean.Compiler.LCNF.ParamMap.Key.jp✝ name jpId = Lean.Compiler.LCNF.ParamMap.Key.jp✝¹ name' jpId' →
(name = name' → jpId = jpId' → P) → P |
MeasureTheory.FiniteMeasure.map_apply_of_aemeasurable | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} {Ω' : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : MeasurableSpace Ω']
(ν : MeasureTheory.FiniteMeasure Ω) {f : Ω → Ω'},
AEMeasurable f ↑ν → ∀ {A : Set Ω'}, MeasurableSet A → (ν.map f) A = ν (f ⁻¹' A) |
Std.DTreeMap.Internal.Impl.getEntryGT?ₘ' | Std.Data.DTreeMap.Internal.Model | {α : Type u} → {β : α → Type v} → [Ord α] → α → Std.DTreeMap.Internal.Impl α β → Option ((a : α) × β a) |
FirstOrder.Language.isRelational_sum | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} [L.IsRelational] [L'.IsRelational], (L.sum L').IsRelational |
Convex.setOf_const_imp | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] {s : Set E} {P : Prop}, Convex 𝕜 s → Convex 𝕜 {x | P → x ∈ s} |
PLift.down_inj._simp_1 | Mathlib.Logic.Function.ULift | ∀ {α : Sort u_1} {a b : PLift α}, (a.down = b.down) = (a = b) |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_44 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ') (k : Turing.PartrecToTM2.K')
(s : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ') (q : Turing.PartrecToTM2.Λ'),
Turing.PartrecToTM2.Λ'.read f = Turing.PartrecToTM2.Λ'.push k s q → False |
KaehlerDifferential.polynomialEquiv_symm | Mathlib.RingTheory.Kaehler.Polynomial | ∀ (R : Type u) [inst : CommRing R] (P : Polynomial R),
(KaehlerDifferential.polynomialEquiv R).symm P = P • (KaehlerDifferential.D R (Polynomial R)) Polynomial.X |
Std.TreeMap.getKeyD_filterMap | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp]
{f : α → β → Option γ} {k fallback : α},
(Std.TreeMap.filterMap f t).getKeyD k fallback = ((t.getKey? k).pfilter fun x h' => (f x t[x]).isSome).getD fallback |
_private.Mathlib.Data.Fintype.Basic.0.Fin.univ_image_getElem'._proof_1 | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} (l : List α) (i : Fin l.length), ¬↑i < l.length → False |
RingCat.hasForgetToSemiRingCat | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.HasForget₂ RingCat SemiRingCat |
GenLoop.fromLoop_symm_toLoop | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] {i : N}
{p : ↑(GenLoop N X x)}, GenLoop.fromLoop i (Path.symm (GenLoop.toLoop i p)) = GenLoop.symmAt i p |
AddSubmonoid.add_subset_closure | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {M : Type u_3} [inst : AddMonoid M] {s t u : Set M}, s ⊆ u → t ⊆ u → s + t ⊆ ↑(AddSubmonoid.closure u) |
CategoryTheory.Pretriangulated.Triangle.instAddCommGroupHom._proof_8 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Preadditive C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (n : ℤ),
CategoryTheory.Functor.Linear ℤ (CategoryTheory.shiftFunctor C n) |
AddCommGrpCat.instCategory.eq_1 | Mathlib.Algebra.Category.Grp.Basic | AddCommGrpCat.instCategory =
{ Hom := fun X Y => X.Hom Y, id := fun X => { hom' := AddMonoidHom.id ↑X },
comp := fun {X Y Z} f g => { hom' := g.hom'.comp f.hom' }, id_comp := @AddCommGrpCat.instCategory._proof_1,
comp_id := @AddCommGrpCat.instCategory._proof_2, assoc := @AddCommGrpCat.instCategory._proof_3 } |
SemiconjBy.function_semiconj_mul_left | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Semigroup G] {a b c : G},
SemiconjBy a b c → Function.Semiconj (fun x => a * x) (fun x => b * x) fun x => c * x |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.integrable_tilted_iff._simp_1_2 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) |
AlgebraicGeometry.SheafedSpace.toPresheafedSpace | Mathlib.Geometry.RingedSpace.SheafedSpace | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → AlgebraicGeometry.SheafedSpace C → AlgebraicGeometry.PresheafedSpace C |
CategoryTheory.instHasImagesSheafType | Mathlib.CategoryTheory.Sites.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C},
CategoryTheory.Limits.HasImages (CategoryTheory.Sheaf J (Type (max v u))) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.