name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Order.Filter.Subsingleton.0.Filter.subsingleton_iff_exists_le_pure._simp_1_1 | Mathlib.Order.Filter.Subsingleton | ∀ {α : Type u_1} {l : Filter α}, l.Subsingleton = (l = ⊥ ∨ ∃ a, l = pure a) | null | false |
fourierCoeffOn_of_hasDerivAt | Mathlib.Analysis.Fourier.AddCircle | ∀ {a b : ℝ} (hab : a < b) {f f' : ℝ → ℂ} {n : ℤ},
n ≠ 0 →
(∀ x ∈ Set.uIcc a b, HasDerivAt f (f' x) x) →
IntervalIntegrable f' MeasureTheory.volume a b →
fourierCoeffOn hab f n =
1 / (-2 * ↑Real.pi * Complex.I * ↑n) * ((fourier (-n)) ↑a * (f b - f a) - (↑b - ↑a) * fourierCoeffOn hab f' n) | Express Fourier coefficients of `f` on an interval in terms of those of its derivative. | true |
Vector.findSomeRev?_push | Init.Data.Vector.Find | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {xs : Vector α n} {a : α} {f : α → Option β},
Vector.findSomeRev? f (xs.push a) = (f a).or (Vector.findSomeRev? f xs) | null | true |
Int16.iSizeMinValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : Int16), ISize.minValue.toInt ≤ x.toInt | null | true |
Std.DHashMap.Raw.isSome_getKey?_iff_mem._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a : α}, ((m.getKey? a).isSome = true) = (a ∈ m) | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_478 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
act_rel_of_rel_of_act_rel | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop} [CovariantClass M N μ r] [IsTrans N r] (m : M)
{a b c : N}, r a b → r (μ m b) c → r (μ m a) c | null | true |
CategoryTheory.IsComonHom.hom_comul_assoc | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {M N : C}
{inst_2 : CategoryTheory.ComonObj M} {inst_3 : CategoryTheory.ComonObj N} (f : M ⟶ N)
[self : CategoryTheory.IsComonHom f] {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj N N ⟶ Z),
Categ... | null | true |
Fintype.subtype_card | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} {p : α → Prop} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ p x), Fintype.card { x // p x } = s.card | null | true |
CategoryTheory.Limits.BinaryFan.IsLimit.lift'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryFan X Y}
(h : CategoryTheory.Limits.IsLimit s) (f : W ⟶ X) (g : W ⟶ Y),
CategoryTheory.CategoryStruct.comp (h.lift (CategoryTheory.Limits.BinaryFan.mk f g)) s.fst = f ∧
CategoryTheory.CategoryStruct.comp ... | null | false |
Aesop.Script.Step.mk | Aesop.Script.Step | Lean.Meta.SavedState →
Lean.MVarId → Aesop.Script.Tactic → Lean.Meta.SavedState → Array Aesop.GoalWithMVars → Aesop.Script.Step | null | true |
isPathConnected_stdSimplex | Mathlib.Analysis.Convex.StdSimplex | ∀ (ι : Type u_1) [inst : Fintype ι] [Nonempty ι], IsPathConnected (stdSimplex ℝ ι) | `stdSimplex ℝ ι` is path connected. | true |
IsDedekindDomain.FiniteAdeleRing.instAlgebra | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | (R : Type u_1) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
(K : Type u_2) →
[inst_2 : Field K] →
[inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → Algebra K (IsDedekindDomain.FiniteAdeleRing R K) | null | true |
HahnSeries.ofFinsupp._proof_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R], { coeff := ⇑0, isPWO_support' := ⋯ } = 0 | null | false |
AddRightCancelMonoid.toIsRightCancelAdd | Mathlib.Algebra.Group.Defs | ∀ {M : Type u} [self : AddRightCancelMonoid M], IsRightCancelAdd M | null | true |
Int64.ofInt_eq_iff_bmod_eq_toInt | Init.Data.SInt.Lemmas | ∀ (a : ℤ) (b : Int64), Int64.ofInt a = b ↔ a.bmod (2 ^ 64) = b.toInt | null | true |
ContinuousMap.sigmaMk._proof_1 | Mathlib.Topology.ContinuousMap.Basic | ∀ {I : Type u_2} {X : I → Type u_1} [inst : (i : I) → TopologicalSpace (X i)] (i : I), Continuous (Sigma.mk i) | null | false |
Additive.toMul_le | Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags | ∀ {α : Type u_1} [inst : Preorder α] {a b : Additive α}, Additive.toMul a ≤ Additive.toMul b ↔ a ≤ b | null | true |
CategoryTheory.Adjunction.Triple.leftToRight._proof_1 | Mathlib.CategoryTheory.Adjunction.Triple | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{H : CategoryTheory.Functor C D} (t : CategoryTheory.Adjunction.Triple F G H) [F.Full] [F.Faithful],
CategoryTheory.IsIso ... | null | false |
Units.isIsometricSMul | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X] [IsIsometricSMul M X] [inst_3 : Monoid M],
IsIsometricSMul Mˣ X | null | true |
CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_22 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)},
S.IsComplex →
∀ (k : ℕ) (hk : k ≤ n),
CategoryTheory.CategoryStruct.comp (S.map' (k + 1) (k + 1 + 1) ⋯ ⋯) (S.map' (k + 1 + 1) (k + 1 +... | null | false |
FrameHom.instFunLike | Mathlib.Order.Hom.CompleteLattice | {α : Type u_2} → {β : Type u_3} → [inst : CompleteLattice α] → [inst_1 : CompleteLattice β] → FunLike (FrameHom α β) α β | null | true |
_private.Mathlib.RingTheory.Coalgebra.TensorProduct.0.Coalgebra._aux_Mathlib_RingTheory_Coalgebra_TensorProduct___delab_app__private_Mathlib_RingTheory_Coalgebra_TensorProduct_0_Coalgebra_termμ_1 | Mathlib.RingTheory.Coalgebra.TensorProduct | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
Lean.Elab.ConfigEval.EvalConfigItemHandler.noConfusion | Lean.Elab.ConfigEval.DeriveEvalConfigItem | {P : Sort u} →
{t t' : Lean.Elab.ConfigEval.EvalConfigItemHandler} →
t = t' → Lean.Elab.ConfigEval.EvalConfigItemHandler.noConfusionType P t t' | null | false |
Std.TreeMap.Raw.getElem?_inter_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ ∩ t₂)[k]? = none | null | true |
Lean.ScopedEnvExtension.Entry.scoped.inj | Lean.ScopedEnvExtension | ∀ {α : Type} {a : Lean.Name} {a_1 : α} {a_2 : Lean.Name} {a_3 : α},
Lean.ScopedEnvExtension.Entry.scoped a a_1 = Lean.ScopedEnvExtension.Entry.scoped a_2 a_3 → a = a_2 ∧ a_1 = a_3 | null | true |
Std.DTreeMap.Internal.Impl.aux_size_modify | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.LawfulEqOrd α] {k : α} {f : β k → β k}
{t : Std.DTreeMap.Internal.Impl α β}, (Std.DTreeMap.Internal.Impl.modify k f t).size = t.size | null | true |
AddCommGroup.torsion_sum | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} {H : Type u_2} [inst : AddCommGroup G] [inst_1 : AddCommGroup H],
AddCommGroup.torsion (G × H) = (AddCommGroup.torsion G).prod (AddCommGroup.torsion H) | null | true |
OrderIso.bddAbove_image | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {s : Set α},
BddAbove (⇑e '' s) ↔ BddAbove s | null | true |
Turing.TM2to1.StAct.push.noConfusion | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{P : Sort u} → {a a' : σ → Γ k} → Turing.TM2to1.StAct.push a = Turing.TM2to1.StAct.push a' → (a ≍ a' → P) → P | null | false |
_private.Mathlib.MeasureTheory.Integral.IntegralEqImproper.0.MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi._simp_1_3 | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.S.encode.match_1.splitter | Mathlib.Tactic.DeriveEncodable | (motive : Mathlib.Deriving.Encodable.S✝ → Sort u_1) →
(x : Mathlib.Deriving.Encodable.S✝) →
((n : ℕ) → motive (Mathlib.Deriving.Encodable.S.nat✝ n)) →
((a b : Mathlib.Deriving.Encodable.S✝) → motive (Mathlib.Deriving.Encodable.S.cons✝ a b)) → motive x | null | true |
BitVec.ne_of_lt | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, x < y → x ≠ y | null | true |
Equiv.Perm.toList_eq_nil_iff | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {p : Equiv.Perm α} {x : α}, p.toList x = [] ↔ x ∉ p.support | null | true |
Lean.Meta.Grind.Arith.isRelevantPred | Lean.Meta.Tactic.Grind.Arith.IsRelevant | Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | true |
MulChar.mem_subgroupOrderIsoSubgroupMulChar_symm_iff._simp_1 | Mathlib.NumberTheory.MulChar.Duality | ∀ {M : Type u_1} {R : Type u_2} [inst : CommMonoid M] [inst_1 : CommRing R] [inst_2 : Finite M]
[inst_3 : HasEnoughRootsOfUnity R (Monoid.exponent Mˣ)] {X : Subgroup (MulChar M R)} {m : Mˣ},
(m ∈ (MulChar.subgroupOrderIsoSubgroupMulChar M R).symm (OrderDual.toDual X)) = ∀ χ ∈ X, χ ↑m = 1 | null | false |
ContMDiff.sumElim | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : 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] {M' : Type u_16} [inst_6 : TopologicalS... | null | true |
Lean.Elab.ChoiceInfo.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.ChoiceInfo → ℕ | null | false |
AddSubmonoid.map._proof_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_3}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M) {a b : N},
a ∈ ⇑f '' ↑S → b ∈ ⇑f '' ↑S → a + b ∈ ⇑f '' ↑S | null | false |
Std.TreeSet.merge | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet α cmp → Std.TreeSet α cmp → Std.TreeSet α cmp | Returns a set that contains all mappings of `t₁` and `t₂.
This function ensures that `t₁` is used linearly.
Hence, as long as `t₁` is unshared, the performance characteristics follow the following imperative
description: Iterate over all mappings in `t₂`, inserting them into `t₁`.
Hence, the runtime of this method sc... | true |
_private.Mathlib.Combinatorics.Graph.Basic.0.Graph.banana_inc._simp_1_2 | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
RegularExpression.map_pow._f | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (P : RegularExpression α) (x : ℕ) (f_1 : Nat.below x),
RegularExpression.map f (P ^ x) = RegularExpression.map f P ^ x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.insert._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Polynomial.powAddExpansion._proof_1 | Mathlib.Algebra.Polynomial.Identities | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (n : ℕ) (z : R),
(x + y) ^ (n + 1) = x ^ (n + 1) + ↑(n + 1) * x ^ (n + 1 - 1) * y + z * y ^ 2 →
(x + y) ^ (n + 2) = x ^ (n + 2) + ↑(n + 2) * x ^ (n + 1) * y + (x * z + (↑n + 1) * x ^ n + z * y) * y ^ 2 | null | false |
CategoryTheory.uniqueHomToTrivial | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | {D : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D] →
(A : CategoryTheory.Mon D) → Unique (A ⟶ CategoryTheory.Mon.trivial D) | **Alias** of `CategoryTheory.Mon.uniqueHomToTrivial`. | true |
Coalgebra.coassoc | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} {inst : CommSemiring R} {inst_1 : AddCommMonoid A} {inst_2 : Module R A}
[self : Coalgebra R A],
↑(TensorProduct.assoc R A A A) ∘ₗ LinearMap.rTensor A CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul =
LinearMap.lTensor A CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul | The comultiplication is coassociative | true |
OrderMonoidHom.noConfusionType | Mathlib.Algebra.Order.Hom.Monoid | Sort u →
{α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : MulOneClass α] →
[inst_3 : MulOneClass β] →
(α →*o β) →
{α' : Type u_6} →
{β' : Type u_7} →
[inst' : Preorder α... | null | false |
openSegment_subset_iff | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] {s : Set E} {x y : E},
openSegment 𝕜 x y ⊆ s ↔ ∀ (a b : 𝕜), 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s | null | true |
Compactum.continuous_of_hom | Mathlib.Topology.Category.Compactum | ∀ {X Y : Compactum} (f : X ⟶ Y), Continuous ⇑(CategoryTheory.ConcreteCategory.hom f) | Any morphism of compacta is continuous. | true |
Finset.sum_nonneg | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι}
[AddLeftMono N], (∀ i ∈ s, 0 ≤ f i) → 0 ≤ ∑ i ∈ s, f i | null | true |
HomologicalComplex.extend.leftHomologyData._proof_4 | Mathlib.Algebra.Homology.Embedding.ExtendHomology | ∀ {ι : Type u_3} {c : ComplexShape ι} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c) {i j k : ι},
CategoryTheory.CategoryStruct.comp (K.sc' i j k).f (K.sc' i j k).g = 0 | null | false |
String.Slice.Pattern.Model.ForwardStringSearcher.isLongestMatchAt_iff_isLongestMatchAt_toSlice | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat : String} {s : String.Slice} {pos₁ pos₂ : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt pat pos₁ pos₂ ↔
String.Slice.Pattern.Model.IsLongestMatchAt pat.toSlice pos₁ pos₂ | null | true |
RootPairing.isSimpleModule_weylGroupRootRep | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [P.IsIrreducible],
IsSimpleModule (MonoidAlgebra R ↥P.weylGroup) P.weylGroupRootRep.asModule | null | true |
Std.LawfulRightIdentity.recOn | Init.Core | {α : Sort u} →
{β : Sort u_1} →
{op : α → β → α} →
{o : β} →
{motive : Std.LawfulRightIdentity op o → Sort u_2} →
(t : Std.LawfulRightIdentity op o) →
([toRightIdentity : Std.RightIdentity op o] → (right_id : ∀ (a : α), op a o = a) → motive ⋯) → motive t | null | false |
Fin.isSome_findSome?_iff._simp_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → Option α}, ((Fin.findSome? f).isSome = true) = ∃ i, (f i).isSome = true | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.borrowed._regBuiltin.Lean.Parser.Term.borrowed_1 | Lean.Parser.Term | IO Unit | null | false |
Lean.Server.FileWorker.SemanticTokensState.mk.sizeOf_spec | Lean.Server.FileWorker.SemanticHighlighting | sizeOf { } = 1 | null | true |
FintypeCat.hom_apply | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y : FintypeCat} (f : X ⟶ Y) (x : X.obj),
(CategoryTheory.ConcreteCategory.hom f.hom) x = (CategoryTheory.ConcreteCategory.hom f) x | null | true |
_private.Mathlib.CategoryTheory.MorphismProperty.IsSmall.0.CategoryTheory.MorphismProperty.isSmall_iSup.match_1 | Mathlib.CategoryTheory.MorphismProperty.IsSmall | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_3, u_2} C] →
{α : Type u_1} →
(W : α → CategoryTheory.MorphismProperty C) →
(motive : (i : α) × ↑(W i).toSet → Sort u_4) →
(x : (i : α) × ↑(W i).toSet) → ((i : α) → (f : ↑(W i).toSet) → motive ⟨i, f⟩) → motive x | null | false |
Nat.stirlingFirst_one_right | Mathlib.Combinatorics.Enumerative.Stirling | ∀ (n : ℕ), (n + 1).stirlingFirst 1 = n.factorial | null | true |
_private.Mathlib.Tactic.ProdAssoc.0.Lean.Expr.mkProdTree._sparseCasesOn_4 | Mathlib.Tactic.ProdAssoc | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.GrothendieckTopology.OneHypercover.id_h₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C}
(E : J.OneHypercover S) {i j : E.I₀} (x : E.I₁ i j),
(CategoryTheory.CategoryStruct.id E).h₁ x = CategoryTheory.CategoryStruct.id (E.Y x) | null | true |
AddChar.toAddMonoidHomEquiv._proof_4 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_2} {M : Type u_1} [inst : AddMonoid A] [inst_1 : Monoid M] (f : A →+ Additive M) (x y : A),
(↑f).toFun (x + y) = (↑f).toFun x + (↑f).toFun y | null | false |
ModuleCat.instModuleCarrierMkOfSMul' | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} →
[inst : Ring R] → {A : AddCommGrpCat} → (φ : R →+* CategoryTheory.End A) → Module R ↑(ModuleCat.mkOfSMul' φ) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics.0.isLittleO_exp_neg_mul_rpow_atTop._simp_1_6 | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.realizeValue.match_7 | Lean.Meta.Basic | (motive : Option Lean.Meta.RealizeValueResult✝ → Sort u_1) →
(x : Option Lean.Meta.RealizeValueResult✝) →
((res : Lean.Meta.RealizeValueResult✝) → motive (some res)) →
((x : Option Lean.Meta.RealizeValueResult✝) → motive x) → motive x | null | false |
Nat.Linear.ExprCnstr.denote_toPoly | Init.Data.Nat.Linear | ∀ (ctx : Nat.Linear.Context) (c : Nat.Linear.ExprCnstr),
Nat.Linear.PolyCnstr.denote ctx c.toPoly = Nat.Linear.ExprCnstr.denote ctx c | null | true |
HeytAlg.Hom.recOn | Mathlib.Order.Category.HeytAlg | {X Y : HeytAlg} →
{motive : X.Hom Y → Sort u_1} → (t : X.Hom Y) → ((hom' : HeytingHom ↑X ↑Y) → motive { hom' := hom' }) → motive t | null | false |
rootsOfUnityCircleEquiv._proof_2 | Mathlib.Analysis.SpecialFunctions.Complex.CircleAddChar | ∀ (n : ℕ) [inst : NeZero n] (z : ↥(rootsOfUnity n ℂ)), (rootsOfUnitytoCircle n).toHomUnits z ∈ rootsOfUnity n Circle | null | false |
Aesop.Options'.ctorIdx | Aesop.Options.Internal | Aesop.Options' → ℕ | null | false |
_private.Mathlib.Data.ENNReal.Basic.0.ENNReal.iUnion_Ioo_coe_nat._simp_1_1 | Mathlib.Data.ENNReal.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioo a b = Set.Ioi a ∩ Set.Iio b | null | false |
CategoryTheory.End.group._proof_3 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] (X : C) (n : ℕ) (a : CategoryTheory.End X),
zpowRec npowRec (↑n.succ) a = zpowRec npowRec (↑n) a * a | null | false |
_private.Mathlib.Tactic.Linarith.Verification.0.Mathlib.Tactic.Linarith.mkLTZeroProof.match_1 | Mathlib.Tactic.Linarith.Verification | (motive : List (Lean.Expr × ℕ) → Sort u_1) →
(x : List (Lean.Expr × ℕ)) →
(Unit → motive []) →
((h : Lean.Expr) → (c : ℕ) → motive [(h, c)]) →
((h : Lean.Expr) → (c : ℕ) → (t : List (Lean.Expr × ℕ)) → motive ((h, c) :: t)) → motive x | null | false |
BinaryTree.right | Mathlib.Data.Tree.Basic | {α : Type u} → BinaryTree α → BinaryTree α | The right child of the tree, or `nil` if the tree is `nil` | true |
Lean.Meta.Grind.AC.getOpId | Lean.Meta.Tactic.Grind.AC.Util | Lean.Meta.Grind.AC.ACM ℕ | null | true |
USize.ofFin_uint32ToFin | Init.Data.UInt.Lemmas | ∀ (n : UInt32), USize.ofFin (Fin.castLE UInt32.size_le_usizeSize n.toFin) = n.toUSize | null | true |
Multiset.singleton_inj | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a b : α}, {a} = {b} ↔ a = b | null | true |
Lean.Lsp.instToJsonWorkspaceClientCapabilities | Lean.Data.Lsp.Capabilities | Lean.ToJson Lean.Lsp.WorkspaceClientCapabilities | null | true |
IsBoundedBilinearMap.isBigO' | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : Semiring 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 F] [inst_5 : SeminormedAddCommGroup G]
[inst_6 : Module 𝕜 G] {f : E × F → G}, IsBoundedBilinearMap 𝕜 f → f =O[⊤] fu... | null | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.one_lt_re_one_add | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {x : ℝ}, 0 < x → ∀ (y : ℝ), 1 < (1 + ↑x).re ∧ 1 < (1 + ↑x + Complex.I * ↑y).re ∧ 1 < (1 + ↑x + 2 * Complex.I * ↑y).re | null | true |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.hasNext.eq_1 | Init.Data.String.Iterator | ∀ (s : String) (i : String.Pos.Raw), { s := s, i := i }.hasNext = decide (i.byteIdx < s.rawEndPos.byteIdx) | null | true |
_private.Mathlib.Tactic.Simps.Basic.0.Lean.Meta.mkSimpContextResult._sparseCasesOn_1 | Mathlib.Tactic.Simps.Basic | {motive : Lean.Elab.Tactic.Simp.DischargeWrapper → Sort u} →
(t : Lean.Elab.Tactic.Simp.DischargeWrapper) →
motive Lean.Elab.Tactic.Simp.DischargeWrapper.default → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
IsSemitopologicalSemiring.continuousNeg_of_mul | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonAssocRing R] [SeparatelyContinuousMul R], ContinuousNeg R | If `R` is a ring with a separately continuous multiplication, then negation is continuous as
well since it is just multiplication with `-1`. | true |
PowerSeries.coe_orderHom | Mathlib.RingTheory.PowerSeries.Order | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : NoZeroDivisors R] [inst_2 : Nontrivial R],
⇑PowerSeries.orderHom = PowerSeries.order | null | true |
Finset.Ico_diff_Ico_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] (a b c : α),
Finset.Ico a b \ Finset.Ico a c = Finset.Ico (max a c) b | **Alias** of `Finset.Ico_sdiff_Ico_left`. | true |
T5Space.of_forall_isOpen_t4Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X], (∀ (s : Set X), IsOpen s → T4Space ↑s) → T5Space X | **Alias** of the reverse direction of `t5Space_iff_forall_isOpen_t4Space`.
---
A space is a `T5Space` iff all its open subspaces are `T4Space`.
| true |
CategoryTheory.ShortComplex.exact_of_f_is_kernel | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) (hS : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯))
[S.HasHomology], S.Exact | null | true |
CoxeterSystem.map_simple | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} {W : Type u_3} {H : Type u_4} [inst : Group W] [inst_1 : Group H] {M : CoxeterMatrix B}
(cs : CoxeterSystem M W) (e : W ≃* H) (i : B), (cs.map e).simple i = e (cs.simple i) | null | true |
SheafOfModules.Presentation.noConfusion | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {P : Sort u_1} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
{inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat} →
{inst_2 : J.WEqualsLocallyBijective AddCommGrpCat} →
... | null | false |
Traversable.foldrm_toList | Mathlib.Control.Fold | ∀ {α β : Type u} {t : Type u → Type u} [inst : Traversable t] [LawfulTraversable t] {m : Type u → Type u}
[inst_2 : Monad m] [LawfulMonad m] (f : α → β → m β) (x : β) (xs : t α),
Traversable.foldrm f x xs = List.foldrM f x (Traversable.toList xs) | null | true |
ENNReal.mul_inv_le_one | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal), a * a⁻¹ ≤ 1 | null | true |
BitVec.toFin_injective | Mathlib.Data.BitVec | ∀ {n : ℕ}, Function.Injective BitVec.toFin | null | true |
Std.DTreeMap.Internal.Impl.minView.induct | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v}
(motive :
(k : α) →
β k →
(l r : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → r.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Prop),
(∀ (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hl : Std.DTreeM... | null | true |
IsNormalClosure.lift | Mathlib.FieldTheory.Normal.Closure | {F : Type u_1} →
{K : Type u_2} →
{L : Type u_3} →
[inst : Field F] →
[inst_1 : Field K] →
[inst_2 : Field L] →
[inst_3 : Algebra F K] →
[inst_4 : Algebra F L] →
[h : IsNormalClosure F K L] →
{L' : Type u_4} →
... | A normal closure of `K/F` embeds into any `L/F`
where the minimal polynomials of `K/F` splits. | true |
Lean.Parser.ParserAttributeHook.postAdd | Lean.Parser.Extension | Lean.Parser.ParserAttributeHook → Lean.Name → Lean.Name → Bool → Lean.AttrM Unit | Called after a parser attribute is applied to a declaration. | true |
Std.DHashMap.Raw.Const.get_unitOfList | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {l : List α} {k : α} {h : k ∈ Std.DHashMap.Raw.Const.unitOfList l},
Std.DHashMap.Raw.Const.get (Std.DHashMap.Raw.Const.unitOfList l) k h = () | null | true |
AEMeasurable.const_sup | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → M} [inst_1 : Max M] [MeasurableSup M], AEMeasurable f μ → ∀ (c : M), AEMeasurable (fun x => c ⊔ f x) μ | null | true |
Std.Internal.LawfulMonadLiftBindFunction.liftBind_bind | Init.Data.Iterators.Internal.LawfulMonadLiftFunction | ∀ {m : Type u → Type v} {n : Type w → Type x} {inst : Monad m} {inst_1 : Monad n}
{liftBind : (γ : Type u) → (δ : Type w) → (γ → n δ) → m γ → n δ}
[self : Std.Internal.LawfulMonadLiftBindFunction liftBind] {β γ : Type u} {δ : Type w} (f : γ → n δ) (x : m β)
(g : β → m γ), liftBind γ δ f (x >>= g) = liftBind β δ (... | null | true |
WeierstrassCurve._sizeOf_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → [SizeOf R] → WeierstrassCurve R → ℕ | null | false |
Std.Async.ETask.bind | Std.Async.Basic | {ε α β : Type} →
Std.Async.ETask ε α →
(α → Std.Async.ETask ε β) → optParam Task.Priority Task.Priority.default → optParam Bool false → Std.Async.ETask ε β | Creates a new `ETask` that will run after `x` has completed. If `x`:
- errors, return an `ETask` that resolves to the error.
- succeeds, run `f` on the result of `x` and return the `ETask` produced by `f`.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.