name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FractionalIdeal.spanSingleton._proof_9 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_2} [inst : CommRing R] (S : Submonoid R) {P : Type u_1} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] (x y : P), ⟨R ∙ x * y, ⋯⟩ = ⟨R ∙ x, ⋯⟩ * ⟨R ∙ y, ⋯⟩ | null | false |
Mathlib.Meta.FunProp.Origin.casesOn | Mathlib.Tactic.FunProp.Types | {motive : Mathlib.Meta.FunProp.Origin → Sort u} →
(t : Mathlib.Meta.FunProp.Origin) →
((name : Lean.Name) → motive (Mathlib.Meta.FunProp.Origin.decl name)) →
((fvarId : Lean.FVarId) → motive (Mathlib.Meta.FunProp.Origin.fvar fvarId)) → motive t | null | false |
ContinuousMultilinearMap.piLinearEquiv._proof_5 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {ι : Type u_2} {M₁ : ι → Type u_3} {R' : Type u_6} {A : Type u_1} [inst : Semiring R'] [inst_1 : Semiring A]
[inst_2 : (i : ι) → AddCommMonoid (M₁ i)] [inst_3 : (i : ι) → TopologicalSpace (M₁ i)]
[inst_4 : (i : ι) → Module A (M₁ i)] {ι' : Type u_5} {M' : ι' → Type u_4} [inst_5 : (i : ι') → AddCommMonoid (M' i)]
... | null | false |
IsGaloisGroup.mulSemiringActionQuotient._proof_2 | Mathlib.RingTheory.IsGaloisGroup.Basic | ∀ (G : Type u_1) [inst : Group G] (B : Type u_2) (C : Type u_3) [inst_1 : Semiring C] [inst_2 : MulSemiringAction G C]
(N : Subgroup G) [inst_3 : CommSemiring B] [inst_4 : Algebra B C] [inst_5 : FaithfulSMul B C]
[inst_6 : IsGaloisGroup (↥N) B C] [inst_7 : N.Normal] (q₁ q₂ : G ⧸ N) (x : B), (q₁ * q₂) • x = q₁ • q₂ ... | null | false |
Continuous.isBounded_range_iff_isBigO | Mathlib.Analysis.Asymptotics.SpecificAsymptotics | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {D : Type u_2} [inst_1 : TopologicalSpace D] {f : D → E},
Continuous f → (Bornology.IsBounded (Set.range f) ↔ f =O[Filter.cocompact D] 1) | A continuous function `f` has bounded range if and only if it is `O(1)` with respect to the
cocompact filter.
| true |
Lean.Parser.Tactic.rwRuleSeq | Init.Tactics | Lean.ParserDescr | A `rwRuleSeq` is a list of `rwRule` in brackets. | true |
Valued.integer.coe_span_singleton_eq_closedBall | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K] (x : ↥(Valued.integer K)),
↑(Ideal.span {x}) = Metric.closedBall 0 ‖x‖ | null | true |
TopCat.Presheaf.IsLocallySurjective | Mathlib.Topology.Sheaves.LocallySurjective | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{FC : C → C → Type u_1} →
{CC : C → Type v} →
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] →
[CategoryTheory.ConcreteCategory C FC] → {X : TopCat} → {ℱ 𝒢 : TopCat.Presheaf C X} → (ℱ ⟶ 𝒢) → Prop | A map of presheaves `T : ℱ ⟶ 𝒢` is **locally surjective** if for any open set `U`,
section `t` over `U`, and `x ∈ U`, there exists an open set `x ∈ V ⊆ U` and a section `s` over `V`
such that `$T_*(s_V) = t|_V$`.
See `TopCat.Presheaf.isLocallySurjective_iff` below.
| true |
IsCoprime.pow | Mathlib.RingTheory.Coprime.Lemmas | ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {m n : ℕ}, IsCoprime x y → IsCoprime (x ^ m) (y ^ n) | null | true |
RingHom.id_comp | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β),
(RingHom.id β).comp f = f | null | true |
MonoidAlgebra.curryRingEquiv._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Monoid N]
(x y : MonoidAlgebra R (M × N)),
MonoidAlgebra.curryAddEquiv.toAddMonoidHom (x * y) =
MonoidAlgebra.curryAddEquiv.toAddMonoidHom x * MonoidAlgebra.curryAddEquiv.toAddMonoidHom y | null | false |
Subalgebra.equivOfEq_symm | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S T : Subalgebra R A)
(h : S = T), (S.equivOfEq T h).symm = T.equivOfEq S ⋯ | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.mem_ball_top._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V}, (G.edist u v ≠ ⊤) = G.Reachable u v | null | false |
ENNReal.div_add_div_same | Mathlib.Basic.ENNReal.Inv | ∀ {a b c : ENNReal}, a / c + b / c = (a + b) / c | null | true |
norm_innerSL_le | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
‖innerSL 𝕜‖ ≤ 1 | null | true |
AddSubmonoid.mem_closure_finset | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_1} [inst : AddCommMonoid M] {x : M} {s : Finset M},
x ∈ AddSubmonoid.closure ↑s ↔ ∃ f, Function.support f ⊆ ↑s ∧ ∑ a ∈ s, f a • a = x | null | true |
UniformFun.ofFun_smul | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_4} [inst : SMul M β] (c : M) (f : α → β),
UniformFun.ofFun (c • f) = c • UniformFun.ofFun f | null | true |
CommRingCat.KaehlerDifferential.ext_iff | Mathlib.Algebra.Category.ModuleCat.Differentials.Basic | ∀ {A B : CommRingCat} {f : A ⟶ B} {M : ModuleCat ↑B} {α β : CommRingCat.KaehlerDifferential f ⟶ M},
α = β ↔
∀ (b : ↑B),
(CategoryTheory.ConcreteCategory.hom α) (CommRingCat.KaehlerDifferential.d b) =
(CategoryTheory.ConcreteCategory.hom β) (CommRingCat.KaehlerDifferential.d b) | null | true |
_private.Mathlib.SetTheory.ZFC.Class.0.ZFClass.iota_val.match_1_1 | Mathlib.SetTheory.ZFC.Class | ∀ (A : ZFClass.{u_1}) (y : ZFSet.{u_1}) (motive : y ∈ A.iota → Prop) (x : y ∈ A.iota),
(∀ (x' : ZFSet.{u_1}) (h : x' ∈ {x | ∀ (y : ZFSet.{u_1}), ZFClass.CMem (↑y) A ↔ y = x}) (yx' : y ∈ ↑x'), motive ⋯) →
motive x | null | false |
Mathlib.Tactic.Determinant.zeroProdCert | Mathlib.Tactic.Determinant.Bird.Cert | {u : Lean.Level} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} →
Q(«$α») → Mathlib.Tactic.Determinant.Cert rα → Lean.MetaM (Mathlib.Tactic.Determinant.Cert rα) | If c.norm = 0, return a certificate with proof `x * c.subject = 0` without
recursively certifying `x`. | true |
Lean.Export.Entry | Mathlib.Util.Export | Type | null | true |
ArithmeticFunction.pow_apply | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {k n : ℕ}, (ArithmeticFunction.pow k) n = if k = 0 ∧ n = 0 then 0 else n ^ k | null | true |
RingHom.Flat.tensorProductMap | Mathlib.RingTheory.RingHom.Flat | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {A : Type u_4}
{B : Type u_5} {C : Type u_6} {D : Type u_7} [inst_3 : CommRing A] [inst_4 : Algebra R A] [inst_5 : Algebra S A]
[inst_6 : IsScalarTower R S A] [inst_7 : CommRing B] [inst_8 : Algebra R B] [inst_9 : CommR... | null | true |
Polynomial.Splits.coeff_zero_eq_leadingCoeff_mul_prod_roots | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R],
f.Splits → f.coeff 0 = (-1) ^ f.natDegree * f.leadingCoeff * f.roots.prod | null | true |
Lean.Elab.Tactic.MkSimpContextResult._sizeOf_1 | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.MkSimpContextResult → ℕ | null | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_15 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (i j k : ℕ),
i < j → j < k → k < tail.length + 1 → ¬i = 0 → i - 1 < tail.length | null | false |
Std.Do.WPMonad.rec | Std.Do.WP.Monad | {m : Type u → Type v} →
{ps : Std.Do.PostShape} →
[inst : Monad m] →
{motive : Std.Do.WPMonad m ps → Sort u_1} →
([toLawfulMonad : LawfulMonad m] →
[toWP : Std.Do.WP m ps] →
(wp_pure : ∀ {α : Type u} (a : α), Std.Do.wp (pure a) = pure a) →
(wp_bind :
... | null | false |
String.isNat_toSlice | Std.Data.String.ToNat | ∀ {s : String}, s.toSlice.isNat = s.isNat | null | true |
Sum.elim_inr | Init.Data.Sum.Basic | ∀ {α : Type u_1} {γ : Sort u_2} {β : Type u_3} (f : α → γ) (g : β → γ) (x : β), Sum.elim f g (Sum.inr x) = g x | null | true |
instHAppendOfAppend | Init.Prelude | {α : Type u_1} → [Append α] → HAppend α α α | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_diff._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.map_rootsOfUnity._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | null | false |
List.dropInfix?.go | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → List α → List α → List α → Option (List α × List α) | Inner loop for `dropInfix?`. | true |
Std.Roi.toArray_iter | Std.Data.Iterators.Lemmas.Producers.Range | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.Rxi.IsAlwaysFinite α]
[inst_2 : Std.PRange.LawfulUpwardEnumerable α] {r : Std.Roi α}, r.iter.toArray = r.toArray | null | true |
_private.Mathlib.NumberTheory.EllipticDivisibilitySequence.0.IsEllipticNet.atomRel_same₂₃._proof_1_2 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] (W : ℤ → R) (a b c : ℤ),
IsEllipticNet.atomRel W a b b c = W b * W 0 * IsEllipticNet.atom W a c | null | false |
NeZero.of_gt' | Mathlib.Algebra.Order.IsBotOne | ∀ {α : Type u_1} {a : α} [inst : Zero α] [inst_1 : Preorder α] [IsBotZeroClass α] [inst_3 : One α] [Fact (1 < a)],
NeZero a | null | true |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda._proof_6 | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_1} [inst_1 : CategoryTheory.SmallCategory I]
(F : CategoryTheory.Functor I (CategoryTheory.Functor Cᵒᵖ (Type u_1))) {J : Type u_1}
[inst_2 : CategoryTheory.SmallCategory J]
(G :
CategoryTheory.Functor J (CategoryTheory.CostructuredArro... | null | false |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.GRewriteLemma.apply.match_7 | Mathlib.Tactic.GRewrite.Core | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((type proof : Lean.Expr) → motive (type, proof)) → motive x | null | false |
Lean.Order.join_mono_right | Std.Internal.Order.Lemmas | ∀ {l : Type uₗ} [inst : Lean.Order.CompleteLattice l] {P Q Q' : l},
Lean.Order.PartialOrder.rel Q Q' → Lean.Order.PartialOrder.rel (Lean.Order.join P Q) (Lean.Order.join P Q') | null | true |
ZeroAtInftyContinuousMap.instMulActionWithZero._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
{R : Type u_3} [inst_3 : MonoidWithZero R] [inst_4 : MulActionWithZero R β] [inst_5 : ContinuousConstSMul R β]
(x y : R) (b : ZeroAtInftyContinuousMap α β), (x * y) • b = x • y • b | null | false |
IsCancelVAdd.mk | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} [inst : VAdd G P] [toIsLeftCancelVAdd : IsLeftCancelVAdd G P],
(∀ (a b : G) (c : P), a +ᵥ c = b +ᵥ c → a = b) → IsCancelVAdd G P | null | true |
instModuleZModOfNatNatAdditiveUnitsInt._proof_1 | Mathlib.Data.ZMod.IntUnitsPower | ∀ (z₁ z₂ : ZMod 2) (au : Additive ℤˣ), Additive.toMul ((z₁ * z₂) • au) = Additive.toMul (z₁ • z₂ • au) | null | false |
GradedLieAlgebra.mk | Mathlib.Algebra.Lie.Graded | {ι : Type u_1} →
{R : Type u_5} →
{L : Type u_6} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid ι] →
[inst_2 : CommRing R] →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
{ℒ : ι → Submodule R L} →
[toGradedBracket : SetLi... | null | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection.0.ContMDiffAt.sum_section._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
_private.Mathlib.RingTheory.Algebraic.Integral.0.Algebra.IsIntegral.isAlgebraic_iff_top._simp_1_1 | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
Algebra.IsAlgebraic R A = ∀ (x : A), IsAlgebraic R x | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.Tactic | null | true |
Unitization.instSub | Mathlib.Algebra.Algebra.Unitization | {R : Type u_3} → {A : Type u_4} → [Sub R] → [Sub A] → Sub (Unitization R A) | null | true |
Lean.Meta.FunInfo.mk._flat_ctor | Lean.Meta.Basic | Array Lean.Meta.ParamInfo → Array ℕ → Lean.Meta.FunInfo | null | false |
List.Forall₂ | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → (α → β → Prop) → List α → List β → Prop | `Forall₂ R l₁ l₂` means that `l₁` and `l₂` have the same length,
and whenever `a` is the nth element of `l₁`, and `b` is the nth element of `l₂`,
then `R a b` is satisfied.
| true |
Dynamics.coverEntropyEntourage_union | Mathlib.Dynamics.TopologicalEntropy.Subset | ∀ {X : Type u_1} {T : X → X} {F G : Set X} {U : SetRel X X},
Dynamics.coverEntropyEntourage T (F ∪ G) U =
max (Dynamics.coverEntropyEntourage T F U) (Dynamics.coverEntropyEntourage T G U) | null | true |
NNReal.coe_inj | Mathlib.Basic.NNReal.Defs | ∀ {r₁ r₂ : NNReal}, ↑r₁ = ↑r₂ ↔ r₁ = r₂ | null | true |
CategoryTheory.Functor.LaxLeftLinear.μₗ_naturality_left._autoParam | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | Lean.Syntax | null | false |
TruncatedWittVector.coeff_out | Mathlib.RingTheory.WittVector.Truncated | ∀ {p n : ℕ} {R : Type u_1} [inst : CommRing R] (x : TruncatedWittVector p n R) (i : Fin n),
x.out.coeff ↑i = TruncatedWittVector.coeff i x | null | true |
Computability._aux_Mathlib_Algebra_Order_Kleene___unexpand_KStar_kstar_1 | Mathlib.Algebra.Order.Kleene | Lean.PrettyPrinter.Unexpander | null | false |
OrderIso.ofIsEmpty | Mathlib.Order.Hom.Basic | (α : Type u_6) → (β : Type u_7) → [inst : Preorder α] → [inst_1 : Preorder β] → [IsEmpty α] → [IsEmpty β] → α ≃o β | `Equiv.equivOfIsEmpty` promoted to an `OrderIso`. | true |
_private.Std.Time.Format.Basic.0.Std.Time.formatMonthLong | Std.Time.Format.Basic | Std.Time.DateFormatSymbols → Std.Time.Month.Ordinal → String | null | true |
_private.Mathlib.RingTheory.SurjectiveOnStalks.0.RingHom.surjective_localRingHom_iff.match_1_2 | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {S : Type u_1} [inst : CommRing S] (P : Ideal S) [inst_1 : P.IsPrime] (motive : S × ↥P.primeCompl → Prop)
(x : S × ↥P.primeCompl), (∀ (y t : S) (h : t ∈ P.primeCompl), motive (y, ⟨t, h⟩)) → motive x | null | false |
Equiv.addZeroClass._proof_2 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : AddZeroClass β] (x y : α),
e (e.symm (e.toFun x + e.toFun y)) = e.toFun x + e.toFun y | null | false |
ContinuousAffineEquiv.toAffineEquiv_pointReflection | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁] [inst_5 : TopologicalSpace V₁]
[inst_6 : IsTopologicalAddTorsor P₁] (x : P₁),
↑(ContinuousAffineEquiv.pointReflection k x) = AffineEquiv.poin... | null | true |
freeGroupEquivCoprodI_apply | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} (a : FreeGroup ι),
freeGroupEquivCoprodI a = (FreeGroup.lift fun i => Monoid.CoprodI.of (FreeGroup.of ())) a | null | true |
_private.Mathlib.Tactic.Translate.UnfoldBoundary.0.Mathlib.Tactic.UnfoldBoundary.refoldConsts.go.match_1 | Mathlib.Tactic.Translate.UnfoldBoundary | (motive : Lean.Expr → Sort u_1) →
(__x : Lean.Expr) →
((binderName : Lean.Name) →
(α body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName α body binderInfo)) →
((x : Lean.Expr) → motive x) → motive __x | null | false |
MeasureTheory.Lp.boundedContinuousFunction._proof_2 | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ (E : Type u_1) [inst : NormedAddCommGroup E], BoundedAdd E | null | false |
CategoryTheory.FreeMonoidalCategory.normalizeIsoApp'._f | Mathlib.CategoryTheory.Monoidal.Free.Coherence | (C : Type u) →
(x : CategoryTheory.FreeMonoidalCategory C) →
CategoryTheory.FreeMonoidalCategory.below (motive := fun x =>
(x_1 : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.FreeMonoidalCategory.inclusionObj x_1) x... | null | false |
Asymptotics.IsBigOTVS.trans | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} {G : Type u_6} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [inst_7 : AddCommGroup G] [inst_8 : Topologi... | null | true |
Prod.instRing._proof_7 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_2} {S : Type u_1} [inst : Ring R] [inst_1 : Ring S] (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1) | null | false |
iter_deriv_zpow' | Mathlib.Analysis.Calculus.Deriv.ZPow | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (m : ℤ) (k : ℕ),
(deriv^[k] fun x => x ^ m) = fun x => (∏ i ∈ Finset.range k, (↑m - ↑i)) * x ^ (m - ↑k) | null | true |
addMonoidAlgebraAddEquivDirectSum_apply_toFun | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_1} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : Semiring M] [inst_2 : (m : M) → Decidable (m ≠ 0)]
(f : AddMonoidAlgebra M ι), ⇑(addMonoidAlgebraAddEquivDirectSum f) = ⇑f.coeff | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.initFn._@.Lean.Elab.DocString.966400761._hygCtx._hyg.2 | Lean.Elab.DocString | IO (IO.Ref (Lean.NameMap (Array (Lean.Name × Lean.Doc.DocDirectiveExpander)))) | null | false |
RestrictedProduct.instContinuousVAddCoePrincipal | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} (R : ι → Type u_2) {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)] {B : (i : ι) → S i}
{T : Set ι} [inst_1 : (i : ι) → TopologicalSpace (R i)] {G : Type u_4} [inst_2 : TopologicalSpace G]
[inst_3 : (i : ι) → VAdd G (R i)] [inst_4 : ∀ (i : ι), VAddMemClass (S i) G (R i)]
[∀ (i : ι), Cont... | null | true |
Lean.Meta.Config.constApprox | Lean.Meta.Basic | Lean.Meta.Config → Bool | When `constApprox` is set to true,
we solve `?m t =?= c` using
`?m := fun _ => c`
when `?m t` is not a higher-order pattern and `c` is not an application as | true |
MulPosStrictMono.mk | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α],
(∀ ⦃c : α⦄, 0 < c → ∀ ⦃a b : α⦄, a < b → a * c < b * c) → MulPosStrictMono α | null | true |
MeasureTheory.Lp.continuous_negPart | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} [inst : Fact (1 ≤ p)],
Continuous fun f => MeasureTheory.Lp.negPart f | null | true |
CategoryTheory.MorphismProperty.Over.mapId_inv_app_left | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) [inst_1 : Q.IsMultiplicative] [inst_2 : P.IsStableUnderComposition]
[inst_3 : P.IsMultiplicative] [inst_4 : Q.RespectsIso] (X : T)
(f : optParam (X ⟶ X) (CategoryTheory.Ca... | null | true |
Set.ncard_diff_singleton_lt_of_mem | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} {a : α},
a ∈ s → autoParam s.Finite Set.ncard_sdiff_singleton_lt_of_mem._auto_1 → (s \ {a}).ncard < s.ncard | **Alias** of `Set.ncard_sdiff_singleton_lt_of_mem`. | true |
_private.Mathlib.LinearAlgebra.Transvection.Generation.0.LinearEquiv.apply_notMem_sup_of_linearIndependent._simp_1_1 | Mathlib.LinearAlgebra.Transvection.Generation | ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M},
LinearIndependent R ![x, y] = ∀ (s t : R), s • x + t • y = 0 → s = 0 ∧ t = 0 | null | false |
AddMonoid.exponent_addSubmonoid_dvd | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddMonoid G] (H : AddSubmonoid G), AddMonoid.exponent ↥H ∣ AddMonoid.exponent G | The exponent of an additive submonoid `H ≤ G` divides the exponent of `G`. | true |
CategoryTheory.equivalenceReflectsNormalMono._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.IsEquivalence] {X Y : C} {f : X ⟶ Y}
(h... | null | false |
CategoryTheory.HomOrthogonal.matrixDecomposition_id | Mathlib.CategoryTheory.Preadditive.HomOrthogonal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_1} {s : ι → C}
[inst_1 : CategoryTheory.Preadditive C] [inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C]
(o : CategoryTheory.HomOrthogonal s) {α : Type} [inst_3 : Finite α] {f : α → ι} (i : ι),
o.matrixDecomposition (CategoryTheory.Category... | null | true |
List.pair_sublist_insertionSort' | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] [Std.Antisymm r] [Std.Total r] [IsTrans α r] {a b : α}
{l : List α}, r a b → [a, b].Subperm l → [a, b].Sublist (List.insertionSort r l) | Another statement of stability of insertion sort.
If a pair `[a, b]` is a sublist of a permutation of `l` and `a ≼ b`,
then `[a, b]` is still a sublist of `insertionSort r l`.
| true |
ContinuousLinearEquiv.conjContinuousAlgEquiv._proof_8 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜 : Type u_3} {G : Type u_2} {H : Type u_1} [inst : AddCommGroup G] [inst_1 : AddCommGroup H]
[inst_2 : NormedField 𝕜] [inst_3 : Module 𝕜 G] [inst_4 : Module 𝕜 H] [inst_5 : TopologicalSpace G]
[inst_6 : TopologicalSpace H] [inst_7 : IsTopologicalAddGroup G] [inst_8 : IsTopologicalAddGroup H]
[inst_9 : Cont... | null | false |
MeasurableEquiv.IicProdIoc | Mathlib.Probability.Kernel.IonescuTulcea.Maps | {ι : Type u_1} →
[inst : LinearOrder ι] →
[inst_1 : LocallyFiniteOrder ι] →
[DecidableLE ι] →
{X : ι → Type u_2} →
[inst_3 : LocallyFiniteOrderBot ι] →
[inst_4 : (i : ι) → MeasurableSpace (X i)] →
{a b : ι} →
a ≤ b →
((i : ↥(Finse... | Gluing `Iic a` and `Ioc a b` into `Iic b`. This version requires `a ≤ b` to get a measurable
equivalence. | true |
Ideal.quotMapEquivTensorQuot._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S], SMulCommClass R S S | null | false |
Ideal.IsMaximal.lt_top | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, I.IsMaximal → I < ⊤ | null | true |
MulEquiv.mk' | Mathlib.Algebra.Group.Equiv.Defs | {M : Type u_4} →
{N : Type u_5} → [inst : Mul M] → [inst_1 : Mul N] → (f : M ≃ N) → (∀ (x y : M), f (x * y) = f x * f y) → M ≃* N | Makes a multiplicative isomorphism from a bijection which preserves multiplication. | true |
_private.Mathlib.Order.Hom.Basic.0.OrderIso.ofRelIsoLT._simp_1 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a ≤ b) = (a = b ∨ a < b) | null | false |
Std.WP.Option.instWPMonad | Std.WP.Monad.Instances | Std.WP.WPMonad Option Prop (Unit → Prop) | `Option` is a WPMonad with `Prop` assertions and a `Unit`-indexed exception postcondition. | true |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.noConfusionType | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | Sort u →
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
[inst_4 : CategoryTheory.MonoidalCl... | null | false |
PEquiv.toMatrix_toPEquiv_eq | Mathlib.Data.Matrix.PEquiv | ∀ {n : Type u_4} {α : Type u_5} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : One α] (σ : Equiv.Perm n),
(Equiv.toPEquiv σ).toMatrix = Matrix.submatrix 1 (⇑σ) id | We can also define permutation matrices by permuting the rows of the identity matrix. | true |
_private.Mathlib.Tactic.Translate.Attributes.0.Mathlib.Tactic.generatingAttrs._proof_1 | Mathlib.Tactic.Translate.Attributes | Nonempty
(ST.Ref IO.RealWorld (Lean.NameMap (Lean.Name → Lean.Syntax → Lean.AttributeKind → Lean.AttrM (Array Lean.Name)))) | null | false |
CategoryTheory.Functor.mapMonNatTrans | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F F' : CategoryTheory.Functor C D} →
[inst_... | Natural transformations between functors lift to monoid objects. | true |
RingHom.surjective_codRestrict | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {σS : Type u_2}
[inst_2 : SetLike σS S] [inst_3 : SubsemiringClass σS S] {f : R →+* S} {s : σS} {h : ∀ (x : R), f x ∈ s},
Function.Surjective ⇑(f.codRestrict s h) ↔ f.rangeS = Subsemiring.ofClass s | null | true |
MeasureTheory.NullMeasurableSet.mono_ac | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.NullMeasurableSet s μ → ν.AbsolutelyContinuous μ → MeasureTheory.NullMeasurableSet s ν | null | true |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.app.noConfusion | Mathlib.Tactic.ClickSuggestions.TryPremises | {P : Sort u} →
{arr arr' : Array Mathlib.Tactic.ClickSuggestions.ApplyLemma} →
Mathlib.Tactic.ClickSuggestions.Candidates.app✝ arr = Mathlib.Tactic.ClickSuggestions.Candidates.app✝ arr' →
(arr = arr' → P) → P | null | false |
hasSum_sq_mul_geometric_of_norm_lt_one' | Mathlib.Analysis.SpecificLimits.Normed | ∀ {R : Type u_4} [inst : NormedRing R] [HasSummableGeomSeries R] {r : R},
‖r‖ < 1 → HasSum (fun n => ↑n ^ 2 * r ^ n) (r * (1 + r) * Ring.inverse (1 - r) ^ 3) | If `‖r‖ < 1`, then `∑' n : ℕ, n ^ 2 * r ^ n = r * (1 + r) / (1 - r) ^ 3`.
`HasSum` version in a general ring with summable geometric series. For a version in a field, using
division instead of `Ring.inverse`, see `hasSum_sq_mul_geometric_of_norm_lt_one`. | true |
Turing.TM2.Cfg.inhabited | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} → (Γ : K → Type u_2) → (Λ : Type u_3) → (σ : Type u_4) → [Inhabited σ] → Inhabited (Turing.TM2.Cfg Γ Λ σ) | null | true |
Complex.isPrimitiveRoot_exp | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ (n : ℕ), n ≠ 0 → IsPrimitiveRoot (Complex.exp (2 * ↑Real.pi * Complex.I / ↑n)) n | null | true |
OpenSubgroup.toSubgroup_prod | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] {H : Type u_2} [inst_2 : Group H]
[inst_3 : TopologicalSpace H] (U : OpenSubgroup G) (V : OpenSubgroup H), ↑(U.prod V) = (↑U).prod ↑V | null | true |
_private.Batteries.Util.ProofWanted.0.initFn._@.Batteries.Util.ProofWanted.2313051376._hygCtx._hyg.2 | Batteries.Util.ProofWanted | IO (Lean.SimplePersistentEnvExtension Lean.Name (Array Lean.Name)) | null | false |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.prod_Ico_cast._simp_1_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {n m : ℕ} (h : n = m) (i j : Fin n),
Finset.Ico (Fin.cast h i) (Fin.cast h j) = Finset.map (finCongr h).toEmbedding (Finset.Ico i j) | null | false |
MvPowerSeries.truncFinset_coe_eq_self_iff | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : Finset (σ →₀ ℕ)} (p : MvPolynomial σ R),
(MvPowerSeries.truncFinset R s) ↑p = p ↔ p.support ⊆ s | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.