name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Under.liftCocone._proof_4 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {J : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} J] (D : CategoryTheory.Functor J T) {X : T}
(s : (CategoryTheory.Functor.const J).obj X ⟶ D) (c : CategoryTheory.Limits.Cocone D) (p : X ⟶ c.pt)
(hp : ∀ (j : J), CategoryTheory.CategoryStruct... | null | false |
Finsupp.toAList_lookupFinsupp | Mathlib.Data.Finsupp.AList | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (f : α →₀ M), f.toAList.lookupFinsupp = f | null | true |
FirstOrder.Language.FGEquiv.symm | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} → {N : Type w'} → [inst : L.Structure M] → [inst_1 : L.Structure N] → L.FGEquiv M N → L.FGEquiv N M | Maps to the symmetric finitely-generated partial equivalence. | true |
HurwitzZeta.hasSum_expZeta_of_one_lt_re | Mathlib.NumberTheory.LSeries.HurwitzZeta | ∀ (a : ℝ) {s : ℂ},
1 < s.re → HasSum (fun n => Complex.exp (2 * ↑Real.pi * Complex.I * ↑a * ↑n) / ↑n ^ s) (HurwitzZeta.expZeta (↑a) s) | null | true |
LinearMap.IsPerfectCompl.left_top_iff | Mathlib.LinearAlgebra.PerfectPairing.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {p : M →ₗ[R] N →ₗ[R] R} [inst_5 : p.IsPerfPair] {V : Submodule R N},
p.IsPerfectCompl ⊤ V ↔ V = ⊤ | null | true |
Std.DHashMap.Internal.Raw₀.diff | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
[BEq α] →
[Hashable α] → Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α β | Internal implementation detail of the hash map | true |
_private.Mathlib.LinearAlgebra.Reflection.0.Module.preReflection_apply_self._abel_1_1 | Mathlib.LinearAlgebra.Reflection | ∀ {M : Type u_1} [inst : AddCommGroup M] {x : M}, x - (x + x) = -x | null | false |
Std.Http.Internal.Char.isValidDomainNameChar | Std.Http.Internal.Char | Char → Bool | Checks if a character is valid for use in a domain name.
Valid characters are ASCII alphanumeric, hyphens, and dots.
| true |
PseudoMetricSpace.induced._proof_3 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) (m : PseudoMetricSpace β) (x x_1 x_2 : α),
dist (f x) (f x_2) ≤ dist (f x) (f x_1) + dist (f x_1) (f x_2) | null | false |
CategoryTheory.Functor.PreservesLeftHomologyOf.congr_simp | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F F_1 : CategoryTheory.Functor C D) (e_F : F = F_1)
[inst_4 : F.PreservesZeroMorphi... | null | true |
Lean.Server.RefInfo.noConfusion | Lean.Server.References | {P : Sort u} → {t t' : Lean.Server.RefInfo} → t = t' → Lean.Server.RefInfo.noConfusionType P t t' | null | false |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.pp | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Lean.Meta.Grind.GoalM Lean.MessageData | null | true |
Std.Sat.AIG.Fanin.invert_flip | Std.Sat.AIG.Basic | ∀ {v : Bool} (f : Std.Sat.AIG.Fanin), (f.flip v).invert = (f.invert ^^ v) | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.mem_iff_get._simp_1_2 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (a ∈ xs) = ∃ i, ∃ (h : i < xs.size), xs[i] = a | null | false |
Lean.Data.AC.Expr.brecOn | Init.Data.AC | {motive : Lean.Data.AC.Expr → Sort u} →
(t : Lean.Data.AC.Expr) → ((t : Lean.Data.AC.Expr) → Lean.Data.AC.Expr.below t → motive t) → motive t | null | false |
_private.Init.Data.Subtype.Order.0.Subtype.instLawfulOrderLT._simp_1 | Init.Data.Subtype.Order | ∀ {α : Type u} {inst : LT α} {inst_1 : LE α} [self : Std.LawfulOrderLT α] (a b : α), (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
Real.strictMonoOn_rpow_Ici_of_exponent_pos | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {r : ℝ}, 0 < r → StrictMonoOn (fun x => x ^ r) (Set.Ici 0) | null | true |
NonUnitalSubsemiringClass.subtype_injective | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : SetLike S R]
[inst_2 : NonUnitalSubsemiringClass S R] (s : S), Function.Injective ⇑(NonUnitalSubsemiringClass.subtype s) | null | true |
AlgebraicGeometry.Scheme.Cover.sigma | Mathlib.AlgebraicGeometry.Cover.Sigma | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S : AlgebraicGeometry.Scheme} →
[AlgebraicGeometry.IsZariskiLocalAtSource P] →
[UnivLE.{v, u}] →
AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S →
AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.S... | If `𝒰` is a cover of `S`, this is the single object cover where the covering
object is the disjoint union. | true |
Lean.Elab.MacroStackElem.before | Lean.Elab.Util | Lean.Elab.MacroStackElem → Lean.Syntax | null | true |
Lean.Lsp.InlayHintClientCapabilities.resolveSupport?._default | Lean.Data.Lsp.LanguageFeatures | Option Lean.Lsp.ResolveSupport | null | false |
CategoryTheory.Functor.HomObj.mk.inj | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {D : Type u'} {inst_1 : CategoryTheory.Category.{v', u'} D}
{F G : CategoryTheory.Functor C D} {A : CategoryTheory.Functor C (Type w)}
{app : (c : C) → A.obj c → (F.obj c ⟶ G.obj c)}
{naturality :
autoParam
(∀ {c d : C} (f : c ⟶ d) (a : A.obj c),
... | null | true |
_private.Mathlib.AlgebraicGeometry.ColimitsOver.0.AlgebraicGeometry.Scheme.Cover.ColimitGluingData.transitionMap_comp._simp_1_1 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | null | false |
Std.ExtTreeMap.getD_map_of_getKey?_eq_some | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Inhabited γ] {f : α → β → γ} {k k' : α} {fallback : γ},
t.getKey? k = some k' → (Std.ExtTreeMap.map f t).getD k fallback = (Option.map (f k') t[k]?).getD fallback | null | true |
PresheafOfModules.Sheafify.zero_smul | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | null | true |
NumberField.mixedEmbedding.negAt_symm | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] {s : Set { w // w.IsReal }},
(NumberField.mixedEmbedding.negAt s).symm = NumberField.mixedEmbedding.negAt s | `negAt` is its own inverse. | true |
Submodule.starProjection_orthogonal' | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(U : Submodule 𝕜 E) [inst_3 : U.HasOrthogonalProjection], Uᗮ.starProjection = 1 - U.starProjection | null | true |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_128 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} (i j : ℕ), j < l.length → i < j → i < (List.take (List.take j l).length l).length | null | false |
List.map_append_flatMap_perm | Mathlib.Data.List.Perm.Basic | ∀ {α : Type u_1} {β : Type u_2} (l : List α) (f : α → β) (g : α → List β),
(List.map f l ++ List.flatMap g l).Perm (List.flatMap (fun x => f x :: g x) l) | null | true |
CategoryTheory.Under.mapId_inv_app_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (Y : T) (X : CategoryTheory.Under Y),
((CategoryTheory.Under.mapId Y).inv.app X).right = CategoryTheory.CategoryStruct.id X.right | null | true |
MeasureTheory.SimpleFunc.instInf | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [Min β] → Min (MeasureTheory.SimpleFunc α β) | null | true |
Lean.IR.IRType.brecOn.go | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) →
((t : Lean.IR.IRType) → t.below → motive_1 t) →
((t : Array Lean.IR.IRType) → Lean.IR.IRType.below_1 t → motive_2 t) →
((t : Li... | null | true |
CategoryTheory.instMonoidalCategoryHom._proof_6 | Mathlib.CategoryTheory.Bicategory.End | ∀ {C : Type u_2} [inst : CategoryTheory.Bicategory C] (X : C) (X_1 Y : X ⟶ X),
CategoryTheory.Bicategory.whiskerLeft X_1 (CategoryTheory.CategoryStruct.id Y) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp X_1 Y) | null | false |
CategoryTheory.Functor.Fiber.fiberInclusion_mk | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {a : 𝒳} (ha : p.obj a = S),
CategoryTheory.Functor.Fiber.fiberInclusion.obj (CategoryTheory.Functor.Fiber.mk ha) = a | null | true |
Lean.CollectMVars.State._sizeOf_1 | Lean.Util.CollectMVars | Lean.CollectMVars.State → ℕ | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.subschemeCover._proof_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (j : ↑X.affineOpens),
AlgebraicGeometry.IsOpenImmersion (CategoryTheory.CategoryStruct.comp (I.glueData.ι j) I.subschemeIso.inv) | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.waitIfContainsMVar._regBuiltin.Lean.Parser.Term.waitIfContainsMVar_1 | Lean.Parser.Term | IO Unit | null | false |
CompactlyCoherentSpace | Mathlib.Topology.Compactness.CompactlyCoherentSpace | (X : Type u_1) → [TopologicalSpace X] → Prop | A space is a compactly coherent space if the topology is generated by the compact sets. | true |
LinearMap.mapMatrixModule_comp_apply | Mathlib.LinearAlgebra.Matrix.Module | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : Ring R] [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] [inst_7 : AddCommGroup P] [inst_8 : Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P) (... | null | true |
DoubleCentralizer.mk.noConfusion | Mathlib.Analysis.CStarAlgebra.Multiplier | {𝕜 : Type u} →
{A : Type v} →
{inst : NontriviallyNormedField 𝕜} →
{inst_1 : NonUnitalNormedRing A} →
{inst_2 : NormedSpace 𝕜 A} →
{inst_3 : SMulCommClass 𝕜 A A} →
{inst_4 : IsScalarTower 𝕜 A A} →
{P : Sort u_1} →
{toProd : (A →L[𝕜] A) × (A →... | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt32.reduceBNe.declare_222._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2393314560._hygCtx.9.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2393314560._hygCtx._hyg.326 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
CategoryTheory.ComposableArrows.isIso_iff₂ | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.ComposableArrows C 2} (f : F ⟶ G),
CategoryTheory.IsIso f ↔
CategoryTheory.IsIso (f.app 0) ∧ CategoryTheory.IsIso (f.app 1) ∧ CategoryTheory.IsIso (f.app 2) | null | true |
ProbabilityTheory.IsGaussianProcess | Mathlib.Probability.Distributions.Gaussian.IsGaussianProcess.Def | {Ω : Type u_1} →
{E : Type u_2} →
{T : Type u_3} →
{mΩ : MeasurableSpace Ω} →
[MeasurableSpace E] →
[TopologicalSpace E] →
[inst : AddCommMonoid E] →
[Module ℝ E] →
(T → Ω → E) → autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.IsGaussianProce... | A stochastic process is a Gaussian process if all its finite dimensional distributions are
Gaussian. | true |
instHashableInt64 | Init.Data.SInt.Basic | Hashable Int64 | null | true |
Metric.hausdorffEDist_le_of_infEDist | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α} {r : ENNReal},
(∀ x ∈ s, Metric.infEDist x t ≤ r) → (∀ x ∈ t, Metric.infEDist x s ≤ r) → Metric.hausdorffEDist s t ≤ r | Bounding the Hausdorff edistance by bounding the edistance of any point
in each set to the other set | true |
SimpleGraph.toSubgraph | Mathlib.Combinatorics.SimpleGraph.Subgraph | {V : Type u} → {G : SimpleGraph V} → (H : SimpleGraph V) → H ≤ G → G.Subgraph | Turn a subgraph of a `SimpleGraph` into a member of its subgraph type. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_filterMap._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Init.Data.SInt.Lemmas.0.Int32.le_total._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x ≤ y) = (x.toInt ≤ y.toInt) | null | false |
_private.Mathlib.MeasureTheory.Measure.LevyProkhorovMetric.0.MeasureTheory.LevyProkhorov.continuous_ofMeasure_probabilityMeasure._simp_1_9 | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
Finset.sup_eq_zero._simp_1 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α}
[inst_2 : Zero α] [IsBotZeroClass α], (s.sup f = 0) = ∀ i ∈ s, f i = 0 | null | false |
ContinuousMonoidHom.comp_toFun | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : Monoid C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] (g : B →ₜ* C) (f : A →ₜ* B)
(x : A), (g.comp f) x = g (f x) | null | true |
Nat.ceil_eq_zero._simp_1 | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R}, (⌈a⌉₊ = 0) = (a ≤ 0) | null | false |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_eq_Ioc_iff._proof_1_2 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α}, a < b ∨ c < d → Set.Ioc a b = Set.Ioc c d → a < b | null | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.sndFunctor._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_5} {B : Type u_6} {C : Type u_7} [inst : CategoryTheory.Category.{u_1, u_5} A]
[inst_1 : CategoryTheory.Category.{u_2, u_6} B] [inst_2 : CategoryTheory.Category.{u_3, u_7} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u_8)
[inst_3 : CategoryTheory.Category.{u_4, u_8}... | null | false |
FirstOrder.Language.Equiv.comp_refl | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(g : L.Equiv M N), g.comp (FirstOrder.Language.Equiv.refl L M) = g | null | true |
Finset.UV.isInitSeg_of_compressed | Mathlib.Combinatorics.SetFamily.KruskalKatona | ∀ {α : Type u_1} [inst : LinearOrder α] {ℬ : Finset (Finset α)} {r : ℕ},
Set.Sized r ↑ℬ →
(∀ (U V : Finset α), Finset.UV.UsefulCompression✝ U V → UV.IsCompressed U V ℬ) → Finset.Colex.IsInitSeg ℬ r | If we're compressed by all useful compressions, then we're an initial segment. This is the other
key Kruskal-Katona part. | true |
Lean.Grind.Config.noConfusion | Init.Grind.Config | {P : Sort u} → {t t' : Lean.Grind.Config} → t = t' → Lean.Grind.Config.noConfusionType P t t' | null | false |
Lean.Exception.toMessageData | Lean.Exception | Lean.Exception → Lean.MessageData | Convert exception into a structured message. | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {k : ℕ} {c : Lean.Meta.Grind.Arith.Linear.EqCnstr} {k_1 : ℕ} {c_1 : Lean.Meta.Grind.Arith.Linear.EqCnstr},
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff k c = Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff k_1 c_1 →
k = k_1 ∧ c = c_1 | null | true |
CategoryTheory.Presieve.CoverByImageStructure.noConfusionType | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | Sort u →
{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] →
{G : CategoryTheory.Functor C D} →
{V U : D} →
{f : V ⟶ U} →
CategoryTheory.Presieve.CoverByImageStructure ... | null | false |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.mem_succ_succ_iff._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.PRange.LawfulUpwardEnumerableLT α]
(a b : α), (a < b) = Std.PRange.UpwardEnumerable.LT a b | null | false |
Module.End.instSemiring._proof_5 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : Module.End R M), x ^ 0 = 1 | null | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.Fintype.not_linearIndependent_iffₒₛ._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : LinearOrder R] [CanonicallyOrderedAdd R] [AddRightReflectLE R] [IsCancelAdd M]
[inst_7 : DecidableEq ι] [inst_8 : Fintype ι],
LinearIndependent R v = ∀ (t : Finset ι) (f : ι → R... | null | false |
Finsupp.equivMapDomain_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ≃ β) (l : α →₀ M) (b : β),
(Finsupp.equivMapDomain f l) b = l (f.symm b) | null | true |
SemilatInfCat.of | Mathlib.Order.Category.Semilat | (X : Type u) → [isSemilatticeInf : SemilatticeInf X] → [isOrderTop : OrderTop X] → SemilatInfCat | Construct a bundled `SemilatInfCat` from a `SemilatticeInf`. | true |
Bimod.tensorBimod | Mathlib.CategoryTheory.Monoidal.Bimod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.Limits.HasCoequalizers C] →
[∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.ten... | Tensor product of two bimodule objects as a bimodule object. | true |
Function.mem_ptsOfPeriod | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} {f : α → α} {x : α} {n : ℕ}, x ∈ Function.ptsOfPeriod f n ↔ Function.IsPeriodicPt f n x | null | true |
Lean.Elab.ConfigEval.EvalConfigItemView.mk.inj | Lean.Elab.ConfigEval.DeriveEvalConfigItem | ∀ {omitFields : Array (Lean.Ident × Lean.Name)} {handlers : Array Lean.Elab.ConfigEval.EvalConfigItemHandler}
{omitFields_1 : Array (Lean.Ident × Lean.Name)} {handlers_1 : Array Lean.Elab.ConfigEval.EvalConfigItemHandler},
{ omitFields := omitFields, handlers := handlers } = { omitFields := omitFields_1, handlers :... | null | true |
UniformConvexOn.mono | Mathlib.Analysis.Convex.Strong | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {φ ψ : ℝ → ℝ} {s : Set E} {f : E → ℝ},
ψ ≤ φ → UniformConvexOn s φ f → UniformConvexOn s ψ f | null | true |
Mathlib.Meta.NormNum.isNat_realSqrt_of_isRat_negOfNat | Mathlib.Tactic.NormNum.RealSqrt | ∀ {x : ℝ} {num denom : ℕ}, Mathlib.Meta.NormNum.IsRat x (Int.negOfNat num) denom → Mathlib.Meta.NormNum.IsNat (√x) 0 | null | true |
_private.Mathlib.RingTheory.WittVector.StructurePolynomial.0.eq_wittStructureInt._simp_1_1 | Mathlib.RingTheory.WittVector.StructurePolynomial | ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
[inst_2 : CommSemiring S₂] (f : R →+* S₁) (g : σ → S₂) (φ : S₁ →+* S₂) (p : MvPolynomial σ R),
(MvPolynomial.eval₂Hom (φ.comp f) g) p = (MvPolynomial.eval₂Hom φ g) ((MvPolynomial.map f) p) | null | false |
TotallyBounded.isSeparable | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] [(uniformity α).IsCountablyGenerated] {s : Set α},
TotallyBounded s → TopologicalSpace.IsSeparable s | A totally bounded set is separable in countably generated uniform spaces. This can be obtained
from the more general `UniformSpace.subset_countable_closure_of_almost_dense_set`. | true |
CategoryTheory.ShortComplex.opcyclesMap'_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData) (a : R),
CategoryTheory.Sho... | null | true |
ProfiniteGrp.toLimit._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u_1}), CompactSpace ↥(ProfiniteGrp.limitConePtAux P.diagram) | null | false |
Set.Ici_nsmul_eq._f | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_2} [inst : AddMonoid α] [inst_1 : Preorder α] [CanonicallyOrderedAdd α] [AddRightMono α] {a : α} (x : ℕ)
(f : Nat.below (motive := fun x => x ≠ 0 → x • Set.Ici a = Set.Ici (x • a)) x),
x ≠ 0 → x • Set.Ici a = Set.Ici (x • a) | null | false |
Multiset.exists_cons_of_mem | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, a ∈ s → ∃ t, s = a ::ₘ t | null | true |
mulMulHom_apply | Mathlib.Algebra.Group.Prod | ∀ {α : Type u_6} [inst : CommSemigroup α] (a : α × α), mulMulHom a = a.1 * a.2 | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.heapifyUp_perm._proof_1_4 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} {sz : ℕ} (a : Vector α sz), a.Perm a | null | false |
Set.union_iUnion | Mathlib.Data.Set.Lattice.Indexed | ∀ {β : Type u_2} {ι : Sort u_4} [Nonempty ι] (s : Set β) (t : ι → Set β), s ∪ ⋃ i, t i = ⋃ i, s ∪ t i | null | true |
CategoryTheory.Functor.sections_ext_iff | Mathlib.CategoryTheory.Types.Basic | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w)} {x y : ↑F.sections},
x = y ↔ ∀ (j : J), ↑x j = ↑y j | null | true |
_private.Mathlib.Topology.NhdsWithin.0.dense_pi._simp_1_1 | Mathlib.Topology.NhdsWithin | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, Dense s = (closure s = Set.univ) | null | false |
Filter.CardinalGenerateSets.rec | Mathlib.Order.Filter.CardinalInter | ∀ {α : Type u} {c : Cardinal.{u}} {g : Set (Set α)} {motive : (a : Set α) → Filter.CardinalGenerateSets g a → Prop},
(∀ {s : Set α} (a : s ∈ g), motive s ⋯) →
motive Set.univ ⋯ →
(∀ {s t : Set α} (a : Filter.CardinalGenerateSets g s) (a_1 : s ⊆ t), motive s a → motive t ⋯) →
(∀ {S : Set (Set α)} (a ... | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Lookup.0.Lean.Meta.RefinedDiscrTree.evalNode.match_4 | Mathlib.Lean.Meta.RefinedDiscrTree.Lookup | (motive : Lean.Meta.RefinedDiscrTree.Key → Sort u_1) →
(key : Lean.Meta.RefinedDiscrTree.Key) →
((label : ℕ) → motive (Lean.Meta.RefinedDiscrTree.Key.labelledStar label)) →
(Unit → motive Lean.Meta.RefinedDiscrTree.Key.star) →
((x : Lean.Meta.RefinedDiscrTree.Key) → motive x) → motive key | null | false |
IicProdIoc_self | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] [inst_2 : DecidableLE ι] {X : ι → Type u_2}
[inst_3 : LocallyFiniteOrderBot ι] (a : ι), IicProdIoc a a = Prod.fst | null | true |
TopologicalSpace.Opens.coe_sup | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] (s t : TopologicalSpace.Opens α), ↑(s ⊔ t) = ↑s ∪ ↑t | null | true |
_private.Mathlib.Data.Set.Function.0.Set.prod_surjOn_snd_iff._simp_1_3 | Mathlib.Data.Set.Function | ∀ {β₁ : Type u_7} {β₂ : Type u_8} {t₁ : Set β₁} {t₂ : Set β₂}, t₁.Nonempty → Set.SurjOn Prod.snd (t₁ ×ˢ t₂) t₂ = True | null | false |
_private.Mathlib.Algebra.SkewPolynomial.Basic.0.SkewPolynomial.coeff_neg._simp_1_1 | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a = -b) = (a + b = 0) | null | false |
_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Finset.Icc_ofNat_ofNat.match_10 | Mathlib.Tactic.Simproc.FinsetInterval | (em en : Q(ℕ)) →
(motive : (s : Q(Finset ℕ)) × Q(Finset.Icc «$em» «$en» = «$s») → Sort u_1) →
(x : (s : Q(Finset ℕ)) × Q(Finset.Icc «$em» «$en» = «$s»)) →
((es : Q(Finset ℕ)) → (p : Q(Finset.Icc «$em» «$en» = «$es»)) → motive ⟨es, p⟩) → motive x | null | false |
Set.exists_image_eq_and_injOn | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (f : α → β), ∃ u, f '' u = f '' s ∧ Set.InjOn f u | null | true |
_private.Mathlib.Data.Bool.Count.0.List.IsChain.count_not_le_count_add_one._proof_1_1 | Mathlib.Data.Bool.Count | ∀ (b head : Bool) (tail : List Bool),
List.IsChain (fun x1 x2 => x1 ≠ x2) (head :: tail) → List.count (!b) (head :: tail) ≤ List.count b (head :: tail) + 1 | null | false |
OrderType.lift_lift | Mathlib.Order.Types.Defs | ∀ (o : OrderType.{u_1}), OrderType.lift.{u, max v u_1} (OrderType.lift.{v, u_1} o) = OrderType.lift.{max v u, u_1} o | null | true |
Dioph.«_aux_Mathlib_NumberTheory_Dioph___macroRules_Dioph_term_D-__1» | Mathlib.NumberTheory.Dioph | Lean.Macro | null | false |
CategoryTheory.PreZeroHypercover.Relation.fst | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{S : C} → {E : CategoryTheory.PreZeroHypercover S} → {i j : E.I₀} → (self : E.Relation i j) → self.obj ⟶ E.X i | The first projection. | true |
CompactlyGeneratedSpace | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | (X : Type u) → [TopologicalSpace X] → Prop | A topological space `X` is compactly generated if its topology is finer than (and thus equal to)
the compactly generated topology, i.e. it is coinduced by the continuous maps from compact
Hausdorff spaces to `X`.
In this version, intended for topological purposes, the compact spaces are taken
in the same universe as `... | true |
CategoryTheory.SimplicialObject.Split.evalN_obj | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (n : ℕ) (S : CategoryTheory.SimplicialObject.Split C),
(CategoryTheory.SimplicialObject.Split.evalN C n).obj S = S.s.N n | null | true |
MeasureTheory.etvDist_of_not_isFiniteMeasure_left | Mathlib.MeasureTheory.Measure.TotalVariation.Defs | ∀ {𝓧 : Type u_1} {m𝓧 : MeasurableSpace 𝓧} {μ ν : MeasureTheory.Measure 𝓧},
¬MeasureTheory.IsFiniteMeasure μ → MeasureTheory.etvDist μ ν = ⊤ | null | true |
RingEquiv.ofNonUnitalRingHom._proof_1 | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(hom : R →ₙ+* S) (inv : S →ₙ+* R),
inv.comp hom = NonUnitalRingHom.id R → ∀ (x : R), (inv.comp hom) x = (NonUnitalRingHom.id R) x | null | false |
CommSemiring.toCoalgebra._proof_7 | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u_1) [inst : CommSemiring R],
↑(TensorProduct.assoc R R R R) ∘ₗ LinearMap.rTensor R ((TensorProduct.mk R R R) 1) ∘ₗ (TensorProduct.mk R R R) 1 =
↑(TensorProduct.assoc R R R R) ∘ₗ LinearMap.rTensor R ((TensorProduct.mk R R R) 1) ∘ₗ (TensorProduct.mk R R R) 1 | null | false |
UInt8.compare_eq_toNat_compare_toNat | Batteries.Data.UInt | ∀ (x y : UInt8), compare x y = compare x.toNat y.toNat | null | true |
unitInterval.symm.eq_1 | Mathlib.Topology.UnitInterval | ∀ (t : ↑unitInterval), unitInterval.symm t = ⟨1 - ↑t, ⋯⟩ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.