name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FirstOrder.Language.HomClass.rec | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} →
{F : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
[inst : FunLike F M N] →
[inst_1 : L.Structure M] →
[inst_2 : L.Structure N] →
{motive : L.HomClass F M N → Sort u} →
((map_fun :
∀ (φ : F) {n : ℕ}... | null | false |
ContinuousLinearMap.snd_comp_prod | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | ∀ {R : Type u_1} [inst : Semiring R] {M₁ : Type u_2} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R M₁] {M₂ : Type u_3} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₂] {M₃ : Type u_4} [inst_7 : TopologicalSpace M₃] [inst_8 : AddCommMonoid M₃]
[inst_... | null | true |
Finset.nsmul_piAntidiag | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {ι : Type u_1} [inst : DecidableEq ι] [inst_1 : DecidableEq (ι → ℕ)] (s : Finset ι) (m : ℕ) {n : ℕ},
n ≠ 0 → n • s.piAntidiag m = {f ∈ s.piAntidiag (n * m) | ∀ i ∈ s, n ∣ f i} | null | true |
CategoryTheory.SymmetricCategory.braiding_swap_eq_inv_braiding | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (X Y : C), (β_ Y X).hom = (β_ X Y).inv | null | true |
Nat.isNone_getElem?_toArray_roc_eq | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, ((m<...=n).toArray[i]?.isNone = true) = (n ≤ i + m) | null | true |
Lean.StructureResolutionOrderConflict.mk.injEq | Lean.Structure | ∀ (isDirectParent : Bool) (badParent : Lean.Name) (conflicts : Array (Bool × Lean.Name)) (isDirectParent_1 : Bool)
(badParent_1 : Lean.Name) (conflicts_1 : Array (Bool × Lean.Name)),
({ isDirectParent := isDirectParent, badParent := badParent, conflicts := conflicts } =
{ isDirectParent := isDirectParent_1, b... | null | true |
Std.TreeMap.getKeyGED | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → α → α | Tries to retrieve the smallest key that is greater than or equal to the
given key, returning `fallback` if no such key exists.
| true |
MeasureTheory.AEStronglyMeasurable.tsum' | Mathlib.MeasureTheory.Constructions.Polish.StronglyMeasurable | ∀ {X : Type u_4} {E : Type u_5} {ι : Type u_6} [inst : MeasurableSpace X] [inst_1 : AddCommMonoid E]
[inst_2 : TopologicalSpace E] [TopologicalSpace.PseudoMetrizableSpace E] [ContinuousAdd E] {L : SummationFilter ι}
[L.NeBot] [L.filter.IsCountablyGenerated] {μ : MeasureTheory.Measure X} {f : ι → X → E},
(∀ (i : ι... | The sum of almost everywhere strongly measurable functions is measurable. | true |
BoxIntegral.TaggedPrepartition.disjUnion.congr_simp | Mathlib.Analysis.BoxIntegral.Partition.SubboxInduction | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π₁ π₁_1 : BoxIntegral.TaggedPrepartition I) (e_π₁ : π₁ = π₁_1)
(π₂ π₂_1 : BoxIntegral.TaggedPrepartition I) (e_π₂ : π₂ = π₂_1) (h : Disjoint π₁.iUnion π₂.iUnion),
π₁.disjUnion π₂ h = π₁_1.disjUnion π₂_1 ⋯ | null | true |
HasSumUniformlyOn.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] (f : ι → β → α) (g : β → α) (s : Set β)
[inst_1 : UniformSpace α],
HasSumUniformlyOn f g s = HasSum (⇑(UniformOnFun.ofFun {s}) ∘ f) ((UniformOnFun.ofFun {s}) g) | null | true |
Lean.Meta.LazyDiscrTree.InitResults.tree | Lean.Meta.LazyDiscrTree | {α : Type} → Lean.Meta.LazyDiscrTree.InitResults α → Lean.Meta.LazyDiscrTree.PreDiscrTree α | null | true |
SimpleGraph.IsTuranMaximal.card_parts | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {V : Type u_1} [inst : Fintype V] {G : SimpleGraph V} [inst_1 : DecidableRel G.Adj] {r : ℕ} (h : G.IsTuranMaximal r)
[inst_2 : DecidableEq V], h.finpartition.parts.card = min (Fintype.card V) r | There are `min n r` parts in a graph on `n` vertices satisfying `G.IsTuranMaximal r`.
`min` handles the `n < r` case, when `G` is complete but still `r + 1`-cliquefree
for having insufficiently many vertices. | true |
le_of_lt_or_eq | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a < b ∨ a = b → a ≤ b | null | true |
DedekindCut.principal_lt_principal._gcongr_1 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a < b → DedekindCut.principal a < DedekindCut.principal b | null | false |
ContinuousAlgEquiv.coeCLE_refl | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
[inst_3 : Algebra R A], ↑(ContinuousAlgEquiv.refl R A) = ContinuousLinearEquiv.refl R A | null | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.mkAnswer | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.ConsumerNode → Lean.MetaM Lean.Meta.SynthInstance.Answer | null | true |
Shrink.instModule | Mathlib.Algebra.Module.Shrink | {R : Type u_1} →
{α : Type u_2} →
[inst : Small.{v, u_2} α] →
[inst_1 : Semiring R] → [inst_2 : AddCommMonoid α] → [Module R α] → Module R (Shrink.{v, u_2} α) | null | true |
CategoryTheory.Iso.hom_inv_id_assoc._to_dual_1 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (self : X ≅ Y) {Z : C} (h : Z ⟶ X),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h self.hom) self.inv = h | null | false |
IsBoundedBilinearMap.differentiable | Mathlib.Analysis.Calculus.FDeriv.Bilinear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {b : E × F → G},
IsBoundedBilinearM... | null | true |
MvPowerSeries.trunc'_expand | Mathlib.RingTheory.MvPowerSeries.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] (p : ℕ) (hp : p ≠ 0) [inst_1 : DecidableEq σ] {n : σ →₀ ℕ}
(φ : MvPowerSeries σ R),
(MvPowerSeries.trunc' R (p • n)) ((MvPowerSeries.expand p hp) φ) =
(MvPolynomial.expand p) ((MvPowerSeries.trunc' R n) φ) | null | true |
CategoryTheory.Limits.Pi.reindex_inv_π | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {γ : Type w'} (ε : β ≃ γ) (f : γ → C)
[inst_1 : CategoryTheory.Limits.HasProduct f] [inst_2 : CategoryTheory.Limits.HasProduct (f ∘ ⇑ε)] (b : β),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.reindex ε f).inv
(CategoryTheory.... | null | true |
AdjoinRoot.of | Mathlib.RingTheory.AdjoinRoot | {R : Type u_1} → [inst : CommRing R] → (f : Polynomial R) → R →+* AdjoinRoot f | Embedding of the original ring `R` into `AdjoinRoot f`. | true |
Int8.xor_zero | Init.Data.SInt.Bitwise | ∀ {a : Int8}, a ^^^ 0 = a | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt32.toUInt8_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
Lean.Meta.Grind.getSimprocs | Lean.Meta.Tactic.Grind.SimpUtil | Lean.MetaM (Array Lean.Meta.Simprocs) | Returns the array of simprocs used by `grind`. | true |
Lean.AssocList.erase._f | Lean.Data.AssocList | {α : Type u} → {β : Type v} → [BEq α] → α → (x : Lean.AssocList α β) → Lean.AssocList.below x → Lean.AssocList α β | null | false |
Subgroup.Characteristic.mk._flat_ctor | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G},
(∀ (ϕ : G ≃* G), Subgroup.comap ϕ.toMonoidHom H = H) → H.Characteristic | null | false |
SimpleGraph.exists_maximal_degree_vertex | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj] [Nonempty V],
∃ v, G.maxDegree = G.degree v | There exists a vertex of maximal degree. Note the assumption of being nonempty is necessary, as
the lemma implies there exists a vertex. | true |
Array.foldl_map | Init.Data.Array.Lemmas | ∀ {β₁ : Type u_1} {β₂ : Type u_2} {α : Type u_3} {f : β₁ → β₂} {g : α → β₂ → α} {xs : Array β₁} {init : α},
Array.foldl g init (Array.map f xs) = Array.foldl (fun x y => g x (f y)) init xs | null | true |
_private.Mathlib.Geometry.Manifold.ChartedSpace.0.ChartedSpace.ext.match_1 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u_1} {inst : TopologicalSpace H} {M : Type u_2} {inst_1 : TopologicalSpace M}
(motive : ChartedSpace H M → Prop) (h : ChartedSpace H M),
(∀ (atlas : Set (OpenPartialHomeomorph M H)) (chartAt : M → OpenPartialHomeomorph M H)
(mem_chart_source : ∀ (x : M), x ∈ (chartAt x).source) (chart_mem_atlas : ... | null | false |
CategoryTheory.ShortComplex.RightHomologyData.ofAbelian._proof_5 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C),
CategoryTheory.Limits.cokernel.desc S.f S.g ⋯ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.cokernel.π
(CategoryTheory.CategoryStruct.comp (Category... | null | false |
MulOpposite.instField._proof_6 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [inst : Field α] (a : αᵐᵒᵖ), a ≠ 0 → a * a⁻¹ = 1 | null | false |
_private.Mathlib.Analysis.BoxIntegral.Box.Basic.0.BoxIntegral.Box.injective_coe._simp_1_2 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, (I ≤ J) = (J.lower ≤ I.lower ∧ I.upper ≤ J.upper) | null | false |
LinearIsometryEquiv.coe_toHomeomorph | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_4} {E₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | null | true |
CategoryTheory.Profunctor.ofCore._proof_2 | Mathlib.CategoryTheory.Profunctor.Basic | ∀ {C : Type u_5} {D : Type u_1} [inst : CategoryTheory.Category.{u_3, u_5} C]
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] (P : CategoryTheory.ProfunctorCore.{u_2, u_3, u_4, u_5, u_1} C D)
(X : C) (X_1 : Dᵒᵖ),
P.map (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X_1).unop =
Category... | null | false |
Std.Do._aux_Std_Do_PostCond___unexpand_Std_Do_PostCond_and_1 | Std.Do.PostCond | Lean.PrettyPrinter.Unexpander | null | false |
Height.AdmissibleAbsValues.mk.noConfusion | Mathlib.NumberTheory.Height.Basic | {K : Type u_1} →
{inst : Field K} →
{P : Sort u} →
{archAbsVal : Multiset (AbsoluteValue K ℝ)} →
{nonarchAbsVal : Set (AbsoluteValue K ℝ)} →
{isNonarchimedean : ∀ v ∈ nonarchAbsVal, IsNonarchimedean ⇑v} →
{hasFiniteMulSupport : ∀ {x : K}, x ≠ 0 → Function.HasFiniteMulSupport fu... | null | false |
CategoryTheory.Pretriangulated.TriangleMorphism.comm₃ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} (self : CategoryTheory.Pretriangulated.TriangleMorphism T₁ T₂),
CategoryTheory.CategoryStruct.comp T₁.mor₃ ((CategoryTheory.shiftFunctor C 1).map self.hom₁) =
Categ... | the third commutative square of a triangle morphism | true |
Int8._sizeOf_inst | Init.Data.SInt.Basic | SizeOf Int8 | null | false |
minpoly.instSMulSubtypeMemSubringSubalgebraIntegralClosure._proof_1 | Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed | ∀ {K : Type u_1} [inst : Field K], SubsemiringClass (Subring K) K | null | false |
Std.ExtTreeSet.min_le_min_erase | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{he : t.erase k ≠ ∅}, (cmp (t.min ⋯) ((t.erase k).min he)).isLE = true | null | true |
CategoryTheory.AddGrpObj.instTensorAddUnit.eq_1 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
CategoryTheory.AddGrpObj.instTensorAddUnit =
{ toAddMonObj := CategoryTheory.AddMonObj.instTensorAddUnit,
neg := CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUn... | null | true |
Left.add_pos | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftStrictMono α],
b < c → 0 < a → b < c + a | Assumes left covariance.
The lemma assuming right covariance is `Right.add_pos`. | true |
Cubic.b_of_eq | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} {P Q : Cubic R} [inst : Semiring R], P.toPoly = Q.toPoly → P.b = Q.b | null | true |
CommGrpCat.commGroupObj._aux_12 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J CommGrpCat) → (j : J) → Inv ((F.comp (CategoryTheory.forget CommGrpCat)).obj j) | null | false |
reindex_mem_doublyStochastic_iff | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {m : Type u_3} [inst_5 : Fintype m] [inst_6 : DecidableEq m]
{M : Matrix n n R} {e₁ e₂ : n ≃ m}, (Matrix.reindex e₁ e₂) M ∈ doublyStochastic R m ↔ M ∈ doublyStochast... | Reindexing a matrix preserves double stochasticity. | true |
AbsolutelyContinuousOnInterval.const_of_ae_hasDerivAt_zero | Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun | ∀ {F : Type u_2} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {f : ℝ → F} {a b : ℝ},
AbsolutelyContinuousOnInterval f a b →
(∀ᵐ (x : ℝ), x ∈ Set.uIcc a b → HasDerivAt f 0 x) → ∃ C, ∀ x ∈ Set.uIcc a b, f x = C | If `f` is absolutely continuous on `uIcc a b` and `f' x = 0` for a.e. `x ∈ uIcc a b`, then `f`
is constant on `uIcc a b`. | true |
_private.Mathlib.RingTheory.Valuation.Discrete.IsDiscreteValuationRing.0.IsDiscreteValuationRing.mker_valuation_eq_isUnitSubmonoid._simp_1_6 | Mathlib.RingTheory.Valuation.Discrete.IsDiscreteValuationRing | ∀ {a : Prop}, (¬¬a) = a | null | false |
SimpleGraph.Embedding.completeGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {α : Type u_2} {β : Type u_1} (f : α ↪ β) {a b : α},
(SimpleGraph.completeGraph β).Adj (f a) (f b) ↔ (SimpleGraph.completeGraph α).Adj a b | null | false |
NoBotOrder.to_noMinOrder | Mathlib.Order.Max | ∀ (α : Type u_3) [inst : LinearOrder α] [NoBotOrder α], NoMinOrder α | null | true |
MulEquiv.AddMonoid.End_symm_apply_apply | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ (A : Type u_4) [inst : AddZeroClass A] (f : Multiplicative A →* Multiplicative A) (a : A),
((MulEquiv.addMonoidEnd A).symm f) a = Multiplicative.toAdd (f (Multiplicative.ofAdd a)) | **Alias** of `MulEquiv.addMonoidEnd_symm_apply_apply`. | true |
Std.Time.Second.Offset.ofWeeks | Std.Time.Date.Basic | Std.Time.Week.Offset → Std.Time.Second.Offset | Convert `Week.Offset` into `Second.Offset`.
| true |
BoundedContinuousFunction.toContinuousMapStarₐ._proof_7 | Mathlib.Topology.ContinuousMap.Bounded.Star | ∀ {β : Type u_1} [inst : NormedRing β], ContinuousAdd β | null | false |
Std.Http.Method.baselineControl | Std.Http.Data.Method | Std.Http.Method | Apply a label to a version-controlled resource baseline.
Source: https://www.rfc-editor.org/rfc/rfc3253#section-12.6
| true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum.eq_def | Lean.Compiler.NameMangling | ∀ (s : String) (p : s.Pos) (res : Lean.Name) (n : ℕ),
Lean.Name.demangleAux.decodeNum✝ s p res n =
if h : p = s.endPos then res.num n
else
have ch := p.get h;
have p := p.next h;
if ch.isDigit = true then Lean.Name.demangleAux.decodeNum✝ s p res (n * 10 + (ch.val - 48).toNat)
else
... | null | true |
Simps.structureExt | Mathlib.Tactic.Simps.Basic | Lean.NameMapExtension (List Lean.Name × Array Simps.ProjectionData) | The `Simps.structureExt` environment extension specifies the preferred projections of the given
structure, used by the `@[simps]` attribute.
- You can generate this with the command `initialize_simps_projections`.
- If not generated, the `@[simps]` attribute will generate this automatically.
- To change the default val... | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.open._regBuiltin.Lean.Parser.Command.openRenaming.parenthesizer_47 | Lean.Parser.Command | IO Unit | null | false |
Lean.Doc.Parser.BlockCtxt.mk.injEq | Lean.DocString.Parser | ∀ (minIndent : ℕ) (maxDirective : Option ℕ) (inLists : List Lean.Doc.Parser.InList) (docStartPosition : Lean.Position)
(baseColumn minIndent_1 : ℕ) (maxDirective_1 : Option ℕ) (inLists_1 : List Lean.Doc.Parser.InList)
(docStartPosition_1 : Lean.Position) (baseColumn_1 : ℕ),
({ minIndent := minIndent, maxDirective... | null | true |
_private.Mathlib.Data.Set.Card.0.Set.eq_insert_of_ncard_eq_succ._simp_1_3 | Mathlib.Data.Set.Card | ∀ {α : Type u} {s : Set α} {a : α} (hs : s.Finite), (a ∈ hs.toFinset) = (a ∈ s) | null | false |
Std.DTreeMap.Internal.Impl.filterMap!.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : Ord α] (f : (a : α) → β a → Option (γ a)),
Std.DTreeMap.Internal.Impl.filterMap! f Std.DTreeMap.Internal.Impl.leaf = Std.DTreeMap.Internal.Impl.leaf | null | true |
_private.Mathlib.Analysis.Asymptotics.Lemmas.0.Asymptotics.isBigOWith_pi._simp_1_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {c : ℝ} {f : α → E} {g : α → F} {l : Filter α} [inst : Norm E]
[inst_1 : Norm F], Asymptotics.IsBigOWith c l f g = ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ | null | false |
Std.TreeMap.getKey?_insertManyIfNewUnit_list_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeMap α Unit cmp} [Std.TransCmp cmp] {l : List α} {k : α},
k ∈ t → (t.insertManyIfNewUnit l).getKey? k = t.getKey? k | null | true |
AddAction.nsmul_mod_period_vadd | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type v} {M : Type u} [inst : AddMonoid M] [inst_1 : AddAction M α] (n : ℕ) {m : M} {a : α},
(n % AddAction.period m a) • m +ᵥ a = n • m +ᵥ a | null | true |
CategoryTheory.Abelian.SpectralObject.EIsoH._auto_3 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
CategoryTheory.Limits.preservesLimit_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (K : CategoryTheory.Functor J C)
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesColimit K.op F.leftOp],
CategoryTheo... | If `F.leftOp : Cᵒᵖ ⥤ D` preserves colimits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F : C ⥤ Dᵒᵖ` preserves
limits of `K : J ⥤ C`. | true |
Std.ExtTreeMap.contains_erase | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k a : α},
(t.erase k).contains a = (cmp k a != Ordering.eq && t.contains a) | null | true |
Std.ExtDHashMap.Const.getD_congr | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a b : α} {fallback : β},
(a == b) = true → Std.ExtDHashMap.Const.getD m a fallback = Std.ExtDHashMap.Const.getD m b fallback | null | true |
_aux_Init_Core___unexpand_Iff_1 | Init.Core | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.Join.inclRightCompOpEquivInverse_hom_app_op | Mathlib.CategoryTheory.Join.Opposites | ∀ {C : Type u₁} (D : Type u₂) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(c : C),
(CategoryTheory.Join.inclRightCompOpEquivInverse C D).hom.app (Opposite.op c) =
CategoryTheory.CategoryStruct.id (Opposite.op (CategoryTheory.Join.left c)) | null | true |
CompactlySupportedContinuousMap.pullback_addMonoidHom._proof_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : AddGroup α]
[inst_2 : TopologicalSpace β] [inst_3 : AddGroup β] [ContinuousAdd β] [inst_5 : NormedAddCommGroup γ] {φ : α →+ β},
Topology.IsClosedEmbedding ⇑φ → ∀ (f : CompactlySupportedContinuousMap β γ) (b : β), Continuous fun a =... | null | false |
CategoryTheory.Oplax.StrongTrans.homCategory_comp_as_app | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {X Y Z : F ⟶ G} (Γ : CategoryTheory.Oplax.StrongTrans.Hom X Y)
(Δ : CategoryTheory.Oplax.StrongTrans.Hom Y Z) (a : B),
(CategoryTheory.CategoryStruct.comp Γ Δ).as.app a... | null | true |
Lean.Lsp.CodeActionParams.workDoneToken?._inherited_default | Lean.Data.Lsp.CodeActions | Option Lean.Lsp.ProgressToken | null | false |
_private.Init.Data.String.Basic.0.String.Slice.Pos.cast_lt_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l < r) = (l.offset < r.offset) | null | false |
FiniteDimensional.fintypeBasisIndex | Mathlib.LinearAlgebra.FiniteDimensional.Defs | {K : Type u} →
{V : Type v} →
[inst : DivisionRing K] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module K V] → {ι : Type u_1} → [FiniteDimensional K V] → Module.Basis ι K V → Fintype ι | If a vector space is `FiniteDimensional`, all bases are indexed by a finite type | true |
CommMonCat.Hom.ext_iff | Mathlib.Algebra.Category.MonCat.Basic | ∀ {A B : CommMonCat} {x y : A.Hom B}, x = y ↔ x.hom' = y.hom' | null | true |
AlgebraicGeometry.LocallyRingedSpace.residue._proof_1 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ (X : AlgebraicGeometry.LocallyRingedSpace) (x : ↑X.toTopCat),
CategoryTheory.Limits.HasColimit
(((CategoryTheory.Functor.whiskeringLeft (TopologicalSpace.OpenNhds x)ᵒᵖ
(TopologicalSpace.Opens ↑↑X.toPresheafedSpace)ᵒᵖ CommRingCat).obj
(TopologicalSpace.OpenNhds.inclusion x).op).obj
... | null | false |
exists_isOpen_superset_and_isCompact_closure | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R1Space X] [WeaklyLocallyCompactSpace X] {K : Set X},
IsCompact K → ∃ V, IsOpen V ∧ K ⊆ V ∧ IsCompact (closure V) | In a weakly locally compact R₁ space,
every compact set has an open neighborhood with compact closure. | true |
Std.DHashMap.isEmpty_ofList | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)}, (Std.DHashMap.ofList l).isEmpty = l.isEmpty | null | true |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.collectUsedOrigins.match_1 | Lean.Meta.Tactic.Grind.Main | (motive : Id (Unit × Std.HashSet Lean.Meta.Sym.ExprPtr × Std.HashSet Lean.Meta.Grind.Origin) → Sort u_1) →
(x : Id (Unit × Std.HashSet Lean.Meta.Sym.ExprPtr × Std.HashSet Lean.Meta.Grind.Origin)) →
((fst : Unit) → (s : Std.HashSet Lean.Meta.Sym.ExprPtr × Std.HashSet Lean.Meta.Grind.Origin) → motive (fst, s)) →
... | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minEntry.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (x : Std.DTreeMap.Internal.Impl α β) → x.isEmpty = false → Sort u_3)
(size : ℕ) (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β)
(x : (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r).isEmpty = false)
(h_1 :
(size : ℕ) →
(k ... | null | true |
_private.Lean.Elab.Tactic.Grind.Config.0.Lean.Elab.Tactic.instEvalExprOrderConfig.evalExpr | Lean.Elab.Tactic.Grind.Config | Lean.Expr → Lean.MetaM Lean.Grind.OrderConfig | null | true |
Module.End.invtSubmodule.disjoint_mk_iff | Mathlib.Algebra.Module.Submodule.Invariant | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f : Module.End R M) {p q : Submodule R M} (hp : p ∈ f.invtSubmodule) (hq : q ∈ f.invtSubmodule),
Disjoint ⟨p, hp⟩ ⟨q, hq⟩ ↔ Disjoint p q | null | true |
ScottContinuousOn.mono | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {D₁ D₂ : Set (Set α)} {f : α → β},
D₁ ⊆ D₂ → ScottContinuousOn D₂ f → ScottContinuousOn D₁ f | null | true |
Empty | Init.Prelude | Type | The empty type. It has no constructors.
Use `Empty.elim` in contexts where a value of type `Empty` is in scope.
| true |
MeasureTheory.limsup_trim | Mathlib.MeasureTheory.Function.LpSeminorm.Trim | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0) {f : α → ENNReal},
Measurable f → Filter.limsup f (MeasureTheory.ae (μ.trim hm)) = Filter.limsup f (MeasureTheory.ae μ) | null | true |
CompHausLike.instFullTopCatCompHausLikeToTop | Mathlib.Topology.Category.CompHausLike.Basic | ∀ (P : TopCat → Prop), (CompHausLike.compHausLikeToTop P).Full | null | true |
Finset.cast_divConst_mul_card | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {𝕜 : Type u_2} [inst_2 : Semifield 𝕜] [CharZero 𝕜]
(A B : Finset G), ↑(A.divConst B) * ↑A.card = ↑(A / B).card | null | true |
Lake.StdVer.noConfusion | Lake.Util.Version | {P : Sort u} → {t t' : Lake.StdVer} → t = t' → Lake.StdVer.noConfusionType P t t' | null | false |
_private.Mathlib.CategoryTheory.Galois.Decomposition.0.CategoryTheory.PreGaloisCategory.has_decomp_connected_components_aux_initial._simp_1_1 | Mathlib.CategoryTheory.Galois.Decomposition | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∀ (a : α), p a) = True | null | false |
_private.Mathlib.GroupTheory.Perm.Sign.0.Equiv.Perm.ofSign_disjUnion._simp_1_1 | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u_5} {s t : Finset α} {h : Disjoint s t} {a : α}, (a ∈ s.disjUnion t h) = (a ∈ s ∨ a ∈ t) | null | false |
Lean.Meta.getUnusedUserNames | Batteries.Lean.Meta.UnusedNames | {m : Type → Type} → [Monad m] → [Lean.MonadLCtx m] → ℕ → Lean.Name → m (Array Lean.Name) | Obtain `n` distinct names such that each name is unused in the current local
context and `suggestion` is a prefix of each name.
| true |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory.IsFundamentalDomain.measure_ne_zero._simp_1_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
Std.Sat.AIG.Fanin.rec | Std.Sat.AIG.Basic | {motive : Std.Sat.AIG.Fanin → Sort u} → ((val : ℕ) → motive { val := val }) → (t : Std.Sat.AIG.Fanin) → motive t | null | false |
Partition._sizeOf_1 | Mathlib.Order.Partition.Basic | {α : Type u_1} → {inst : CompleteLattice α} → {s : α} → [SizeOf α] → Partition s → ℕ | null | false |
HomologicalComplex.dNatTrans | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
(V : Type u) →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
(c : ComplexShape ι) → (i j : ι) → HomologicalComplex.eval V c i ⟶ HomologicalComplex.eval V c j | The differential as a natural transformation between `eval`. | true |
RingCat.of.noConfusion | Mathlib.Algebra.Category.Ring.Basic | {P : Sort u_1} →
{carrier : Type u} →
{ring : Ring carrier} →
{carrier' : Type u} → {ring' : Ring carrier'} → ↧carrier = ↧carrier' → (carrier = carrier' → ring ≍ ring' → P) → P | null | false |
CategoryTheory.InjectiveResolution.descHomotopyZero | Mathlib.CategoryTheory.Abelian.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{Y Z : C} →
{I : CategoryTheory.InjectiveResolution Y} →
{J : CategoryTheory.InjectiveResolution Z} →
(f : I.cocomplex ⟶ J.cocomplex) → CategoryTheory.CategoryStruct.comp I.ι f = 0 ... | Any descent of the zero morphism is homotopic to zero. | true |
_private.Mathlib.GroupTheory.Coset.Basic.0.leftCoset_assoc._simp_1_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] {t : Set β} {a : α}, a • t = (fun x => a • x) '' t | null | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.withAutoBoundImplicit.loop.match_1 | Lean.Elab.Term.TermElabM | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → ((n : Lean.Name) → motive (some n)) → (Unit → motive none) → motive x | null | false |
WithCStarModule.instModule._proof_1 | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ (R : Type u_3) (A : Type u_1) (E : Type u_2) [inst : Semiring R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(x y : R) (b : WithCStarModule A E), (x * y) • b = x • y • b | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.