name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LinearIndependent.repr | Mathlib.LinearAlgebra.LinearIndependent.Defs | {ι : Type u'} →
{R : Type u_2} →
{M : Type u_4} →
{v : ι → M} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → LinearIndependent R v → ↥(Submodule.span R (Set.range v)) →ₗ[R] ι →₀ R | Linear combination representing a vector in the span of linearly independent vectors.
Given a family of linearly independent vectors, we can represent any vector in their span as
a linear combination of these vectors. These are provided by this linear map.
It is simply one direction of `LinearIndependent.linearCombina... | true |
Lean.Meta.LiftLetsConfig.noConfusion | Init.MetaTypes | {P : Sort u} → {t t' : Lean.Meta.LiftLetsConfig} → t = t' → Lean.Meta.LiftLetsConfig.noConfusionType P t t' | null | false |
_private.Batteries.Data.DList.Lemmas.0.Batteries.DList.push.match_1.eq_1 | Batteries.Data.DList.Lemmas | ∀ {α : Type u_1} (motive : Batteries.DList α → α → Sort u_2) (f : List α → List α) (h : ∀ (l : List α), f l = f [] ++ l)
(a : α)
(h_1 :
(f : List α → List α) → (h : ∀ (l : List α), f l = f [] ++ l) → (a : α) → motive { apply := f, invariant := h } a),
(match { apply := f, invariant := h }, a with
| { appl... | null | true |
Functor._aux_Mathlib_Control_Functor___unexpand_Functor_mapConstRev_1 | Mathlib.Control.Functor | Lean.PrettyPrinter.Unexpander | null | false |
AlgebraicGeometry.StructureSheaf.sectionsSubalgebra | Mathlib.AlgebraicGeometry.StructureSheaf | {R : Type u} →
(A : Type u) →
[inst : CommRing R] →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] →
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) →
Subalgebra R ((x : ↥U) → AlgebraicGeometry.StructureSheaf.Localizations A ↑x) | The functions satisfying `isLocallyFraction` form a subalgebra. | true |
_private.Mathlib.RingTheory.Polynomial.Content.0.Polynomial.associated_content_C_mul._simp_1_2 | Mathlib.RingTheory.Polynomial.Content | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, (n ∈ p.support) = (p.coeff n ≠ 0) | null | false |
Ideal.cotangentToQuotientSquare | Mathlib.RingTheory.Ideal.Cotangent | {R : Type u} → [inst : CommRing R] → (I : Ideal R) → I.Cotangent →ₗ[R] R ⧸ I ^ 2 | The inclusion map `I ⧸ I ^ 2` to `R ⧸ I ^ 2`. | true |
Std.TreeMap.Raw.Equiv.getEntryLE!_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited (α × β)] {k : α}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getEntryLE! k = t₂.getEntryLE! k | null | true |
_private.Mathlib.Topology.Order.IntermediateValue.0.setOfPred_isPreconnected_eq_of_ordered._simp_1_13 | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {a : α}, IsPreconnected (Set.Iio a) = True | null | false |
iSup_psigma' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_6} [inst : CompleteLattice α] (f : (i : ι) → κ i → α),
⨆ i, ⨆ j, f i j = ⨆ ij, f ij.fst ij.snd | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_erase._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 |
String.rawEndPos.eq_1 | Init.Data.String.Iterator | ∀ (s : String), s.rawEndPos = { byteIdx := s.utf8ByteSize } | null | true |
CategoryTheory.Limits.colimitIsoFlipCompColim_hom_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (X : K),
(CategoryThe... | null | true |
CategoryTheory.Cat.Hom.ext | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} {x y : C.Hom D}, x.toFunctor = y.toFunctor → x = y | null | true |
Frm.carrier | Mathlib.Order.Category.Frm | Frm → Type u_1 | The underlying frame. | true |
_private.Mathlib.Analysis.Convex.StrictCombination.0.StrictConvex.centerMass_mem_interior._simp_1_4 | Mathlib.Analysis.Convex.StrictCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (r s : R) (x : M),
r • x + s • x = (r + s) • x | null | false |
Std.DHashMap.Internal.Raw₀.Const.get?ₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → (Std.DHashMap.Internal.Raw₀ α fun x => β) → α → Option β | Internal implementation detail of the hash map | true |
IsDedekindDomain.HeightOneSpectrum.algebraMap_adicCompletionIntegers_apply | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R),
↑((algebraMap R ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v)) r) =
IsDedekindDomain.He... | null | true |
Subfield.relrank.eq_1 | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B : Subfield E), A.relrank B = Module.rank ↥(A ⊓ B) ↥(Subfield.extendScalars ⋯) | null | true |
Lean.Server.Completion.ContextualizedCompletionInfo.mk._flat_ctor | Lean.Server.Completion.CompletionUtils | Lean.Server.Completion.HoverInfo →
Lean.Elab.ContextInfo → Lean.Elab.CompletionInfo → Lean.Server.Completion.ContextualizedCompletionInfo | null | false |
ProofWidgets.RefreshComponent.RpcEncodablePacket.mk._@.ProofWidgets.Component.RefreshComponent.4220679497._hygCtx._hyg.1 | ProofWidgets.Component.RefreshComponent | Lean.Json → Lean.Json → ProofWidgets.RefreshComponent.RpcEncodablePacket✝ | null | false |
SymmetricAlgebra.algHom._proof_1 | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsScalarTower R R M | null | false |
Lean.Compiler.LCNF.JoinPointCommonArgs.AnalysisCtx._sizeOf_inst | Lean.Compiler.LCNF.JoinPoints | SizeOf Lean.Compiler.LCNF.JoinPointCommonArgs.AnalysisCtx | null | false |
IsLocalization.Away.exists_isIntegral_mul_of_isIntegral_algebraMap | Mathlib.RingTheory.Localization.Integral | ∀ {R : Type u_5} {S : Type u_6} {Sₘ : Type u_7} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing Sₘ]
[inst_3 : Algebra R S] [inst_4 : Algebra S Sₘ] [inst_5 : Algebra R Sₘ] [IsScalarTower R S Sₘ] {r : S},
IsIntegral R r →
∀ [IsLocalization.Away r Sₘ] {x : S}, IsIntegral R ((algebraMap S Sₘ) x) → ∃ n,... | If `t` is `R`-integral in `S[1/r]` where `r : S` is integral over `R`,
then `r ^ n • t` is integral in `S` for some `n`. | true |
CompositionSeries.Equivalent.trans | Mathlib.Order.JordanHolder | ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] {s₁ s₂ s₃ : CompositionSeries X},
s₁.Equivalent s₂ → s₂.Equivalent s₃ → s₁.Equivalent s₃ | null | true |
Filter.EventuallyLE.rfl | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {f : α → β}, f ≤ᶠ[l] f | null | true |
_private.Lean.Compiler.Old.0.Lean.Compiler.getDeclNamesForCodeGen.match_1 | Lean.Compiler.Old | (motive : Lean.Declaration → Sort u_1) →
(x : Lean.Declaration) →
((name : Lean.Name) →
(levelParams : List Lean.Name) →
(type value : Lean.Expr) →
(hints : Lean.ReducibilityHints) →
(safety : Lean.DefinitionSafety) →
(all : List Lean.Name) →
... | null | false |
_private.Lean.Meta.WrapInstance.0.Lean.Meta.getParentStructType?.match_1 | Lean.Meta.WrapInstance | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive x | null | false |
IsCoprime.mono | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x y z w : R}, x ∣ y → z ∣ w → IsCoprime y w → IsCoprime x z | null | true |
_private.Mathlib.Algebra.Module.Presentation.Tensor.0.Module.Relations.tensor.match_1.eq_1 | Mathlib.Algebra.Module.Presentation.Tensor | ∀ {A : Type u_5} [inst : CommRing A] (relations₁ : Module.Relations A) (relations₂ : Module.Relations A)
(motive : relations₁.R × relations₂.G ⊕ relations₁.G × relations₂.R → Sort u_6) (r₁ : relations₁.R)
(g₂ : relations₂.G) (h_1 : (r₁ : relations₁.R) → (g₂ : relations₂.G) → motive (Sum.inl (r₁, g₂)))
(h_2 : (g₁ ... | null | true |
LinearMap.baseChange_comp | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N]
[inst_5 : AddCommMonoid P] [inst_6 : Module R M] [inst_7 : Module R N] [inst_8 : Module R P] (f : M →ₗ[R] N)
(g : ... | null | true |
IsSl2Triple | Mathlib.Algebra.Lie.Sl2 | {L : Type u_2} → [LieRing L] → L → L → L → Prop | An `sl₂` triple within a Lie ring `L` is a triple of elements `h`, `e`, `f` obeying relations
which ensure that the Lie subalgebra they generate is equivalent to `sl₂`. | true |
SSet.PtSimplex.MulStruct.ctorIdx | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} → {x : X.obj (Opposite.op { len := 0 })} → {f g fg : X.PtSimplex n x} → {i : Fin n} → f.MulStruct g fg i → ℕ | null | false |
UInt32.ofBitVec_add | Init.Data.UInt.Lemmas | ∀ (a b : BitVec 32), { toBitVec := a + b } = { toBitVec := a } + { toBitVec := b } | null | true |
bddAbove_range_mul | Mathlib.Algebra.Order.GroupWithZero.Bounds | ∀ {α : Type u_1} {β : Type u_2} [Nonempty α] {u v : α → β} [inst : Preorder β] [inst_1 : Zero β] [inst_2 : Mul β]
[PosMulMono β] [MulPosMono β],
BddAbove (Set.range u) → 0 ≤ u → BddAbove (Set.range v) → 0 ≤ v → BddAbove (Set.range (u * v)) | If `u v : α → β` are nonnegative and bounded above, then `u * v` is bounded above. | true |
Complex.tendsto_norm_tan_of_cos_eq_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.ComplexDeriv | ∀ {x : ℂ}, Complex.cos x = 0 → Filter.Tendsto (fun x => ‖Complex.tan x‖) (nhdsWithin x {x}ᶜ) Filter.atTop | null | true |
ProbabilityTheory.Indistinguishable.fun_smul | Mathlib.Probability.Process.Indistinguishable | ∀ {ι : Type u_1} {Ω : Type u_2} {E : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X Y : ι → Ω → E}
{F : Type u_4} {Z T : ι → Ω → F} [inst : SMul F E],
X ≡ᵐ[P] Y → Z ≡ᵐ[P] T → (fun i i_1 => Z i i_1 • X i i_1) ≡ᵐ[P] fun i i_1 => T i i_1 • Y i i_1 | Eta-expanded form of `ProbabilityTheory.Indistinguishable.smul` | true |
Subtype.t0Space | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T0Space X] {p : X → Prop}, T0Space (Subtype p) | [Stacks Tag 0B31](https://stacks.math.columbia.edu/tag/0B31) (part 1) | true |
groupHomology.cycles₁IsoOfIsTrivial.eq_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) [inst_2 : A.IsTrivial],
groupHomology.cycles₁IsoOfIsTrivial A = (LinearEquiv.ofTop (groupHomology.cycles₁ A) ⋯).toModuleIso | null | true |
Matroid.subsingleton_indep._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax | null | false |
InfHom.withBot_toFun | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] (f : InfHom α β) (a : WithBot α),
f.withBot a = WithBot.map (⇑f) a | null | true |
CategoryTheory.normalOfIsPushoutSndOfNormal._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S} [gn : CategoryTheory.NormalEpi g]
(comm : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k)
(t : CategoryT... | null | false |
Std.TreeSet.Raw.max?_eq_none_iff._simp_1 | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → (t.max? = none) = (t.isEmpty = true) | null | false |
two_mul_le_add_mul_sq | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a b ε : α},
0 < ε → 2 * a * b ≤ ε * a ^ 2 + ε⁻¹ * b ^ 2 | null | true |
CategoryTheory.Limits.IsImage.instInhabitedSelf | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_1 : CategoryTheory.Mono f] →
Inhabited (CategoryTheory.Limits.IsImage (CategoryTheory.Limits.MonoFactorisation.self f)) | null | true |
Lean.Elab.Command.ComputedFieldView.mk.injEq | Lean.Elab.MutualInductive | ∀ (ref modifiers : Lean.Syntax) (fieldId : Lean.Name) (type : Lean.Term)
(matchAlts : Lean.TSyntax `Lean.Parser.Term.matchAlts) (ref_1 modifiers_1 : Lean.Syntax) (fieldId_1 : Lean.Name)
(type_1 : Lean.Term) (matchAlts_1 : Lean.TSyntax `Lean.Parser.Term.matchAlts),
({ ref := ref, modifiers := modifiers, fieldId :=... | null | true |
Std.DTreeMap.Internal.Const.RoiSliceData.noConfusionType | Std.Data.DTreeMap.Internal.Zipper | Sort u_1 →
{α : Type u} →
{β : Type v} →
[inst : Ord α] →
Std.DTreeMap.Internal.Const.RoiSliceData α β →
{α' : Type u} → {β' : Type v} → [inst' : Ord α'] → Std.DTreeMap.Internal.Const.RoiSliceData α' β' → Sort u_1 | null | false |
Set.insert_diff_subset | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α} {a : α}, insert a s \ t ⊆ insert a (s \ t) | **Alias** of `Set.insert_sdiff_subset`. | true |
MulRingSeminormClass | Mathlib.Algebra.Order.Hom.RingNorm | (F : Type u_4) →
(α : outParam (Type u_5)) →
(β : outParam (Type u_6)) → [NonAssocRing α] → [Semiring β] → [PartialOrder β] → [FunLike F α β] → Prop | `MulRingSeminormClass F α` states that `F` is a type of `β`-valued multiplicative seminorms
on the ring `α`.
You should extend this class when you extend `MulRingSeminorm`. | true |
IsSumSq.natCast._simp_1 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ {R : Type u_2} [inst : NonAssocSemiring R] (n : ℕ), IsSumSq ↑n = True | null | false |
Chebyshev.primeCounting_sub_theta_div_log_isBigO | Mathlib.NumberTheory.Chebyshev | (fun x => ↑⌊x⌋₊.primeCounting - Chebyshev.theta x / Real.log x) =O[Filter.atTop] fun x => x / Real.log x ^ 2 | null | true |
Lake.instInhabitedComparatorOp.default | Lake.Util.Version | Lake.ComparatorOp | null | true |
DFinsupp.liftAddHom_apply_single | Mathlib.Data.DFinsupp.BigOperators | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)]
[inst_2 : AddCommMonoid γ] (f : (i : ι) → β i →+ γ) (i : ι) (x : β i),
((DFinsupp.liftAddHom f) fun₀ | i => x) = (f i) x | The `DFinsupp` version of `Finsupp.liftAddHom_apply_single` | true |
Lean.MessageData.ofWidget.sizeOf_spec | Lean.Message | ∀ (a : Lean.Widget.WidgetInstance) (a_1 : Lean.MessageData),
sizeOf (Lean.MessageData.ofWidget a a_1) = 1 + sizeOf a + sizeOf a_1 | null | true |
star_left_conjugate_le_conjugate | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a b : R}, a ≤ b → ∀ (c : R), star c * a * c ≤ star c * b * c | null | true |
CategoryTheory.GrpObj.zpow_comp_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G H X : C} [inst_2 : CategoryTheory.GrpObj G] [inst_3 : CategoryTheory.GrpObj H] (f : X ⟶ G) (n : ℤ) (g : G ⟶ H)
[CategoryTheory.IsMonHom g] {Z : C} (h : H ⟶ Z),
CategoryTheory.CategoryStruct.comp (f ^ ... | null | true |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.reassocMax.maxArgs._sparseCasesOn_1 | Lean.Meta.Constructions.CtorElim | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → ((a a_1 : Lean.Level) → motive (a.max a_1)) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Util.Diff.0.Lean.Diff.Histogram.addLeft.match_1 | Lean.Util.Diff | {α : Type u_1} →
{lsize rsize : ℕ} →
(motive : Option (Lean.Diff.Histogram.Entry α lsize rsize) → Sort u_2) →
(x : Option (Lean.Diff.Histogram.Entry α lsize rsize)) →
(Unit → motive none) → ((x : Lean.Diff.Histogram.Entry α lsize rsize) → motive (some x)) → motive x | null | false |
Cardinal.mk_range_inr | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u} {β : Type v}, Cardinal.mk ↑(Set.range Sum.inr) = Cardinal.lift.{u, v} (Cardinal.mk β) | null | true |
Lean.Parser.Term.set_option.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
WeakFEPair.f_modif_aux1 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (P : WeakFEPair E),
Set.EqOn (fun x => P.f_modif x - P.f x + P.f₀)
(((Set.Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1)
(Set.Ioi 0) | Alternative form for the difference between `f - f₀` and its modified term. | true |
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom.congr_simp | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData} (h : I ≤ J) (U : ↑X.affineOpens),
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom h U =
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom h U | null | true |
SkewMonoidAlgebra.mapDomain_smul | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_3} {f : G → G'} {v : SkewMonoidAlgebra k G}
{R : Type u_5} [inst_1 : Monoid R] [inst_2 : DistribMulAction R k] {b : R},
(SkewMonoidAlgebra.mapDomain f) (b • v) = b • (SkewMonoidAlgebra.mapDomain f) v | null | true |
MulEquiv.monoidHomCongrLeft.eq_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M₁ : Type u_5} {M₂ : Type u_6} {N : Type u_8} [inst : MulOneClass M₁] [inst_1 : MulOneClass M₂]
[inst_2 : CommMonoid N] (e : M₁ ≃* M₂), e.monoidHomCongrLeft = { toEquiv := e.monoidHomCongrLeftEquiv, map_mul' := ⋯ } | null | true |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.Context.maxCalls | Lean.Util.ParamMinimizer | {m : Type → Type} → Lean.Util.ParamMinimizer.Context✝ m → ℕ | Budget. That is, the maximum number of calls to `test` that we are willing to perform.
`0` means unbounded.
| true |
SimpleGraph.Embedding.sumInl | Mathlib.Combinatorics.SimpleGraph.Sum | {V : Type u_3} → {W : Type u_5} → {G : SimpleGraph V} → {H : SimpleGraph W} → G ↪g G ⊕g H | The embedding of `G` into `G ⊕g H`. | true |
CStarAlgebra.pow_nonneg._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | null | false |
AddSubgroup.instPartialOrder.eq_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G], AddSubgroup.instPartialOrder = PartialOrder.ofSetLike (AddSubgroup G) | null | true |
MeasureTheory.isTightMeasureSet_iff_exists_isCompact_measure_compl_le | Mathlib.MeasureTheory.Measure.Tight | ∀ {𝓧 : Type u_1} {m𝓧 : MeasurableSpace 𝓧} {S : Set (MeasureTheory.Measure 𝓧)} [inst : TopologicalSpace 𝓧],
MeasureTheory.IsTightMeasureSet S ↔ ∀ (ε : ENNReal), 0 < ε → ∃ K, IsCompact K ∧ ∀ μ ∈ S, μ Kᶜ ≤ ε | A set of measures `S` is tight if for all `0 < ε`, there exists a compact set `K` such that
for all `μ ∈ S`, `μ Kᶜ ≤ ε`. | true |
SimpleGraph.IsEdgeReachable.rfl | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ∞} {u : V}, G.IsEdgeReachable k u u | null | true |
Set.unbounded_le_iff | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α], Set.Unbounded (fun x1 x2 => x1 ≤ x2) s ↔ ∀ (a : α), ∃ b ∈ s, a < b | null | true |
Polynomial.monic_X_pow_sub_C | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u_1} [inst : Ring R] (a : R) {n : ℕ}, n ≠ 0 → (Polynomial.X ^ n - Polynomial.C a).Monic | `X ^ n - a` is monic. | true |
CategoryTheory.MorphismProperty.MapFactorizationData.hp | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} {X Y : C}
{f : X ⟶ Y} (self : W₁.MapFactorizationData W₂ f), W₂ self.p | null | true |
Lean.Lsp.instToJsonMarkupContent | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.MarkupContent | null | true |
Fin.encodeSubtype_succ_neg | Batteries.Data.Fin.Coding | ∀ {n : ℕ} {P : Fin (n + 1) → Prop} [inst : DecidablePred P] (h₀ : ¬P 0) {i : Fin n} (h : P i.succ),
Fin.encodeSubtype P ⟨i.succ, h⟩ = Fin.cast ⋯ (Fin.encodeSubtype (fun i => P i.succ) ⟨i, h⟩) | null | true |
instFloorSemiringNat._proof_1 | Mathlib.Algebra.Order.Floor.Defs | ∀ {a n : ℕ}, n ≤ id a ↔ ↑n ≤ a | null | false |
Std.DTreeMap.Raw.inter_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp}, t₁.inter t₂ = t₁ ∩ t₂ | null | true |
Int.neg_clog_inv_eq_log | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
(b : ℕ) (r : R), -Int.clog b r⁻¹ = Int.log b r | null | true |
compl_le_compl | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ≤ b → bᶜ ≤ aᶜ | null | true |
CategoryTheory.instQuiverMonad | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → Quiver (CategoryTheory.Monad C) | null | true |
Array.back_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : ℕ → α → β} (h : 0 < (Array.mapIdx f xs).size),
(Array.mapIdx f xs).back h = f (xs.size - 1) (xs.back ⋯) | null | true |
List.getLast!_eq_getLast?_getD | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α] {l : List α}, l.getLast! = l.getLast?.getD default | null | true |
MonoidHom.decidableMemRange | Mathlib.Algebra.Group.Subgroup.Finite | {G : Type u_1} →
[inst : Group G] →
{N : Type u_2} →
[inst_1 : Group N] → (f : G →* N) → [Fintype G] → [DecidableEq N] → DecidablePred fun x => x ∈ f.range | null | true |
AddSubmonoid.addGroupMultiples._proof_4 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : AddMonoid M] {x : M} {n : ℕ},
n • x = 0 → ∀ (m : ℕ) (x_1 : ↥(AddSubmonoid.multiples x)), ↑m.succ • x_1 = ↑m • x_1 + x_1 | null | false |
CategoryTheory.Functor.whiskerRight._proof_1 | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
{G H : CategoryTheory.Functor C D} (α : G ⟶ H) (F : CategoryTheory.Functor D E) (X Y : C) (f : X ⟶ Y),
CategoryTheory.Categor... | null | false |
SymbolicDynamics.FullShift.MulSubshift.ctorIdx | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
{inst : TopologicalSpace A} → {G : Type u_2} → {inst_1 : Monoid G} → SymbolicDynamics.FullShift.MulSubshift A G → ℕ | null | false |
MultilinearMap.dfinsuppFamily._proof_6 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type u_1} {κ : ι → Type u_2} {R : Type u_5} {M : (i : ι) → κ i → Type u_3} {N : ((i : ι) → κ i) → Type u_4}
[inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : Semiring R]
[inst_3 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_4 : (p : (i : ι) → κ i) → AddCommMonoid (N p)]
[inst_5 : (i : ι) → (k : ... | null | false |
Set.tprod.eq_def | Mathlib.Data.Prod.TProd | ∀ {ι : Type u} {α : ι → Type v} (x : List ι) (x_1 : (i : ι) → Set (α i)),
Set.tprod x x_1 =
match x, x_1 with
| [], x => Set.univ
| i :: is, t => t i ×ˢ Set.tprod is t | null | true |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop._proof_1 | Init.Data.Array.InsertionSort | ∀ {α : Type u_1} (xs : Array α), ∀ j < xs.size, ∀ (j' : ℕ), j = j'.succ → j' < xs.size | null | false |
Std.DHashMap.Internal.toListModel_replicate_nil | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {c : ℕ},
Std.DHashMap.Internal.toListModel (Array.replicate c Std.DHashMap.Internal.AssocList.nil) = [] | null | true |
HomogeneousIdeal.toIdeal_inf | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal | null | true |
isLUB_singleton._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsLUB {a} a = True | null | false |
Int.getElem?_toArray_rcc_eq_some_iff | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ} {i : ℕ}, (m...=n).toArray[i]? = some k ↔ i < (n + 1 - m).toNat ∧ m + ↑i = k | null | true |
HasStrictFDerivAt.const_cpow | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {f' : StrongDual ℂ E} {x : E}
{c : ℂ},
HasStrictFDerivAt f f' x → c ≠ 0 ∨ f x ≠ 0 → HasStrictFDerivAt (fun x => c ^ f x) ((c ^ f x * Complex.log c) • f') x | null | true |
Matrix.instCStarAlgebra | Mathlib.Analysis.CStarAlgebra.Matrix | {n : Type u_5} → [Fintype n] → [DecidableEq n] → CStarAlgebra (Matrix n n ℂ) | The matrices `Matrix n n ℂ` with the L2 operator norm form a `CStarAlgebra`. | true |
CategoryTheory.Abelian.LeftResolution.chainComplexXIso | Mathlib.Algebra.Homology.LeftResolution.Basic | {A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{ι : CategoryTheory.Functor C A} →
(Λ : CategoryTheory.Abelian.LeftResolution ι) →
(X : A) →
[inst_2 : ι.Full] →
[in... | The isomorphism which gives the inductive step of the construction of `Λ.chainComplex X`. | true |
RBTree.RBNode.Path.listL._f | Batteries.Recycling.RBTree.Lemmas | {α : Type u_1} → (x : RBTree.RBNode.Path α) → RBTree.RBNode.Path.below x → List α | null | false |
ENNReal.lintegral_mul_eq_one_iff_of_lintegral_rpow_eq_one | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {p q : ℝ},
p.HolderConjugate q →
∀ {f g : α → ENNReal},
AEMeasurable f μ →
AEMeasurable g μ →
∫⁻ (a : α), f a ^ p ∂μ = 1 → ∫⁻ (a : α), g a ^ q ∂μ = 1 → (∫⁻ (a : α), (f * g) a ∂μ = 1 ↔ f ^ p =ᵐ[μ] g ^ q) | Equality case of Hölder's inequality for functions with norm `1` | true |
RBTree.RBNode.size_lt_depth | Batteries.Recycling.RBTree.Depth | ∀ {α : Type u_1} (t : RBTree.RBNode α), t.size < 2 ^ t.depth | null | true |
_private.Mathlib.Probability.Independence.ZeroOne.0.ProbabilityTheory.Kernel.indep_limsup_atTop_self._simp_1_2 | Mathlib.Probability.Independence.ZeroOne | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.