name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Chebyshev.integral_theta_div_log_sq_isLittleO | Mathlib.NumberTheory.Chebyshev | (fun x => ∫ (t : ℝ) in 2..x, Chebyshev.theta t / (t * Real.log t ^ 2)) =o[Filter.atTop] fun x => x / Real.log x | true |
typeToPointed._proof_3 | Mathlib.CategoryTheory.Category.Pointed | ∀ (x : Type u_1),
{ toFun := Option.map (CategoryTheory.CategoryStruct.id x), map_point := ⋯ } =
CategoryTheory.CategoryStruct.id { X := Option x, point := none } | false |
MeasureTheory.lintegral_sub_right_eq_self | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_1 : AddGroup G] [MeasurableAdd G]
[μ.IsAddRightInvariant] (f : G → ENNReal) (g : G), ∫⁻ (x : G), f (x - g) ∂μ = ∫⁻ (x : G), f x ∂μ | true |
Std.HashSet.Raw.mem_toList._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α}, (k ∈ m.toList) = (k ∈ m) | false |
WithTop.measurable_of_measurable_comp_coe | Mathlib.MeasureTheory.Constructions.BorelSpace.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι]
[inst_3 : MeasurableSpace ι] [BorelSpace ι] {α : Type u_2} {mα : MeasurableSpace α} {f : WithTop ι → α},
(Measurable fun p => f ↑p) → Measurable f | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Ordering.swap.match_1.splitter | Std.Data.DTreeMap.Internal.Model | (motive : Ordering → Sort u_1) →
(x : Ordering) → (Unit → motive Ordering.lt) → (Unit → motive Ordering.eq) → (Unit → motive Ordering.gt) → motive x | true |
Option.pfilter_filter | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {p : α → Bool} {q : (a : α) → Option.filter p o = some a → Bool},
(Option.filter p o).pfilter q = o.pfilter fun a h => if h' : p a = true then q a ⋯ else false | true |
Lean.Compiler.LCNF.Check.Pure.State.all | Lean.Compiler.LCNF.Check | Lean.Compiler.LCNF.Check.Pure.State → Lean.FVarIdHashSet | true |
Lean.Meta.LazyDiscrTree.instEmptyCollectionTrie | Lean.Meta.LazyDiscrTree | {α : Type} → EmptyCollection (Lean.Meta.LazyDiscrTree.Trie α) | true |
Lean.Lsp.CompletionItemTag.deprecated.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.CompletionItemTag.deprecated = 1 | true |
LowerSet.mem_Iic_iff._simp_1 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (b ∈ LowerSet.Iic a) = (b ≤ a) | false |
ModuleCat.HasColimit.colimitCocone_pt_isModule | Mathlib.Algebra.Category.ModuleCat.Colimits | ∀ {R : Type w} [inst : Ring R] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : CategoryTheory.Limits.HasColimit (F.comp (CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat))],
(ModuleCat.HasColimit.colimitCocone F).pt.isModule =
ModuleCat.instModuleCarrierMkOfSMul' (ModuleCat.HasColimit.coconePointSMul F) | true |
tendsto_birkhoffAverage_apply_sub_birkhoffAverage' | Mathlib.Dynamics.BirkhoffSum.NormedSpace | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] (𝕜 : Type u_3) [inst_1 : RCLike 𝕜]
[inst_2 : NormedSpace 𝕜 E] {g : α → E},
Bornology.IsBounded (Set.range g) →
∀ (f : α → α) (x : α),
Filter.Tendsto (fun n => birkhoffAverage 𝕜 f g n (f x) - birkhoffAverage 𝕜 f g n x) Filter.atTop (nhds 0) | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Basic.0.linearIndependent_unique_iff._simp_1_3 | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {α : Sort u_1} [inst : Unique α] {p : α → Prop}, (∀ (a : α), p a) = p default | false |
EisensteinSeries.G2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | UpperHalfPlane → ℂ | true |
WeierstrassCurve.Affine.baseChange_polynomialX | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} {S : Type s} {A : Type u} {B : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A]
[inst_3 : CommRing B] {W : WeierstrassCurve.Affine R} [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsScalarTower R S B]
(f : A →ₐ[S] B),
(WeierstrassCurve.baseChange W B).toAffine.polynomialX =
Polynomial.map (Polynomial.mapRingHom ↑f) (WeierstrassCurve.baseChange W A).toAffine.polynomialX | true |
Subsemiring.comap_comap | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S]
[inst_2 : NonAssocSemiring T] (s : Subsemiring T) (g : S →+* T) (f : R →+* S),
Subsemiring.comap f (Subsemiring.comap g s) = Subsemiring.comap (g.comp f) s | true |
lift_cardinalMk_eq_lift_cardinalMk_field_pow_lift_rank | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ (K : Type u) (V : Type v) [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[Module.Free K V] [Module.Finite K V],
Cardinal.lift.{u, v} (Cardinal.mk V) = Cardinal.lift.{v, u} (Cardinal.mk K) ^ Cardinal.lift.{u, v} (Module.rank K V) | true |
MeasureTheory.locallyIntegrableOn_congr | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f g : X → ε} {μ : MeasureTheory.Measure X} {s : Set X},
f =ᵐ[μ.restrict s] g → (MeasureTheory.LocallyIntegrableOn f s μ ↔ MeasureTheory.LocallyIntegrableOn g s μ) | true |
Nat.repr_of_ge | Init.Data.Nat.ToString | ∀ {n : ℕ}, 10 ≤ n → n.repr = (n / 10).repr ++ String.singleton (n % 10).digitChar | true |
CategoryTheory.Precoverage.Saturate.recOn | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.Precoverage C}
{motive : (X : C) → (a : CategoryTheory.Sieve X) → J.Saturate X a → Prop} {X : C} {a : CategoryTheory.Sieve X}
(t : J.Saturate X a),
(∀ (X : C) (S : CategoryTheory.Presieve X) (hS : S ∈ J.coverings X), motive X (CategoryTheory.Sieve.generate S) ⋯) →
(∀ (X : C), motive X ⊤ ⋯) →
(∀ (X : C) (S : CategoryTheory.Sieve X) (a : J.Saturate X S) (Y : C) (f : Y ⟶ X),
motive X S a → motive Y (CategoryTheory.Sieve.pullback f S) ⋯) →
(∀ (X : C) (S R : CategoryTheory.Sieve X) (a : J.Saturate X S)
(a_1 : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → J.Saturate Y (CategoryTheory.Sieve.pullback f R)),
motive X S a →
(∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄ (a : S.arrows f), motive Y (CategoryTheory.Sieve.pullback f R) ⋯) → motive X R ⋯) →
motive X a t | false |
_private.Mathlib.Algebra.Polynomial.HasseDeriv.0.Polynomial.natDegree_hasseDeriv_le._simp_1_6 | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | false |
Int32.neg_mul_neg | Init.Data.SInt.Lemmas | ∀ (a b : Int32), -a * -b = a * b | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.NatOffset.recOn | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | {motive : Nat.NatOffset✝ → Sort u} →
(t : Nat.NatOffset✝¹) →
((n : ℕ) → motive (Nat.NatOffset.const✝ n)) →
((e o : Lean.Expr) → (n : ℕ) → motive (Nat.NatOffset.offset✝ e o n)) → motive t | false |
StructureGroupoid.noConfusionType | Mathlib.Geometry.Manifold.StructureGroupoid | Sort u →
{H : Type u_2} →
[inst : TopologicalSpace H] →
StructureGroupoid H → {H' : Type u_2} → [inst' : TopologicalSpace H'] → StructureGroupoid H' → Sort u | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.mk._flat_ctor | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{F : CategoryTheory.Functor J C} →
{c : CategoryTheory.Limits.Cocone F} →
{X Y : C} →
{p : X ⟶ Y} →
{f : F.obj ⊥ ⟶ X} →
{g : c.pt ⟶ Y} →
{j : J} →
(f' : F.obj j ⟶ X) →
autoParam (CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.homOfLE ⋯)) f' = f)
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.w₁._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp f' p =
CategoryTheory.CategoryStruct.comp (c.ι.app j) g)
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.w₂._autoParam →
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct c p f g j | false |
Std.Do.WP.withReader_MonadWithReader | Std.Do.WP.SimpLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {ρ α : Type u} {Q : Std.Do.PostCond α ps} [inst : MonadWithReaderOf ρ m]
[inst_1 : Std.Do.WP m ps] (f : ρ → ρ) (x : m α),
(Std.Do.wp (withReader f x)).apply Q = (Std.Do.wp (MonadWithReaderOf.withReader f x)).apply Q | true |
CategoryTheory.Abelian.SpectralObject.fromOpcycles | Mathlib.Algebra.Homology.SpectralObject.Cycles | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
(X : CategoryTheory.Abelian.SpectralObject C ι) →
{i j k : ι} →
(f : i ⟶ j) →
(g : j ⟶ k) →
(fg : i ⟶ k) →
CategoryTheory.CategoryStruct.comp f g = fg →
(n : ℤ) → X.opcycles f g n ⟶ (X.H n).obj (CategoryTheory.ComposableArrows.mk₁ fg) | true |
ContinuousLinearEquiv.ofFinrankEq._proof_2 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E],
Module.Free 𝕜 E | false |
Filter.Tendsto.eventually_intervalIntegrable_ae | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ι : Type u_1} {E : Type u_5} [inst : NormedAddCommGroup E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
{l l' : Filter ℝ},
StronglyMeasurableAtFilter f l' μ →
∀ [Filter.TendstoIxxClass Set.Ioc l l'] [l'.IsMeasurablyGenerated],
μ.FiniteAtFilter l' →
∀ {c : E},
Filter.Tendsto f (l' ⊓ MeasureTheory.ae μ) (nhds c) →
∀ {u v : ι → ℝ} {lt : Filter ι},
Filter.Tendsto u lt l → Filter.Tendsto v lt l → ∀ᶠ (t : ι) in lt, IntervalIntegrable f μ (u t) (v t) | true |
_private.Lean.Meta.PProdN.0.Lean.Meta.PProdN.unpack.go._sparseCasesOn_1 | Lean.Meta.PProdN | {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 | false |
SchwartzMap.compCLM_apply | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_2) {D : Type u_4} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : RCLike 𝕜] [inst_5 : NormedAddCommGroup D]
[inst_6 : NormedSpace ℝ D] [inst_7 : NormedSpace 𝕜 F] {g : D → E} (hg : Function.HasTemperateGrowth g)
(hg_upper : ∃ k C, ∀ (x : D), ‖x‖ ≤ C * (1 + ‖g x‖) ^ k) (f : SchwartzMap E F),
⇑((SchwartzMap.compCLM 𝕜 hg hg_upper) f) = ⇑f ∘ g | true |
Subsemigroup.recOn | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_3} →
[inst : Mul M] →
{motive : Subsemigroup M → Sort u} →
(t : Subsemigroup M) →
((carrier : Set M) →
(mul_mem' : ∀ {a b : M}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) →
motive { carrier := carrier, mul_mem' := mul_mem' }) →
motive t | false |
AddCommGrpCat.isFinite | Mathlib.Algebra.Category.Grp.IsFinite | CategoryTheory.ObjectProperty AddCommGrpCat | true |
AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_point_assoc | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) (x x' : ↑X.toTopCat) (hxx' : x = x') {Z : CommRingCat}
(h : X.presheaf.stalk x' ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x)
(CategoryTheory.CategoryStruct.comp (X.presheaf.stalkSpecializes ⋯) h) =
CategoryTheory.CategoryStruct.comp (Y.presheaf.stalkSpecializes ⋯)
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x') h) | true |
FractionalIdeal.mul_induction_on | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{I J : FractionalIdeal S P} {C : P → Prop} {r : P},
r ∈ I * J → (∀ i ∈ I, ∀ j ∈ J, C (i * j)) → (∀ (x y : P), C x → C y → C (x + y)) → C r | true |
Lean.Doc.suggestTactic | Lean.Elab.DocString.Builtin | Lean.StrLit → Lean.Doc.DocM (Array Lean.Doc.CodeSuggestion) | true |
ULift.commMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : CommMonoid α], ULift.commMonoid = Function.Injective.commMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ | true |
Std.DTreeMap.Internal.Impl.erase._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[Ord α] →
α →
(t : Std.DTreeMap.Internal.Impl α β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (t.size - 1) t.size | false |
Matrix.transpose_reindex | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} (eₘ : m ≃ l) (eₙ : n ≃ o) (M : Matrix m n α),
((Matrix.reindex eₘ eₙ) M).transpose = (Matrix.reindex eₙ eₘ) M.transpose | true |
_private.Mathlib.Algebra.Homology.Localization.0.HomotopyCategory.quotient_map_mem_quasiIso_iff._simp_1_3 | Mathlib.Algebra.Homology.Localization | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c} (f : K ⟶ L)
[inst_2 : ∀ (i : ι), K.HasHomology i] [inst_3 : ∀ (i : ι), L.HasHomology i], QuasiIso f = ∀ (i : ι), QuasiIsoAt f i | false |
CategoryTheory.ShortComplex.SnakeInput.Hom.comp_f₂ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex.SnakeInput C} (f : S₁.Hom S₂) (g : S₂.Hom S₃),
(f.comp g).f₂ = CategoryTheory.CategoryStruct.comp f.f₂ g.f₂ | true |
Sum.Ioc_inr_inr | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (b₁ b₂ : β),
Finset.Ioc (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ioc b₁ b₂) | true |
ModelWithCorners.Boundaryless.mk | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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},
Set.range ↑I = Set.univ → I.Boundaryless | true |
_private.Mathlib.NumberTheory.Primorial.0.«_aux_Mathlib_NumberTheory_Primorial___macroRules__private_Mathlib_NumberTheory_Primorial_0_term_#_1» | Mathlib.NumberTheory.Primorial | Lean.Macro | false |
MeasureTheory.AEEqFun.comp_comp | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace δ] [inst_2 : TopologicalSpace β] [inst_3 : TopologicalSpace γ] (g : γ → δ) (g' : β → γ)
(hg : Continuous g) (hg' : Continuous g') (f : α →ₘ[μ] β),
MeasureTheory.AEEqFun.comp g hg (MeasureTheory.AEEqFun.comp g' hg' f) = MeasureTheory.AEEqFun.comp (g ∘ g') ⋯ f | true |
Submodule.mem_span_finset | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Finset M}
{x : M}, x ∈ Submodule.span R ↑s ↔ ∃ f, Function.support f ⊆ ↑s ∧ ∑ a ∈ s, f a • a = x | true |
Matrix.IsHermitian.submatrix | Mathlib.LinearAlgebra.Matrix.Hermitian | ∀ {α : Type u_1} {m : Type u_3} {n : Type u_4} [inst : Star α] {A : Matrix n n α},
A.IsHermitian → ∀ (f : m → n), (A.submatrix f f).IsHermitian | true |
Std.IteratorLoop.WithWF.mk.injEq | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β] {γ : Type x}
{PlausibleForInStep : β → γ → ForInStep γ → Prop} {hwf : Std.IteratorLoop.WellFounded α m PlausibleForInStep}
(it : Std.IterM m β) (acc : γ) (it_1 : Std.IterM m β) (acc_1 : γ),
({ it := it, acc := acc } = { it := it_1, acc := acc_1 }) = (it = it_1 ∧ acc = acc_1) | true |
SimpleGraph.regularityReduced_anti | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : DecidableEq α] {A : Finset α}
{P : Finpartition A} {G : SimpleGraph α} [inst_3 : DecidableRel G.Adj] {ε δ₁ δ₂ : 𝕜},
δ₁ ≤ δ₂ → SimpleGraph.regularityReduced P G ε δ₂ ≤ SimpleGraph.regularityReduced P G ε δ₁ | true |
monotone_vecCons | Mathlib.Order.Fin.Tuple | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} {f : Fin (n + 1) → α} {a : α},
Monotone (Matrix.vecCons a f) ↔ a ≤ f 0 ∧ Monotone f | true |
Dense.exists_ge | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIicTopology α] [NoMaxOrder α] {s : Set α},
Dense s → ∀ (x : α), ∃ y ∈ s, x ≤ y | true |
Std.TreeSet.Raw.size_filter_eq_size_iff | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] {f : α → Bool},
t.WF → ((Std.TreeSet.Raw.filter f t).size = t.size ↔ ∀ (k : α) (h : k ∈ t), f (t.get k h) = true) | true |
NNRat.cast_eq_zero | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_3} [inst : DivisionSemiring α] [CharZero α] {q : ℚ≥0}, ↑q = 0 ↔ q = 0 | true |
RingCat.ofHom | Mathlib.Algebra.Category.Ring.Basic | {R S : Type u} → [inst : Ring R] → [inst_1 : Ring S] → (R →+* S) → (RingCat.of R ⟶ RingCat.of S) | true |
Batteries.ByteSubarray.forIn._proof_3 | Batteries.Data.ByteSlice | ∀ (self : Batteries.ByteSubarray), self.size ≤ self.size | false |
sub_right_injective | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {b : G}, Function.Injective fun a => b - a | true |
MeasureTheory.memLp_of_memLp_trim | Mathlib.MeasureTheory.Function.LpSeminorm.Trim | ∀ {α : Type u_1} {ε : Type u_3} {m m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] (hm : m ≤ m0) {f : α → ε},
MeasureTheory.MemLp f p (μ.trim hm) → MeasureTheory.MemLp f p μ | true |
Std.Iterators.PostconditionT | Init.Data.Iterators.PostconditionMonad | (Type w → Type w') → Type w → Type (max w w') | true |
instMulSemiringActionSubtypeMemSubalgebraIntegralClosure._proof_1 | Mathlib.RingTheory.IntegralClosure.Algebra.Basic | ∀ {G : Type u_3} {R : Type u_2} {K : Type u_1} [inst : CommRing R] [inst_1 : CommRing K] [inst_2 : Algebra R K]
[inst_3 : Group G] [inst_4 : MulSemiringAction G K] [inst_5 : SMulCommClass G R K] (g h : G)
(x : ↥(integralClosure R K)), (g * h) • x = g • h • x | false |
IsAddQuantale.recOn | Mathlib.Algebra.Order.Quantale | {α : Type u_1} →
[inst : AddSemigroup α] →
[inst_1 : CompleteLattice α] →
{motive : IsAddQuantale α → Sort u} →
(t : IsAddQuantale α) →
((add_sSup_distrib : ∀ (x : α) (s : Set α), x + sSup s = ⨆ y ∈ s, x + y) →
(sSup_add_distrib : ∀ (s : Set α) (y : α), sSup s + y = ⨆ x ∈ s, x + y) → motive ⋯) →
motive t | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_325 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
Matroid.eq_loopyOn_iff_loops | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {E : Set α}, M = Matroid.loopyOn E ↔ M.loops = E ∧ M.E = E | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalFirst.loop | Lean.Elab.Tactic.BuiltinTactic | Array Lean.Syntax → ℕ → Lean.Elab.Tactic.TacticM Unit | true |
Std.HashMap.Raw.getKey!_unitOfList_of_contains_eq_false | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited α] {l : List α}
{k : α}, l.contains k = false → (Std.HashMap.Raw.unitOfList l).getKey! k = default | true |
_private.Mathlib.Geometry.Euclidean.Incenter.0.Affine.Simplex.sum_excenterWeights._simp_1_7 | Mathlib.Geometry.Euclidean.Incenter | ∀ {a : Prop}, (¬¬a) = a | false |
Lean.Grind.Semiring.add_comm | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Semiring α] (a b : α), a + b = b + a | true |
CliffordAlgebra.even.lift_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Even | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {A : Type u_3} [inst_3 : Ring A] [inst_4 : Algebra R A] (f : CliffordAlgebra.EvenHom Q A)
(m₁ m₂ : M), ((CliffordAlgebra.even.lift Q) f) (((CliffordAlgebra.even.ι Q).bilin m₁) m₂) = (f.bilin m₁) m₂ | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.stoppers | Mathlib.Tactic.Linter.FlexibleLinter | Std.HashSet Lean.Name | true |
CompactIccSpace.isCompact_Icc | Mathlib.Topology.Order.Compact | ∀ {α : Type u_1} {inst : TopologicalSpace α} {inst_1 : Preorder α} [self : CompactIccSpace α] {a b : α},
IsCompact (Set.Icc a b) | true |
StrictAnti.prodMap | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β]
[inst_2 : Preorder γ] [inst_3 : Preorder δ] {f : α → γ} {g : β → δ},
StrictAnti f → StrictAnti g → StrictAnti (Prod.map f g) | true |
Std.Tactic.BVDecide.BVExpr.decEq._proof_139 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (rw : ℕ)
(rlhs : Std.Tactic.BVDecide.BVExpr w) (rrhs : Std.Tactic.BVDecide.BVExpr rw),
¬lw = rw → ¬llhs.shiftRight lrhs = rlhs.shiftRight rrhs | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_insertMany_list_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
BiheytingHom.comp | Mathlib.Order.Heyting.Hom | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : BiheytingAlgebra α] →
[inst_1 : BiheytingAlgebra β] →
[inst_2 : BiheytingAlgebra γ] → BiheytingHom β γ → BiheytingHom α β → BiheytingHom α γ | true |
smul_iterate_apply | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {α : Type u_5} [inst : Monoid M] [inst_1 : MulAction M α] (a : M) (n : ℕ) (x : α),
(fun x => a • x)^[n] x = a ^ n • x | true |
Matroid.map_val_restrictSubtype_eq | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), (M.restrictSubtype X).map Subtype.val ⋯ = M.restrict X | true |
CategoryTheory.Limits.fiberwiseColimitLimitIso._proof_8 | Mathlib.CategoryTheory.Limits.Preserves.Grothendieck | ∀ {C : Type u_8} [inst : CategoryTheory.Category.{u_7, u_8} C] {H : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} H] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{F : CategoryTheory.Functor C CategoryTheory.Cat}
(K : CategoryTheory.Functor J (CategoryTheory.Functor (CategoryTheory.Grothendieck F) H))
[inst_3 : ∀ (c : C), CategoryTheory.Limits.HasColimitsOfShape (↑(F.obj c)) H]
[CategoryTheory.Limits.HasLimitsOfShape J H]
[∀ (c : C), CategoryTheory.Limits.PreservesLimitsOfShape J CategoryTheory.Limits.colim] (c : C),
CategoryTheory.Limits.HasLimit
((K.comp
((CategoryTheory.Functor.whiskeringLeft (↑(F.obj c)) (CategoryTheory.Grothendieck F) H).obj
(CategoryTheory.Grothendieck.ι F c))).comp
CategoryTheory.Limits.colim) | false |
Std.Do.SPred.Notation.unpack | Std.Do.SPred.Notation.Basic | {m : Type → Type} → [Monad m] → [Lean.MonadRef m] → [Lean.MonadQuotation m] → Lean.Term → m Lean.Term | true |
pow_right_monotone | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] {a : M}, 1 ≤ a → Monotone fun n => a ^ n | true |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.SpectrumRestricts.spectralRadius_eq.match_1_2 | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜₁ : Type u_2} {𝕜₂ : Type u_1} {A : Type u_3} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂]
[inst_2 : NormedRing A] [inst_3 : NormedAlgebra 𝕜₁ A] [inst_4 : NormedAlgebra 𝕜₁ 𝕜₂] {a : A} (x : 𝕜₂)
(motive : x ∈ ⇑(algebraMap 𝕜₁ 𝕜₂) '' spectrum 𝕜₁ a → Prop) (x_1 : x ∈ ⇑(algebraMap 𝕜₁ 𝕜₂) '' spectrum 𝕜₁ a),
(∀ (y : 𝕜₁) (hy : y ∈ spectrum 𝕜₁ a) (hy' : (algebraMap 𝕜₁ 𝕜₂) y = x), motive ⋯) → motive x_1 | false |
isFwInvariant_iff_isInvariant | Mathlib.Dynamics.Flow | ∀ {τ : Type u_1} {α : Type u_2} [inst : AddMonoid τ] [inst_1 : PartialOrder τ] [CanonicallyOrderedAdd τ] {ϕ : τ → α → α}
{s : Set α}, IsForwardInvariant ϕ s ↔ IsInvariant ϕ s | true |
Std.DHashMap.Internal.Raw.WF.out | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [i₁ : EquivBEq α] [i₂ : LawfulHashable α]
{m : Std.DHashMap.Raw α β}, m.WF → Std.DHashMap.Internal.Raw.WFImp m | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj_obj | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommMon C)
(x : CategoryTheory.Discrete PUnit.{u + 1}),
(CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraidedObj A).obj x = A.X | true |
HasFPowerSeriesWithinAt.continuousWithinAt_insert | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : 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] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {s : Set E} {x : E},
HasFPowerSeriesWithinAt f p s x → ContinuousWithinAt f (insert x s) x | true |
Lean.Compiler.LCNF.CSE.instMonadFVarSubstMPureFalse | Lean.Compiler.LCNF.CSE | Lean.Compiler.LCNF.MonadFVarSubst Lean.Compiler.LCNF.CSE.M Lean.Compiler.LCNF.Purity.pure false | true |
Std.DTreeMap.Internal.Impl.get?_insertIfNew | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insertIfNew k v t ⋯).impl.get? a =
if h : compare k a = Ordering.eq ∧ k ∉ t then some (cast ⋯ v) else t.get? a | true |
Lean.Meta.ElimAltInfo.noConfusion | Lean.Meta.Tactic.ElimInfo | {P : Sort u} → {t t' : Lean.Meta.ElimAltInfo} → t = t' → Lean.Meta.ElimAltInfo.noConfusionType P t t' | false |
TrivSqZeroExt.fstHom._proof_5 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ (S : Type u_3) (R : Type u_1) (M : Type u_2) [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Algebra S R] (_r : S), (TrivSqZeroExt.inl ((algebraMap S R) _r)).fst = (algebraMap S R) _r | false |
LocallyLipschitz.iterate | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → α}, LocallyLipschitz f → ∀ (n : ℕ), LocallyLipschitz f^[n] | true |
Prod.rec._@.Mathlib.Util.CompileInductive.3167448894._hygCtx._hyg.3 | Mathlib.Util.CompileInductive | {α : Type u} →
{β : Type v} → {motive : α × β → Sort u_1} → ((fst : α) → (snd : β) → motive (fst, snd)) → (t : α × β) → motive t | false |
List.trop_sum | Mathlib.Algebra.Tropical.BigOperators | ∀ {R : Type u_1} [inst : AddMonoid R] (l : List R), Tropical.trop l.sum = (List.map Tropical.trop l).prod | true |
Batteries.BEqCmp.mk._flat_ctor | Batteries.Classes.Deprecated | ∀ {α : Type u_1} [inst : BEq α] {cmp : α → α → Ordering},
(∀ {x y : α}, cmp x y = Ordering.eq ↔ (x == y) = true) → Batteries.BEqCmp cmp | false |
SimpleGraph.IsTuranMaximal.finpartition | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | {V : Type u_1} →
[inst : Fintype V] →
{G : SimpleGraph V} →
[inst_1 : DecidableRel G.Adj] → {r : ℕ} → G.IsTuranMaximal r → [inst_2 : DecidableEq V] → Finpartition Finset.univ | true |
Aesop.getUnusedNames | Aesop.Util.Basic | Lean.LocalContext → Array Lean.Name → Array Lean.Name × Lean.LocalContext | true |
Bornology.forall_isBounded_image_eval_iff | Mathlib.Topology.Bornology.Constructions | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : (i : ι) → Bornology (X i)] {s : Set ((i : ι) → X i)},
(∀ (i : ι), Bornology.IsBounded (Function.eval i '' s)) ↔ Bornology.IsBounded s | true |
Relation.SymmGen.rfl | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} {a : α} [Std.Refl r], Relation.SymmGen r a a | true |
MeasureTheory.AEEqFun.instLattice._proof_6 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace β]
[inst_2 : Lattice β] [inst_3 : TopologicalLattice β] (f' f g : α →ₘ[μ] β), f' ≤ f → f' ≤ g → f' ≤ f ⊓ g | false |
Lean.MVarId.introsWithBinderIdents | Mathlib.Tactic.Core | Lean.MVarId →
List (Lean.TSyntax `Lean.binderIdent) →
optParam (Option ℕ) none → Lean.MetaM (List (Lean.TSyntax `Lean.binderIdent) × Array Lean.FVarId × Lean.MVarId) | true |
RingCon.mkₐ._proof_1 | Mathlib.Algebra.RingQuot | ∀ (S : Type u_2) [inst : CommSemiring S] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra S A] (c : RingCon A)
(x : S), (↑↑c.mk').toFun ((algebraMap S A) x) = (↑↑c.mk').toFun ((algebraMap S A) x) | false |
SimpleGraph.Copy.toLineGraphEmbedding | Mathlib.Combinatorics.SimpleGraph.LineGraph | {V : Type u_1} → {V' : Type u_2} → {G : SimpleGraph V} → {G' : SimpleGraph V'} → G.Copy G' → G.lineGraph ↪g G'.lineGraph | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.