name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.ContinuedFractions.Translations.0.GenContFract.contsAux.match_3.splitter | Mathlib.Algebra.ContinuedFractions.Translations | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → motive n.succ.succ) → motive x | null | true |
ESeminormedCommMonoid.mk.noConfusion | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
{inst : TopologicalSpace E} →
{P : Sort u} →
{toESeminormedMonoid : ESeminormedMonoid E} →
{mul_comm : ∀ (a b : E), a * b = b * a} →
{toESeminormedMonoid' : ESeminormedMonoid E} →
{mul_comm' : ∀ (a b : E), a * b = b * a} →
{ toESeminormedMonoid :=... | null | false |
Lean.getLibDir | Lean.Util.Path | System.FilePath → IO System.FilePath | null | true |
Algebra.norm_natCast | Mathlib.RingTheory.Norm.Defs | ∀ (R : Type u_1) {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] [Module.Free R S] (n : ℕ),
(Algebra.norm R) ↑n = ↑n ^ Module.finrank R S | null | true |
Lean.Grind.CommRing.SPolResult.k₂._default | Lean.Meta.Sym.Arith.Poly | ℤ | null | false |
instTransLtAntisymmRelLe | Mathlib.Order.Antisymmetrization | {α : Type u_1} →
[inst : Preorder α] → Trans (fun x1 x2 => x1 < x2) (AntisymmRel fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 < x2 | null | true |
Con.lift._proof_1 | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_2} {P : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass P] (c : Con M) (f : M →* P)
(H : c ≤ Con.ker f), Con.liftOn 1 ⇑f ⋯ = 1 | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Laplacian.0.ContDiffAt.laplacian_sub._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ {ι : Type u_1} {G : Type u_5} {s : Finset ι} [inst : SubtractionCommMonoid G] (f g : ι → G),
∑ x ∈ s, f x - ∑ x ∈ s, g x = ∑ x ∈ s, (f x - g x) | null | false |
_private.Mathlib.Order.Bounds.Basic.0.lt_isLUB_iff._simp_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b < a) = ¬a ≤ b | null | false |
Submonoid.bot_prod_bot | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {N : Type u_2} [inst : MulOneClass N] {M : Type u_5} [inst_1 : MulOneClass M], ⊥.prod ⊥ = ⊥ | null | true |
nnnorm_commutator_units_sub_one_le | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a b : αˣ),
‖↑(a * b * a⁻¹ * b⁻¹) - 1‖₊ ≤ 2 * ‖↑a⁻¹‖₊ * ‖↑b⁻¹‖₊ * ‖↑a - 1‖₊ * ‖↑b - 1‖₊ | null | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.exists_linearIndependent'._simp_1_2 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
MeasureTheory.MeasurePreserving.aestronglyMeasurable_comp_iff | Mathlib.MeasureTheory.Function.StronglyMeasurable.Lemmas | ∀ {α : Type u_1} {γ : Type u_3} [inst : TopologicalSpace γ] {β : Type u_4} {f : α → β} {mα : MeasurableSpace α}
{μa : MeasureTheory.Measure α} {mβ : MeasurableSpace β} {μb : MeasureTheory.Measure β},
MeasureTheory.MeasurePreserving f μa μb →
MeasurableEmbedding f →
∀ {g : β → γ}, MeasureTheory.AEStronglyM... | null | true |
MonoidAlgebra.nonAssocRing._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : MulOneClass M] (n : ℕ), MonoidAlgebra.single 1 ↑↑n = ↑n | null | false |
DividedPowers.IsDPMorphism | Mathlib.RingTheory.DividedPowers.DPMorphism | {A : Type u_1} →
{B : Type u_2} →
[inst : CommSemiring A] →
[inst_1 : CommSemiring B] → {I : Ideal A} → {J : Ideal B} → DividedPowers I → DividedPowers J → (A →+* B) → Prop | Given divided power structures on the `A`-ideal `I` and the `B`-ideal `J`, a ring morphism
`A → B` is a divided power morphism if it is compatible with these divided power structures. | true |
ProbabilityTheory.Kernel.IsSFiniteKernel.finset_sum | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{κs : ι → ProbabilityTheory.Kernel α β} (I : Finset ι),
(∀ i ∈ I, ProbabilityTheory.IsSFiniteKernel (κs i)) → ProbabilityTheory.IsSFiniteKernel (∑ i ∈ I, κs i) | **Alias** of `ProbabilityTheory.Kernel.IsSFiniteKernel.finsetSum`. | true |
mellin_hasDerivAt_of_isBigO_rpow | Mathlib.Analysis.MellinTransform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {a b : ℝ} {f : ℝ → E} {s : ℂ},
MeasureTheory.LocallyIntegrableOn f (Set.Ioi 0) MeasureTheory.volume →
(f =O[Filter.atTop] fun x => x ^ (-a)) →
s.re < a →
(f =O[nhdsWithin 0 (Set.Ioi 0)] fun x => x ^ (-b)) →
b < s.re ... | Suppose `f` is locally integrable on `(0, ∞)`, is `O(x ^ (-a))` as `x → ∞`, and is
`O(x ^ (-b))` as `x → 0`. Then its Mellin transform is differentiable on the domain `b < re s < a`,
with derivative equal to the Mellin transform of `log • f`. | true |
AlgebraicGeometry.Scheme.IsRationalOver.recOn | Mathlib.AlgebraicGeometry.Birational.Birational | {S X : AlgebraicGeometry.Scheme} →
{sX : X ⟶ S} →
{motive : AlgebraicGeometry.Scheme.IsRationalOver sX → Sort u_1} →
(t : AlgebraicGeometry.Scheme.IsRationalOver sX) →
((exists_birationalOver_affineSpace :
∃ n, AlgebraicGeometry.Scheme.BirationalOver sX (AlgebraicGeometry.AffineSpace n... | null | false |
AddOpposite.instIsOrderedAddMonoid | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α], IsOrderedAddMonoid αᵃᵒᵖ | null | true |
String.Slice.Pattern.Model.split_endPos | Init.Data.String.Lemmas.Pattern.Split.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.Model.StrictPatternModel pat] {s : String.Slice} {firstRejected : s.Pos},
String.Slice.Pattern.Model.split pat firstRejected s.endPos ⋯ = [s.subslice firstRejected s.endPos ⋯] | null | true |
KaehlerDifferential.endEquivAuxEquiv._proof_3 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
IsScalarTower R (TensorProduct R S S ⧸ KaehlerDifferential.ideal R S ^ 2)
(TensorProduct R S S ⧸ KaehlerDifferential.ideal R S ^ 2) | null | false |
Orientation.inner_rotation_pi_div_two_left_smul | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x : V) (r : ℝ), inner ℝ ((o.rotation ↑(Real.pi / 2)) x) (r • x) = 0 | The inner product between a `π / 2` rotation of a vector and a multiple of that vector is
zero. | true |
IsMoritaEquivalent.cond | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} [inst : CommSemiring R] {A : Type u₁} [inst_1 : Ring A] [inst_2 : Algebra R A] {B : Type u₂}
[inst_3 : Ring B] [inst_4 : Algebra R B], IsMoritaEquivalent R A B → Nonempty (MoritaEquivalence R A B) | null | true |
ContinuousLinearMap.toSpanSingletonCLE | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : IsTopologicalAddGroup E] → [inst_5 : ContinuousSMul 𝕜 E] → E ≃L[𝕜] 𝕜 →L[𝕜] E | `ContinuousLinearMap.toSpanSingleton` as a continuous linear equivalence. | true |
Lean.Elab.ConfigEval.ConfigItem.prevRoot? | Lean.Elab.ConfigEval.Basic | Lean.Elab.ConfigEval.ConfigItem → Option Lean.Syntax | null | true |
Topology.IsCoinducing.casesOn | Mathlib.Topology.Defs.Induced | {X : Type u_1} →
{Y : Type u_2} →
[tX : TopologicalSpace X] →
[tY : TopologicalSpace Y] →
{f : X → Y} →
{motive : Topology.IsCoinducing f → Sort u} →
(t : Topology.IsCoinducing f) →
((eq_coinduced : tY = TopologicalSpace.coinduced f tX) → motive ⋯) → motive t | null | false |
_private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.comm_ring_aux₁._proof_13 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : Fact (Nat.Prime p)] (i : ℤ), WittVector.ghostFun✝ ↑i = ↑i | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.forallMetaTelescopeReducingAux.process | Lean.Meta.Basic | Bool →
Option ℕ →
Lean.MetavarKind →
Array Lean.Expr →
Array Lean.BinderInfo → ℕ → Lean.Expr → Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) | null | true |
Lean.Expr.relevantConstantsAsSet | Lean.LibrarySuggestions.Basic | Lean.Expr → Lean.MetaM Lean.NameSet | Collect the constants occurring in `e` (once each), skipping instance arguments and proofs. | true |
Std.Roo.Sliceable | Init.Data.Slice.Notation | Type u → outParam (Type v) → outParam (Type w) → Type (max (max u v) w) | This typeclass indicates how to obtain slices of elements of `α` over ranges in the index type
`β`, the ranges being open.
The type of the resulting slices is `γ`.
| true |
Monoid.coprodCon | Mathlib.GroupTheory.Coprod.Basic | (M : Type u_1) → (N : Type u_2) → [MulOneClass M] → [MulOneClass N] → Con (FreeMonoid (M ⊕ N)) | The minimal congruence relation `c` on `FreeMonoid (M ⊕ N)`
such that `FreeMonoid.of ∘ Sum.inl` and `FreeMonoid.of ∘ Sum.inr` are monoid homomorphisms
to the quotient by `c`. | true |
RingEquiv.sofLeftInverse'._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] {g : S → R}
{f : R →ₙ+* S},
Function.LeftInverse g ⇑f →
∀ (x : ↥f.srange), f.srangeRestrict (g ((NonUnitalSubsemiringClass.subtype f.srange) x)) = x | null | false |
_private.Mathlib.Tactic.NormNum.Core.0.Mathlib.Meta.NormNum.getSimpContext.match_3 | Mathlib.Tactic.NormNum.Core | (motive : Lean.Meta.Simp.ConfigWithOptions → Sort u_1) →
(x : Lean.Meta.Simp.ConfigWithOptions) →
((config : Lean.Meta.Simp.Config) →
(userConfig : Lean.Options) → motive { config := config, userConfig := userConfig }) →
motive x | null | false |
CategoryTheory.Arrow.arrow_mk_eqToHom_comp | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X' X Y : T} (f : X ⟶ Y) (h : X' = X),
CategoryTheory.Arrow.mk (CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h) f) = CategoryTheory.Arrow.mk f | null | true |
_private.Init.Data.BitVec.Bootstrap.0.BitVec.getElem_cons._simp_1_4 | Init.Data.BitVec.Bootstrap | ∀ (n : ℕ), (n ≤ n) = True | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.isIso_mapFourδ₄Toδ₃'._proof_5 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ (n₀ n₁ : ℤ),
autoParam (n₀ + 1 = n₁)
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.isIso_mapFourδ₄Toδ₃'._auto_1 →
n₀ + 1 = n₁ | null | false |
Std.FactoryInstances.instLawfulOrderLeftLeaningMaxOfOrd | Init.Data.Order.PackageFactories | ∀ {α : Type u} [inst : Ord α] [inst_1 : LE α] [Std.LawfulOrderOrd α], Std.LawfulOrderLeftLeaningMax α | null | true |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.isAtomOrDerivable._sparseCasesOn_1 | Mathlib.Tactic.Ring.Common | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Filter.EventuallyEq.inf | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} [inst : Min β] {l : Filter α} {f f' g g' : α → β},
f =ᶠ[l] f' → g =ᶠ[l] g' → f ⊓ g =ᶠ[l] f' ⊓ g' | null | true |
Std.instStreamSubarray | Init.Data.Stream | {α : Type u_1} → Std.Stream (Subarray α) α | null | true |
_private.Mathlib.Data.List.GetD.0.List.getD_surjective_iff._simp_1_4 | Mathlib.Data.List.GetD | ∀ {α : Sort u_1} {p q : α → Prop}, (∃ x, p x ∨ q x) = ((∃ x, p x) ∨ ∃ x, q x) | null | false |
_private.Mathlib.Data.Finset.Lattice.Lemmas.0.Finset.singleton_inter_of_notMem._simp_1_2 | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
Colex.instCommMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : CommMonoid α], Colex.instCommMonoid = { toMonoid := Colex.instMonoid, mul_comm := ⋯ } | null | true |
Lean.DeprecatedModuleEntry.since?._default | Lean.DeprecatedModule | Option String | null | false |
Std.DTreeMap.Internal.Impl.minEntry.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : α → Type v} (x : Std.DTreeMap.Internal.Impl α β) (x_1 : x.isEmpty = false),
x.minEntry x_1 =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r, x => ⟨k, v⟩
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Internal.Impl.inner s... | null | true |
CategoryTheory.Idempotents.instIsIdempotentCompleteKaroubi | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C],
CategoryTheory.IsIdempotentComplete (CategoryTheory.Idempotents.Karoubi C) | null | true |
HasFDerivWithinAt.fun_sum | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{s : Set E} {ι : Type u_4} {u : Finset ι} {A : ι → E → F} {A' : ι → E →L[𝕜] F},
(∀ i ∈ u, HasFDerivWi... | Eta-expanded form of `HasFDerivWithinAt.sum` | true |
Order.enum | Mathlib.SetTheory.Cardinal.Cofinality.Enum | {α : Type u_1} →
[inst : LinearOrder α] → [inst_1 : WellFoundedLT α] → [IsRegularCardinalOrder α] → (s : Set α) → IsCofinal s → α ≃o ↑s | Enumerate the elements of a cofinal subset of `α` by `α` itself. This is a generalization of
`Nat.nth`. | true |
IsAddIndecomposable.pairwise_sub_notMem_range | Mathlib.Algebra.Group.Irreducible.Indecomposable | ∀ {ι : Type u_1} {G : Type u_3} [inst : AddCommGroup G] [inst_1 : InvolutiveNeg ι] (v : ι → G),
(∀ (i : ι), v i ≠ 0) →
(∀ (i : ι), v (-i) = -v i) →
∀ (s t : Set ι),
s ⊆ {i | IsAddIndecomposable v t i} →
(∀ (i : ι), i ∈ t ∨ -i ∈ t) → s.Pairwise fun i j => v i - v j ∉ Set.range v | null | true |
CategoryTheory.GrothendieckTopology.uliftYoneda.eq_1 | Mathlib.CategoryTheory.Sites.Subcanonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical],
CategoryTheory.GrothendieckTopology.uliftYoneda.{w, v, u} J =
J.yoneda.comp (CategoryTheory.sheafCompose J CategoryTheory.uliftFunctor.{w, v}) | null | true |
disjoint_bot_right._simp_2 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, Disjoint a ⊥ = True | null | false |
CategoryTheory.Limits.BinaryBicone.retract_left | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q : C} → (c : CategoryTheory.Limits.BinaryBicone P Q) → CategoryTheory.Retract P c.pt | The retract of a binary bicone `c` given by `c.inl` and `c.fst`. | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.tdiv_eq_ediv_of_nonneg.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (motive : (x : ℤ) → ℤ → 0 ≤ x → Prop) (x x_1 : ℤ) (x_2 : 0 ≤ x),
(∀ (x : ℤ) (x_3 : 0 ≤ 0), motive 0 x x_3) →
(∀ (x : ℤ) (x_3 : 0 ≤ x), motive x 0 x_3) →
(∀ (n n_1 : ℕ) (x : 0 ≤ ↑n.succ), motive (Int.ofNat n.succ) (Int.ofNat n_1.succ) x) →
(∀ (n a : ℕ) (x : 0 ≤ ↑n.succ), motive (Int.ofNat n.succ) (... | null | false |
WeierstrassCurve.Jacobian.addX_eq' | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q →
W'.addX P Q * (P 2 * Q 2) ^ 2 =
(P 1 * Q 2 ^ 3 - Q 1 * P 2 ^ 3) ^ 2 +
W'.a₁ * (P 1 * Q 2 ^ 3 - Q 1 * P 2 ^ 3) * P 2 * Q 2 * WeierstrassCurve.Jacobian.addZ P Q -
... | null | true |
DistLat.hom_inv_apply | Mathlib.Order.Category.DistLat | ∀ {X Y : DistLat} (e : X ≅ Y) (s : ↑Y),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.Progress.noConfusion | Mathlib.Tactic.GRewrite.Core | {P : Sort u} →
{t t' : Mathlib.Tactic.GRewrite.Progress✝} → t = t' → Mathlib.Tactic.GRewrite.Progress.noConfusionType✝ P t t' | null | false |
Lean.Option.setIfNotSet | Lean.Data.Options | {α : Type} → [Lean.KVMap.Value α] → Lean.Options → Lean.Option α → α → Lean.Options | Similar to `set`, but update `opts` only if it doesn't already contains an setting for `opt.name` | true |
Std.ExtDTreeMap.getKey?_insert_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, (t.insert k v).getKey? k = some k | null | true |
Qq.Impl.floatExprAntiquot | Qq.Macro | {m : Type → Type} →
[Monad m] → [Lean.MonadQuotation m] → ℕ → Lean.Term → StateT (Array (Lean.Ident × Lean.Term × Lean.Term)) m Lean.Term | null | true |
MeasureTheory.Measure.IsHaarMeasure.sigmaFinite | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : TopologicalSpace G]
(μ : MeasureTheory.Measure G) [μ.IsHaarMeasure] [SigmaCompactSpace G], MeasureTheory.SigmaFinite μ | A Haar measure on a σ-compact space is σ-finite.
See Note [lower instance priority] | true |
LucasLehmer.X.left_distrib | Mathlib.NumberTheory.LucasLehmer | ∀ {q : ℕ} (x y z : LucasLehmer.X q), x * (y + z) = x * y + x * z | null | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_mon_one_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C (CategoryTheory.CommMon D)) (X : C),
CategoryTheory.MonObj.one.app X = Cate... | null | true |
FreeAddGroup.map._proof_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) (L₁ L₂ : List (α × Bool)),
FreeAddGroup.Red.Step L₁ L₂ →
FreeAddGroup.Red.Step (List.map (fun x => (f x.1, x.2)) L₁) (List.map (fun x => (f x.1, x.2)) L₂) | null | false |
Lean.Parser.Command.protected.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
AddOpposite.instMulZeroClass._proof_1 | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : MulZeroClass α] (x : αᵃᵒᵖ), 0 * x = 0 | null | false |
CategoryTheory.Limits.isLimitMapConeForkEquiv' | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(G : CategoryTheory.Functor C D) →
... | The map of a kernel fork is a limit iff
the kernel fork consisting of the mapped morphisms is a limit.
This essentially lets us commute `KernelFork.ofι` with `Functor.mapCone`.
This is a variant of `isLimitMapConeForkEquiv` for equalizers,
which we can't use directly between `G.map 0 = 0` does not hold definitionally.... | true |
Lean.Parser.Tactic.Grind.ring | Init.Grind.Interactive | Lean.ParserDescr | `ring` (commutative) rings and fields. | true |
CompactlySupportedContinuousMapClass.hasCompactSupport | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {F : Type u_5} {α : outParam (Type u_6)} {β : outParam (Type u_7)} {inst : TopologicalSpace α} {inst_1 : Zero β}
{inst_2 : TopologicalSpace β} {inst_3 : FunLike F α β} [self : CompactlySupportedContinuousMapClass F α β] (f : F),
HasCompactSupport ⇑f | Each member of the class has compact support. | true |
_private.Init.Data.Vector.OfFn.0.Vector.ofFn_succ._simp_1_1 | Init.Data.Vector.OfFn | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x : α} {y : ¬p → α},
(x = if h : p then x else y h) = ∀ (h : ¬p), x = y h | null | false |
_private.Mathlib.Topology.Algebra.Module.LinearPMap.0.LinearPMap.closureHasCore._simp_1_2 | Mathlib.Topology.Algebra.Module.LinearPMap | ∀ {a b : Prop}, (a ∧ b ↔ a) = (a → b) | null | false |
AddAction.orbitRel.Quotient.addSubgroup_quotient_eq_iff | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {H : AddSubgroup G}
{x : AddAction.orbitRel.Quotient G α} {a b : ↑x.orbit}, ⟦a⟧ = ⟦b⟧ ↔ ⟦↑a⟧ = ⟦↑b⟧ | null | true |
Mathlib.Tactic.BicategoryLike.Normalize.Result.recOn | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {motive : Mathlib.Tactic.BicategoryLike.Normalize.Result → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.Normalize.Result) →
((normalizedHom : Mathlib.Tactic.BicategoryLike.NormalizedHom) →
(toNormalize : Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
motive { normalizedHom := normalizedHom, toNormaliz... | null | false |
DirectLimit.instNonAssocRingOfRingHomClass._proof_7 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_1} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR₂.run'.eq_3 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (le : α → α → Bool) (n_1 : ℕ) (xs : { l // l.length = n_1 + 2 }),
List.MergeSort.Internal.mergeSortTR₂.run'✝ le xs =
match List.MergeSort.Internal.splitRevInTwo' xs with
| (l, r) =>
List.MergeSort.Internal.mergeTR (List.MergeSort.Internal.mergeSortTR₂.run'✝ le r)
(List.MergeSort... | null | true |
CategoryTheory.Subgroupoid.full | Mathlib.CategoryTheory.Groupoid.Subgroupoid | {C : Type u} → [inst : CategoryTheory.Groupoid C] → Set C → CategoryTheory.Subgroupoid C | The full subgroupoid on a set `D : Set C` | true |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.WF.findMin._proof_5 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} {le : α → α → Bool} {res : Batteries.BinomialHeap.Imp.FindMin α} (a : α), le res.val a = le res.val a | null | false |
TensorialAt.mkHom₂._proof_4 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_7} [inst : NontriviallyNormedField 𝕜] {E : Type u_8} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_9} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_2}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_3} [inst_6 : NormedAddCommG... | null | false |
CategoryTheory.hasSeparator_op_iff._simp_1 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.HasSeparator Cᵒᵖ = CategoryTheory.HasCoseparator C | null | false |
WithConv.instAddAction | Mathlib.Algebra.WithConv | {R : Type u_1} → {A : Type u_2} → [inst : AddMonoid R] → [AddAction R A] → AddAction R (WithConv A) | null | true |
HomologicalComplex.homotopyCofiber.inlX_d' | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel] (i j : ι) (hij : c.Rel i j),
¬c.Rel j (c.next j) →
... | null | true |
Finset.empty_sups | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] {t : Finset α}, ∅ ⊻ t = ∅ | null | true |
Polynomial.mapAlgEquiv._proof_2 | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u_2} {A : Type u_1} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A ≃ₐ[R] B),
(Polynomial.mapAlgHom ↑f.symm).comp (Polynomial.mapAlgHom ↑f) = AlgHom.id R (Polynomial A) | null | false |
ContDiffMapSupportedIn.toBoundedContinuousFunctionCLM._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_3) {E : Type u_2} {F : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] {n : ℕ∞} {K : TopologicalSpace.Compacts E},
Continuo... | null | false |
Matrix.SpecialLinearGroup.toGLPos._proof_4 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_2} [inst_2 : CommRing R]
[inst_3 : LinearOrder R] [inst_4 : IsStrictOrderedRing R], ⟨Matrix.SpecialLinearGroup.toGL 1, ⋯⟩ = 1 | null | false |
Function.Injective.noZeroSMulDivisors | Mathlib.Algebra.NoZeroSMulDivisors.Defs | ∀ {R : Type u_4} {M : Type u_5} {N : Type u_6} [inst : Zero R] [inst_1 : Zero M] [inst_2 : Zero N] [inst_3 : SMul R M]
[inst_4 : SMul R N] [NoZeroSMulDivisors R N] (f : M → N),
Function.Injective f → f 0 = 0 → (∀ (c : R) (x : M), f (c • x) = c • f x) → NoZeroSMulDivisors R M | Pullback a `NoZeroSMulDivisors` instance along an injective function. | true |
Matrix.IsAdjMatrix.symm | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : Zero α] [inst_1 : One α] {A : Matrix V V α}, A.IsAdjMatrix → A.IsSymm | null | true |
Multiset.sup_cons | Mathlib.Data.Multiset.Lattice | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (a : α) (s : Multiset α), (a ::ₘ s).sup = a ⊔ s.sup | null | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.initFn._@.Lean.Elab.Tactic.Try.1352056574._hygCtx._hyg.2 | Lean.Elab.Tactic.Try | IO (Lean.KeyedDeclsAttribute Lean.Elab.Tactic.Try.TryTactic) | null | false |
Std.Do.SVal.getThe_here | Std.Do.SPred.SVal | ∀ {σs : List (Type u)} (σ : Type u) (s : σ), Std.Do.SVal.getThe σ s = Std.Do.SVal.curry fun x => s | null | true |
subsetConditionallyCompleteLinearOrder._proof_3 | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_1} (s : Set α) [inst : ConditionallyCompleteLinearOrder α] [inst_1 : Inhabited ↑s] (t : Set ↑s),
¬BddAbove t → sSup t = sSup ∅ | null | false |
isUpperSet_setOf | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {p : α → Prop}, IsUpperSet {a | p a} ↔ Monotone p | **Alias** of `isUpperSet_setOfPred`. | true |
Lean.Level.PP.Result.offset.elim | Lean.Level | {motive_1 : Lean.Level.PP.Result → Sort u} →
(t : Lean.Level.PP.Result) →
t.ctorIdx = 2 → ((a : Lean.Level.PP.Result) → (a_1 : ℕ) → motive_1 (a.offset a_1)) → motive_1 t | null | false |
MinTropical.instInfSet | Mathlib.Algebra.Tropical.Lattice | {R : Type u_1} → [InfSet R] → InfSet (MinTropical R) | null | true |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_9 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} (head : α) (ha : a ∈ [head]),
a ≠ [head].head ⋯ → some ([head].prev a ha) = [head][List.idxOf a [head] - 1]? | null | false |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.isAwful | Lean.Data.FuzzyMatching | Lean.FuzzyMatching.Score✝ → Bool | null | true |
FreeAddMonoid.lift_ofList | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : AddMonoid M] (f : α → M) (l : List α),
(FreeAddMonoid.lift f) (FreeAddMonoid.ofList l) = (List.map f l).sum | null | true |
Array.findIdxM? | Init.Data.Array.Basic | {α : Type u} → {m : Type → Type u_1} → [Monad m] → (α → m Bool) → Array α → m (Option ℕ) | Finds the index of the first element of an array for which the monadic predicate `p` returns `true`.
Elements are examined in order from left to right, and the search is terminated when an element that
satisfies `p` is found. If no such element exists in the array, then `none` is returned.
| true |
Group.Presentation.isFinitelyNormallyGenerated_ker_lift | Mathlib.GroupTheory.Presentation | ∀ {G : Type u_1} {ι : Type u_2} [inst : Group G] (P : Group.Presentation G ι),
P.rel.Finite → P.lift.ker.IsFinitelyNormallyGenerated | null | true |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set_lt._proof_2 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {w : i < xs.size} {j : ℕ}, j < i → ¬i - 1 < xs.size - 1 → False | null | false |
CategoryTheory.GlueData.recOn | Mathlib.CategoryTheory.GlueData | {C : Type u₁} →
[inst : CategoryTheory.Category.{v, u₁} C] →
{motive : CategoryTheory.GlueData C → Sort u} →
(t : CategoryTheory.GlueData C) →
((J : Type v) →
(U : J → C) →
(V : J × J → C) →
(f : (i j : J) → V (i, j) ⟶ U i) →
(f_mono : ∀ (i... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.