name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AlgebraicGeometry.coprodMk._proof_2 | Mathlib.AlgebraicGeometry.Limits | ∀ (X Y : AlgebraicGeometry.Scheme),
CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.pair X Y) AlgebraicGeometry.Scheme.forgetToTop | null | false |
CategoryTheory.AddGrpObj.neg_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G H X : C} [inst_2 : CategoryTheory.AddGrpObj G] [inst_3 : CategoryTheory.AddGrpObj H] (f : X ⟶ G) (g : G ⟶ H)
[CategoryTheory.IsAddMonHom g], CategoryTheory.CategoryStruct.comp (-f) g = -CategoryTheory.C... | null | true |
Mathlib.Tactic.Monoidal.instMonadMor₁MonoidalM._sparseCasesOn_1 | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Filter.lift'_bot | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {h : Set α → Set β}, Monotone h → ⊥.lift' h = Filter.principal (h ∅) | null | true |
mulMonoidHom._proof_2 | Mathlib.Algebra.Group.Prod | ∀ {α : Type u_1} [inst : CommMonoid α] (x y : α × α), mulMulHom.toFun (x * y) = mulMulHom.toFun x * mulMulHom.toFun y | null | false |
_private.Mathlib.CategoryTheory.MorphismProperty.Composition.0.CategoryTheory.MorphismProperty.ContainsIdentities.iff_identities_le.match_1_1 | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] ⦃X : C⦄
(motive : (Y : C) → (f : X ⟶ Y) → CategoryTheory.MorphismProperty.identities C f → Prop) (Y : C) (f : X ⟶ Y)
(h : CategoryTheory.MorphismProperty.identities C f),
(∀ (_ : Unit), motive X (CategoryTheory.CategoryStruct.id X) ⋯) → motive Y f h | null | false |
CategoryTheory.Limits.IsColimit.descCoconeMorphism_eq_isInitial_to | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(s : CategoryTheory.Limits.Cocone F), hc.descCoconeMorphism s = (c.isColimitEquivIsIn... | null | true |
MvPowerSeries.substAlgHom_X | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {τ : Type u_4} {S : Type u_5} [inst_1 : CommRing S]
[inst_2 : Algebra R S] {a : σ → MvPowerSeries τ S} (ha : MvPowerSeries.HasSubst a) (s : σ),
(MvPowerSeries.substAlgHom ha) (MvPowerSeries.X s) = a s | null | true |
Ring.uniformContinuousConstSMul_op | Mathlib.Topology.Algebra.UniformMulAction | ∀ (R : Type u) [inst : Ring R] [inst_1 : UniformSpace R] [IsUniformAddGroup R] [ContinuousMul R],
UniformContinuousConstSMul Rᵐᵒᵖ R | The action of `Semiring.toOppositeModule` is uniformly continuous. | true |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.isComplement_subgroup_left_iff_existsUnique_quotientMk''._simp_1_4 | Mathlib.GroupTheory.Complement | ∀ {α : Sort u_1} {s₁ : Setoid α} {a b : α}, s₁ a b = (Quotient.mk'' a = Quotient.mk'' b) | null | false |
IsUniformEmbedding.nonemptyCompacts_map | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β}
(hf : IsUniformEmbedding f), IsUniformEmbedding (TopologicalSpace.NonemptyCompacts.map f ⋯) | null | true |
Path.mul_apply | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : Mul X] [inst_2 : ContinuousMul X] {a₁ b₁ a₂ b₂ : X}
(γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) (a : ↑unitInterval), (γ₁.mul γ₂) a = γ₁ a * γ₂ a | null | true |
CategoryTheory.SimplicialThickening.mk.noConfusion | Mathlib.AlgebraicTopology.SimplicialNerve | {J : Type u_1} →
{inst : LinearOrder J} → {P : Sort u} → {as as' : J} → { as := as } = { as := as' } → (as ≍ as' → P) → P | null | false |
Array.getElem?_setIfInBounds_self_of_lt | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α}, i < xs.size → (xs.setIfInBounds i a)[i]? = some a | null | true |
IsOfFinOrder.natCard_powers_le_orderOf | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G] {a : G}, IsOfFinOrder a → Nat.card ↑↑(Submonoid.powers a) ≤ orderOf a | null | true |
AlgebraicGeometry.Scheme.Pullback.SpecTensorTo_SpecOfPoint | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (t : ↥(CategoryTheory.Limits.pullback f g)),
(AlgebraicGeometry.Scheme.Pullback.Triplet.ofPoint t).SpecTensorTo (AlgebraicGeometry.Scheme.Pullback.SpecOfPoint t) =
t | null | true |
CategoryTheory.Pretriangulated.Opposite.instAdditiveOppositeShiftFunctorInt | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Preadditive C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (n : ℤ),
(CategoryTheory.shiftFunctor Cᵒᵖ n).Additive | null | true |
ContinuousMultilinearMap.apply._proof_3 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ (𝕜 : Type u_1) {ι : Type u_2} (E : ι → Type u_3) (F : Type u_4) [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopological... | null | false |
CategoryTheory.StructuredArrow.faithful_map₂ | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {L : D} {R : CategoryTheory.Functor C D} {L' : B}
{R' : CategoryTheory.Fun... | null | true |
CategoryTheory.Functor.Final.colimitCoconeOfComp | Mathlib.CategoryTheory.Limits.Final | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[F.Final] →
{E : Type u₃} →
[inst_3 : CategoryTheory.Category.{v₃, u₃} E] →
{G : Catego... | Given a colimit cocone over `F ⋙ G` we can construct a colimit cocone over `G`. | true |
RandGT | Mathlib.Control.Random | Type → (Type u_1 → Type u_2) → Type u_1 → Type (max u_1 u_2) | A monad transformer to generate random objects using the generic generator type `g` | true |
Filter.EventuallyEq.fun_const_vadd | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_2} [inst : VAdd γ β] {f g : α → β} {l : Filter α},
f =ᶠ[l] g → ∀ (c : γ), (fun i => c +ᵥ f i) =ᶠ[l] fun i => c +ᵥ g i | Eta-expanded form of `Filter.EventuallyEq.const_vadd` | true |
OrderIso.preimage_Ici | Mathlib.Order.Interval.Set.OrderIso | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (b : β),
⇑e ⁻¹' Set.Ici b = Set.Ici (e.symm b) | null | true |
Lean.Elab.FixedParamPerms.fixedArePrefix | Lean.Elab.PreDefinition.FixedParams | Lean.Elab.FixedParamPerms → Bool | Are all fixed parameters a non-reordered prefix?
| true |
ByteArray.Iterator.mk | Init.Data.ByteArray.Basic | ByteArray → ℕ → ByteArray.Iterator | null | true |
CategoryTheory.Limits.HasColimit.exists_colimit | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} J} {C : Type u} {inst_1 : CategoryTheory.Category.{v, u} C}
{F : CategoryTheory.Functor J C} [self : CategoryTheory.Limits.HasColimit F],
Nonempty (CategoryTheory.Limits.ColimitCocone F) | There exists a colimit for `F` | true |
_private.Mathlib.Data.Nat.Fib.Zeckendorf.0.Nat.zeckendorf_sum_fib._simp_1_4 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ {α : Type u_1} {R : α → α → Prop} {l : List α} [Trans R R R], List.IsChain R l = List.Pairwise R l | null | false |
Lean.Server.RequestHandlerCompleteness.noConfusion | Lean.Server.Requests | {P : Sort u} →
{t t' : Lean.Server.RequestHandlerCompleteness} →
t = t' → Lean.Server.RequestHandlerCompleteness.noConfusionType P t t' | null | false |
_private.Std.Do.WP.Sound.0.Std.Do.PredTrans.pushExcept.match_1.eq_2 | Std.Do.WP.Sound | ∀ {α ε : Type u_1} (motive : Except ε α → Sort u_2) (e : ε) (h_1 : (a : α) → motive (Except.ok a))
(h_2 : (e : ε) → motive (Except.error e)),
(match Except.error e with
| Except.ok a => h_1 a
| Except.error e => h_2 e) =
h_2 e | null | true |
Lean.Meta.etaStruct? | Lean.Meta.Structure | Lean.Expr → (Lean.Name → Bool) → Lean.MetaM (Option Lean.Expr) | Checks if the expression is of the form `S.mk x.1 ... x.n` with `n` nonzero
and `S.mk` a structure constructor with `S` one of the recorded structure parents.
Returns `x`.
Each projection `x.i` can be either a native projection or from a projection function.
| true |
Int.blt' | Init.Data.Int.Basic | ℤ → ℤ → Bool | `x < y` for kernel reduction. | true |
NonarchAddGroupNorm.apply_one | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] [inst_1 : DecidableEq E] (x : E), 1 x = if x = 0 then 0 else 1 | null | true |
AddGrpCat.hom_comp | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y T : AddGrpCat} (f : X ⟶ Y) (g : Y ⟶ T),
AddGrpCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (AddGrpCat.Hom.hom g).comp (AddGrpCat.Hom.hom f) | null | true |
AddSubgroup.toAddSubmonoid_le._simp_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {p q : AddSubgroup G}, (p.toAddSubmonoid ≤ q.toAddSubmonoid) = (p ≤ q) | null | false |
Lean.Compiler.LCNF.Phase | Lean.Compiler.LCNF.CompilerM | Type | The pipeline phase a certain `Pass` is supposed to happen in.
| true |
CategoryTheory.Limits.Bicone._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
(F : J → C) → [SizeOf J] → [SizeOf C] → SizeOf (CategoryTheory.Limits.Bicone F) | null | false |
String.Pos.splits_append_rawEndPos | Init.Data.String.Lemmas.Splits | ∀ {s t : String}, ((s ++ t).pos s.rawEndPos ⋯).Splits s t | null | true |
CategoryTheory.Limits.splitMonoOfIdempotentEqualizer | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
{f : X ⟶ X} →
CategoryTheory.CategoryStruct.comp f f = f →
[inst_1 : CategoryTheory.Limits.HasEqualizer (CategoryTheory.CategoryStruct.id X) f] →
CategoryTheory.SplitMono (CategoryTheory.Limits.equalizer.ι (Ca... | The equalizer of an idempotent morphism and the identity is split mono. | true |
PUnit.instMulAction | Mathlib.Algebra.Module.PUnit | {R : Type u_1} → MulAction PUnit.{u_3 + 1} R | null | true |
Sublattice.coe_inf._simp_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L : Sublattice α} (a b : ↥L), ↑a ⊓ ↑b = ↑(a ⊓ b) | null | false |
Algebra.IsIntegral.isAlgebraic_iff_top | Mathlib.RingTheory.Algebraic.Integral | ∀ (R : Type u_1) (S : Type u_2) {A : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A] [NoZeroDivisors S]
[Algebra.IsIntegral R S] [FaithfulSMul R S], Algebra.IsAlgebraic R A ↔ Algebra.IsAlgebraic S A | null | true |
GaloisConnection.le_iff_le | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
GaloisConnection l u → ∀ {a : α} {b : β}, l a ≤ b ↔ a ≤ u b | null | true |
AddGroupNorm.ctorIdx | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} → {inst : AddGroup G} → AddGroupNorm G → ℕ | null | false |
String.revFind_of_valid | Batteries.Data.String.Lemmas | ∀ (p : Char → Bool) (s : String),
String.Legacy.revFind s p =
Option.map (fun x => { byteIdx := String.utf8Len x }) (List.dropWhile (fun x => !p x) s.toList.reverse).tail? | null | true |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.evaln.match_1.eq_8 | Mathlib.Computability.PartrecCode | ∀ (motive : ℕ → Nat.Partrec.Code → Sort u_1) (k : ℕ) (cf cg : Nat.Partrec.Code)
(h_1 : (x : Nat.Partrec.Code) → motive 0 x) (h_2 : (k : ℕ) → motive k.succ Nat.Partrec.Code.zero)
(h_3 : (k : ℕ) → motive k.succ Nat.Partrec.Code.succ) (h_4 : (k : ℕ) → motive k.succ Nat.Partrec.Code.left)
(h_5 : (k : ℕ) → motive k.su... | null | true |
CategoryTheory.SmallObject.restrictionLE | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : PartialOrder J] →
{j : J} → CategoryTheory.Functor (↑(Set.Iic j)) C → {i : J} → i ≤ j → CategoryTheory.Functor (↑(Set.Iic i)) C | The functor `Set.Iic i ⥤ C` obtained by "restriction" of `F : Set.Iic j ⥤ C`
when `i ≤ j`. | true |
Monoid.Coprod.range_swap | Mathlib.GroupTheory.Coprod.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H], (Monoid.Coprod.swap G H).range = ⊤ | null | true |
_private.Mathlib.Tactic.Echelon.Cert.0.Mathlib.Tactic.Echelon.certifyDecomposition._proof_2 | Mathlib.Tactic.Echelon.Cert | ∀ {u : Lean.Level} {α : Q(Type u)} (rα : Q(CommRing «$α»)) (aα : Q(Add «$α»))
(__defeqres : PLift («$aα» =Q instDistribOfSemiring.toAdd)), «$aα» =Q instDistribOfSemiring.toAdd | null | false |
CategoryTheory.eHomFunctor_map_app | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | ∀ (V : Type u') [inst : CategoryTheory.Category.{v', u'} V] [inst_1 : CategoryTheory.MonoidalCategory V] (C : Type u)
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] {X Y : Cᵒᵖ}
(φ : X ⟶ Y) (Y_1 : C), ((CategoryTheory.eHomFunctor V C).map φ).app Y_1 = CategoryTheor... | null | true |
Submodule.map_eq_range_iff | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {p : Submodule R M},
Submodule.map f p... | null | true |
Matrix.empty_eq | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} (v : Fin 0 → α), v = ![] | null | true |
CategoryTheory.Dial.Hom.mk.sizeOf_spec | Mathlib.CategoryTheory.Dialectica.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X Y : CategoryTheory.Dial C} [inst_3 : SizeOf C] (f : X.src ⟶ Y.src)
(F : X.src ⨯ Y.tgt ⟶ X.tgt)
(le :
(CategoryTheory.Subobject.pullback (CategoryTheo... | null | true |
Int.fib_two_mul | Mathlib.Data.Int.Fib.Basic | ∀ (n : ℤ), Int.fib (2 * n) = Int.fib n * (2 * Int.fib (n + 1) - Int.fib n) | null | true |
DerivedCategory.Plus.instEssSurjArrowPlusMapArrowQh | Mathlib.Algebra.Homology.DerivedCategory.Plus | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C], DerivedCategory.Plus.Qh.mapArrow.EssSurj | null | true |
Topology._aux_Mathlib_Topology_Defs_Basic___macroRules_Topology_IsOpen_of_1 | Mathlib.Topology.Defs.Basic | Lean.Macro | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isDefEqOffset.match_1 | Lean.Meta.Sym.Pattern | (motive : OptionT Id Lean.Meta.Sym.Offset → Sort u_1) →
(x : OptionT Id Lean.Meta.Sym.Offset) →
((s' : Lean.Expr) → (k₂ : ℕ) → motive (some (Lean.Meta.Sym.Offset.add s' k₂))) →
((x : OptionT Id Lean.Meta.Sym.Offset) → motive x) → motive x | null | false |
IsTensorProduct.map_injective_of_flat_left_right | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {M₁ : Type u_4} {M₂ : Type u_5} {N₁ : Type u_6}
{N₂ : Type u_7} [inst_5 : AddCommMonoid M₁] [inst_6 : AddCommMonoid M₂] [inst_7 : Module R M₁] [ins... | If `M₁` and `N₂` are flat `R`-modules, `i₁ : M₁ →ₗ[R] N₁` and `i₂ : M₂ →ₗ[R] N₂` are injective
linear maps, then the linear map `i : M ≅ M₁ ⊗[R] M₂ →ₗ[R] N₁ ⊗[R] N₂ ≅ N` induced by `i₁`
and `i₂` is injective.
See `IsTensorProduct.map_injective_of_flat` for different flatness conditions. | true |
_private.Init.Data.SInt.Lemmas.0.Int64.ofNat_add._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int64.ofNat n = Int64.ofInt ↑n | null | false |
Std.TreeMap.Raw.mem_ofList._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (k ∈ Std.TreeMap.Raw.ofList l cmp) = ((List.map Prod.fst l).contains k = true) | null | false |
List.maxOn_mem | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {xs : List α} {f : α → β} {h : xs ≠ []},
List.maxOn f xs h ∈ xs | null | true |
AddSubmonoid.mem_comap | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {S : AddSubmonoid N} {f : F} {x : M},
x ∈ AddSubmonoid.comap f S ↔ f x ∈ S | null | true |
CategoryTheory.Functor.instAdditiveTypeSigmaConst | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasCoproducts C], CategoryTheory.Limits.sigmaConst.Additive | null | true |
Mathlib.Tactic.Algebra.BaseType.mk.inj | Mathlib.Tactic.Algebra.Basic | ∀ {u v : Lean.Level} {R : Q(Type u)} {A : Q(Type v)} {sR : Q(CommSemiring «$R»)} {sA : Q(CommSemiring «$A»)}
{sAlg : Q(Algebra «$R» «$A»)} {r : Q(«$R»)} {x x_1 : Mathlib.Tactic.Ring.ExSum q(«$sR») r},
Mathlib.Tactic.Algebra.BaseType.mk r x = Mathlib.Tactic.Algebra.BaseType.mk r x_1 → x = x_1 | null | true |
hasSum_of_subseq_of_summable | Mathlib.Analysis.Normed.Group.InfiniteSum | ∀ {ι : Type u_1} {α : Type u_2} {E : Type u_3} [inst : SeminormedAddCommGroup E] {f : ι → E},
(Summable fun a => ‖f a‖) →
∀ {s : α → Finset ι} {p : Filter α} [p.NeBot],
Filter.Tendsto s p Filter.atTop → ∀ {a : E}, Filter.Tendsto (fun b => ∑ i ∈ s b, f i) p (nhds a) → HasSum f a | If a function `f` is summable in norm, and along some sequence of finsets exhausting the space
its sum is converging to a limit `a`, then this holds along all finsets, i.e., `f` is summable
with sum `a`. | true |
IsSimpleAddGroup.toNontrivial | Mathlib.GroupTheory.Subgroup.Simple | ∀ {A : Type u_2} {inst : AddGroup A} [self : IsSimpleAddGroup A], Nontrivial A | null | true |
Std.DTreeMap.Internal.Impl.getEntryLE?.go._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} → [Ord α] → α → Option ((a : α) × β a) → Std.DTreeMap.Internal.Impl α β → Option ((a : α) × β a) | null | false |
EStateM.run'_modify | Batteries.Lean.EStateM | ∀ {σ ε : Type u_1} (f : σ → σ) (s : σ), (modify f).run' s = some PUnit.unit | null | true |
List.dedup.eq_1 | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α], List.dedup = List.pwFilter fun x1 x2 => x1 ≠ x2 | null | true |
groupHomology.chainsIso₂ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] → (A : Rep.{u, u, u} k G) → (groupHomology.inhomogeneousChains A).X 2 ≅ ↧(G × G →₀ ↑A) | The 2nd object in the complex of inhomogeneous chains of `A : Rep k G` is isomorphic
to `G² →₀ A` as a `k`-module. | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData.lift._proof_1 | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y}
{f : F.obj ⊥ ⟶ X} {g : c.pt ⟶ Y} [inst_3 : F.IsWellOrderContinuous] {j : J} (hj : Order.IsSuccLimit... | null | false |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.exists_lt_eVariationOn_inter_Icc._simp_1_7 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
Mathlib.Tactic.Order.AtomicFact.isTop.noConfusion | Mathlib.Tactic.Order.CollectFacts | {P : Sort u} →
{idx idx' : ℕ} →
Mathlib.Tactic.Order.AtomicFact.isTop idx = Mathlib.Tactic.Order.AtomicFact.isTop idx' → (idx = idx' → P) → P | null | false |
Ordinal.univ_umax | Mathlib.SetTheory.Ordinal.Univ | Ordinal.univ.{u, max (u + 1) v} = Ordinal.univ.{u, v} | null | true |
AddCommGroup.DirectLimit.hom_ext_iff | Mathlib.Algebra.Colimit.Module | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (G i)]
{f : (i j : ι) → i ≤ j → G i →+ G j} [inst_2 : DecidableEq ι] {P : Type u_4} [inst_3 : AddCommMonoid P]
{g₁ g₂ : AddCommGroup.DirectLimit G f →+ P},
g₁ = g₂ ↔ ∀ (i : ι), g₁.comp (AddCommGroup.DirectLimit.of G f i) = g... | null | true |
MeasureTheory.IsStoppingTime.measurableSpace | Mathlib.Probability.Process.Stopping | {Ω : Type u_1} →
{ι : Type u_3} →
{m : MeasurableSpace Ω} →
[inst : Preorder ι] →
{f : MeasureTheory.Filtration ι m} → {τ : Ω → WithTop ι} → MeasureTheory.IsStoppingTime f τ → MeasurableSpace Ω | The associated σ-algebra with a stopping time. | true |
Lean.Compiler.LCNF.SimpleGroundExpr.array.injEq | Lean.Compiler.LCNF.SimpleGroundExpr | ∀ (elems elems_1 : Array Lean.Compiler.LCNF.SimpleGroundArg),
(Lean.Compiler.LCNF.SimpleGroundExpr.array elems = Lean.Compiler.LCNF.SimpleGroundExpr.array elems_1) =
(elems = elems_1) | null | true |
LinearIndependent.group_smul_iff | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{G : Type u_6} [hG : Group G] [inst_3 : MulAction G R] [inst_4 : MulAction G M] [IsScalarTower G R M]
[SMulCommClass G R M] (v : ι → M) (w : ι → G), LinearIndependent R (w • v) ↔ LinearIndependent R v | null | true |
dvd_gcd_mul_iff_dvd_mul | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] {m n k : α}, k ∣ gcd k m * n ↔ k ∣ m * n | null | true |
Mathlib.Tactic.ITauto.AndKind.eq | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.AndKind | null | true |
Aesop.checkGoalLimit | Aesop.Search.Main | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM Q (Option Lean.MessageData) | null | true |
groupHomology.eq_d₃₂_comp_inv_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) {Z : ModuleCat k}
(h : ↧((Fin 2 → G) →₀ ↑A) ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupHomology.chainsIso₃ A).inv
(CategoryTheory.CategoryStruct.comp
(ChainComplex.of.d (fun n => ↧((Fin n → G) →₀ ↑A)) (fun n => groupHo... | null | true |
Set.mulAction._proof_1 | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : Monoid α] [inst_1 : MulAction α β] (s : Set β), (fun x2 => 1 • x2) '' s = s | null | false |
Lean.Lsp.TextDocumentContentChangeEvent.casesOn | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentContentChangeEvent → Sort u} →
(t : Lean.Lsp.TextDocumentContentChangeEvent) →
((range : Lean.Lsp.Range) →
(text : String) → motive (Lean.Lsp.TextDocumentContentChangeEvent.rangeChange range text)) →
((text : String) → motive (Lean.Lsp.TextDocumentContentChangeEvent.fu... | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Mon.0.CategoryTheory.Functor.FullyFaithful.isMonHom_preimage._simp_4 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {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} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.MonObj X],
Ca... | null | false |
FGAlgCat.equivUnder._proof_9 | Mathlib.Algebra.Category.CommAlgCat.FiniteType | ∀ (R : CommRingCat)
(A : (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => RingHom.FiniteType).Under ⊤ R),
RingHom.toMorphismProperty (fun {R S} [CommRing R] [CommRing S] => RingHom.FiniteType) A.hom | null | false |
Ordnode.instSingleton | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Singleton α (Ordnode α) | null | true |
Std.ExtHashMap.getThenInsertIfNew?_snd | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {v : β}, (m.getThenInsertIfNew? k v).2 = m.insertIfNew k v | null | true |
MDifferentiable.div | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {F' : Type u_17} [inst_6 : NormedDivisi... | null | true |
Lean.Elab.PreDefinition.ref | Lean.Elab.PreDefinition.Basic | Lean.Elab.PreDefinition → Lean.Syntax | null | true |
SimpleGraph.IsAcyclic.isPath_iff_isChain | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V},
G.IsAcyclic → ∀ {v w : V} (p : G.Walk v w), p.IsPath ↔ List.IsChain (fun x1 x2 => x1 ≠ x2) p.edges | null | true |
Set.smulCommClass_set'' | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SMul α γ] [inst_1 : SMul β γ] [SMulCommClass α β γ],
SMulCommClass (Set α) β (Set γ) | null | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Basic.0.Finset.prod_involution._proof_1_6 | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_2} {M : Type u_1} [inst : CommMonoid M] {f : ι → M} (s : Finset ι) (g : (a : ι) → a ∈ s → ι),
(∀ (a : ι) (ha : a ∈ s), f a * f (g a ha) = 1) →
∀ (g_mem : ∀ (a : ι) (ha : a ∈ s), g a ha ∈ s),
(∀ (a : ι) (ha : a ∈ s), g (g a ha) ⋯ = a) → ∀ (x : ι) (hx : x ∈ s), g x hx ≠ x → ∏ x ∈ {x, g x hx}, f ... | null | false |
CategoryTheory.Profunctor.whiskerRight_app_app | Mathlib.CategoryTheory.Profunctor.Comp | ∀ {C D E : Type u} [inst : CategoryTheory.Category.{v_1, u} C] [inst_1 : CategoryTheory.Category.{v_2, u} D]
[inst_2 : CategoryTheory.Category.{v_3, u} E] {P Q : CategoryTheory.Profunctor.{max u w, v_1, v_2, u, u} C D}
(R : CategoryTheory.Profunctor.{max u w, v_2, v_3, u, u} D E) (f : P ⟶ Q) (X : C) (Y : Eᵒᵖ),
((... | null | true |
_private.Mathlib.Topology.Compactness.Compact.0.isCompact_iff_ultrafilter_le_nhds'._simp_1_1 | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
IsCompact s = ∀ (f : Ultrafilter X), ↑f ≤ Filter.principal s → ∃ x ∈ s, ↑f ≤ nhds x | null | false |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.not_isNilpotent_one.match_1_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_1} [inst : MonoidWithZero R] (motive : IsNilpotent 1 → Prop) (x : IsNilpotent 1),
(∀ (w : ℕ) (H : 1 ^ w = 0), motive ⋯) → motive x | null | false |
Algebra.TensorProduct.piRightHom_mul | Mathlib.RingTheory.TensorProduct.Pi | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] {ι : Type u_4}
{B : ι → Type u_5} [inst_7 : (i : ι) → Semiring (B i)] [inst_8 : (i : ι) → Algebra... | null | true |
IsLocalRing.isRegular_of_perm | Mathlib.RingTheory.Regular.RegularSequence | ∀ {R : Type u_1} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsLocalRing R]
[IsNoetherian R M] {rs rs' : List R},
RingTheory.Sequence.IsRegular M rs → rs.Perm rs' → RingTheory.Sequence.IsRegular M rs' | null | true |
_private.Mathlib.Topology.Maps.Basic.0.Topology.isQuotientMap_iff_isClosed._simp_1_4 | Mathlib.Topology.Maps.Basic | ∀ {a b : Prop}, (a ↔ b) = (b ↔ a) | null | false |
CategoryTheory.Limits.IsInitial.orderBot | Mathlib.CategoryTheory.Limits.Preorder | {C : Type u} → [inst : Preorder C] → {X : C} → CategoryTheory.Limits.IsInitial X → OrderBot C | An initial object in a preorder `C` is bottom element for `C`. | true |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.Raw₀.Const.getThenInsertIfNew?.eq_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (a : α) (b : β) (size : ℕ)
(buckets : Array (Std.DHashMap.Internal.AssocList α fun x => β))
(hm : 0 < { size := size, buckets := buckets }.buckets.size),
Std.DHashMap.Internal.Raw₀.Const.getThenInsertIfNew? ⟨{ size := size, buckets := buckets }, hm⟩... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.