name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Time.TimeZone.TZif.TZifV2._sizeOf_inst | Std.Time.Zoned.Database.TzIf | SizeOf Std.Time.TimeZone.TZif.TZifV2 | false |
PresheafOfModules.evaluationJointlyReflectsLimits | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{J : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor J (PresheafOfModules R)) →
[∀ (X : Cᵒᵖ),
Small.{v, max u₂ v}
... | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.localization_away_comap_range._simp_1_3 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | false |
Submodule.equivMapOfInjective._proof_4 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
(f : M →ₛₗ[σ₁₂] M₂) (i : Function.Injective ⇑f) (p : Submodule R M),
Function.RightInvers... | false |
Mathlib.PrintSorries.State.mk.inj | Mathlib.Util.PrintSorries | ∀ {visited : Lean.NameSet} {sorries : Std.HashSet Lean.Expr} {sorryMsgs : Array Lean.MessageData}
{visited_1 : Lean.NameSet} {sorries_1 : Std.HashSet Lean.Expr} {sorryMsgs_1 : Array Lean.MessageData},
{ visited := visited, sorries := sorries, sorryMsgs := sorryMsgs } =
{ visited := visited_1, sorries := sorri... | true |
NonUnitalStarSubalgebra.toNonUnitalSubring_injective | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A] [inst_3 : Star A],
Function.Injective NonUnitalStarSubalgebra.toNonUnitalSubring | true |
Lean.ErrorExplanation.Metadata.removedVersion? | Lean.ErrorExplanation | Lean.ErrorExplanation.Metadata → Option String | true |
CategoryTheory.sheafificationNatIso | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type u_1) →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[inst_2 : CategoryTheory.HasWeakSheafify J D] →
CategoryTheory.Functor.id (CategoryTheory.Sheaf J D) ≅
... | true |
RelIso.sumLexComplRight_symm_apply | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {x : α} [inst : IsTrans α r] [inst_1 : Std.Trichotomous r] [inst_2 : DecidableRel r]
(a : { x_1 // ¬r x x_1 } ⊕ Subtype (r x)), (RelIso.sumLexComplRight r x) a = (Equiv.sumCompl (r x)) a.swap | true |
CategoryTheory.ShortComplex.RightHomologyMapData.comp_φQ | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {φ' : S₂ ⟶ S₃} {h₁ : S₁.RightHomologyData}
{h₂ : S₂.RightHomologyData} {h₃ : S₃.RightHomologyData} (ψ : CategoryTheory.ShortComplex.RightHomolog... | true |
WithSeminorms.hasBasis_ball | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {p : SeminormFamily 𝕜 E ι},
WithSeminorms p → ∀ {x : E}, (nhds x).HasBasis (fun sr => 0 < sr.2) fun sr => (sr.1.sup p).ball x sr.2 | true |
List.sortedLE_ofFn_iff | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} {f : Fin n → α}, (List.ofFn f).SortedLE ↔ Monotone f | true |
Rel.edgeDensity.congr_simp | Mathlib.Combinatorics.SimpleGraph.Density | ∀ {α : Type u_4} {β : Type u_5} (r r_1 : α → β → Prop),
r = r_1 →
∀ {inst : (a : α) → DecidablePred (r a)} [inst_1 : (a : α) → DecidablePred (r_1 a)] (s s_1 : Finset α),
s = s_1 → ∀ (t t_1 : Finset β), t = t_1 → Rel.edgeDensity r s t = Rel.edgeDensity r_1 s_1 t_1 | true |
CategoryTheory.CostructuredArrow.toOverCompYoneda._proof_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
(T : CategoryTheory.Over A) {X Y : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.CostructuredArrow.toOver CategoryTheory.... | false |
Lean.IR.LogEntry | Lean.Compiler.IR.CompilerM | Type | true |
Differentiable.continuous | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} [ContinuousAdd E] [ContinuousSMul 𝕜 E] [ContinuousAdd F]
[C... | true |
Int64.sub_mul | Init.Data.SInt.Lemmas | ∀ {a b c : Int64}, (a - b) * c = a * c - b * c | true |
OrderHom.gfp_le | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, (∀ b ≤ f b, b ≤ a) → OrderHom.gfp f ≤ a | true |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic.0.Algebra.finite_iff_isIntegral_and_finiteType.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(motive : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A → Prop)
(x : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A),
(∀ (h : Algebra.IsIntegral R A) (right : Algebra.FiniteType R A), motive ⋯) → motive x | false |
Lean.Compiler.LCNF.instInhabitedLetDecl | Lean.Compiler.LCNF.Basic | {a : Lean.Compiler.LCNF.Purity} → Inhabited (Lean.Compiler.LCNF.LetDecl a) | true |
Lean.Parser.Tactic.mcasesPatAlts | Std.Tactic.Do.Syntax | Lean.ParserDescr | true |
Nucleus.mem_toSublocale | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {n : Nucleus X} {x : X}, x ∈ n.toSublocale ↔ ∃ y, n y = x | true |
CategoryTheory.LaxFunctor.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{P : Sort u} →
{toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C} →
{mapId :
(a : B) →
CategoryTheory.CategoryStruct.id (toPrelaxF... | false |
ULift.div | Mathlib.Algebra.Group.ULift | {α : Type u} → [Div α] → Div (ULift.{u_1, u} α) | true |
LinearIsometryEquiv.symm_conjStarAlgEquiv | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (e : H ≃ₗᵢ[𝕜] K), e.conjStarAlgEquiv.symm = e.symm.conjStarAlg... | true |
CategoryTheory.Functor.prod._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{u_7, u_1} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_3, u_5} B] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_8, u_2} C]
{D : Type u_6} [inst_3 : CategoryTheory.Category.{u_4, u_6} D] (F : CategoryTheory.Functor A B)
(G : CategoryTheory.Functor C... | false |
MeasureTheory.lintegral_lintegral_symm | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] ⦃f : α → β → ENNReal⦄,
AEMeasurable (Function.uncurry f) (μ.prod ν) →
∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (... | true |
CompactlySupportedContinuousMap._sizeOf_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_5} →
{β : Type u_6} →
{inst : TopologicalSpace α} →
{inst_1 : Zero β} →
{inst_2 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → CompactlySupportedContinuousMap α β → ℕ | false |
Mathlib.Tactic.BicategoryCoherence.LiftHom.recOn | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom f → Sort u_1} →
(t : Mathlib.Tactic.BicategoryCoherence.LiftHom f) →
((lift : CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicateg... | false |
StarMemClass.rec | Mathlib.Algebra.Star.Basic | {S : Type u_1} →
{R : Type u_2} →
[inst : Star R] →
[inst_1 : SetLike S R] →
{motive : StarMemClass S R → Sort u} →
((star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s) → motive ⋯) → (t : StarMemClass S R) → motive t | false |
Std.IterM.stepSize | Std.Data.Iterators.Combinators.Monadic.StepSize | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] → [Std.IteratorAccess α m] → [Monad m] → Std.IterM m β → ℕ → Std.IterM m β | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._proof_1_6 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (y : BitVec w), ¬2 ^ w - 1 - y.toNat < 2 ^ w → False | false |
ContinuousMap.Homotopy.extend_one | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(F : f₀.Homotopy f₁), F.extend 1 = f₁ | true |
MeasureTheory.exists_subordinate_pairwise_disjoint | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {ι : Type u_1} {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Countable ι] {s : ι → Set α},
(∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) →
Pairwise (Function.onFun (MeasureTheory.AEDisjoint μ) s) →
∃ t,
(∀ (i : ι), t i ⊆ s i) ∧
(∀ (i : ι), s i =ᵐ[μ] t i) ∧... | true |
RightCancelMonoid.Nat.card_submonoidPowers | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : RightCancelMonoid G] {a : G}, Nat.card ↥(Submonoid.powers a) = orderOf a | true |
_private.Mathlib.Algebra.Lie.Ideal.0.LieIdeal.comap._simp_2 | Mathlib.Algebra.Lie.Ideal | ∀ {M : Type u_1} [inst : AddZeroClass M] {s : AddSubmonoid M} {x : M}, (x ∈ s.toAddSubsemigroup) = (x ∈ s) | false |
Mul.recOn | Init.Prelude | {α : Type u} → {motive : Mul α → Sort u_1} → (t : Mul α) → ((mul : α → α → α) → motive { mul := mul }) → motive t | false |
SubmoduleClass.module'._proof_2 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_4} {M : Type u_1} {T : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Semiring S] [inst_3 : Module R M] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M]
[inst_7 : SetLike T M] [inst_8 : SMulMemClass T R M] (t : T) (x : ↥t), 1 • x = x | false |
_private.Mathlib.NumberTheory.Divisors.0.Nat.pairwise_divisorsAntidiagonalList_snd._simp_1_4 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | false |
_private.Lean.Compiler.LCNF.DeclHash.0.Lean.Compiler.LCNF.instHashableSignature.hash.match_1 | Lean.Compiler.LCNF.DeclHash | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Signature pu → Sort u_1) →
(x : Lean.Compiler.LCNF.Signature pu) →
((a : Lean.Name) →
(a_1 : List Lean.Name) →
(a_2 : Lean.Expr) →
(a_3 : Array (Lean.Compiler.LCNF.Param pu)) →
(a_4 : Bool) → ... | false |
USize.lt_of_le_of_lt | Init.Data.UInt.Lemmas | ∀ {a b c : USize}, a ≤ b → b < c → a < c | true |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.Reorder.permute!.cyclicPermuteAux._unsafe_rec | Mathlib.Tactic.Translate.Reorder | {α : Type u_1} → Array α → List ℕ → α → ℕ → Array α | false |
Lean.Elab.Term.StructInst.SourcesView.noConfusionType | Lean.Elab.StructInst | Sort u → Lean.Elab.Term.StructInst.SourcesView → Lean.Elab.Term.StructInst.SourcesView → Sort u | false |
CategoryTheory.monoidalCategoryMop._proof_11 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(W X Y Z : Cᴹᵒᵖ),
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z.unmop
(CategoryTheory.MonoidalCategoryStruct.associator Y.unmop X.unmop W.unmop).... | false |
ZSpan.fract_eq_self | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] {b : Module.Basis ι K E} [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] {x : E}, ZSpan.fract b x = x ↔ x ∈ ZSpan.fundamentalDomain b | true |
groupHomology.inhomogeneousChains.d._proof_4 | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ (n : ℕ), NeZero (n + 1) | false |
instDecidableIsValidUTF8 | Init.Data.String.Basic | {b : ByteArray} → Decidable b.IsValidUTF8 | true |
Matroid.IsBasis'.eRk_eq_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis' I X → M.eRk X = I.encard | true |
AddOpposite.coe_symm_opAddEquiv | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} [inst : AddCommMonoid M], ⇑AddOpposite.opAddEquiv.symm = AddOpposite.unop | true |
LocalSubring.exists_le_valuationSubring | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_3} [inst : Field K] (A : LocalSubring K), ∃ B, A ≤ B.toLocalSubring | true |
AddMonCat.forget_createsLimit._proof_6 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
(this : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections)
(s : CategoryTheory.Limits.Cone F) (x y : ↑s.1),
(CategoryTheory.Limits.Types.Small.limitConeIsLimit (F.comp (CategoryTheor... | false |
Complex.tan | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ | true |
Finset.sup_eq_bot_of_isEmpty | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] [IsEmpty β] (f : β → α) (S : Finset β),
S.sup f = ⊥ | true |
QuasiconcaveOn.convex_gt | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconcaveOn 𝕜 s f → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ r < f x} | true |
Nat.prod_divisors_prime_pow | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} [inst : CommMonoid α] {k p : ℕ} {f : ℕ → α},
Nat.Prime p → ∏ x ∈ (p ^ k).divisors, f x = ∏ x ∈ Finset.range (k + 1), f (p ^ x) | true |
StrictMonoOn.add | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f g : β → α} {s : Set β}
[AddLeftStrictMono α] [AddRightStrictMono α],
StrictMonoOn f s → StrictMonoOn g s → StrictMonoOn (fun x => f x + g x) s | true |
Submodule.mem_span_set | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : M}
{s : Set M}, m ∈ Submodule.span R s ↔ ∃ c, ↑c.support ⊆ s ∧ (c.sum fun mi r => r • mi) = m | true |
_private.Init.Data.Int.Gcd.0.Int.lcm_mul_right_dvd_mul_lcm._simp_1_1 | Init.Data.Int.Gcd | ∀ (k m n : ℕ), (k.lcm (m * n) ∣ k.lcm m * k.lcm n) = True | false |
MulOpposite.instCancelCommMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CancelCommMonoid α],
MulOpposite.instCancelCommMonoid = { toCommMonoid := MulOpposite.instCommMonoid, toIsLeftCancelMul := ⋯ } | true |
AdicCompletion.AdicCauchySequence.instAddCommGroup._proof_4 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : AdicCompletion.AdicCauchySequence I M), ↑(-x) = ↑(-x) | false |
TrivSqZeroExt.isNilpotent_inr | Mathlib.RingTheory.DualNumber | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] (x : M), IsNilpotent (TrivSqZeroExt.inr x) | true |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.recOn | Lean.Server.Logging | {motive : Lean.Server.Logging.LogEntry✝ → Sort u} →
(t : Lean.Server.Logging.LogEntry✝¹) →
((time : Std.Time.ZonedDateTime) →
(direction : Lean.JsonRpc.MessageDirection) →
(kind : Lean.JsonRpc.MessageKind) →
(msg : Lean.JsonRpc.Message) → motive { time := time, direction := direction... | false |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset._sparseCasesOn_1 | Lean.Meta.Sym.Offset | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Summable.tsum_of_nat_of_neg | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{f : ℤ → G},
(Summable fun n => f ↑n) →
(Summable fun n => f (-↑n)) → ∑' (n : ℤ), f n = ∑' (n : ℕ), f ↑n + ∑' (n : ℕ), f (-↑n) - f 0 | true |
Lean.Elab.Command.CtorView.modifiers | Lean.Elab.MutualInductive | Lean.Elab.Command.CtorView → Lean.Elab.Modifiers | true |
Algebra.IsAlgebraic.mk._flat_ctor | Mathlib.RingTheory.Algebraic.Defs | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
(∀ (x : A), IsAlgebraic R x) → Algebra.IsAlgebraic R A | false |
CategoryTheory.Functor.LaxMonoidal.ofBifunctor.bottomMapᵣ | Mathlib.CategoryTheory.Monoidal.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u_2} →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj
... | true |
Subarray.mkSlice_roi_eq_mkSlice_rco | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs lo<...* = Std.Rco.Sliceable.mkSlice xs (lo + 1)...Std.Slice.size xs | true |
LinearEquiv.cast_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_14} {M : ι → Type u_15} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] {i j : ι} (h : i = j) (a : M j), (LinearEquiv.cast h).symm a = cast ⋯ a | true |
MeasureTheory.MemLp.integrable_enorm_pow | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε} {p : ℕ},
MeasureTheory.MemLp f (↑p) μ → p ≠ 0 → MeasureTheory.Integrable (fun x => ‖f x‖ₑ ^ p) μ | true |
SkewMonoidAlgebra.liftNCRingHom._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} [inst : Semiring k] {R : Type u_2} [inst_1 : Semiring R], AddMonoidHomClass (k →+* R) k R | false |
Nat.recOnPrimePow._proof_5 | Mathlib.Data.Nat.Factorization.Induction | ∀ (k : ℕ), (k + 2) / (k + 2).minFac ^ (k + 2).factorization (k + 2).minFac < k + 2 | false |
CategoryTheory.LocalizerMorphism.RightResolution.mk_surjective | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
(R : Φ.RightResolution X₂), ∃ X₁ w, ∃ (hw : W... | true |
AffineMap.map_midpoint | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ {R : Type u_1} {V : Type u_2} {V' : Type u_3} {P : Type u_4} {P' : Type u_5} [inst : Ring R] [inst_1 : Invertible 2]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup V']
[inst_6 : Module R V'] [inst_7 : AddTorsor V' P'] (f : P →ᵃ[R] P') (a b : P),
f (midpoint R a b... | true |
Std.DHashMap.getKey?_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₂ → (m₁ ∪ m₂).getKey? k = m₁.getKey? k | true |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.IsLocal.mem_jacobson_or_exists_inv.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} (x : R) (motive : (∃ y ∈ I, ∃ z ∈ Ideal.span {x}, y + z = 1) → Prop)
(x_1 : ∃ y ∈ I, ∃ z ∈ Ideal.span {x}, y + z = 1),
(∀ (p : R) (hpi : p ∈ I) (q : R) (hq : q ∈ Ideal.span {x}) (hpq : p + q = 1), motive ⋯) → motive x_1 | false |
Std.ExtDHashMap.Const.insertManyIfNewUnit_list_eq_empty_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α}, (Std.ExtDHashMap.Const.insertManyIfNewUnit m l = ∅) = (m = ∅ ∧ l = []) | false |
Lean.Meta.DiagSummary.data._default | Lean.Meta.Diagnostics | Array Lean.MessageData | false |
Bundle.TotalSpace.recOn | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_4} →
{E : B → Type u_5} →
{motive : Bundle.TotalSpace F E → Sort u} →
(t : Bundle.TotalSpace F E) → ((proj : B) → (snd : E proj) → motive ⟨proj, snd⟩) → motive t | false |
ENNReal.finsetSum_iSup | Mathlib.Data.ENNReal.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} {s : Finset α} {f : α → ι → ENNReal},
(∀ (i j : ι), ∃ k, ∀ (a : α), f a i ≤ f a k ∧ f a j ≤ f a k) → ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i | true |
Lean.SubExpr.Pos.pushAppArg | Lean.SubExpr | Lean.SubExpr.Pos → Lean.SubExpr.Pos | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.findSome?_eq_some_iff._simp_1_1 | Batteries.Data.Fin.Lemmas | ∀ {p : Fin 0 → Prop}, (∀ (i : Fin 0), p i) = True | false |
PUnit.instLinearOrderedAddCommMonoidWithTop._proof_3 | Mathlib.Algebra.Order.PUnit | ∀ (x : PUnit.{1}), x ≤ x | false |
Lean.Meta.DiscrTree.getSubexpressionMatches._unsafe_rec | Mathlib.Lean.Meta.DiscrTree | {α : Type} → Lean.Meta.DiscrTree α → Lean.Expr → Lean.MetaM (Array α) | false |
_aux_Mathlib_Algebra_Group_Units_Defs___unexpand_Units_1 | Mathlib.Algebra.Group.Units.Defs | Lean.PrettyPrinter.Unexpander | false |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processImplicitArg._unsafe_rec | Lean.Elab.PatternVar | Bool →
Lean.Elab.Term.CollectPatternVars.Context →
Lean.Elab.Term.CollectPatternVars.M Lean.Elab.Term.CollectPatternVars.Context | false |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_nat._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ} {x : M}, (x ∈ (f.genEigenspace μ) ↑k) = (x ∈ ((f - μ • 1) ^ k).ker) | false |
IsAddUnit.of_add_eq_zero_right | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] [IsDedekindFiniteAddMonoid M] {b : M} (a : M), a + b = 0 → IsAddUnit b | true |
MeasureTheory.VectorMeasure.dirac._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {β : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : MeasurableSpace β] (x : β) (v : M) ⦃i : Set β⦄,
¬MeasurableSet i → (if MeasurableSet i ∧ x ∈ i then v else 0) = 0 | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.induction_aux._simp_1_9 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {ι : Sort u_5} (a : α) (f : ι → β),
(Set.range fun i => a • f i) = a • Set.range f | false |
UniqueFactorizationMonoid.radical_ne_zero._simp_1 | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M} [Nontrivial M], (UniqueFactorizationMonoid.radical a = 0) = False | false |
DirectSum.IsInternal.exists_subordinateOrthonormalBasisIndex_eq | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : FiniteDimensional 𝕜 E] {n : ℕ}
(hn : Module.finrank 𝕜 E = n) [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
(hV' : ... | true |
LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_3} → [self : LinearOrderedCommGroupWithZero α] → LinearOrderedCommMonoidWithZero α | true |
_private.Mathlib.Tactic.CongrExclamation.0.Congr!.plausiblyEqualTypes.match_5 | Mathlib.Tactic.CongrExclamation | (motive : ℕ → Sort u_1) → (maxDepth : ℕ) → (Unit → motive 0) → ((maxDepth : ℕ) → motive maxDepth.succ) → motive maxDepth | false |
CochainComplex.isKProjective_shift_iff | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(K : CochainComplex C ℤ) (n : ℤ),
((CategoryTheory.shiftFunctor (CochainComplex C ℤ) n).obj K).IsKProjective ↔ K.IsKProjective | true |
Hyperreal.coe_add | Mathlib.Analysis.Real.Hyperreal | ∀ (x y : ℝ), ↑(x + y) = ↑x + ↑y | true |
Bundle.Prod.contMDiffVectorBundle | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} [inst : NontriviallyNormedField 𝕜] {EB : Type u_7}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_8} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB B] (F₁ : Type u_... | true |
CategoryTheory.ProjectiveResolution.liftFOne._proof_3 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Y : C}
(P : CategoryTheory.ProjectiveResolution Y), CategoryTheory.Projective (P.complex.X 1) | false |
Std.DTreeMap.Raw.Equiv.of_toList_perm | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp},
t₁.toList.Perm t₂.toList → t₁.Equiv t₂ | true |
PEquiv.ofSet_eq_refl._simp_1 | Mathlib.Data.PEquiv | ∀ {α : Type u} {s : Set α} [inst : DecidablePred fun x => x ∈ s], (PEquiv.ofSet s = PEquiv.refl α) = (s = Set.univ) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.