name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.ThinSkeleton.map₂Functor._proof_2 | Mathlib.CategoryTheory.Skeletal | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_4, u_3} E]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (x : CategoryTheory.ThinSkeleton C)
{X Y Z : CategoryTheory.ThinSkeleton D} (f : X ⟶ Y) (g : Y ⟶ Z),
Quotient.recOnSubsingleton (motive := fun x =>
(X ⟶ Z) → (CategoryTheory.ThinSkeleton.map₂ObjMap F x X ⟶ CategoryTheory.ThinSkeleton.map₂ObjMap F x Z)) x
(fun X_1 => Quotient.recOnSubsingleton₂ X Z fun x x_1 hY => CategoryTheory.homOfLE ⋯)
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
(Quotient.recOnSubsingleton (motive := fun x =>
(X ⟶ Y) → (CategoryTheory.ThinSkeleton.map₂ObjMap F x X ⟶ CategoryTheory.ThinSkeleton.map₂ObjMap F x Y)) x
(fun X_1 => Quotient.recOnSubsingleton₂ X Y fun x x_1 hY => CategoryTheory.homOfLE ⋯) f)
(Quotient.recOnSubsingleton (motive := fun x =>
(Y ⟶ Z) → (CategoryTheory.ThinSkeleton.map₂ObjMap F x Y ⟶ CategoryTheory.ThinSkeleton.map₂ObjMap F x Z)) x
(fun X => Quotient.recOnSubsingleton₂ Y Z fun x x_1 hY => CategoryTheory.homOfLE ⋯) g) |
Vector.append_empty | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n}, xs ++ #v[] = xs |
TopCat.binaryCofan._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat), Continuous Sum.inr |
Mathlib.Tactic.Bicategory.instMonadMor₂BicategoryM | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Mathlib.Tactic.BicategoryLike.MonadMor₂ Mathlib.Tactic.Bicategory.BicategoryM |
mdifferentiableOn_iUnion_iff_of_isOpen | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {ι : Type u_11}
{s : ι → Set M}, (∀ (i : ι), IsOpen (s i)) → (MDiff[⋃ i, s i] f ↔ ∀ (i : ι), MDiff[s i] f) |
Asymptotics.isEquivalent_iff_tendsto_one | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedField β] {u v : α → β} {l : Filter α},
(∀ᶠ (x : α) in l, v x ≠ 0) → (Asymptotics.IsEquivalent l u v ↔ Filter.Tendsto (u / v) l (nhds 1)) |
USize.ofNatTruncate_eq_ofNat | Init.Data.UInt.Lemmas | ∀ n < USize.size, USize.ofNatTruncate n = USize.ofNat n |
_private.Mathlib.Data.Set.Pointwise.Support.0.support_comp_inv_smul._simp_1_2 | Mathlib.Data.Set.Pointwise.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, (x ∈ Function.support f) = (f x ≠ 0) |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Equiv.Perm.isoCycle._simp_6 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ ↑l) = (a ∈ l) |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Markov.0.MeasureTheory.ae_lt_top'._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {p : α → Prop}, (∀ᵐ (a : α) ∂μ, p a) = (μ {a | ¬p a} = 0) |
UniqueAdd.of_image_filter | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] [inst_2 : DecidableEq H] (f : G →ₙ+ H) {A B : Finset G}
{aG bG : G} {aH bH : H},
f aG = aH →
f bG = bH →
UniqueAdd (Finset.image (⇑f) A) (Finset.image (⇑f) B) aH bH →
UniqueAdd ({a ∈ A | f a = aH}) ({b ∈ B | f b = bH}) aG bG → UniqueAdd A B aG bG |
OpenPartialHomeomorph.trans' | Mathlib.Topology.OpenPartialHomeomorph.Composition | {X : Type u_1} →
{Y : Type u_3} →
{Z : Type u_5} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
(e : OpenPartialHomeomorph X Y) →
(e' : OpenPartialHomeomorph Y Z) → e.target = e'.source → OpenPartialHomeomorph X Z |
IsGroupLikeElem.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.GroupLike | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] {a : A},
CoalgebraStruct.counit a = 1 → CoalgebraStruct.comul a = a ⊗ₜ[R] a → IsGroupLikeElem R a |
_private.Mathlib.Topology.Algebra.Order.Field.0.tendsto_const_mul_pow_nhds_iff'._simp_1_1 | Mathlib.Topology.Algebra.Order.Field | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [T1Space X] {l : Filter Y} [l.NeBot] {c d : X},
Filter.Tendsto (fun x => c) l (nhds d) = (c = d) |
OrderAddMonoidHom.coe_zero | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : AddZeroClass α]
[inst_3 : AddZeroClass β], ⇑0 = 0 |
RingHom.fromOpposite._proof_3 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
(↑(f.toAddMonoidHom.comp MulOpposite.opAddEquiv.symm.toAddMonoidHom)).toFun 0 = 0 |
BoxIntegral.Box.mk' | Mathlib.Analysis.BoxIntegral.Box.Basic | {ι : Type u_1} → (ι → ℝ) → (ι → ℝ) → WithBot (BoxIntegral.Box ι) |
Nat.divMaxPow_one_left | Mathlib.Data.Nat.MaxPowDiv | ∀ (p : ℕ), Nat.divMaxPow 1 p = 1 |
AddAction.instElemOrbit_1 | Mathlib.GroupTheory.GroupAction.Defs | {G : Type u_1} →
{α : Type u_2} →
[inst : AddGroup G] → [inst_1 : AddAction G α] → (x : AddAction.orbitRel.Quotient G α) → AddAction G ↑x.orbit |
Qq.Impl.ExprBackSubstResult.quoted.injEq | Qq.Macro | ∀ (e e_1 : Lean.Expr), (Qq.Impl.ExprBackSubstResult.quoted e = Qq.Impl.ExprBackSubstResult.quoted e_1) = (e = e_1) |
CategoryTheory.Limits.MulticospanIndex.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : SizeOf C] (left : J.L → C) (right : J.R → C) (fst : (b : J.R) → left (J.fst b) ⟶ right b)
(snd : (b : J.R) → left (J.snd b) ⟶ right b), sizeOf { left := left, right := right, fst := fst, snd := snd } = 1 |
SnakeLemma.δ._proof_2 | Mathlib.Algebra.Module.SnakeLemma | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) |
AddSubgroup.neg_mem' | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_3} [inst : AddGroup G] (self : AddSubgroup G) {x : G}, x ∈ self.carrier → -x ∈ self.carrier |
Submonoid.noConfusion | Mathlib.Algebra.Group.Submonoid.Defs | {P : Sort u} →
{M : Type u_3} →
{inst : MulOneClass M} →
{t : Submonoid M} →
{M' : Type u_3} →
{inst' : MulOneClass M'} →
{t' : Submonoid M'} → M = M' → inst ≍ inst' → t ≍ t' → Submonoid.noConfusionType P t t' |
CategoryTheory.map_coyonedaEquiv | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {F : CategoryTheory.Functor C (Type v₁)}
(f : CategoryTheory.coyoneda.obj (Opposite.op X) ⟶ F) (g : X ⟶ Y),
F.map g (CategoryTheory.coyonedaEquiv f) = f.app Y g |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_17 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.simplifyResultingUniverse.simp.match_3 | Lean.Elab.MutualInductive | (motive : Lean.Level → Sort u_1) →
(u : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((a : Lean.LMVarId) → motive (Lean.Level.mvar a)) →
((a : Lean.Name) → motive (Lean.Level.param a)) →
((a : Lean.Level) → motive a.succ) →
((a b : Lean.Level) → motive (a.max b)) → ((a b : Lean.Level) → motive (a.imax b)) → motive u |
DirichletCharacter.FactorsThrough.χ₀._proof_2 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} (h : χ.FactorsThrough d),
∃ χ₀, χ = (DirichletCharacter.changeLevel ⋯) χ₀ |
WithBot.pred_coe | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] [inst_2 : (a : α) → Decidable (Order.pred a = a)]
[NoMinOrder α] {a : α}, Order.pred ↑a = ↑(Order.pred a) |
ProperCone.relative_hyperplane_separation | Mathlib.Analysis.Convex.Cone.InnerDual | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
[inst_2 : CompleteSpace E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℝ F] [inst_5 : CompleteSpace F]
{C : ProperCone ℝ E} {f : E →L[ℝ] F} {b : F},
b ∈ ProperCone.map f C ↔ ∀ (y : F), (ContinuousLinearMap.adjoint f) y ∈ ProperCone.innerDual ↑C → 0 ≤ inner ℝ b y |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_image_const_sub_eq_Ico._simp_1_2 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) |
Nat.card_ulift | Mathlib.SetTheory.Cardinal.Finite | ∀ (α : Type u_3), Nat.card (ULift.{u_4, u_3} α) = Nat.card α |
iteratedFDerivWithin._proof_1 | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], IsTopologicalAddGroup F |
Lean.TheoremVal.all._default | Lean.Declaration | Lean.Name → List Lean.Name |
Aesop.Match.forwardDeps | Aesop.Forward.Match.Types | Aesop.Match → Array Aesop.PremiseIndex |
Module.subsingletonEquiv.congr_simp | Mathlib.LinearAlgebra.Basis.Defs | ∀ (R : Type u_4) (M : Type u_5) (ι : Type u_6) [inst : Semiring R] [inst_1 : Subsingleton R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M], Module.subsingletonEquiv R M ι = Module.subsingletonEquiv R M ι |
CategoryTheory.Comon.MonOpOpToComon._proof_2 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : (CategoryTheory.Mon Cᵒᵖ)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f.unop.hom.unop CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp CategoryTheory.ComonObj.comul
(CategoryTheory.MonoidalCategoryStruct.tensorHom f.unop.hom.unop f.unop.hom.unop) |
_private.Lean.Elab.Tactic.Config.0.Lean.Elab.Tactic.elabConfig.match_3 | Lean.Elab.Tactic.Config | (motive : Option Lean.Term → Sort u_1) →
(source? : Option Lean.Term) →
((source : Lean.Term) → motive (some source)) → ((x : Option Lean.Term) → motive x) → motive source? |
_private.Mathlib.Topology.Instances.Matrix.0.Matrix.GeneralLinearGroup.continuous_det._simp_1_2 | Mathlib.Topology.Instances.Matrix | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Group G] [inst_2 : DivisionMonoid H]
[MonoidHomClass F G H] (f : F) (a : G), (f a)⁻¹ = f a⁻¹ |
CategoryTheory.WithTerminal.lift._proof_4 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z),
(∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) →
∀ {X Y Z_1 : CategoryTheory.WithTerminal C} (f : X ⟶ Y) (g : Y ⟶ Z_1),
(match X, Z_1, CategoryTheory.CategoryStruct.comp f g with
| CategoryTheory.WithTerminal.of a, CategoryTheory.WithTerminal.of a_1, f =>
F.map (CategoryTheory.WithTerminal.down f)
| CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.star, x_1 => M x
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => CategoryTheory.CategoryStruct.id Z) =
CategoryTheory.CategoryStruct.comp
(match X, Y, f with
| CategoryTheory.WithTerminal.of a, CategoryTheory.WithTerminal.of a_1, f =>
F.map (CategoryTheory.WithTerminal.down f)
| CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.star, x_1 => M x
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => CategoryTheory.CategoryStruct.id Z)
(match Y, Z_1, g with
| CategoryTheory.WithTerminal.of a, CategoryTheory.WithTerminal.of a_1, f =>
F.map (CategoryTheory.WithTerminal.down f)
| CategoryTheory.WithTerminal.of x, CategoryTheory.WithTerminal.star, x_1 => M x
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => CategoryTheory.CategoryStruct.id Z) |
CochainComplex.HomComplex.Cochain.diff | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → (K : CochainComplex C ℤ) → CochainComplex.HomComplex.Cochain K K 1 |
LinearMap.toContinuousLinearMap._proof_7 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type u_3}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : IsTopologicalAddGroup F']
[inst_9 : ContinuousSMul 𝕜 F'] [inst_10 : CompleteSpace 𝕜] [inst_11 : T2Space E] [inst_12 : FiniteDimensional 𝕜 E]
(x x_1 : E →ₗ[𝕜] F'), { toLinearMap := x + x_1, cont := ⋯ } = { toLinearMap := x + x_1, cont := ⋯ } |
_private.Mathlib.LinearAlgebra.FiniteDimensional.Basic.0.LinearMap.ker_noncommProd_eq_of_supIndep_ker._simp_1_2 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) |
Lean.Meta.Simp.Methods.toMethodsRef | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Methods → Lean.Meta.Simp.MethodsRef |
Polynomial.degree_mul_C_of_isUnit | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} {a : R} [inst : Semiring R], IsUnit a → ∀ (p : Polynomial R), (p * Polynomial.C a).degree = p.degree |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_separation_compact_nhds._simp_1_5 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) |
_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkLeLtPrefix | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Name → Lean.Meta.Grind.Order.OrderM Lean.Expr |
GenContFract.terminatedAt_iff_s_none | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {α : Type u_1} {g : GenContFract α} {n : ℕ}, g.TerminatedAt n ↔ g.s.get? n = none |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1.recOn | Lean.Server.FileWorker.WidgetRequests | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
(t : Lean.Widget.RpcEncodablePacket✝) →
((type exprExplicit doc : Lean.Json) → motive { type := type, exprExplicit := exprExplicit, doc := doc }) → motive t |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Decl.isExtern._sparseCasesOn_1 | Lean.Compiler.IR.Basic | {motive : Lean.IR.Decl → Sort u} →
(t : Lean.IR.Decl) →
((f : Lean.IR.FunId) →
(xs : Array Lean.IR.Param) →
(type : Lean.IR.IRType) → (ext : Lean.ExternAttrData) → motive (Lean.IR.Decl.extern f xs type ext)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Group.rank | Mathlib.GroupTheory.Rank | (G : Type u_1) → [inst : Group G] → [h : Group.FG G] → ℕ |
Finset.mem_neg_vadd_finset_iff | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : AddGroup α] [inst_2 : AddAction α β] {s : Finset β}
{a : α} {b : β}, b ∈ -a +ᵥ s ↔ a +ᵥ b ∈ s |
List.modifyHead_eq_nil_iff._simp_1 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {l : List α}, (List.modifyHead f l = []) = (l = []) |
_private.Mathlib.LinearAlgebra.Transvection.0.LinearMap.transvection.eq_id_of_finrank_le_one._proof_1_3 | Mathlib.LinearAlgebra.Transvection | ∀ {R : Type u_1} {V : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid V] [inst_2 : Module R V]
[inst_3 : Module.Free R V] [inst_4 : Module.Finite R V] [inst_5 : StrongRankCondition R] (h : Module.finrank R V = 1)
(x : V), ∀ b_1 ∈ Finset.univ, ¬b_1 = ⟨0, ⋯⟩ → ((Module.finBasis R V).repr x) b_1 • (Module.finBasis R V) b_1 = 0 |
Lean.Parser.registerBuiltinParserAttribute._auto_1 | Lean.Parser.Extension | Lean.Syntax |
Complex.VerticalIntegrable._auto_1 | Mathlib.Analysis.MellinTransform | Lean.Syntax |
Int.sign_one | Init.Data.Int.Order | Int.sign 1 = 1 |
DerivingHelpers._aux_Init_LawfulBEqTactics___macroRules_DerivingHelpers_tacticDeriving_ReflEq_tactic_1 | Init.LawfulBEqTactics | Lean.Macro |
CategoryTheory.ComposableArrows.Precomp.map_zero_succ_succ._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (j : ℕ), 0 ≤ j + 1 |
Lean.Parser.LeadingIdentBehavior.noConfusionType | Lean.Parser.Basic | Sort v✝ → Lean.Parser.LeadingIdentBehavior → Lean.Parser.LeadingIdentBehavior → Sort v✝ |
Prefunctor.IsCovering.symmetrify | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V),
φ.IsCovering → φ.symmetrify.IsCovering |
IsCompactOperator.hasEigenvalue_iff_mem_spectrum | Mathlib.Analysis.Normed.Operator.FredholmAlternative | ∀ {𝕜 : Type u_1} {X : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X] {T : X →L[𝕜] X} {μ : 𝕜} [CompleteSpace X],
IsCompactOperator ⇑T → μ ≠ 0 → (Module.End.HasEigenvalue (↑T) μ ↔ μ ∈ spectrum 𝕜 T) |
PowerSeries.«term_%ʷ_» | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | Lean.TrailingParserDescr |
Dilation.ratioHom | Mathlib.Topology.MetricSpace.Dilation | {α : Type u_1} → [inst : PseudoEMetricSpace α] → (α →ᵈ α) →* NNReal |
irrational_ratCast_add_iff | Mathlib.NumberTheory.Real.Irrational | ∀ {q : ℚ} {x : ℝ}, Irrational (↑q + x) ↔ Irrational x |
MeasurableEquiv.shearAddRight | Mathlib.MeasureTheory.Group.Prod | (G : Type u_1) →
[inst : MeasurableSpace G] → [inst_1 : AddGroup G] → [MeasurableAdd₂ G] → [MeasurableNeg G] → G × G ≃ᵐ G × G |
lie_abelian_iff_equiv_lie_abelian | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), IsLieAbelian L₁ ↔ IsLieAbelian L₂ |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscrete_accPt._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S : Set X},
(S ∈ Filter.codiscrete X) = ∀ (x : X), Disjoint (nhdsWithin x {x}ᶜ) (Filter.principal Sᶜ) |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.instEffectiveEpiComp.match_1 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | (motive : Unit → Sort u_1) → (x : Unit) → (Unit → motive PUnit.unit) → motive x |
Lean.Grind.CommRing.Poly.NonnegCoeffs.below.casesOn | Init.Grind.Ring.CommSemiringAdapter | ∀ {motive : (a : Lean.Grind.CommRing.Poly) → a.NonnegCoeffs → Prop}
{motive_1 :
{a : Lean.Grind.CommRing.Poly} → (t : a.NonnegCoeffs) → Lean.Grind.CommRing.Poly.NonnegCoeffs.below t → Prop}
{a : Lean.Grind.CommRing.Poly} {t : a.NonnegCoeffs} (t_1 : Lean.Grind.CommRing.Poly.NonnegCoeffs.below t),
(∀ (c : ℤ) (a : c ≥ 0), motive_1 ⋯ ⋯) →
(∀ (a : ℤ) (m : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRing.Poly) (a_1 : a ≥ 0) (a_2 : p.NonnegCoeffs)
(ih : Lean.Grind.CommRing.Poly.NonnegCoeffs.below a_2) (a_ih : motive p a_2), motive_1 ⋯ ⋯) →
motive_1 t t_1 |
UniqueDiffWithinAt.inter' | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
UniqueDiffWithinAt 𝕜 s x → t ∈ nhdsWithin x s → UniqueDiffWithinAt 𝕜 (s ∩ t) x |
Polynomial.Monic.pow | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → ∀ (n : ℕ), (p ^ n).Monic |
WithLp.noConfusion | Mathlib.Analysis.Normed.Lp.WithLp | {P : Sort u} →
{p : ENNReal} →
{V : Type u_1} →
{t : WithLp p V} →
{p' : ENNReal} →
{V' : Type u_1} → {t' : WithLp p' V'} → p = p' → V = V' → t ≍ t' → WithLp.noConfusionType P t t' |
instPreorderShrink | Mathlib.Order.Shrink | {α : Type u_1} → [inst : Small.{u, u_1} α] → [Preorder α] → Preorder (Shrink.{u, u_1} α) |
Mathlib.Tactic.ToDual.initFn._@.Mathlib.Tactic.Translate.ToDual.394485197._hygCtx._hyg.2 | Mathlib.Tactic.Translate.ToDual | IO Unit |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.interSmallerFn.match_1 | Std.Data.DHashMap.Internal.Defs | {α : Type u_2} →
{β : α → Type u_1} →
(motive : Option ((a : α) × β a) → Sort u_3) →
(x : Option ((a : α) × β a)) → ((kv' : (a : α) × β a) → motive (some kv')) → (Unit → motive none) → motive x |
Multiset.exists_multiset_eq_map_quot_mk | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {r : α → α → Prop} (s : Multiset (Quot r)), ∃ t, s = Multiset.map (Quot.mk r) t |
CliffordAlgebra.reverse_mem_evenOdd_iff._simp_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {x : CliffordAlgebra Q} {n : ZMod 2},
(CliffordAlgebra.reverse x ∈ CliffordAlgebra.evenOdd Q n) = (x ∈ CliffordAlgebra.evenOdd Q n) |
CommGroup.monoidHomMonoidHomEquiv._proof_5 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ (G : Type u_2) (M : Type u_1) [inst : CommGroup G] [inst_1 : CommMonoid M] (g : G), 1 g = 1 |
FractionalIdeal.coeIdeal_inj | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_3} [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
{I J : Ideal R}, ↑I = ↑J ↔ I = J |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.ConnectedComponent.supp_injective._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b |
Std.Time.OffsetO | Std.Time.Format.Basic | Type |
CategoryTheory.Limits.biprod.lift_desc_assoc | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] {T U : C} {f : T ⟶ X} {g : T ⟶ Y} {h : X ⟶ U} {i : Y ⟶ U}
{Z : C} (h_1 : U ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift f g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.desc h i) h_1) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h + CategoryTheory.CategoryStruct.comp g i)
h_1 |
inl_coprodIsoPushout_hom_assoc | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasInitial C]
[inst_2 : CategoryTheory.Limits.HasPushouts C] (X Y : C) [inst_3 : CategoryTheory.Limits.HasBinaryCoproduct X Y]
{Z : C}
(h : CategoryTheory.Limits.pushout (CategoryTheory.Limits.initial.to X) (CategoryTheory.Limits.initial.to Y) ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
(CategoryTheory.CategoryStruct.comp (coprodIsoPushout X Y).hom h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pushout.inl (CategoryTheory.Limits.initial.to X) (CategoryTheory.Limits.initial.to Y)) h |
CategoryTheory.Bicategory.whiskerLeftIso | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
(f : a ⟶ b) →
{g h : b ⟶ c} → (g ≅ h) → (CategoryTheory.CategoryStruct.comp f g ≅ CategoryTheory.CategoryStruct.comp f h) |
CategoryTheory.MonoidalCategory.DayConvolution.isPointwiseLeftKanExtensionUnit | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{V : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} V} →
{inst_2 : CategoryTheory.MonoidalCategory C} →
{inst_3 : CategoryTheory.MonoidalCategory V} →
(F G : CategoryTheory.Functor C V) →
[self : CategoryTheory.MonoidalCategory.DayConvolution F G] →
(CategoryTheory.Functor.LeftExtension.mk
(CategoryTheory.MonoidalCategory.DayConvolution.convolution F G)
(CategoryTheory.MonoidalCategory.DayConvolution.unit F G)).IsPointwiseLeftKanExtension |
CategoryTheory.ShortComplex.Homotopy.ofEq._proof_10 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂},
φ₁ = φ₂ → φ₁.τ₃ = 0 + CategoryTheory.CategoryStruct.comp 0 S₂.g + φ₂.τ₃ |
Lean.Firefox.ProfileMeta.product._default | Lean.Util.Profiler | String |
IsPrimitiveRoot.integralPowerBasis_dim | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n), hζ.integralPowerBasis.dim = n.totient |
curveIntegral | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | {𝕜 : Type u_4} →
{E : Type u_5} →
{F : Type u_6} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] → [inst_4 : NormedSpace 𝕜 F] → {a b : E} → (E → E →L[𝕜] F) → Path a b → F |
_private.Mathlib.Algebra.Module.Presentation.Tensor.0.Module.Relations.Solution.tensor.match_1.splitter | Mathlib.Algebra.Module.Presentation.Tensor | {A : Type u_5} →
[inst : CommRing A] →
{relations₁ : Module.Relations A} →
{relations₂ : Module.Relations A} →
(motive : (relations₁.tensor relations₂).G → Sort u_6) →
(x : (relations₁.tensor relations₂).G) →
((g₁ : relations₁.G) → (g₂ : relations₂.G) → motive (g₁, g₂)) → motive x |
termSudoSet_option___In_ | Mathlib.Tactic.SudoSetOption | Lean.ParserDescr |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_one_add_div_one_sub._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False |
String.front_eq | Batteries.Data.String.Lemmas | ∀ (s : String), String.Legacy.front s = s.toList.headD default |
Metric.ediam_pi_le_of_le | Mathlib.Topology.EMetricSpace.Diam | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → PseudoEMetricSpace (X i)]
{s : (i : ι) → Set (X i)} {c : ENNReal}, (∀ (b : ι), Metric.ediam (s b) ≤ c) → Metric.ediam (Set.univ.pi s) ≤ c |
DenseRange.zpow_of_ergodic_mul_left | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[OpensMeasurableSpace G] {μ : MeasureTheory.Measure G} [μ.IsOpenPosMeasure] {g : G},
Ergodic (fun x => g * x) μ → DenseRange fun x => g ^ x |
CategoryTheory.Sigma.descUniq_inv_app | Mathlib.CategoryTheory.Sigma.Basic | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D)
(q : CategoryTheory.Functor ((i : I) × C i) D) (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q ≅ F i) (i : I)
(X : C i), (CategoryTheory.Sigma.descUniq F q h).inv.app ⟨i, X⟩ = (h i).inv.app X |
groupCohomology.isMulCoboundary₁_of_isMulCocycle₁_of_aut_to_units | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L]
(f : Gal(L/K) → Lˣ), groupCohomology.IsMulCocycle₁ f → groupCohomology.IsMulCoboundary₁ f |
continuousOn_union_iff_of_isOpen | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s t : Set α} {f : α → β},
IsOpen s → IsOpen t → (ContinuousOn f (s ∪ t) ↔ ContinuousOn f s ∧ ContinuousOn f t) |
Finmap.lookup_toFinmap | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
Finmap.lookup a s.toFinmap = AList.lookup a s |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.