name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Int.Linear.Poly.add.elim | Init.Data.Int.Linear | {motive : Int.Linear.Poly → Sort u} →
(t : Int.Linear.Poly) →
t.ctorIdx = 1 →
((k : ℤ) → (v : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.add k v p)) → motive t |
AlgebraicTopology.DoldKan.MorphComponents.noConfusionType | Mathlib.AlgebraicTopology.DoldKan.Decomposition | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : CategoryTheory.SimplicialObject C} →
{n : ℕ} →
{Z : C} →
AlgebraicTopology.DoldKan.MorphComponents X n Z →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{X' : CategoryTheory.SimplicialObject C'} →
{n' : ℕ} → {Z' : C'} → AlgebraicTopology.DoldKan.MorphComponents X' n' Z' → Sort u |
CategoryTheory.Limits.ImageFactorisation.copy_isImage | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
(F : CategoryTheory.Limits.ImageFactorisation f) (m : F.F.I ⟶ Y) (e : X ⟶ F.F.I)
(hm : autoParam (m = F.F.m) CategoryTheory.Limits.ImageFactorisation.copy._auto_1)
(he : autoParam (e = F.F.e) CategoryTheory.Limits.ImageFactorisation.copy._auto_3),
(F.copy m e hm he).isImage = F.isImage.copy m e ⋯ ⋯ |
MvPolynomial.C | Mathlib.Algebra.MvPolynomial.Basic | {R : Type u} → {σ : Type u_1} → [inst : CommSemiring R] → R →+* MvPolynomial σ R |
AffineMap.hasStrictDerivAt | Mathlib.Analysis.Calculus.Deriv.AffineMap | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 →ᵃ[𝕜] E) {x : 𝕜}, HasStrictDerivAt (⇑f) (f.linear 1) x |
FractionalIdeal.coeIdeal_injective' | 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]
[loc : IsLocalization S P], S ≤ nonZeroDivisors R → Function.Injective fun I => ↑I |
Lean.Parser.Tactic.dsimpArg | Init.Tactics | Lean.ParserDescr |
ContinuousLinearMap.norm_compContinuousAlternatingMap_le | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {G : Type wG} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : Fintype ι]
(g : F →L[𝕜] G) (f : E [⋀^ι]→L[𝕜] F), ‖g.compContinuousAlternatingMap f‖ ≤ ‖g‖ * ‖f‖ |
List.isPrefixOf?_eq_some_iff_append_eq | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {xs ys zs : List α}, xs.isPrefixOf? ys = some zs ↔ xs ++ zs = ys |
ModuleCat.restrictCoextendScalarsAdj._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_3} {S : Type u_1} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) {X : ModuleCat S} {Y : ModuleCat R}
{g : X ⟶ (ModuleCat.coextendScalars f).obj Y},
{ toFun := ModuleCat.RestrictionCoextensionAdj.HomEquiv.fromRestriction f,
invFun := ModuleCat.RestrictionCoextensionAdj.HomEquiv.toRestriction f, left_inv := ⋯, right_inv := ⋯ }.symm
g =
CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalars f).map g)
((ModuleCat.RestrictionCoextensionAdj.counit' f).app Y) |
AddSubmonoid.mk | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : AddZeroClass M] → (toAddSubsemigroup : AddSubsemigroup M) → 0 ∈ toAddSubsemigroup.carrier → AddSubmonoid M |
CategoryTheory.Quiv.equivOfIso | Mathlib.CategoryTheory.Category.Quiv | {V W : CategoryTheory.Quiv} → (V ≅ W) → ↑V ≃ ↑W |
Subgroup.closure_singleton_inv | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : Group G] (x : G), Subgroup.closure {x⁻¹} = Subgroup.closure {x} |
_private.Mathlib.FieldTheory.RatFunc.Basic.0.RatFunc.wrapped._proof_1._@.Mathlib.FieldTheory.RatFunc.Basic.1687740377._hygCtx._hyg.2 | Mathlib.FieldTheory.RatFunc.Basic | @RatFunc.definition✝ = @RatFunc.definition✝ |
Pi.coe_evalLatticeHom | Mathlib.Order.Hom.Lattice | ∀ {ι : Type u_6} {α : ι → Type u_7} [inst : (i : ι) → Lattice (α i)] (i : ι), ⇑(Pi.evalLatticeHom i) = Function.eval i |
CategoryTheory.Comma.coconeOfPreserves_pt_hom | Mathlib.CategoryTheory.Limits.Comma | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] {A : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
{B : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃}
[inst_3 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T}
(F : CategoryTheory.Functor J (CategoryTheory.Comma L R))
[inst_4 : CategoryTheory.Limits.PreservesColimit (F.comp (CategoryTheory.Comma.fst L R)) L]
{c₁ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.fst L R))} (t₁ : CategoryTheory.Limits.IsColimit c₁)
(c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R))),
(CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).pt.hom =
(CategoryTheory.Limits.isColimitOfPreserves L t₁).desc (CategoryTheory.Comma.colimitAuxiliaryCocone F c₂) |
IsMaxOn.isLUB | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α},
a ∈ s → IsMaxOn f s a → IsLUB {x | ∃ x_1 ∈ s, f x_1 = x} (f a) |
Aesop.Frontend.Parser.transparency | Aesop.Frontend.RuleExpr | Lean.ParserDescr |
CochainComplex.HomComplex.Cocycle.diff._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | 1 + 1 = 1 + 1 |
Finset.single_lt_sum | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedCancelAddMonoid M] {f : ι → M}
{s : Finset ι} [AddLeftStrictMono M] {i j : ι},
j ≠ i → i ∈ s → j ∈ s → 0 < f j → (∀ k ∈ s, k ≠ i → 0 ≤ f k) → f i < ∑ k ∈ s, f k |
instFintypeSymbol._proof_7 | Mathlib.Computability.Language | ∀ (T : Type u_1) (N : Type u_2),
Function.LeftInverse
(fun x =>
match x with
| Symbol.terminal a => Sum.inl a
| Symbol.nonterminal a => Sum.inr a)
fun x =>
match x with
| Sum.inl a => Symbol.terminal a
| Sum.inr a => Symbol.nonterminal a |
Lean.instHashableLocalDeclKind.hash | Lean.LocalContext | Lean.LocalDeclKind → UInt64 |
Lean.Meta.AC.PreExpr.noConfusionType | Lean.Meta.Tactic.AC.Main | Sort u → Lean.Meta.AC.PreExpr → Lean.Meta.AC.PreExpr → Sort u |
Std.HashMap.Raw.mem_map._simp_1 | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → γ} {k : α}, m.WF → (k ∈ Std.HashMap.Raw.map f m) = (k ∈ m) |
Lean.PrintImportsResult.mk.inj | Lean.Elab.ParseImportsFast | ∀ {imports imports_1 : Array Lean.PrintImportResult},
{ imports := imports } = { imports := imports_1 } → imports = imports_1 |
TensorProduct.AlgebraTensorModule.lift._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], IsScalarTower R R (TensorProduct R M N) |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.sign_ediv._proof_1_8 | Init.Data.Int.DivMod.Lemmas | ∀ (b a : ℕ), a < b → ¬a + 1 < b + 1 → False |
_private.Mathlib.Topology.Instances.ENat.0.ENat.tendsto_nhds_top_iff_natCast_lt._simp_1_2 | Mathlib.Topology.Instances.ENat | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : α → β} {x : Filter α} {y : ι → Filter β},
Filter.Tendsto f x (⨅ i, y i) = ∀ (i : ι), Filter.Tendsto f x (y i) |
_private.Mathlib.Tactic.IntervalCases.0.Mathlib.Tactic.IntervalCases.Methods.getBound.match_8 | Mathlib.Tactic.IntervalCases | (motive : Lean.Expr × Mathlib.Tactic.IntervalCases.Bound × Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Mathlib.Tactic.IntervalCases.Bound × Lean.Expr × Lean.Expr) →
((e' : Lean.Expr) → (c : Mathlib.Tactic.IntervalCases.Bound × Lean.Expr × Lean.Expr) → motive (e', c)) →
motive __discr |
_private.Init.Grind.Ordered.Ring.0.Lean.Grind.OrderedRing.mul_le_mul_of_nonneg_right._simp_1_1 | Init.Grind.Ordered.Ring | ∀ {α : Type u} [inst : LE α] [Std.Refl fun x1 x2 => x1 ≤ x2] (a : α), (a ≤ a) = True |
_private.Mathlib.GroupTheory.QuotientGroup.Defs.0.Con.subgroup_quotientGroupCon._simp_1_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {x y : α}, (QuotientGroup.leftRel s) x y = (x⁻¹ * y ∈ s) |
CategoryTheory.Limits.cokernel.desc_zero | 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) [inst_2 : CategoryTheory.Limits.HasCokernel f] {W : C} {h : CategoryTheory.CategoryStruct.comp f 0 = 0},
CategoryTheory.Limits.cokernel.desc f 0 h = 0 |
Lean.Expr.NumObjs.State | Lean.Util.NumObjs | Type |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun.0.AbsolutelyContinuousOnInterval.const_of_ae_hasDerivAt_zero._simp_1_11 | Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
Lean.Compiler.LCNF.JoinPointContextExtender.ExtendContext.candidates._default | Lean.Compiler.LCNF.JoinPoints | Lean.FVarIdSet |
CategoryTheory.MorphismProperty.ContainsIdentities.id_mem | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {W : CategoryTheory.MorphismProperty C}
[self : W.ContainsIdentities] (X : C), W (CategoryTheory.CategoryStruct.id X) |
Lean.Server.DocumentMeta.mk | Lean.Server.Utils | Lean.Lsp.DocumentUri → Lean.Name → ℕ → Lean.FileMap → Lean.Lsp.DependencyBuildMode → Lean.Server.DocumentMeta |
CategoryTheory.Functor.CoreMonoidal.mk'_μIso | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D}
(εIso :
CategoryTheory.MonoidalCategoryStruct.tensorUnit D ≅ F.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
(μIso :
(X Y : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj X) (F.obj Y) ≅
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
(μIso_inv_natural_left :
autoParam
(∀ {X Y : C} (f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp (μIso X X').inv
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (F.map f) (F.obj X')) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.whiskerRight f X'))
(μIso Y X').inv)
CategoryTheory.Functor.CoreMonoidal.mk'._auto_1)
(μIso_inv_natural_right :
autoParam
(∀ {X Y : C} (X' : C) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (μIso X' X).inv
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X') (F.map f)) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X' f))
(μIso X' Y).inv)
CategoryTheory.Functor.CoreMonoidal.mk'._auto_3)
(oplax_associativity :
autoParam
(∀ (X Y Z : C),
CategoryTheory.CategoryStruct.comp (μIso (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (μIso X Y).inv (F.obj Z))
(CategoryTheory.MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom)
(CategoryTheory.CategoryStruct.comp (μIso X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)).inv
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (μIso Y Z).inv)))
CategoryTheory.Functor.CoreMonoidal.mk'._auto_5)
(oplax_left_unitality :
autoParam
(∀ (X : C),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (F.obj X)).inv =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).inv)
(CategoryTheory.CategoryStruct.comp (μIso (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) X).inv
(CategoryTheory.MonoidalCategoryStruct.whiskerRight εIso.inv (F.obj X))))
CategoryTheory.Functor.CoreMonoidal.mk'._auto_7)
(oplax_right_unitality :
autoParam
(∀ (X : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X)).inv =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv)
(CategoryTheory.CategoryStruct.comp (μIso X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) εIso.inv)))
CategoryTheory.Functor.CoreMonoidal.mk'._auto_9)
(X Y : C),
(CategoryTheory.Functor.CoreMonoidal.mk' εIso μIso μIso_inv_natural_left μIso_inv_natural_right oplax_associativity
oplax_left_unitality oplax_right_unitality).μIso
X Y =
μIso X Y |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.StartsWithResult.casesOn | Lean.Meta.Tactic.Grind.AC.Seq | {motive : Lean.Grind.AC.StartsWithResult✝ → Sort u} →
(t : Lean.Grind.AC.StartsWithResult✝¹) →
motive Lean.Grind.AC.StartsWithResult.false✝ →
motive Lean.Grind.AC.StartsWithResult.exact✝ →
((s : Lean.Grind.AC.Seq) → motive (Lean.Grind.AC.StartsWithResult.prefix✝ s)) → motive t |
MeasureTheory.Measure.MutuallySingular.haveLebesgueDecomposition | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
μ.MutuallySingular ν → μ.HaveLebesgueDecomposition ν |
RingCat.forget_obj | Mathlib.Algebra.Category.Ring.Basic | ∀ {R : RingCat}, (CategoryTheory.forget RingCat).obj R = ↑R |
LinearMap.BilinForm.tensorDistrib.eq_1 | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct | ∀ (R : Type uR) (A : Type uA) {M₁ : Type uM₁} {M₂ : Type uM₂} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Algebra R A] [inst_5 : Module R M₁]
[inst_6 : Module A M₁] [inst_7 : SMulCommClass R A M₁] [inst_8 : IsScalarTower R A M₁] [inst_9 : Module R M₂],
LinearMap.BilinForm.tensorDistrib R A =
↑(TensorProduct.AlgebraTensorModule.rid R A A).congrRight₂ ∘ₗ LinearMap.BilinMap.tensorDistrib R A |
Set.VAddAntidiagonal.finite_of_isPWO | Mathlib.Data.Set.SMulAntidiagonal | ∀ {G : Type u_1} {P : Type u_2} {s : Set G} {t : Set P} [inst : PartialOrder G] [inst_1 : PartialOrder P]
[inst_2 : VAdd G P] [IsOrderedCancelVAdd G P], s.IsPWO → t.IsPWO → ∀ (a : P), (s.vaddAntidiagonal t a).Finite |
PSet.rank_le_iff | Mathlib.SetTheory.ZFC.Rank | ∀ {o : Ordinal.{u_1}} {x : PSet.{u_1}}, x.rank ≤ o ↔ ∀ ⦃y : PSet.{u_1}⦄, y ∈ x → y.rank < o |
_private.Mathlib.Analysis.Hofer.0.termD | Mathlib.Analysis.Hofer | Lean.ParserDescr |
RatCast.rec | Batteries.Classes.RatCast | {K : Type u} →
{motive : RatCast K → Sort u_1} → ((ratCast : ℚ → K) → motive { ratCast := ratCast }) → (t : RatCast K) → motive t |
UpperHalfPlane.instBorelSpace | Mathlib.Analysis.Complex.UpperHalfPlane.Measure | BorelSpace UpperHalfPlane |
FiniteArchimedeanClass.congrOrderIso.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : LinearOrder N] [inst_5 : IsOrderedAddMonoid N]
(e : ArchimedeanClass M ≃o ArchimedeanClass N),
FiniteArchimedeanClass.congrOrderIso e = { toEquiv := (↑e).subtypeEquiv ⋯, map_rel_iff' := ⋯ } |
Lean.Lsp.instReprCompletionItemKind | Lean.Data.Lsp.LanguageFeatures | Repr Lean.Lsp.CompletionItemKind |
Std.Internal.List.DistinctKeys.filterMap | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : BEq α] [PartialEquivBEq α] {l : List ((a : α) × β a)}
{f : (a : α) → β a → Option (γ a)},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.DistinctKeys (List.filterMap (fun p => Option.map (fun x => ⟨p.fst, x⟩) (f p.fst p.snd)) l) |
DividedPowers.SubDPIdeal.mk | Mathlib.RingTheory.DividedPowers.SubDPIdeal | {A : Type u_1} →
[inst : CommSemiring A] →
{I : Ideal A} →
{hI : DividedPowers I} →
(carrier : Ideal A) → carrier ≤ I → (∀ (n : ℕ), n ≠ 0 → ∀ j ∈ carrier, hI.dpow n j ∈ carrier) → hI.SubDPIdeal |
Lean.Syntax.getTailInfo | Init.Meta.Defs | Lean.Syntax → Lean.SourceInfo |
exists_nsmul_eq_self_of_coprime | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] {x : G} {n : ℕ}, n.Coprime (addOrderOf x) → ∃ m, m • n • x = x |
CategoryTheory.evaluationLeftAdjoint.congr_simp | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c c_1 : C),
c = c_1 → CategoryTheory.evaluationLeftAdjoint D c = CategoryTheory.evaluationLeftAdjoint D c_1 |
spectrum.spectralRadius_one | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : Ring A] [inst_2 : Algebra 𝕜 A] [Nontrivial A],
spectralRadius 𝕜 1 = 1 |
CategoryTheory.CatCommSq.mk | Mathlib.CategoryTheory.CatCommSq | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄] →
{T : CategoryTheory.Functor C₁ C₂} →
{L : CategoryTheory.Functor C₁ C₃} →
{R : CategoryTheory.Functor C₂ C₄} →
{B : CategoryTheory.Functor C₃ C₄} → (T.comp R ≅ L.comp B) → CategoryTheory.CatCommSq T L R B |
aliasIn | Mathlib.Util.AliasIn | Lean.ParserDescr |
_private.Mathlib.Algebra.BigOperators.Expect.0.BigOperators.delabFinsetExpect.match_3 | Mathlib.Algebra.BigOperators.Expect | (motive : Array Lean.Expr → Sort u_1) →
(x : Array Lean.Expr) →
((head head_1 head_2 head_3 s f : Lean.Expr) → motive #[head, head_1, head_2, head_3, s, f]) →
((x : Array Lean.Expr) → motive x) → motive x |
Lean.Server.RequestHandlerCompleteness.partial.sizeOf_spec | Lean.Server.Requests | ∀ (refreshMethod : String) (refreshIntervalMs : ℕ),
sizeOf (Lean.Server.RequestHandlerCompleteness.partial refreshMethod refreshIntervalMs) =
1 + sizeOf refreshMethod + sizeOf refreshIntervalMs |
Matrix.isNilpotent_toLin'_iff._simp_1 | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ {R : Type u_1} {ι : Type u_3} [inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : CommSemiring R]
(A : Matrix ι ι R), IsNilpotent (Matrix.toLin' A) = IsNilpotent A |
Real.norm_deriv_mulExpNegMulSq_le_one | Mathlib.Analysis.SpecialFunctions.MulExpNegMulSq | ∀ {ε : ℝ}, 0 < ε → ∀ (x : ℝ), ‖deriv ε.mulExpNegMulSq x‖ ≤ 1 |
PiTensorProduct.injectiveSeminorm_def | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {ι : Type u_1} [inst : Fintype ι] {𝕜 : Type u_2} [inst_1 : NontriviallyNormedField 𝕜] {E : ι → Type u_3}
[inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)],
PiTensorProduct.injectiveSeminorm =
sSup
{p |
∃ G x x_1,
p =
(normSeminorm 𝕜 (ContinuousMultilinearMap 𝕜 E G →L[𝕜] G)).comp
(PiTensorProduct.toDualContinuousMultilinearMap G)} |
Equiv.Perm.swapFactors._proof_3 | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : LinearOrder α] (f : Equiv.Perm α) {x : α} {x_1 : f x ≠ x},
x ∈ Finset.univ.sort fun a b => a ≤ b |
ProperVAdd.toContinuousVAdd | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {G : Type u_1} {X : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G X] [inst_2 : TopologicalSpace G]
[inst_3 : TopologicalSpace X] [ProperVAdd G X], ContinuousVAdd G X |
Lean.Meta.Match.Pattern.var.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} →
{fvarId fvarId' : Lean.FVarId} →
Lean.Meta.Match.Pattern.var fvarId = Lean.Meta.Match.Pattern.var fvarId' → (fvarId = fvarId' → P) → P |
_private.Mathlib.Data.Finset.Range.0.Finset.mem_range_le._proof_1_1 | Mathlib.Data.Finset.Range | ∀ {n x : ℕ}, x ∈ Finset.range n → x ≤ n |
CategoryTheory.ShortComplex.RightHomologyData.canonical_p | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology],
(CategoryTheory.ShortComplex.RightHomologyData.canonical S).p = S.pOpcycles |
Polynomial.derivWithin_aeval | Mathlib.Analysis.Calculus.Deriv.Polynomial | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {R : Type u_1} [inst_1 : CommSemiring R]
[inst_2 : Algebra R 𝕜] (q : Polynomial R),
UniqueDiffWithinAt 𝕜 s x →
derivWithin (fun x => (Polynomial.aeval x) q) s x = (Polynomial.aeval x) (Polynomial.derivative q) |
AlgebraicGeometry.quasiCompact_iff | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
AlgebraicGeometry.QuasiCompact f ↔ ∀ (U : Set ↥Y), IsOpen U → IsCompact U → IsCompact (⇑f ⁻¹' U) |
Int8.le | Init.Data.SInt.Basic | Int8 → Int8 → Prop |
ProbabilityTheory.stronglyMeasurable_stieltjesOfMeasurableRat | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : Measurable f) (x : ℝ),
MeasureTheory.StronglyMeasurable fun a => ↑(ProbabilityTheory.stieltjesOfMeasurableRat f hf a) x |
Char.ofOrdinal | Init.Data.Char.Ordinal | Fin Char.numCodePoints → Char |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence_inverse_obj_obj | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat))
(ι : Type u_1) [inst_1 : Unique ι] {X S : C} (f : X ⟶ S)
(A : (CategoryTheory.Adjunction.ofCat (F.map f.op.toLoc).adj).toComonad.Coalgebra) (x : ι),
((CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence F ι f).inverse.obj A).obj x = A.A |
Lean.Elab.CommandContextInfo.mk.inj | Lean.Elab.InfoTree.Types | ∀ {env : Lean.Environment} {cmdEnv? : Option Lean.Environment} {fileMap : Lean.FileMap} {mctx : Lean.MetavarContext}
{options : Lean.Options} {currNamespace : Lean.Name} {openDecls : List Lean.OpenDecl} {ngen : Lean.NameGenerator}
{env_1 : Lean.Environment} {cmdEnv?_1 : Option Lean.Environment} {fileMap_1 : Lean.FileMap}
{mctx_1 : Lean.MetavarContext} {options_1 : Lean.Options} {currNamespace_1 : Lean.Name}
{openDecls_1 : List Lean.OpenDecl} {ngen_1 : Lean.NameGenerator},
{ env := env, cmdEnv? := cmdEnv?, fileMap := fileMap, mctx := mctx, options := options,
currNamespace := currNamespace, openDecls := openDecls, ngen := ngen } =
{ env := env_1, cmdEnv? := cmdEnv?_1, fileMap := fileMap_1, mctx := mctx_1, options := options_1,
currNamespace := currNamespace_1, openDecls := openDecls_1, ngen := ngen_1 } →
env = env_1 ∧
cmdEnv? = cmdEnv?_1 ∧
fileMap = fileMap_1 ∧
mctx = mctx_1 ∧
options = options_1 ∧ currNamespace = currNamespace_1 ∧ openDecls = openDecls_1 ∧ ngen = ngen_1 |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_exact | 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.kernelSequenceOpcyclesE_exact._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_exact._auto_3),
(X.kernelSequenceOpcyclesE f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).Exact |
Path.Homotopy.reflTransSymm._proof_5 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} (p : Path x₀ x₁) (x : ↑unitInterval),
p ⟨Path.Homotopy.reflTransSymmAux (1, x), ⋯⟩ = (p.trans p.symm).toContinuousMap x |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.packingNumber_pos_iff._simp_1_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) |
Turing.ToPartrec.Code.prec | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code → Turing.ToPartrec.Code → Turing.ToPartrec.Code |
Aesop.elabSimpTheorems | Aesop.RuleTac.ElabRuleTerm | Lean.Syntax →
Lean.Meta.Simp.Context →
Lean.Meta.Simp.SimprocsArray →
Bool → Lean.Elab.Tactic.TacticM (Lean.Meta.Simp.Context × Lean.Meta.Simp.SimprocsArray) |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.List.range'_eq_toList_rco._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {α : Type u_1} {l₁ l₂ : List α},
(l₁ = l₂) = (l₁.length = l₂.length ∧ ∀ (i : ℕ) (h₁ : i < l₁.length) (h₂ : i < l₂.length), l₁[i] = l₂[i]) |
Finset.subset_insert._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), (s ⊆ insert a s) = True |
_private.Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset.0.Finset.zero_smul_subset._simp_1_2 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] {s : Finset α} {t : Finset β} {x : β},
(x ∈ s • t) = ∃ y ∈ s, ∃ z ∈ t, y • z = x |
Std.ExtDHashMap.union | Std.Data.ExtDHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{x : BEq α} →
{x_1 : Hashable α} →
[EquivBEq α] → [LawfulHashable α] → Std.ExtDHashMap α β → Std.ExtDHashMap α β → Std.ExtDHashMap α β |
Lean.Meta.LazyDiscrTree.ImportData.mk._flat_ctor | Lean.Meta.LazyDiscrTree | IO.Ref (Array Lean.Meta.LazyDiscrTree.ImportFailure) → Lean.Meta.LazyDiscrTree.ImportData |
_private.Mathlib.Algebra.Ring.Int.Parity.0.Int.odd_mul._simp_1_1 | Mathlib.Algebra.Ring.Int.Parity | ∀ {n : ℤ}, Odd n = ¬Even n |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Projection.0.isIdempotentElem_iff_spectrum_subset._proof_1_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Projection | ∀ (R : Type u_1) {A : Type u_2} [inst : Field R] [inst_6 : Ring A] [inst_8 : Algebra R A], IsScalarTower R A A |
TypeVec.«term_:::_» | Mathlib.Data.TypeVec | Lean.TrailingParserDescr |
List.mapWithPrefixSuffixAux._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → (List α → α → List α → β) → List α → List α → List β |
Std.Tactic.BVDecide.LRAT.Internal.Result._sizeOf_1 | Std.Tactic.BVDecide.LRAT.Internal.LRATChecker | Std.Tactic.BVDecide.LRAT.Internal.Result → ℕ |
List.take_sum_flatten | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {α : Type u_2} (L : List (List α)) (i : ℕ),
List.take (List.take i (List.map List.length L)).sum L.flatten = (List.take i L).flatten |
Lean.Meta.Grind.proveHEq? | Lean.Meta.Tactic.Grind.ProveEq | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) |
Nat.div.go.congr_simp | Init.Data.Nat.Div.Basic | ∀ (y y_1 : ℕ) (e_y : y = y_1) (hy : 0 < y) (fuel fuel_1 : ℕ) (e_fuel : fuel = fuel_1) (x x_1 : ℕ) (e_x : x = x_1)
(hfuel : x < fuel), Nat.div.go y hy fuel x hfuel = Nat.div.go y_1 ⋯ fuel_1 x_1 ⋯ |
AddActionHom.prod | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
{N : Type u_2} →
{α : Type u_3} →
{γ : Type u_5} →
{δ : Type u_6} →
[inst : VAdd M α] →
[inst_1 : VAdd N γ] → [inst_2 : VAdd N δ] → {σ : M → N} → (α →ₑ[σ] γ) → (α →ₑ[σ] δ) → α →ₑ[σ] γ × δ |
Std.DHashMap.getKey_diff | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {h_mem : k ∈ m₁ \ m₂}, (m₁ \ m₂).getKey k h_mem = m₁.getKey k ⋯ |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobiMatrix._proof_1_4 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (m k : ℕ) (i : Fin m) (i_1 : Fin k), m + ↑i_1 - ↑i + 1 ≤ k → m + ↑i_1 - ↑i < k |
TensorProduct.prodLeft._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Prod | ∀ (R : Type u_1) (S : Type u_5) (M₁ : Type u_2) (M₂ : Type u_3) (M₃ : Type u_4) [inst : CommSemiring R]
[inst_1 : Semiring S] [inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : AddCommMonoid M₃]
[inst_5 : Algebra R S] [inst_6 : Module R M₁] [inst_7 : Module S M₁] [inst_8 : IsScalarTower R S M₁]
[inst_9 : Module R M₂] [inst_10 : Module R M₃] [inst_11 : Module S M₂] [inst_12 : IsScalarTower R S M₂] (c : S)
(x y : TensorProduct R (M₁ × M₂) M₃),
(TensorProduct.comm R (M₁ × M₂) M₃ ≪≫ₗ TensorProduct.prodRight R R M₃ M₁ M₂ ≪≫ₗ
(TensorProduct.comm R M₃ M₁).prodCongr (TensorProduct.comm R M₃ M₂)).toAddEquiv
(c • x) =
c •
(TensorProduct.comm R (M₁ × M₂) M₃ ≪≫ₗ TensorProduct.prodRight R R M₃ M₁ M₂ ≪≫ₗ
(TensorProduct.comm R M₃ M₁).prodCongr (TensorProduct.comm R M₃ M₂)).toAddEquiv
x →
(TensorProduct.comm R (M₁ × M₂) M₃ ≪≫ₗ TensorProduct.prodRight R R M₃ M₁ M₂ ≪≫ₗ
(TensorProduct.comm R M₃ M₁).prodCongr (TensorProduct.comm R M₃ M₂)).toAddEquiv
(c • y) =
c •
(TensorProduct.comm R (M₁ × M₂) M₃ ≪≫ₗ TensorProduct.prodRight R R M₃ M₁ M₂ ≪≫ₗ
(TensorProduct.comm R M₃ M₁).prodCongr (TensorProduct.comm R M₃ M₂)).toAddEquiv
y →
(TensorProduct.comm R (M₁ × M₂) M₃ ≪≫ₗ TensorProduct.prodRight R R M₃ M₁ M₂ ≪≫ₗ
(TensorProduct.comm R M₃ M₁).prodCongr (TensorProduct.comm R M₃ M₂)).toAddEquiv
(c • (x + y)) =
c •
(TensorProduct.comm R (M₁ × M₂) M₃ ≪≫ₗ TensorProduct.prodRight R R M₃ M₁ M₂ ≪≫ₗ
(TensorProduct.comm R M₃ M₁).prodCongr (TensorProduct.comm R M₃ M₂)).toAddEquiv
(x + y) |
Vector.isSome_find? | Init.Data.Vector.Find | ∀ {α : Type} {n : ℕ} {xs : Vector α n} {f : α → Bool}, (Vector.find? f xs).isSome = xs.any fun x => f x |
Ideal.exists_disjoint_powers_of_span_eq_top | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u} [inst : CommSemiring α] (s : Set α),
Ideal.span s = ⊤ → ∀ (I : Ideal α), I ≠ ⊤ → ∃ r ∈ s, Disjoint ↑I ↑(Submonoid.powers r) |
Set.Ico_add_Icc_subset | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] [AddLeftStrictMono α] [AddRightStrictMono α] (a b c d : α),
Set.Ico a b + Set.Icc c d ⊆ Set.Ico (a + c) (b + d) |
_private.Mathlib.Topology.Compactness.Compact.0.IsClosed.exists_minimal_nonempty_closed_subset._simp_1_5 | Mathlib.Topology.Compactness.Compact | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.