name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Order.coheight | Mathlib.Order.KrullDimension | {α : Type u_1} → [Preorder α] → α → ℕ∞ | The **coheight** of an element `a` in a preorder `α` is the supremum of the rightmost index of all
relation series of `α` ordered by `<` and beginning with `a`. In other words, it is
the largest `n` such that there's a series `a = a₀ < a₁ < ... < aₙ` (or `∞` if there is
no largest `n`).
The definition of `coheight` is... | true |
MonotoneOn._to_dual_cast_4 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
MonotoneOn f s = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → b ≤ a → f b ≤ f a | null | false |
Std.TreeMap.maxKey!_modify_eq_maxKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
[inst : Inhabited α] {k : α} {f : β → β}, (t.modify k f).maxKey! = t.maxKey! | null | true |
FirstOrder.Language.Ultraproduct.structure._aux_3 | Mathlib.ModelTheory.Ultraproducts | {α : Type u_1} →
{M : α → Type u_2} →
{u : Ultrafilter α} →
{L : FirstOrder.Language} →
[(a : α) → L.Structure (M a)] →
autoParam ({n : ℕ} → L.Relations n → (Fin n → (↑u).Product M) → Prop)
FirstOrder.Language.Structure.RelMap._autoParam | null | false |
WithBot.sumHomeomorph.match_1 | Mathlib.Topology.Order.WithTop | (ι : Type u_1) →
(motive : ι ⊕ Unit → Sort u_2) →
(x : ι ⊕ Unit) → ((i : ι) → motive (Sum.inl i)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x | null | false |
SimpleGraph.EdgeLabeling.labelGraph | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | {V : Type u_1} → {G : SimpleGraph V} → {K : Type u_3} → G.EdgeLabeling K → K → SimpleGraph V | Given an edge labeling and a choice of label `k`, construct the graph corresponding to the edges
labeled `k`.
| true |
Array.mk._flat_ctor | Init.Prelude | {α : Type u} → List α → Array α | null | false |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId_left_H | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j : ι} (f : i ⟶ j) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObjec... | null | true |
CategoryTheory.Lax.LaxTrans.StrongCore.naturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{η : F ⟶ G} →
CategoryTheory.Lax.LaxTrans.StrongCore η →
{a b : B} →
(f : a ⟶ b) →
... | The underlying 2-isomorphisms of the naturality constraint. | true |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux | Mathlib.CategoryTheory.Sites.CoverLifting | {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] →
{G : CategoryTheory.Functor C D} →
{A : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} A] →
{J : CategoryTheory.GrothendieckTop... | Auxiliary definition for `lift`. | true |
Pi.nonAssocRing._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonAssocRing (f i)] (a : (i : I) → f i), a * 1 = a | null | false |
_private.BatteriesRecycling.RBTree.Lemmas.0.RBTree.RBNode.ins.match_1.eq_3 | BatteriesRecycling.RBTree.Lemmas | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.gt)
(h_3 : Unit → motive Ordering.eq),
(match Ordering.eq with
| Ordering.lt => h_1 ()
| Ordering.gt => h_2 ()
| Ordering.eq => h_3 ()) =
h_3 () | null | true |
_private.Mathlib.Condensed.Discrete.LocallyConstant.0.CompHausLike.LocallyConstant.adjunction._proof_2 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [inst : CompHausLike.HasExplicitFiniteCoproducts P] [inst_1 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f))
(X : CategoryTheory.Sheaf (CategoryTheory.coher... | null | false |
groupCohomology.cocycles₁IsoOfIsTrivial._proof_6 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_2, u_1, u_1} k G) [hA : A.IsTrivial]
(x x_1 : ↥(groupCohomology.cocycles₁ A)),
{ toFun := ⇑(x + x_1) ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ } =
{ toFun := ⇑(x + x_1) ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ } | null | false |
ContinuousWithinAt.sub | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u_1} {X : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace G] [inst_2 : Sub G]
[ContinuousSub G] {f g : X → G} {s : Set X} {x : X},
ContinuousWithinAt f s x → ContinuousWithinAt g s x → ContinuousWithinAt (fun x => f x - g x) s x | null | true |
Lean.Parser.Term.arrow.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
isOpen_range_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpen (Set.range (Sigma.mk i)) | null | true |
definition._@.Mathlib.Topology.FiberBundle.Constructions.1875155857._hygCtx._hyg.8 | Mathlib.Topology.FiberBundle.Constructions | {B : Type u} →
(F : Type v) →
(E : B → Type w₁) →
{B' : Type w₂} →
(f : B' → B) →
[TopologicalSpace B'] →
[TopologicalSpace (Bundle.TotalSpace F E)] → TopologicalSpace (Bundle.TotalSpace F (f *ᵖ E)) | null | false |
Matrix.toBilin'_apply | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} [inst : CommSemiring R₁] {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix n n R₁) (x y : n → R₁), ((Matrix.toBilin' M) x) y = ∑ i, ∑ j, x i * M i j * y j | null | true |
MeasureTheory.Measure.sub_self | Mathlib.MeasureTheory.Measure.Sub | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ - μ = 0 | null | true |
LieModule.chainBotCoeff | Mathlib.Algebra.Lie.Weights.Chain | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
{M : Type u_3} →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L... | This is the largest `n : ℕ` such that `-i • α + β` is a weight for all `0 ≤ i ≤ n`. | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkRichHCongr.withNewEqs | Mathlib.Lean.Meta.CongrTheorems | Lean.Meta.FunInfo →
{α : Type} →
Array Lean.Expr →
Array Lean.Expr →
Array Bool →
(Array Lean.Meta.CongrArgKind → Array (Option (Lean.Expr × Lean.Expr × Lean.Expr)) → Lean.MetaM α) →
Lean.MetaM α | Introduce variables for equalities between the arrays of variables. Uses `fixedParams`
to control whether to introduce an equality for each pair. The array of triples passed to `k`
consists of (1) the simple congr lemma HEq arg, (2) the richer HEq arg, and (3) how to
compute 1 in terms of 2. | true |
AddCommGrpCat.image.lift._proof_2 | Mathlib.Algebra.Category.Grp.Images | ∀ {G H : AddCommGrpCat} {f : G ⟶ H} (F' : CategoryTheory.Limits.MonoFactorisation f)
(x y : ↥(AddCommGrpCat.Hom.hom f).range),
(CategoryTheory.ConcreteCategory.hom F'.e)
↑(Classical.indefiniteDescription (fun x_1 => (AddCommGrpCat.Hom.hom f) x_1 = ↑(x + y)) ⋯) =
(CategoryTheory.ConcreteCategory.hom F'.e)
... | null | false |
_private.Mathlib.Algebra.Lie.Submodule.0.LieSubmodule.instInfSet._simp_2 | Mathlib.Algebra.Lie.Submodule | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
forall_isClosed_iff | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {p : Set X → Prop},
(∀ (t : Set X), IsClosed t → p t) ↔ ∀ (t : Set X), p (closure t) | null | true |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.compactSpace_iff_completeSpace_and_isDiscreteValuationRing_and_finite_residueField.match_1_1 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} {Γ₀ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [inst_2 : Valued K Γ₀]
(motive :
CompleteSpace ↥(Valued.integer K) ∧ IsDiscreteValuationRing ↥(Valued.integer K) ∧ Finite (Valued.ResidueField K) →
Prop)
(x :
CompleteSpace ↥(Valued.integer K) ∧ IsDiscreteVa... | null | false |
KaehlerDifferential.isBaseChange | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTow... | If `B` is the tensor product of `S` and `A` over `R`,
then `Ω[B⁄S]` is the base change of `Ω[A⁄R]` along `R → S`.
| true |
_private.Std.Time.DateTime.PlainDateTime.0.Std.Time.PlainDateTime.ofWallTime._proof_2 | Std.Time.DateTime.PlainDateTime | ∀ (stamp : Std.Time.WallTime),
↑(Std.Time.Internal.Bounded.LE.byMod stamp.toNanoseconds.val 1000000000 Std.Time.PlainDateTime.ofWallTime._proof_1✝) <
0 →
↑(Std.Time.Internal.Bounded.LE.byMod stamp.toNanoseconds.val 1000000000
Std.Time.PlainDateTime.ofWallTime._proof_1✝) ≤
0 - 1 | null | false |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.DoOps.default._sparseCasesOn_4 | Lean.Elab.Do.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
MeasCat.instLargeCategory._proof_5 | Mathlib.MeasureTheory.Category.MeasCat | ∀ {X Y Z : MeasCat} (f : { f // Measurable f }) (g : { f // Measurable f }), Measurable (↑g ∘ ↑f) | null | false |
Filter.tendsto_neg_atTop_iff._simp_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] {l : Filter α}
{f : α → G}, Filter.Tendsto (fun x => -f x) l Filter.atTop = Filter.Tendsto f l Filter.atBot | null | false |
spectralAlgNorm_extends | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ {K : Type u_2} [inst : NormedField K] {L : Type u_3} [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsUltrametricDist K] [h_alg : Algebra.IsAlgebraic K L] (k : K),
(spectralAlgNorm K L) ((algebraMap K L) k) = ‖k‖ | null | true |
FundamentalGroupoid.eqToHom_eq | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} (h : x₀ = x₁),
CategoryTheory.eqToHom ⋯ = (Path.Homotopic.Quotient.refl x₁).cast h ⋯ | null | true |
SimplexCategory.δ_one_eq_const | Mathlib.AlgebraicTopology.SimplexCategory.Basic | SimplexCategory.δ 1 = { len := 0 }.const { len := 0 + 1 } 0 | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology.0.CochainComplex.HomComplex.CohomologyClass.toHom._simp_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {G : Type u_1} [inst : AddGroup G] {M : Type u_7} [inst_1 : AddZeroClass M] {f : G →+ M} {x : G},
(x ∈ f.ker) = (f x = 0) | null | false |
Semiquot.blur'._proof_1 | Mathlib.Data.Semiquot | ∀ {α : Type u_1} (q : Semiquot α) {s : Set α}, q.s ⊆ s → ∀ (a : ↑q.s), ↑a ∈ s | null | false |
Matrix.spectrum_toLpLin | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
(p : ENNReal), spectrum 𝕜 ((Matrix.toLpLin p p) A) = spectrum 𝕜 A | The spectrum of a matrix `A` coincides with the spectrum of `toLpLin p p A`. | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.EqInfo.noConfusion | Lean.Meta.CongrTheorems | {P : Sort u} → {t t' : Lean.Meta.EqInfo✝} → t = t' → Lean.Meta.EqInfo.noConfusionType✝ P t t' | null | false |
Lean.Meta.Sym.SymExtension.id | Lean.Meta.Sym.SymM | {σ : Type} → Lean.Meta.Sym.SymExtension σ → ℕ | null | true |
List.max?_toArray | Init.Data.Array.MinMax | ∀ {α : Type u_1} [inst : Max α] {l : List α}, l.toArray.max? = l.max? | null | true |
Cardinal.lift_le_aleph1 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {c : Cardinal.{u}}, Cardinal.lift.{v, u} c ≤ Cardinal.aleph 1 ↔ c ≤ Cardinal.aleph 1 | **Alias** of `Cardinal.lift_le_aleph_one`. | true |
_private.Mathlib.Data.Fintype.Pi.0.Set.iUnion_snoc._simp_1_2 | Mathlib.Data.Fintype.Pi | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) | null | false |
Std.ExtDTreeMap.diff.congr_simp | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (m₁ m₁_1 : Std.ExtDTreeMap α β cmp),
m₁ = m₁_1 → ∀ (m₂ m₂_1 : Std.ExtDTreeMap α β cmp), m₂ = m₂_1 → m₁.diff m₂ = m₁_1.diff m₂_1 | null | true |
Units.instIsManifoldModelWithCornersSelf | Mathlib.Geometry.Manifold.Instances.UnitsOfNormedAlgebra | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : CompleteSpace R] {n : WithTop ℕ∞} {𝕜 : Type u_2}
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedAlgebra 𝕜 R], IsManifold (modelWithCornersSelf 𝕜 R) n Rˣ | null | true |
Concept.instSupSet | Mathlib.Order.Concept | {α : Type u_2} → {β : Type u_3} → {r : α → β → Prop} → SupSet (Concept α β r) | null | true |
CategoryTheory.ConcreteCategory.homEquiv | Mathlib.CategoryTheory.ConcreteCategory.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{FC : C → C → Type u_1} →
{CC : C → Type w} →
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] →
[inst_2 : CategoryTheory.ConcreteCategory C FC] → {X Y : C} → (X ⟶ Y) ≃ CategoryTheory.ToHom X Y | `ConcreteCategory.hom` bundled as an `Equiv`.
| true |
Lean.Meta.DiscrTree.Key.star | Lean.Meta.DiscrTree.Types | Lean.Meta.DiscrTree.Key | null | true |
CategoryTheory.Limits.image.map | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{f g : CategoryTheory.Arrow C} →
[inst_1 : CategoryTheory.Limits.HasImage f.hom] →
[inst_2 : CategoryTheory.Limits.HasImage g.hom] →
(sq : f ⟶ g) →
[CategoryTheory.Limits.HasImageMap sq] →
CategoryTheory.L... | The map on images induced by a commutative square. | true |
groupCohomology.coboundaries₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → (A : Rep.{max u u_1, u, u} k G) → Submodule k (G → ↑A) | The 1-coboundaries `B¹(G, A)` of `A : Rep k G`, defined as the image of the map
`A → Fun(G, A)` sending `(a, g) ↦ ρ_A(g)(a) - a.` | true |
FirstOrder.Language.BoundedFormula.listEncode.eq_def | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u'} (x : ℕ) (x_1 : L.BoundedFormula α x),
x_1.listEncode =
match x, x_1 with
| n, FirstOrder.Language.BoundedFormula.falsum => [Sum.inr (Sum.inr (n + 2))]
| x, FirstOrder.Language.BoundedFormula.equal t₁ t₂ => [Sum.inl ⟨x, t₁⟩, Sum.inl ⟨x, t₂⟩]
| n, FirstOrder.Lan... | null | true |
MvQPF.WEquiv.below.trans | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n}
{motive : (a a_1 : (MvQPF.P F).W α) → MvQPF.WEquiv a a_1 → Prop} (u v w : (MvQPF.P F).W α) (a : MvQPF.WEquiv u v)
(a_1 : MvQPF.WEquiv v w),
MvQPF.WEquiv.below a → motive u v a → MvQPF.WEquiv.below a_1 → motive v w a_1 → MvQPF.WEquiv.be... | null | true |
Multiset.nodup_zero | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1}, Multiset.Nodup 0 | null | true |
_private.Mathlib.Order.Category.DistLat.0.DistLat.Hom.mk._flat_ctor | Mathlib.Order.Category.DistLat | {X Y : DistLat} → LatticeHom ↑X ↑Y → X.Hom Y | null | false |
Lean.Server.LoadedILean.refs | Lean.Server.References | Lean.Server.LoadedILean → Lean.Lsp.ModuleRefs | Reference information from this ILean. | true |
hasFDerivAt_pi_polarCoord_symm | Mathlib.Analysis.SpecialFunctions.PolarCoord | ∀ {ι : Type u_1} [Finite ι] (p : ι → ℝ × ℝ),
HasFDerivAt (fun x i => ↑polarCoord.symm (x i)) (fderivPiPolarCoordSymm p) p | null | true |
Std.DTreeMap.size_emptyc | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}, ∅.size = 0 | null | true |
WithZero.coe_mul | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Mul α] (a b : α), ↑(a * b) = ↑a * ↑b | null | true |
Lean.Elab.Tactic.Conv.evalNestedTacticCore | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.Tactic | null | true |
IsDiscrete.recOn | Mathlib.Topology.Constructions | {X : Type u_5} →
[inst : TopologicalSpace X] →
{s : Set X} →
{motive : IsDiscrete s → Sort u} → (t : IsDiscrete s) → ((to_subtype : DiscreteTopology ↑s) → motive ⋯) → motive t | null | false |
MultilinearMap.ofSubsingleton_apply_apply | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ (R : Type uR) {ι : Type uι} (M₂ : Type v₂) (M₃ : Type v₃) [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] [inst_5 : Subsingleton ι] (i : ι)
(f : M₂ →ₗ[R] M₃) (x : ι → M₂), ((MultilinearMap.ofSubsingleton R M₂ M₃ i) f) x = f (x i) | null | true |
Multiset.prod_hom_rel | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {ι : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommMonoid M] [inst_1 : CommMonoid N] (s : Multiset ι)
{r : M → N → Prop} {f : ι → M} {g : ι → N},
r 1 1 → (∀ ⦃a : ι⦄ ⦃b : M⦄ ⦃c : N⦄, r b c → r (f a * b) (g a * c)) → r (Multiset.map f s).prod (Multiset.map g s).prod | null | true |
RestrictedProduct.nhds_zero_eq_map_ofPre | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} (R : ι → Type u_2) {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)] {B : (i : ι) → S i}
{T : Set ι} [inst_1 : (i : ι) → TopologicalSpace (R i)] [inst_2 : (i : ι) → Zero (R i)]
[inst_3 : ∀ (i : ι), ZeroMemClass (S i) (R i)],
(∀ (i : ι), IsOpen ↑(B i)) →
∀ (hT : Filter.cofinite ≤ Filte... | null | true |
UInt64.add_eq_right | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a + b = b ↔ a = 0 | null | true |
EReal.nhds_top | Mathlib.Topology.Instances.EReal.Lemmas | nhds ⊤ = ⨅ a, ⨅ (_ : a ≠ ⊤), Filter.principal (Set.Ioi a) | null | true |
DirectSum.instNonUnitalNonAssocRingOfNat._proof_8 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddZeroClass ι] (x : ℤ) (x_1 : A 0), (DirectSum.of A 0) (x • x_1) = x • (DirectSum.of A 0) x_1 | null | false |
FreeAbelianGroup.ofMulHom_coe | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u} [inst : Monoid α], ⇑FreeAbelianGroup.ofMulHom = FreeAbelianGroup.of | null | true |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.posGE._unary.eq_def | Init.Data.String.Lemmas.FindPos | ∀ (s : String.Slice) (_x : (offset : String.Pos.Raw) ×' offset ≤ s.rawEndPos),
String.Slice.posGE._unary s _x =
PSigma.casesOn _x fun offset h =>
if h' : String.Pos.Raw.IsValidForSlice s offset then s.pos offset h'
else
have this := ⋯;
String.Slice.posGE._unary s ⟨offset.inc, ⋯⟩ | null | false |
Std.Time.Database.TZdb | Std.Time.Zoned.Database.TZdb | Type | Represents a Time Zone Database (TZdb) configuration with paths to local and general timezone data.
| true |
NumberField.InfinitePlace.Completion.WithAbs.ratCast_equiv | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ (v : NumberField.InfinitePlace ℚ) (x : WithAbs ↑v), ↑((WithAbs.equiv ↑v) x) = ↑x | The coercion from the rationals to its completion along an infinite place is `Rat.cast`. | true |
HomologicalComplex.mkHomFromDouble_f₁ | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X₀ X₁ : C} {f : X₀ ⟶ X₁} {ι : Type u_2} {c : ComplexShape ι}
{i₀ i₁ : ι} (hi₀₁ : c.Rel i₀ i₁) (h : i₀ ≠ i₁) {K : HomologicalComplex C c} (φ₀ : X₀ ⟶ K.X... | null | true |
Lean.Parser.ParserInfo.collectTokens | Lean.Parser.Types | Lean.Parser.ParserInfo → List Lean.Parser.Token → List Lean.Parser.Token | null | true |
Lean.Meta.State._sizeOf_inst | Lean.Meta.Basic | SizeOf Lean.Meta.State | null | false |
CategoryTheory.Presieve.FamilyOfElements.Compatible.to_sieveCompatible | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
{S : CategoryTheory.Sieve X} {x : CategoryTheory.Presieve.FamilyOfElements P S.arrows},
x.Compatible → x.SieveCompatible | null | true |
isInteger_of_is_root_of_monic | Mathlib.RingTheory.Polynomial.RationalRoot | ∀ {A : Type u_1} {K : Type u_2} [inst : CommRing A] [IsDomain A] [UniqueFactorizationMonoid A] [inst_3 : Field K]
[inst_4 : Algebra A K] [IsFractionRing A K] {p : Polynomial A},
p.Monic → ∀ {r : K}, (Polynomial.aeval r) p = 0 → IsLocalization.IsInteger A r | **Integral root theorem**:
if `r : f.codomain` is a root of a monic polynomial over the ufd `A`,
then `r` is an integer | true |
Lean.Elab.Tactic.BVDecide.Frontend.State.mk.injEq | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | ∀ (atoms : Std.HashMap Lean.Expr Lean.Elab.Tactic.BVDecide.Frontend.Atom) (atomsAssignmentCache : Option Lean.Expr)
(evalsAtCache : Std.HashMap Lean.Expr (Option Lean.Expr))
(atoms_1 : Std.HashMap Lean.Expr Lean.Elab.Tactic.BVDecide.Frontend.Atom) (atomsAssignmentCache_1 : Option Lean.Expr)
(evalsAtCache_1 : Std.... | null | true |
ShiftLeft.recOn | Init.Prelude | {α : Type u} →
{motive : ShiftLeft α → Sort u_1} →
(t : ShiftLeft α) → ((shiftLeft : α → α → α) → motive { shiftLeft := shiftLeft }) → motive t | null | false |
ENat.sSup_mul | Mathlib.Data.ENat.Lattice | ∀ {s : Set ℕ∞} {a : ℕ∞}, sSup s * a = ⨆ b ∈ s, b * a | null | true |
List.dropLast_prefix | Init.Data.List.Sublist | ∀ {α : Type u_1} (l : List α), l.dropLast <+: l | null | true |
AddUnits.instAddCommGroupAddUnits | Mathlib.Algebra.Group.Units.Defs | {α : Type u_1} → [inst : AddCommMonoid α] → AddCommGroup (AddUnits α) | Additive units of an additive commutative monoid form
an additive commutative group. | true |
_private.Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter.0.CategoryTheory.SimplicialObject.σ₀Iter_δ₀Iter._simp_1_3 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {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 |
_private.Mathlib.LinearAlgebra.CliffordAlgebra.Even.0.CliffordAlgebra.even.lift.fFold._proof_8 | Mathlib.LinearAlgebra.CliffordAlgebra.Even | ∀ {R : Type u_3} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} {A : Type u_1} [inst_3 : Ring A] [inst_4 : Algebra R A] (f : CliffordAlgebra.EvenHom Q A)
(x : M) (x_1 x_2 : A × ↥(CliffordAlgebra.even.lift.S✝ f)),
(↑(x_1 + x_2).2 x, ⟨LinearMap.mulRight R ... | null | false |
_private.Std.Http.Protocol.H1.Reader.0.Std.Http.Protocol.H1.Reader.instBEqBodyState.beq._sparseCasesOn_4 | Std.Http.Protocol.H1.Reader | {motive : Std.Http.Protocol.H1.Reader.BodyState → Sort u} →
(t : Std.Http.Protocol.H1.Reader.BodyState) →
motive Std.Http.Protocol.H1.Reader.BodyState.closeDelimited → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Internal.Impl.get?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.LawfulEqOrd α] (k : α),
Std.DTreeMap.Internal.Impl.leaf.get? k = none | null | true |
BoxIntegral.Prepartition.distortion_le_of_mem | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) [inst : Fintype ι],
J ∈ π → J.distortion ≤ π.distortion | null | true |
BitVec.toInt_eq_toNat_of_lt | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x : BitVec n}, 2 * x.toNat < 2 ^ n → x.toInt = ↑x.toNat | null | true |
preimage_map_fst_pullbackDiagonal | Mathlib.Data.Set.Prod | ∀ {X : Type u_2} {Y : Sort u_3} {Z : Type u_1} {f : X → Y} {g : Z → Y},
Function.PullbackSelf.map_fst ⁻¹' Function.pullbackDiagonal f = Function.pullbackDiagonal Function.Pullback.snd | null | true |
HomotopicalAlgebra.CofibrantObject.HoCat.adjUnit._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x : HomotopicalAlgebra.CofibrantObject C), HomotopicalAlgebra.cofibrantObjects C x.bifibrantResolutionObj.obj | null | false |
DomMulAct.mk_pow | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : Monoid M] (a : M) (n : ℕ), DomMulAct.mk (a ^ n) = DomMulAct.mk a ^ n | null | true |
_private.Mathlib.Topology.Algebra.Group.Matrix.0.Matrix.SpecialLinearGroup.range_toGL.match_1_2 | Mathlib.Topology.Algebra.Group.Matrix | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {A : Type u_2} [inst_2 : CommRing A] (x : GL n A)
(motive : (∃ y, ↑y = ↑x) → Prop) (x_1 : ∃ y, ↑y = ↑x),
(∀ (y : Matrix.SpecialLinearGroup n A) (hy : ↑y = ↑x), motive ⋯) → motive x_1 | null | false |
Lean.Lsp.CodeAction.title | Lean.Data.Lsp.CodeActions | Lean.Lsp.CodeAction → String | A short, human-readable, title for this code action. | true |
Matroid.RankFinite | Mathlib.Combinatorics.Matroid.Basic | {α : Type u_1} → Matroid α → Prop | A `RankFinite` matroid is one whose bases are finite | true |
CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId_hom_app_app | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (A : Type u₁) [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
[inst_2 : CategoryTheory.Limits.HasProducts A] (X : CategoryTheory.Functor Cᵒᵖ A) (X_1 : Cᵒᵖ),
((CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId C A).hom.app X).app X_1 =
CategoryTheory.... | null | true |
Group.nilpotent_of_surjective | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] {G' : Type u_2} [inst_1 : Group G'] [h : Group.IsNilpotent G] (f : G →* G'),
Function.Surjective ⇑f → Group.IsNilpotent G' | The range of a surjective homomorphism from a nilpotent group is nilpotent. | true |
Real.exists_seq_rat_strictAnti_tendsto | Mathlib.Topology.Instances.Real.Lemmas | ∀ (x : ℝ), ∃ u, StrictAnti u ∧ (∀ (n : ℕ), x < ↑(u n)) ∧ Filter.Tendsto (fun x => ↑(u x)) Filter.atTop (nhds x) | null | true |
PadicInt.intCast_eq | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (z1 z2 : ℤ), ↑z1 = ↑z2 ↔ z1 = z2 | null | true |
Set.monoid._proof_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_1} [inst : Monoid α] (x : Set α), npowRecAuto 0 x = 1 | null | false |
List.le_apply_get_maxOn?_of_mem | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {f : α → β}
{xs : List α} {x : α} (h : x ∈ xs), f x ≤ f ((List.maxOn? f xs).get ⋯) | null | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.EqInfo._sizeOf_inst | Lean.Meta.CongrTheorems | SizeOf Lean.Meta.EqInfo✝ | null | false |
SetLike.GradeZero.instRing._proof_9 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {σ : Type u_2} {R : Type u_1} [inst : Ring R] [inst_1 : AddMonoid ι] [inst_2 : SetLike σ R]
[inst_3 : AddSubgroupClass σ R] (A : ι → σ) [inst_4 : SetLike.GradedMonoid A],
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
OrderIso.sumLexAssoc_apply_inl_inr | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] [inst_2 : LE γ] (b : β),
(OrderIso.sumLexAssoc α β γ) (toLex (Sum.inl (toLex (Sum.inr b)))) = toLex (Sum.inr (toLex (Sum.inl b))) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.