name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LinearEquiv.piRing.eq_1 | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u) (M : Type v) (ι : Type x) [inst : Semiring R] (S : Type u_4) [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : Semiring S] [inst_4 : AddCommMonoid M] [inst_5 : Module R M] [inst_6 : Module S M]
[inst_7 : SMulCommClass R S M],
LinearEquiv.piRing R M ι S =
(LinearMap.lsum R (fun x => R) S).... | null | true |
Homeomorph.inv.congr_simp | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G],
Homeomorph.inv G = Homeomorph.inv G | null | true |
String.Slice.Pattern.Model.IsLongestRevMatch.isRevMatch | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatch pat pos → String.Slice.Pattern.Model.IsRevMatch pat pos | null | true |
_private.Mathlib.RepresentationTheory.FiniteIndex.0.Rep.coindToInd_of_support_subset_orbit._simp_1_2 | Mathlib.RepresentationTheory.FiniteIndex | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y | null | false |
Subgroup.pi_le_iff | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_3} {f : η → Type u_4} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] [Finite η]
{H : (i : η) → Subgroup (f i)} {J : Subgroup ((i : η) → f i)},
Subgroup.pi Set.univ H ≤ J ↔ ∀ (i : η), Subgroup.map (MonoidHom.mulSingle f i) (H i) ≤ J | For finite index types, the `Subgroup.pi` is generated by the embeddings of the groups. | true |
_private.Mathlib.Combinatorics.Additive.ErdosGinzburgZiv.0.Int.erdos_ginzburg_ziv_prime | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {p : ℕ} [Fact (Nat.Prime p)] {s : Finset ι} (a : ι → ℤ),
s.card = 2 * p - 1 → ∃ t ⊆ s, t.card = p ∧ ↑p ∣ ∑ i ∈ t, a i | The prime case of the **Erdős–Ginzburg–Ziv theorem** for `ℤ`.
Any sequence of `2 * p - 1` elements of `ℤ` contains a subsequence of `p` elements whose sum is
divisible by `p`. | true |
Lean.Meta.Grind.getEqc | Lean.Meta.Tactic.Grind.Types | Lean.Expr → optParam Bool false → Lean.Meta.Grind.GoalM (List Lean.Expr) | Returns expressions in the given expression equivalence class. | true |
CategoryTheory.ProfunctorCore.map_comp | Mathlib.CategoryTheory.Profunctor.Basic | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.ProfunctorCore.{w, v₁, v₂, u₁, u₂} C D) {X₁ X₂ X₃ : C} {Y₁ Y₂ Y₃ : D} (f : X₁ ⟶ X₂)
(f' : X₂ ⟶ X₃) (g : Y₁ ⟶ Y₂) (g' : Y₂ ⟶ Y₃),
self.map (CategoryTheory.CategoryStruct.co... | null | true |
LieModule.isNilpotent_of_top_iff._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [LieModule R L M],
LieModule.IsNilpotent (↥⊤) M = LieModule.IsNilpotent L M | null | false |
Lean.Expr.withApp'.go._f | Batteries.Lean.Expr | {α : Sort u_1} →
(Lean.Expr → Array Lean.Expr → α) →
(a : Lean.Expr) → Lean.Expr.below (motive := fun a => Array Lean.Expr → ℕ → α) a → Array Lean.Expr → ℕ → α | null | false |
CategoryTheory.Limits.reflectsColimitsOfSize_of_rightOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor Cᵒᵖ D) [CategoryTheory.Limits.ReflectsLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.rightOp],
CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F | If `F.rightOp : C ⥤ Dᵒᵖ` reflects limits, then `F : Cᵒᵖ ⥤ D` reflects colimits. | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[inst_3 : CategoryTheory.BraidedCategory D] →
CategoryTheory.Functor.id (CategoryTheory.CommMon (Category... | The unit for the equivalence `CommMon (C ⥤ D) ≌ C ⥤ CommMon D`.
| true |
«_aux_Mathlib_Algebra_Lie_Basic___macroRules_term_→ₗ⁅_⁆__1» | Mathlib.Algebra.Lie.Basic | Lean.Macro | null | false |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformFun.«_aux_Mathlib_Topology_UniformSpace_UniformConvergenceTopology___macroRules__private_Mathlib_Topology_UniformSpace_UniformConvergenceTopology_0_UniformFun_term𝒰(_,_,_)_1» | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | Lean.Macro | null | false |
Std.Http.instReprVersion | Std.Http.Data.Version | Repr Std.Http.Version | null | true |
Subgroup.exists_index_le_card_of_leftCoset_cover | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {g : ι → G} {s : Finset ι},
⋃ i ∈ s, g i • ↑(H i) = Set.univ → ∃ i ∈ s, (H i).FiniteIndex ∧ (H i).index ≤ s.card | B. H. Neumann Lemma :
If a finite family of cosets of subgroups covers the group, then at least one
of these subgroups has index not exceeding the number of cosets. | true |
CategoryTheory.SubobjectRepresentableBy.classifier._proof_4 | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {Ω : C}
(h : CategoryTheory.SubobjectRepresentableBy Ω) [inst_2 : CategoryTheory.Limits.HasTerminal C],
CategoryTheory.CategoryStruct.comp h.Ω₀.arrow (CategoryTheory.Iso.refl Ω).hom =
CategoryTheory.Ca... | null | false |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.tryTheoremCore.match_1 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__do_lift : Option Lean.Meta.Simp.Result) →
(Unit → motive none) → ((r : Lean.Meta.Simp.Result) → motive (some r)) → motive __do_lift | null | false |
SymmetricPower.«_aux_Mathlib_LinearAlgebra_TensorPower_Symmetric___delab_app_SymmetricPower_term⨂ₛ[_]_,__1» | Mathlib.LinearAlgebra.TensorPower.Symmetric | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.multipliableLocallyUniformlyOn_one_sub_pow._simp_1_1 | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ {α : 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 |
Lean.Meta.Grind.AC.Struct._sizeOf_1 | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.Struct → ℕ | null | false |
Plausible.Testable.minimizeAux | Plausible.Testable | {α : Sort u_1} →
[inst : Plausible.SampleableExt α] →
{β : α → Prop} →
[(x : α) → Plausible.Testable (β x)] →
Plausible.Configuration →
String →
Plausible.SampleableExt.proxy α →
ℕ →
OptionT Plausible.Gen
((x : Plausible.Sampleabl... | Shrink a counter-example `x` by using `Shrinkable.shrink x`, picking the first
candidate that falsifies a property and recursively shrinking that one.
The process is guaranteed to terminate because `shrink x` produces
a proof that all the values it produces are smaller (according to `SizeOf`)
than `x`. | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_8 | Std.Data.DTreeMap.Internal.Operations | ¬0 - 1 ≤ 1 → False | null | false |
_private.Mathlib.CategoryTheory.CofilteredSystem.0.CategoryTheory.Functor.isMittagLeffler_iff_subset_range_comp._simp_1_1 | Mathlib.CategoryTheory.CofilteredSystem | ∀ {J : Type u} [inst : CategoryTheory.Category.{v_1, u} J] (F : CategoryTheory.Functor J (Type v)),
F.IsMittagLeffler = ∀ (j : J), ∃ i f, F.eventualRange j = Set.range ⇑(CategoryTheory.ConcreteCategory.hom (F.map f)) | null | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.findInfoTree?._sparseCasesOn_7 | Lean.Server.CodeActions.Provider | {motive_1 : Lean.Elab.InfoTree → Sort u} →
(t : Lean.Elab.InfoTree) →
((i : Lean.Elab.PartialContextInfo) → (t : Lean.Elab.InfoTree) → motive_1 (Lean.Elab.InfoTree.context i t)) →
((i : Lean.Elab.Info) →
(children : Lean.PersistentArray Lean.Elab.InfoTree) → motive_1 (Lean.Elab.InfoTree.node i chi... | null | false |
_private.Mathlib.Analysis.Convex.StrictCombination.0.StrictConvex.centerMass_mem_interior._proof_1_11 | Mathlib.Analysis.Convex.StrictCombination | ∀ {R : Type u_3} {V : Type u_2} {ι : Type u_1} [inst : Field R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
{w : ι → R} {z : ι → V} (i : ι) (t : Finset ι) (i' j' : ι),
i' ∈ insert i t →
j' ∈ insert i t →
z i' ≠ z j' →
w i' ≠ 0 →
w j' ≠ 0 →
z i = t.centerMass w z →
... | null | false |
CategoryTheory.Sieve.giGenerate._proof_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (x : CategoryTheory.Sieve X) (x_1 : C)
(x_2 : x_1 ⟶ X), x.arrows x_2 → ∃ Y h g, x.arrows g ∧ CategoryTheory.CategoryStruct.comp h g = x_2 | null | false |
MeasureTheory.Submartingale.condExp_sub_nonneg | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
{μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
{ℱ : MeasureTheory.Filtration ι m0} [CompleteSpace E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E]
{f : ι → Ω → E}, MeasureTheory... | null | true |
Ordset.mem | Mathlib.Data.Ordmap.Ordset | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → α → Ordset α → Bool | O(log n). Does the set contain the element `x`? That is,
is there an element that is equivalent to `x` in the order? | true |
Filter.Germ.LiftPred._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} (p : β → Prop) (_f _g : α → β),
_f =ᶠ[l] _g → (∀ᶠ (x : α) in l, p (_f x)) = ∀ᶠ (x : α) in l, p (_g x) | null | false |
Std.ExtTreeSet.ext_contains | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp] {t₁ t₂ : Std.ExtTreeSet α cmp},
(∀ (k : α), t₁.contains k = t₂.contains k) → t₁ = t₂ | null | true |
Ring.DirectLimit.lift_injective | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) [Nonempty ι] [IsDirectedOrder ι],
(∀ (i : ι), Fun... | null | true |
affineIndependent_of_ne_of_mem_of_mem_of_notMem | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p₁ p₂ p₃ : P},
p₁ ≠ p₂ → p₁ ∈ s → p₂ ∈ s → p₃ ∉ s → AffineIndependent k ![p₁, p₂, p₃] | If distinct points `p₁` and `p₂` lie in `s` but `p₃` does not, the three points are affinely
independent. | true |
_private.Mathlib.Topology.Separation.Basic.0.t0Space_iff_inseparable.match_1_1 | Mathlib.Topology.Separation.Basic | ∀ (X : Type u_1) [inst : TopologicalSpace X] (motive : T0Space X → Prop) (x : T0Space X),
(∀ (h : ∀ ⦃x y : X⦄, Inseparable x y → x = y), motive ⋯) → motive x | null | false |
FundamentalGroupoidFunctor.prodToProdTop.match_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | (A : TopCat) →
(B : TopCat) →
(motive :
(x y :
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B)) →
(x ⟶ y) → Sort u_3) →
(x y :
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
... | null | false |
GromovHausdorff.auxGluing._proof_5 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ (X : ℕ → Type) [inst : (n : ℕ) → MetricSpace (X n)] [inst_1 : ∀ (n : ℕ), CompactSpace (X n)]
[inst_2 : ∀ (n : ℕ), Nonempty (X n)] (n : ℕ) (Y : GromovHausdorff.AuxGluingStruct (X n)),
Isometry (Metric.toGlueR ⋯ ⋯ ∘ GromovHausdorff.optimalGHInjr (X n) (X (n + 1))) | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.maxView._proof_8 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β) (size : ℕ) (k' : α) (v' : β k')
(l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced →
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').s... | null | false |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_obj_map_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) (X_1 : CategoryTheory.Functor J₂ C)
{X_2 Y : J₁} (f... | null | true |
Circle.exp_eq_exp | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {x y : ℝ}, Circle.exp x = Circle.exp y ↔ ∃ m, x = y + ↑m * (2 * Real.pi) | null | true |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.val_map_lt_iff._simp_1_1 | Mathlib.RingTheory.Valuation.Extension | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
PredOrder.prelimitRecOn._proof_4 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] (a : α) (h : ¬Order.IsPredPrelimit a),
¬IsMin (Classical.choose ⋯) | null | false |
NumberField.mixedEmbedding.fundamentalCone.idealSetEquiv._proof_4 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(J : ↥(nonZeroDivisors (Ideal (NumberField.RingOfIntegers K))))
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.idealSet K J)),
(fun a => ⟨NumberField.mixedEmbedding.fundamentalCone.idealSetMap K J a, ⋯⟩) x =
(fun a => ⟨NumberField.mixedEmbedd... | null | false |
CategoryTheory.isProjective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.ObjectProperty C | The `ObjectProperty C` corresponding to the notion of projective objects in `C`. | true |
_private.Mathlib.Algebra.Group.Fin.Basic.0.Fin.le_sub_one_iff._simp_1_1 | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, (a ≤ b) = (↑a ≤ ↑b) | null | false |
Lean.Lsp.ClientCapabilities._sizeOf_inst | Lean.Data.Lsp.Capabilities | SizeOf Lean.Lsp.ClientCapabilities | null | false |
_private.Mathlib.CategoryTheory.Triangulated.Pretriangulated.0.CategoryTheory.Pretriangulated.Triangle.isZero₃_of_isZero₁₂._simp_1_1 | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) | null | false |
Valuation.ideal_isPrincipal | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {K : Type u_2} [inst_1 : Field K] (v : Valuation K Γ)
[IsCyclic ↥(MonoidWithZeroHom.ofClass v).valueGroup] [Nontrivial ↥(MonoidWithZeroHom.ofClass v).valueGroup]
(I : Ideal ↥v.valuationSubring), Submodule.IsPrincipal I | null | true |
AddMonoidAlgebra.addAddCommMonoid._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] (a : AddMonoidAlgebra R M), 0 + a = a | null | false |
Prod.instOrderTop | Mathlib.Order.BoundedOrder.Basic | (α : Type u) → (β : Type v) → [inst : LE α] → [inst_1 : LE β] → [OrderTop α] → [OrderTop β] → OrderTop (α × β) | null | true |
_private.Mathlib.Algebra.Category.Grp.EpiMono.0.GrpCat.SurjectiveOfEpiAuxs._aux_Mathlib_Algebra_Category_Grp_EpiMono___macroRules__private_Mathlib_Algebra_Category_Grp_EpiMono_0_GrpCat_SurjectiveOfEpiAuxs_termSX'_1 | Mathlib.Algebra.Category.Grp.EpiMono | Lean.Macro | null | false |
CategoryTheory.Bicategory.conjugateEquiv_whiskerRight | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {l₁ : a ⟶ b} {r₁ : b ⟶ a}
(adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁) {l₁' : a ⟶ b} {r₁' : b ⟶ a}
(adj₁' : CategoryTheory.Bicategory.Adjunction l₁' r₁') {l₂ : b ⟶ c} {r₂ : c ⟶ b}
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (φ : l₁' ⟶ ... | null | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Convolution.0.MeasureTheory.hasFDerivAt_convolution_right_with_param._simp_1_9 | Mathlib.Analysis.Calculus.ContDiff.Convolution | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
LinearMap.BilinMap.tensorDistrib._proof_27 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_1) (A : Type u_2) {M₁ : Type u_3} {N₁ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid N₁] [inst_4 : Algebra R A] [inst_5 : Module A M₁]
[inst_6 : Module R N₁] [inst_7 : Module A N₁] [inst_8 : IsScalarTower R A N₁],
IsScalarTower R A (... | null | false |
Equiv.swap_eq_refl_iff | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y : α}, Equiv.swap x y = Equiv.refl α ↔ x = y | null | true |
MulAction.block_stabilizerOrderIso.match_3 | Mathlib.GroupTheory.GroupAction.Blocks | (G : Type u_1) →
[inst : Group G] →
{X : Type u_2} →
[inst_1 : MulAction G X] →
(a : X) →
(motive : ↑(Set.Ici (MulAction.stabilizer G a)) → Sort u_3) →
(x : ↑(Set.Ici (MulAction.stabilizer G a))) →
((H : Subgroup G) → (hH : H ∈ Set.Ici (MulAction.stabilizer G a)) ... | null | false |
CategoryTheory.Functor.PushoutObjObj.ofHasPushout_ι | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₂ Y₂ : C₂} {f₂ : X₂ ⟶ Y₂}
[inst_3 :... | null | true |
Finset.insert_Ico_right_eq_Ico_succ | Mathlib.Order.Interval.Finset.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : SuccOrder α] {a b : α} [NoMaxOrder α],
a ≤ b → insert b (Finset.Ico a b) = Finset.Ico a (Order.succ b) | null | true |
Units.le_of_inv_mul_le_one | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ) {a : M}, ↑u⁻¹ * a ≤ 1 → a ≤ ↑u | **Alias** of the forward direction of `Units.inv_mul_le_one`. | true |
CategoryTheory.Over.grpObjMkPullbackSnd_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X R S : C} {f : R ⟶ X} {g : S ⟶ X} [inst_2 : CategoryTheory.GrpObj (CategoryTheory.Over.mk f)],
CategoryTheory.MonObj.one =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε (Ca... | null | true |
CategoryTheory.Limits.pullback.lift_fst_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y)
(w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g) {Z_1 : C} (h_1 : X ⟶ Z_1),
CategoryTheory.CategoryStruct.com... | null | true |
_private.Mathlib.Order.Monotone.MonovaryOrder.0.monovary_iff_exists_monotone._simp_1_1 | Mathlib.Order.Monotone.MonovaryOrder | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
Monovary f g = MonovaryOn f g Set.univ | null | false |
Mathlib.Tactic.Order.ToInt.toInt_sup_toInt_eq_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j k : Fin n),
max (Mathlib.Tactic.Order.ToInt.toInt val i) (Mathlib.Tactic.Order.ToInt.toInt val j) =
Mathlib.Tactic.Order.ToInt.toInt val k ↔
max (val i) (val j) = val k | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.MLListImpl.nil | Batteries.Data.MLList.Basic | {m : Type u → Type u} → {α : Type u} → MLList.MLListImpl✝ m α | null | true |
instFullCondensedTypeCondensedSetUlift | Mathlib.Condensed.Functors | Condensed.ulift.Full | null | true |
ULift.seminormedCommRing._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (a b : ULift.{u_1, u_2} α), a - b = a + -b | null | false |
Matrix.IsHermitian.splits_charpoly | 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],
A.IsHermitian → A.charpoly.Splits | null | true |
Tropical.untrop_injective | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u}, Function.Injective Tropical.untrop | null | true |
Ordinal.instPosMulStrictMono | Mathlib.SetTheory.Ordinal.Arithmetic | PosMulStrictMono Ordinal.{u_4} | null | true |
CategoryTheory.Lax.LaxTrans.isoMk_inv_as_app | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} (app : (a : B) → η.app a ≅ θ.app a)
(naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bic... | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.action_exchange | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {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] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {w x : D} {y z : C} (f : w ⟶ x) (g : y ⟶ z),
CategoryTheory.CategoryStruct.c... | null | true |
CategoryTheory.Functor.IsLocallyFull | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | {C : Type uC} →
[inst : CategoryTheory.Category.{vC, uC} C] →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{vD, uD} D] →
CategoryTheory.Functor C D → CategoryTheory.GrothendieckTopology D → Prop | A functor `G : C ⥤ D` is locally full w.r.t. a topology on `D` if for every `f : G.obj U ⟶ G.obj V`,
the set of `G.map fᵢ : G.obj Wᵢ ⟶ G.obj U` such that `G.map fᵢ ≫ f` is
in the image of `G` is a coverage of the topology on `D`.
| true |
List.toString | Init.Data.ToString.Extra | {α : Type u_1} → [ToString α] → List α → String | Converts a list into a string, using `ToString.toString` to convert its elements.
The resulting string resembles list literal syntax, with the elements separated by `", "` and
enclosed in square brackets.
The resulting string may not be valid Lean syntax, because there's no such expectation for
`ToString` instances.
... | true |
SSet.Subcomplex.PairingCore.mk.inj | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} {ι : Type v} {dim : ι → ℕ}
{simplex : (s : ι) → X.obj (Opposite.op { len := dim s + 1 })} {index : (s : ι) → Fin (dim s + 2)}
{nonDegenerate₁ : ∀ (s : ι), simplex s ∈ X.nonDegenerate (dim s + 1)}
{nonDegenerate₂ :
∀ (s : ι),
(CategoryTheory.ConcreteCategory.hom (CategoryT... | null | true |
symmDiff_sdiff | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b c : α), symmDiff a b \ c = a \ (b ⊔ c) ⊔ b \ (a ⊔ c) | null | true |
PartOrdEmb.Hom.noConfusion | Mathlib.Order.Category.PartOrdEmb | {P : Sort u_1} →
{X Y : PartOrdEmb} →
{t : X.Hom Y} →
{X' Y' : PartOrdEmb} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → PartOrdEmb.Hom.noConfusionType P t t' | null | false |
ZMod.LFunction | Mathlib.NumberTheory.LSeries.ZMod | {N : ℕ} → [NeZero N] → (ZMod N → ℂ) → ℂ → ℂ | The unique meromorphic function `ℂ → ℂ` which agrees with `∑' n : ℕ, Φ n / n ^ s` wherever the
latter is convergent. This is constructed as a linear combination of Hurwitz zeta functions.
Note that this is not the same as `LSeries Φ`: they agree in the convergence range, but
`LSeries Φ s` is defined to be `0` if `re s... | true |
_private.Lean.Data.Lsp.Ipc.0.Lean.Lsp.Ipc.expandOutgoingCallHierarchy.go | Lean.Data.Lsp.Ipc | ℕ →
Lean.Lsp.CallHierarchyItem →
Array Lean.Lsp.Range → Std.TreeSet String compare → Lean.Lsp.Ipc.IpcM (Lean.Lsp.Ipc.CallHierarchy × ℕ) | null | true |
LinearMap.eq_adjoint_iff_basis_left | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace 𝕜 E] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : FiniteDimensional 𝕜 E] [inst_6 : FiniteDimensional 𝕜 F] {ι : Type u_5} (b : Module.Basis ι 𝕜 E)
(A : E... | null | true |
Std.DHashMap.Raw.Const.getD_empty | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {a : α} {fallback : β},
Std.DHashMap.Raw.Const.getD ∅ a fallback = fallback | null | true |
exists_and_self | Init.PropLemmas | ∀ (P : Prop) (Q : P → Prop), (∃ (p : P), Q p) ∧ P ↔ ∃ (p : P), Q p | null | true |
MvQPF.Pi.repr | Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {n : ℕ} →
{A : Type u} →
(F : A → TypeVec.{u} n → Type u) →
[inst : (α : A) → MvQPF (F α)] → ⦃α : TypeVec.{u} n⦄ → MvQPF.Pi F α → ↑(MvQPF.Pi.P F) α | representation function for dependent products | true |
AlgebraicGeometry.Scheme.IdealSheafData.instIsPreimmersionSubschemeι | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData), AlgebraicGeometry.IsPreimmersion I.subschemeι | See `AlgebraicGeometry.Morphisms.ClosedImmersion` for the closed immersion version. | true |
Unitization.instCStarAlgebra | Mathlib.Analysis.CStarAlgebra.Unitization | {A : Type u_3} → [NonUnitalCStarAlgebra A] → CStarAlgebra (Unitization ℂ A) | null | true |
CategoryTheory.Pretriangulated.id_hom₂ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(A : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.CategoryStruct.id A).hom₂ = CategoryTheory.CategoryStruct.id A.obj₂ | null | true |
_private.Lean.Elab.Tactic.Do.ProofMode.LeftRight.0.Lean.Elab.Tactic.Do.ProofMode.elabMLeft._regBuiltin.Lean.Elab.Tactic.Do.ProofMode.elabMLeft_1 | Lean.Elab.Tactic.Do.ProofMode.LeftRight | IO Unit | null | false |
_private.Init.Data.Range.Polymorphic.UInt.0.USize.instLawfulHasSize._simp_2 | Init.Data.Range.Polymorphic.UInt | ∀ {a b : USize}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Std.TreeSet.get!_erase_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).get! k = default | null | true |
Polynomial.Splits.eq_X_sub_C_of_single_root | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R],
f.Splits → ∀ {x : R}, f.roots = {x} → f = Polynomial.C f.leadingCoeff * (Polynomial.X - Polynomial.C x) | null | true |
Sum.Lex.noMaxOrder | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [NoMaxOrder α] [NoMaxOrder β], NoMaxOrder (α ⊕ₗ β) | null | true |
CategoryTheory.IsUniversallyEffectiveEquivalenceRelationCategory.mk | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {R A : C},
(∀ (p₁ p₂ : R ⟶ A) [CategoryTheory.IsEquivalenceRelation p₁ p₂],
CategoryTheory.IsUniversallyEffectiveEquivalenceRelation p₁ p₂) →
CategoryTheory.IsUniversallyEffectiveEquivalenceRelationCategory C | null | true |
Lean.Elab.Do.Context.doBlockResultType | Lean.Elab.Do.Basic | Lean.Elab.Do.Context → Lean.Expr | The expected type of the current `do` block.
This can be different from `earlyReturnType` in `for` loop `do` blocks, for example.
| true |
Interval.completeLattice._proof_4 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] (S : Set (Interval α)),
(⊥ ∉ S ∧ ∀ ⦃s : NonemptyInterval α⦄, ↑s ∈ S → ∀ ⦃t : NonemptyInterval α⦄, ↑t ∈ S → s.toProd.1 ≤ t.toProd.2) →
⨆ i, ⨆ (_ : ↑i ∈ S), i.toProd.1 ≤ (⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.1, ⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.2).2 | null | false |
PrimeSpectrum.BasicConstructibleSetData.map.eq_1 | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (φ : R →+* S)
(C : PrimeSpectrum.BasicConstructibleSetData R),
PrimeSpectrum.BasicConstructibleSetData.map φ C = { f := φ C.f, n := C.n, g := ⇑φ ∘ C.g } | null | true |
Lean.Meta.Match.Example.var.injEq | Lean.Meta.Match.Basic | ∀ (a a_1 : Lean.FVarId), (Lean.Meta.Match.Example.var a = Lean.Meta.Match.Example.var a_1) = (a = a_1) | null | true |
IsSemitopologicalRing.casesOn | Mathlib.Topology.Algebra.Ring.Basic | {R : Type u_2} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocRing R] →
{motive : IsSemitopologicalRing R → Sort u} →
(t : IsSemitopologicalRing R) →
([toIsSemitopologicalSemiring : IsSemitopologicalSemiring R] →
[toContinuousNeg : ContinuousNeg R] → motive ⋯) →
... | null | false |
Std.ExtTreeMap.compare_minKey!_modify_eq | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {f : β → β}, cmp (t.modify k f).minKey! t.minKey! = Ordering.eq | null | true |
CategoryTheory.TransfiniteCompositionOfShape.iic._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : OrderBot J] (j : J), ⊥ ≤ j | null | false |
Std.Internal.UV.TCP.Socket.cancelAccept | Std.Internal.UV.TCP | Std.Internal.UV.TCP.Socket → IO Unit | Cancels the accept request of a socket.
| true |
SimpleGraph.not_reachable_of_neighborSet_right_eq_empty | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, u ≠ v → G.neighborSet v = ∅ → ¬G.Reachable u v | null | true |
MeasureTheory.measurable_mlconvolution | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Mul G] [inst_1 : Inv G] [MeasurableMul₂ G] [MeasurableInv G]
{f g : G → ENNReal} (μ : MeasureTheory.Measure G) [MeasureTheory.SFinite μ],
Measurable f → Measurable g → Measurable (MeasureTheory.mlconvolution f g μ) | The convolution of measurable functions is measurable. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.