name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.factoredNumbers.map_prime_pow_mul | Mathlib.NumberTheory.SmoothNumbers | ∀ {F : Type u_1} [inst : Mul F] {f : ℕ → F},
(∀ {m n : ℕ}, m.Coprime n → f (m * n) = f m * f n) →
∀ {s : Finset ℕ} {p : ℕ},
Nat.Prime p → p ∉ s → ∀ (e : ℕ) {m : ↑(Nat.factoredNumbers s)}, f (p ^ e * ↑m) = f (p ^ e) * f ↑m | If `f : ℕ → F` is multiplicative on coprime arguments, `p ∉ s` is a prime and `m`
is `s`-factored, then `f (p^e * m) = f (p^e) * f m`. | true |
MeasureTheory.ComplexMeasure.singularPart._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ContinuousAdd ℝ | null | false |
EquivLike.comp_surjective | Mathlib.Basic.FunLike.Equiv | ∀ {F : Sort u_2} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [inst : EquivLike F β γ] (f : α → β) (e : F),
Function.Surjective (⇑e ∘ f) ↔ Function.Surjective f | null | true |
FiniteArchimedeanClass.closedBall | Mathlib.Algebra.Order.Module.Archimedean | {M : Type u_1} →
[inst : AddCommGroup M] →
[inst_1 : LinearOrder M] →
[inst_2 : IsOrderedAddMonoid M] →
(K : Type u_2) →
[inst_3 : Ring K] →
[inst_4 : LinearOrder K] →
[IsOrderedRing K] →
[Archimedean K] → [inst_7 : Module K M] → [PosSMulMono K M] ... | A closed ball defined by `ArchimedeanClass.submodule` of `UpperSet.Ici c`.
This has the same carrier as `ArchimedeanClass.closedBallAddSubgroup`'s. | true |
Submodule.piQuotientLift._proof_1 | Mathlib.LinearAlgebra.Quotient.Pi | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
Batteries.Tactic.Lint.SimpTheoremInfo.noConfusionType | Batteries.Tactic.Lint.Simp | Sort u → Batteries.Tactic.Lint.SimpTheoremInfo → Batteries.Tactic.Lint.SimpTheoremInfo → Sort u | null | false |
MvPolynomial.iterToSum_C_X | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R] (c : S₂),
(MvPolynomial.iterToSum R S₁ S₂) (MvPolynomial.C (MvPolynomial.X c)) = MvPolynomial.X (Sum.inr c) | null | true |
_private.Mathlib.Order.Filter.AtTopBot.Group.0.Filter.tendsto_comp_inv_atBot_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g | null | false |
instHasUniqueRootsMultiplicativeOfHasUniqueDiv | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u} [inst : AddMonoid α] [HasUniqueDiv α], HasUniqueRoots (Multiplicative α) | null | true |
StarSubalgebra.topologicalClosure._proof_4 | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
[inst_7 : IsSemitopologicalSemiring A] (s : StarSubalgebra R A), 0 ∈ s.topologicalClosure.carrier | null | false |
UInt64.toBitVec_eq_of_eq | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a = b → a.toBitVec = b.toBitVec | null | true |
Complex.exp_ne_zero._simp_1 | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℂ), (Complex.exp x = 0) = False | null | false |
IsLocalExtr.deriv_eq_zero | Mathlib.Analysis.Calculus.LocalExtr.Basic | ∀ {f : ℝ → ℝ} {a : ℝ}, IsLocalExtr f a → deriv f a = 0 | **Fermat's Theorem**: the derivative of a function at a local extremum equals zero. | true |
_private.Mathlib.Order.CountableSupClosed.0.countableSupClosure_eq_sInter._simp_1_2 | Mathlib.Order.CountableSupClosed | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Function.HasTemperateGrowth.zero | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F], Function.HasTemperateGrowth fun x => 0 | null | true |
nhdsSet_Iic | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderClosedTopology α] {a : α},
nhdsSet (Set.Iic a) = nhds a ⊔ Filter.principal (Set.Iio a) | null | true |
QuaternionAlgebra.imJ | Mathlib.Algebra.Quaternion | {R : Type u_1} → {a b c : R} → QuaternionAlgebra R a b c → R | Second imaginary part (j) of a quaternion. | true |
Lean.Server.RequestHandler.mk.noConfusion | Lean.Server.Requests | {P : Sort u} →
{fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri} →
{handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)} →
{fileSource' : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri} →
{handle' : Lea... | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.LinearMap.isPositive_iff._simp_1_2 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
_private.Mathlib.Data.Seq.Defs.0.Stream'.Seq.notMem_nil.match_1_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u_1} (a : α) (motive : a ∈ Stream'.Seq.nil → Prop) (x : a ∈ Stream'.Seq.nil),
(∀ (w : ℕ) (h : some a = none), motive ⋯) → motive x | null | false |
Field.div._inherited_default | Mathlib.Algebra.Field.Defs | {K : Type u} →
(one : K) →
(mul : K → K → K) →
(∀ (a b c : K), a * b * c = a * (b * c)) →
(∀ (a : K), 1 * a = a) →
(∀ (a : K), a * 1 = a) →
(npow : ℕ → K → K) →
(∀ (x : K), x ^ 0 = 1) → (∀ (n : ℕ) (x : K), x ^ (n + 1) = x ^ n * x) → (K → K) → K → K → K | null | false |
WeierstrassCurve.coeff_Φ | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (n : ℤ), (W.Φ n).coeff (n.natAbs ^ 2) = 1 | null | true |
_private.Lean.Level.0.Lean.Level.isIMax._sparseCasesOn_1.else_eq | Lean.Level | ∀ {motive : Lean.Level → Sort u} (t : Lean.Level) (imax : (a a_1 : Lean.Level) → motive (a.imax a_1))
(«else» : Nat.hasNotBit 8 t.ctorIdx → motive t) (h : Nat.hasNotBit 8 t.ctorIdx),
Lean.Level.isIMax._sparseCasesOn_1✝ t imax «else» = «else» h | null | false |
Set.SurjOn.image_invFunOn_image | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} [inst : Nonempty α],
Set.SurjOn f s t → f '' Function.invFunOn f s '' t = t | This lemma is a special case of `rightInvOn_invFunOn.image_image`; it may make more sense
to use the other lemma directly in an application. | true |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.young_inequality_eq_iff._simp_1_1 | Mathlib.Analysis.MeanInequalities | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Fin.appendIsometry._proof_2 | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (m n : ℕ) (x x_1 : (Fin m → α) × (Fin n → α)),
edist ((Fin.appendEquiv m n).toFun x) ((Fin.appendEquiv m n).toFun x_1) = edist x x_1 | null | false |
Valuation.IsEquiv.of_eq | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] {v v' : Valuation R Γ₀},
v = v' → v.IsEquiv v' | null | true |
_private.Mathlib.Condensed.Light.InternallyProjective.0.LightCondensed.ihom_map_val_app._simp_1_2 | Mathlib.Condensed.Light.InternallyProjective | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X : C} {Y Y' : D} (f : X ⟶ G.obj Y)
(g : Y ⟶ Y'),
CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y).symm f) ... | null | false |
Lean.Doc.MdRendererState.rec | Lean.DocString.Markdown | {motive : Lean.Doc.MdRendererState → Sort u} →
((imported current : Lean.NameMap Lean.Name) → motive { imported := imported, current := current }) →
(t : Lean.Doc.MdRendererState) → motive t | null | false |
PowerSeries.IsWeierstrassDivisorAt.mod_coe_eq_self | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] {g : PowerSeries A} {I : Ideal A} (H : g.IsWeierstrassDivisorAt I)
[inst_1 : IsAdicComplete I A] {r : Polynomial A},
r.degree < ↑((PowerSeries.map (Ideal.Quotient.mk I)) g).order.toNat → H.mod ↑r = r | null | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.ker_eval₂Hom_universalFactorizationMap._simp_1_3 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rcf : RingHomClass F R S] {f : F} {r : R}, (r ∈ RingHom.ker f) = (f r = 0) | null | false |
Lean.Expr.replaceNoCache._sunfold | Lean.Util.ReplaceExpr | (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Expr | null | false |
Array.setIfInBounds_def | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (xs : Array α) (i : ℕ) (a : α), xs.setIfInBounds i a = if h : i < xs.size then xs.set i a h else xs | null | true |
_private.Mathlib.Data.Rat.Cast.Order.0.Mathlib.Meta.Positivity.evalRatCast.match_3 | Mathlib.Data.Rat.Cast.Order | (a : Q(ℚ)) →
(motive : Mathlib.Meta.Positivity.Strictness q(inferInstance) a (some q(inferInstance)) → Sort u_1) →
(__do_lift : Mathlib.Meta.Positivity.Strictness q(inferInstance) a (some q(inferInstance))) →
((pa : Q(0 < «$a»)) → motive (Mathlib.Meta.Positivity.Strictness.positive pa)) →
((pa : Q(0... | null | false |
Lean.Parser.ParserCategory._sizeOf_1 | Lean.Parser.Basic | Lean.Parser.ParserCategory → ℕ | null | false |
SeparationQuotient.instAddCommSemigroup | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : AddCommSemigroup M] → [ContinuousAdd M] → AddCommSemigroup (SeparationQuotient M) | null | true |
IsSimpleAddGroup.of_isSimpleOrder | Mathlib.GroupTheory.Subgroup.Simple | ∀ {G : Type u_1} [inst : AddGroup G] [hG : IsSimpleOrder (AddSubgroup G)], IsSimpleAddGroup G | An additive group whose subgroups are only `⊥` and `⊤` is simple. | true |
CategoryTheory.Over.ConstructProducts.conesEquivFunctor.match_1 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {J : Type u_1} →
(motive : CategoryTheory.Discrete J → Sort u_2) →
(x : CategoryTheory.Discrete J) → ((j : J) → motive { as := j }) → motive x | null | false |
TensorProduct.toIntegralClosure_bijective_of_smooth | Mathlib.RingTheory.Smooth.IntegralClosure | ∀ {R : Type u_1} {S : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [Algebra.Smooth R S],
Function.Bijective ⇑(TensorProduct.toIntegralClosure R S B) | null | true |
MeasureTheory.SimpleFunc.instSemilatticeSup._proof_3 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : SemilatticeSup β]
(_f _g _h : MeasureTheory.SimpleFunc α β), _f ≤ _h → _g ≤ _h → ∀ (a : α), _f a ⊔ _g a ≤ _h a | null | false |
Mathlib.Tactic.Echelon.IsPivotedList.rec | Mathlib.Tactic.Echelon.Reflection | ∀ {α : Type u_1} {n : ℕ} [inst : Zero α]
{motive : (a : List (Fin n)) → (a_1 : List (List α)) → Mathlib.Tactic.Echelon.IsPivotedList a a_1 → Prop},
(∀ {rows : List (List α)} (hz : rows = List.map (fun x => List.replicate n 0) rows), motive [] rows ⋯) →
(∀ {k : Fin n} {ks : List (Fin n)} {row : List α} {rows : L... | null | false |
Complex.contDiff_exp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ] {n : WithTop ℕ∞},
ContDiff 𝕜 n Complex.exp | null | true |
mdifferentiableAt_fun_add_section | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_5} [inst : TopologicalSpace B]
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : (x : B) → TopologicalSpace (E x)]
[inst_3 : NormedAddCommGroup F] [inst_4 : NontriviallyNormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : FiberBundle F E... | Eta-expanded form of `mdifferentiableAt_add_section` | true |
Frm.Iso.mk._proof_4 | Mathlib.Order.Category.Frm | ∀ {α β : Frm} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊓ b) = e.symm a ⊓ e.symm b | null | false |
Pi.mulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
(α : Type u_1) →
[inst : MonoidWithZero α] →
[inst_1 : (i : I) → Zero (f i)] → [(i : I) → MulActionWithZero α (f i)] → MulActionWithZero α ((i : I) → f i) | null | true |
HomotopicalAlgebra.PathObject.symm_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.PathObject A), P.symm.ι = P.ι | null | true |
SimpleGraph.chromaticNumber_le_card | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V} [inst : Fintype V], G.chromaticNumber ≤ ↑(Fintype.card V) | null | true |
Rat.inv_natCast_num_of_pos | Mathlib.Data.Rat.Lemmas | ∀ {a : ℕ}, 0 < a → (↑a)⁻¹.num = 1 | null | true |
Set.sInter_delab | Mathlib.Order.SetNotation | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for indexed intersections. | true |
_private.Lean.Meta.InferType.0.Lean.Meta.inferTypeImp.infer.match_1 | Lean.Meta.InferType | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((c : Lean.Name) → motive (Lean.Expr.const c [])) →
((c : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const c us)) →
((n : Lean.Name) → (i : ℕ) → (s : Lean.Expr) → motive (Lean.Expr.proj n i s)) →
((f arg : Lean.Expr) → motive... | null | false |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.finite_of_free_aux._simp_1_2 | Mathlib.RingTheory.Unramified.Finite | ∀ {M : Type u_1} {N : Type u_2} {γ : Type u_3} [inst : AddCommMonoid N] [inst_1 : DistribSMul M N] {r : M} {f : γ → N}
{s : Finset γ}, ∑ x ∈ s, r • f x = r • ∑ x ∈ s, f x | null | false |
Nat.gcd_right_comm | Mathlib.Data.Nat.GCD.Basic | ∀ (a b c : ℕ), (a.gcd b).gcd c = (a.gcd c).gcd b | null | true |
AffineEquiv.mk.sizeOf_spec | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_4} {V₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] [inst_7 : SizeOf k] [inst_8 : SizeOf P₁] [inst_9 : SizeOf P₂]
[... | null | true |
CategoryTheory.Equivalence.instMonoidalInverseTrans._proof_15 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.biproduct.isoProduct_inv._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | null | false |
ULift.field._proof_9 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : Field α] (q : ℚ≥0) (a : ULift.{u_1, u_2} α), DivisionRing.nnqsmul q a = ↑q * a | null | false |
Filter.IsCountableBasis.casesOn | Mathlib.Order.Filter.CountablyGenerated | {α : Type u_1} →
{ι : Type u_3} →
{p : ι → Prop} →
{s : ι → Set α} →
{motive : Filter.IsCountableBasis p s → Sort u} →
(t : Filter.IsCountableBasis p s) →
((toIsBasis : Filter.IsBasis p s) → (countable : (Set.ofPred p).Countable) → motive ⋯) → motive t | null | false |
CategoryTheory.Balanced.isIso_of_mono_of_epi | Mathlib.CategoryTheory.Balanced | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Mono f] [CategoryTheory.Epi f], CategoryTheory.IsIso f | null | true |
SmoothPartitionOfUnity.casesOn | Mathlib.Geometry.Manifold.PartitionOfUnity | {ι : Type uι} →
{E : Type uE} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type uH} →
[inst_2 : TopologicalSpace H] →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
[inst_3 : TopologicalSpace M] →
[inst_4 : ... | null | false |
Valuation.IsEquiv.valueGroup₀Fun._proof_3 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] {v : Valuation R Γ₀}
(x : (↑v).ValueGroup₀), ¬x = 0 → ∃ d, x = ↑(MonoidWithZeroHom.valueGroup.mk (↑v) (↑d).1 (↑d).2 ⋯ ⋯) | null | false |
MeasurableDiv₂.rec | Mathlib.MeasureTheory.Group.Arithmetic | {G₀ : Type u_2} →
[inst : MeasurableSpace G₀] →
[inst_1 : Div G₀] →
{motive : MeasurableDiv₂ G₀ → Sort u} →
((measurable_div : Measurable fun p => p.1 / p.2) → motive ⋯) → (t : MeasurableDiv₂ G₀) → motive t | null | false |
Std.TreeMap.Raw.Equiv.entryAtIdxD_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {i : ℕ}
{fallback : α × β}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.entryAtIdxD i fallback = t₂.entryAtIdxD i fallback | null | true |
Perfection.teichmuller | Mathlib.RingTheory.Teichmuller | (p : ℕ) →
[inst : Fact (Nat.Prime p)] →
{R : Type u_1} →
[inst_1 : CommRing R] →
(I : Ideal R) → [inst_2 : CharP (R ⧸ I) p] → [IsAdicComplete I R] → Perfection (R ⧸ I) p →* R | Given an `I`-adically complete ring `R`, and a prime number `p` with `p ∈ I`, this is the
multiplicative map from `Perfection (R ⧸ I) p` to `R` itself. Specifically, it is defined as the
limit of `p^n`-th powers of arbitrary lifts in `R` of the `n`-th component from the perfection of
`R ⧸ I`.
The simp NF is `teichmull... | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.0.SSet.instKanComplexOp._proof_7 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex | ∀ (n : ℕ) (j k : Fin (n + 3)), j < k → k ≠ 0 | null | false |
MeasureTheory.Lp.compMeasurePreserving._proof_2 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {β : Type u_2} [inst_1 : MeasurableSpace β]
{μb : MeasureTheory.Measure β}, AddSubmonoidClass (AddSubgroup (β →ₘ[μb] E)) (β →ₘ[μb] E) | null | false |
Bundle.Trivialization.contMDiffOn_iff | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_3} {M : Type u_4} {E : B → Type u_5}
[inst : NontriviallyNormedField 𝕜] {EB : Type u_6} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB]
{HB : Type u_7} [inst_3 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSp... | null | true |
Char.instLawfulUpwardEnumerableLE | Init.Data.Range.Polymorphic.Char | Std.PRange.LawfulUpwardEnumerableLE Char | null | true |
_private.Mathlib.MeasureTheory.Function.AbsolutelyContinuous.0.AbsolutelyContinuousOnInterval.hasBasis_totalLengthFilter._simp_1_3 | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {p q : Prop}, (p ↔ q ∧ p) = (p → q) | null | false |
Std.HashMap.Raw.mem_of_mem_insertMany_list | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {l : List (α × β)} {k : α}, k ∈ m.insertMany l → (List.map Prod.fst l).contains k = false → k ∈ m | null | true |
AddSubgroup.ascending_central_series_le_upper | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : AddGroup G] (H : ℕ → AddSubgroup G),
AddSubgroup.IsAscendingCentralSeries H → ∀ (n : ℕ), H n ≤ AddSubgroup.upperCentralSeries G n | Any ascending central series for an additive group is bounded above by the upper
central series. | true |
instZeroEuclideanQuadrant | Mathlib.Geometry.Manifold.Instances.Real | {n : ℕ} → Zero (EuclideanQuadrant n) | null | true |
CategoryTheory.Adjunction.right_triangle_components_assoc._to_dual_1 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (self : G ⊣ F) (Y : D) {Z : C} (h : Z ⟶ G.obj Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h (G.map ... | null | false |
HomologicalComplex.restrictionHomologyIso_hom_homologyι_assoc | Mathlib.Algebra.Homology.Embedding.RestrictionHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j k : ι) (hi : c.prev j = i)
(hk : c.next j = k)... | null | true |
LocallyConstant.charFn | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
(Y : Type u_2) → [inst : TopologicalSpace X] → [MulZeroOneClass Y] → {U : Set X} → IsClopen U → LocallyConstant X Y | Characteristic functions are locally constant functions taking `x : X` to `1` if `x ∈ U`,
where `U` is a clopen set, and `0` otherwise. | true |
WithLp.ctorIdx | Mathlib.Analysis.Normed.Lp.WithLp | {p : ENNReal} → {V : Type u_1} → WithLp p V → ℕ | null | false |
ImportGraph.WorkspaceModel._sizeOf_1 | ImportGraph.WorkspaceModel.Model | ImportGraph.WorkspaceModel → ℕ | null | false |
Bool.sizeOf_eq_one | Init.SizeOf | ∀ (b : Bool), sizeOf b = 1 | null | true |
Filter.isBoundedUnder_ge_inf._simp_1 | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] {f : Filter β} {u v : β → α},
(Filter.IsBoundedUnder (fun x1 x2 => x2 ≤ x1) f fun a => u a ⊓ v a) =
(Filter.IsBoundedUnder (fun x1 x2 => x2 ≤ x1) f u ∧ Filter.IsBoundedUnder (fun x1 x2 => x2 ≤ x1) f v) | null | false |
MvPolynomial.support_sum | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {α : Type u_2} [inst_1 : DecidableEq σ] {s : Finset α}
{f : α → MvPolynomial σ R}, (∑ x ∈ s, f x).support ⊆ s.biUnion fun x => (f x).support | null | true |
Set.mulIndicator_one | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} (M : Type u_3) [inst : One M] (s : Set α), (s.mulIndicator fun x => 1) = fun x => 1 | null | true |
CategoryTheory.Limits.pushout.map._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z S T : C} (f₁ : S ⟶ W) (f₂ : S ⟶ X) (g₁ : T ⟶ Y)
(g₂ : T ⟶ Z) [inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂] (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T),
CategoryTheory.CategoryStruct.comp f₁ i₁ = CategoryTheory.CategoryStruct.comp i₃ g₁ →
Cat... | null | false |
Lean.Meta.Grind.checkMaxEmatchExceeded | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalM Bool | Returns `true` if the maximum number of E-matching rounds has been reached. | true |
Batteries.AssocList.isEmpty.eq_1 | Batteries.Data.AssocList.Lemmas | ∀ {α : Type u_1} {β : Type u_2}, Batteries.AssocList.nil.isEmpty = true | null | true |
Aesop.RuleTacDescr.constructors | Aesop.RuleTac.Descr | Array Lean.Name → Lean.Meta.TransparencyMode → Aesop.RuleTacDescr | null | true |
div_lt_div_iff' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LT α] [MulLeftStrictMono α] {a b c d : α}, a / b < c / d ↔ a * d < c * b | null | true |
Module.Basis.empty.congr_simp | Mathlib.RingTheory.Smooth.StandardSmoothOfFree | ∀ {ι : Type u_1} {R : Type u_2} (M : Type u_4) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Subsingleton M] [inst_4 : IsEmpty ι], Module.Basis.empty M = Module.Basis.empty M | null | true |
SNum.lt | Mathlib.Data.Num.Lemmas | LT SNum | null | true |
Std.DTreeMap.Internal.Impl.mem_of_mem_erase! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {k a : α}, a ∈ Std.DTreeMap.Internal.Impl.erase! k t → a ∈ t | null | true |
String.Slice.Pos.prevAux.go.eq_def | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ) (h₁ : off < s.utf8ByteSize),
String.Slice.Pos.prevAux.go off h₁ =
if hbyte : (s.getUTF8Byte { byteIdx := off } h₁).IsUTF8FirstByte then { byteIdx := off }
else
have this := ⋯;
match off, h₁, hbyte, this with
| 0, h₁, hbyte, this => ⋯.elim
| off.succ, h₁, ... | null | true |
_private.Mathlib.Tactic.Algebra.Basic.0.Mathlib.Tactic.Algebra.RingCompute.isOne.match_3 | Mathlib.Tactic.Algebra.Basic | {u : Lean.Level} →
{R : Q(Type u)} →
{sR : Q(CommSemiring «$R»)} →
(motive : (r : Q(«$R»)) → Mathlib.Tactic.Ring.ExSum q(«$sR») r → Sort u_1) →
(r : Q(«$R»)) →
(vx : Mathlib.Tactic.Ring.ExSum q(«$sR») r) →
((a : Q(«$R»)) →
(c : Mathlib.Tactic.Ring.RatCoeff a) →
... | null | false |
CategoryTheory.WithTerminal.starIsoTerminal_inv | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
CategoryTheory.WithTerminal.starIsoTerminal.inv =
CategoryTheory.WithTerminal.starTerminal.from (⊤_ CategoryTheory.WithTerminal C) | null | true |
Homeomorph.setCongr._proof_2 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X} (h : s = t), Continuous (Set.equivOfEq h).invFun | null | false |
uniformity_pseudoedist | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α],
uniformity α = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} | Reformulation of the uniform structure in terms of the extended distance | true |
RootPairing.PolarizationEquiv._proof_5 | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_3} {R : Type u_1} {M : Type u_2} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Field R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
[P.IsAnisotropic] [P.IsRootSystem], P.RootForm.Nondegenerate | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.instBEqSplitStatus.beq._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitStatus → Sort u} →
(t : Lean.Meta.Grind.SplitStatus) →
((numCases : ℕ) →
(isRec tryPostpone : Bool) → motive (Lean.Meta.Grind.SplitStatus.ready numCases isRec tryPostpone)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
Orientation.eq_rotation_self_iff | 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) (θ : Real.Angle), x = (o.rotation θ) x ↔ x = 0 ∨ θ = 0 | A vector equals a rotation of that vector if and only if the vector or the angle is zero. | true |
Applicative.mk.noConfusion | Init.Prelude | {f : Type u → Type v} →
{P : Sort u_1} →
{toFunctor : Functor f} →
{toPure : Pure f} →
{toSeq : Seq f} →
{toSeqLeft : SeqLeft f} →
{toSeqRight : SeqRight f} →
{toFunctor' : Functor f} →
{toPure' : Pure f} →
{toSeq' : Seq f} →
... | null | false |
AlgebraicGeometry.Scheme.ProEt.instFullOverForget | Mathlib.AlgebraicGeometry.Sites.Proetale | ∀ (S : AlgebraicGeometry.Scheme), (AlgebraicGeometry.Scheme.ProEt.forget S).Full | null | true |
Std.Stream.noConfusion | Init.Data.Stream | {P : Sort u_1} →
{stream : Type u} →
{value : Type v} →
{t : Std.Stream stream value} →
{stream' : Type u} →
{value' : Type v} →
{t' : Std.Stream stream' value'} →
stream = stream' → value = value' → t ≍ t' → Std.Stream.noConfusionType P t t' | null | false |
Lake.ComparatorOp.le.elim | Lake.Util.Version | {motive : Lake.ComparatorOp → Sort u} → (t : Lake.ComparatorOp) → t.ctorIdx = 1 → motive Lake.ComparatorOp.le → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.