name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
GroupTopology.coinduced | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u_1} → {β : Type u_2} → [t : TopologicalSpace α] → [inst : Group β] → (α → β) → GroupTopology β | Given `f : α → β` and a topology on `α`, the coinduced group topology on `β` is the finest
topology such that `f` is continuous and `β` is a topological group. | true |
AddMonoidHom.coe_of_map_sub | Mathlib.Algebra.Group.Hom.Basic | ∀ {G : Type u_5} [inst : AddGroup G] {H : Type u_8} [inst_1 : AddGroup H] (f : G → H)
(hf : ∀ (x y : G), f (x - y) = f x - f y), ⇑(AddMonoidHom.ofMapSub f hf) = f | null | true |
_private.Init.Data.List.Lemmas.0.List.length_eq_of_beq.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] (motive : (l₁ l₂ : List α) → (l₁ == l₂) = true → Prop) (l₁ l₂ : List α)
(h : (l₁ == l₂) = true),
(∀ (h : ([] == []) = true), motive [] [] h) →
(∀ (head : α) (tail : List α) (h : ([] == head :: tail) = true), motive [] (head :: tail) h) →
(∀ (head : α) (tail : List α) (h : (... | null | false |
ContDiffMapSupportedIn.seminorm_fderivLM_top | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] {K : TopologicalSpace.Compacts E} {i : ℕ} (f : ContDif... | null | true |
Colex.instPow_1 | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → {β : Type u_2} → [Pow α β] → Pow α (Colex β) | null | true |
PiTensorProduct.ofDFinsuppEquiv | Mathlib.LinearAlgebra.PiTensorProduct.DFinsupp | {R : Type u_1} →
{ι : Type u_2} →
{κ : ι → Type u_3} →
{M : (i : ι) → κ i → Type u_4} →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → (j : κ i) → AddCommMonoid (M i j)] →
[inst_2 : (i : ι) → (j : κ i) → Module R (M i j)] →
[Fintype ι] →
[DecidableE... | The `ι`-ary tensor product distributes over `κ i`-ary finitely supported functions. | true |
CategoryTheory.Functor.Initial.limitConeOfComp_cone | 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) [inst_2 : F.Initial] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
{G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.LimitCone (F.comp G)),... | null | true |
riemannZeta_re_pos_of_one_lt | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {x : ℝ}, 1 < x → 0 < (riemannZeta ↑x).re | The real part of the Riemann zeta function is positive for real arguments greater than 1. | true |
Real.one_le_rpow_of_pos_of_le_one_of_nonpos | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x z : ℝ}, 0 < x → x ≤ 1 → z ≤ 0 → 1 ≤ x ^ z | null | true |
Interval.instUniqueOfIsEmpty._proof_1 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : LE α] [IsEmpty α] (a : Interval α), a = default | null | false |
Module.Invertible.bijective_curry | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} {M : Type v} {N : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N]
[inst_3 : Module R M] [inst_4 : Module R N] (e : TensorProduct R M N ≃ₗ[R] R),
Function.Bijective ⇑(TensorProduct.curry ↑e) | If there is an `R`-isomorphism between `M ⊗[R] N` and `R`,
the induced map `M → Nᵛ` is an isomorphism. | true |
RingHom.rangeRestrictFieldEquiv_apply_symm_apply | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] (f : K →+* L) (x : ↥f.fieldRange),
f (f.rangeRestrictFieldEquiv.symm x) = ↑x | null | true |
ProofWidgets.ExprWithCtx.ci | ProofWidgets.Compat | ProofWidgets.ExprWithCtx → Lean.Elab.ContextInfo | null | true |
Lean.PrettyPrinter.OneLine.State._sizeOf_inst | Lean.PrettyPrinter.Formatter | SizeOf Lean.PrettyPrinter.OneLine.State | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.aux_tendsto_tsum._simp_1_5 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Mathlib.RingTheory.RingHom.OpenImmersion.0.Algebra.IsStandardOpenImmersion.trans.match_1_1 | Mathlib.RingTheory.RingHom.OpenImmersion | ∀ (S : Type u_1) (T : Type u_2) [inst : CommSemiring S] [inst_1 : CommSemiring T] [inst_2 : Algebra S T]
(motive : (∃ r, IsLocalization.Away r T) → Prop) (x : ∃ r, IsLocalization.Away r T),
(∀ (s : S) (h : IsLocalization.Away s T), motive ⋯) → motive x | null | false |
_private.Init.Data.String.Defs.0.String.Pos.Raw.offsetBy_sliceRawEndPos_right._simp_1_1 | Init.Data.String.Defs | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | null | false |
Std.DTreeMap.Internal.Impl.Const.getKey_insertManyIfNewUnit_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] (h : t.WF)
{l : List α} {k : α}
{h' : Std.DTreeMap.Internal.Impl.contains k ↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯) = true}
(contains : k ∈ t), (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfN... | null | true |
NumberField.RingOfIntegers.instFreeInt | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Module.Free ℤ (NumberField.RingOfIntegers K) | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.val_step_filterMap.match_3.splitter | Init.Data.Iterators.Lemmas.Combinators.FilterMap | {α β : Type u_1} →
(motive : Std.IterStep (Std.Iter β) β → Sort u_2) →
(x : Std.IterStep (Std.Iter β) β) →
((it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.Iter β) → motive (Std.IterStep.skip it')) → (Unit → motive Std.IterStep.done) → motive x | null | true |
ContinuousMultilinearMap.toMultilinearMapLinear_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} {R' : Type u_1} {A : Type u_2} [inst : Semiring R']
[inst_1 : Semiring A] [inst_2 : (i : ι) → AddCommMonoid (M₁ i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : (i : ι) → TopologicalSpace (M₁ i)] [inst_5 : TopologicalSpace M₂] [inst_6 : ContinuousAdd M₂]
[inst_7 : (i : ι)... | null | true |
SaturatedAddSubmonoid.instMin.eq_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : AddZeroClass M],
SaturatedAddSubmonoid.instMin M =
{
min := fun s₁ s₂ =>
let __src := s₁.toAddSubmonoid ⊓ s₂.toAddSubmonoid;
{ toAddSubmonoid := __src, addSaturated := ⋯ } } | null | true |
RingNormClass.mk._flat_ctor | Mathlib.Algebra.Order.Hom.RingNorm | ∀ {F : Type u_4} {α : outParam (Type u_5)} {β : outParam (Type u_6)} [inst : NonUnitalNonAssocRing α]
[inst_1 : Semiring β] [inst_2 : PartialOrder β] [inst_3 : FunLike F α β],
(∀ (f : F) (a b : α), f (a + b) ≤ f a + f b) →
(∀ (f : F), f 0 = 0) →
(∀ (f : F) (a : α), f (-a) = f a) →
(∀ (f : F) (a b ... | null | false |
_private.Std.Http.Protocol.H1.Message.0.Std.Http.Protocol.H1.Message.Head.getSize.match_1 | Std.Http.Protocol.H1.Message | (motive : Option (Array Std.Http.Header.Value) → Sort u_1) →
(contentLength : Option (Array Std.Http.Header.Value)) →
((cl : Std.Http.Header.Value) → motive (some #[cl])) →
((val : Array Std.Http.Header.Value) → motive (some val)) → (Unit → motive none) → motive contentLength | null | false |
Multiset.sum_filter_add_sum_filter_not | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {M : Type u_5} [inst : AddCommMonoid M] {s : Multiset M} (p : M → Prop) [inst_1 : DecidablePred p],
(Multiset.filter p s).sum + (Multiset.filter (fun a => ¬p a) s).sum = s.sum | null | true |
groupHomology.mapShortComplexH1._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u_1, u_1, u_1} k G}
{B : Rep.{u_1, u_1, u_1} k H} (f : G →* H) (φ : A ⟶ Rep.res f B),
CategoryTheory.CategoryStruct.comp (groupHomology.chainsMap₁ f φ) (groupHomology.shortComplexH1 B).g =
CategoryTheory.CategoryStruct.comp... | null | false |
WithBot.inhabited | Mathlib.Order.TypeTags | {α : Type u_1} → Inhabited (WithBot α) | null | true |
Finset.image_univ_of_surjective | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq α] [inst_2 : Fintype β] {f : β → α},
Function.Surjective f → Finset.image f Finset.univ = Finset.univ | null | true |
Differentiable.fun_inv._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {R : Type u_4} [inst_3 : NormedDivisionRing R] [inst_4 : NormedAlgebra 𝕜 R] {h : E → R},
Differentiable 𝕜 h → (∀ (x : E), h x ≠ 0) → (Differentiable 𝕜 fun i => (h i)⁻¹) = True | null | false |
UpperHemicontinuous.union | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_3} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → Set β},
UpperHemicontinuous f → UpperHemicontinuous g → UpperHemicontinuous fun x => f x ∪ g x | Pointwise unions of upper hemicontinuous maps are upper hemicontinuous. | true |
ProofWidgets.RpcEncodablePacket._sizeOf_inst._@.ProofWidgets.Component.Basic.1956376046._hygCtx._hyg.1 | ProofWidgets.Component.Basic | SizeOf ProofWidgets.RpcEncodablePacket✝ | null | false |
Finset.vadd_mem_vadd | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : VAdd α β] {s : Finset α} {t : Finset β} {a : α}
{b : β}, a ∈ s → b ∈ t → a +ᵥ b ∈ s +ᵥ t | null | true |
Matrix.instStarMulSubtypeMemSubmonoidSpecialUnitaryGroup._proof_6 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type u_2} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A B : ↥(Matrix.specialUnitaryGroup n α)),
star ↑(A * B) ∈ ↑(Matrix.unitaryGroup n α) ∧ star ↑(A * B) ∈ ↑(MonoidHom.mker Matrix.detMonoidHom) | null | false |
Matrix.IsParabolic | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | {R : Type u_1} → [CommRing R] → Matrix (Fin 2) (Fin 2) R → Prop | A `2 × 2` matrix is *parabolic* if it is non-scalar and its discriminant is 0. | true |
Symbol.terminal.elim | Mathlib.Computability.Language | {T : Type u_4} →
{N : Type u_5} →
{motive : Symbol T N → Sort u} →
(t : Symbol T N) → t.ctorIdx = 0 → ((t : T) → motive (Symbol.terminal t)) → motive t | null | false |
CategoryTheory.AddGrp.instCartesianMonoidalCategory._proof_3 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (G H : CategoryTheory.AddGrp C),
CategoryTheory.AddGrp.homMk' (CategoryTheory.SemiCartesianMonoidalCategory.snd G.toAddMon H.toAddMon) =
CategoryTheory... | null | false |
Sum.elimZeroLeft_apply | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {ι : Type u_6} {κ : Type u_7} {R : Type u_8} [inst : Semiring R] (g : ι → R) (a : κ ⊕ ι),
Sum.elimZeroLeft g a = Sum.elim 0 g a | null | true |
Lean.Lsp.CallHierarchyOutgoingCallsParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{t t' : Lean.Lsp.CallHierarchyOutgoingCallsParams} →
t = t' → Lean.Lsp.CallHierarchyOutgoingCallsParams.noConfusionType P t t' | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.neighborSet_eq_empty._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
Set.Ioi_eq_empty_iff._simp_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (Set.Ioi a = ∅) = IsMax a | null | false |
AddUnits.rightOfAdd._proof_2 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (a b : M), AddCommute a b → AddCommute b a | null | false |
CategoryTheory.Abelian.SpectralObject.dCokernelSequence_exact._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Homology | Lean.Syntax | null | false |
MeasurableSet.coe_insert | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] (a : α) (s : Subtype MeasurableSet),
↑(insert a s) = insert a ↑s | null | true |
RestrictedProduct.coeMonoidHom._proof_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} {R : ι → Type u_2} {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)]
(x x_1 : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕), ⇑(x * x_1) = ⇑(x * x_1) | null | false |
PowerSeries.coe_sub | Mathlib.RingTheory.LaurentSeries | ∀ {R' : Type u_2} [inst : Ring R'] (f' g' : PowerSeries R'),
(HahnSeries.ofPowerSeries ℤ R') (f' - g') = (HahnSeries.ofPowerSeries ℤ R') f' - (HahnSeries.ofPowerSeries ℤ R') g' | null | true |
Std.ExtDTreeMap.union | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → Std.ExtDTreeMap α β cmp → Std.ExtDTreeMap α β cmp → Std.ExtDTreeMap α β cmp | Computes the union of the given tree maps. If a key appears in both maps, the entry contained in
the second argument will appear in the result.
This function always merges the smaller map into the larger map.
| true |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.Split.initFn._@.Lean.Meta.Tactic.Split.806046213._hygCtx._hyg.2 | Lean.Meta.Tactic.Split | IO Lean.InternalExceptionId | null | false |
LinearEquiv.rTensor_zpow | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (f : M ≃ₗ[R] M) (n : ℤ),
LinearEquiv.rTensor N f ^ n = LinearEquiv.rTensor N (f ^ n) | null | true |
InnerProductSpace.Core.topology_eq | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[cd : InnerProductSpace.Core 𝕜 F] [tF : TopologicalSpace F] [IsTopologicalAddGroup F] [ContinuousConstSMul 𝕜 F],
ContinuousAt (fun v => inner 𝕜 v v) 0 →
Bornology.IsVonNBounded 𝕜 {v | RCLike.re (inner 𝕜 v v... | In a topological vector space, if the unit ball of a continuous inner product is von Neumann
bounded, then the inner product defines the same topology as the original one. | true |
WithZero.coe_pow._simp_1 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : One α] [inst_1 : Pow α ℕ] (a : α) (n : ℕ), ↑a ^ n = ↑(a ^ n) | null | false |
CategoryTheory.Limits.Types.isColimitOfMulticoequalizerDiagram._simp_9 | Mathlib.CategoryTheory.Limits.Types.Multicoequalizer | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
CategoryTheory.Adjunction.homEquiv_apply | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (X : C) (Y : D) (f : F.obj X ⟶ Y),
(adj.homEquiv X Y) f = CategoryTheory.CategoryStruct.comp (adj.unit.app X) (G.map... | null | true |
Finset.subset_vadd | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : VAdd α β] {u : Finset β} {s : Set α} {t : Set β},
↑u ⊆ s +ᵥ t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' +ᵥ t' | If a finset `u` is contained in the scalar sum of two sets `s +ᵥ t`, we can find two
finsets `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' +ᵥ t'`. | true |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.Indep.fundCircuit_isCircuit._simp_1_2 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Field.DirectLimit.field._proof_3 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : Nonempty ι] [inst_2 : IsDirectedOrder ι]
[inst_3 : (i : ι) → Field (G i)] (f' : (i j : ι) → i ≤ j → G i →+* G j) (n : ℕ)
(a : Ring.DirectLimit G fun x1 x2 x3 => ⇑(f' x1 x2 x3)), a ^ ↑n.succ = a ^ ↑n * a | null | false |
ZFSet.iUnion_vonNeumann | Mathlib.SetTheory.ZFC.VonNeumann | ⋃ o, ↑(ZFSet.vonNeumann o) = Set.univ | null | true |
Finset.empty_eq_image._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α}, (∅ = Finset.image f s) = (s = ∅) | null | false |
ContinuousAlternatingMap.piLinearEquiv._proof_2 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {ι' : Type u_2} {M' : ι' → Type u_3} [inst_1 : (i : ι') → AddCommMonoid (M' i)]
[inst_2 : (i : ι') → TopologicalSpace (M' i)] [inst_3 : (i : ι') → Module R (M' i)]
[∀ (i : ι'), ContinuousConstSMul R (M' i)], ContinuousConstSMul R ((i : ι') → M' i) | null | false |
AddSubgroup.prod | Mathlib.Algebra.Group.Subgroup.Basic | {G : Type u_1} →
[inst : AddGroup G] → {N : Type u_4} → [inst_1 : AddGroup N] → AddSubgroup G → AddSubgroup N → AddSubgroup (G × N) | Given `AddSubgroup`s `H`, `K` of `AddGroup`s `A`, `B` respectively, `H × K`
as an `AddSubgroup` of `A × B`. | true |
AddLECancellable.tsub_lt_tsub_iff_left_of_le | Mathlib.Algebra.Order.Sub.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [CanonicallyOrderedAdd α] [inst_3 : Sub α]
[OrderedSub α] {a b c : α}, AddLECancellable a → AddLECancellable b → b ≤ a → (a - b < a - c ↔ c < b) | See `lt_tsub_iff_left_of_le_of_le` for a weaker statement in a partial order. | true |
CategoryTheory.Pi.closedUnit | Mathlib.CategoryTheory.Pi.Monoidal | {I : Type w₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] →
[inst_2 : (i : I) → CategoryTheory.MonoidalClosed (C i)] →
(X : (i : I) → C i) →
CategoryTheory.Functor.id ((i : I) → C i... | The unit for the adjunction `tensorLeft X ⊣ ihom X`. | true |
String.Pos.Raw.extract.go₂._sunfold | Init.Data.String.Basic | List Char → String.Pos.Raw → String.Pos.Raw → List Char | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Checker.0.Std.Tactic.BVDecide.LRAT.Internal.check.go._unary.eq_def | Std.Tactic.BVDecide.LRAT.Internal.Checker | ∀ (proof : Array Std.Tactic.BVDecide.LRAT.IntAction) (_x : (_ : Std.Tactic.BVDecide.LRAT.Internal.State) ×' ℕ),
Std.Tactic.BVDecide.LRAT.Internal.check.go._unary✝ proof _x =
PSigma.casesOn _x fun state idx =>
if h : idx < proof.size then
have step := proof[idx];
match step with
| Std... | null | false |
MeasureTheory.Measure.comap | Mathlib.MeasureTheory.Measure.Comap | {α : Type u_1} →
{β : Type u_2} →
[inst : MeasurableSpace α] →
[inst_1 : MeasurableSpace β] → (α → β) → MeasureTheory.Measure β → MeasureTheory.Measure α | Pullback of a `Measure`. If `f` sends each measurable set to a null-measurable set,
then for each measurable set `s` we have `comap f μ s = μ (f '' s)`.
Note that if `f` is not injective, this definition assigns `Set.univ` measure zero. | true |
IsPGroup.of_equiv | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G], IsPGroup p G → ∀ {H : Type u_2} [inst_1 : Group H] (ϕ : G ≃* H), IsPGroup p H | null | true |
CategoryTheory.CountableCategory.objAsTypeEquiv._proof_1 | Mathlib.CategoryTheory.Countable | ∀ (α : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} α] [inst_1 : CategoryTheory.CountableCategory α],
(CategoryTheory.inducedFunctor ⇑(equivShrink α).symm).IsEquivalence | null | false |
Aesop.getConclusionDiscrTreeKeys | Aesop.Util.Basic | Lean.Expr → Lean.MetaM (Array Lean.Meta.DiscrTree.Key) | null | true |
Function.diag | Mathlib.Logic.Function.Defs | {α : Type u_1} → α → α × α | The diagonal map into `Prod`. | true |
Int.ediv_eq_iff_of_pos | Init.Data.Int.DivMod.Lemmas | ∀ {k x y : ℤ}, 0 < k → (x / k = y ↔ y * k ≤ x ∧ x < y * k + k) | null | true |
CommGrpCat.Hom.casesOn | Mathlib.Algebra.Category.Grp.Basic | {A B : CommGrpCat} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →* ↑B) → motive { hom' := hom' }) → motive t | null | false |
LinearOrderedAddCommGroupWithTop.top_pos._simp_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommGroupWithTop α], (0 < ⊤) = True | null | false |
CategoryTheory.InjectiveResolution.ctorIdx | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroObject C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} → {Z : C} → CategoryTheory.InjectiveResolution Z → ℕ | null | false |
Polynomial.logMahlerMeasure_mul_eq_add_logMahlerMeasure | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {p q : Polynomial ℂ}, p * q ≠ 0 → (p * q).logMahlerMeasure = p.logMahlerMeasure + q.logMahlerMeasure | null | true |
Prod.mk_wcovBy_mk_iff | Mathlib.Order.Cover | ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] {a₁ a₂ : α} {b₁ b₂ : β},
(a₁, b₁) ⩿ (a₂, b₂) ↔ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂ | null | true |
Derivation.mapCoeffs._proof_2 | Mathlib.RingTheory.Derivation.MapCoeffs | ∀ {R : Type u_3} {A : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : AddCommGroup M] [inst_4 : Module A M] [inst_5 : Module R M] (d : Derivation R A M) (p q : Polynomial A),
(PolynomialModule.map A ↑d ∘ₗ ↑PolynomialModule.equivPolynomial.symm) (p * q) =
p • (... | null | false |
_private.Mathlib.Computability.TuringMachine.StackTuringMachine.0.Turing.TM2to1.stRun.match_1.splitter | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_3} →
{k : K} →
(motive : Turing.TM2to1.StAct K Γ σ k → Sort u_4) →
(x : Turing.TM2to1.StAct K Γ σ k) →
((f : σ → Γ k) → motive (Turing.TM2to1.StAct.push f)) →
((f : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StA... | null | true |
AList.extract | Mathlib.Data.List.AList | {α : Type u} → {β : α → Type v} → [DecidableEq α] → (a : α) → AList β → Option (β a) × AList β | Erase a key from the map, and return the corresponding value, if found. | true |
BddDistLat.mk.injEq | Mathlib.Order.Category.BddDistLat | ∀ (toDistLat : DistLat) [isBoundedOrder : BoundedOrder ↑toDistLat] (toDistLat_1 : DistLat)
(isBoundedOrder_1 : BoundedOrder ↑toDistLat_1),
({ toDistLat := toDistLat, isBoundedOrder := isBoundedOrder } =
{ toDistLat := toDistLat_1, isBoundedOrder := isBoundedOrder_1 }) =
(toDistLat = toDistLat_1 ∧ isBounde... | null | true |
Nat.Partrec.Code.const_inj._f | Mathlib.Computability.PartrecCode | ∀ (x : ℕ)
(f : Nat.below (motive := fun x => ∀ (x_1 : ℕ), Nat.Partrec.Code.const x = Nat.Partrec.Code.const x_1 → x = x_1) x)
(x_1 : ℕ), Nat.Partrec.Code.const x = Nat.Partrec.Code.const x_1 → x = x_1 | null | false |
Subgroup.discreteTopology_iff_of_isFiniteRelIndex | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [T2Space G] {H K : Subgroup G},
H ≤ K → ∀ [H.IsFiniteRelIndex K], DiscreteTopology ↥H ↔ DiscreteTopology ↥K | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.Context.ctorIdx | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.UnifyM.Context✝ → ℕ | null | false |
Batteries.HashMap.casesOn | Batteries.Data.HashMap.Basic | {α : Type u} →
{β : Type v} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Batteries.HashMap α β → Sort u_1} →
(t : Batteries.HashMap α β) → ((inner : Std.HashMap α β) → motive { inner := inner }) → motive t | null | false |
Std.IterM.fold_hom | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β γ₁ γ₂ : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β} (f : γ₁ → γ₂)
{g₁ : γ₁ → β → γ₁} {g₂ : γ₂ → β → γ₂} {init : γ₁},
(∀ (x : γ₁) (y : β), g₂ (f ... | null | true |
Equiv.coe_vaddConst | Mathlib.Algebra.Torsor.Defs | ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [inst_1 : AddTorsor G P] (p : P),
⇑(Equiv.vaddConst p) = fun v => v +ᵥ p | null | true |
CompHausLike.instPreservesLimitTopCatWalkingCospanCospanCompHausLikeToTop | Mathlib.Topology.Category.CompHausLike.Limits | ∀ {P : TopCat → Prop} {X Y B : CompHausLike P} (f : X ⟶ B) (g : Y ⟶ B) [CompHausLike.HasExplicitPullback f g],
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) (CompHausLike.compHausLikeToTop P) | The functor to `TopCat` preserves pullbacks. | true |
MeasurableVAdd₂ | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → (α : Type u_3) → [VAdd M α] → [MeasurableSpace M] → [MeasurableSpace α] → Prop | We say that the action of `M` on `α` has `MeasurableVAdd₂` if the map
`(c, x) ↦ c +ᵥ x` is a measurable function. | true |
Vector.getElem?_eq_some_getElem_iff | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} (h : i < n), xs[i]? = some xs[i] ↔ True | null | true |
ENat.add_eq_top | Mathlib.Data.ENat.Basic | ∀ {a b : ℕ∞}, a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ | null | true |
USize.toUInt64_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ},
USize.size ≤ n →
(USize.ofNatClamp n).toUInt64 = UInt64.ofNatLT (USize.size - 1) USize.toUInt64_ofNatClamp_of_le._proof_1 | null | true |
Lean.Meta.LetToHave.instInhabitedResult.default | Lean.Meta.LetToHave | Lean.Meta.LetToHave.Result✝ | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.sub_add_sub_cancel._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, b ≤ a → c ≤ b → ¬a - b + (b - c) = a - c → False | null | false |
CategoryTheory.Kleisli.category_id_of | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.Monad C) (X : CategoryTheory.Kleisli T),
(CategoryTheory.CategoryStruct.id X).of = T.η.app X.of | null | true |
_private.Lean.Elab.Tactic.Grind.Config.0.Lean.Elab.Tactic.instEvalExprNoopConfig.evalExpr | Lean.Elab.Tactic.Grind.Config | Lean.Expr → Lean.MetaM Lean.Grind.NoopConfig | null | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image_aux1._simp_1_10 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | null | false |
String.Slice.mk.noConfusion | Init.Data.String.Defs | {P : Sort u} →
{str : String} →
{startInclusive endExclusive : str.Pos} →
{startInclusive_le_endExclusive : startInclusive ≤ endExclusive} →
{str' : String} →
{startInclusive' endExclusive' : str'.Pos} →
{startInclusive_le_endExclusive' : startInclusive' ≤ endExclusive'} →
... | null | false |
ContinuousLinearEquiv.conjContinuousAlgEquiv | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | {𝕜 : Type u_1} →
{G : Type u_4} →
{H : Type u_5} →
[inst : AddCommGroup G] →
[inst_1 : AddCommGroup H] →
[inst_2 : NormedField 𝕜] →
[inst_3 : Module 𝕜 G] →
[inst_4 : Module 𝕜 H] →
[inst_5 : TopologicalSpace G] →
[inst_6 : Topo... | A continuous linear equivalence of two spaces induces a continuous equivalence of algebras of
their endomorphisms. | true |
UpperHalfPlane.atImInfty | Mathlib.Analysis.Complex.UpperHalfPlane.FunctionsBoundedAtInfty | Filter UpperHalfPlane | Filter for approaching `i∞`. | true |
CategoryTheory.Pseudofunctor.map₂_left_unitor_app | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (self : CategoryTheory.Pseudofunctor B CategoryTheory.Cat)
{a b : B} (f : a ⟶ b) (X : ↑(self.obj a)),
(self.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom).toNatTrans.app X =
CategoryTheory.CategoryStruct.comp ((self.mapComp (CategoryTheory.CategoryStruct... | null | true |
SimpleGraph.commonNeighbors_subset_neighborSet_left | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) (v w : V), G.commonNeighbors v w ⊆ G.neighborSet v | null | true |
Std.ExtTreeMap.foldrM | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{δ : Type w} →
{m : Type w → Type w₂} →
[inst : Monad m] → [LawfulMonad m] → [Std.TransCmp cmp] → (α → β → δ → m δ) → δ → Std.ExtTreeMap α β cmp → m δ | Folds the given monadic function over the mappings in the map in descending order. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.