name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Int64.toUInt64_neg | Init.Data.SInt.Lemmas | ∀ (a : Int64), (-a).toUInt64 = -a.toUInt64 | null | true |
Finset.prod_le_one₀ | Mathlib.Algebra.Order.BigOperators.GroupWithZero.Finset | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommMonoidWithZero R] [inst_1 : Preorder R] [ZeroLEOneClass R] [PosMulMono R]
{f : ι → R} {s : Finset ι}, (∀ i ∈ s, 0 ≤ f i) → (∀ i ∈ s, f i ≤ 1) → ∏ i ∈ s, f i ≤ 1 | If each `f i`, `i ∈ s` belongs to `[0, 1]`, then their product is less than or equal to one.
See also `Finset.prod_le_one` for the case of an ordered commutative multiplicative monoid. | true |
Multipliable.tprod_subtype_mul_tprod_subtype_compl | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : CommGroup α] [IsUniformGroup α] [CompleteSpace α]
[T2Space α] {f : β → α}, Multipliable f → ∀ (s : Set β), (∏' (x : ↑s), f ↑x) * ∏' (x : ↑sᶜ), f ↑x = ∏' (x : β), f x | null | true |
_private.Mathlib.RepresentationTheory.Continuous.TopRep.0.TopRep.Hom.ext.match_1 | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u_1} {G : Type u_2} {inst : TopologicalSpace k} {inst_1 : Ring k} {inst_2 : Monoid G} {A : TopRep k G}
{B : TopRep k G} (motive : A.Hom B → Prop) (h : A.Hom B),
(∀ (hom' : ContIntertwiningMap A.ρ B.ρ), motive { hom' := hom' }) → motive h | null | false |
ContinuousAffineMap.comp_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] {W₂ : Type u_6} {... | null | true |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_of_le_of_ne._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) | null | false |
DyckWord.ctorIdx | Mathlib.Combinatorics.Enumerative.DyckWord | DyckWord → ℕ | null | false |
Std.IterM.toIter_mk | Init.Data.Iterators.Basic | ∀ {α β : Type u_1} {it : α}, { internalState := it }.toIter = { internalState := it } | null | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.markRhss.match_1 | Lean.Elab.Quotation | (motive : Lean.TSyntax `term × Lean.TSyntax `term → Sort u_1) →
(x : Lean.TSyntax `term × Lean.TSyntax `term) → ((idx rhs : Lean.TSyntax `term) → motive (idx, rhs)) → motive x | null | false |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons_succ_of_pos._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {xs : List α} {i : ℕ} {a : α},
p a = true → List.countPBefore p (a :: xs) (i + 1) = List.countPBefore p xs i + 1 | null | false |
Matrix.IsTotallyNonneg.diagonal | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyNonneg | ∀ {ι : Type u_1} {R : Type u_3} [inst : PartialOrder ι] [inst_1 : CommRing R] [inst_2 : PartialOrder R]
[IsOrderedRing R] [inst_4 : DecidableEq ι] {f : ι → R}, 0 ≤ f → (Matrix.diagonal f).IsTotallyNonneg | A diagonal matrix with nonnegative diagonal entries is totally nonnegative. | true |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd'.congr_simp | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (a b n : ℤ)
(h : a + b = n),
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd' C a b n h =
CategoryThe... | null | true |
IsLocalization.exists_mk'_eq | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (z : S), ∃ x y, IsLocalization.mk' S x y = z | null | true |
MeasureTheory.SimpleFunc.instNonAssocRing._proof_7 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonAssocRing β],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Mathlib.Tactic.Push.elabHead | Mathlib.Tactic.Push | Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.Push.Head | Elaborator for the argument passed to `push`. It accepts a constant, or a function | true |
_private.Init.Data.List.Nat.BEq.0.List.beq_eq_isEqv._simp_1_2 | Init.Data.List.Nat.BEq | ∀ {n : ℕ} {p : (m : ℕ) → m < n + 1 → Prop},
(∀ (m : ℕ) (h : m < n + 1), p m h) = (p 0 ⋯ ∧ ∀ (m : ℕ) (h : m < n), p (m + 1) ⋯) | null | false |
Char.toUpper_toUpper_eq_toUpper | Batteries.Data.Char.AsciiCasing | ∀ (c : Char), c.toUpper.toUpper = c.toUpper | null | true |
Aesop.Frontend.RuleExpr.rec_1 | Aesop.Frontend.RuleExpr | {motive_1 : Aesop.Frontend.RuleExpr → Sort u} →
{motive_2 : Array Aesop.Frontend.RuleExpr → Sort u} →
{motive_3 : List Aesop.Frontend.RuleExpr → Sort u} →
((f : Aesop.Frontend.Feature) →
(children : Array Aesop.Frontend.RuleExpr) →
motive_2 children → motive_1 (Aesop.Frontend.RuleExpr.... | null | false |
LinearEquiv.toSpanNonzeroSingleton._proof_4 | Mathlib.LinearAlgebra.Span.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[Module.IsTorsionFree R M] (x : M), x ≠ 0 → Function.Injective ⇑(LinearMap.toSpanSingleton R M x) | null | false |
Polynomial.algebra | Mathlib.RingTheory.PolynomialAlgebra | (R : Type u_1) →
(A : Type u_3) →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra (Polynomial R) (Polynomial A) | If `A` is an `R`-algebra, then `A[X]` is an `R[X]` algebra.
This gives a diamond for `Algebra R[X] R[X][X]`, so this is not a global instance. | true |
ContinuousMulEquiv.trans.eq_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {L : Type u_3} [inst_4 : Mul L] [inst_5 : TopologicalSpace L] (cme1 : M ≃ₜ* N) (cme2 : N ≃ₜ* L),
cme1.trans cme2 = { toMulEquiv := cme1.trans cme2.toMulEquiv, continuous_toFun := ⋯, continuous... | null | true |
CategoryTheory.shrinkYoneda_obj_map | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] {X : C}
{Y Y' : Cᵒᵖ} (g : Y ⟶ Y') (f : (CategoryTheory.shrinkYoneda.{w, v, u}.obj X).obj Y),
(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.shrinkYoneda.{w, v, u}.obj X).map g)) f =
CategoryTheory.... | null | true |
_private.Mathlib.Data.Int.Interval.0.Finset.Ico_succ_succ._simp_1_2 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
OrderMonoidIso.instEquivLike.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β],
OrderMonoidIso.instEquivLike =
{ coe := fun f => f.toFun, inv := fun f => f.invFun, left_inv := ⋯, right_inv := ⋯, coe_injective' := ⋯ } | null | true |
isOpen_iff_ultrafilter | Mathlib.Topology.Ultrafilter | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen s ↔ ∀ x ∈ s, ∀ (l : Ultrafilter X), ↑l ≤ nhds x → s ∈ l | null | true |
AddCommGrpCat.Forget₂.createsLimit._proof_7 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddCommGrpCat)
(this : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections)
(s : CategoryTheory.Limits.Cone F),
EquivLike.coe
(equivShrink
↑((F.comp
((Category... | null | false |
Complex.cderiv._proof_1 | Mathlib.Analysis.Complex.LocallyUniformLimit | (1 + 1).AtLeastTwo | null | false |
Fin.castSucc_eq_zero_iff._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {a : Fin n}, (a.castSucc = 0) = (a = 0) | null | false |
_private.Init.Data.String.Decode.0.parseFirstByte_eq_oneMore_of_utf8DecodeChar?_eq_some._proof_1_3 | Init.Data.String.Decode | ∀ {b : ByteArray} {i : ℕ} {c : Char}, c.utf8Size = 2 → c.utf8Size = 3 → False | null | false |
_private.Mathlib.Algebra.Polynomial.Degree.Lemmas.0.Polynomial.degree_comp._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R},
(p.comp q = 0) = (p = 0 ∨ Polynomial.eval (q.coeff 0) p = 0 ∧ q = Polynomial.C (q.coeff 0)) | null | false |
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_convRing_nf!__1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro | null | false |
SimpleGraph.UnitDistEmbedding.subsingleton._proof_2 | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | ∀ {V : Type u_1} {E : Type u_2} [Subsingleton V] (x : E), Function.Injective fun x_1 => x | null | false |
hasSum_fourier_series_of_summable | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ} [hT : Fact (0 < T)] {f : C(AddCircle T, ℂ)},
Summable (fourierCoeff ⇑f) → HasSum (fun i => fourierCoeff (⇑f) i • fourier i) f | If the sequence of Fourier coefficients of `f` is summable, then the Fourier series converges
uniformly to `f`. | true |
CategoryTheory.PreGaloisCategory.IsNaturalSMul.casesOn | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{F : CategoryTheory.Functor C FintypeCat} →
{G : Type u_1} →
[inst_1 : Group G] →
[inst_2 : (X : C) → MulAction G (F.obj X).obj] →
{motive : CategoryTheory.PreGaloisCategory.IsNaturalSMul F G → Sort u} →
... | null | false |
Int.Internal.Linear.Poly.mul | Init.Data.Int.Linear | Int.Internal.Linear.Poly → ℤ → Int.Internal.Linear.Poly | null | true |
_private.Mathlib.Analysis.Polynomial.CauchyBound.0.Polynomial.IsRoot.norm_lt_cauchyBound._simp_1_10 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Finset.Nonempty.of_image | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α},
(Finset.image f s).Nonempty → s.Nonempty | **Alias** of the forward direction of `Finset.image_nonempty`. | true |
CategoryTheory.surjective_up_to_refinements_of_epi | Mathlib.CategoryTheory.Abelian.Refinements | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Epi f] {A : C} (y : A ⟶ Y),
∃ A' π,
∃ (_ : CategoryTheory.Epi π), ∃ x, CategoryTheory.CategoryStruct.comp π y = CategoryTheory.CategoryStruct.comp x f | null | true |
SimpleGraph.Hom.injective_of_top_hom | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G' : SimpleGraph W} (f : ⊤ →g G'), Function.Injective ⇑f | Every graph homomorphism from a complete graph is injective. | true |
Std.Do.WP.liftWith_refl | Std.Do.WP.SimpLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {α : Type u} {Q : Std.Do.PostCond α ps} [inst : Std.Do.WP m ps]
[inst_1 : Pure m] (f : ({β : Type u} → m β → m β) → m α),
(Std.Do.wp (liftWith f)).apply Q = (Std.Do.wp (f fun {β} x => x)).apply Q | null | true |
ENat.LEInfty.out | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {m : WithTop ℕ∞} [self : ENat.LEInfty m], m ≤ ↑⊤ | null | true |
Lean.Compiler.LCNF.TraverseFVar.forFVarM | Lean.Compiler.LCNF.FVarUtil | {α : Type} →
[self : Lean.Compiler.LCNF.TraverseFVar α] → {m : Type → Type} → [Monad m] → (Lean.FVarId → m Unit) → α → m Unit | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0.wrapped._proof_1._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.1460898547._hygCtx._hyg.8 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | @definition✝ = @definition✝ | null | false |
_private.Mathlib.Order.Sum.Order.0.WithBot.orderIsoPUnitSumLex._simp_8 | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {b : β} {a : α},
Sum.Lex r s (Sum.inr b) (Sum.inl a) = False | null | false |
isClosed_of_mem_irreducibleComponents | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X], ∀ s ∈ irreducibleComponents X, IsClosed s | [Stacks Tag 004W](https://stacks.math.columbia.edu/tag/004W) ((2)) | true |
logDeriv_comp_neg | Mathlib.Analysis.Calculus.LogDeriv | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] (f : 𝕜 → 𝕜') (x : 𝕜), logDeriv (fun x => f (-x)) x = -logDeriv f (-x) | null | true |
Subgroup.instDistribMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Group.Subgroup.Actions | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : AddMonoid α] [inst_2 : DistribMulAction G α] (S : Subgroup G)
(r : ↥S.toSubmonoid) (b₁ b₂ : α), ↑r • (b₁ + b₂) = ↑r • b₁ + ↑r • b₂ | null | false |
Std.DHashMap.containsThenInsertIfNew_fst | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {k : α} {v : β k},
(m.containsThenInsertIfNew k v).1 = m.contains k | null | true |
_private.Mathlib.Basic.Real.Basic.0.Real.cauchy_mul.match_1_1 | Mathlib.Basic.Real.Basic | ∀ (motive : ℝ → ℝ → Prop) (x x_1 : ℝ),
(∀ (a b : CauSeq.Completion.Cauchy abs), motive { cauchy := a } { cauchy := b }) → motive x x_1 | null | false |
le_of_forall_neg_add_le | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] [DenselyOrdered α] {a b : α},
(∀ ε < 0, a + ε ≤ b) → a ≤ b | null | true |
IsCompact.closedBall_zero_add | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {δ : ℝ} {s : Set E},
IsCompact s → 0 ≤ δ → Metric.closedBall 0 δ + s = Metric.cthickening δ s | null | true |
IsUpperSet.compl | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsUpperSet s → IsLowerSet sᶜ | null | true |
HomotopicalAlgebra.CofibrantObject.toHoCatLocalizerMorphism | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.LocalizerMorphism (HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.CofibrantObject C))
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.CofibrantObject.HoCa... | The functor `CofibrantObject C ⥤ HoCat C`, considered as a localizer morphism. | true |
PowerBasis.trace_gen_eq_nextCoeff_minpoly | Mathlib.RingTheory.Trace.Basic | ∀ {S : Type u_2} [inst : CommRing S] {K : Type u_3} [inst_1 : Field K] [inst_2 : Algebra K S] [Nontrivial S]
(pb : PowerBasis K S), (Algebra.trace K S) pb.gen = -(minpoly K pb.gen).nextCoeff | Given `pb : PowerBasis K S`, the trace of `pb.gen` is `-(minpoly K pb.gen).nextCoeff`. | true |
Lean.Level.hash | Lean.Level | Lean.Level → UInt64 | null | true |
Real.Angle.two_zsmul_eq_zero_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, 2 • θ = 0 ↔ θ = 0 ∨ θ = ↑Real.pi | null | true |
Int.toList_rcc_eq_cons_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {xs : List ℤ} {m n a : ℤ}, ((m...=n).toList = a :: xs) = (m = a ∧ m ≤ n ∧ (m + 1...=n).toList = xs) | null | false |
CategoryTheory.Functor.mapIso_hom | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (i : X ≅ Y), (F.mapIso i).hom = F.map i.hom | null | true |
inner_map_complex | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {G : Type u_4} [inst : SeminormedAddCommGroup G] [inst_1 : InnerProductSpace ℝ G] (f : G ≃ₗᵢ[ℝ] ℂ) (x y : G),
inner ℝ x y = (f y * (starRingEnd ℂ) (f x)).re | The inner product on an inner product space of dimension 2 can be evaluated in terms
of a complex-number representation of the space. | true |
LinearMap.toContinuousBilinearMap._proof_11 | Mathlib.Topology.Algebra.Module.FiniteDimensionBilinear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_3} [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[inst_3 : TopologicalSpace F] {G : Type u_2} [inst_4 : AddCommGroup G] [inst_5 : Module 𝕜 G]
[inst_6 : TopologicalSpace G] [inst_7 : IsTopologicalAddGroup G] [inst_8 : ContinuousSMul 𝕜 G],
Conti... | null | false |
OpenPartialHomeomorph.IsImage.iff_symm_preimage_eq | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e : OpenPartialHomeomorph X Y} {s : Set X} {t : Set Y}, e.IsImage s t ↔ e.target ∩ ↑e.symm ⁻¹' s = e.target ∩ t | null | true |
Submodule.prod_comap_inr | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (p : Submodule R M) (q : Submodule R M₂),
Submodule.comap (LinearMap.inr R M M₂) (p.prod q) = q | null | true |
SlashInvariantForm.instIsAddApplyUpperHalfPlaneComplex | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ}, IsAddApply (SlashInvariantForm Γ k) UpperHalfPlane ℂ | null | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine.noConfusion | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {P : Sort u} →
{c₁ c₂ c₁' c₂' : Lean.Meta.Grind.Arith.Linear.IneqCnstr} →
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine c₁ c₂ =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine c₁' c₂' →
(c₁ = c₁' → c₂ = c₂' → P) → P | null | false |
MeasureTheory.Integrable.congr' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup β] [inst_1 : NormedAddCommGroup γ] {f : α → β} {g : α → γ},
MeasureTheory.Integrable f μ →
MeasureTheory.AEStronglyMeasurable g μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ = ‖g a‖) → MeasureTheory.Integ... | null | true |
CategoryTheory.ShortComplex.SnakeInput.v₂₃ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] → (self : CategoryTheory.ShortComplex.SnakeInput C) → self.L₂ ⟶ self.L₃ | the morphism from the second row to the third row | true |
Submodule.quotientEquivOrthogonal_mk | Mathlib.Analysis.InnerProductSpace.ProdL2 | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (x : E) (hx : x ∈ Kᗮ),
K.quotientEquivOrthogonal (Submodule.Quotient.mk x) = ⟨x, hx⟩ | null | true |
Nat.factorization_centralBinom_eq_zero_of_two_mul_lt | Mathlib.Data.Nat.Choose.Factorization | ∀ {p n : ℕ}, 2 * n < p → n.centralBinom.factorization p = 0 | If a prime `p` has positive multiplicity in the `n`th central binomial coefficient,
`p` is no more than `2 * n` | true |
isCompact_Ioo_iff._simp_1 | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] [DenselyOrdered α] {a b : α},
IsCompact (Set.Ioo a b) = (b ≤ a) | null | false |
Lean.Elab.Structural.RecArgInfo.fixedParamPerm | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Elab.Structural.RecArgInfo → Lean.Elab.FixedParamPerm | Information which arguments are fixed | true |
IntermediateField.sum_mem | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
{ι : Type u_4} {t : Finset ι} {f : ι → L}, (∀ c ∈ t, f c ∈ S) → ∑ i ∈ t, f i ∈ S | Sum of elements in an `IntermediateField` indexed by a `Finset` is in the `IntermediateField`.
| true |
AugmentedSimplexCategory.equivAugmentedSimplicialObjectFunctorCompDropIso | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
AugmentedSimplexCategory.equivAugmentedSimplicialObject.functor.comp
CategoryTheory.SimplicialObject.Augmented.drop ≅
(CategoryTheory.Functor.whiskeringLeft SimplexCategoryᵒᵖ AugmentedSimplexCategoryᵒᵖ C).obj
AugmentedSimplexCa... | Through the equivalence `(AugmentedSimplexCategoryᵒᵖ ⥤ C) ≌ SimplicialObject.Augmented C`,
dropping the augmentation corresponds to precomposition with
`inclusionᵒᵖ : SimplexCategoryᵒᵖ ⥤ AugmentedSimplexCategoryᵒᵖ`. | true |
CategoryTheory.EnrichedCat.bicategory._proof_4 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c : CategoryTheory.EnrichedCat V} (f : CategoryTheory.EnrichedFunctor V ↑a ↑b)
{g h i : CategoryTheory.EnrichedFunctor V ↑b ↑c} (η : g ⟶ h) (θ : h ⟶ i),
CategoryTheory.EnrichedCat.whiskerLeft f (Catego... | null | false |
HomologicalComplex.extend_d_to_eq_zero | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c) (e : c.Embedding c') (i' j' : ι')
(j : ι), e.f... | null | true |
MeasureTheory.SimpleFunc.setToSimpleFunc_mono | Mathlib.MeasureTheory.Integral.FinMeasAdditive | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {G' : Type u_7} {G'' : Type u_8}
[inst : NormedAddCommGroup G''] [inst_1 : PartialOrder G''] [IsOrderedAddMonoid G''] [inst_3 : NormedSpace ℝ G'']
[inst_4 : NormedAddCommGroup G'] [inst_5 : PartialOrder G'] [inst_6 : NormedSpace ℝ G'] [IsOrdered... | null | true |
Matrix.SpecialLinearGroup.instPowNat | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] → {R : Type v} → [inst_2 : CommRing R] → Pow (Matrix.SpecialLinearGroup n R) ℕ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
ENNReal.ofNNReal_add_natCast | Mathlib.Basic.ENNReal.Basic | ∀ (r : NNReal) (n : ℕ), ↑(r + ↑n) = ↑r + ↑n | null | true |
WithZero.not_lt_zero | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LT α] (a : WithZero α), ¬a < 0 | null | true |
Std.ExtDTreeMap.Const.get! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{β : Type v} → [Std.TransCmp cmp] → [Inhabited β] → Std.ExtDTreeMap α (fun x => β) cmp → α → β | Tries to retrieve the mapping for the given key, panicking if no such mapping is present.
Uses the `LawfulEqCmp` instance to cast the retrieved value to the correct type.
| true |
Filter.Realizer.cofinite | Mathlib.Data.Analysis.Filter | {α : Type u_1} → [DecidableEq α] → Filter.cofinite.Realizer | Construct a realizer for the cofinite filter | true |
CategoryTheory.IsPushout.isVanKampen_iff | Mathlib.CategoryTheory.Adhesive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z}
(H : CategoryTheory.IsPushout f g h i),
H.IsVanKampen ↔ CategoryTheory.IsVanKampenColimit (CategoryTheory.Limits.PushoutCocone.mk h i ⋯) | null | true |
CochainComplex.mappingConeCompTriangle._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ : CochainComplex C ℤ} (f : X₁ ⟶ X₂),
HomologicalComplex.HasHomotopyCofiber f | null | false |
sup_eq_of_isMaxOn | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {D : α → β} {s : Finset α} {a : α},
a ∈ s → IsMaxOn D (↑s) a → s.sup D = D a | null | true |
Lean.Lsp.CompletionClientCapabilities.rec | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.CompletionClientCapabilities → Sort u} →
((completionItem? : Option Lean.Lsp.CompletionItemCapabilities) → motive { completionItem? := completionItem? }) →
(t : Lean.Lsp.CompletionClientCapabilities) → motive t | null | false |
ULift.normedRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : NormedRing α] (x y : ULift.{u_1, u_2} α), dist x y = ‖-x + y‖ | null | false |
CategoryTheory.MonoidalCategory.DayConvolutionUnit.instIsLeftKanExtensionProdDiscretePUnitExternalProductExtensionUnitLeftφ | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(U : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolutionUnit U]
(F : Ca... | null | true |
Inclusion.Univ.casesOn | Mathlib.Tactic.Inclusion.Core.ToSet | {Iα : Type u_1} →
{α : Type u_2} →
[inst : Inclusion.ToSet Iα α] →
{motive : Inclusion.Univ Iα α → Sort u} →
(t : Inclusion.Univ Iα α) →
((univ : Iα) → (mem_univ : ∀ (x : α), x ∈ univ) → motive { univ := univ, mem_univ := mem_univ }) → motive t | null | false |
Std.Broadcast.Sync.Receiver.recv | Std.Sync.Broadcast | {α : Type} → [Inhabited α] → Std.Broadcast.Sync.Receiver α → BaseIO (Option α) | Receive a value from the channel, blocking until the transmission could be completed.
| true |
Lean.Lsp.InlayHintOptions.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{toWorkDoneProgressOptions : Lean.Lsp.WorkDoneProgressOptions} →
{resolveProvider? : Option Bool} →
{toWorkDoneProgressOptions' : Lean.Lsp.WorkDoneProgressOptions} →
{resolveProvider?' : Option Bool} →
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions, resolveProvider... | null | false |
ImportGraph.Shake.Needs.HighToLow | ImportGraph.Shake.Basic | Type | A `Needs` with a `ForIn` instance that traverses the component bitset's indices from the
highest index to the lowest. This is the most efficient traversal of a bitset. Does not actually
reverse the indices in the bitsets. | true |
CategoryTheory.ShiftedHom.homEquiv | Mathlib.CategoryTheory.Shift.ShiftedHom | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{M : Type u_4} →
[inst_1 : AddMonoid M] →
[inst_2 : CategoryTheory.HasShift C M] →
{X Y : C} → (m₀ : M) → m₀ = 0 → (X ⟶ Y) ≃ CategoryTheory.ShiftedHom X Y m₀ | The bijection `(X ⟶ Y) ≃ ShiftedHom X Y m₀` when `m₀ = 0`. | true |
_private.Mathlib.Order.Filter.Cofinite.0.Filter.coprodᵢ_cofinite._simp_1_1 | Mathlib.Order.Filter.Cofinite | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : Set ((i : ι) → α i)},
(sᶜ ∈ Filter.coprodᵢ f) = ∀ (i : ι), (Function.eval i '' s)ᶜ ∈ f i | null | false |
DerivedCategory.instIsTriangulated | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C], CategoryTheory.IsTriangulated (DerivedCategory C) | null | true |
EuclideanGeometry.concyclic_singleton | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (p : P), EuclideanGeometry.Concyclic {p} | A single point is concyclic. | true |
Perfection.instCommRing | Mathlib.RingTheory.Perfection | (R : Type u_1) → [inst : CommRing R] → (p : ℕ) → [hp : Fact (Nat.Prime p)] → [CharP R p] → CommRing (Perfection R p) | null | true |
_private.Mathlib.Data.ZMod.Basic.0.Nat.range_mul_add._simp_1_6 | Mathlib.Data.ZMod.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) | null | false |
sInf_add | Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | ∀ {M : Type u_1} [inst : CompleteLattice M] [inst_1 : AddGroup M] [AddLeftMono M] [AddRightMono M] (s t : Set M),
sInf (s + t) = sInf s + sInf t | null | true |
SSet.RelativeMorphism.botEquiv | Mathlib.AlgebraicTopology.SimplicialSet.Homotopy | {X Y : SSet} → SSet.RelativeMorphism ⊥ ⊥ (SSet.Subcomplex.isInitialBot.to ⊥.toSSet) ≃ (X ⟶ Y) | Morphisms relatively to the `⊥` subcomplexes of `X` and `Y`
identify to morphisms `X ⟶ Y`. | true |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.toNat_toInt_add_one_sub_toInt.match_1_1 | Init.Data.Range.Polymorphic.SInt | ∀ (motive : (n : ℕ) → {lo hi : BitVec n} → n > 0 → Prop) (n : ℕ) {lo hi : BitVec n} (h : n > 0),
(∀ (lo hi : BitVec 0) (h : 0 > 0), motive 0 h) →
(∀ (n : ℕ) (lo hi : BitVec (n + 1)) (h : n + 1 > 0), motive n.succ h) → motive n h | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.