name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Mon_Class.one_eq_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.MonObj M], CategoryTheory.MonObj.one = 1 |
Lean.Lsp.instFromJsonSignatureHelpTriggerKind | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SignatureHelpTriggerKind |
iterate_map_sub | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} {F : Type u_11} [inst : AddGroup M] [inst_1 : FunLike F M M] [AddMonoidHomClass F M M] (f : F) (n : ℕ)
(x y : M), (⇑f)^[n] (x - y) = (⇑f)^[n] x - (⇑f)^[n] y |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_495 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
List.idxOfNth w [g (g a)] {g a, g (g a)}.card + 1 ≤ (List.filter (fun x => decide (x = w)) []).length →
List.idxOfNth w [g (g a)] {g a, g (g a)}.card < (List.filter (fun x => decide (x = w)) []).length |
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.nonzero_span_atom._simp_1_1 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M)
(p : Submodule R M), (R ∙ m ≤ p) = (m ∈ p) |
Sigma.Lex.linearOrder._proof_4 | Mathlib.Data.Sigma.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)] (a b : (i : ι) × α i),
Sigma.Lex (fun x1 x2 => x1 < x2) (fun x x1 x2 => x1 ≤ x2) a b ∨
Sigma.Lex (fun x1 x2 => x1 < x2) (fun x x1 x2 => x1 ≤ x2) b a |
ContDiffMapSupportedIn.instSMul | 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} →
{R : Type u_5} →
[inst_4 : Semiring R] →
[inst_5 : Module R F] →
[SMulCommClass ℝ R F] → [ContinuousConstSMul R F] → SMul R (ContDiffMapSupportedIn E F n K) |
Lean.Expr.foldRelevantConstants | Lean.LibrarySuggestions.Basic | {α : Type} → Lean.Expr → α → (Lean.Name → α → Lean.MetaM α) → Lean.MetaM α |
Subalgebra.involutiveStar._proof_11 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] (S : Subalgebra R A),
{
carrier :=
star
{ carrier := star S.carrier, mul_mem' := ⋯, one_mem' := ⋯, add_mem' := ⋯, zero_mem' := ⋯,
algebraMap_mem' := ⋯ }.carrier,
mul_mem' := ⋯, one_mem' := ⋯, add_mem' := ⋯, zero_mem' := ⋯, algebraMap_mem' := ⋯ } =
S |
StieltjesFunction.instModuleNNReal._proof_5 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : NNReal), x • 0 = 0 |
BoundedOrder.noConfusionType | Mathlib.Order.BoundedOrder.Basic | Sort u_1 → {α : Type u} → [inst : LE α] → BoundedOrder α → {α' : Type u} → [inst' : LE α'] → BoundedOrder α' → Sort u_1 |
_private.Mathlib.Data.Set.Finite.Lattice.0.Set.Finite.bddAbove_biUnion._simp_1_1 | Mathlib.Data.Set.Finite.Lattice | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], BddAbove ∅ = True |
CategoryTheory.Functor.instEffectiveEpiEffectiveEpiOver | Mathlib.CategoryTheory.EffectiveEpi.Enough | ∀ {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] (F : CategoryTheory.Functor C D) [inst_2 : F.EffectivelyEnough]
(X : D), CategoryTheory.EffectiveEpi (F.effectiveEpiOver X) |
derivWithin_fun_const | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (c : F), derivWithin (fun x => c) s = 0 |
CoeOut.mk | Init.Coe | {α : Sort u} → {β : semiOutParam (Sort v)} → (α → β) → CoeOut α β |
CategoryTheory.Functor.IsCoverDense.sheafYonedaHom | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{K : CategoryTheory.GrothendieckTopology D} →
{A : Type u_4} →
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] →
{G : CategoryTheory.Functor C D} →
[G.IsCoverDense K] →
[G.IsLocallyFull K] →
{ℱ : CategoryTheory.Functor Dᵒᵖ A} →
{ℱ' : CategoryTheory.Sheaf K A} →
(G.op.comp ℱ ⟶ G.op.comp ℱ'.val) →
(ℱ.comp CategoryTheory.yoneda ⟶ ℱ'.val.comp CategoryTheory.yoneda) |
_private.Mathlib.Topology.UniformSpace.Closeds.0.IsCompact.nhds_hausdorff_eq_nhds_vietoris._simp_1_2 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) |
_private.Mathlib.AlgebraicTopology.SimplicialObject.II.0.SimplexCategory.II.last_mem_finset._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialObject.II | ∀ {n m : ℕ} (f : Fin (n + 1) →o Fin (m + 1)) (x : Fin (m + 2)) (i : Fin (n + 2)),
(i ∈ SimplexCategory.II.finset f x) =
(i = Fin.last (n + 1) ∨ ∃ (h : i ≠ Fin.last (n + 1)), x ≤ (f (i.castPred h)).castSucc) |
Stream'.Seq1.bind_assoc | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.Seq1 α) (f : α → Stream'.Seq1 β) (g : β → Stream'.Seq1 γ),
(s.bind f).bind g = s.bind fun x => (f x).bind g |
Std.Time.Month.instInhabitedOrdinal | Std.Time.Date.Unit.Month | Inhabited Std.Time.Month.Ordinal |
Nat.le_three_of_sqrt_eq_one | Mathlib.Data.Nat.Sqrt | ∀ {n : ℕ}, n.sqrt = 1 → n ≤ 3 |
_private.Mathlib.Order.ModularLattice.0.Set.Iic.isCompl_inf_inf_of_isCompl_of_le._simp_1_1 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) |
Lean.Elab.Term.TacticMVarKind.term.sizeOf_spec | Lean.Elab.Term.TermElabM | sizeOf Lean.Elab.Term.TacticMVarKind.term = 1 |
Lean.PrettyPrinter.Delaborator.delabHOrElse._regBuiltin.Lean.PrettyPrinter.Delaborator.delabHOrElse_1 | Lean.PrettyPrinter.Delaborator.Builtins | IO Unit |
Lean.Parser.Term.app._regBuiltin.Lean.Parser.Term.ellipsis.formatter_11 | Lean.Parser.Term | IO Unit |
CategoryTheory.Functor.WellOrderInductionData.Extension.limit._proof_3 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_2} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_1)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} [inst_3 : WellFoundedLT J] (j : J)
(hj : Order.IsSuccLimit j) (e : (i : J) → i < j → d.Extension val₀ i),
F.map (CategoryTheory.homOfLE ⋯).op
(d.lift j hj
⟨fun x =>
match x with
| Opposite.op ⟨i, hi⟩ => (e i hi).val,
⋯⟩) =
val₀ |
Partition.mk._flat_ctor | Mathlib.Order.Partition.Basic | {α : Type u_1} →
[inst : CompleteLattice α] → {s : α} → (parts : Set α) → sSupIndep parts → ⊥ ∉ parts → sSup parts = s → Partition s |
instCStarAlgebraSubtypeMemStarSubalgebraComplexElemental._proof_5 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : CStarAlgebra A], ContinuousStar A |
MvPolynomial.degrees_neg | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {R : Type u} {σ : Type u_1} [inst : CommRing R] (p : MvPolynomial σ R), (-p).degrees = p.degrees |
Mathlib.Tactic.BicategoryLike.MkMor₂.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkMor₂ m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkMor₂ m) →
((ofExpr : Lean.Expr → m Mathlib.Tactic.BicategoryLike.Mor₂) → motive { ofExpr := ofExpr }) → motive t |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_5 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.ball 0 r) = (‖a‖ < r) |
CategoryTheory.RightRigidCategory.noConfusionType | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.RightRigidCategory C →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
[inst'_1 : CategoryTheory.MonoidalCategory C'] → CategoryTheory.RightRigidCategory C' → Sort u_1 |
AlgebraicGeometry.SheafedSpace.mk.injEq | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (toPresheafedSpace : AlgebraicGeometry.PresheafedSpace C)
(IsSheaf : toPresheafedSpace.presheaf.IsSheaf) (toPresheafedSpace_1 : AlgebraicGeometry.PresheafedSpace C)
(IsSheaf_1 : toPresheafedSpace_1.presheaf.IsSheaf),
({ toPresheafedSpace := toPresheafedSpace, IsSheaf := IsSheaf } =
{ toPresheafedSpace := toPresheafedSpace_1, IsSheaf := IsSheaf_1 }) =
(toPresheafedSpace = toPresheafedSpace_1) |
EStateM.Backtrackable.recOn | Init.Prelude | {δ σ : Type u} →
{motive : EStateM.Backtrackable δ σ → Sort u_1} →
(t : EStateM.Backtrackable δ σ) →
((save : σ → δ) → (restore : σ → δ → σ) → motive { save := save, restore := restore }) → motive t |
Mathlib.Tactic.Ring.ExBase.atom.injEq | Mathlib.Tactic.Ring.Common | ∀ {u : Lean.Level} {α : Q(Type u)} {sα : Q(CommSemiring «$α»)} {e : Q(«$α»)} (id id_1 : ℕ),
(Mathlib.Tactic.Ring.ExBase.atom id = Mathlib.Tactic.Ring.ExBase.atom id_1) = (id = id_1) |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.induction_aux._simp_1_10 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {a : α} {b : β}, {a • b} = a • {b} |
CategoryTheory.Functor.OplaxMonoidal.whiskeringRight._proof_6 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_3} {D : Type u_4} {E : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} E]
[inst_3 : CategoryTheory.MonoidalCategory D] [inst_4 : CategoryTheory.MonoidalCategory E]
(L : CategoryTheory.Functor D E) [inst_5 : L.OplaxMonoidal] {X Y : CategoryTheory.Functor C D} (f : X ⟶ Y)
(X' : CategoryTheory.Functor C D),
CategoryTheory.CategoryStruct.comp
{ app := fun X_1 => CategoryTheory.Functor.OplaxMonoidal.δ L (X.obj X_1) (X'.obj X_1), naturality := ⋯ }
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (((CategoryTheory.Functor.whiskeringRight C D E).obj L).map f)
(((CategoryTheory.Functor.whiskeringRight C D E).obj L).obj X')) =
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.whiskeringRight C D E).obj L).map
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f X'))
{ app := fun X => CategoryTheory.Functor.OplaxMonoidal.δ L (Y.obj X) (X'.obj X), naturality := ⋯ } |
Std.Iter.allM_map | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β β' : Type w} {m : Type → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad m]
[inst_3 : Std.IteratorLoop α Id m] [LawfulMonad m] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {f : β → β'}
{p : β' → m Bool}, Std.Iter.allM p (Std.Iter.map f it) = Std.Iter.allM (fun x => p (f x)) it |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.mem_erase._simp_1_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, (a ∈ m) = (m.contains a = true) |
PiTensorProduct.map._proof_1 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_2} {R : Type u_1} [inst : CommSemiring R] {t : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (t i)]
[inst_2 : (i : ι) → Module R (t i)], SMulCommClass R R (PiTensorProduct R fun i => t i) |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.isAtoms | Lean.Elab.DocString.Builtin.Keywords | List String → Lean.Syntax → Bool |
Finset.trop_inf | Mathlib.Algebra.Tropical.BigOperators | ∀ {R : Type u_1} {S : Type u_2} [inst : LinearOrder R] [inst_1 : OrderTop R] (s : Finset S) (f : S → R),
Tropical.trop (s.inf f) = ∑ i ∈ s, Tropical.trop (f i) |
CategoryTheory.Limits.Bicone.IsBilimit.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {B : CategoryTheory.Limits.Bicone F}
[inst_2 : SizeOf J] [inst_3 : SizeOf C] (isLimit : CategoryTheory.Limits.IsLimit B.toCone)
(isColimit : CategoryTheory.Limits.IsColimit B.toCocone),
sizeOf { isLimit := isLimit, isColimit := isColimit } = 1 + sizeOf isLimit + sizeOf isColimit |
ProofWidgets.Html._sizeOf_inst | ProofWidgets.Data.Html | SizeOf ProofWidgets.Html |
CategoryTheory.EffectiveEpiStruct.noConfusionType | Mathlib.CategoryTheory.EffectiveEpi.Basic | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
{f : Y ⟶ X} →
CategoryTheory.EffectiveEpiStruct f →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{X' Y' : C'} → {f' : Y' ⟶ X'} → CategoryTheory.EffectiveEpiStruct f' → Sort u |
QuadraticAlgebra.instFinite | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} (a b : R) [inst : Semiring R], Module.Finite R (QuadraticAlgebra R a b) |
ULift.up_iSup | Mathlib.Order.CompleteLattice.Lemmas | ∀ {α : Type u_1} {ι : Sort u_4} [inst : SupSet α] (f : ι → α), { down := ⨆ i, f i } = ⨆ i, { down := f i } |
Polygon.mk.sizeOf_spec | Mathlib.Geometry.Polygon.Basic | ∀ {P : Type u_1} {n : ℕ} [inst : SizeOf P] (vertices : Fin n → P), sizeOf { vertices := vertices } = 1 |
MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} {f f' : ℝ → E} {a : ℝ} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E],
(∀ x ∈ Set.Ioi a, HasDerivAt f (f' x) x) →
MeasureTheory.IntegrableOn f' (Set.Ioi a) MeasureTheory.volume →
Filter.Tendsto f Filter.atTop (nhds (limUnder Filter.atTop f)) |
sigmaFinsuppEquivDFinsupp | Mathlib.Data.Finsupp.ToDFinsupp | {ι : Type u_1} → {η : ι → Type u_4} → {N : Type u_5} → [inst : Zero N] → ((i : ι) × η i →₀ N) ≃ Π₀ (i : ι), η i →₀ N |
LinearPMap.ctorIdx | Mathlib.LinearAlgebra.LinearPMap | {R : Type u} →
{inst : Ring R} →
{E : Type v} →
{inst_1 : AddCommGroup E} →
{inst_2 : Module R E} → {F : Type w} → {inst_3 : AddCommGroup F} → {inst_4 : Module R F} → (E →ₗ.[R] F) → ℕ |
Option.get_of_eq_some | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {a : α} {o : Option α} (h : o.isSome = true), o = some a → o.get h = a |
LinearEquiv.multilinearMapCongrLeft._proof_3 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.Polynomial.Chebyshev.negOnePow_mul_negOnePow_mul_cancel | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {α β : ℝ} {i : ℕ}, (-1) ^ i * α * ((-1) ^ i * β) = α * β |
ProofWidgets.Penrose.DiagramState._sizeOf_inst | ProofWidgets.Component.PenroseDiagram | SizeOf ProofWidgets.Penrose.DiagramState |
left_neg_eq_right_neg | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_2} [inst : AddMonoid M] {a b c : M}, b + a = 0 → a + c = 0 → b = c |
Mathlib.Tactic.Ring.of_eq | Mathlib.Tactic.Ring.Basic | ∀ {α : Sort u_1} {a b c : α}, a = c → b = c → a = b |
_private.Mathlib.Tactic.SimpRw.0.Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1.match_1 | Mathlib.Tactic.SimpRw | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → ((x : Lean.Syntax) → motive (some x)) → (Unit → motive none) → motive x |
Lean.CodeAction.insertBuiltin | Lean.Server.CodeActions.Attr | Array Lean.Name → Lean.CodeAction.CommandCodeAction → IO Unit |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_ennreal_mul._simp_1_3 | Mathlib.Data.EReal.Basic | ∀ (x y : NNReal), ↑x * ↑y = ↑(x * y) |
CategoryTheory.Functor.corepresentable_preservesLimit | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type v)) [F.IsCorepresentable]
{J : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} J] (G : CategoryTheory.Functor J C),
CategoryTheory.Limits.PreservesLimit G F |
CategoryTheory.Functor.pointwiseLeftKanExtension._proof_4 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_4} {H : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.Category.{u_5, u_6} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) [inst_3 : L.HasPointwiseLeftKanExtension F] (Y : D)
(g₁ g₂ : CategoryTheory.CostructuredArrow L Y) (φ : g₁ ⟶ g₂),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.CostructuredArrow.proj L Y).comp F).map φ)
(CategoryTheory.Limits.colimit.ι ((CategoryTheory.CostructuredArrow.proj L Y).comp F)
((CategoryTheory.CostructuredArrow.map (CategoryTheory.CategoryStruct.id Y)).obj g₂)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimit.ι ((CategoryTheory.CostructuredArrow.proj L Y).comp F)
((CategoryTheory.CostructuredArrow.map (CategoryTheory.CategoryStruct.id Y)).obj g₁))
(((CategoryTheory.Functor.const (CategoryTheory.CostructuredArrow L Y)).obj
(CategoryTheory.Limits.colimit ((CategoryTheory.CostructuredArrow.proj L Y).comp F))).map
φ) |
CategoryTheory.sectionsFunctorNatIsoCoyoneda_inv_app_coe | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : Type (max u₁ u₂)) [inst_1 : Unique X]
(X_1 : CategoryTheory.Functor C (Type (max u₁ u₂)))
(a : (CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.Functor.const C).obj X))).obj X_1) (j : C),
↑((CategoryTheory.sectionsFunctorNatIsoCoyoneda X).inv.app X_1 a) j = a.app j default |
NormedGroup.induced.eq_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {𝓕 : Type u_1} (E : Type u_5) (F : Type u_6) [inst : FunLike 𝓕 E F] [inst_1 : Group E] [inst_2 : NormedGroup F]
[inst_3 : MonoidHomClass 𝓕 E F] (f : 𝓕) (h : Function.Injective ⇑f),
NormedGroup.induced E F f h =
{ toNorm := (SeminormedGroup.induced E F f).toNorm, toGroup := (SeminormedGroup.induced E F f).toGroup,
toPseudoMetricSpace := (SeminormedGroup.induced E F f).toPseudoMetricSpace, eq_of_dist_eq_zero := ⋯,
dist_eq := ⋯ } |
PEquiv.vecMul_toMatrix_toPEquiv | Mathlib.Data.Matrix.PEquiv | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : DecidableEq n] [inst_1 : Fintype m] [inst_2 : NonAssocSemiring α]
(σ : m ≃ n) (a : m → α), Matrix.vecMul a σ.toPEquiv.toMatrix = a ∘ ⇑σ.symm |
IsStrictlyPositive.sqrt | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [IsTopologicalRing A] [T2Space A] {a : A},
IsStrictlyPositive a → IsStrictlyPositive (CFC.sqrt a) |
MeasureTheory.Lp_toLp_restrict_smul | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {F : Type u_4} {mX : MeasurableSpace X} {𝕜 : Type u_5} [inst : NormedRing 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : Module 𝕜 F] [inst_3 : IsBoundedSMul 𝕜 F] {p : ENNReal}
{μ : MeasureTheory.Measure X} (c : 𝕜) (f : ↥(MeasureTheory.Lp F p μ)) (s : Set X),
MeasureTheory.MemLp.toLp ↑↑(c • f) ⋯ = c • MeasureTheory.MemLp.toLp ↑↑f ⋯ |
SmoothBumpFunction.mk.noConfusion | Mathlib.Geometry.Manifold.BumpFunction | {E : Type uE} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{H : Type uH} →
{inst_2 : TopologicalSpace H} →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
{inst_3 : TopologicalSpace M} →
{inst_4 : ChartedSpace H M} →
{c : M} →
{P : Sort u} →
{toContDiffBump : ContDiffBump (↑(extChartAt I c) c)} →
{closedBall_subset :
Metric.closedBall (↑(extChartAt I c) c) toContDiffBump.rOut ∩ Set.range ↑I ⊆
(extChartAt I c).target} →
{toContDiffBump' : ContDiffBump (↑(extChartAt I c) c)} →
{closedBall_subset' :
Metric.closedBall (↑(extChartAt I c) c) toContDiffBump'.rOut ∩ Set.range ↑I ⊆
(extChartAt I c).target} →
{ toContDiffBump := toContDiffBump, closedBall_subset := closedBall_subset } =
{ toContDiffBump := toContDiffBump', closedBall_subset := closedBall_subset' } →
(toContDiffBump ≍ toContDiffBump' → P) → P |
Substring.Raw.ValidFor.of_eq | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (s : Substring.Raw),
s.str.toList = l ++ m ++ r →
s.startPos.byteIdx = String.utf8Len l →
s.stopPos.byteIdx = String.utf8Len l + String.utf8Len m → Substring.Raw.ValidFor l m r s |
instComplementInt16 | Init.Data.SInt.Basic | Complement Int16 |
MeasureTheory.measure_union_le | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α] {μ : F}
(s t : Set α), μ (s ∪ t) ≤ μ s + μ t |
sub_add_sub_comm | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c d : α), a - b + (c - d) = a + c - (b + d) |
_private.Mathlib.GroupTheory.Archimedean.0.Subgroup.exists_isLeast_one_lt._simp_1_2 | Mathlib.GroupTheory.Archimedean | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a ^ n * a = a ^ (n + 1) |
HomologicalComplex.cylinder.ι₀_desc | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F K : HomologicalComplex C c} [inst_2 : DecidableRel c.Rel]
[inst_3 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)]
[inst_4 :
HomologicalComplex.HasHomotopyCofiber
(CategoryTheory.Limits.biprod.lift (CategoryTheory.CategoryStruct.id K) (-CategoryTheory.CategoryStruct.id K))]
(φ₀ φ₁ : K ⟶ F) (h : Homotopy φ₀ φ₁),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.cylinder.ι₀ K) (HomologicalComplex.cylinder.desc φ₀ φ₁ h) = φ₀ |
Lean.Lsp.DidChangeTextDocumentParams.mk | Lean.Data.Lsp.TextSync | Lean.Lsp.VersionedTextDocumentIdentifier →
Array Lean.Lsp.TextDocumentContentChangeEvent → Lean.Lsp.DidChangeTextDocumentParams |
_private.Init.Data.Array.Find.0.Array.get_find?_mem._simp_1_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} (h : (List.find? p xs).isSome = true),
((List.find? p xs).get h ∈ xs) = True |
_private.Lean.Meta.Tactic.Grind.Util.0._regBuiltin.Lean.Meta.Grind.reducePreMatchCond.declare_56._@.Lean.Meta.Tactic.Grind.Util.2249970803._hygCtx._hyg.10 | Lean.Meta.Tactic.Grind.Util | IO Unit |
Primrec.nat_casesOn | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {f : α → ℕ} {g : α → β} {h : α → ℕ → β},
Primrec f → Primrec g → Primrec₂ h → Primrec fun a => Nat.casesOn (f a) (g a) (h a) |
Std.ExtHashMap.get?_eq_getElem? | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, m.get? a = m[a]? |
Lean.Lsp.instHashableResolvableCompletionItem | Lean.Data.Lsp.LanguageFeatures | Hashable Lean.Lsp.ResolvableCompletionItem |
ModuleCat.piIsoPi_hom_ker_subtype | Mathlib.Algebra.Category.ModuleCat.Products | ∀ {R : Type u} [inst : Ring R] {ι : Type v} (Z : ι → ModuleCat R) [inst_1 : CategoryTheory.Limits.HasProduct Z] (i : ι),
CategoryTheory.CategoryStruct.comp (ModuleCat.piIsoPi Z).hom (ModuleCat.ofHom (LinearMap.proj i)) =
CategoryTheory.Limits.Pi.π Z i |
monovary_iff_mul_rearrangement | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {f g : ι → α},
Monovary f g ↔ ∀ (i j : ι), f i * g j + f j * g i ≤ f i * g i + f j * g j |
_private.Mathlib.Algebra.Homology.Embedding.Basic.0.ComplexShape.notMem_range_embeddingUpIntLE_iff._proof_1_2 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ (p n : ℤ), p < n → ∀ (i : ℕ), ¬p - ↑i = n |
FractionalIdeal.coeIdeal_inf | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[FaithfulSMul R P] (I J : Ideal R), ↑(I ⊓ J) = ↑I ⊓ ↑J |
Sum.Lex.mono | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {r₁ r₂ : α → α → Prop} {β : Type u_2} {s₁ s₂ : β → β → Prop} {x y : α ⊕ β},
(∀ (a b : α), r₁ a b → r₂ a b) → (∀ (a b : β), s₁ a b → s₂ a b) → Sum.Lex r₁ s₁ x y → Sum.Lex r₂ s₂ x y |
AlgebraicGeometry.opensRestrict | Mathlib.AlgebraicGeometry.Restrict | {X : AlgebraicGeometry.Scheme} → (U : X.Opens) → (↑U).Opens ≃ { V // V ≤ U } |
_private.Lean.Widget.Diff.0.Lean.Widget.instAppendExprDiff | Lean.Widget.Diff | Append Lean.Widget.ExprDiff✝ |
_private.Mathlib.MeasureTheory.Measure.Portmanteau.0.MeasureTheory.FiniteMeasure.limsup_measure_closed_le_of_tendsto._simp_1_2 | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True |
Lean.Meta.Grind.Arith.Cutsat.State.nonlinearOccs._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.PersistentHashMap Int.Linear.Var (List Int.Linear.Var) |
Std.Rxi.HasSize.mk._flat_ctor | Init.Data.Range.Polymorphic.Basic | {α : Type u} → (α → ℕ) → Std.Rxi.HasSize α |
AlgebraicGeometry.isLimitOpensCone._proof_1 | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u_1} [inst : CategoryTheory.Category.{u_1, u_1} I] (i : I),
CategoryTheory.IsConnected (CategoryTheory.Over i) |
cfc_comp_zpow._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
Lean.MonadRef.rec | Init.Prelude | {m : Type → Type} →
{motive : Lean.MonadRef m → Sort u} →
((getRef : m Lean.Syntax) →
(withRef : {α : Type} → Lean.Syntax → m α → m α) → motive { getRef := getRef, withRef := withRef }) →
(t : Lean.MonadRef m) → motive t |
Mathlib.Meta.FunProp.FunctionData._sizeOf_inst | Mathlib.Tactic.FunProp.FunctionData | SizeOf Mathlib.Meta.FunProp.FunctionData |
MvPolynomial.IsWeightedHomogeneous.weightedHomogeneousComponent_ne | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] {w : σ → M} {m : M}
(n : M) {p : MvPolynomial σ R},
MvPolynomial.IsWeightedHomogeneous w p m → n ≠ m → (MvPolynomial.weightedHomogeneousComponent w n) p = 0 |
Submodule.annihilator_map_mkQ_eq_colon | Mathlib.RingTheory.Ideal.Colon | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N P : Submodule R M},
(Submodule.map N.mkQ P).annihilator = N.colon ↑P |
MeasureTheory.empty_mem_measurableCylinders | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_2} (α : ι → Type u_1) [inst : (i : ι) → MeasurableSpace (α i)], ∅ ∈ MeasureTheory.measurableCylinders α |
Std.ExtTreeMap.self_le_maxKey!_insertIfNew | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β}, (cmp k (t.insertIfNew k v).maxKey!).isLE = true |
SimpleGraph.not_isTutteViolator_of_isPerfectMatching | Mathlib.Combinatorics.SimpleGraph.Tutte | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V] {M : G.Subgraph},
M.IsPerfectMatching → ∀ (u : Set V), ¬G.IsTutteViolator u |
OpenSubgroup.instLattice.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : ContinuousMul G],
OpenSubgroup.instLattice =
{ toSemilatticeSup := Function.Injective.semilatticeSup OpenSubgroup.toSubgroup ⋯ ⋯ ⋯ ⋯, inf := SemilatticeInf.inf,
inf_le_left := ⋯, inf_le_right := ⋯, le_inf := ⋯ } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.