name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
RingHom.frobenius_comm | Mathlib.Algebra.CharP.Frobenius | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (g : R →+* S) (p : ℕ)
[inst_2 : ExpChar R p] [inst_3 : ExpChar S p], g.comp (frobenius R p) = (frobenius S p).comp g | The Frobenius endomorphism commutes with any ring homomorphism. | true |
Locale.pt | Mathlib.Topology.Order.Category.FrameAdjunction | CategoryTheory.Functor Locale TopCat | The covariant functor `pt` from the category of locales to the category of
topological spaces, which sends a locale `L` to the topological space `PT L` of homomorphisms
from `L` to `Prop` and a locale homomorphism `f` to a continuous function between the spaces
of points. | true |
Insert.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{γ : Type v} →
{P : Sort u_1} →
{insert insert' : α → γ → γ} → { insert := insert } = { insert := insert' } → (insert ≍ insert' → P) → P | null | false |
MvPolynomial.X_mul_pderiv_monomial | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} [inst : CommSemiring R] {i : σ} {m : σ →₀ ℕ} {r : R},
MvPolynomial.X i * (MvPolynomial.pderiv i) ((MvPolynomial.monomial m) r) = m i • (MvPolynomial.monomial m) r | null | true |
CategoryTheory.Lax.OplaxTrans.associator | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H I : CategoryTheory.LaxFunctor B C} →
(η : F ⟶ G) →
(θ : G ⟶ H) →
(ι : H ⟶ I) →
CategoryTheory.CategoryStruct.comp (CategoryTheory... | Associator for the vertical composition of oplax natural transformations. | true |
MvPolynomial.constantCoeff_comp_algebraMap | Mathlib.Algebra.MvPolynomial.Basic | ∀ (R : Type u) (σ : Type u_1) [inst : CommSemiring R],
MvPolynomial.constantCoeff.comp (algebraMap R (MvPolynomial σ R)) = RingHom.id R | null | true |
Class.coe_empty | Mathlib.SetTheory.ZFC.Class | ↑∅ = ∅ | null | true |
nnnorm_apply_le_nnnorm_cfcₙ._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
AlgHom.tensorEqualizerEquiv_apply | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_3)
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {A : Type u_4}
{B : Type u_5} [inst_7 : CommRing A] [inst_8 : CommRing B] [inst_9 : Algebra R A] [inst_10... | null | true |
Std.Http.Status._sizeOf_inst | Std.Http.Data.Status | SizeOf Std.Http.Status | null | false |
Set.Finite.iSup_biInf_of_antitone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [Nonempty ι'] [IsCodirectedOrder ι']
[inst_3 : Order.Frame α] {s : Set ι},
s.Finite → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Antitone (f i)) → ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j | null | true |
Std.Time.GenericFormat.ctorIdx | Std.Time.Format.Basic | {awareness : Std.Time.Awareness} → Std.Time.GenericFormat awareness → ℕ | null | false |
Lean.PrettyPrinter.Parenthesizer.many1NoAntiquot.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_III._simp_1_4 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) | null | false |
Std.TreeMap.contains_insertIfNew | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k a : α} {v : β},
(t.insertIfNew k v).contains a = (cmp k a == Ordering.eq || t.contains a) | null | true |
IsNonstrictStrictOrder.right_iff_left_not_left | Mathlib.Order.RelClasses | ∀ {α : Type u_1} {r : semiOutParam (α → α → Prop)} {s : α → α → Prop} [self : IsNonstrictStrictOrder α r s] (a b : α),
s a b ↔ r a b ∧ ¬r b a | The relation `r` is the nonstrict relation corresponding to the strict relation `s`. | true |
Set.pi_univ_Ici | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i),
(Set.univ.pi fun i => Set.Ici (x i)) = Set.Ici x | null | true |
Ideal.isLocal_of_isMaximal_radical | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, I.radical.IsMaximal → I.IsLocal | null | true |
CategoryTheory.SmallObject.FunctorObjIndex.i | Mathlib.CategoryTheory.SmallObject.Construction | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type w} →
{A B : I → C} →
{f : (i : I) → A i ⟶ B i} → {S X : C} → {πX : X ⟶ S} → CategoryTheory.SmallObject.FunctorObjIndex f πX → I | an element in the index type | true |
star_finsuppSum | Mathlib.Algebra.Star.BigOperators | ∀ {R : Type u_1} {ι : Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : AddCommMonoid R] [inst_2 : StarAddMonoid R]
(s : ι →₀ M) (f : ι → M → R), star (s.sum f) = s.sum fun i m => star f i m | null | true |
DirSupClosedOn.mono | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} {s : Set α} {D₁ D₂ : Set (Set α)} [inst : Preorder α],
D₁ ⊆ D₂ → DirSupClosedOn D₂ s → DirSupClosedOn D₁ s | null | true |
AlgebraicGeometry.StructureSheaf.instAlgebraCarrierStalkCommRingCatObjPresheafTopObjPushforwardTopMapObjFunctorOppositeOpensCarrierTopIsSheafGrothendieckTopologyStructureSheaf | Mathlib.AlgebraicGeometry.Spec | {R S : CommRingCat} →
(f : R ⟶ S) →
(p : PrimeSpectrum ↑R) →
Algebra ↑R
↑(((TopCat.Presheaf.pushforward CommRingCat (AlgebraicGeometry.Spec.topMap f)).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p) | null | true |
Sym2.diagSet_compl_eq_fromRel_ne | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1}, Sym2.diagSetᶜ = Sym2.fromRel ⋯ | null | true |
_private.Lean.Parser.Extension.0.Lean.Parser.ParserExtension.OLeanEntry.toEntry | Lean.Parser.Extension | Lean.Parser.ParserExtension.State →
Lean.Parser.ParserExtension.OLeanEntry → Lean.ImportM Lean.Parser.ParserExtension.Entry | null | true |
Nat.Linear.Poly.cancelAux.eq_def | Init.Data.Nat.Linear | ∀ (fuel : ℕ) (m₁ m₂ r₁ r₂ : Nat.Linear.Poly),
Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂ =
match fuel with
| 0 => (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂)
| fuel.succ =>
match m₁, m₂ with
| m₁, [] => (List.reverse r₁ ++ m₁, List.reverse r₂)
| [], m₂ => (List.reverse r₁, List.revers... | null | true |
AddCircle.measurableEquivIoc | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | (T : ℝ) → [hT : Fact (0 < T)] → (a : ℝ) → AddCircle T ≃ᵐ ↑(Set.Ioc a (a + T)) | The isomorphism `AddCircle T ≃ Ioc a (a + T)` whose inverse is the natural quotient map,
as an equivalence of measurable spaces. | true |
BoxIntegral.IntegrationParams.RCond.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Filter | ∀ {ι : Type u_2} (l : BoxIntegral.IntegrationParams) (r : (ι → ℝ) → ↑(Set.Ioi 0)),
l.RCond r = (l.bRiemann = true → ∀ (x : ι → ℝ), r x = r 0) | null | true |
CategoryTheory.functorProdFunctorEquivCounitIso._proof_4 | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u_4) [inst : CategoryTheory.Category.{u_1, u_4} A] (B : Type u_6)
[inst_1 : CategoryTheory.Category.{u_2, u_6} B] (C : Type u_5) [inst_2 : CategoryTheory.Category.{u_3, u_5} C]
{X Y : CategoryTheory.Functor A (B × C)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.functorProdT... | null | false |
instFintypeWithTop._aux_1 | Mathlib.Data.Fintype.WithTopBot | {α : Type u_1} → [Fintype α] → Finset (WithTop α) | null | false |
CStarAlgebra.ringInverse_le_ringInverse | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a b : A},
a ≤ b →
autoParam (IsStrictlyPositive a) CStarAlgebra.ringInverse_le_ringInverse._auto_1 → Ring.inverse b ≤ Ring.inverse a | null | true |
BoundedContinuousFunction.tendsto_integral_of_forall_integral_le_liminf_integral | Mathlib.MeasureTheory.Integral.BoundedContinuousFunction | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] [OpensMeasurableSpace X] {ι : Type u_2}
{L : Filter ι} {μ : MeasureTheory.Measure X} [MeasureTheory.IsProbabilityMeasure μ] {μs : ι → MeasureTheory.Measure X}
[∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)],
(∀ (f : BoundedContinuous... | null | true |
finprod_mem_union | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {s t : Set α},
Disjoint s t →
s.Finite → t.Finite → ∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i = (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i | Given two finite disjoint sets `s` and `t`, the product of `f i` over `i ∈ s ∪ t` equals the
product of `f i` over `i ∈ s` times the product of `f i` over `i ∈ t`. | true |
FirstOrder.Language.LHom.IsExpansionOn.map_onFunction._autoParam | Mathlib.ModelTheory.LanguageMap | Lean.Syntax | null | false |
Quiver.HasInvolutiveReverse.rec | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} →
[inst : Quiver V] →
{motive : Quiver.HasInvolutiveReverse V → Sort u} →
([toHasReverse : Quiver.HasReverse V] →
(inv' : ∀ {a b : V} (f : a ⟶ b), Quiver.reverse (Quiver.reverse f) = f) →
motive { toHasReverse := toHasReverse, inv' := inv' }) →
(t : Quiver.HasInv... | null | false |
Lean.Elab.Term.Quotation.HeadCheck.slice.elim | Lean.Elab.Quotation | {motive : Lean.Elab.Term.Quotation.HeadCheck → Sort u} →
(t : Lean.Elab.Term.Quotation.HeadCheck) →
t.ctorIdx = 2 →
((numPrefix numSuffix : ℕ) → motive (Lean.Elab.Term.Quotation.HeadCheck.slice numPrefix numSuffix)) → motive t | null | false |
_private.Aesop.Forward.State.0.Aesop.InstMap.insertMatch.match_1 | Aesop.Forward.State | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((inst : Lean.Expr) → motive (some inst)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
Finset.prod_Ioc_succ_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : CommMonoid M] {a b : ℕ},
a ≤ b → ∀ (f : ℕ → M), ∏ k ∈ Finset.Ioc a (b + 1), f k = (∏ k ∈ Finset.Ioc a b, f k) * f (b + 1) | null | true |
CategoryTheory.Functor.mapGrpIdIso.eq_1 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
CategoryTheory.Functor.mapGrpIdIso =
CategoryTheory.NatIso.ofComponents
(fun X => CategoryTheory.Grp.mkIso (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapGrp.obj X).X) ⋯ ⋯) ⋯ | null | true |
LinearMap.prodMapRingHom_apply | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (f : (M →ₗ[R] M) × (M₂ →ₗ[R] M₂)),
(LinearMap.prodMapRingHom R M M₂) f = f.1.prodMap f.2 | null | true |
Finset.biUnion_image_sup_left | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] (s t : Finset α),
(s.biUnion fun a => Finset.image (fun x => a ⊔ x) t) = s ⊻ t | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt.0.Lean.Meta.Grind.Arith.Cutsat.expandIfWrap.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → (Unit → motive none) → ((b : Lean.Expr) → motive (some b)) → motive x | null | false |
_private.Lean.Elab.DeclNameGen.0.PSum.casesOn._arg_pusher | Lean.Elab.DeclNameGen | ∀ {α : Sort u} {β : Sort v} {motive : α ⊕' β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : α ⊕' β → α_1 → Prop) (t : α ⊕' β)
(inl : (val : α) → ((y : α_1) → rel (PSum.inl val) y → β_1 y) → motive (PSum.inl val))
(inr : (val : β) → ((y : α_1) → rel (PSum.inr val) y → β_1 y) → mot... | null | false |
LinearEquiv.mk.congr_simp | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_14} {S : Type u_15} [inst : Semiring R] [inst_1 : Semiring S] {σ : R →+* S} {σ' : S →+* R}
[inst_2 : RingHomInvPair σ σ'] [inst_3 : RingHomInvPair σ' σ] {M : Type u_16} {M₂ : Type u_17}
[inst_4 : AddCommMonoid M] [inst_5 : AddCommMonoid M₂] [inst_6 : Module R M] [inst_7 : Module S M₂]
(toLinearMap t... | null | true |
Real.tendsto_logb_atTop_of_base_lt_one | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b : ℝ}, 0 < b → b < 1 → Filter.Tendsto (Real.logb b) Filter.atTop Filter.atBot | null | true |
tensorKaehlerQuotKerSqEquiv._proof_3 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_1) (P : Type u_2) (S : Type u_3) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S],
SMulCommClass R (P ⧸ RingHom.ker (algebraMap P S) ^ 2) (P ⧸ RingHom.ker (algebraMap P S) ^ 2) | null | false |
Asymptotics.IsEquivalent | Mathlib.Analysis.Asymptotics.Defs | {α : Type u_1} → {E' : Type u_6} → [SeminormedAddCommGroup E'] → Filter α → (α → E') → (α → E') → Prop | Two functions `u` and `v` are said to be asymptotically equivalent along a filter `l`
(denoted as `u ~[l] v` in the `Asymptotics` namespace)
when `u x - v x = o(v x)` as `x` converges along `l`. | true |
SNum.instNeg | Mathlib.Data.Num.Bitwise | Neg SNum | null | true |
ValueDistribution.circleAverage_log_norm_meromorphicTrailingCoeffAt_of_meromorphicOrderAt_eq_zero | Mathlib.Analysis.Complex.ValueDistribution.Cartan | ∀ {f : ℂ → ℂ},
meromorphicOrderAt f 0 = 0 →
Real.circleAverage (fun a => Real.log ‖meromorphicTrailingCoeffAt (fun x => f x - a) 0‖) 0 1 =
‖meromorphicTrailingCoeffAt f 0‖.posLog | Circle average of the function `fun a ↦ log ‖meromorphicTrailingCoeffAt (f · - a) 0‖` that appears
in Cartan's formula, in case where `f` has order zero at the origin.
| true |
AddUnits.addAction'._proof_3 | Mathlib.Algebra.Group.Action.Units | ∀ {G : Type u_2} {M : Type u_1} [inst : AddGroup G] [inst_1 : AddMonoid M] [inst_2 : AddAction G M]
[inst_3 : VAddCommClass G M M] [inst_4 : VAddAssocClass G M M] (x x_1 : G) (x_2 : AddUnits M),
(x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | null | false |
NNRat.divNat._proof_1 | Mathlib.Data.NNRat.Defs | ∀ (n d : ℕ), 0 ≤ Rat.divInt ↑n ↑d | null | false |
AffineSubspace.subtype_linear | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : AffineSubspace k P) [inst_4 : Nonempty ↥s], s.subtype.linear = s.direction.subtype | null | true |
Filter.tendsto_sup | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y ↔ Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y | null | true |
_private.Batteries.Data.List.Basic.0.List.next?.match_1.eq_2 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (l : List α) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l | null | true |
Set.mulIndicator_eq_one_or_self | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] (s : Set α) (f : α → M) (a : α),
s.mulIndicator f a = 1 ∨ s.mulIndicator f a = f a | null | true |
jacobiSym.mod_right | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (a : ℤ) {b : ℕ}, Odd b → jacobiSym a b = jacobiSym a (b % (4 * a.natAbs)) | The Jacobi symbol `J(a | b)` depends only on `b` mod `4*a`. | true |
Finset.single_le_sum_of_canonicallyOrdered | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] {f : ι → M}
{s : Finset ι} {i : ι}, i ∈ s → f i ≤ ∑ j ∈ s, f j | In a canonically-ordered additive monoid, a sum bounds each of its terms.
See also `Finset.single_le_sum`. | true |
CategoryTheory.FreeBicategory.liftHom.match_1 | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u_1} →
[inst : Quiver B] →
(motive : (x x_1 : CategoryTheory.FreeBicategory B) → (x ⟶ x_1) → Sort u_3) →
(x x_1 : CategoryTheory.FreeBicategory B) →
(x_2 : x ⟶ x_1) →
((x x_3 : B) → (f : x ⟶ x_3) → motive x x_3 (CategoryTheory.FreeBicategory.Hom.of f)) →
((a : B) → mo... | null | false |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.recOn | Mathlib.Tactic.Linter.TextBased | {motive : Mathlib.Linter.TextBased.ErrorContext✝ → Sort u} →
(t : Mathlib.Linter.TextBased.ErrorContext✝) →
((error : Mathlib.Linter.TextBased.StyleError✝) →
(lineNumber : ℕ) →
(path : System.FilePath) → motive { error := error, lineNumber := lineNumber, path := path }) →
motive t | null | false |
_private.Init.Data.Nat.ToString.0.Nat.length_toDigits_le_iff._simp_1_4 | Init.Data.Nat.ToString | ∀ {n : ℕ}, (n ≠ 0) = (0 < n) | null | false |
RBTree.RBSet.upperBoundP?_exists | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t : RBTree.RBSet α cmp} [Std.TransCmp cmp]
[RBTree.RBNode.IsCut cmp cut], (∃ x, t.upperBoundP? cut = some x) ↔ ∃ x ∈ t, cut x ≠ Ordering.gt | null | true |
Lean.Elab.Tactic.RCases.instCoeIdentTSyntaxConsSyntaxNodeKindMkStr1Nil_lean | Lean.Elab.Tactic.RCases | Coe Lean.Ident (Lean.TSyntax `rcasesPat) | null | true |
summable_of_sum_range_le | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {f : ℕ → ℝ} {c : ℝ}, (∀ (n : ℕ), 0 ≤ f n) → (∀ (n : ℕ), ∑ i ∈ Finset.range n, f i ≤ c) → Summable f | null | true |
ContinuousMultilinearMap.norm_mkPiAlgebraFin_zero | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {A : Type u_1} [inst_1 : SeminormedRing A]
[inst_2 : NormedAlgebra 𝕜 A], ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 0 A‖ = ‖1‖ | null | true |
Bimod.TensorBimod.actRight._proof_4 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{R S T : CategoryTheory.Mon C} (P : Bimod R S) (Q : Bimod S T)
[∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorRight X... | null | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.f'_eq | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
(hkf : CategoryTheory.Limits.IsLimit kf),
hkf.lift (CategoryTheory.Limits.KernelFork.ofι S.f ⋯) =
CategoryTheory.CategoryStruct.comp S.to... | null | true |
Finset.expect | Mathlib.Algebra.BigOperators.Expect | {ι : Type u_1} → {M : Type u_4} → [inst : AddCommMonoid M] → [Module ℚ≥0 M] → Finset ι → (ι → M) → M | Average of a function over a finset. If the finset is empty, this is equal to zero. | true |
FirstOrder.Ring.genericPolyMap.eq_1 | Mathlib.RingTheory.MvPolynomial.FreeCommRing | ∀ {ι : Type u_1} {κ : Type u_2} (monoms : ι → Finset (κ →₀ ℕ)) (i : ι),
FirstOrder.Ring.genericPolyMap monoms i =
∑ m ∈ (monoms i).attach, FreeCommRing.of (Sum.inl ⟨i, m⟩) * (↑m).prod fun j n => FreeCommRing.of (Sum.inr j) ^ n | null | true |
_private.Mathlib.Topology.ContinuousOn.0.continuousOn_singleton._simp_1_2 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {l : Filter β}, Filter.Tendsto f (pure a) l = ∀ s ∈ l, f a ∈ s | null | false |
CategoryTheory.GradedObject.isInitialSingleObjApply._proof_1 | Mathlib.CategoryTheory.GradedObject.Single | ∀ {J : Type u_3} {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Limits.HasInitial C] [inst_2 : DecidableEq J] (j : J) (X : C) (i : J),
i ≠ j → CategoryTheory.Limits.IsInitial (if i = j then X else ⊥_ C) = CategoryTheory.Limits.IsInitial (⊥_ C) | null | false |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithTop.pow_right_strictMono.match_1_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (h : 0 ≠ 0), motive 0 h) →
(∀ (x : 1 ≠ 0), motive 1 x) → (∀ (n : ℕ) (x : n + 2 ≠ 0), motive n.succ.succ x) → motive x x_1 | null | false |
Sylow.normal_of_normalizerCondition | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G],
NormalizerCondition G → ∀ {p : ℕ} [Fact (Nat.Prime p)] [Finite (Sylow p G)] (P : Sylow p G), (↑P).Normal | null | true |
iInf_singleton | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {b : β}, ⨅ x ∈ {b}, f x = f b | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Φ_neg._simp_1_5 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a | null | false |
ContinuousAddMonoidHom.instAddCommMonoid._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_1} {E : Type u_2} [inst : AddMonoid A] [inst_1 : TopologicalSpace A] [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] (x : A →ₜ+ E), nsmulRecAuto 0 x = 0 | null | false |
CategoryTheory.CommRingObjCat.instCategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y Z : CategoryTheory.CommRingObjCat C} (f : X.Hom Y) (g : Y.Hom Z),
CategoryTheory.IsRingHom (CategoryTheory.CategoryStruct.comp f.hom g.hom) | null | false |
instFintypeWithTop | Mathlib.Data.Fintype.WithTopBot | {α : Type u_1} → [Fintype α] → Fintype (WithTop α) | null | true |
NNReal.coe_real_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ↑NNReal.pi = Real.pi | null | true |
FiniteDimensional.RCLike.properSpace_submodule | Mathlib.Analysis.RCLike.Lemmas | ∀ (K : Type u_1) {E : Type u_2} [inst : RCLike K] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(S : Submodule K E) [FiniteDimensional K ↥S], ProperSpace ↥S | null | true |
_private.Mathlib.CategoryTheory.Generator.Basic.0.CategoryTheory.ObjectProperty.IsCoseparating.isCodetecting._simp_1_2 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.ObjectProperty C),
P.IsCoseparating = P.op.IsSeparating | null | false |
Finite.card_eq_zero_of_surjective | Mathlib.SetTheory.Cardinal.NatCard | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Surjective f → Nat.card β = 0 → Nat.card α = 0 | NB: `Nat.card` is defined to be `0` for infinite types. | true |
IsPrimitiveRoot.neZero' | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} {ζ : R} [inst : CommRing R] [IsDomain R] {n : ℕ} [NeZero n], IsPrimitiveRoot ζ n → NeZero ↑n | null | true |
MeasureTheory.setIntegral_indicatorConstLp | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{s t : Set X} {μ : MeasureTheory.Measure X} [CompleteSpace E] {p : ENNReal},
MeasurableSet s →
∀ (ht : MeasurableSet t) (hμt : μ t ≠ ⊤) (e : E),
∫ (x : X) in s, ↑↑(MeasureTheory.indicatorConst... | null | true |
Polynomial.degree_map_le | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {f : R →+* S} {p : Polynomial R},
(Polynomial.map f p).degree ≤ p.degree | null | true |
Std.ExtDHashMap.Const.get?_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] {f : α → β → Option γ} {k : α},
Std.ExtDHashMap.Const.get? (Std.ExtDHashMap.filterMap f m) k =
(Std.ExtDHashMap.Const.get? m k).pbind fun x_2 h' => f (m.getK... | null | true |
LinearMap.flip._proof_5 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_6} {R₂ : Type u_7} {S : Type u_3} {S₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : Semiring S] [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_2} {P : Type u_1} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module... | null | false |
Vector.toList_map | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {xs : Vector α n}, (Vector.map f xs).toList = List.map f xs.toList | null | true |
AddSemiconjBy.map._simp_1 | Mathlib.Algebra.Group.Commute.Hom | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : Add N] {a x y : M} [inst_2 : FunLike F M N]
[AddHomClass F M N], AddSemiconjBy a x y → ∀ (f : F), AddSemiconjBy (f a) (f x) (f y) = True | null | false |
Option.min_eq_some_iff._simp_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Min α] {o o' : Option α} {a : α},
(o ⊓ o' = some a) = ∃ b c, o = some b ∧ o' = some c ∧ b ⊓ c = a | null | false |
fourierSubalgebra_coe | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ}, Subalgebra.toSubmodule fourierSubalgebra.toSubalgebra = Submodule.span ℂ (Set.range fourier) | The star subalgebra of `C(AddCircle T, ℂ)` generated by `fourier n` for `n ∈ ℤ` is in fact the
linear span of these functions. | true |
AlgebraicGeometry.Spec.map_surjective | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | ∀ {R S : CommRingCat}, Function.Surjective AlgebraicGeometry.Spec.map | Useful for replacing `f` by `Spec.map φ` everywhere in proofs. | true |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.RingCompute.pow._proof_1 | Mathlib.Tactic.Ring.Basic | ∀ {b : Q(ℕ)} (lit : Q(ℕ)), «$b» =Q «$lit» | null | false |
FreeMonoid.map._proof_2 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x x_1 : FreeMonoid α),
List.map f (FreeMonoid.toList x ++ FreeMonoid.toList x_1) =
List.map f (FreeMonoid.toList x) ++ List.map f (FreeMonoid.toList x_1) | null | false |
Std.CloseableChannel.Error.alreadyClosed | Std.Sync.Channel | Std.CloseableChannel.Error | Tried to close an already closed channel.
| true |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_14 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → x :: y :: tail ≠ [] | null | false |
_private.Lean.Meta.Tactic.Replace.0.Lean.MVarId.withReverted.match_1 | Lean.Meta.Tactic.Replace | (motive : Option Lean.FVarId → Sort u_1) →
(x? : Option Lean.FVarId) → ((x : Lean.FVarId) → motive (some x)) → ((x : Option Lean.FVarId) → motive x) → motive x? | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.toList_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Order.IsPredLimit.ne_top | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : OrderTop α], Order.IsPredLimit a → a ≠ ⊤ | null | true |
_private.Mathlib.Analysis.Analytic.Within.0.hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt._simp_1_10 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) | null | false |
MeasureTheory.Lp.coe_posPart._simp_1 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} (f : ↥(MeasureTheory.Lp ℝ p μ)),
(↑f).posPart = ↑(MeasureTheory.Lp.posPart f) | null | false |
CategoryTheory.mono_iff_injective | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (f : X ⟶ Y), CategoryTheory.Mono f ↔ Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) | A morphism in `Type` is a monomorphism if and only if it is injective. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.