name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.OuterMeasure.map._proof_2 | Mathlib.MeasureTheory.OuterMeasure.Operations | IsScalarTower ENNReal ENNReal ENNReal | null | false |
IsArtinianRing.localization_surjective | Mathlib.RingTheory.Artinian.Ring | ∀ {R : Type u_1} [inst : CommRing R] [IsArtinianRing R] (S : Submonoid R) (L : Type u_2) [inst_2 : CommSemiring L]
[inst_3 : Algebra R L] [IsLocalization S L], Function.Surjective ⇑(algebraMap R L) | Localizing an Artinian ring can only reduce the amount of elements. | true |
RootPairing.posRootForm_posForm_anisotropic | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
(S : Type u_5) [inst_6 : CommRing S] [inst_7 : LinearOrder S] [inst_8 : IsStrictOrderedRing... | null | true |
Lean.MessageLog.reportedPlusUnreported | Lean.Message | Lean.MessageLog → Lean.PersistentArray Lean.Message | null | true |
Filter.ZeroAtFilter.boundedAtFilter | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddGroup β] {l : Filter α} {f : α → β},
l.ZeroAtFilter f → l.BoundedAtFilter f | null | true |
Multiset.coe_fold_r | Mathlib.Data.Multiset.Fold | ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b : α) (l : List α),
Multiset.fold op b ↑l = List.foldr op b l | null | true |
Char.utf8Size_eq | Init.Data.String.Decode | ∀ (c : Char), c.utf8Size = 1 ∨ c.utf8Size = 2 ∨ c.utf8Size = 3 ∨ c.utf8Size = 4 | null | true |
Std.Time.Hour.instDecidableEqOffset | Std.Time.Time.Unit.Hour | DecidableEq Std.Time.Hour.Offset | null | true |
Real.rpowIntegrand₁₂_eq_mul_rpowIntegrand₀₁ | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p t x : ℝ}, 0 ≤ x → 0 < t → p.rpowIntegrand₁₂ t x = x * (p - 1).rpowIntegrand₀₁ t x | null | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity'.process.match_1 | Mathlib.Lean.Meta.CongrTheorems | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((fvar val : Lean.Expr) → motive (fvar, val)) → motive x | null | false |
HasOpenLowerSections | Mathlib.Topology.Semicontinuity.Defs | {α : Type u_1} → {β : Type u_2} → [TopologicalSpace α] → (α → Set β) → Prop | A function `f : α → Set β` has open lower sections if, for every `b`, the set `{x | b ∈ f x}`
is open. Equivalently, whenever `b ∈ f x`, then `b ∈ f x'` for all `x'` sufficiently close to
`x`. | true |
cfcHomSuperset_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Ring A] [inst_6 : StarRing A]
[inst_7 : TopologicalSpace A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | null | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates.0.Tactic.ComputeAsymptotics.UnitMonomial.FirstNonzeroIsPos.cons_iff._proof_1_5 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates | ∀ {hd : ℝ} {tl : Tactic.ComputeAsymptotics.UnitMonomial},
Tactic.ComputeAsymptotics.UnitMonomial.FirstNonzeroIsPos (hd :: tl) ↔ 0 < hd ∨ hd = 0 ∧ tl.FirstNonzeroIsPos | null | false |
CategoryTheory.AddMod.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Mod | {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.MonoidalLeftAction C D] →
{A : C} →
[inst_4 : Cat... | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.recommended_spelling._regBuiltin.Lean.Parser.Command.recommended_spelling.formatter_7 | Lean.Parser.Command | IO Unit | null | false |
PiTensorProduct.toDualContinuousMultilinearMap._proof_5 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (F : Type u_2) [inst_1 : SeminormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | null | false |
SSet.Subcomplex.N.orderIsoOfIso | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | {X : SSet} → {A : X.Subcomplex} → {Y : SSet} → {B : Y.Subcomplex} → (e : X ≅ Y) → B.preimage e.hom = A → A.N ≃o B.N | The bijection `A.N ≃ B.N` on nondegenerate simplices not belonging
to a certain subcomplex that is induced by an isomorphism `X ≅ Y` of
simplicial sets which maps `A : X.Subcomplex` to `B : Y.Subcomplex`. | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.toInt_eq_ofNat_toNat_rotate_sub._proof_1_8 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x : BitVec (n + 1)), ↑x.toNat < 2 ^ n → ¬↑x.toNat + 2 ^ n < 2 ^ (n + 1) → False | null | false |
antitoneOn_of_succ_le | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_3} {β : Type u_4} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : SuccOrder α]
[IsSuccArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMax a → a ∈ s → Order.succ a ∈ s → f (Order.succ a) ≤ f a) → AntitoneOn f s | null | true |
Mathlib.Tactic.Linarith.runLinarith | Mathlib.Tactic.Linarith.Frontend | Mathlib.Tactic.Linarith.LinarithConfig → Option Lean.Expr → Lean.MVarId → List Lean.Expr → Lean.MetaM (List ℕ) | Given a list `hyps` of proofs of comparisons, `runLinarith cfg prefType g hyps` preprocesses
`hyps` according to the list of preprocessors in `cfg`. This results in a list of branches
(typically only one), each of which must succeed in order to close the goal.
In each branch, the hypotheses are partitioned by type and... | true |
SeminormedRing.toRingSeminorm._proof_1 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ (R : Type u_1) [inst : SeminormedRing R], ‖0‖ = 0 | null | false |
Module.freeLocus_eq_univ_iff | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ {R : Type uR} {M : Type uM} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[Module.FinitePresentation R M], Module.freeLocus R M = Set.univ ↔ Module.Projective R M | null | true |
Subsemigroup.toAddSubsemigroup._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M],
Function.LeftInverse (fun S => { carrier := ⇑Additive.ofMul ⁻¹' ↑S, mul_mem' := ⋯ }) fun S =>
{ carrier := ⇑Additive.toMul ⁻¹' ↑S, add_mem' := ⋯ } | null | false |
Std.TreeMap.Raw.maxKey?_erase_eq_iff_not_compare_eq_maxKey? | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, (t.erase k).maxKey? = t.maxKey? ↔ ∀ {km : α}, t.maxKey? = some km → ¬cmp k km = Ordering.eq | null | true |
Ideal.count_associates_factors_eq | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {I J : Ideal R},
I ≠ 0 →
J.IsPrime →
J ≠ ⊥ →
(Associates.mk J).count (Associates.mk I).factors =
Multiset.count J (UniqueFactorizationMonoid.normalizedFactors I) | The number of times an ideal `I` occurs as normalized factor of another ideal `J` is stable
when regarding these ideals as associated elements of the monoid of ideals. | true |
Mathlib.Meta.FunProp.LambdaTheoremType._sizeOf_inst | Mathlib.Tactic.FunProp.Theorems | SizeOf Mathlib.Meta.FunProp.LambdaTheoremType | null | false |
CategoryTheory.tensorHom_eComp_op_eq_assoc | Mathlib.CategoryTheory.Enriched.Opposite | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V]
[inst_2 : CategoryTheory.BraidedCategory V] {C : Type u} [inst_3 : CategoryTheory.EnrichedCategory V C] {x y z : Cᵒᵖ}
{v w : V} (f : v ⟶ z ⟶[V] y) (g : w ⟶ y ⟶[V] x) {Z : V} (h : (z ⟶[V] x) ⟶ Z),
CategoryTheor... | When composing a tensor product of morphisms with the `V`-composition morphism in `Cᵒᵖ`,
this re-writes the `V`-composition to be in `C` and moves the braiding to the left. | true |
IsPowApply.rec | Mathlib.Algebra.Group.IsApply | {M : Type u_1} →
{F : Type u_2} →
{α : Type u_3} →
{β : Type u_4} →
[inst : FunLike F α β] →
[inst_1 : Pow β M] →
[inst_2 : Pow F M] →
{motive : IsPowApply M F α β → Sort u} →
((pow_apply : ∀ (f : F) (n : M) (x : α), (f ^ n) x = f x ^ n) → motive ⋯... | null | false |
CategoryTheory.Pretriangulated.comp_distTriang_mor_zero₂₃_assoc | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pr... | Given any distinguished triangle
```
f g h
X ───> Y ───> Z ───> X⟦1⟧
```
the composition `g ≫ h = 0`. | true |
ExteriorAlgebra.ι_eq_algebraMap_iff | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M) (r : R),
(ExteriorAlgebra.ι R) x = (algebraMap R (ExteriorAlgebra R M)) r ↔ x = 0 ∧ r = 0 | null | true |
MonCat.coe_comp | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : MonCat} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | null | true |
exteriorPower.presentation.relationsSolutionEquiv_symm_apply_var | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {N : Type u_2} [inst_1 : AddCommGroup N] [inst_2 : Module R N] {ι : Type u_4}
[inst_3 : DecidableEq ι] {M : Type u_5} [inst_4 : AddCommGroup M] [inst_5 : Module R M] (f : M [⋀^ι]→ₗ[R] N)
(m : (exteriorPower.presentation.relations R ι M).G),
(exteriorPower.presentation.relationsS... | null | true |
UpperHalfPlane.casesOn | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | {motive : UpperHalfPlane → Sort u} →
(t : UpperHalfPlane) →
((coe : ℂ) → (coe_im_pos : 0 < coe.im) → motive { coe := coe, coe_im_pos := coe_im_pos }) → motive t | null | false |
smul_right_cancel_iff | Mathlib.Algebra.Torsor.Defs | ∀ {G : Type u_1} {P : Type u_2} [inst : Group G] [T : Torsor G P] {g₁ g₂ : G} (p : P), g₁ • p = g₂ • p ↔ g₁ = g₂ | null | true |
Aesop.UnsafeRuleInfo.mk | Aesop.Rule | Aesop.Percent → Aesop.UnsafeRuleInfo | null | true |
CategoryTheory.enrichedCategoryTypeOfCategory._proof_6 | Mathlib.CategoryTheory.Enriched.Basic | ∀ (C : Type u_2) [𝒞 : CategoryTheory.Category.{u_1, u_2} C] (W X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator (W ⟶ X) (X ⟶ Y) (Y ⟶ Z)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(TypeCat.ofHom f... | null | false |
exp_neg_integrableOn_Ioi | Mathlib.MeasureTheory.Integral.ExpDecay | ∀ (a : ℝ) {b : ℝ}, 0 < b → MeasureTheory.IntegrableOn (fun x => Real.exp (-b * x)) (Set.Ioi a) MeasureTheory.volume | `exp (-b * x)` is integrable on `(a, ∞)`. | true |
Batteries.Tactic.Lint.instInhabitedLintVerbosity | Batteries.Tactic.Lint.Frontend | Inhabited Batteries.Tactic.Lint.LintVerbosity | null | true |
Std.TreeSet.Raw.minD_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback : α}, t.minD fallback ∈ t | null | true |
CategoryTheory.SimplicialThickening.instCategoryStruct._proof_4 | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ (J : Type u_1) [inst : LinearOrder J] {i j k : CategoryTheory.SimplicialThickening J}
(f : CategoryTheory.SimplicialThickening.Path i.as j.as) (g : CategoryTheory.SimplicialThickening.Path j.as k.as),
∀ l ∈ f.I ∪ g.I, i.as ≤ l | null | false |
_private.Mathlib.Analysis.Calculus.DifferentialForm.Basic.0.extDeriv_apply._simp_1_1 | Mathlib.Analysis.Calculus.DifferentialForm.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(ω : E → E [⋀^Fin n]→L[𝕜] F), extDeriv ω = extDerivWithin ω Set.univ | null | false |
alternatingGroup.stabilizer.surjective_toPerm | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {s : Set α},
sᶜ.Nontrivial → Function.Surjective MulAction.toPerm | null | true |
LinearEquiv.extendScalarsOfIsLocalizationEquiv._proof_3 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_4} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_3) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_1} {N : Type u_2} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[i... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Stirling.0.Stirling.factorial_isEquivalent_stirling._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Stirling | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
FixedDetMatrices.repsFintype._proof_2 | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ (k : ℤ) ⦃M N : ↑(FixedDetMatrices.reps k)⦄, ((fun i j => ⟨↑↑M i j, ⋯⟩) = fun i j => ⟨↑↑N i j, ⋯⟩) → M = N | null | false |
AlgebraicGeometry.HasRingHomProperty.inf | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ {P P' : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
{Q Q' : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P fun {R S} [CommRing R] [CommRing S] => Q]
[AlgebraicGeometry.HasRingHomProperty P' fun {R S} [CommRing R] [CommRing S... | null | true |
ProbabilityTheory.Kernel.IndepFun.comp₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {β : Type u_4} {β' : Type u_5} {γ : Type u_6} {γ' : Type u_7} {mα : MeasurableSpace α}
{mΩ : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'} {mγ : MeasurableSpace γ} {mγ' ... | null | true |
Std.DHashMap.Internal.AssocList.AssocListIterator.recOn | Std.Data.DHashMap.Internal.AssocList.Iterator | {α : Type u} →
{β : α → Type v} →
{motive : Std.DHashMap.Internal.AssocList.AssocListIterator α β → Sort u_1} →
(t : Std.DHashMap.Internal.AssocList.AssocListIterator α β) →
((l : Std.DHashMap.Internal.AssocList α β) → motive { l := l }) → motive t | null | false |
Lean.Omega.Fin.ofNat_val_sub | Init.Omega.Int | ∀ {n : ℕ} {x y : Fin n}, ↑↑(x - y) = (↑(n - ↑y) + ↑↑x) % ↑n | null | true |
MeasureTheory.integral_of_isEmpty | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [IsEmpty α] {f : α → G}, ∫ (x : α), f x ∂μ = 0 | null | true |
Sym.coe_replicate | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} {a : α}, ↑(Sym.replicate n a) = Multiset.replicate n a | null | true |
TopCat.Presheaf.stalkFunctor_map_germ_assoc | Mathlib.Topology.Sheaves.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X : TopCat}
{F G : TopCat.Presheaf C X} (U : TopologicalSpace.Opens ↑X) (x : ↑X) (hx : x ∈ U) (f : F ⟶ G) {Z : C}
(h : (TopCat.Presheaf.stalkFunctor C x).obj G ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.germ ... | null | true |
List.Sublist.append_left | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → ∀ (l : List α), (l ++ l₁).Sublist (l ++ l₂) | null | true |
_private.Mathlib.RingTheory.PowerBasis.0.PowerBasis.aeval_minpolyGen._simp_1_3 | Mathlib.RingTheory.PowerBasis | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
NormedRing.npow._inherited_default | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} → α → (mul : α → α → α) → (∀ (a b c : α), a * b * c = a * (b * c)) → ℕ → α → α | null | false |
norm_add_sq_eq_norm_sq_add_norm_sq_of_inner_eq_zero | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x y : E), inner 𝕜 x y = 0 → ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ | Pythagorean theorem, vector inner product form. | true |
_private.Init.Data.Array.QSort.Basic.0.Array.qpartition.loop._unary._proof_16 | Init.Data.Array.QSort.Basic | ∀ {n : ℕ} (lo hi i k : ℕ), lo ≤ i → lo ≤ i + 1 | null | false |
Holor.instAddCommSemigroup | Mathlib.Data.Holor | {α : Type} → {ds : List ℕ} → [AddCommSemigroup α] → AddCommSemigroup (Holor α ds) | null | true |
SmoothBumpFunction.isOpen_support | Mathlib.Geometry.Manifold.BumpFunction | ∀ {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 : ChartedSpace H M] {c : M}
(f : SmoothBumpFunction I c) [inst_5 : FiniteDimensional ℝ E], IsOpen (Function.support ↑f... | null | true |
TensorProduct.tensorQuotMapSMulEquivTensorQuot._proof_13 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), IsScalarTower R R (R ⧸ I) | null | false |
OrderedFinpartition.compAlongOrderedFinpartition._proof_2 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_1}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
... | null | false |
ProbabilityTheory.moment_def | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} (X : Ω → ℝ) (p : ℕ) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.moment X p μ = ∫ (x : Ω), (X ^ p) x ∂μ | null | true |
CategoryTheory.Codiscrete.as | Mathlib.CategoryTheory.CodiscreteCategory | {α : Type u} → CategoryTheory.Codiscrete α → α | A wrapper for promoting any type to a category,
with a unique morphism between any two objects of the category. | true |
Filter.NeBot.of_vadd_filter | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {f : Filter β} {a : α}, (a +ᵥ f).NeBot → f.NeBot | null | true |
_private.Lake.Util.Date.0.Lake.Date.ofString?.match_1 | Lake.Util.Date | (motive : List String.Slice → Sort u_1) →
(x : List String.Slice) →
((y m d : String.Slice) → motive [y, m, d]) → ((x : List String.Slice) → motive x) → motive x | null | false |
Lean.Compiler.LCNF.Ownedness.borrow.elim | Lean.Compiler.LCNF.PropagateBorrow | {motive : Lean.Compiler.LCNF.Ownedness → Sort u} →
(t : Lean.Compiler.LCNF.Ownedness) → t.ctorIdx = 1 → motive Lean.Compiler.LCNF.Ownedness.borrow → motive t | null | false |
SemilatSupCat.of.noConfusion | Mathlib.Order.Category.Semilat | {P : Sort u_1} →
{X : Type u} →
{isSemilatticeSup : SemilatticeSup X} →
{isOrderBot : OrderBot X} →
{X' : Type u} →
{isSemilatticeSup' : SemilatticeSup X'} →
{isOrderBot' : OrderBot X'} →
↧X = ↧X' → (X = X' → isSemilatticeSup ≍ isSemilatticeSup' → isOrderBot ≍ isO... | null | false |
_private.Mathlib.CategoryTheory.Limits.VanKampen.0.CategoryTheory.IsUniversalColimit.map_reflective._simp_1_2 | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | null | false |
TypeVec.toSubtype'._unsafe_rec | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u} n} →
(p : (α.prod α).Arrow (TypeVec.repeat n Prop)) →
TypeVec.Arrow (fun i => { x // TypeVec.ofRepeat (p i (TypeVec.prod.mk i x.1 x.2)) }) (TypeVec.Subtype_ p) | null | false |
Rep.instSymmetricCategory._proof_2 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : CommRing k] [inst_1 : Monoid G] (X Y : Rep.{u_1, u_1, u_2} k G),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | null | false |
CategoryTheory.Oplax.OplaxTrans.Hom | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} → (F ⟶ G) → (F ⟶ G) → Type (max u₁ w₂) | Type-alias for modifications between oplax transformations of oplax functors. This is the type
used for the 2-homomorphisms in the bicategory of oplax functors equipped with oplax
transformations. | true |
MeasureTheory.VectorMeasure.AbsolutelyContinuous.add | Mathlib.MeasureTheory.VectorMeasure.Relations | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_4} {N : Type u_5} [inst : AddCommMonoid M]
[inst_1 : TopologicalSpace M] [inst_2 : AddCommMonoid N] [inst_3 : TopologicalSpace N] [inst_4 : ContinuousAdd M]
{v₁ v₂ : MeasureTheory.VectorMeasure α M} {w : MeasureTheory.VectorMeasure α N},
v₁.AbsolutelyContinuous... | null | true |
Subsemigroup.giMapComap._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Surjective ⇑f → ∀ (S : Subsemigroup N), ∀ x ∈ S, x ∈ Subsemigroup.map f (Subsemigroup.comap f S) | null | false |
_private.Init.Data.Order.Factories.0.Std.LawfulOrderSup.of_lt._simp_1_2 | Init.Data.Order.Factories | ∀ {a b : Prop} [Decidable a] [Decidable b], (¬a ↔ ¬b) = (a ↔ b) | null | false |
CategoryTheory.MorphismProperty.rlp_coproducts | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C),
(CategoryTheory.MorphismProperty.coproducts.{w, v, u} T).rlp = T.rlp | null | true |
LocallyConstant.instAddZeroClass | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [AddZeroClass Y] → AddZeroClass (LocallyConstant X Y) | null | true |
Subsingleton.conformalAt._simp_1 | Mathlib.Analysis.Calculus.Conformal.NormedSpace | ∀ {X : Type u_1} {Y : Type u_2} [inst : NormedAddCommGroup X] [inst_1 : NormedAddCommGroup Y] [inst_2 : NormedSpace ℝ X]
[inst_3 : NormedSpace ℝ Y] [Subsingleton X] (f : X → Y) (x : X), ConformalAt f x = True | null | false |
CanonicallyOrderedAdd | Mathlib.Algebra.Order.Monoid.Canonical.Defs | (α : Type u_1) → [Add α] → [LE α] → Prop | An ordered additive monoid is `CanonicallyOrderedAdd`
if the ordering coincides with the subtractibility relation,
which is to say, `a ≤ b` iff there exists `c` with `b = a + c`.
This is satisfied by the natural numbers, for example, but not
the integers or other nontrivial ordered groups.
We have `a ≤ b + a` and `a ≤... | true |
CategoryTheory.Functor.WellOrderInductionData.Extension.ofLE._proof_3 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_2} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_1)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} {j : J} (e : d.Extension val₀ j)
{i : J} (hij : i ≤ j) (k : J) (hk : Order.IsSuccLimit k) (hki : k ≤ i),
(CategoryTheory.Co... | null | false |
ContRepresentation.coind₁Equivcoind._proof_1 | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {V : Type u_1} [inst : AddCommGroup V] [inst_1 : TopologicalSpace V] [inst_2 : IsTopologicalAddGroup V] {G : Type u_2}
[inst_3 : Group G] [inst_4 : TopologicalSpace G], IsTopologicalAddGroup C(↥⊥, V) | null | false |
Filter.tendsto_mul_const_atTop_of_pos | Mathlib.Order.Filter.AtTopBot.Field | ∀ {α : Type u_1} {β : Type u_2} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {l : Filter β}
{f : β → α} {r : α}, 0 < r → (Filter.Tendsto (fun x => f x * r) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop) | If `r` is a positive constant, `fun x ↦ f x * r` tends to infinity along a filter
if and only if `f` tends to infinity along the same filter. | true |
_private.Lean.Elab.Tactic.Omega.OmegaM.0.Lean.Elab.Tactic.Omega.commitWhen.match_1 | Lean.Elab.Tactic.Omega.OmegaM | {α : Type} → (motive : α × Bool → Sort u_1) → (x : α × Bool) → ((a : α) → (r : Bool) → motive (a, r)) → motive x | null | false |
AddSubmonoid.ctorIdx | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} → {inst : AddZeroClass M} → AddSubmonoid M → ℕ | null | false |
Array.modifyMUnsafe | Init.Data.Array.Basic | {α : Type u} → {m : Type u → Type u_1} → [Monad m] → Array α → ℕ → (α → m α) → m (Array α) | null | true |
Function.ext_iff_support | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f g : ι → M},
f = g ↔ Function.support f = Function.support g ∧ ∀ x ∈ Function.support f, f x = g x | null | true |
MonoidHom.subgroupComap_injective | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] (f : G →* G') (H' : Subgroup G'),
Function.Injective ⇑f → Function.Injective ⇑(f.subgroupComap H') | null | true |
discrete_gronwall_prod_general | Mathlib.Analysis.ODE.DiscreteGronwall | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] {u b c : ℕ → R} {n₀ : ℕ},
(∀ n ≥ n₀, u (n + 1) ≤ c n * u n + b n) →
(∀ n ≥ n₀, 0 ≤ c n) →
∀ ⦃n : ℕ⦄,
n₀ ≤ n → u n ≤ u n₀ * ∏ i ∈ Finset.Ico n₀ n, c i + ∑ k ∈ Finset.Ico n₀ n, b k * ∏ i ∈ Finset.Ico (k + 1) n, c i | Discrete Grönwall inequality, product form: if `u (n+1) ≤ c n * u n + b n` and `0 ≤ c n`
then `u n ≤ u n₀ * ∏ c i + ∑ b k * ∏ c i` over the appropriate ranges. | true |
CategoryTheory.Limits.BinaryBicone.sndKernelFork | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} → (c : CategoryTheory.Limits.BinaryBicone X Y) → CategoryTheory.Limits.KernelFork c.snd | A kernel fork for the kernel of `BinaryBicone.snd`. It consists of the morphism
`BinaryBicone.inl`. | true |
DoubleCentralizer.instRing._proof_7 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {A : Type u_1} [inst : NonUnitalNormedRing A], IsScalarTower ℤ A A | null | false |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Type | A divisibility constraint and its justification/proof. | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct.0.CategoryTheory.Limits.SequentialProduct.functorMap_epi.match_1_1 | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ (n : ℕ) (motive : { x // x < n + 1 } → Prop) (h : { x // x < n + 1 }),
(∀ (val : ℕ) (property : val < n + 1), motive ⟨val, property⟩) → motive h | null | false |
CategoryTheory.NatTrans.rightDerivedFunctorPlus_zero | Mathlib.Algebra.Homology.DerivedCategory.RightDerivedFunctorPlus | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] [inst_4 : HasDerivedCategory C] [inst_5 : HasDerivedCategory D]
[inst_6 : CategoryTheory.EnoughInjectives C] (F₁ F₂ ... | null | true |
UpperSet.coe_sub._simp_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (s t : UpperSet α),
↑s - ↑t = ↑(s - t) | null | false |
String.findAllSubstr | Batteries.Data.String.Matcher | String → Substring.Raw → Array Substring.Raw | Returns all the substrings of `s` that match `pattern`.
| true |
Pi.opensMeasurableSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {ι : Type u_6} {X : ι → Type u_7} [Countable ι] [t' : (i : ι) → TopologicalSpace (X i)]
[inst : (i : ι) → MeasurableSpace (X i)] [∀ (i : ι), SecondCountableTopology (X i)]
[∀ (i : ι), OpensMeasurableSpace (X i)], OpensMeasurableSpace ((i : ι) → X i) | null | true |
Finsupp.sumFinsuppAddEquivProdFinsupp_symm_apply | Mathlib.Data.Finsupp.Basic | ∀ {M : Type u_5} [inst : AddMonoid M] {α : Type u_12} {β : Type u_13} (fg : (α →₀ M) × (β →₀ M)),
Finsupp.sumFinsuppAddEquivProdFinsupp.symm fg = fg.1.sumElim fg.2 | null | true |
AlgebraicGeometry.Scheme.evaluation.congr_simp | Mathlib.AlgebraicGeometry.ResidueField | ∀ (X : AlgebraicGeometry.Scheme) (U : X.Opens) (x : ↥X) (hx : x ∈ U), X.evaluation U x hx = X.evaluation U x hx | null | true |
monovary_inv_left₀._simp_1 | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : LinearOrder β] {f : ι → α} {g : ι → β}, StrongLT 0 f → Monovary f⁻¹ g = Antivary f g | null | false |
Lean.Lsp.CompletionList._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CompletionList | null | false |
CategoryTheory.Functor.toPseudofunctor_mapComp | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D)
{a b c : CategoryTheory.LocallyDiscrete C} (x : a ⟶ b) (x_1 : b ⟶ c),
F.toPseudofunctor.mapComp x x_1 =
match x with
| { as := f } =>
match x... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.