name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Function.partialInv_left | Mathlib.Logic.Function.Basic | ∀ {α : Type u_4} {β : Sort u_5} {f : α → β}, Function.Injective f → ∀ (x : α), Function.partialInv f (f x) = some x | null | true |
CategoryTheory.Join.mapPairComp_hom_app_right | Mathlib.CategoryTheory.Join.Basic | ∀ {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] {E' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} E'] {J : Type u₅} [inst_4 : CategoryTheory.Category.{v₅, u₅} J]
{K : Type u₆... | null | true |
Cardinal.mul_natCast_inj._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (a * ↑n = b * ↑n) = (a = b) | null | false |
MulActionHom.mk._flat_ctor | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{φ : M → N} →
{X : Type u_5} →
[inst : SMul M X] →
{Y : Type u_6} →
[inst_1 : SMul N Y] → (toFun : X → Y) → (∀ (m : M) (x : X), toFun (m • x) = φ m • toFun x) → X →ₑ[φ] Y | null | false |
Function.Injective.factorsThrough | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {f : α → β},
Function.Injective f → ∀ (g : α → γ), Function.FactorsThrough g f | null | true |
AffineIsometryEquiv.coe_symm_toContinuousAffineEquiv | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_4} {P : Type u_7} {P₂ : Type u_8} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMe... | null | true |
WeierstrassCurve.isHomogeneous_addSubMap | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) (i : Fin 3), (W.addSubMap i).IsHomogeneous 2 | null | true |
CategoryTheory.Oplax.OplaxTrans.whiskerLeft_naturality_id | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{G H : CategoryTheory.OplaxFunctor B C} (θ : CategoryTheory.Oplax.OplaxTrans G H) {a : B} {a' : C} (f : a' ⟶ G.obj a),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (θ.natura... | null | true |
_private.Lean.Parser.Basic.0.Lean.Parser.checkColEq._regBuiltin.Lean.Parser.checkColEq.docString_1 | Lean.Parser.Basic | IO Unit | null | false |
MeasureTheory.NullMeasurableSet._auto_1 | Mathlib.MeasureTheory.Measure.NullMeasurable | Lean.Syntax | null | false |
OrderMonoidWithZeroHom.coe_mk | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulZeroOneClass α]
[inst_3 : MulZeroOneClass β] (f : α →*₀ β) (h : Monotone (↑f).toFun),
⇑{ toMonoidWithZeroHom := f, monotone' := h } = ⇑f | null | true |
birkhoffSum_of_comp_eq | Mathlib.Dynamics.BirkhoffSum.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] {f : α → α} {φ : α → M},
φ ∘ f = φ → ∀ (n : ℕ), birkhoffSum f φ n = n • φ | If a function `φ` is invariant under a function `f` (i.e., `φ ∘ f = φ`), then the Birkhoff sum
of `φ` over `f` for `n` iterations is equal to `n • φ`. | true |
Laplacian.laplacian | Mathlib.Analysis.Distribution.DerivNotation | {E : Type v} → {F : outParam (Type w)} → [self : Laplacian E F] → E → F | `Δ f` is the Laplacian of `f`. The meaning of this notation is type-dependent. | true |
AddEquiv.toAdditive_toMultiplicative_symm_apply | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ (G : Type u_2) [inst : Add G] (x : G),
(AddEquiv.additiveMultiplicative G).symm x = Additive.ofMul (Multiplicative.ofAdd x) | **Alias** of `AddEquiv.additiveMultiplicative_symm_apply`. | true |
Pell.dnsq | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a), Zsqrtd.Nonsquare (Pell.d✝ a1) | null | true |
Lean.Lsp.CreateFile.mk.inj | Lean.Data.Lsp.Basic | ∀ {uri : Lean.Lsp.DocumentUri} {options? : Option Lean.Lsp.CreateFile.Options} {annotationId? : Option String}
{uri_1 : Lean.Lsp.DocumentUri} {options?_1 : Option Lean.Lsp.CreateFile.Options} {annotationId?_1 : Option String},
{ uri := uri, options? := options?, annotationId? := annotationId? } =
{ uri := uri... | null | true |
Set.fintypeAdd | Mathlib.Algebra.Group.Pointwise.Set.Finite | {α : Type u_1} → [inst : Add α] → [DecidableEq α] → (s t : Set α) → [Fintype ↑s] → [Fintype ↑t] → Fintype ↑(s + t) | Addition preserves finiteness. | true |
CategoryTheory.ObjectProperty.instSmallPair | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X Y : C),
CategoryTheory.ObjectProperty.Small.{w, v, u} (CategoryTheory.ObjectProperty.pair X Y) | null | true |
TopologicalAddGroup.IsSES.isOpenQuotientMap | Mathlib.Topology.Algebra.Group.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : AddGroup A] [inst_1 : AddGroup B] [inst_2 : AddGroup C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] {φ : A →+ B} {ψ : B →+ C},
TopologicalAddGroup.IsSES φ ψ → IsOpenQuotientMap ⇑ψ | null | true |
GrpCat.Hom._mkInternal._flat_ctor | Mathlib.Algebra.Category.Grp.Basic | {A B : GrpCat} → (↑A →* ↑B) → A.Hom B | null | false |
_aux_Init_Notation___unexpand_HAppend_hAppend_1 | Init.Notation | Lean.PrettyPrinter.Unexpander | null | false |
Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem | Mathlib.RingTheory.GradedAlgebra.Radical | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : CommRing A] [inst_1 : AddCommMonoid ι] [inst_2 : LinearOrder ι]
[IsOrderedCancelAddMonoid ι] [inst_4 : SetLike σ A] [inst_5 : AddSubmonoidClass σ A] {𝒜 : ι → σ}
[inst_6 : GradedRing 𝒜] {I : Ideal A},
Ideal.IsHomogeneous 𝒜 I →
I ≠ ⊤ →
(∀ {x y : A}... | null | true |
RingHom.StableUnderCompositionWithLocalizationAwayTarget.and | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
(RingHom.StableUnderCompositionWithLocalizationAwayTarget fun {R S} [CommRing R] [CommRing S] => P) →
(RingHom.StableUnderCompositionWithLocalizationAwayTarget fun {R S} [CommRing R] [CommRing S] => Q) →
RingHom.Stabl... | null | true |
Finset.EquitableOn.le_add_one | Mathlib.Data.Set.Equitable | ∀ {α : Type u_1} {s : Finset α} {f : α → ℕ} {a : α}, (↑s).EquitableOn f → a ∈ s → f a ≤ (∑ i ∈ s, f i) / s.card + 1 | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceFinHAddNatOfNatProdIntCoreE₂CohomologicalFin._proof_11 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r p : ℤ), p - r + r = p | null | false |
SimpleGraph.Walk.IsCycle.of_mapLe | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G G' : SimpleGraph V} (h : G ≤ G') {u : V} {p : G.Walk u u},
(SimpleGraph.Walk.mapLe h p).IsCycle → p.IsCycle | **Alias** of the forward direction of `SimpleGraph.Walk.isCycle_mapLe`. | true |
Nat.lcm_mul_right_right | Init.Data.Nat.Lcm | ∀ (m n : ℕ), n.lcm (n * m) = n * m | null | true |
_private.Qq.Macro.0.Qq.Impl.unquoteExpr.match_5 | Qq.Macro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((c : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const c us)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
AddGroupExtension.Equiv.ofAddMonoidHom._proof_4 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_4} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup G] {E : Type u_2} [inst_2 : AddGroup E]
{S : AddGroupExtension N E G} {E' : Type u_1} [inst_3 : AddGroup E'] {S' : AddGroupExtension N E' G} (f : E →+ E'),
f.comp S.inl = S'.inl →
S'.rightHom.comp f = S.rightHom →
∀ (e' : E'),
... | null | false |
_private.Mathlib.NumberTheory.ModularForms.SlashActions.0.ModularForm.«term_∣[_]__1» | Mathlib.NumberTheory.ModularForms.SlashActions | Lean.TrailingParserDescr | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.Trimmed | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Trimming | {basis_hd : ℝ → ℝ} →
{basis_tl : Tactic.ComputeAsymptotics.Basis} →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl → Prop | We call a `Multiseries` `Trimmed` if it is either `.nil` or `cons (exp, coef) tl` where `coef`
is trimmed and is not zero. | true |
Int.two_dvd_ne_zero._simp_1 | Mathlib.Algebra.Group.Int.Even | ∀ {n : ℤ}, (¬2 ∣ n) = (n % 2 = 1) | null | false |
Int8.neg_one_or | Init.Data.SInt.Bitwise | ∀ {a : Int8}, -1 ||| a = -1 | null | true |
Real.arcsin_le_arcsin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x y : ℝ}, x ≤ y → Real.arcsin x ≤ Real.arcsin y | null | true |
CategoryTheory.shift_shiftFunctorCompIsoId_add_neg_cancel_hom_app | Mathlib.CategoryTheory.Shift.Basic | ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddGroup A]
[inst_2 : CategoryTheory.HasShift C A] (n : A) (X : C),
(CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorCompIsoId C n (-n) ⋯).hom.app X) =
(CategoryTheory.shiftFunctorCompIsoId C (-n) n ⋯).hom.app ((... | null | true |
Mathlib.Tactic.RingNF.RingMode.raw.elim | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} →
(t : Mathlib.Tactic.RingNF.RingMode) → t.ctorIdx = 1 → motive Mathlib.Tactic.RingNF.RingMode.raw → motive t | null | false |
Ideal.quotientMulEquivQuotientProd._proof_3 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : CommRing R] (I J : Ideal R), IsCoprime I J → I * J = I ⊓ J | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go_get | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w newWidth : ℕ} (aig : Std.Sat.AIG α) (input : aig.RefVec w)
(lo curr : ℕ) (hcurr : curr ≤ newWidth) (s : aig.RefVec curr) (idx : ℕ) (hidx1 : idx < newWidth),
curr ≤ idx →
(Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go input lo curr hcurr s).get i... | null | true |
BesselPotentialSpace.instAddCommGroup._proof_10 | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : CompleteSpace F] [inst_7 : NormedSpace ℂ F] {s : ℝ} {p : ENNReal} [hp : Fact (1 ≤ p)]
(a : ... | null | false |
BoundedContinuousFunction.probCharDual | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | {F : Type u_2} →
[inst : SeminormedAddCommGroup F] → [inst_1 : NormedSpace ℝ F] → StrongDual ℝ F → BoundedContinuousFunction F ℂ | The bounded continuous map `x ↦ exp (L x * I)`, for a continuous linear form `L`. | true |
Real.hasSum_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.Series | ∀ (r : ℝ), HasSum (fun n => r ^ (2 * n + 1) / ↑(2 * n + 1).factorial) (Real.sinh r) | The power series expansion of `Real.sinh`. | true |
Nat.sub_max_sub_right._f | Init.Data.Nat.Lemmas | ∀ (x : ℕ) (f : Nat.below (motive := fun x => ∀ (x_1 x_2 : ℕ), max (x_1 - x) (x_2 - x) = max x_1 x_2 - x) x)
(x_1 x_2 : ℕ), max (x_1 - x) (x_2 - x) = max x_1 x_2 - x | null | false |
CategoryTheory.IsIso.instUnmopOfMonoidalOpposite | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᴹᵒᵖ} (f : X ⟶ Y) [CategoryTheory.IsIso f],
CategoryTheory.IsIso f.unmop | null | true |
CommMonCat.coyonedaType._proof_2 | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ (X : Type u_1ᵒᵖ) {X_1 Y Z : CommMonCat} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
CommMonCat.ofHom
(MonoidHom.pi fun i =>
(CommMonCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g)).comp (Pi.evalMonoidHom (fun a => ↑X_1) i)) =
CategoryTheory.CategoryStruct.comp
(CommMonCat.ofHom (MonoidHom.pi fun i => (C... | null | false |
MeasureTheory.Lp.indicatorConstLp_compMeasurePreserving._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.Indicator | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_2} [inst : MeasurableSpace β]
{μb : MeasureTheory.Measure β} {f : α → β} {s : Set β},
MeasurableSet s → μb s ≠ ⊤ → MeasureTheory.MeasurePreserving f μ μb → μ (f ⁻¹' s) ≠ ⊤ | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform.0.EisensteinSeries.δ._proof_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | (1 + 1).AtLeastTwo | null | false |
ProfiniteAddGrp.toLimit._proof_3 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteAddGrp.{u_1}), IsTopologicalAddGroup ↥(ProfiniteAddGrp.limitConePtAux P.diagram) | null | false |
MeasureTheory.IsStoppingTime.measurableSet_ge | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : LinearOrder ι] {f : MeasureTheory.Filtration ι m}
{τ : Ω → WithTop ι} [inst_1 : TopologicalSpace ι] [OrderTopology ι] [FirstCountableTopology ι],
MeasureTheory.IsStoppingTime f τ → ∀ (i : ι), MeasurableSet {ω | ↑i ≤ τ ω} | null | true |
_private.Mathlib.Algebra.Polynomial.Div.0.Polynomial.sub_dvd_eval_sub._simp_1_1 | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} {a : R} [inst : CommRing R] {p : Polynomial R}, (Polynomial.X - Polynomial.C a ∣ p) = p.IsRoot a | null | false |
Mathlib.Tactic.withResetServerInfo.Result.mk.noConfusion | Mathlib.Tactic.Basic | {α : Type} →
{P : Sort u} →
{result? : Option α} →
{msgs : Lean.MessageLog} →
{trees : Lean.PersistentArray Lean.Elab.InfoTree} →
{result?' : Option α} →
{msgs' : Lean.MessageLog} →
{trees' : Lean.PersistentArray Lean.Elab.InfoTree} →
{ result? := ... | null | false |
ProfiniteAddGrp.instIsTopologicalAddGroupCarrierToTopTotallyDisconnectedSpacePtProfiniteLimitConeCompForget₂ContinuousAddMonoidHomToProfiniteContinuousMap | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max v u}),
IsTopologicalAddGroup
↑(Profinite.limitCone (F.comp (CategoryTheory.forget₂ ProfiniteAddGrp.{max u v} Profinite))).pt.toTop | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Inner.Basic.0.SSet.Subcomplex.Pairing.innerAnodyneExtensions._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Inner.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.MorphismProperty C}
[Q.IsStableUnderCobaseChange], (P.pushouts ≤ Q) = (P ≤ Q) | null | false |
Sum.instBEq.beq.match_1 | Init.Data.Sum.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : α ⊕ β → α ⊕ β → Sort u_3) →
(x x_1 : α ⊕ β) →
((a b : α) → motive (Sum.inl a) (Sum.inl b)) →
((a b : β) → motive (Sum.inr a) (Sum.inr b)) → ((x x_2 : α ⊕ β) → motive x x_2) → motive x x_1 | null | false |
MvPolynomial.eval₂_uniqueAlgEquiv_symm | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Unique σ]
{f : Polynomial R} {φ : R →+* S} {a : σ → S},
MvPolynomial.eval₂ φ a ((MvPolynomial.uniqueAlgEquiv R σ).symm f) = Polynomial.eval₂ φ (a default) f | null | true |
Nat.forall_prime_of_two_of_odd | Mathlib.Data.Nat.Prime.Basic | ∀ {P : ℕ → Prop}, (P 2 ∧ ∀ (p : ℕ), Nat.Prime p → Odd p → P p) → ∀ (p : ℕ), Nat.Prime p → P p | To prove a property of all primes, it is enough to prove it for `2` and for the odd primes. | true |
Filter.CountableFilterBasis.rec | Mathlib.Order.Filter.CountablyGenerated | {α : Type u_5} →
{motive : Filter.CountableFilterBasis α → Sort u} →
((toFilterBasis : FilterBasis α) →
(countable : toFilterBasis.sets.Countable) →
motive { toFilterBasis := toFilterBasis, countable := countable }) →
(t : Filter.CountableFilterBasis α) → motive t | null | false |
Algebra.Extension.homInfinitesimal._proof_5 | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A], IsScalarTower R R A | null | false |
Std.ExtDHashMap.mem_alter_of_beq | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : Option (β k) → Option (β k)}, (k == k') = true → (k' ∈ m.alter k f ↔ (f (m.get? k)).isSome = true) | null | true |
CategoryTheory.ShortComplex.leftHomologyFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.leftHomologyFunctor C).obj S = S.leftHomo... | null | true |
Prefunctor.mapPath._sunfold | Mathlib.Combinatorics.Quiver.Path | {V : Type u₁} →
[inst : Quiver V] →
{W : Type u₂} → [inst_1 : Quiver W] → (F : V ⥤q W) → {a b : V} → Quiver.Path a b → Quiver.Path (F.obj a) (F.obj b) | null | false |
List.length_pos_of_sum_pos | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] [inst_1 : Preorder M] (L : List M), 0 < L.sum → 0 < L.length | A list with positive sum must have positive length. | true |
_private.Lean.Compiler.LCNF.StructProjCases.0.Lean.Compiler.LCNF.StructProjCases.visitCode._sparseCasesOn_10 | Lean.Compiler.LCNF.StructProjCases | {pu : Lean.Compiler.LCNF.Purity} →
{motive_1 : Lean.Compiler.LCNF.Alt pu → Sort u} →
(t : Lean.Compiler.LCNF.Alt pu) →
((ctorName : Lean.Name) →
(params : Array (Lean.Compiler.LCNF.Param pu)) →
(code : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.pure... | null | false |
_private.Mathlib.CategoryTheory.ObjectProperty.LimitsClosure.0.CategoryTheory.ObjectProperty.strictLimitsClosureStep_strictLimitsClosureIter_eq_self._simp_1_1 | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : CategoryTheory.ObjectProperty C) (X : C),
(P ⊔ Q) X = (P X ∨ Q X) | null | false |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.StrongHomClass.realize_boundedFormula._simp_1_7 | Mathlib.ModelTheory.Semantics | ∀ {γ : Sort u_1} {δ : Sort u_2} {α : Type u_3} {β : Type u_4} (f : γ → δ) (g : α → γ) (h : β → γ),
Sum.elim (f ∘ g) (f ∘ h) = f ∘ Sum.elim g h | null | false |
_private.Lean.Meta.Tactic.TryThis.0.Lean.Meta.Tactic.TryThis.tryThisProvider._sparseCasesOn_6 | Lean.Meta.Tactic.TryThis | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.CustomInfo) → motive (Lean.Elab.Info.ofCustomInfo i)) →
(Nat.hasNotBit 1024 t.ctorIdx → motive t) → motive t | null | false |
ContDiffBump.mk.injEq | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} {c : E} (rIn rOut : ℝ) (rIn_pos : 0 < rIn) (rIn_lt_rOut : rIn < rOut) (rIn_1 rOut_1 : ℝ)
(rIn_pos_1 : 0 < rIn_1) (rIn_lt_rOut_1 : rIn_1 < rOut_1),
({ rIn := rIn, rOut := rOut, rIn_pos := rIn_pos, rIn_lt_rOut := rIn_lt_rOut } =
{ rIn := rIn_1, rOut := rOut_1, rIn_pos := rIn_pos_1, rIn_lt_rOut ... | null | true |
CategoryTheory.Limits.piConst | Mathlib.CategoryTheory.Limits.Shapes.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasProducts C] → CategoryTheory.Functor C (CategoryTheory.Functor Type wᵒᵖ C) | The functor sending `(X, n)` to the product of copies of `X` indexed by `n`. | true |
ProbabilityTheory.Kernel.measurable_singularPart | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] (κ η : ProbabilityTheory.Kernel α γ)
[ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel η],
Measurable fun a => (κ a).singularPart (η a) | For two kernels `κ, η`, the singular part of `κ a` with respect to `η a` is a measurable
function of `a`. | true |
MeasureTheory.continuousOn_setToFun_of_dominated | Mathlib.MeasureTheory.Integral.SetToL1.DominatedConvergence | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{T : Set α → E →L[ℝ] F} {C : ℝ} {X : Type u_4} [inst_4 : TopologicalSpace X] [FirstCountableTopolog... | null | true |
WittVector.IsPoly | Mathlib.RingTheory.WittVector.IsPoly | (p : ℕ) → (⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R) → Prop | A function `f : Π R, 𝕎 R → 𝕎 R` that maps Witt vectors to Witt vectors over arbitrary base rings
is said to be *polynomial* if there is a family of polynomials `φₙ` over `ℤ` such that the `n`th
coefficient of `f x` is given by evaluating `φₙ` at the coefficients of `x`.
See also `WittVector.IsPoly₂` for the binary v... | true |
CategoryTheory.Limits.Fork.isoForkOfι_hom_hom | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : X ⟶ Y} (c : CategoryTheory.Limits.Fork f g),
c.isoForkOfι.hom.hom = CategoryTheory.CategoryStruct.id c.pt | null | true |
Finset.not_isDiag_mk_of_mem_offDiag | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1} {s : Finset α} {a b : α}, (a, b) ∈ s.offDiag → ¬s(a, b).IsDiag | null | true |
Std.DTreeMap.minKey?_eq_head?_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.minKey? = t.keys.head? | null | true |
Submonoid.pointwiseMulAction._proof_1 | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {α : Type u_2} {M : Type u_1} [inst : Monoid M] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction α M]
(S : Submonoid M), 1 • S = S | null | false |
TestFunction.Simps.coe | Mathlib.Analysis.Distribution.TestFunction | {E : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{Ω : TopologicalSpace.Opens E} →
{F : Type u_4} →
[inst_2 : NormedAddCommGroup F] → [inst_3 : NormedSpace ℝ F] → {n : ℕ∞} → TestFunction Ω F n → E → F | See note [custom simps projection]. | true |
zsmulRec.eq_2 | Mathlib.Algebra.Group.DivInvMonoid | ∀ {G : Type u_1} [inst : Zero G] [inst_1 : Add G] [inst_2 : Neg G] (npow : ℕ → G → G) (x : G) (n : ℕ),
zsmulRec npow (Int.negSucc n) x = -npow n.succ x | null | true |
instLawfulCommIdentityUSizeHMulOfNat | Init.Data.UInt.Lemmas | Std.LawfulCommIdentity (fun x1 x2 => x1 * x2) 1 | null | true |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
SSet.stdSimplex.coe_edge_down_toOrderHom | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ (n : ℕ) (a b : Fin (n + 1)) (hab : a ≤ b),
⇑(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.edge n a b hab).down) = ![a, b] | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.logDeriv_sineTerm_eq_cotTerm._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Set.finite_mem_finset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} (s : Finset α), {a | a ∈ s}.Finite | null | true |
_private.Mathlib.Data.QPF.Multivariate.Constructions.Sigma.0.MvQPF.Pi.abs.match_1.splitter | Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {n : ℕ} →
{A : Type u_1} →
(F : A → TypeVec.{u_1} n → Type u_1) →
[inst : (α : A) → MvQPF (F α)] →
⦃α : TypeVec.{u_1} n⦄ →
(motive : ↑(MvQPF.Pi.P F) α → Sort u_2) →
(x : ↑(MvQPF.Pi.P F) α) →
((a : (MvQPF.Pi.P F).A) → (f : ((MvQPF.Pi.P F).B a).Arrow α) → motive ⟨a,... | null | true |
Std.DTreeMap.Internal.RccSliceData.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {P : Sort u_1} →
{α : Type u} →
{β : α → Type v} →
{inst : Ord α} →
{t : Std.DTreeMap.Internal.RccSliceData α β} →
{α' : Type u} →
{β' : α' → Type v} →
{inst' : Ord α'} →
{t' : Std.DTreeMap.Internal.RccSliceData α' β'} →
α = α' → ... | null | false |
AddCon.prod.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (c : AddCon M) (d : AddCon N),
c.prod d = { toSetoid := c.prod d.toSetoid, add' := ⋯ } | null | true |
CategoryTheory.Bicategory.Adj.forget₁._proof_3 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {f g h : a ⟶ b}
(η : f ⟶ g) (θ : g ⟶ h), (CategoryTheory.CategoryStruct.comp η θ).τl = CategoryTheory.CategoryStruct.comp η.τl θ.τl | null | false |
List.min_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] [Std.MinEqOr α] {l : List α} (hl : l ≠ []), l.min hl ∈ l | null | true |
ChevalleyThm.MvPolynomialC.numBound._mutual._proof_1 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | WellFounded (invImage (fun x => PSum.casesOn x (fun a => (a, 0)) fun a => (a, 1)) Prod.instWellFoundedRelation).1 | null | false |
CategoryTheory.MorphismProperty.IsWeakFactorizationSystem.rlp | Mathlib.CategoryTheory.MorphismProperty.WeakFactorizationSystem | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {W₁ W₂ : CategoryTheory.MorphismProperty C}
[self : W₁.IsWeakFactorizationSystem W₂], W₁.rlp = W₂ | null | true |
irrational_div_intCast_iff | Mathlib.NumberTheory.Real.Irrational | ∀ {m : ℤ} {x : ℝ}, Irrational (x / ↑m) ↔ m ≠ 0 ∧ Irrational x | null | true |
Char.quoteCore | Init.Data.Repr | Char → optParam Bool false → String | null | true |
_private.Lean.Compiler.IR.Format.0.Lean.IR.formatFnBody.loop | Lean.Compiler.IR.Format | ℕ → Lean.IR.FnBody → Std.Format | null | true |
CategoryTheory.Functor.pointwiseRightKanExtension_lift_app | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) [inst_3 : L.HasPointwiseRightKanExtension F]
(G : CategoryT... | null | true |
Turing.PartrecToTM2.contSupp_fix | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.contSupp (Turing.PartrecToTM2.Cont'.fix f k) =
Turing.PartrecToTM2.codeSupp f (Turing.PartrecToTM2.Cont'.fix f k) | null | true |
LaurentSeries.instValuedSpaceWithValRatFuncWithZeroMultiplicativeIntPolynomialValuationXRatfuncAdicComplPkg._proof_4 | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_1} [inst : Field K] (s t : Set LaurentSeries.ratfuncAdicComplPkg.space),
LaurentSeries.instValuedSpaceWithValRatFuncWithZeroMultiplicativeIntPolynomialValuationXRatfuncAdicComplPkg._aux_1 s →
LaurentSeries.instValuedSpaceWithValRatFuncWithZeroMultiplicativeIntPolynomialValuationXRatfuncAdicComplPkg.... | null | false |
Real.ofDigitsTerm_nonneg | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ} {digits : ℕ → Fin b} {n : ℕ}, 0 ≤ Real.ofDigitsTerm digits n | null | true |
Inclusion.InclusionFamily.mk._flat_ctor | Mathlib.Tactic.Inclusion.Core.Extensions | Lean.Name →
DiscrTreeExt.EnvExt Inclusion.InclusionExt → DiscrTreeExt.EnvExt Inclusion.HypothesisExt → Inclusion.InclusionFamily | null | false |
CategoryTheory.Cat.FreeRefl.homMk | Mathlib.CategoryTheory.Category.ReflQuiv | {V : Type u_1} →
[inst : CategoryTheory.ReflQuiver V] →
{v w : V} → (v ⟶ w) → (CategoryTheory.Cat.FreeRefl.mk v ⟶ CategoryTheory.Cat.FreeRefl.mk w) | Constructor for morphisms in `FreeRefl`. | true |
CategoryTheory.EffectiveEpiFamilyStruct.desc.congr_simp | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {B : C} {α : Type u_2} {X : α → C}
{π : (a : α) → X a ⟶ B} (self self_1 : CategoryTheory.EffectiveEpiFamilyStruct X π),
self = self_1 →
∀ {W : C} (e e_1 : (a : α) → X a ⟶ W) (e_e : e = e_1)
(a :
∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g... | null | true |
nodup_permsOfList | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α}, l.Nodup → (permsOfList l).Nodup | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.emod_lt_of_neg._proof_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ {b : ℤ} (b' : ℕ), Int.negSucc b' < 0 → ¬0 < ↑b' + 1 → False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.