name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.instQuoteCharCharLitKind | Init.Meta.Defs | Lean.Quote Char Lean.charLitKind |
Function.FromTypes.uncurry_two_eq_uncurry | Mathlib.Data.Fin.Tuple.Curry | ∀ (p : Fin 2 → Type u) (τ : Type u) (f : Function.FromTypes p τ), f.uncurry = Function.uncurry f ∘ ⇑(piFinTwoEquiv p) |
DirectSum.lieAlgebraComponent._proof_1 | Mathlib.Algebra.Lie.DirectSum | ∀ (R : Type u_3) (ι : Type u_2) [inst : CommRing R] (L : ι → Type u_1) [inst_1 : (i : ι) → LieRing (L i)]
[inst_2 : (i : ι) → LieAlgebra R (L i)] (j : ι) {x y : DirectSum ι fun i => L i},
(DirectSum.component R ι L j) ⁅x, y⁆ = ⁅(DirectSum.component R ι L j) x, (DirectSum.component R ι L j) y⁆ |
Hindman.FS.below.tail' | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FS a a_1 → Prop}
(a : Stream' M) (m : M) (h : Hindman.FS a.tail m), Hindman.FS.below h → motive a.tail m h → Hindman.FS.below ⋯ |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.mk | Init.Data.Format.Basic | Bool → Bool → ℕ → Std.Format.SpaceResult✝ |
TypeVec.lastFun_appendFun | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α : TypeVec.{u_1} n} {α' : TypeVec.{u_2} n} {β : Type u_1} {β' : Type u_2} (f : α.Arrow α') (g : β → β'),
TypeVec.lastFun (f ::: g) = g |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.remainder_lt_aux | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Field R] {q : Polynomial R} (p : Polynomial R), q ≠ 0 → (p.mod q).degree < q.degree |
UInt16.xor_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt16}, (a ^^^ b = 0) = (a = b) |
_private.Mathlib.RingTheory.TensorProduct.DirectLimitFG.0.TensorProduct.Algebra.eq_of_fg_of_subtype_eq._simp_1_11 | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ {α : Type u} {s t : Set α}, (t ⊆ s ∪ t) = True |
CategoryTheory.OverPresheafAux.OverArrows.yonedaArrow_val | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {Y : C}
{η : CategoryTheory.yoneda.obj Y ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {f : X ⟶ Y}
(hf : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) η = s),
(CategoryTheory.OverPresheafAux.OverArrows.yonedaArrow f hf).val = f |
SNum._aux_Mathlib_Data_Num_Bitwise___unexpand_SNum_bit_1 | Mathlib.Data.Num.Bitwise | Lean.PrettyPrinter.Unexpander |
IO.instLTTaskState | Init.System.IO | LT IO.TaskState |
Lean.Lsp.SnippetString.noConfusion | Lean.Data.Lsp.Basic | {P : Sort u} → {t t' : Lean.Lsp.SnippetString} → t = t' → Lean.Lsp.SnippetString.noConfusionType P t t' |
Aesop.NormM.Context.rec | Aesop.Search.Expansion.Norm | {motive : Aesop.NormM.Context → Sort u} →
((options : Aesop.Options') →
(ruleSet : Aesop.LocalRuleSet) →
(normSimpContext : Aesop.NormSimpContext) →
motive { options := options, ruleSet := ruleSet, normSimpContext := normSimpContext }) →
(t : Aesop.NormM.Context) → motive t |
Continuous.cexp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ}, Continuous f → Continuous fun y => Complex.exp (f y) |
HomologicalComplex.hasExactColimitsOfShape | Mathlib.Algebra.Homology.GrothendieckAbelian | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (J : Type w) [inst_2 : CategoryTheory.Category.{w', w} J]
[CategoryTheory.Limits.HasFiniteLimits C] [inst_4 : CategoryTheory.Limits.HasColimitsOfShape J C]
[CategoryTheory.HasExactColimitsOfShape J C], CategoryTheory.HasExactColimitsOfShape J (HomologicalComplex C c) |
Lean.Meta.DiscrTree.Key.arrow | Lean.Meta.DiscrTree.Types | Lean.Meta.DiscrTree.Key |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_two_mul_toInt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {x : BitVec 0}, (¬-2 ^ 0 ≤ 2 * if 2 * x.toNat < 2 ^ 0 then ↑x.toNat else ↑x.toNat - ↑(2 ^ 0)) → False |
IsRightUniformGroup.mk._flat_ctor | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {G : Type u_7} [inst : UniformSpace G] [inst_1 : Group G],
(Continuous fun p => p.1 * p.2) →
(Continuous fun a => a⁻¹) → uniformity G = Filter.comap (fun x => x.2 * x.1⁻¹) (nhds 1) → IsRightUniformGroup G |
Language.reverse_zero | Mathlib.Computability.Language | ∀ {α : Type u_1}, Language.reverse 0 = 0 |
Nat.add_choose | Mathlib.Data.Nat.Choose.Basic | ∀ (i j : ℕ), (i + j).choose j = (i + j).factorial / (i.factorial * j.factorial) |
CategoryTheory.Functor.FullyFaithful.preimage | Mathlib.CategoryTheory.Functor.FullyFaithful | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} → F.FullyFaithful → {X Y : C} → (F.obj X ⟶ F.obj Y) → (X ⟶ Y) |
AlgebraicGeometry.HasRingHomProperty.of_source_openCover | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P Q] {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [AlgebraicGeometry.IsAffine Y]
(𝒰 : X.OpenCover) [∀ (i : 𝒰.I₀), AlgebraicGeometry.IsAffine (𝒰.X i)],
(∀ (i : 𝒰.I₀),
Q (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appTop (CategoryTheory.CategoryStruct.comp (𝒰.f i) f)))) →
P f |
_private.Init.Grind.Ring.Basic.0.Lean.Grind.Ring.intCast_add._proof_1_6 | Init.Grind.Ring.Basic | ∀ (x y : ℕ), y ≥ x + 1 → ¬-↑(x + 1) + ↑y = ↑(y - (x + 1)) → False |
Lean.Elab.Tactic.Doc.TacticDoc._sizeOf_inst | Lean.Elab.Tactic.Doc | SizeOf Lean.Elab.Tactic.Doc.TacticDoc |
GaloisInsertion.choice_eq | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(self : GaloisInsertion l u) (a : α) (h : u (l a) ≤ a), self.choice a h = l a |
PrimeSpectrum.zeroLocusEquivIrreducibleCloseds | Mathlib.RingTheory.Spectrum.Prime.Topology | {R : Type u} →
[inst : CommSemiring R] →
(I : Set R) → ↑(PrimeSpectrum.zeroLocus I) ≃o (TopologicalSpace.IrreducibleCloseds ↑(PrimeSpectrum.zeroLocus I))ᵒᵈ |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceCyclesEIso_inv_τ₂ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.cokernelSequenceCyclesEIso._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.cokernelSequenceCyclesEIso._auto_3),
(X.cokernelSequenceCyclesEIso f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).inv.τ₂ = (X.cyclesIso f₁ f₂ f₃ n₀ n₁ n₂ ⋯ ⋯).hom |
Units.instStarMul._proof_4 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (x : Rˣ),
star ↑{ val := star ↑x, inv := star ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ }⁻¹ *
star ↑{ val := star ↑x, inv := star ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ } =
1 |
Lean.Parser.Term.noImplicitLambda._regBuiltin.Lean.Parser.Term.noImplicitLambda_1 | Lean.Parser.Term | IO Unit |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.fst._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ (p : ℤ), p + 2 = p + 2 |
Orthonormal.basisTensorProduct | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F] {ι₁ : Type u_6}
{ι₂ : Type u_7} {b₁ : Module.Basis ι₁ 𝕜 E} {b₂ : Module.Basis ι₂ 𝕜 F},
Orthonormal 𝕜 ⇑b₁ → Orthonormal 𝕜 ⇑b₂ → Orthonormal 𝕜 ⇑(b₁.tensorProduct b₂) |
instCoeTCBiheytingHomOfBiheytingHomClass._proof_3 | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_1} [inst : FunLike F α β] [inst_1 : BiheytingAlgebra α]
[inst_2 : BiheytingAlgebra β] [BiheytingHomClass F α β] (f : F) (a b : α), f (a ⇨ b) = f a ⇨ f b |
HomologicalComplex₂.total.map | Mathlib.Algebra.Homology.TotalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{I₁₂ : Type u_4} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
{K L : HomologicalComplex₂ C c₁ c₂} →
(K ⟶ L) →
(c₁₂ : ComplexShape I₁₂) →
[inst_2 : TotalComplexShape c₁ c₂ c₁₂] →
[inst_3 : DecidableEq I₁₂] →
[inst_4 : K.HasTotal c₁₂] → [inst_5 : L.HasTotal c₁₂] → K.total c₁₂ ⟶ L.total c₁₂ |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategorySnd._proof_6 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) {X_1 Y_1 Z : CategoryTheory.Over Y} (f : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z),
CategoryTheory.Over.homMk
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.CategoryStruct.comp f g).left) ⋯ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.homMk (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f.left) ⋯)
(CategoryTheory.Over.homMk (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X g.left) ⋯) |
Height.logHeight_fun_mul_eq | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} {ι' : Type u_3} [Finite ι]
[Finite ι'] {x : ι → K},
x ≠ 0 → ∀ {y : ι' → K}, y ≠ 0 → (Height.logHeight fun a => x a.1 * y a.2) = Height.logHeight x + Height.logHeight y |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_collision.match_1_3 | Mathlib.NumberTheory.Rayleigh | ∀ {s : ℝ} ⦃j : ℤ⦄ (motive : j ∈ {x | ∃ k, beattySeq' s k = x} → Prop) (h : j ∈ {x | ∃ k, beattySeq' s k = x}),
(∀ (m : ℤ) (h₂ : beattySeq' s m = j), motive ⋯) → motive h |
Std.PRange.Nat.size_Rio | Init.Data.Range.Polymorphic.NatLemmas | ∀ {b : ℕ}, (*...b).size = b |
PUnit.normedCommRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ (a b : PUnit.{u_1 + 1}), a + b = b + a |
SSet.horn₂₂.isPushout | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | CategoryTheory.IsPushout (SSet.stdSimplex.δ 0) (SSet.stdSimplex.δ 0) SSet.horn₂₂.ι₀₂ SSet.horn₂₂.ι₁₂ |
MeasureTheory.ComplexMeasure.re | Mathlib.MeasureTheory.Measure.Complex | {α : Type u_1} → {m : MeasurableSpace α} → MeasureTheory.ComplexMeasure α →ₗ[ℝ] MeasureTheory.SignedMeasure α |
MonCat.Colimits.coconeMorphism._proof_1 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat) (j : J),
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) (MonCat.Colimits.Prequotient.of j 1) =
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) MonCat.Colimits.Prequotient.one |
Qq.Impl.ExprBackSubstResult | Qq.Macro | Type |
Besicovitch.TauPackage.iUnionUpTo.eq_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(i : Ordinal.{u}), p.iUnionUpTo i = ⋃ j, Metric.ball (p.c (p.index ↑j)) (p.r (p.index ↑j)) |
_private.Mathlib.LinearAlgebra.Semisimple.0.Module.End.IsSemisimple.of_mem_adjoin_pair._simp_1_2 | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {y : R} [inst : CommSemiring R], (Ideal.span {y}).IsRadical = IsRadical y |
ProbabilityTheory.Kernel.instIsFiniteKernelSectROfProd | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel (α × β) γ) (a : α) [ProbabilityTheory.IsFiniteKernel κ],
ProbabilityTheory.IsFiniteKernel (κ.sectR a) |
_private.Mathlib.Probability.Process.Predictable.0.MeasureTheory.IsPredictable.measurableSet_prodMk_add_one_of_predictable._simp_1_3 | Mathlib.Probability.Process.Predictable | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.withAlts | Lean.Meta.Match.Match | {α : Type} →
Lean.Expr →
Array Lean.Expr →
Array Lean.Meta.Match.DiscrInfo →
List Lean.Meta.Match.AltLHS →
Option Lean.Meta.Match.Overlaps →
(List Lean.Meta.Match.Alt → Array Lean.Expr → Array Lean.Meta.Match.AltParamInfo → Lean.MetaM α) →
Lean.MetaM α |
Std.Rii.pairwise_toList_ne | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rii α} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_4 : Std.Rxi.IsAlwaysFinite α], List.Pairwise (fun a b => a ≠ b) r.toList |
CategoryTheory.PresheafOfGroups.OneCocycle.mk | Mathlib.CategoryTheory.Sites.NonabelianCohomology.H1 | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{G : CategoryTheory.Functor Cᵒᵖ GrpCat} →
{I : Type w'} →
{U : I → C} →
(toOneCochain : CategoryTheory.PresheafOfGroups.OneCochain G U) →
autoParam
(∀ (i j k : I) ⦃T : C⦄ (a : T ⟶ U i) (b : T ⟶ U j) (c : T ⟶ U k),
toOneCochain.ev i j a b * toOneCochain.ev j k b c = toOneCochain.ev i k a c)
CategoryTheory.PresheafOfGroups.OneCocycle.ev_trans._autoParam →
CategoryTheory.PresheafOfGroups.OneCocycle G U |
CategoryTheory.MonoidalCategory.«term_◁ᵢ_» | Mathlib.CategoryTheory.Monoidal.Category | Lean.TrailingParserDescr |
hasFDerivAt_apply | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {ι : Type u_6} {F' : ι → Type u_7}
[inst_1 : (i : ι) → NormedAddCommGroup (F' i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (F' i)] (i : ι) (f : (i : ι) → F' i),
HasFDerivAt (fun f => f i) (ContinuousLinearMap.proj i) f |
Filter.le_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter (α × β)} {g : Filter α} {g' : Filter β},
f ≤ g ×ˢ g' ↔ Filter.Tendsto Prod.fst f g ∧ Filter.Tendsto Prod.snd f g' |
Multiset.union_comm | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ∪ t = t ∪ s |
skewAdjoint.instSMulSubtypeMemAddSubgroupOfStarModule | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} →
{A : Type u_2} →
[inst : Star R] →
[TrivialStar R] →
[inst_2 : AddCommGroup A] →
[inst_3 : StarAddMonoid A] →
[inst_4 : Monoid R] → [inst_5 : DistribMulAction R A] → [StarModule R A] → SMul R ↥(skewAdjoint A) |
Lean.Lsp.TextDocumentChangeRegistrationOptions.mk._flat_ctor | Lean.Data.Lsp.TextSync | Option Lean.Lsp.DocumentSelector → Lean.Lsp.TextDocumentSyncKind → Lean.Lsp.TextDocumentChangeRegistrationOptions |
_private.Qq.ForLean.Do.0.Lean.Elab.Term.extractBind.match_1 | Qq.ForLean.Do | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((m returnType : Lean.Expr) → motive (m.app returnType)) → ((x : Lean.Expr) → motive x) → motive type |
Rat.mul_eq_mkRat | Mathlib.Data.Rat.Defs | ∀ (q r : ℚ), q * r = mkRat (q.num * r.num) (q.den * r.den) |
CategoryTheory.Localization.SmallShiftedHom.equiv | Mathlib.CategoryTheory.Localization.SmallShiftedHom | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(W : CategoryTheory.MorphismProperty C) →
{M : Type w'} →
[inst_2 : AddMonoid M] →
[inst_3 : CategoryTheory.HasShift C M] →
[inst_4 : CategoryTheory.HasShift D M] →
(L : CategoryTheory.Functor C D) →
[L.IsLocalization W] →
[L.CommShift M] →
{X Y : C} →
[inst_7 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y] →
{m : M} →
CategoryTheory.Localization.SmallShiftedHom W X Y m ≃
CategoryTheory.ShiftedHom (L.obj X) (L.obj Y) m |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rcc_ne_empty_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) |
CategoryTheory.Limits.isColimitOfConeUnopOfCocone | Mathlib.CategoryTheory.Limits.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) →
{c : CategoryTheory.Limits.Cocone F} →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneUnopOfCocone c) → CategoryTheory.Limits.IsColimit c |
Lean.Lsp.Hover.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {contents : Lean.Lsp.MarkupContent} {range? : Option Lean.Lsp.Range} {contents_1 : Lean.Lsp.MarkupContent}
{range?_1 : Option Lean.Lsp.Range},
{ contents := contents, range? := range? } = { contents := contents_1, range? := range?_1 } →
contents = contents_1 ∧ range? = range?_1 |
Int.neg_neg | Init.Data.Int.Lemmas | ∀ (a : ℤ), - -a = a |
CategoryTheory.ShortComplex.leftRightHomologyComparison'_fac | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h₁ : S.LeftHomologyData) (h₂ : S.RightHomologyData) [inst_2 : S.HasHomology],
CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁ h₂ =
CategoryTheory.CategoryStruct.comp h₁.homologyIso.inv h₂.homologyIso.hom |
AffineEquiv.mk.inj | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_4} {V₂ : Type u_5} {inst : Ring k}
{inst_1 : AddCommGroup V₁} {inst_2 : AddCommGroup V₂} {inst_3 : Module k V₁} {inst_4 : Module k V₂}
{inst_5 : AddTorsor V₁ P₁} {inst_6 : AddTorsor V₂ P₂} {toEquiv : P₁ ≃ P₂} {linear : V₁ ≃ₗ[k] V₂}
{map_vadd' : ∀ (p : P₁) (v : V₁), toEquiv (v +ᵥ p) = linear v +ᵥ toEquiv p} {toEquiv_1 : P₁ ≃ P₂}
{linear_1 : V₁ ≃ₗ[k] V₂} {map_vadd'_1 : ∀ (p : P₁) (v : V₁), toEquiv_1 (v +ᵥ p) = linear_1 v +ᵥ toEquiv_1 p},
{ toEquiv := toEquiv, linear := linear, map_vadd' := map_vadd' } =
{ toEquiv := toEquiv_1, linear := linear_1, map_vadd' := map_vadd'_1 } →
toEquiv = toEquiv_1 ∧ linear = linear_1 |
RootPairing.Base.cartanMatrix_apply_eq_zero_iff_symm | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (b : P.Base)
[inst_5 : P.IsCrystallographic] [CharZero R] [IsDomain R] {i j : ↥b.support},
b.cartanMatrix i j = 0 ↔ b.cartanMatrix j i = 0 |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.Result.mk.inj | Lean.Meta.LetToHave | ∀ {expr : Lean.Expr} {type? : Option Lean.Expr} {expr_1 : Lean.Expr} {type?_1 : Option Lean.Expr},
{ expr := expr, type? := type? } = { expr := expr_1, type? := type?_1 } → expr = expr_1 ∧ type? = type?_1 |
Mathlib.TacticAnalysis.Config.mk._flat_ctor | Mathlib.Tactic.TacticAnalysis | (Array Mathlib.TacticAnalysis.TacticNode → Lean.Elab.Command.CommandElabM Unit) → Mathlib.TacticAnalysis.Config |
_private.Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions.0.CategoryTheory.Localization.exists_leftFraction₂.match_1_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : L.IsLocalization W] {X Y : C} (f : L.obj X ⟶ L.obj Y)
(motive : (∃ φ, f = φ.map L ⋯) → Prop) (x : ∃ φ, f = φ.map L ⋯),
(∀ (φ : W.LeftFraction X Y) (hφ : f = φ.map L ⋯), motive ⋯) → motive x |
_private.Mathlib.Topology.ContinuousOn.0.continuousOn_prod_of_discrete_right._simp_1_3 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [DiscreteTopology β] {f : α × β → γ} {s : Set (α × β)} {x : α × β},
ContinuousWithinAt f s x = ContinuousWithinAt (fun x_1 => f (x_1, x.2)) {a | (a, x.2) ∈ s} x.1 |
Filter.commMonoid._proof_5 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : CommMonoid α] (a : Filter α), a * 1 = a |
_private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.fastJacobiSym._proof_6 | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (b : ℕ), ¬b = 0 → b / 2 < b |
Std.DTreeMap.Internal.RoiSliceData._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) →
(β : α → Type v) →
{inst : Ord α} → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Std.DTreeMap.Internal.RoiSliceData α β) |
FractionalIdeal.spanFinset_coe | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ (R₁ : Type u_3) [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
[inst_3 : IsFractionRing R₁ K] {ι : Type u_5} (s : Finset ι) (f : ι → K),
↑(FractionalIdeal.spanFinset R₁ s f) = Submodule.span R₁ (f '' ↑s) |
SemiRingCat.limitπRingHom._proof_2 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] (j : J),
(↑(MonCat.limitπMonoidHom (F.comp (CategoryTheory.forget₂ SemiRingCat MonCat)) j)).toFun 1 = 1 |
WithTop.lt_untop_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {b : α} [inst : LT α] {x : WithTop α} (hx : x ≠ ⊤), b < x.untop hx ↔ ↑b < x |
AugmentedSimplexCategory.equivAugmentedSimplicialObject_inverse_obj_map | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : CategoryTheory.SimplicialObject.Augmented C)
{X_1 Y : (CategoryTheory.WithInitial SimplexCategory)ᵒᵖ} (f : X_1 ⟶ Y),
(AugmentedSimplexCategory.equivAugmentedSimplicialObject.inverse.obj X).map f =
match
match Opposite.unop X_1 with
| CategoryTheory.WithInitial.of x => CategoryTheory.WithTerminal.of (Opposite.op x)
| CategoryTheory.WithInitial.star => CategoryTheory.WithTerminal.star,
match Opposite.unop Y with
| CategoryTheory.WithInitial.of x => CategoryTheory.WithTerminal.of (Opposite.op x)
| CategoryTheory.WithInitial.star => CategoryTheory.WithTerminal.star,
match X_1, Y, Opposite.unop f, f with
| Opposite.op (CategoryTheory.WithInitial.of x), Opposite.op (CategoryTheory.WithInitial.of y), f, x_1 =>
(CategoryTheory.WithTerminal.down f).op
| Opposite.op (CategoryTheory.WithInitial.of a), Opposite.op CategoryTheory.WithInitial.star, x, x_1 =>
CategoryTheory.WithTerminal.starTerminal.from (CategoryTheory.WithTerminal.of (Opposite.op a))
| Opposite.op CategoryTheory.WithInitial.star, Opposite.op CategoryTheory.WithInitial.star, x, x_1 =>
CategoryTheory.CategoryStruct.id CategoryTheory.WithTerminal.star with
| CategoryTheory.WithTerminal.of a, CategoryTheory.WithTerminal.of a_1, f =>
X.left.map (CategoryTheory.WithTerminal.down f)
| CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.star, x_1 => X.hom.app x
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => CategoryTheory.CategoryStruct.id X.right |
_private.Mathlib.Data.Finset.Update.0.Function.updateFinset_updateFinset._simp_1_3 | Mathlib.Data.Finset.Update | (¬False) = True |
_private.Mathlib.Data.Rat.Cast.Order.0.Mathlib.Meta.Positivity.evalRatCast._proof_5 | Mathlib.Data.Rat.Cast.Order | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) |
Lean.Elab.Structural.IndGroupInst.recOn | Lean.Elab.PreDefinition.Structural.IndGroupInfo | {motive : Lean.Elab.Structural.IndGroupInst → Sort u} →
(t : Lean.Elab.Structural.IndGroupInst) →
((toIndGroupInfo : Lean.Elab.Structural.IndGroupInfo) →
(levels : List Lean.Level) →
(params : Array Lean.Expr) →
motive { toIndGroupInfo := toIndGroupInfo, levels := levels, params := params }) →
motive t |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.Submodule.le_linearEquiv_of_sSup_eq_top.match_1_5 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N m : Submodule R M)
(motive : (∃ S, Nonempty (↥N ≃ₗ[R] ↥S)) → Prop) (x : ∃ S, Nonempty (↥N ≃ₗ[R] ↥S)),
(∀ (S : Submodule R ↥m) (e : ↥N ≃ₗ[R] ↥S), motive ⋯) → motive x |
Lean.Elab.Term.applyResult | Lean.Elab.Term.TermElabM | {α : Type} → Lean.Elab.Term.TermElabResult α → Lean.Elab.TermElabM α |
CategoryTheory.Adjunction.unit | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} → (F ⊣ G) → (CategoryTheory.Functor.id C ⟶ F.comp G) |
FreeGroup.of | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → α → FreeGroup α |
_private.Mathlib.AlgebraicTopology.SimplicialSet.CompStruct.0._auto_80 | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | Lean.Syntax |
NumberField.ComplexEmbedding.conjugate_comp | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_1} [inst : Field K] {k : Type u_2} [inst_1 : Field k] (φ : K →+* ℂ) (σ : k →+* K),
(NumberField.ComplexEmbedding.conjugate φ).comp σ = NumberField.ComplexEmbedding.conjugate (φ.comp σ) |
normalizedGCDMonoidOfExistsLCM._proof_4 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
(h : ∀ (a b : α), ∃ c, ∀ (d : α), a ∣ d ∧ b ∣ d ↔ c ∣ d) (x x_1 : α),
normalize (normalize (Classical.choose ⋯)) = normalize (Classical.choose ⋯) |
UInt8.le_total | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), a ≤ b ∨ b ≤ a |
CategoryTheory.MorphismProperty.toSet_max | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W₁ W₂ : CategoryTheory.MorphismProperty C),
(W₁ ⊔ W₂).toSet = W₁.toSet ∪ W₂.toSet |
NonUnitalAlgHom.coe_comp | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} {T : Type u_1} [inst : Monoid R] [inst_1 : Monoid S] [inst_2 : Monoid T] {φ : R →* S}
{A : Type v} {B : Type w} {C : Type w₁} [inst_3 : NonUnitalNonAssocSemiring A] [inst_4 : DistribMulAction R A]
[inst_5 : NonUnitalNonAssocSemiring B] [inst_6 : DistribMulAction S B] [inst_7 : NonUnitalNonAssocSemiring C]
[inst_8 : DistribMulAction T C] {ψ : S →* T} {χ : R →* T} (f : B →ₛₙₐ[ψ] C) (g : A →ₛₙₐ[φ] B)
[inst_9 : φ.CompTriple ψ χ], ⇑(f.comp g) = ⇑f ∘ ⇑g |
Std.DTreeMap.Internal.Impl.getKey?_insertMany_empty_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} [Std.TransOrd α] {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l → (↑(Std.DTreeMap.Internal.Impl.empty.insertMany l ⋯)).getKey? k' = some k |
nonempty_orderEmbedding_of_finite_infinite | Mathlib.Data.Finset.Sort | ∀ (α : Type u_1) [inst : LinearOrder α] [hα : Finite α] (β : Type u_2) [inst_1 : LinearOrder β] [hβ : Infinite β],
Nonempty (α ↪o β) |
Filter.map_inr_inf_map_inl | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, Filter.map Sum.inr f ⊓ Filter.map Sum.inl g = ⊥ |
CategoryTheory.Subfunctor.Subpresheaf.toRange_app_val | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} (p : F' ⟶ F) {i : C}
(x : F'.obj i), ↑((CategoryTheory.Subfunctor.toRange p).app i x) = p.app i x |
Module.Basis.mk_coord_apply_ne | Mathlib.LinearAlgebra.Basis.Basic | ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : ι → M} {hli : LinearIndependent R v} {hsp : ⊤ ≤ Submodule.span R (Set.range v)} {i j : ι},
j ≠ i → ((Module.Basis.mk hli hsp).coord i) (v j) = 0 |
le_or_lt_of_mul_le_mul | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Mul α] [MulLeftMono α] [MulRightStrictMono α] {a₁ a₂ b₁ b₂ : α},
a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂ |
CategoryTheory.PreGaloisCategory.instHasFiniteLimits | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.PreGaloisCategory C],
CategoryTheory.Limits.HasFiniteLimits C |
binomialSeries_eq_ordinaryHypergeometricSeries | Mathlib.Analysis.Analytic.Binomial | ∀ {𝕂 : Type u} [inst : Field 𝕂] [inst_1 : CharZero 𝕂] {𝔸 : Type v} [inst_2 : Ring 𝔸] [inst_3 : Algebra 𝕂 𝔸]
[inst_4 : TopologicalSpace 𝔸] [inst_5 : IsTopologicalRing 𝔸] {a b : 𝕂},
(∀ (k : ℕ), ↑k ≠ -b) →
binomialSeries 𝔸 a = (ordinaryHypergeometricSeries 𝔸 (-a) b b).compContinuousLinearMap (-ContinuousLinearMap.id 𝕂 𝔸) |
Lean.Elab.Term.ToDepElimPattern.TopSort.State._sizeOf_1 | Lean.Elab.Match | Lean.Elab.Term.ToDepElimPattern.TopSort.State → ℕ |
ODE.FunSpace.instMetricSpace | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} → {t₀ : ↑(Set.Icc tmin tmax)} → {x₀ : E} → {r L : NNReal} → MetricSpace (ODE.FunSpace t₀ x₀ r L) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.