name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
DualNumber.lift._proof_9 | Mathlib.Algebra.DualNumber | ∀ {R : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring B] [inst_2 : Algebra R B],
SMulCommClass R Bᵐᵒᵖ B | null | false |
LinearMap.piMap | Mathlib.LinearAlgebra.Pi | {R : Type u} →
{ι : Type x} →
[inst : Semiring R] →
{φ : ι → Type i} →
[inst_1 : (i : ι) → AddCommMonoid (φ i)] →
[inst_2 : (i : ι) → Module R (φ i)] →
{ψ : ι → Type u_1} →
[inst_3 : (i : ι) → AddCommMonoid (ψ i)] →
[inst_4 : (i : ι) → Module R (ψ ... | Construct a linear map between two (dependent) function spaces
by applying index-dependent linear maps to the coordinates.
A bundled version of `Pi.map`.
If the index type is finite, then this map can be seen as a “block diagonal” map
between indexed products of modules. | true |
ContinuousLinearMap.measurable_apply' | Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : MeasurableSpace E] [OpensMeasurableSpace E] [inst_7 : MeasurableSpace F] [BorelSpace F],
Measurable ... | null | true |
_private.Aesop.Builder.Forward.0.Aesop.RuleBuilder.forwardCore₂.match_1 | Aesop.Builder.Forward | (motive : Aesop.PhaseSpec → Sort u_1) →
(phase : Aesop.PhaseSpec) →
((info : Aesop.SafeRuleInfo) → motive (Aesop.PhaseSpec.safe info)) →
((info : Aesop.NormRuleInfo) → motive (Aesop.PhaseSpec.norm info)) →
((info : Aesop.UnsafeRuleInfo) → motive (Aesop.PhaseSpec.unsafe info)) → motive phase | null | false |
CategoryTheory.instBicategoryMonoidalSingleObj._proof_20 | Mathlib.CategoryTheory.Bicategory.SingleObj | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{a b : CategoryTheory.MonoidalSingleObj C} {c : CategoryTheory.MonoidalSingleObj C}
{d e : CategoryTheory.MonoidalSingleObj C} (f g h i : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Monoida... | null | false |
Std.DTreeMap.Internal.Impl.Const.get!_filterMap!_of_getKey?_eq_some | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[Std.TransOrd α] [inst : Inhabited γ] {f : α → β → Option γ} {k k' : α},
t.WF →
t.getKey? k = some k' →
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.filterMap! f t) k =
((S... | null | true |
AlgebraicGeometry.Scheme.PartialMap.dense_domain | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y : AlgebraicGeometry.Scheme} (self : X.PartialMap Y), Dense ↑self.domain | null | true |
Fintype.sum_Prop | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] (f : Prop → M), ∑ p, f p = f True + f False | null | true |
MeasureTheory.condExpL2_const_inner | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2 | ∀ {α : Type u_1} {E : Type u_2} {𝕜 : Type u_7} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : CompleteSpace E] {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(hm : m ≤ m0) (f : ↥(MeasureTheory.Lp E 2 μ)) (c : E),
↑↑↑((MeasureTheory.condExpL2 𝕜 𝕜 hm) (Me... | `condExpL2` commutes with taking inner products with constants. See the lemma
`condExpL2_comp_continuousLinearMap` for a more general result about commuting with continuous
linear maps. | true |
HasSmallInductiveDimensionLT.zero | Mathlib.Topology.InductiveDimension.Classes | ∀ {X : Type u} [inst : TopologicalSpace X] [IsEmpty X], HasSmallInductiveDimensionLT X 0 | null | true |
StateRefT'.get | Init.Control.StateRef | {ω σ : Type} → {m : Type → Type} → [MonadLiftT (ST ω) m] → StateRefT' ω σ m σ | Retrieves the current value of the monad's mutable state.
This increments the reference count of the state, which may inhibit in-place updates.
| true |
CategoryTheory.LocalizerMorphism.IsInduced.inverseImage_eq | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {inst : CategoryTheory.Category.{v₁, u₁} C₁}
{inst_1 : CategoryTheory.Category.{v₂, u₂} C₂} {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) [self : Φ.IsInduced],
W₂.inverseImage Φ.functor = W₁ | null | true |
MeasurableEquiv.symm_apply_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β) (x : α),
e.symm (e x) = x | null | true |
TopCat.commRingYoneda | Mathlib.Topology.Sheaves.CommRingCat | CategoryTheory.Functor TopCommRingCat (CategoryTheory.Functor TopCatᵒᵖ CommRingCat) | An upgraded version of the Yoneda embedding, observing that the continuous maps
from `X : TopCat` to `R : TopCommRingCat` form a commutative ring, functorial in both `X` and
`R`. | true |
instFiniteWithBot | Mathlib.Data.Fintype.WithTopBot | ∀ {α : Type u_1} [Finite α], Finite (WithBot α) | null | true |
_private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.comm_ring_aux₂._proof_4 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : Fact (Nat.Prime p)] (x y : WittVector p (MvPolynomial R ℤ)),
WittVector.mapFun (⇑(MvPolynomial.map (Int.castRingHom ℚ))) (x + y) =
WittVector.mapFun (⇑(MvPolynomial.map (Int.castRingHom ℚ))) x +
WittVector.mapFun (⇑(MvPolynomial.map (Int.castRingHom ℚ))) y | null | false |
AddGroup.casesOn | Mathlib.Algebra.Group.Defs | {A : Type u_2} →
{motive : AddGroup A → Sort u} →
(t : AddGroup A) →
([toSubNegMonoid : SubNegMonoid A] →
(neg_add_cancel : ∀ (a : A), -a + a = 0) →
motive { toSubNegMonoid := toSubNegMonoid, neg_add_cancel := neg_add_cancel }) →
motive t | null | false |
AddMonoid.End.coe_pow._simp_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M] (f : AddMonoid.End M) (n : ℕ), (⇑f)^[n] = ⇑(f ^ n) | null | false |
IsGalois.normalAutEquivQuotient_apply | Mathlib.FieldTheory.Galois.Basic | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : FiniteDimensional K L] [inst_4 : IsGalois K L] (H : Subgroup Gal(L/K)) [inst_5 : H.Normal] (σ : Gal(L/K)),
(IsGalois.normalAutEquivQuotient H) ↑σ = (AlgEquiv.restrictNormalHom ↥(IntermediateField.fixedField H)) σ | null | true |
CategoryTheory.GrothendieckTopology.Cover.index_left | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
{D : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D)
(I : S.shape.L), (S.index P).left I = P.obj (Opposite.op I.Y) | null | true |
AlgebraicGeometry.IsZariskiLocalAtSource.of_isOpenImmersion | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsZariskiLocalAtSource P]
{X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [P.ContainsIdentities] [AlgebraicGeometry.IsOpenImmersion f], P f | null | true |
countableSupClosed_countableSupClosure | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} {s : Set α} [inst : Preorder α], CountableSupClosed (countableSupClosure s) | null | true |
IsPrimitiveRoot.not_exists_int_prime_dvd_sub_of_prime_ne_two | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p k : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[hcycl : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))),
p ≠ 2 → ¬∃ n, ↑p ∣ hζ.toInteger - ↑n | In a `p ^ (k + 1)`-th cyclotomic extension of `ℚ `, we have that `ζ` is not congruent to an
integer modulo `p` if `p ≠ 2`. | true |
CategoryTheory.ShortComplex.hasFiniteLimits | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{v_2, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteLimits C], CategoryTheory.Limits.HasFiniteLimits (CategoryTheory.ShortComplex C) | null | true |
Sym.cons._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (s : Sym α n), (a ::ₘ ↑s).card = n.succ | null | false |
_private.Mathlib.Analysis.Calculus.Rademacher.0.LipschitzWith.integral_inv_smul_sub_mul_tendsto_integral_lineDeriv_mul._simp_1_4 | Mathlib.Analysis.Calculus.Rademacher | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Std.DHashMap.Internal.Raw₀.Const.getKey!_insertManyIfNewUnit_list_of_contains | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Internal.Raw₀ α fun x => Unit) [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited α],
(↑m).WF →
∀ {l : List α} {k : α},
m.contains k = true → (↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit m l)).getKey! k = m.getKey! k | null | true |
alternatingGeometricSeries_radius | Mathlib.Analysis.Analytic.Constructions | ∀ (𝕜 : Type u_2) [inst : NontriviallyNormedField 𝕜] (A : Type u_7) [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
[NormOneClass A], (alternatingGeometricSeries 𝕜 A).radius = 1 | null | true |
NonUnitalSubalgebra.toNonUnitalStarSubalgebra_toNonUnitalSubalgebra | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : Star A] (s : NonUnitalSubalgebra R A) (h_star : ∀ x ∈ s, star x ∈ s),
(s.toNonUnitalStarSubalgebra h_star).toNonUnitalSubalgebra = s | null | true |
_private.Mathlib.Topology.Compactification.OnePoint.ProjectiveLine.0.Matrix.GeneralLinearGroup.IsParabolic.smul_eq_self_iff._proof_1_6 | Mathlib.Topology.Compactification.OnePoint.ProjectiveLine | ∀ {K : Type u_1} [inst : Field K] {g : GL (Fin 2) K},
(↑g 0 0 + ↑g 1 1) ^ 2 - 4 * (↑g 0 0 * ↑g 1 1 - ↑g 0 1 * ↑g 1 0) = 0 → (↑g 1 1 - ↑g 0 0) ^ 2 - 4 * ↑g 1 0 * -↑g 0 1 = 0 | null | false |
Finset.self_mem_range_succ | Mathlib.Data.Finset.Range | ∀ (n : ℕ), n ∈ Finset.range (n + 1) | null | true |
CategoryTheory.CostructuredArrow.mapIso | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{T T' : D} →
{S : CategoryTheory.Functor C D} →
(T ≅ T') → (CategoryTheory.CostructuredArrow S T ≌ CategoryTheory.CostructuredArrow S T') | An isomorphism `T ≅ T'` induces an equivalence
`CostructuredArrow S T ≌ CostructuredArrow S T'`. | true |
Lean.Order.instCCPOSTOfNonempty._proof_4 | Init.Internal.Order.MonadTail | ∀ {α σ : Type} [inst : Nonempty α] {x y : ST σ α},
Lean.Order.PartialOrder.rel x y → Lean.Order.PartialOrder.rel y x → x = y | null | false |
Std.TreeSet.Equiv.atIdx_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {i : ℕ} {h' : i < t₁.size}
(h : t₁.Equiv t₂), t₁.atIdx i h' = t₂.atIdx i ⋯ | null | true |
abs_sub_eq_two_nsmul_negPart | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a : α), |a| - a = 2 • a⁻ | null | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceCycles | 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] →
CategoryTheory.Abelian.SpectralObject C ι →
{i j k : ι} →
(f : i ⟶ j) →
(g : j... | The short complex expressing `Z^n(f, g)` as a cokernel of
the map `H^n(f) ⟶ H^n(f ≫ g)`. | true |
MeasureTheory.setLIntegral_eq_zero_iff' | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s →
∀ {f : α → ENNReal}, AEMeasurable f (μ.restrict s) → (∫⁻ (a : α) in s, f a ∂μ = 0 ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → f x = 0) | The measurability assumption is necessary, otherwise there are counterexamples: for instance,
the conclusion fails if `s = univ` and `f` is the characteristic function of a Vitali set. | true |
_private.Mathlib.Analysis.Meromorphic.Order.0.meromorphicOrderAt_add._simp_1_3 | Mathlib.Analysis.Meromorphic.Order | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀} {m n : ℤ},
a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0 → a ^ m * a ^ n = a ^ (m + n) | null | false |
WithAbs.moduleLeft._proof_4 | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_1} {T : Type u_3} [inst_2 : Semiring R]
(v : AbsoluteValue R S) [inst_3 : AddCommMonoid T] [inst_4 : Module R T] (a : WithAbs v) (x y : T),
a • (x + y) = a • x + a • y | null | false |
FiniteField.finrank_extension | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] [inst_1 : Finite k] (p : ℕ) [inst_2 : Fact (Nat.Prime p)] [inst_3 : CharP k p] (n : ℕ)
[inst_4 : NeZero n], Module.finrank k (FiniteField.Extension k p n) = n | null | true |
Int.neg_tmod | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (-a).tmod b = -a.tmod b | null | true |
CategoryTheory.MonoOver.isoMk.congr_simp | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {f g : CategoryTheory.MonoOver X}
(h h_1 : f.obj.left ≅ g.obj.left) (e_h : h = h_1) (w : CategoryTheory.CategoryStruct.comp h.hom g.arrow = f.arrow),
CategoryTheory.MonoOver.isoMk h w = CategoryTheory.MonoOver.isoMk h_1 ⋯ | null | true |
Inclusion.IVar.toExprInclusionBody | Mathlib.Tactic.Inclusion.Core.Types | Inclusion.IVar → Inclusion.ExprInclusionBody | Convert an `IVar` to an `ExprInclusionBody`. | true |
IsRightCancelMul.recOn | Mathlib.Algebra.Group.Semigroup | {G : Type u_2} →
[inst : Mul G] →
{motive : IsRightCancelMul G → Sort u} →
(t : IsRightCancelMul G) → ((mul_right_cancel : ∀ (a : G), IsRightRegular a) → motive ⋯) → motive t | null | false |
Mathlib.Tactic.ITauto.Proof.orInR.inj | Mathlib.Tactic.ITauto | ∀ {p p_1 : Mathlib.Tactic.ITauto.Proof}, p.orInR = p_1.orInR → p = p_1 | null | true |
CommRingCat.limitCommRing._proof_24 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommRingCat))).pt), 0 * a = 0 | null | false |
ContinuousAt.cfcₙ_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
Std.DTreeMap.Raw.find?_toList_eq_none_iff_contains_eq_false | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, List.find? (fun x => cmp x.fst k == Ordering.eq) t.toList = none ↔ t.contains k = false | null | true |
Matrix.SpecialLinearGroup.diag2._proof_2 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | 0 ≠ 1 | null | false |
Lean.Lsp.DidChangeWatchedFilesRegistrationOptions.rec | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.DidChangeWatchedFilesRegistrationOptions → Sort u} →
((watchers : Array Lean.Lsp.FileSystemWatcher) → motive { watchers := watchers }) →
(t : Lean.Lsp.DidChangeWatchedFilesRegistrationOptions) → motive t | null | false |
CochainComplex.HomComplex.leftHomologyData_i_hom_apply | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ) (x : CochainComplex.HomComplex.Cocycle K L n),
(AddCommGrpCat.Hom.hom (CochainComplex.HomComplex.leftHomologyData K L n).i) x = ↑x | null | true |
AddSubmonoid.neg_bot | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G], -⊥ = ⊥ | null | true |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitDeclAux.match_4 | Lean.Compiler.IR.EmitLLVM | (motive : Lean.IR.VarTypeMap × Lean.IR.JPParamsMap → Sort u_1) →
(x : Lean.IR.VarTypeMap × Lean.IR.JPParamsMap) →
((fst : Lean.IR.VarTypeMap) → (jpMap : Lean.IR.JPParamsMap) → motive (fst, jpMap)) → motive x | null | false |
CategoryTheory.EffectiveEpiFamilyStruct.uniq | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {B : C} {α : Type u_2} {X : α → C}
{π : (a : α) → X a ⟶ B} (self : CategoryTheory.EffectiveEpiFamilyStruct X π) {W : C} (e : (a : α) → X a ⟶ W)
(h :
∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
CategoryTheory.CategoryStruct.comp g₁ (... | ...and as such, unique. | true |
MeasurableInf₂.rec | Mathlib.MeasureTheory.Order.Lattice | {M : Type u_1} →
[inst : MeasurableSpace M] →
[inst_1 : Min M] →
{motive : MeasurableInf₂ M → Sort u} →
((measurable_inf : Measurable fun p => p.1 ⊓ p.2) → motive ⋯) → (t : MeasurableInf₂ M) → motive t | null | false |
CategoryTheory.Center.instMonoidalForget._proof_8 | Mathlib.CategoryTheory.Monoidal.Center | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : CategoryTheory.Center C),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor ((CategoryTheory.Center.forget C).obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategorySt... | null | false |
Finsupp.instNonUnitalRing._proof_2 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalRing β], ⇑0 = 0 | null | false |
Stream'.WSeq.recOn | Mathlib.Data.WSeq.Basic | {α : Type u} →
{motive : Stream'.WSeq α → Sort v} →
(s : Stream'.WSeq α) →
motive Stream'.WSeq.nil →
((x : α) → (s : Stream'.WSeq α) → motive (Stream'.WSeq.cons x s)) →
((s : Stream'.WSeq α) → motive s.think) → motive s | Recursion principle for weak sequences, compare with `List.recOn`. | true |
HurwitzZeta.hurwitzOddFEPair_f | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (a_1 : ℝ), (HurwitzZeta.hurwitzOddFEPair a).f a_1 = (Complex.ofReal ∘ HurwitzZeta.oddKernel a) a_1 | null | true |
_private.Mathlib.NumberTheory.Padics.HeightOneSpectrum.0.Rat.HeightOneSpectrum.primesEquiv._simp_1 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ {p : ℕ}, Prime ↑p = Nat.Prime p | null | false |
and_congr_left | Init.SimpLemmas | ∀ {c a b : Prop}, (c → (a ↔ b)) → (a ∧ c ↔ b ∧ c) | null | true |
HomotopicalAlgebra.BifibrantObject.toHoCat_map_eq_iff | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
{X Y : HomotopicalAlgebra.BifibrantObject C} (f g : X ⟶ Y),
HomotopicalAlgebra.BifibrantObject.toHoCat.map f = HomotopicalAlgebra.BifibrantObject.toHoCat.map g ↔
HomotopicalAlgebra.BifibrantObject.homRel C f g | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty.0.SimplexCategory.Truncated.epi_induction._proof_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty | ∀ {d : ℕ} {x : CategoryTheory.ObjectProperty.FullSubcategory fun a => a.len ≤ d}, x.obj.len + 1 ≤ d → x.obj.len < d | null | false |
Plausible.InjectiveFunction.shrink | Mathlib.Testing.Plausible.Functions | {α : Type} → [DecidableEq α] → Plausible.InjectiveFunction α → List (Plausible.InjectiveFunction α) | Shrink an injective function slicing a segment in the middle of the domain and removing
the corresponding elements in the codomain, hence maintaining the property that
one is a permutation of the other.
| true |
Set.«_aux_Mathlib_Order_SetNotation___macroRules_Set_term⋃_,__1» | Mathlib.Order.SetNotation | Lean.Macro | null | false |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.instLinearOrderedCommMonoidWithZeroMultiplicativeOrderDual._simp_2 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Add α] (a b : α), OrderDual.toDual a + OrderDual.toDual b = OrderDual.toDual (a + b) | null | false |
Std.ExtDHashMap.Const.get!_congr | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited β] {a b : α},
(a == b) = true → Std.ExtDHashMap.Const.get! m a = Std.ExtDHashMap.Const.get! m b | null | true |
Module.End.IsSemisimple.iSup_eigenspace_eq_top | Mathlib.LinearAlgebra.Eigenspace.Semisimple | ∀ {K : Type u_3} {V : Type u_4} [inst : Field K] [IsAlgClosed K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[FiniteDimensional K V] {f : Module.End K V}, f.IsSemisimple → ⨆ μ, f.eigenspace μ = ⊤ | null | true |
_private.Mathlib.Order.BooleanGenerators.0.IsCompactlyGenerated.BooleanGenerators.atomistic._simp_1_3 | Mathlib.Order.BooleanGenerators | ∀ {α : Type u} {x : α} {S : Set (Set α)}, (x ∈ ⋃₀ S) = ∃ t ∈ S, x ∈ t | null | false |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.setOfPred_sSameSide_eq_image2._simp_1_2 | Mathlib.Analysis.Convex.Side | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a | null | false |
Std.Internal.List.getValueCastD_filter_not_contains_map_fst_of_containsKey_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α}
{fallback : β k},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = false →
Std.Internal.List.getValueCastD k (List.filter (fun p => !(List.map Sigma.fst l₂).contains p.fst) ... | null | true |
IsCoprime.eq_1 | Mathlib.RingTheory.Coprime.Lemmas | ∀ {R : Type u} [inst : CommSemiring R] (x y : R), IsCoprime x y = ∃ a b, a * x + b * y = 1 | null | true |
Matroid.spanning_iff_eRk_le._auto_1 | Mathlib.Combinatorics.Matroid.Rank.ENat | Lean.Syntax | null | false |
AddMonoidHom.fst_comp_inl | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
(AddMonoidHom.fst M N).comp (AddMonoidHom.inl M N) = AddMonoidHom.id M | null | true |
EReal.sub_nonneg | Mathlib.Data.EReal.Operations | ∀ {x y : EReal}, x ≠ ⊤ ∨ y ≠ ⊤ → x ≠ ⊥ ∨ y ≠ ⊥ → (0 ≤ x - y ↔ y ≤ x) | null | true |
Array.map_eq_singleton_iff._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α} {b : β}, (Array.map f xs = #[b]) = ∃ a, xs = #[a] ∧ f a = b | null | false |
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sigma._simp_5 | Mathlib.Combinatorics.Matroid.Sum | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
LinearMap.prodOfFinsuppNat | Mathlib.LinearAlgebra.Finsupp.Pi | {R : Type u_1} →
{M : Type u_2} →
{P : Type u_4} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : AddCommMonoid P] → [inst_4 : Module R P] → (P × M →ₗ[R] M) → (ℕ →₀ P) →ₗ[R] P × M | A linear map from a product module `P × M` to `M` induces a linear map from `P^(ℕ)` to `M`,
where the `n`th component is given by `P —ι₁→ P × M` composed with `P × M —f→ M —ι₂→ P × M`
`n` times. | true |
StrictAnti.cmp_map_eq | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β},
StrictAnti f → ∀ (x y : α), cmp (f x) (f y) = cmp y x | null | true |
List.countP_cons | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α},
List.countP p (a :: l) = List.countP p l + if p a = true then 1 else 0 | null | true |
TypeVec.Subtype_.match_1 | Mathlib.Data.TypeVec | (motive : (x : ℕ) → (x_1 : TypeVec.{u_1} x) → x_1.Arrow (TypeVec.repeat x Prop) → Fin2 x → Sort u_2) →
(x : ℕ) →
(x_1 : TypeVec.{u_1} x) →
(x_2 : x_1.Arrow (TypeVec.repeat x Prop)) →
(x_3 : Fin2 x) →
((n : ℕ) →
(x : TypeVec.{u_1} (n + 1)) → (p : x.Arrow (TypeVec.repeat (n + 1... | null | false |
Module.Flat.projective_of_finitePresentation | Mathlib.RingTheory.Flat.EquationalCriterion | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
[Module.FinitePresentation R M], Module.Projective R M | [Stacks Tag 00NX](https://stacks.math.columbia.edu/tag/00NX) ((1) → (2)) | true |
ByteArray.utf8DecodeChar?.match_1.congr_eq_2 | Init.Data.String.Decode | ∀ (motive : ByteArray.utf8DecodeChar?.FirstByte → Sort u_1) (x : ByteArray.utf8DecodeChar?.FirstByte)
(h_1 : x = ByteArray.utf8DecodeChar?.FirstByte.invalid → motive ByteArray.utf8DecodeChar?.FirstByte.invalid)
(h_2 : x = ByteArray.utf8DecodeChar?.FirstByte.done → motive ByteArray.utf8DecodeChar?.FirstByte.done)
... | null | true |
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.cons_subset._simp_1_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s t : Multiset α}, (s ⊆ t) = ∀ ⦃x : α⦄, x ∈ s → x ∈ t | null | false |
MeasureTheory.SimpleFunc.monotone_eapprox | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} [inst : MeasurableSpace α] (f : α → ENNReal), Monotone (MeasureTheory.SimpleFunc.eapprox f) | null | true |
Nat.le_lt_asymm | Init.Data.Nat.Basic | ∀ {a b : ℕ}, a ≤ b → ¬b < a | null | true |
Lean.Lsp.DiagnosticWith.noConfusionType | Lean.Data.Lsp.Diagnostics | Sort u → {α : Type} → Lean.Lsp.DiagnosticWith α → {α' : Type} → Lean.Lsp.DiagnosticWith α' → Sort u | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.truncTotal_subst_eq_truncTotal_subst_sum._simp_1_4 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {α : Type u} {s : Set α} {a : α} (hs : s.Finite), (a ∈ hs.toFinset) = (a ∈ s) | null | false |
String.posLT_lt_iff._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} {h : 0 < p} {q : s.Pos}, (s.posLT p h < q) = (p ≤ q.offset) | null | false |
CategoryTheory.Idempotents.Karoubi.decompId_i | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(P : CategoryTheory.Idempotents.Karoubi C) → P ⟶ { X := P.X, p := CategoryTheory.CategoryStruct.id P.X, idem := ⋯ } | The split mono which appears in the factorisation `decompId P`. | true |
Std.TreeMap.foldr_eq_foldr_keys | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {δ : Type w} {f : α → δ → δ} {init : δ},
Std.TreeMap.foldr (fun a x d => f a d) init t = List.foldr f init t.keys | null | true |
Lean.Linter.UnusedVariables.References._sizeOf_1 | Lean.Linter.UnusedVariables | Lean.Linter.UnusedVariables.References → ℕ | null | false |
Int.trailingZeros._proof_2 | Init.Data.Dyadic.Basic | ∀ (k : ℕ) (i : ℤ), i ≠ 0 → i.natAbs ≤ k → k ≠ 0 | null | false |
MeasureTheory.FiniteMeasure.prod_apply | Mathlib.MeasureTheory.Measure.FiniteMeasureProd | ∀ {α : Type u_1} [inst : MeasurableSpace α] {β : Type u_2} [inst_1 : MeasurableSpace β]
(μ : MeasureTheory.FiniteMeasure α) (ν : MeasureTheory.FiniteMeasure β) (s : Set (α × β)),
MeasurableSet s → (μ.prod ν) s = (∫⁻ (x : α), ↑ν (Prod.mk x ⁻¹' s) ∂↑μ).toNNReal | null | true |
Subgroup.instMulActionQuotientDiff | Mathlib.GroupTheory.SchurZassenhaus | {G : Type u_1} →
[inst : Group G] →
{H : Subgroup G} →
[inst_1 : IsMulCommutative ↥H] → [inst_2 : H.FiniteIndex] → [H.Normal] → MulAction G H.QuotientDiff | null | true |
CategoryTheory.Comma.isAccessibleCategory | Mathlib.CategoryTheory.Presentable.Comma | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
(F₁ : CategoryTheory.Functor C₁ D) (F₂ : CategoryTheory.Functor C₂ D) [CategoryTheory.LocallySmall.{w, v_3, u_3} D]
[Cate... | null | true |
MulEquiv.instCoeFunForall.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N], MulEquiv.instCoeFunForall = { coe := fun f => ⇑f } | null | true |
MeasureTheory.measure_eq_zero_iff_ae_notMem | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s : Set α}, μ s = 0 ↔ ∀ᵐ (a : α) ∂μ, a ∉ s | null | true |
Finset.card_dfinsupp | Mathlib.Data.DFinsupp.Interval | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (α i)] (s : Finset ι)
(t : (i : ι) → Finset (α i)), (s.dfinsupp t).card = ∏ i ∈ s, (t i).card | null | true |
LinearIsometry.norm_compContinuousAlternatingMap | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {G : Type wG} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : Fintype... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.