name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
QuotientAddGroup.equivIocMod._proof_4 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a : α) (b : ↑(Set.Ioc a (a + p))), ⟨⋯.lift ↑↑b, ⋯⟩ = b | null | false |
CategoryTheory.PreOneHypercover.instIsIsoH₁Hom | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : E.I₀} (k : E.I₁ i j), CategoryTheory.IsIso (e.hom.h₁ k) | null | true |
ValuedCSP.Term.noConfusionType | Mathlib.Combinatorics.Optimization.ValuedCSP | Sort u →
{D : Type u_1} →
{C : Type u_2} →
[inst : AddCommMonoid C] →
[inst_1 : PartialOrder C] →
[inst_2 : IsOrderedAddMonoid C] →
{Γ : ValuedCSP D C} →
{ι : Type u_3} →
Γ.Term ι →
{D' : Type u_1} →
{C' : Type... | null | false |
_private.Mathlib.RingTheory.Localization.Ideal.0.IsLocalization.map_inf._simp_1_2 | Mathlib.RingTheory.Localization.Ideal | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
Lean.Meta.Simp.Diagnostics.thmsWithBadKeys | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Diagnostics → Lean.PArray Lean.Meta.SimpTheorem | When using `Simp.Config.index := false`, and `set_option diagnostics true`,
for every theorem used by `simp`, we check whether the theorem would be
also applied if `index := true`, and we store it here if it would not have
been tried.
| true |
ComputablePred.computable_iff | Mathlib.Computability.RE | ∀ {α : Type u_1} [inst : Primcodable α] {p : α → Prop}, ComputablePred p ↔ ∃ f, Computable f ∧ p = fun a => f a = true | null | true |
EReal.neBotTopHomeomorphReal._proof_2 | Mathlib.Topology.Instances.EReal.Lemmas | Continuous fun x => ⟨↑x, ⋯⟩ | null | false |
IsAddRightRegular.nsmul | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {a : R} (n : ℕ), IsAddRightRegular a → IsAddRightRegular (n • a) | null | true |
CompletePartialOrder.ctorIdx | Mathlib.Order.CompletePartialOrder | {α : Type u_4} → CompletePartialOrder α → ℕ | null | false |
Std.ExtDTreeMap.mergeWith._proof_1 | Std.Data.ExtDTreeMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Std.LawfulEqCmp cmp]
(mergeFn : (a : α) → β a → β a → β a) (x x_1 x_2 x_3 : Std.DTreeMap α β cmp),
x.Equiv x_2 →
x_1.Equiv x_3 →
Std.ExtDTreeMap.mk (Std.DTreeMap.mergeWith mergeFn x x_1) =
Std.ExtDTreeMap.mk (S... | null | false |
SimpleGraph.Embedding.preimage_edgeSet | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} (f : G ↪g G'),
Sym2.map ⇑f ⁻¹' G'.edgeSet = G.edgeSet | null | true |
NonUnitalStarSubalgebra.centralizer_univ | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : StarRing A]
[inst_3 : Module R A] [inst_4 : IsScalarTower R A A] [inst_5 : SMulCommClass R A A],
NonUnitalStarSubalgebra.centralizer R Set.univ = NonUnitalStarSubalgebra.center R A | null | true |
ModuleCat.lsmul_eq_smul_id | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {S : Type u} [inst : CommRing S] (M : ModuleCat S) (s : S),
ModuleCat.ofHom ((LinearMap.lsmul S ↑M) s) = s • CategoryTheory.CategoryStruct.id M | null | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestAtomic | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic → Lean.Elab.Tactic.TacticM (Lean.TSyntax `tactic) | null | true |
RBTree.RBNode.Path.listL.eq_def | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} (x : RBTree.RBNode.Path α),
x.listL =
match x with
| RBTree.RBNode.Path.root => []
| RBTree.RBNode.Path.left c parent v r => parent.listL
| RBTree.RBNode.Path.right c l v parent => parent.listL ++ (l.toList ++ [v]) | null | true |
Vector.ofFn_succ' | Init.Data.Vector.OfFn | ∀ {n : ℕ} {α : Type u_1} {f : Fin (n + 1) → α}, Vector.ofFn f = Vector.cast ⋯ (#v[f 0] ++ Vector.ofFn fun i => f i.succ) | null | true |
Polynomial.eq_zero_of_dvd_of_degree_lt | Mathlib.Algebra.Polynomial.Degree.Domain | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R}, p ∣ q → q.degree < p.degree → q = 0 | null | true |
Bialgebra.TensorProduct.coalgebra_rid_eq_algebra_rid_apply | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Bialgebra S A] [inst_4 : Algebra R A] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R S A]
(x : TensorProduct R A R), (Coalgebra.TensorProduct.rid R S A) x = (Algebra.TensorProduct.rid R... | null | true |
FinEnum.instUInt32 | Mathlib.Data.FinEnum | FinEnum UInt32 | null | true |
CStarMatrix.instNonUnitalCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : StarOrderedRing A] {n : Type u_2}
[inst_3 : Fintype n] (x : ℂ) (y z : CStarMatrix n n A), (x • y) • z = x • y • z | null | false |
Lean.Lsp.CodeActionContext.mk._flat_ctor | Lean.Data.Lsp.CodeActions | Array Lean.Lsp.Diagnostic →
Option (Array Lean.Lsp.CodeActionKind) → Option Lean.Lsp.CodeActionTriggerKind → Lean.Lsp.CodeActionContext | null | false |
_private.Lean.Meta.Tactic.Apply.0.Lean.MVarId.iffOfEq._sparseCasesOn_1 | Lean.Meta.Tactic.Apply | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Topology.LocallyFinite.0.locallyFinite_option._simp_1_1 | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_1} {X : Type u_4} [inst : TopologicalSpace X] [Finite ι] (f : ι → Set X), LocallyFinite f = True | null | false |
RootPairing.Equiv.mul_eq_comp | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (x y : P.Equiv P),
x * y = x.comp y | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.EulerSineProd.0.EulerSine.integral_sin_mul_sin_mul_cos_pow_eq._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.EulerSineProd | (1 + 1).AtLeastTwo | null | false |
SemiSimplexCategory.smallCategory._proof_2 | Mathlib.AlgebraicTopology.SimplexCategory.SemiSimplexCategory | ∀ {X Y : SemiSimplexCategory} (f : X.Hom Y), RelEmbedding.trans f (RelEmbedding.refl fun x1 x2 => x1 ≤ x2) = f | null | false |
Setoid.gi._proof_1 | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} (x : α → α → Prop) (s : Setoid α), Relation.EqvGen.setoid x ≤ s ↔ x ≤ ⇑s | null | false |
SetSemiring.instAddCommMonoid._proof_1 | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} (x : SetSemiring α), 0 • x = 0 | null | false |
RootPairing.Equiv.mk'._proof_7 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_4} {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N), P.flip.IsPerfPair | null | false |
ClopenUpperSet.coe_toUpperSet | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] (s : ClopenUpperSet α), ↑s.toUpperSet = ↑s | null | true |
_private.Mathlib.Analysis.Normed.Module.MultipliableUniformlyOn.0.Summable.hasProdUniformlyOn_one_add._simp_1_1 | Mathlib.Analysis.Normed.Module.MultipliableUniformlyOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α],
HasProdUniformlyOn f g s = TendstoUniformlyOn (fun x1 x2 => ∏ i ∈ x1, f i x2) g Filter.atTop s | null | false |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.replaceLhs? | Lean.Meta.Tactic.Grind.MatchCond | Lean.Expr → Lean.Expr → Option Lean.Expr → Option Lean.Expr | Replaces the left-hand side of an equality (or heterogeneous equality) `e` with `lhsNew`.
| true |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.getKey._proof_3 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m : Std.ExtDHashMap α β) (a : α) (h : a ∈ m) (m_1 m' : Std.DHashMap α β) (x_2 : m = Std.ExtDHashMap.mk m_1),
m = Std.ExtDHashMap.mk m' → ∀ (h_1 : m_1.Equiv m'), m_1.getKey a ⋯ = m'.getKey a ⋯ | null | false |
Filter.Tendsto.atBot_mul_atBot₀ | Mathlib.Order.Filter.AtTopBot.Ring | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] {l : Filter β}
{f g : β → α},
Filter.Tendsto f l Filter.atBot → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x * g x) l Filter.atTop | null | true |
Affine.Simplex.map_mkOfPoint | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {V₂ : Type u_3} {P : Type u_5} {P₂ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V]
[inst_2 : AddCommGroup V₂] [inst_3 : Module k V] [inst_4 : Module k V₂] [inst_5 : AddTorsor V P]
[inst_6 : AddTorsor V₂ P₂] (f : P →ᵃ[k] P₂) (hf : Function.Injective ⇑f) (p : P),
(Affine.Simple... | null | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.spanFinset_eq_zero._simp_1_7 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | null | false |
Subgroup.mem_sup_of_normal_left | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] {s t : Subgroup G} [hs : s.Normal] {x : G}, x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x | null | true |
CategoryTheory.Localization.SmallShiftedHom.shift | Mathlib.CategoryTheory.Localization.SmallShiftedHom | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{W : CategoryTheory.MorphismProperty C} →
{M : Type w'} →
[inst_1 : AddMonoid M] →
[inst_2 : CategoryTheory.HasShift C M] →
[W.IsCompatibleWithShift M] →
{X Y : C} →
{a : M} →
... | Given `f : SmallShiftedHom.{w} W X Y a`, this is the element in
`SmallHom.{w} W (X⟦n⟧) (Y⟦a'⟧)` that is obtained by shifting by `n`
when `a + n = a'`. | true |
ContinuousAlternatingMap._sizeOf_1 | Mathlib.Topology.Algebra.Module.Alternating.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
{ι : Type u_4} →
{inst : Semiring R} →
{inst_1 : AddCommMonoid M} →
{inst_2 : Module R M} →
{inst_3 : TopologicalSpace M} →
{inst_4 : AddCommMonoid N} →
{inst_5 : Module R N} →
... | null | false |
lp.inftyStarRing._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {I : Type u_1} {B : I → Type u_2} [inst : (i : I) → NonUnitalNormedRing (B i)],
AddSubmonoidClass (AddSubgroup (PreLp B)) (PreLp B) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss.0.Polynomial.Chebyshev.sumZeroes_T_of_not_dvd._simp_1_12 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
instNonemptyTypeName | Init.Dynamic | ∀ {α : Type u_1}, Nonempty (TypeName α) | null | true |
ArchimedeanClass.instSMulNat._proof_1 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] (n : ℕ) (x y : R),
ArchimedeanClass.mk x = ArchimedeanClass.mk y → ArchimedeanClass.mk (x ^ n) = ArchimedeanClass.mk (y ^ n) | null | false |
CategoryTheory.Limits.Fan.ext_hom_hom._to_dual_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : β → C}
{c₁ c₂ : CategoryTheory.Limits.Cofan f} (e : c₁.pt ≅ c₂.pt)
(w :
autoParam (∀ (b : β), c₁.inj b = CategoryTheory.CategoryStruct.comp (c₂.inj b) e.inv)
CategoryTheory.Limits.Fan.ext._auto_1),
(CategoryTheory.Limits.Cofan.ex... | null | false |
CategoryTheory.Limits.pushout.inl_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Epi g],
CategoryTheory.Epi (CategoryTheory.Limits.pushout.inl f g) | The pushout of an epimorphism is an epimorphism | true |
CategoryTheory.Functor.OplaxRightLinear.rec | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D'] →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Mo... | null | false |
CategoryTheory.Abelian.SpectralObject.fromOpcycles._proof_1 | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | null | false |
Concept.casesOn | Mathlib.Order.Concept | {α : Type u_2} →
{β : Type u_3} →
{r : α → β → Prop} →
{motive : Concept α β r → Sort u} →
(t : Concept α β r) →
((extent : Set α) →
(intent : Set β) →
(upperPolar_extent : upperPolar r extent = intent) →
(lowerPolar_intent : lowerPolar r int... | null | false |
AlgebraicGeometry.Proj.toLocallyRingedSpace | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] → (𝒜 : ℕ → σ) → [GradedRing 𝒜] → AlgebraicGeometry.LocallyRingedSpace | `Proj` of a graded ring as a `LocallyRingedSpace` | true |
EuclideanSpace.equiv | Mathlib.Analysis.InnerProductSpace.PiL2 | (ι : Type u_1) → (𝕜 : Type u_3) → [inst : RCLike 𝕜] → EuclideanSpace 𝕜 ι ≃L[𝕜] ι → 𝕜 | A shorthand for `PiLp.continuousLinearEquiv`. | true |
PFunctor.Approx.CofixA.noConfusion | Mathlib.Data.PFunctor.Univariate.M | {P : Sort u} →
{F : PFunctor.{uA, uB}} →
{a : ℕ} →
{t : PFunctor.Approx.CofixA F a} →
{F' : PFunctor.{uA, uB}} →
{a' : ℕ} →
{t' : PFunctor.Approx.CofixA F' a'} →
F = F' → a = a' → t ≍ t' → PFunctor.Approx.CofixA.noConfusionType P t t' | null | false |
List.take_succ_cons | Init.Data.List.Basic | ∀ {α : Type u} {a : α} {as : List α} {i : ℕ}, List.take (i + 1) (a :: as) = a :: List.take i as | null | true |
Lean.Compiler.LCNF.Code.del.elim | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
t.ctorIdx = 13 →
((fvarId : Lean.FVarId) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive_4 (Lean.Compiler.LCNF.... | null | false |
Lean.KVMap.Value.ctorIdx | Lean.Data.KVMap | {α : Type} → Lean.KVMap.Value α → ℕ | null | false |
List.findFinIdx?.go.match_1 | Init.Data.List.Basic | {α : Type u_1} →
(l : List α) →
(motive : (x : List α) → (x_1 : ℕ) → x.length + x_1 = l.length → Sort u_2) →
(x : List α) →
(x_1 : ℕ) →
(x_2 : x.length + x_1 = l.length) →
((x : ℕ) → (x_3 : [].length + x = l.length) → motive [] x x_3) →
((a : α) → (l_1 : List α) →... | null | false |
GrpCat.of.eq_1 | Mathlib.Algebra.Category.Grp.Basic | ∀ (M : Type u) [inst : Group M], ↧M = { carrier := M, str := inst } | null | true |
isClosed_empty._simp_1 | Mathlib.Topology.Basic | ∀ {X : Type u} [inst : TopologicalSpace X], IsClosed ∅ = True | null | false |
_private.Mathlib.Dynamics.TopologicalEntropy.NetEntropy.0.Dynamics.netMaxcard_infinite_iff._simp_1_3 | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
Int.Internal.Linear.Poly.combine'.match_1.congr_eq_2 | Init.Data.Int.Linear | ∀ (motive : Int.Internal.Linear.Poly → Int.Internal.Linear.Poly → Sort u_1) (p₁ p₂ : Int.Internal.Linear.Poly)
(h_1 : (k₁ k₂ : ℤ) → motive (Int.Internal.Linear.Poly.num k₁) (Int.Internal.Linear.Poly.num k₂))
(h_2 :
(k₁ a : ℤ) →
(x : Int.Internal.Linear.Var) →
(p : Int.Internal.Linear.Poly) → motiv... | null | true |
CategoryTheory.Limits.colimitConstInitial._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasInitial C],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.initial.to (CategoryTheory.Limits.colimit ((CategoryTheory.Functor.const J).obj... | null | false |
Submodule.CoFG.topologicalClosure | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : TopologicalSpace E] [inst_2 : Ring 𝕜]
[inst_3 : Module 𝕜 E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] (s : Submodule 𝕜 E) [s.CoFG],
s.topologicalClosure.CoFG | null | true |
EReal.coe_ennreal_ne_zero | Mathlib.Data.EReal.Basic | ∀ {x : ENNReal}, ↑x ≠ 0 ↔ x ≠ 0 | null | true |
Vector.range'_inj._simp_1 | Init.Data.Vector.Range | ∀ {s n s' : ℕ}, (Vector.range' s n = Vector.range' s' n) = (n = 0 ∨ s = s') | null | false |
_private.Mathlib.Data.List.Lookmap.0.List.lookmap_congr.match_1_1 | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} {f g : α → Option α} (motive : (x : List α) → (∀ a ∈ x, f a = g a) → Prop) (x : List α)
(x_1 : ∀ a ∈ x, f a = g a),
(∀ (x : ∀ a ∈ [], f a = g a), motive [] x) →
(∀ (a : α) (l : List α) (H : ∀ a_1 ∈ a :: l, f a_1 = g a_1), motive (a :: l) H) → motive x x_1 | null | false |
_private.Mathlib.Topology.Compactness.Lindelof.0.IsLindelof.elim_nhds_subcover._simp_1_3 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
IsOrderedCancelAddMonoid.le_of_add_le_add_right._default | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_2} {inst : AddCommMonoid α} {inst_1 : Preorder α},
(∀ (a b c : α), a + b ≤ a + c → b ≤ c) → ∀ (a b c : α), b + a ≤ c + a → b ≤ c | null | false |
UniformSpace.Completion.commRing | Mathlib.Topology.Algebra.UniformRing | (R : Type u_2) →
[inst : CommRing R] →
[inst_1 : UniformSpace R] → [IsUniformAddGroup R] → [IsTopologicalRing R] → CommRing (UniformSpace.Completion R) | null | true |
IsRelPrime.of_mul_left_left | Mathlib.Algebra.Divisibility.Units | ∀ {α : Type u_1} [inst : CommMonoid α] {x y z : α}, IsRelPrime (x * y) z → IsRelPrime x z | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.elim.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr), sizeOf (Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.elim c) = 1 + sizeOf c | null | true |
Mathlib.Tactic.Bicategory.Context.level₁ | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Mathlib.Tactic.Bicategory.Context → Lean.Level | The level for 1-morphisms. | true |
toDual_min | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : LinearOrder α] (a b : α),
OrderDual.toDual (min a b) = max (OrderDual.toDual a) (OrderDual.toDual b) | null | true |
_aux_Init_Control_Basic___unexpand_andM_1 | Init.Control.Basic | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.Endofunctor.Algebra.comp_eq_comp | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{A₀ A₁ A₂ : CategoryTheory.Endofunctor.Algebra F} (f : A₀ ⟶ A₁) (g : A₁ ⟶ A₂),
CategoryTheory.Endofunctor.Algebra.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g | null | true |
CategoryTheory.MonoOver.isColimitCoconeOfHasStrongEpiMonoFactorisation._proof_1 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Y : C} [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Limits.HasStrongEpiMonoFactorisations C] {J : Type u_3}
[inst_3 : CategoryTheory.Category.{u_4, u_3} J] (F : CategoryTheory.Functor J (CategoryTheory.MonoOver Y))
(c : C... | null | false |
CategoryTheory.CartesianMonoidalCategory.lift_braiding_inv_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {T X Y : C} (f : T ⟶ X) (g : T ⟶ Y) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y X ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.C... | null | true |
_private.Mathlib.Algebra.Group.Pointwise.Set.Basic.0.Set.prod_pow.match_1_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
IsAddUnit.add_neg_cancel_right | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : SubtractionMonoid α] {b : α}, IsAddUnit b → ∀ (a : α), a + b + -b = a | null | true |
CategoryTheory.Oplax.LaxTrans.Modification.naturality | 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} (self : CategoryTheory.Oplax.LaxTrans.Modification η θ)
{a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight ... | The naturality condition. | true |
StalkSkyscraperPresheafAdjunctionAuxs.counit | Mathlib.Topology.Sheaves.Skyscraper | {X : TopCat} →
(p₀ : ↑X) →
[inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] →
{C : Type v} →
[inst_1 : CategoryTheory.Category.{u, v} C] →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
[inst_3 : CategoryTheory.Limits.HasColimits C] →
(skyscraperPre... | The counit in `Presheaf.stalkFunctor ⊣ skyscraperPresheafFunctor`
| true |
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Localization.0.Module.associatedPrimes.mem_associatedPrimes_of_comap_mem_associatedPrimes_of_isLocalizedModule.match_1_7 | Mathlib.RingTheory.Ideal.AssociatedPrime.Localization | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : M) (r : R) (motive : (∃ n s', s' • r ^ n • x = 0) → Prop) (x_1 : ∃ n s', s' • r ^ n • x = 0),
(∀ (n : ℕ) (t : ↥S) (ht : t • r ^ n • x = 0), motive ⋯) → motive x_1 | null | false |
CategoryTheory.Limits.Pi.isoLimit_inv_π_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete α) C)
[inst_1 : CategoryTheory.Limits.HasCoproduct fun j => X.obj { as := j }] [inst_2 : CategoryTheory.Limits.HasColimit X]
(j : α) {Z : C} (h : Z ⟶ X.obj { as := j }),
CategoryTheory.Cat... | null | false |
deriv_div_const | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_2} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c : 𝕜 → 𝕜'} (d : 𝕜'), deriv (fun x => c x / d) x = deriv c x / d | null | true |
exists_orderEmbedding_covby_of_forall_covby_finite_of_bot | Mathlib.Order.KonigLemma | ∀ {α : Type u_1} [inst : PartialOrder α] [IsStronglyAtomic α] [inst_2 : OrderBot α] [Infinite α],
(∀ (a : α), {x | a ⋖ x}.Finite) → ∃ f, f 0 = ⊥ ∧ ∀ (i : ℕ), f i ⋖ f (i + 1) | A version of Kőnig's lemma where the sequence starts at the minimum of an infinite order. | true |
List.sectionsTR | Batteries.Data.List.Basic | {α : Type u_1} → List (List α) → List (List α) | Optimized version of `sections`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.neighborSet_bot._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} {v : V}, ⊥.neighborSet v = ∅ | null | false |
CategoryTheory.Comma.preLeft_obj_hom | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {C : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} C] (F : CategoryTheory.Functor C A) (L : CategoryTheory.Functor A T)
(R : Cat... | null | true |
NumberField.place | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | {K : Type u_1} → [inst : Field K] → {A : Type u_2} → [inst_1 : NormedDivisionRing A] → (K →+* A) → AbsoluteValue K ℝ | An embedding into a normed division ring defines a place of `K` | true |
hasSum_sq_fourierCoeffOn | Mathlib.Analysis.Fourier.AddCircle | ∀ {a b : ℝ} {f : ℝ → ℂ} (hab : a < b),
MeasureTheory.MemLp f 2 (MeasureTheory.volume.restrict (Set.Ioc a b)) →
HasSum (fun i => ‖fourierCoeffOn hab f i‖ ^ 2) ((b - a)⁻¹ • ∫ (x : ℝ) in a..b, ‖f x‖ ^ 2) | **Parseval's identity**: for a function `f` which is square integrable on `(a,b]`,
the sum of the squared norms of the Fourier coefficients equals the `L²` norm of `f`. | true |
CoalgCat.rec | Mathlib.Algebra.Category.CoalgCat.Basic | {R : Type u} →
[inst : CommRing R] →
{motive : CoalgCat R → Sort u_1} →
((toModuleCat : ModuleCat R) →
(instCoalgebra : Coalgebra R ↑toModuleCat) →
motive { toModuleCat := toModuleCat, instCoalgebra := instCoalgebra }) →
(t : CoalgCat R) → motive t | null | false |
coborder.eq_1 | Mathlib.Topology.LocallyClosed | ∀ {X : Type u} [inst : TopologicalSpace X] (s : Set X), coborder s = (closure s \ s)ᶜ | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Span.Basic.0.CategoryTheory.Span.SpanBicat.rightUnitor._proof_3 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
List.filterM_toArray' | Init.Data.Array.Monadic | ∀ {m : Type → Type u_1} {α : Type} {stop : ℕ} [inst : Monad m] [LawfulMonad m] {l : List α} {p : α → m Bool},
stop = l.length → Array.filterM p l.toArray 0 stop = List.toArray <$> List.filterM p l | Variant of `filterM_toArray` with a side condition for the stop position. | true |
MaxTropical.injective_trop | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u}, Function.Injective MaxTropical.trop | null | true |
Std.Symm.iff | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Symm r] (x y : α), r x y ↔ r y x | null | true |
AbsolutelyContinuousOnInterval.hasBasis_totalLengthFilter | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {X : Type u_1} [inst : PseudoMetricSpace X],
AbsolutelyContinuousOnInterval.totalLengthFilter.HasBasis (fun ε => 0 < ε) fun ε =>
{E | ∑ i ∈ Finset.range E.1, dist (E.2 i).1 (E.2 i).2 < ε} | null | true |
_private.Mathlib.CategoryTheory.Sites.Point.Skyscraper.0.CategoryTheory.GrothendieckTopology.Point.presheafToSheafCompSheafFiberIso._simp_2 | Mathlib.CategoryTheory.Sites.Point.Skyscraper | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
Lean.Elab.Term.instInhabitedDiscr.default | Lean.Elab.Match | Lean.Elab.Term.Discr | null | true |
Fin.inv_partialProd_mul_eq_contractNth | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} {G : Type u_3} [inst : Group G] (g : Fin (n + 1) → G) (j : Fin (n + 1)) (k : Fin n),
(Fin.partialProd g (j.succ.succAbove k.castSucc))⁻¹ * Fin.partialProd g (j.succAbove k).succ =
j.contractNth (fun x1 x2 => x1 * x2) g k | Let `(g₀, g₁, ..., gₙ)` be a tuple of elements in `Gⁿ⁺¹`.
Then if `k < j`, this says `(g₀g₁...gₖ₋₁)⁻¹ * g₀g₁...gₖ = gₖ`.
If `k = j`, it says `(g₀g₁...gₖ₋₁)⁻¹ * g₀g₁...gₖ₊₁ = gₖgₖ₊₁`.
If `k > j`, it says `(g₀g₁...gₖ)⁻¹ * g₀g₁...gₖ₊₁ = gₖ₊₁.`
Useful for defining group cohomology. | true |
_private.Lean.Elab.Tactic.Omega.Frontend.0.Lean.Elab.Tactic.Omega.formatErrorMessage.varNameOf | Lean.Elab.Tactic.Omega.Frontend | ℕ → String | null | true |
Function.sometimes_spec | Mathlib.Logic.Function.Basic | ∀ {p : Prop} {α : Sort u_1} [inst : Nonempty α] (P : α → Prop) (f : p → α) (a : p), P (f a) → P (Function.sometimes f) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.