name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
EisensteinSeries.E2_periodic | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | Function.Periodic (EisensteinSeries.E2 ∘ ↑UpperHalfPlane.ofComplex) 1 | `E2 ∘ ofComplex` has period `1`. | true |
Std.DTreeMap.Internal.Impl.Const.get!ₘ | Std.Data.DTreeMap.Internal.Model | {α : Type u} → {β : Type v} → [Ord α] → (Std.DTreeMap.Internal.Impl α fun x => β) → α → [Inhabited β] → β | Model implementation of the `get!` function.
Internal implementation detail of the tree map
| true |
String.skipPrefix? | Init.Data.String.TakeDrop | {ρ : Type} → (s : String) → (pat : ρ) → [String.Slice.Pattern.ForwardPattern pat] → Option s.Pos | If `pat` matches a prefix of `s`, returns the position at the start of the remainder.
Returns `none` otherwise.
This function is generic over all currently supported patterns.
| true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts₁_supportsStmt_mono._simp_1_15 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | null | false |
Ideal.span_singleton_absNorm_le | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDedekindDomain S] [inst_2 : Infinite S] (I : Ideal S),
Ideal.span {↑(Ideal.absNorm I)} ≤ I | null | true |
Subrepresentation.toRepresentation_apply_mk._simp_1 | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} {ρ' : Subrepresentation ρ} {g : G} {v w : W} {hv : v ∈ ρ'}
{hw : w ∈ ρ'}, ((ρ'.toRepresentation g) ⟨v, hv⟩ = ⟨w, hw⟩) = ((ρ g) v = w) | null | false |
_private.Mathlib.RepresentationTheory.Induced.0.Rep.indResHomEquiv._simp_1 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} {W : Type u_9} [inst : CommRing k] [inst_1 : Group G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
(ρ : Representation k G V) (τ : Representation k G W) (x : V) (y : W) (g : G),
(Representation.Coinvariants.mk (ρ.tpr... | null | false |
_private.Lean.Meta.Tactic.Simp.Simproc.0.Lean.Meta.Simp.initFn._@.Lean.Meta.Tactic.Simp.Simproc.1481072680._hygCtx._hyg.2 | Lean.Meta.Tactic.Simp.Simproc | IO (IO.Ref Lean.Meta.Simp.BuiltinSimprocs) | null | false |
NormalizationMonoid.ofUniqueUnits | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_1} → [inst : CommMonoidWithZero α] → [Subsingleton αˣ] → StrongNormalizationMonoid α | **Alias** of `instStrongNormalizationMonoid`. | true |
MonoidHom.toAdditiveRightMulEquiv._proof_1 | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : CommMonoid N] (x x_1 : Multiplicative M →* N),
(MonoidHom.toAdditiveRight.trans Multiplicative.ofAdd).toFun (x * x_1) =
(MonoidHom.toAdditiveRight.trans Multiplicative.ofAdd).toFun (x * x_1) | null | false |
Matroid.IsStrictMinor.trans | Mathlib.Combinatorics.Matroid.Minor.Order | ∀ {α : Type u_1} {M M' N : Matroid α}, N <m M → M <m M' → N <m M' | null | true |
Polynomial.associated_of_dvd_of_natDegree_le_of_leadingCoeff | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] {p q : Polynomial R},
p ∣ q → q.natDegree ≤ p.natDegree → q.leadingCoeff ∣ p.leadingCoeff → Associated p q | null | true |
Lean.Grind.CommRing.Poly | Init.Grind.Ring.CommSolver | Type | null | true |
TrivSqZeroExt.addMonoid._proof_1 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddMonoid R] [inst_1 : AddMonoid M] (a b c : TrivSqZeroExt R M),
a + b + c = a + (b + c) | null | false |
ContinuousWithinAt.eq_const_of_mem_closure | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T1Space Y] {f : X → Y}
{s : Set X} {x : X} {c : Y}, ContinuousWithinAt f s x → x ∈ closure s → (∀ y ∈ s, f y = c) → f x = c | null | true |
MeasureTheory.OuterMeasure.trim_zero | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasureTheory.OuterMeasure.trim 0 = 0 | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk'_obj | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) (a : B),
(CategoryTheory.StrictlyUnitaryLaxFunctor.mk' S).obj a = S.obj a | null | true |
Topology.IsEmbedding.toPartialHomeomorph | Mathlib.Topology.PartialHomeomorph.Basic | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → (f : X → Y) → Topology.IsEmbedding f → [Nonempty X] → PartialHomeomorph X Y | An embedding of `X` into `Y`, with `X` nonempty, defines a partial homeomorphism
whose source is all of `X`. The converse is also true; see `PartialHomeomorph.isEmbedding`. | true |
_private.Lean.Compiler.LCNF.Simp.SimpValue.0.Lean.Compiler.LCNF.Simp.simpAppApp?.match_3 | Lean.Compiler.LCNF.Simp.SimpValue | (motive : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(__x : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure)) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) → motive (some decl)) →
((x : Option (Lean.Compiler.LCNF.LetDecl Lean.Co... | null | false |
CommRingCat.commRingObj._proof_2 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J CommRingCat) (j : J)
(n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Lean.Parser.Term.doLetRec | Lean.Parser.Do | Lean.Parser.Parser | null | true |
_private.Lean.Data.RArray.0.Lean.RArray.get_ofFn._proof_1_3 | Lean.Data.RArray | ∀ {n : ℕ} (i : Fin n), ∀ lb ≤ ↑i, ↑i < lb + 1 → ¬lb = ↑i → False | null | false |
IsDedekindDomain.HeightOneSpectrum.adicCompletion._sizeOf_inst | Mathlib.RingTheory.DedekindDomain.AdicValuation | {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} →
(v : IsDedekindDomain.HeightOneSpectrum R) →
[SizeOf R] → [SizeOf K] → SizeOf (IsD... | null | false |
IsPrimitiveRoot.toInteger_coe | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {K : Type u} [inst : Field K] {k : ℕ} [inst_1 : NeZero k] {x : NumberField.RingOfIntegers K}
(hx : IsPrimitiveRoot (↑x) k), hx.toInteger = x | null | true |
CategoryTheory.SpectralSequence.Hom._sizeOf_1 | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} → {E E' : CategoryTheory.SpectralSequence C c r₀} → [SizeOf C] → [SizeOf κ] → E.Hom E' → ℕ | null | false |
RingHom.FinitePresentation.of_finiteType | Mathlib.RingTheory.FinitePresentation | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [IsNoetherianRing A] {f : A →+* B},
f.FiniteType ↔ f.FinitePresentation | null | true |
PresentedMonoid.closure_range_of | Mathlib.Algebra.PresentedMonoid.Basic | ∀ {α : Type u_2} (rels : FreeMonoid α → FreeMonoid α → Prop),
Submonoid.closure (Set.range (PresentedMonoid.of rels)) = ⊤ | The generators of a presented monoid generate the presented monoid. That is, the submonoid
closure of the set of generators equals `⊤`. | true |
AddSubgroup.IsSubnormal.below.step | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_2} [inst : AddGroup G] {motive : (a : AddSubgroup G) → a.IsSubnormal → Prop} (H K : AddSubgroup G)
(h_le : H ≤ K) (hSubn : K.IsSubnormal) (hN : (H.addSubgroupOf K).Normal),
AddSubgroup.IsSubnormal.below hSubn → motive K hSubn → AddSubgroup.IsSubnormal.below ⋯ | null | true |
Setoid.liftEquiv._proof_2 | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (r : Setoid α),
Function.LeftInverse (fun f => ⟨f ∘ Quotient.mk'', ⋯⟩) fun f => Quotient.lift ↑f ⋯ | null | false |
CategoryTheory.BraidedCategory.curriedBraidingNatIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C) {X_1 Y : C} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.MonoidalCategory.curriedTensor C).obj X).map f) (β_ X Y).hom =
CategoryT... | null | false |
Aesop.EqualUpToIds.MVarValue.ctorIdx | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIds.MVarValue → ℕ | null | false |
MeasureTheory.eLpNorm'_zero' | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α} {ε : Type u_8}
[inst : TopologicalSpace ε] [inst_1 : ESeminormedAddMonoid ε], q ≠ 0 → μ ≠ 0 → MeasureTheory.eLpNorm' 0 q μ = 0 | null | true |
Simps.ProjectionRule.add.inj | Mathlib.Tactic.Simps.Basic | ∀ {a : Lean.Name} {a_1 : Lean.Syntax} {a_2 : Lean.Name} {a_3 : Lean.Syntax},
Simps.ProjectionRule.add a a_1 = Simps.ProjectionRule.add a_2 a_3 → a = a_2 ∧ a_1 = a_3 | null | true |
CategoryTheory.instHasLimitsOfShapeOverOfWithTerminal | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
(X : C) [CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.WithTerminal J) C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Over X) | null | true |
CategoryTheory.AddMonObj.lift_comp_zero_right | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.AddMonObj B] (f : A ⟶ B)
(g : A ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCat... | null | true |
CategoryTheory.Abelian.SpectralObject.opcyclesIsoH_hom_inv_id._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
Matrix.«_aux_Mathlib_LinearAlgebra_Matrix_ConjTranspose___macroRules_Matrix_term_ᴴ_1» | Mathlib.LinearAlgebra.Matrix.ConjTranspose | Lean.Macro | null | false |
Set.Ioc_disjoint_Ioi | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] {a b c : α}, b ≤ c → Disjoint (Set.Ioc a b) (Set.Ioi c) | null | true |
CategoryTheory.ComposableArrows.homMk₄._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | 2 < 4 + 1 | null | false |
Mathlib.Tactic.Polynomial.map_algebraMap | Mathlib.Tactic.Polynomial.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (r : R),
Polynomial.map (algebraMap R A) ((algebraMap R (Polynomial R)) r) = (algebraMap A (Polynomial A)) ((algebraMap R A) r) | null | true |
ZFClass.mem_powerset | Mathlib.SetTheory.ZFC.Class | ∀ {A : ZFClass.{u}} {x : ZFSet.{u}}, x ∈ A.powerset ↔ ↑x ⊆ A | null | true |
Lean.Meta.Grind.Goal.hasSameRoot | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Goal → Lean.Expr → Lean.Expr → Bool | null | true |
egauge_pi' | Mathlib.Analysis.Convex.EGauge | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} [inst : NormedDivisionRing 𝕜] [inst_1 : (i : ι) → AddCommGroup (E i)]
[inst_2 : (i : ι) → Module 𝕜 (E i)] {I : Set ι},
I.Finite →
∀ {U : (i : ι) → Set (E i)},
(∀ i ∈ I, Balanced 𝕜 (U i)) →
∀ (x : (i : ι) → E i),
I = Set.univ ∨ (∃ i ∈... | The extended gauge of a point `x` in an indexed product
with respect to a product of finitely many balanced sets `U i`, `i ∈ I`,
(and the whole spaces for the other indices)
is the supremum of the extended gauges of the components of `x`
with respect to the corresponding balanced set.
This version assumes the followin... | true |
CyclotomicRing.eq_adjoin_primitive_root | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) [NeZero n] (A : Type u) (K : Type w) [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K]
{μ : CyclotomicField n K}, IsPrimitiveRoot μ n → CyclotomicRing n A K = ↥A[μ] | null | true |
MonomialOrder.addCommMonoidSyn | Mathlib.Data.Finsupp.MonomialOrder | {σ : Type u_1} → (self : MonomialOrder σ) → AddCommMonoid self.syn | `syn` is an additive commutative monoid | true |
CategoryTheory.yonedaMon._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(x : CategoryTheory.Mon C), CategoryTheory.IsMonHom (CategoryTheory.CategoryStruct.id x).hom | null | false |
Std.ExtDHashMap.filterMap_eq_map | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] {f : (a : α) → β a → γ a},
Std.ExtDHashMap.filterMap (fun k v => some (f k v)) m = Std.ExtDHashMap.map f m | null | true |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.NormalizationMonoid.ofRightInverse._simp_2 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (u : M₀ˣ) {a : M₀}, (a * ↑u = 0) = (a = 0) | null | false |
ISize.ofIntLE_eq_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : ISize.minValue.toInt ≤ x} {h₂ : x ≤ ISize.maxValue.toInt}, ISize.ofIntLE x h₁ h₂ = ISize.ofIntClamp x | null | true |
CategoryTheory.NatTrans.naturality._autoParam | Mathlib.CategoryTheory.NatTrans | Lean.Syntax | null | false |
CategoryTheory.Limits.HasWidePushouts | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | A category `HasWidePushouts` if it has all colimits of shape `WidePushoutShape J`, i.e. if it
has a wide pushout for every collection of morphisms with the same domain. | true |
wbtw_self_iff._simp_1 | Mathlib.Analysis.Convex.Between | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {x y : P}, Wbtw R x y x = (y = x) | null | false |
Lean.Compiler.LCNF.Simp.DiscrM | Lean.Compiler.LCNF.Simp.DiscrM | Type → Type | Helper monad for tracking mappings from discriminant to constructor applications and back.
The combinator `withDiscrCtor` should be used when visiting `cases` alternatives.
| true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm.casesOn | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {α : ℕ → ℕ → Type} →
{motive : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm α → Sort u} →
(t : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm α) →
((getElem : {n m : ℕ} → α n m → ℕ → ℕ → ℚ) →
(setElem : {n m : ℕ} → α n m → ℕ → ℕ → ℚ → α n m) →
(g... | null | false |
VertexOperator.ncoeff_apply | Mathlib.Algebra.Vertex.VertexOperator | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(A : VertexOperator R V) (n : ℤ), VertexOperator.ncoeff A n = HVertexOperator.coeff A (-n - 1) | null | true |
Lean.TrailingParserDescr | Init.Prelude | Type | Although `TrailingParserDescr` is an abbreviation for `ParserDescr`, Lean will
look at the declared type in order to determine whether to add the parser to
the leading or trailing parser table. The determination is done automatically
by the `syntax` command.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss.0.Polynomial.Chebyshev.sumZeroes_T_of_not_dvd._proof_1_9 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss | ∀ {n : ℕ} {k : ℤ},
¬2 * ↑n ∣ k →
n ≠ 0 →
Complex.exp (↑k / ↑n * ↑Real.pi * Complex.I) = Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 →
¬Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 - 1 = 0 ∧
¬1 - Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 = 0 | null | false |
Asymptotics.instTransForallIsBigOIsTheta | Mathlib.Analysis.Asymptotics.Theta | {α : Type u_1} →
{E : Type u_3} →
{G : Type u_5} →
{F' : Type u_7} →
[inst : Norm E] →
[inst_1 : Norm G] →
[inst_2 : SeminormedAddCommGroup F'] →
{l : Filter α} → Trans (Asymptotics.IsBigO l) (Asymptotics.IsTheta l) (Asymptotics.IsBigO l) | null | true |
FreeGroup.Red.eq_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u}, FreeGroup.Red = Relation.ReflTransGen FreeGroup.Red.Step | null | true |
String.utf8Len.eq_def | Batteries.Data.String.Lemmas | ∀ (x : List Char),
String.utf8Len x =
match x with
| [] => 0
| c :: cs => String.utf8Len cs + c.utf8Size | null | true |
_private.Mathlib.Data.EReal.Operations.0.Mathlib.Meta.Positivity.evalERealAdd._proof_2 | Mathlib.Data.EReal.Operations | ∀ (α : Q(Type)) (pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$pα» =Q instPartialOrderEReal)),
«$pα» =Q instPartialOrderEReal | null | false |
Std.Tactic.BVDecide.BVExpr.WithCache.ctorIdx | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {α : Type u} → {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} → Std.Tactic.BVDecide.BVExpr.WithCache α aig → ℕ | null | false |
MeasureTheory.unifTight_iff_nnreal | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : NormedAddCommGroup β] {x : MeasurableSpace α} (f : ι → α → β)
(p : ENNReal) (μ : MeasureTheory.Measure α),
MeasureTheory.UnifTight f p μ ↔
∀ ⦃ε : NNReal⦄, 0 < ε → ∃ s, μ s ≠ ⊤ ∧ ∀ (i : ι), MeasureTheory.eLpNorm (sᶜ.indicator (f i)) p μ ≤ ↑ε | null | true |
PrincipalSeg.ofElement_toFun | Mathlib.Order.InitialSeg | ∀ {α : Type u_4} (r : α → α → Prop) (a : α) (self : { x // r x a }), (PrincipalSeg.ofElement r a).toFun self = ↑self | null | true |
Equiv.Perm.Basis.rec | Mathlib.GroupTheory.Perm.Centralizer | {α : Type u_1} →
[inst : DecidableEq α] →
[inst_1 : Fintype α] →
{g : Equiv.Perm α} →
{motive : g.Basis → Sort u} →
((toFun : ↥g.cycleFactorsFinset → α) →
(mem_support_self' : ∀ (c : ↥g.cycleFactorsFinset), toFun c ∈ (↑c).support) →
motive { toFun := toFun, me... | null | false |
Nat.dfold_add._proof_16 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i ≤ n, i ≤ n + m | null | false |
USize._sizeOf_1._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.299 | Mathlib.Util.CompileInductive | USize → ℕ | null | false |
Lean.Grind.CommRing.Mon.revlexFuel.induct_unfolding | Init.Grind.Ring.CommSolver | ∀ (motive : ℕ → Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Ordering → Prop),
(∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), motive 0 m₁ m₂ (m₁.revlexWF m₂)) →
(∀ (fuel : ℕ), motive fuel.succ Lean.Grind.CommRing.Mon.unit Lean.Grind.CommRing.Mon.unit Ordering.eq) →
(∀ (fuel : ℕ) (p : Lean.Grind.CommRing.Power... | null | true |
_private.Std.Data.Iterators.Lemmas.Producers.Repeat.0.Nat.repeat.match_1.splitter | Std.Data.Iterators.Lemmas.Producers.Repeat | {α : Type u_2} →
(motive : ℕ → α → Sort u_1) →
(x : ℕ) → (x_1 : α) → ((a : α) → motive 0 a) → ((n : ℕ) → (a : α) → motive n.succ a) → motive x x_1 | null | true |
Ideal.span_range_eq_span_range_support | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {ι : Type u_1} (x : ι → α),
Ideal.span (Set.range x) = Ideal.span (Set.range fun i => x ↑i) | null | true |
MulActionHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ (F : Type u_8) (M : Type u_9) (X : Type u_10) (Y : Type u_11) [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y], MulActionHomClass F M X Y = MulActionSemiHomClass F id X Y | null | true |
Std.DHashMap.Raw.Equiv.constInsertMany_list | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m₁.WF →
m₂.WF →
∀ (l : List (α × β)),
m₁.Equiv m₂ → (Std.DHashMap.Raw.Const.insertMany m₁ l).Equiv (Std.DHashMap.Raw.Const.insertMany m₂ l) | null | true |
CategoryTheory.Functor.isoWhiskerRight_left_assoc | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) {G H : CategoryTheory.Functor C D}
(α : G... | null | true |
HomologicalComplex.homologicalComplexToDGO | Mathlib.Algebra.Homology.DifferentialObject | {β : Type u_1} →
[inst : AddCommGroup β] →
(b : β) →
(V : Type u_2) →
[inst_1 : CategoryTheory.Category.{v_1, u_2} V] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V] →
CategoryTheory.Functor (HomologicalComplex V (ComplexShape.up' b))
(CategoryTheory.Differe... | The functor from homological complexes to differential graded objects.
| true |
Lean.Lsp.SymbolInformation.containerName? | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolInformation → Option String | null | true |
Fin.insertNthEquiv_last | Mathlib.Data.Fin.Tuple.Basic | ∀ (n : ℕ) (α : Type u_3), Fin.insertNthEquiv (fun x => α) (Fin.last n) = Fin.snocEquiv fun x => α | Note this lemma can only be written about non-dependent tuples as `insertNth (last n) = snoc` is
not a definitional equality. | true |
Int.inductionOn'_add_one | Mathlib.Data.Int.Init | ∀ {motive : ℤ → Sort u_1} {z b : ℤ} {zero : motive b} {succ : (k : ℤ) → b ≤ k → motive k → motive (k + 1)}
{pred : (k : ℤ) → k ≤ b → motive k → motive (k - 1)} (hz : b ≤ z),
Int.inductionOn' (z + 1) b zero succ pred = succ z hz (Int.inductionOn' z b zero succ pred) | null | true |
RatFunc.CompletionAtInfty.instValuedWithZeroMultiplicativeInt._proof_10 | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] (x : RatFunc.CompletionAtInfty F),
nhds x = Filter.comap (Prod.mk x) (RatFunc.CompletionAtInfty.instValuedWithZeroMultiplicativeInt._aux_6 F) | null | false |
ProbabilityTheory.Kernel.integral_deterministic' | Mathlib.Probability.Kernel.Integral | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {E : Type u_3}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : β → E} {a : α} [CompleteSpace E] {g : α → β}
(hg : Measurable g),
MeasureTheory.StronglyMeasurable f → ∫ (x : β), f x ∂(ProbabilityTheory.Kernel.determinis... | null | true |
CategoryTheory.Limits.MonoFactorisation.e | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f : X ⟶ Y} → (self : CategoryTheory.Limits.MonoFactorisation f) → X ⟶ self.I | A factorisation of a morphism `f = e ≫ m`, with `m` monic. | true |
Mathlib.Meta.FunProp.DecompositionResult.failed.elim | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.DecompositionResult → Sort u} →
(t : Mathlib.Meta.FunProp.DecompositionResult) →
t.ctorIdx = 2 → motive Mathlib.Meta.FunProp.DecompositionResult.failed → motive t | null | false |
List.min_singleton | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] {x : α}, [x].min ⋯ = x | null | true |
Multiset.zero_product | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} (t : Multiset β), 0 ×ˢ t = 0 | null | true |
ChevalleyThm.MvPolynomialC.degBound_casesOn_succ._mutual | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ (k₀ k : ℕ) (D : ℕ → ℕ) (x : ℕ ⊕' ℕ),
PSum.casesOn x
(fun _x =>
ChevalleyThm.MvPolynomialC.degBound k₀ (fun t => Nat.casesOn t k D) (_x + 1) =
(k₀ * k) ^ (k₀ * k) * ChevalleyThm.MvPolynomialC.degBound (k₀ * k) ((k₀ * k) ^ (k₀ * k) • D) _x)
fun _x =>
ChevalleyThm.MvPolynomialC.numBound k₀ (f... | null | false |
Directed.le_sequence | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable α] [inst_1 : Inhabited α] [inst_2 : Preorder β] {f : α → β}
(hf : Directed (fun x1 x2 => x1 ≤ x2) f) (a : α), f a ≤ f (Directed.sequence f hf (Encodable.encode a + 1)) | null | true |
_private.Mathlib.Data.Finsupp.Indicator.0.Finsupp.indicator_indicator._proof_1_2 | Mathlib.Data.Finsupp.Indicator | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) {t : Finset ι} (f : (i : ι) → i ∈ s → α)
[inst_1 : DecidableEq ι],
(Finsupp.indicator t fun i x => (Finsupp.indicator s f) i) = Finsupp.indicator (s ∩ t) fun i hi => f i ⋯ | null | false |
BialgCat.mk | Mathlib.Algebra.Category.BialgCat.Basic | {R : Type u} →
[inst : CommRing R] →
(carrier : Type v) → [instRing : Ring carrier] → [instBialgebra : Bialgebra R carrier] → BialgCat R | null | true |
Std.TreeSet.Raw.le_maxD_of_contains | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxD fallback)).isLE = true | null | true |
AffineSubspace.SOppSide.trans_wSameSide | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y z : P}, s.SOppSide x y → s.WSameSide y z → s.WOppSide x z | null | true |
SupBotHom.dual_comp | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Max α] [inst_1 : Bot α] [inst_2 : Max β] [inst_3 : Bot β]
[inst_4 : Max γ] [inst_5 : Bot γ] (g : SupBotHom β γ) (f : SupBotHom α β),
SupBotHom.dual (g.comp f) = (SupBotHom.dual g).comp (SupBotHom.dual f) | null | true |
_private.Mathlib.Basic.Rel.0.SetRel.sUnion_comp._proof_1_1 | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (ℛ : Set (SetRel α β)) (S : SetRel β γ),
SetRel.comp (⋃₀ ℛ) S = ⋃ R ∈ ℛ, SetRel.comp R S | null | false |
UInt16.le_refl._simp_1 | Init.Data.UInt.Lemmas | ∀ (a : UInt16), (a ≤ a) = True | null | false |
AlexDisc.recOn | Mathlib.Topology.Order.Category.AlexDisc | {motive : AlexDisc → Sort u} →
(t : AlexDisc) →
((toTopCat : TopCat) →
[is_alexandrovDiscrete : AlexandrovDiscrete ↑toTopCat] →
motive { toTopCat := toTopCat, is_alexandrovDiscrete := is_alexandrovDiscrete }) →
motive t | null | false |
_private.Mathlib.Data.Fintype.Prod.0.Finset.product_eq_univ._simp_1_1 | Mathlib.Data.Fintype.Prod | ∀ {α : Type u_1} [inst : Fintype α] {s : Finset α}, (s = Finset.univ) = ∀ (x : α), x ∈ s | null | false |
PowerSeries.exp_pow_eq_rescale_exp | Mathlib.RingTheory.PowerSeries.Exp | ∀ {A : Type u_4} [inst : CommRing A] [inst_1 : Algebra ℚ A] (k : ℕ),
PowerSeries.exp A ^ k = (PowerSeries.rescale ↑k) (PowerSeries.exp A) | Shows that $(e^{X})^k = e^{kX}$. | true |
ContinuousMulEquiv.eq_symm_comp | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {α : Type u_3} (e : M ≃ₜ* N) (f : α → M) (g : α → N), f = ⇑e.symm ∘ g ↔ ⇑e ∘ f = g | null | true |
QuotientGroup.preimage_image_mk | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : Group α] (N : Subgroup α) (s : Set α),
QuotientGroup.mk ⁻¹' QuotientGroup.mk '' s = ⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s | null | true |
ZFSet.singleton_inj._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {x y : ZFSet.{u_1}}, ({x} = {y}) = (x = y) | null | false |
CategoryTheory.Limits.WalkingMultispan.instSubsingletonHomLeft | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MultispanShape} (a b : J.L),
Subsingleton (CategoryTheory.Limits.WalkingMultispan.left a ⟶ CategoryTheory.Limits.WalkingMultispan.left b) | null | true |
Representation.IntertwiningMap.centralAlgebraMulHom._proof_2 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_2} {G : Type u_3} {V : Type u_1} [inst : CommSemiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module A V] (ρ : Representation A G V), Representation.IntertwiningMap.centralAlgebraMul ρ ⋯ = 1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.