name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.Types.productIso._proof_1 | Mathlib.CategoryTheory.Limits.Types.Products | ∀ {J : Type u_1} (F : J → Type (max u_1 u_2)), CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor F) | null | false |
CategoryTheory.WideSubcategory.instSymmetricCategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.SymmetricCategory C] [P.IsStableUnderBraiding],
P.IsMultiplicative | null | false |
T5Space.casesOn | Mathlib.Topology.Separation.Regular | {X : Type u} →
[inst : TopologicalSpace X] →
{motive : T5Space X → Sort u_1} →
(t : T5Space X) →
([toT1Space : T1Space X] → [toCompletelyNormalSpace : CompletelyNormalSpace X] → motive ⋯) → motive t | null | false |
Equiv.Set.compl | Mathlib.Logic.Equiv.Set | {α : Type u} →
{β : Type v} →
{s : Set α} →
{t : Set β} →
[DecidablePred fun x => x ∈ s] →
[DecidablePred fun x => x ∈ t] → (e₀ : ↑s ≃ ↑t) → { e // ∀ (x : ↑s), e ↑x = ↑(e₀ x) } ≃ (↑sᶜ ≃ ↑tᶜ) | Given an equivalence `e₀` between sets `s : Set α` and `t : Set β`, the set of equivalences
`e : α ≃ β` such that `e ↑x = ↑(e₀ x)` for each `x : s` is equivalent to the set of equivalences
between `sᶜ` and `tᶜ`. | true |
_private.Mathlib.Topology.ContinuousMap.Basic.0.ContinuousMap.instNontrivialOfNonempty.match_1 | Mathlib.Topology.ContinuousMap.Basic | ∀ {β : Type u_1} (motive : (∃ x y, x ≠ y) → Prop) (x : ∃ x y, x ≠ y),
(∀ (b₁ b₂ : β) (hb : b₁ ≠ b₂), motive ⋯) → motive x | null | false |
Lean.Grind.Linarith.eq_normN_cert | Init.Grind.Module.NatModuleNorm | Lean.Grind.Linarith.Expr → Lean.Grind.Linarith.Expr → Bool | null | true |
finsetProd_apply_eq_zero' | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [inst : AddCommMonoid ι] [inst_1 : LinearOrder ι] [IsOrderedAddMonoid ι]
[inst_3 : DecidableEq ι] [CanonicallyOrderedAdd ι] [inst_5 : CommSemiring R] [inst_6 : SetLike σ R]
[inst_7 : AddSubmonoidClass σ R] {A : ι → σ} [inst_8 : SetLike.GradedMonoid A]
{s : Finset ((D... | The difference with `DirectSum.finsetProd_apply_eq_zero` is that the indices at which
the terms of the multiset are zero is allowed to vary. | true |
CategoryTheory.Limits.IsLimit.ofIsoLimit_lift | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {r t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit r)
(i : r ≅ t) (s : CategoryTheory.Limits.Cone F),
(P.ofIsoLimit i).lift s = CategoryTheo... | null | true |
Finset.orderEmbOfFin_last | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {k : ℕ} (h : s.card = k) (hz : 0 < k),
(s.orderEmbOfFin h) ⟨k - 1, ⋯⟩ = s.max' ⋯ | The bijection `orderEmbOfFin s h` sends `k-1` to the maximum of `s`. | true |
LinearEquiv.prodCongr._proof_2 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_5} {M : Type u_1} {M₂ : Type u_3} {M₃ : Type u_2} {M₄ : Type u_4} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : AddCommMonoid M₄]
{module_M : Module R M} {module_M₂ : Module R M₂} {module_M₃ : Module R M₃} {module_M₄ : Module R M₄}
(... | null | false |
riemannZeta₀.eq_1 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ (s : ℂ), riemannZeta₀ s = if s = 1 then ↑Real.eulerMascheroniConstant else riemannZeta s - (s - 1)⁻¹ | null | true |
USize.ofFin_uint8ToFin | Init.Data.UInt.Lemmas | ∀ (n : UInt8), USize.ofFin (Fin.castLE UInt8.size_le_usizeSize n.toFin) = n.toUSize | null | true |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.compositionAsSetEquiv._proof_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ (n : ℕ) (i : Fin (n - 1)), 1 + ↑i < n.succ | null | false |
Cardinal.aleph0_power_aleph0 | Mathlib.SetTheory.Cardinal.Continuum | Cardinal.aleph0 ^ Cardinal.aleph0 = Cardinal.continuum | null | true |
LinearPMap.neg_domain | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] (f : E →ₛₗ.[σ] F),
(-f).domain = f.domain | null | true |
List.disjoint_append_right | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {l l₁ l₂ : List α}, l.Disjoint (l₁ ++ l₂) ↔ l.Disjoint l₁ ∧ l.Disjoint l₂ | null | true |
_private.Mathlib.Algebra.Order.BigOperators.GroupWithZero.List.0.List.prod_nonneg._simp_1_2 | Mathlib.Algebra.Order.BigOperators.GroupWithZero.List | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | null | false |
CategoryTheory.GrpObj.lift_inv_comp_left | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.GrpObj A] [inst_3 : CategoryTheory.GrpObj B] (f : A ⟶ B)
[CategoryTheory.IsMonHom f],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCateg... | null | true |
Std.TreeMap.getD_filterMap' | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {f : α → β → Option γ} {k : α} {fallback : γ},
(Std.TreeMap.filterMap f t).getD k fallback = (t[k]?.bind (f k)).getD fallback | Simpler variant of `getD_filterMap` when `LawfulEqCmp` is available. | true |
AddMonoidHom.toHomAddUnits._proof_1 | Mathlib.Algebra.Group.Units.Hom | ∀ {G : Type u_2} {M : Type u_1} [inst : AddGroup G] [inst_1 : AddMonoid M] (f : G →+ M) (g : G), f g + f (-g) = 0 | null | false |
Kronecker.«_aux_Mathlib_LinearAlgebra_Matrix_Kronecker___macroRules_Kronecker_term_⊗ₖₜ__1» | Mathlib.LinearAlgebra.Matrix.Kronecker | Lean.Macro | null | false |
FiberBundleCore.baseSet_at | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι), Z.baseSet i = (Z.localTriv i).baseSet | null | true |
CategoryTheory.Bimon.toTrivial | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (A : CategoryTheory.Bimon C) → A ⟶ CategoryTheory.Bimon.trivial C | The bimonoid morphism from any bimonoid to the trivial bimonoid. | true |
Plausible.InjectiveFunction.mk._proof_1 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type u_1} (xs ys : List α), xs.Perm ys → xs.length ≤ ys.length | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Boundary.0.SSet.stdSimplex.subcomplex_hasDimensionLT_of_neq_top._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.Boundary | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
Lean.Expr.getForallBinderNames._f | Lean.Expr | (x : Lean.Expr) → Lean.Expr.below x → List Lean.Name | null | false |
Algebra.Generators.reindex._proof_2 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{ι' : Type u_4} (P : Algebra.Generators R S ι') (e : ι ≃ ι'),
algebraMap (MvPolynomial ι R) S = ↑(MvPolynomial.aeval (P.val ∘ ⇑e)) | null | false |
CategoryTheory.AddModObj.ext_iff | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M : C}
[inst_2 : CategoryTheory.AddMonObj M] {X : C} {h₁ h₂ : CategoryTheory.AddModObj M X},
h₁ = h₂ ↔ CategoryTheory.AddModObj.vadd = CategoryTheory.AddModObj.vadd | null | true |
Lean.Compiler.LCNF.InferType.Pure.inferAppType | Lean.Compiler.LCNF.InferType | Lean.Expr → Lean.Compiler.LCNF.InferType.Pure.InferTypeM Lean.Expr | null | true |
DualNumber.lift._proof_13 | Mathlib.Algebra.DualNumber | ∀ {R : Type u_3} {B : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (fe : { fe // fe.2 * fe.2 = 0 ∧ ∀ (a : A), Commute fe.2 (fe.1 a) }),
⟨((↑⟨((↑fe).1, MulOpposite.op (↑fe).2 • (↑fe).1.toLinearMap), ⋯⟩).1,
(↑⟨((↑fe)... | null | false |
_private.Mathlib.Topology.Homotopy.Lifting.0.IsQuotientCoveringMap.monodromy_toPermFiber._proof_1_1 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X} {G : Type u_3}
[inst_2 : Group G] [inst_3 : MulAction G E], IsQuotientCoveringMap p G → Continuous p | null | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.subtypeDomain_eq_iff_forall._simp_1_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
SimpleGraph.isBipartiteWith_neighborFinset' | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} {w : V} {G : SimpleGraph V} {s t : Finset V} [inst : Fintype ↑(G.neighborSet w)]
[inst_1 : DecidableRel G.Adj], G.IsBipartiteWith ↑s ↑t → w ∈ t → G.neighborFinset w = {v ∈ s | G.Adj v w} | If `G.IsBipartiteWith s t` and `w ∈ t`, then the neighbor finset of `w` is the set of vertices
in `s` adjacent to `w` in `G`. | true |
Float.Model.UnpackedFloat.beq.eq_1 | Batteries.Data.Float.Lemmas | ∀ (a b : Float.Model.UnpackedFloat), a.beq b = (a.compare b == some Ordering.eq) | null | true |
ContinuousLinearEquiv.strictConvex_image._simp_1 | Mathlib.Analysis.Convex.ContinuousLinearEquiv | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [inst_5 : AddCommGroup F] [inst_6 : Module 𝕜 F]
[inst_7 : TopologicalSpace F] {s : Set E} (e : E ≃L[𝕜] F), StrictConvex 𝕜 (⇑e '' s) = StrictC... | null | false |
_private.Lean.LibrarySuggestions.SineQuaNon.0.Lean.LibrarySuggestions.SineQuaNon.sineQuaNonTriggersFor | Lean.LibrarySuggestions.SineQuaNon | Lean.Name → Lean.CoreM (List (Lean.Name × Float)) | null | true |
CategoryTheory.GrothendieckTopology.pseudofunctorOver_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_obj_α | Mathlib.CategoryTheory.Sites.PseudofunctorSheafOver | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} A] (b : CategoryTheory.LocallyDiscrete Cᵒᵖ),
↑((J.pseudofunctorOver A).obj b) = CategoryTheory.Sheaf (J.over (Opposite.unop b.as)) A | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_maxKeyD._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Lean.Elab.Import.0.Lean.Elab.parseImports._proof_1 | Lean.Elab.Import | ∀ (input : String), input.rawEndPos ≤ input.rawEndPos | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeGroup.idxOf_toWord_of_mul_eq._proof_1_1 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} (x : FreeGroup α), x.toWord.head? = some (a, false) → ¬x.toWord = [] | null | false |
to_compactlyCoherentSpace | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactlyGeneratedSpace X], CompactlyCoherentSpace X | Every compactly generated space is a compactly coherent space. | true |
_private.Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric.0.Complex.regularizedHGFunCoeff_zero_neg_nat_add_one._proof_1_3 | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | ∀ (n i : ℕ),
(Complex.Gamma (-↑n + 1 + (↑i + ↑n)))⁻¹ * (Complex.Gamma (↑i + ↑n + 1))⁻¹ =
(Complex.Gamma (↑n + 1 + ↑i))⁻¹ * (Complex.Gamma (↑i + 1))⁻¹ | null | false |
TopologicalSpace.IrreducibleCloseds.carrier | Mathlib.Topology.Sets.Closeds | {α : Type u_4} → [inst : TopologicalSpace α] → TopologicalSpace.IrreducibleCloseds α → Set α | the carrier set, i.e. the points in this set | true |
ContinuousMultilinearMap.compContinuousLinearMapL._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_4} {ι : Type u_1} {E : ι → Type u_2} {F : Type u_3} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopological... | null | false |
Ideal.comap_map_of_surjective | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Ring S] [inst_2 : FunLike F R S]
[inst_3 : RingHomClass F R S] (f : F),
Function.Surjective ⇑f → ∀ (I : Ideal R), Ideal.comap f (Ideal.map f I) = I ⊔ Ideal.comap f ⊥ | null | true |
Finset.Ioo_pred_left_eq_Ioc | Mathlib.Order.Interval.Finset.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : PredOrder α] [NoMinOrder α] (a b : α),
Finset.Ioo (Order.pred a) b = Finset.Ico a b | **Alias** of `Finset.Ioo_pred_left_eq_Ico`. | true |
_private.Init.Data.SInt.Lemmas.0.Int64.le_iff_lt_or_eq._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) | null | false |
Lean.Elab.Tactic.instMonadExceptExceptionTacticM | Lean.Elab.Tactic.Basic | MonadExcept Lean.Exception Lean.Elab.Tactic.TacticM | null | true |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.eq_of_getLast_mem_of_prefix._proof_1_5 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l₁ l₂ : List α} {hne : l₂ ≠ []} (w : List α), l₁ ++ w = l₂ → ¬l₁ ++ w = [] | null | false |
Function.Surjective.distrib._proof_1 | Mathlib.Algebra.Ring.InjSurj | ∀ {R : Type u_2} {S : Type u_1} (f : R → S),
Function.Surjective f →
∀ [inst : Add S] [inst_1 : Mul S] [inst_2 : Distrib R],
(∀ (x y : R), f (x + y) = f x + f y) → (∀ (x y : R), f (x * y) = f x * f y) → LeftDistribClass S | null | false |
Topology.CWComplex.disjoint_skeletonLT_openCell | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : T2Space X] [inst_1 : Topology.RelCWComplex C D] {n : ℕ∞}
{m : ℕ} {j : Topology.RelCWComplex.cell C m},
n ≤ ↑m → Disjoint (↑(Topology.RelCWComplex.skeletonLT C n)) (Topology.RelCWComplex.openCell m j) | **Alias** of `Topology.RelCWComplex.disjoint_skeletonLT_openCell`.
---
A skeleton and an open cell of a higher dimension are disjoint. | true |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.instT | Mathlib.RingTheory.Extension.Cotangent.Basis | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{ι : Type u_4} →
{P : Algebra.Generators R S ι} →
{σ : Type u_5} →
{b : Module.Basis σ S P.toExtension.Cotangent} →
(D : Alge... | null | true |
Metric.IsCover.subset_cthickening | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {ε : NNReal} {s N : Set X} [ProperSpace X],
IsClosed N → Metric.IsCover ε s N → s ⊆ Metric.cthickening (↑ε) N | **Alias** of the forward direction of `Metric.isCover_iff_subset_cthickening`. | true |
MeasureTheory.Measure.IsAddHaarMeasure.comap | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} {H : Type u_2} [inst : MeasurableSpace G] [inst_1 : MeasurableSpace H] [inst_2 : AddGroup G]
[inst_3 : TopologicalSpace G] [BorelSpace G] [MeasurableAdd G] [inst_6 : AddGroup H] [inst_7 : TopologicalSpace H]
[BorelSpace H] {mH : MeasurableAdd H} (μ : MeasureTheory.Measure H) [μ.IsAddHaarMeasure] {f... | null | true |
MeasureTheory.JordanDecomposition.instInvolutiveNeg | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | {α : Type u_1} → [inst : MeasurableSpace α] → InvolutiveNeg (MeasureTheory.JordanDecomposition α) | null | true |
CategoryTheory.HasRightDual.mk.noConfusion | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{X : C} →
{P : Sort u} →
{rightDual : C} →
{exact : CategoryTheory.ExactPairing X rightDual} →
{rightDual' : C} →
{exact' : CategoryTheory.... | null | false |
cfc_ringInverse_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p]... | null | true |
AddValuation.toPreorder | Mathlib.RingTheory.Valuation.Basic | {R : Type u_3} →
{Γ₀ : Type u_4} → [inst : Ring R] → [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] → AddValuation R Γ₀ → Preorder R | A valuation gives a preorder on the underlying ring. | true |
NonUnitalCommRing.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u} →
(zero : α) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), 0 • x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n : ... | null | false |
HomotopicalAlgebra.BifibrantObject.instCongruenceHomRel | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
CategoryTheory.Congruence (HomotopicalAlgebra.BifibrantObject.homRel C) | null | true |
CategoryTheory.Limits.IsZero.isInitial | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → CategoryTheory.Limits.IsZero X → CategoryTheory.Limits.IsInitial X | A zero object is in particular initial. | true |
_private.Lean.AddDecl.0.Lean.registerNamePrefixes.go._sunfold | Lean.AddDecl | Lean.Environment → Lean.Name → Lean.Environment | null | false |
StandardEtalePresentation.toPresentation._proof_3 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : StandardEtalePresentation R S),
Function.Surjective
(⇑(P.lift P.x ⋯) ∘
⇑P.equivMvPolynomialQuotient.symm ∘
⇑(Ideal.Quotient.mk
(Ideal.span
{(Polynomial.Bivariate.equivMvP... | null | false |
SubringClass.instIsDomainSubtypeMem | Mathlib.Algebra.Ring.Subring.Defs | ∀ {S : Type v} (s : S) {R : Type u_1} [inst : Ring R] [IsDomain R] [inst_2 : SetLike S R] [inst_3 : SubringClass S R],
IsDomain ↥s | A subring of a domain is a domain. | true |
CategoryTheory.ShortComplex.instMonoFKernelSequence | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C}
(f : X ⟶ Y), CategoryTheory.Mono (CategoryTheory.ShortComplex.kernelSequence f).f | null | true |
CategoryTheory.MonoidalCategory.tensorμ_natural | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X₁ X₂ Y₁ Y₂ U₁ U₂ V₁ V₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : U₁ ⟶ V₁)
(g₂ : U₂ ⟶ V₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryS... | null | true |
CategoryTheory.FreeMonoidalCategory.normalizeIsoApp._sunfold | Mathlib.CategoryTheory.Monoidal.Free.Coherence | (C : Type u) →
(X : CategoryTheory.FreeMonoidalCategory C) →
(n : (CategoryTheory.Discrete ∘ CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject) C) →
((CategoryTheory.FreeMonoidalCategory.tensorFunc C).obj X).obj n ≅
((CategoryTheory.FreeMonoidalCategory.normalize' C).obj X).obj n | null | false |
LieAlgebra.zeroRootSubalgebra.congr_simp | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H H_1 : LieSubalgebra R L) (e_H : H = H_1) [inst_3 : LieRing.IsNilpotent ↥H],
LieAlgebra.zeroRootSubalgebra R L H = LieAlgebra.zeroRootSubalgebra R L H_1 | null | true |
Interval.coe_bot | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α], ↑⊥ = ∅ | null | true |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.Decl.detectSimpleGround._sparseCasesOn_3 | Lean.Compiler.LCNF.SimpleGroundExpr | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.DeclValue pu → Sort u} →
(t : Lean.Compiler.LCNF.DeclValue pu) →
((code : Lean.Compiler.LCNF.Code pu) → motive (Lean.Compiler.LCNF.DeclValue.code code)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
lemma | Mathlib.Tactic.Lemma | Lean.ParserDescr | `lemma` means the same as `theorem`. It is used to denote "less important" theorems | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.TsumUniformlyOn.0.iteratedDerivWithin_tsum._proof_1_1 | Mathlib.Topology.Algebra.InfiniteSum.TsumUniformlyOn | ∀ (m : ℕ), m ≤ m + 1 | null | false |
PerfectClosure.instAddCommGroup._proof_8 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (n : ℕ) (x : K),
((n, x).1 + (0, 0).1, (⇑(frobenius K p))^[(0, 0).1] (n, x).2 + (⇑(frobenius K p))^[(n, x).1] (0, 0).2) = (n, x) | null | false |
codisjoint_inf_right | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderTop α] {a b c : α},
Codisjoint a (b ⊓ c) ↔ Codisjoint a b ∧ Codisjoint a c | null | true |
Order.Ideal.IsPrime.recOn | Mathlib.Order.PrimeIdeal | {P : Type u_1} →
[inst : Preorder P] →
{I : Order.Ideal P} →
{motive : I.IsPrime → Sort u} →
(t : I.IsPrime) → ([toIsProper : I.IsProper] → (compl_filter : Order.IsPFilter (↑I)ᶜ) → motive ⋯) → motive t | null | false |
Lean.Linter.UnusedVariables.followAliases._unsafe_rec | Lean.Linter.UnusedVariables | Std.HashMap Lean.FVarId Lean.FVarId → Lean.FVarId → Lean.FVarId | null | false |
_private.Init.Data.List.Lemmas.0.List.forall_mem_iff_forall_getElem._simp_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ l) = ∃ i, ∃ (h : i < l.length), l[i] = a | null | false |
εNFA.εClosure_empty | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} (M : εNFA α σ), M.εClosure ∅ = ∅ | null | true |
String.Pos.next_ofSliceFrom | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceFrom p₀).Pos} {h : String.Pos.ofSliceFrom p ≠ s.endPos},
(String.Pos.ofSliceFrom p).next h = String.Pos.ofSliceFrom (p.next ⋯) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Decomp.0.SimpleGraph.Walk.dropUntil_eq_drop._proof_1_9 | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u_1} {G : SimpleGraph V} {w a v_1 w_1 : V} (h_1 : G.Adj a v_1) (p : G.Walk v_1 w_1),
w ∈ (SimpleGraph.Walk.cons h_1 p).support → w ≠ a → w ∈ p.support | null | false |
_private.Mathlib.Tactic.Linarith.Verification.0.Mathlib.Tactic.Linarith.addExprs'.go._unsafe_rec | Mathlib.Tactic.Linarith.Verification | {u : Lean.Level} →
{α :
let u := u;
Q(Type u)} →
Q(AddMonoid «$α») → Q(«$α») → List Q(«$α») → Q(«$α») | null | false |
LeftCancelSemigroup.ext_iff | Mathlib.Algebra.Group.Semigroup | ∀ {G : Type u_2} {x y : LeftCancelSemigroup G}, x = y ↔ Mul.mul = Mul.mul | null | true |
Lean.Doc.Parser.role | Lean.DocString.Parser | Lean.Doc.Parser.InlineCtxt → Lean.Parser.ParserFn | Parses a role. | true |
ContinuousMap.instT0Space | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T0Space Y], T0Space C(X, Y) | null | true |
MeasureTheory.VectorMeasure.tendsto_integral_of_dominated_convergence | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] {μ : MeasureTheory.VectorMeasure X F} {B : E →L[ℝ] F →... | **Lebesgue dominated convergence theorem** provides sufficient conditions under which almost
everywhere convergence of a sequence of functions implies the convergence of their integrals.
We could weaken the condition `bound_integrable` to require
`HasFiniteIntegral bound μ.variation` instead (i.e. not requiring that `b... | true |
Cardinal.sdiff_nonempty_of_mk_lt_mk | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u} {S T : Set α}, Cardinal.mk ↑S < Cardinal.mk ↑T → (T \ S).Nonempty | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.outerKernel._proof_4 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ (𝕜 : Type u_2) [inst : RCLike 𝕜] {V : Type u_1} [inst_1 : NormedAddCommGroup V] [inst_2 : InnerProductSpace 𝕜 V],
ContinuousAdd (V →L[𝕜] V) | null | false |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.exists_cons_of_leadingCoeff_pos._proof_1_8 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] {P : Polynomial R} (η : R),
P.eraseLead.natDegree + 1 = P.natDegree →
∀ (d : ℕ),
P.natDegree = 0 + d + 1 →
((Polynomial.X - Polynomial.C η) * P).natDegree = P.natDegree + 1 →
(Polynomial.monomial P.natDegree) ((Polynomial.X - Polynomial.C η) * P).nextCoeff ... | null | false |
Lean.Elab.Tactic.filterSuggestionsAndLocalsFromSimpConfig | Lean.Elab.Tactic.SimpTrace | Lean.TSyntax `Lean.Parser.Tactic.optConfig → Lean.MetaM (Lean.TSyntax `Lean.Parser.Tactic.optConfig) | Filter out `+suggestions` and `+locals` from the config syntax | true |
LinearMap.instDistribMulActionDomMulActOfSMulCommClass | Mathlib.Algebra.Module.LinearMap.Basic | {R : Type u_1} →
{R' : Type u_2} →
{M : Type u_4} →
{M' : Type u_5} →
[inst : Semiring R] →
[inst_1 : Semiring R'] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M'] →
[inst_4 : Module R M] →
[inst_5 : Module R' M'] →
... | null | true |
InformationTheory.IsUniquelyDecodable.epsilon_notMem | Mathlib.InformationTheory.Coding.UniquelyDecodable | ∀ {α : Type u_1} {S : Set (List α)}, InformationTheory.IsUniquelyDecodable S → [] ∉ S | If a code is uniquely decodable, it does not contain the empty string.
The empty string can be "decoded" as either zero or two copies of itself,
violating unique decodability. | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.cardDistinctFactors_eq_zero._simp_1_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {n : ℕ}, (n ≤ 1) = (n = 0 ∨ n = 1) | null | false |
CategoryTheory.ShortComplex.HomologyMapData.instSubsingleton | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.HomologyData} {h₂ : S₂.HomologyData},
Subsingleton (CategoryTheory.ShortComplex.HomologyMapData φ h₁ h₂) | null | true |
SimpleGraph.Subgraph.Connected | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | {V : Type u} → {G : SimpleGraph V} → G.Subgraph → Prop | A subgraph is connected if it is connected when coerced to be a simple graph.
Note: This is a structure to make it so one can be precise about how dot notation resolves. | true |
Lean.Elab.Tactic.ElabSimpArgsResult.noConfusion | Lean.Elab.Tactic.Simp | {P : Sort u} →
{t t' : Lean.Elab.Tactic.ElabSimpArgsResult} → t = t' → Lean.Elab.Tactic.ElabSimpArgsResult.noConfusionType P t t' | null | false |
Set.IciExtend_self | Mathlib.Order.Interval.Set.ProjIcc | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] {a : α} (f : ↑(Set.Ici a) → β), Set.IciExtend f a = f ⟨a, ⋯⟩ | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.tdiv_eq_ediv._simp_1_10 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℕ}, (Int.negSucc a % (↑b + 1) = 0) = ((a + 1) % (b + 1) = 0) | null | false |
DivisionRing.qsmul_def._autoParam | Mathlib.Algebra.Field.Defs | Lean.Syntax | null | false |
ConcaveOn.lipschitzOnWith_of_abs_le | Mathlib.Analysis.Convex.Continuous | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x₀ : E} {ε r M : ℝ},
ConcaveOn ℝ (Metric.ball x₀ r) f →
0 < ε → (∀ (a : E), dist a x₀ < r → |f a| ≤ M) → LipschitzOnWith (2 * M / ε).toNNReal f (Metric.ball x₀ (r - ε)) | null | true |
ComplexShape.hasNoLoop_down | Mathlib.Algebra.Homology.HasNoLoop | ∀ {α : Type u_2} [inst : AddZeroClass α] [inst_1 : IsRightCancelAdd α] [IsLeftCancelAdd α] [inst_3 : One α],
1 ≠ 0 → (ComplexShape.down α).HasNoLoop | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.