name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_convRing_nf!__1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro | null | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Basic.0.Finset.prod_involution._proof_1_3 | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} (s : Finset ι) (g : (a : ι) → a ∈ s → ι),
(∀ (a : ι) (ha : a ∈ s), g a ha ∈ s) → ∀ (x : ι) (hx : x ∈ s) (ha : g x ⋯ ∈ s), g (g x ⋯) ha ∈ s | 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 |
QuadraticForm.equivalent_weightedSumSquares_units_of_nondegenerate' | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | ∀ {K : Type u_3} {V : Type u_8} [inst : Field K] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[FiniteDimensional K V] (Q : QuadraticForm K V),
LinearMap.SeparatingLeft (QuadraticMap.associated Q) →
∃ w, QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares K w) | null | 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 |
Equiv.Perm.card_cycleType_pos | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α}, 0 < σ.cycleType.card ↔ σ ≠ 1 | null | true |
CategoryTheory.Functor.FullyFaithful.homNatIsoMaxRight | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{max v₁ v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
F.FullyFaithful →
(X : C) → F.op.comp (CategoryTheory.yoneda.obj (F.obj X)) ≅ CategoryTheory.uliftYoneda.{v₂, ... | `FullyFaithful.homEquiv` as a natural isomorphism. | 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 |
_private.Lean.Meta.Offset.0.Lean.Meta.isNatZero | Lean.Meta.Offset | Lean.Expr → Lean.MetaM Bool | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.curriedActionMonoidal._proof_21 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_2, u_1} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (x : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor
((Catego... | null | false |
Std.CloseableChannel.tryRecv | Std.Sync.Channel | {α : Type} → Std.CloseableChannel α → BaseIO (Option α) | Try to receive a value from the channel, if this can be completed right away without blocking return
`some value`, otherwise return `none`.
| true |
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 |
Sigma.instIsTransLex | Mathlib.Data.Sigma.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} [IsTrans ι r]
[∀ (i : ι), IsTrans (α i) (s i)], IsTrans ((i : ι) × α i) (Sigma.Lex r s) | null | 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.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mintro_1 | Std.Tactic.Do.Syntax | Lean.Macro | null | false |
AddMonoidAlgebra.toDirectSum_sub | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_1} {M : Type u_3} [inst : Ring M] (f g : AddMonoidAlgebra M ι),
(f - g).toDirectSum = f.toDirectSum - g.toDirectSum | null | true |
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 |
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 |
RelLowerSet.rec | Mathlib.Order.Defs.Unbundled | {α : Type u_1} →
[inst : LE α] →
{P : α → Prop} →
{motive : RelLowerSet P → Sort u} →
((carrier : Set α) →
(isRelLowerSet' : IsRelLowerSet carrier P) →
motive { carrier := carrier, isRelLowerSet' := isRelLowerSet' }) →
(t : RelLowerSet P) → motive t | 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 |
ContinuousMapZero.mk.congr_simp | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : Zero R] [inst_2 : TopologicalSpace X]
[inst_3 : TopologicalSpace R] (toContinuousMap toContinuousMap_1 : C(X, R))
(e_toContinuousMap : toContinuousMap = toContinuousMap_1) (map_zero' : toContinuousMap 0 = 0),
{ toContinuousMap := toContinuousMap, map_zero'... | null | true |
_private.Mathlib.Topology.LocalAtTarget.0.TopologicalSpace.IsOpenCover.isHomeomorph_iff_restrictPreimage._simp_1_1 | Mathlib.Topology.LocalAtTarget | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsHomeomorph f = (Topology.IsEmbedding f ∧ Function.Surjective f) | null | false |
_private.Mathlib.MeasureTheory.Covering.LiminfLimsup.0.blimsup_cthickening_mul_ae_eq._simp_1_1 | Mathlib.MeasureTheory.Covering.LiminfLimsup | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.lratChecker.match_3.eq_3 | Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound | ∀ {α : Type u_1} {β : Type u_2} (motive : List (Std.Tactic.BVDecide.LRAT.Action β α) → Sort u_3) (id : ℕ) (c : β)
(rupHints : Array ℕ) (restPrf : List (Std.Tactic.BVDecide.LRAT.Action β α)) (h_1 : Unit → motive [])
(h_2 :
(id : ℕ) →
(rupHints : Array ℕ) →
(tail : List (Std.Tactic.BVDecide.LRAT.Act... | null | true |
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 |
_private.Mathlib.Data.Finset.Empty.0.Finset.notMem_empty._simp_1_2 | Mathlib.Data.Finset.Empty | ∀ {α : Type u_1} (a : α), (a ∈ 0) = False | null | false |
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 |
AlgebraNorm.mk._flat_ctor | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
(toFun : S → ℝ) →
toFun 0 = 0 →
(∀ (r s : S), toFun (r + s) ≤ toFun r + toFun s) →
(∀ (r : S), toFun (-r) = toFun r) →
... | null | false |
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_4} [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 |
Lean.LocalDecl.ctorElim | Lean.LocalContext | {motive : Lean.LocalDecl → Sort u} →
(ctorIdx : ℕ) → (t : Lean.LocalDecl) → ctorIdx = t.ctorIdx → Lean.LocalDecl.ctorElimType ctorIdx → motive t | null | false |
Lean.Plugin.instFromJson | Lean.Setup | Lean.FromJson Lean.Plugin | null | true |
inf_eq_and_sup_eq_iff | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b c : α}, a ⊓ b = c ∧ a ⊔ b = c ↔ a = c ∧ b = c | 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 |
Submodule.orthogonalProjection_apply_of_mem_orthogonal | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} [inst_3 : K.HasOrthogonalProjection] {v : E}, v ∈ Kᗮ → K.orthogonalProjectionOnto v = 0 | **Alias** of `Submodule.orthogonalProjectionOnto_apply_of_mem_orthogonal`.
---
The orthogonal projection onto `K` of an element of `Kᗮ` is zero. | 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 |
Lean.Parser.Term.strictImplicitRightBracket.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | null | true |
OpenPartialHomeomorph.IsImage.iff_symm_preimage_eq | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_3} [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 |
Affine.Triangle.toPolygon_toTriangle | Mathlib.Geometry.Polygon.Basic | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] (t : Affine.Triangle R P), Polygon.toTriangle R (Affine.Triangle.toPolygon t) ⋯ = t | Converting a triangle to a polygon and back yields the original triangle. | 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 |
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 |
Function.range_eq_image_or_of_mulSupport_subset | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M} {k : Set ι},
Function.mulSupport f ⊆ k → Set.range f = f '' k ∨ Set.range f = insert 1 (f '' k) | null | true |
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 |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory._aux_Mathlib_MeasureTheory_Group_FundamentalDomain___unexpand_AddAction_orbitRel_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | Lean.PrettyPrinter.Unexpander | null | false |
DomAddAct.instFaithfulVAddForallOfNontrivial | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {β : Type u_2} {α : Type u_3} [inst : VAdd M α] [FaithfulVAdd M α] [Nontrivial β],
FaithfulVAdd Mᵈᵃᵃ (α → β) | 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 |
_private.Mathlib.Topology.Homotopy.Basic.0.ContinuousMap.Homotopic.prodMk.match_1_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(X, Z)} (motive : f₀.Homotopic f₁ → g₀.Homotopic g₁ → Prop)
(x : f₀.Homotopic f₁) (x_1 : g₀.Homotopic g₁),
(∀ (F : f₀.Homotopy f₁) (G : g₀.Homotopy g₁)... | null | false |
CategoryTheory.StrictPseudofunctorCore.map₂_right_unitor._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | Lean.Syntax | null | false |
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 |
Symmetric.flip_eq | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} [Std.Symm r], flip r = r | **Alias** of `Std.Symm.flip_eq`. | true |
Lean.Elab.Structural.RecArgInfo.fixedParamPerm | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Elab.Structural.RecArgInfo → Lean.Elab.FixedParamPerm | Information which arguments are fixed | true |
affineHomeomorph._proof_1 | Mathlib.Topology.Algebra.Field | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (a b : 𝕜), a ≠ 0 → ∀ (x : 𝕜), (fun y => (y - b) / a) ((fun x => a * x + b) x) = x | null | false |
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 |
Nat.ofDigits_eq_sum_mapIdx | Mathlib.Data.Nat.Digits.Lemmas | ∀ (b : ℕ) (L : List ℕ), Nat.ofDigits b L = (List.mapIdx (fun i a => a * b ^ i) L).sum | null | 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 |
HomRel.FactorsThroughLocalization.strictUniversalPropertyFixedTarget._proof_5 | Mathlib.CategoryTheory.Localization.Quotient | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {homRel : HomRel C}
{W : CategoryTheory.MorphismProperty C},
homRel.FactorsThroughLocalization W →
∀ {E : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} E] (F : CategoryTheory.Functor C E),
W.IsInvertedBy F → ∀ (x x_1 : C) (f g : x ⟶ x... | null | false |
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.Data.ENNReal.Basic | ∀ (r : NNReal) (n : ℕ), ↑(r + ↑n) = ↑r + ↑n | null | true |
AddSubgroup.index_eq_zero_iff_infinite | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.index = 0 ↔ Infinite (G ⧸ H) | null | true |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.degree_add_le._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {m : σ →₀ ℕ},
(m ∉ p.support) = (MvPolynomial.coeff m p = 0) | null | false |
WithZero.not_lt_zero | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LT α] (a : WithZero α), ¬a < 0 | null | true |
TopologicalSpace.Compacts.coe_toCloseds | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : T2Space α] (s : TopologicalSpace.Compacts α), ↑s.toCloseds = ↑s | 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 |
_private.Mathlib.CategoryTheory.Quotient.Preadditive.0.CategoryTheory.Quotient.Preadditive.add._simp_1 | Mathlib.CategoryTheory.Quotient.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (r : HomRel C)
[CategoryTheory.HomRel.IsStableUnderPrecomp r] [CategoryTheory.HomRel.IsStableUnderPostcomp r] {X Y : C}
(f g : X ⟶ Y), CategoryTheory.HomRel.CompClosure r f g = r f g | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.FirstPage.0.CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.HasFirstPageComputation._proof_1 | Mathlib.Algebra.Homology.SpectralObject.FirstPage | ∀ {r₀ : ℤ}, r₀ ≤ r₀ | null | false |
ULift.addLeftCancelSemigroup.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : AddLeftCancelSemigroup α],
ULift.addLeftCancelSemigroup = Function.Injective.addLeftCancelSemigroup ⇑Equiv.ulift ⋯ ⋯ | null | true |
ModuleCat.MonModuleEquivalenceAlgebra.Algebra_of_Mon_._proof_5 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : ModuleCat R) [inst_1 : CategoryTheory.MonObj A]
(x y : ↑(CategoryTheory.MonoidalCategoryStruct.tensorUnit (ModuleCat R))),
(ModuleCat.Hom.hom CategoryTheory.MonObj.one).toFun (x + y) =
(ModuleCat.Hom.hom CategoryTheory.MonObj.one).toFun x + (ModuleCat.Hom.hom CategoryTh... | null | false |
String.Slice.Pattern.Model.matchAt?_eq_none_iff | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {startPos : s.Pos},
String.Slice.Pattern.Model.matchAt? pat startPos = none ↔ ¬String.Slice.Pattern.Model.MatchesAt pat startPos | null | true |
SeparatelyContinuousMul.continuous_mul_const | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} {inst : TopologicalSpace M} {inst_1 : Mul M} [self : SeparatelyContinuousMul M] {a : M},
Continuous fun x => x * a | null | true |
List.reverse_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a : α}, (List.replicate n a).reverse = List.replicate n a | null | true |
CategoryTheory.Monad.monadMonEquiv._proof_28 | Mathlib.CategoryTheory.Monad.EquivMon | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C],
CategoryTheory.CategoryStruct.comp
{
app := fun x =>
{
hom :=
CategoryTheory.CategoryStruct.id
((CategoryTheory.Functor.id (CategoryTheory.Mon (CategoryTheory.Functor C C))).obj x).X,
... | null | false |
ConditionallyCompleteLinearOrder.compare_eq_compareOfLessAndEq | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ {α : Type u_5} [self : ConditionallyCompleteLinearOrder α] (a b : α), compare a b = compareOfLessAndEq a b | Comparison via `compare` is equal to the canonical comparison given decidable `<` and `=`. | true |
ProperSpace.of_isCompact_closedBall_of_le | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α] (R : ℝ),
(∀ (x : α) (r : ℝ), R ≤ r → IsCompact (Metric.closedBall x r)) → ProperSpace α | If all closed balls of large enough radius are compact, then the space is proper. Especially
useful when the lower bound for the radius is 0. | true |
ContinuousLinearMapWOT._aux_Mathlib_Analysis_LocallyConvex_WeakOperatorTopology___unexpand_ContinuousLinearMapWOT_2 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | Lean.PrettyPrinter.Unexpander | null | false |
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 |
SimpleGraph.Walk.lastDart_mem_darts._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w} (hnil : ¬p.Nil), (p.lastDart hnil ∈ p.darts) = True | 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 |
Locale.PT.instTopologicalSpace._proof_3 | Mathlib.Topology.Order.Category.FrameAdjunction | ∀ (L : Type u_1) [inst : CompleteLattice L] (S : Set (Set (Locale.PT L))),
(∀ t ∈ S, ∃ u, {x | x u} = t) → ∃ u, {x | x u} = ⋃₀ S | null | false |
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 |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_eq_ediv._simp_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ (n : ℕ), (0 ≤ Int.negSucc n) = False | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.