name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.smul_add._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, (s ∪ t).IsPWO = (s.IsPWO ∧ t.IsPWO) | null | false |
WeierstrassCurve.Affine.addX_self_of_Y_ne | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] {x y : F},
W.Equation x y →
y ≠ W.negY x y →
W.addX x x (W.slope x x y y) =
(x ^ 4 - WeierstrassCurve.b₄ W * x ^ 2 - 2 * WeierstrassCurve.b₆ W * x - WeierstrassCurve.b₈ W) /
(4 * x ^ 3 + WeierstrassCur... | The explicit duplication formula for the `x`-coordinate when `2*P ≠ 0`. | true |
NumberField.IsCMField.isConj_complexConj | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (φ : K →+* ℂ),
NumberField.ComplexEmbedding.IsConj φ (NumberField.IsCMField.complexConj K) | The complex conjugation is the conjugation of any complex embedding of a CM-field.
| true |
Nat.nth_add_one | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} {n : ℕ}, ¬p 0 → Nat.nth p n ≠ 0 → Nat.nth (fun i => p (i + 1)) n + 1 = Nat.nth p n | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.completeBipartiteGraph_isContained_iff.match_1_7 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_2} {G : SimpleGraph V} {α : Type u_3} {β : Type u_1} [inst : Fintype β]
(f : (completeBipartiteGraph α β).Copy G) (x : V)
(motive : (∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x) → Prop)
(hr : ∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x),
(∀ (w : β) (left : w ∈ F... | null | false |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂),
CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂ →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ComposableArrows.mk₃ f₁₂ f₃ f₄).map' 0 1 C... | null | false |
CategoryTheory.Pseudofunctor.CoGrothendieck.noConfusion | Mathlib.CategoryTheory.Bicategory.Grothendieck | {P : Sort u} →
{𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} →
{t : F.CoGrothendieck} →
{𝒮' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} 𝒮'} →
... | null | false |
CochainComplex.HomComplex.CohomologyClass.toSmallShiftedHom | Mathlib.Algebra.Homology.DerivedCategory.SmallShiftedHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{K L : CochainComplex C ℤ} →
{n : ℤ} →
[inst_2 :
CategoryTheory.Localization.HasSmallLocalizedShiftedHom
(HomologicalComplex.quasiIso C (ComplexShape.up ℤ)) ℤ K L]... | Given `x : CohomologyClass K L n`, this is the element in the type
`SmallShiftedHom` relatively to quasi-isomorphisms that is associated
to the `x`. | true |
Function.Surjective.involutiveNeg._proof_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Neg M₂] [inst_1 : InvolutiveNeg M₁] (f : M₁ → M₂),
(∀ (x : M₁), f (-x) = -f x) → ∀ (x : M₁), - -f x = f x | null | false |
_private.Init.Data.Array.Find.0.Array.getElem?_zero_flatten._simp_1_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {l : List α}, l[0]? = l.head? | null | false |
Std.DTreeMap.Raw.Equiv.forIn_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} {δ : Type w}
{m : Type w → Type w'} [Std.TransCmp cmp] [inst : Monad m] [LawfulMonad m] {b : δ}
{f : (a : α) × β a → δ → m (ForInStep δ)}, t₁.WF → t₂.WF → t₁.Equiv t₂ → forIn t₁ b f = forIn t₂ b f | null | true |
Subgroup.mulSingle_mem_pi._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_5} {f : η → Type u_6} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), (Pi.mulSingle i x ∈ Subgroup.pi I H) = (i ∈ I → x ∈ H i) | null | false |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceOpcyclesE_X₁ | 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₀ i₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.Cat... | null | true |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.TStructure.t._proof_12 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | (ComplexShape.embeddingUpIntLE 0).IsTruncLE | null | false |
_private.Init.Omega.Int.0.Lean.Omega.Fin.ne_iff_lt_or_gt._simp_1_1 | Init.Omega.Int | ∀ {a b : ℕ}, (a ≠ b) = (a < b ∨ b < a) | null | false |
SSet.Subcomplex.Pairing.RankFunction.filtration_of_isSuccLimit | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι) [OrderBot ι]
[SuccOrder ι] (i : ι), Order.IsSuccLimit i → f.filtration i = ⨆ j, ⨆ (_ : j < i), f.filtration j | null | true |
genLoopEquivOfUnique._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} (N : Type u_2) [inst_1 : Unique N] (p : LoopSpace X x),
{ toFun := fun c => p (c default), continuous_toFun := ⋯ } ∈ GenLoop N X x | null | false |
Lean.Server.instMonadLiftCancellableMRequestM.match_1 | Lean.Server.Requests | {α : Type} →
(motive : Except Lean.Server.RequestCancellation α → Sort u_1) →
(r : Except Lean.Server.RequestCancellation α) →
((a : Lean.Server.RequestCancellation) → motive (Except.error a)) → ((v : α) → motive (Except.ok v)) → motive r | null | false |
Lean.Elab.Do.instToMessageDataMutVar | Lean.Elab.Do.Basic | Lean.ToMessageData Lean.Elab.Do.MutVar | null | true |
CategoryTheory.PrelaxFunctorStruct.map₂ | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | {B : Type u₁} →
[inst : Quiver B] →
[inst_1 : (a b : B) → Quiver (a ⟶ b)] →
{C : Type u₂} →
[inst_2 : Quiver C] →
[inst_3 : (a b : C) → Quiver (a ⟶ b)] →
(self : CategoryTheory.PrelaxFunctorStruct B C) →
{a b : B} → {f g : a ⟶ b} → (f ⟶ g) → (self.map f ⟶ self.map... | The action of a lax prefunctor on 2-morphisms. | true |
ArchimedeanClass.closedBallAddSubgroup.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M]
(c : ArchimedeanClass M), c.closedBallAddSubgroup = ArchimedeanClass.addSubgroup (UpperSet.Ici c) | null | true |
Std.DTreeMap.Internal.Const.RicSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Const.RicSliceData α β → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => β) →
(range : Std.Ric α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.Const.Ric... | null | false |
Lean.Data.AC.Variable.mk | Init.Data.AC | {α : Sort u} → {op : α → α → α} → (value : α) → Option (PLift (Std.LawfulIdentity op value)) → Lean.Data.AC.Variable op | null | true |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow_covBySMul_sq_inter_sq._simp_1_10 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
CommRingCat.Colimits.Prequotient.noConfusion | Mathlib.Algebra.Category.Ring.Colimits | {P : Sort u} →
{J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
{F : CategoryTheory.Functor J CommRingCat} →
{t : CommRingCat.Colimits.Prequotient F} →
{J' : Type v} →
{inst' : CategoryTheory.SmallCategory J'} →
{F' : CategoryTheory.Functor J' CommRingCat}... | null | false |
PartOrd.dual | Mathlib.Order.Category.PartOrd | CategoryTheory.Functor PartOrd PartOrd | `OrderDual` as a functor. | true |
Int.ModEq.prod_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℤ} {f : α → ℤ} {s : Finset α}, (∀ x ∈ s, f x ≡ 1 [ZMOD n]) → ∏ x ∈ s, f x ≡ 1 [ZMOD n] | null | true |
CategoryTheory.Adjunction.leftAdjointUniq_trans_assoc | Mathlib.CategoryTheory.Adjunction.Unique | ∀ {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] {F F' F'' : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (adj1 : F ⊣ G) (adj2 : F' ⊣ G) (adj3 : F'' ⊣ G) {Z : CategoryTheory.Functor C D}
(h : F'' ⟶ Z),
CategoryTheory.Ca... | null | true |
_private.Mathlib.MeasureTheory.Integral.PeakFunction.0.tendsto_integral_comp_smul_smul_of_integrable._simp_1_3 | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c ≤ max a b) = (c ≤ a ∨ c ≤ b) | null | false |
UInt64.toNat_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt64), (-a).toNat = (UInt64.size - a.toNat) % UInt64.size | null | true |
_private.Lean.Elab.PreDefinition.FixedParams.0.Lean.Elab.FixedParamPerm.pickFixed.go._f | Lean.Elab.PreDefinition.FixedParams | {α : Type u_1} →
(x : List (Option ℕ × α)) → List.below (motive := fun x => Array α → Id (Array α)) x → Array α → Id (Array α) | null | false |
_private.Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution.0.DiscreteConvolution.single_convolution._proof_1_1 | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {M : Type u_1} [inst : Monoid M] (x : M), (1, x) ∈ DiscreteConvolution.mulFiber x | null | false |
Aesop.GoalState.toNodeState | Aesop.Tree.Data | Aesop.GoalState → Aesop.NodeState | null | true |
_private.Mathlib.Tactic.Translate.Expr.0.Mathlib.Tactic.Translate.findPrefixTranslation?.go._f | Mathlib.Tactic.Translate.Expr | Mathlib.Tactic.Translate.TranslateData →
Lean.Environment →
(n : Lean.Name) →
Lean.Name.below (motive := fun n => List String → Option Mathlib.Tactic.Translate.TranslationInfo) n →
List String → Option Mathlib.Tactic.Translate.TranslationInfo | null | false |
LocallyLipschitz.pow_end._f | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : Function.End α},
LocallyLipschitz f → ∀ (x : ℕ) (f_1 : Nat.below x), LocallyLipschitz (f ^ x) | null | false |
MeasureTheory.Measure.FiniteSpanningSetsIn.disjointed_set_eq | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(S : μ.FiniteSpanningSetsIn {s | MeasurableSet s}), S.disjointed.set = disjointed S.set | null | true |
NNReal.arith_mean_le_rpow_mean | Mathlib.Analysis.MeanInequalitiesPow | ∀ {ι : Type u} (s : Finset ι) (w z : ι → NNReal),
∑ i ∈ s, w i = 1 → ∀ {p : ℝ}, 1 ≤ p → ∑ i ∈ s, w i * z i ≤ (∑ i ∈ s, w i * z i ^ p) ^ (1 / p) | Weighted generalized mean inequality, version for sums over finite sets, with `ℝ≥0`-valued
functions and real exponents. | true |
CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj._proof_2 | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C))
(j : J), (CategoryTheory.CategoryStruct.comp P.p P.p).app j = P.p.app j | null | false |
String.isInt | Init.Data.String.Search | String → Bool | Checks whether the string can be interpreted as the decimal representation of an integer.
A string can be interpreted as a decimal integer if it only consists of at least one decimal digit
and optionally `-` in front. Leading `+` characters are not allowed.
Use `String.toInt?` or `String.toInt!` to convert
such a str... | true |
CategoryTheory.Under.forgetCone._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) ⦃X_1 Y : CategoryTheory.Under X⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const (CategoryTheory.Under X)).obj X).map f) Y.hom =
CategoryTheory.CategoryStruct.comp X_1.hom ((CategoryTheory.Under.forget X).map ... | null | false |
CategoryTheory.MonoidalClosed.enrichedCategorySelf_id | Mathlib.CategoryTheory.Monoidal.Closed.Enrichment | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.MonoidalClosed C] (X : C), CategoryTheory.eId C X = CategoryTheory.MonoidalClosed.id X | null | true |
Std.DTreeMap.Raw.get!_eq_default | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {a : α} [inst_1 : Inhabited (β a)], a ∉ t → t.get! a = default | null | true |
Finset.isScalarTower' | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq γ] [inst_1 : DecidableEq β] [inst_2 : SMul α β]
[inst_3 : SMul α γ] [inst_4 : SMul β γ] [IsScalarTower α β γ], IsScalarTower α (Finset β) (Finset γ) | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback.0.CategoryTheory.MonoidalCategory.Limits.pushout.condition_whiskerRight._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y : C}
(f : W ⟶ X) (g : X ⟶ Y) (Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z)
(CategoryTheory.MonoidalCategoryStruct.whiskerRight g Z) =
Category... | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_466 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
FirstOrder.Language.IsFraisse.is_equiv_invariant | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {K : Set (CategoryTheory.Bundled L.Structure)} [h : FirstOrder.Language.IsFraisse K]
{M N : CategoryTheory.Bundled L.Structure}, Nonempty (L.Equiv ↑M ↑N) → (M ∈ K ↔ N ∈ K) | null | true |
PiLp.nnnorm_single | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [hp : Fact (1 ≤ p)] [inst : Fintype ι]
[inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_2 : DecidableEq ι] (i : ι) (b : β i),
‖PiLp.single p i b‖₊ = ‖b‖₊ | null | true |
String.take_eq | Batteries.Data.String.Lemmas | ∀ (s : String) (n : ℕ), String.Legacy.take s n = String.ofList (List.take n s.toList) | null | true |
Preord.inv_hom_apply | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (e : X ≅ Y) (x : ↑X),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | null | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.midπ_w_f_assoc | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] [inst_3 : CategoryTheory.Mono f]
(n₀ : ℤ) [inst_4 : K.IsStrictlyGE (n₀ + 1)] [inst_5 : L.IsStrictlyGE (n₀ + 1)] (q₁ q₂ : ℕ) (hq : q₁ ... | null | true |
CategoryTheory.Presheaf.isSheaf_iff_extensiveSheaf_of_projective | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u₃}
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] (F : CategoryTheory.Functor Cᵒᵖ A)
[inst_2 : CategoryTheory.Preregular C] [inst_3 : CategoryTheory.FinitaryExtensive C]
[∀ (X : C), CategoryTheory.Projective X],
CategoryTheory.Presheaf.IsS... | null | true |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSimpa?__1_1 | Init.Tactics | Lean.Macro | null | false |
Frm.Hom.recOn | Mathlib.Order.Category.Frm | {X Y : Frm} →
{motive : X.Hom Y → Sort u_1} → (t : X.Hom Y) → ((hom' : FrameHom ↑X ↑Y) → motive { hom' := hom' }) → motive t | null | false |
Polynomial.one_le_cauchyBound._simp_1 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {K : Type u_1} [inst : NormedDivisionRing K] (p : Polynomial K), (1 ≤ p.cauchyBound) = True | null | false |
Std.ExtTreeMap.getKey!_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α}, cmp k k' = Ordering.eq → t.getKey! k = t.getKey! k' | null | true |
Membership.noConfusionType | Init.Prelude | Sort u_1 → {α : Type u} → {γ : Type v} → Membership α γ → {α' : Type u} → {γ' : Type v} → Membership α' γ' → Sort u_1 | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.prod_one_div_prime_den_coprime._simp_1_1 | Mathlib.NumberTheory.Bernoulli | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
HahnSeries.SummableFamily.instModule._proof_10 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_4} {R : Type u_2} {V : Type u_5} {α : Type u_3} [inst : AddCommMonoid Γ]
[inst_1 : PartialOrder Γ] [inst_2 : PartialOrder Γ'] [inst_3 : AddAction Γ Γ'] [inst_4 : IsOrderedCancelVAdd Γ Γ']
[inst_5 : Semiring R] [inst_6 : AddCommMonoid V] [inst_7 : Module R V] (x : HahnSeries Γ R)
(x_1... | null | false |
Bipointed.toProd | Mathlib.CategoryTheory.Category.Bipointed | (self : Bipointed) → self.X × self.X | The two points of a bipointed type, bundled together as a pair. | true |
String.Pos.Raw.offsetOfPos | Init.Data.String.Basic | String → String.Pos.Raw → ℕ | Returns the character index that corresponds to the provided position (i.e. UTF-8 byte index) in a
string.
If the position is at the end of the string, then the string's length in characters is returned. If
the position is invalid due to pointing at the middle of a UTF-8 byte sequence, then the character
index of the ... | true |
CategoryTheory.Limits.limitCompCoyonedaIsoCone._proof_2 | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
(F : CategoryTheory.Functor J C) (X : C),
CategoryTheory.Limits.HasLimit (F.comp (CategoryTheory.coyoneda.obj (Opposite.op X))) | null | false |
Mathlib.Tactic.IntervalCases.Methods.roundDown | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Given `a, b, b', p` where `p` proves `a ≱ b` and `b' := b-1`, prove `a ≤ b'`. | true |
_private.Lean.Linter.MissingDocs.0.Lean.Linter.MissingDocs.missingDocsExt.match_3 | Lean.Linter.MissingDocs | (motive : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler → Sort u_1) →
(x : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler) →
((n k : Lean.Name) → (h : Lean.Linter.MissingDocs.Handler) → motive (n, k, h)) → motive x | null | false |
CentroidHom.applyModule._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), f 0 = 0 | null | false |
Inclusion.IntervalDyadicReal.mem_Ici._inclusionExt_1 | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Basic | Inclusion.InclusionExt | null | false |
SheafOfModules.Presentation.isColimit._proof_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R} (P : M.Presentation),
CategoryTheory.Categ... | null | false |
SubmodulesRingBasis.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
{B : ι → Submodule R A},
(∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j) →
(∀ (a : A) (i : ι), ∃ j, a • B j ≤ B i) → (∀ (i : ι), ∃ j, ↑(B j) * ↑(B j) ⊆ ↑(B i)) → SubmodulesRingBasis B | null | false |
String.Slice.Pos.get_skipWhile_char_ne | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos} {h : pos.skipWhile c ≠ s.endPos}, (pos.skipWhile c).get h ≠ c | null | true |
RelSeries.last_drop | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) (i : Fin (p.length + 1)), (p.drop i).last = p.last | null | true |
CategoryTheory.MorphismProperty.Arrow.isoMk_inv_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q W : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] [inst_2 : W.IsMultiplicative] [inst_3 : Q.RespectsIso] [inst_4 : W.RespectsIso]
{A B : P.Arrow Q W} (f : A.left ≅ B.left) (g : A.right ≅ B.right)
(w :
autoParam (CategoryThe... | null | true |
Function.locallyFinsuppWithin.addSubgroup._proof_1 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] (U : Set X) {Y : Type u_2} [inst_1 : AddGroup Y] {f : X → Y},
f ∈ {f | Function.support f ⊆ U ∧ ∀ z ∈ U, ∃ t ∈ nhds z, (t ∩ Function.support f).Finite} →
-f ∈ {f | Function.support f ⊆ U ∧ ∀ z ∈ U, ∃ t ∈ nhds z, (t ∩ Function.support f).Finite} | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.ErdosStoneSimonovits.0.SimpleGraph.ErdosStone.filter_subset_compl_verts | Mathlib.Combinatorics.SimpleGraph.Extremal.ErdosStoneSimonovits | ∀ {n : ℕ} {G : SimpleGraph (Fin n)} [inst : DecidableRel G.Adj] {r t t' : ℕ} (K : G.CompleteEquipartiteSubgraph r t'),
SimpleGraph.ErdosStone.filter✝ K t ⊆ K.vertsᶜ | null | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_X₁ | 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 k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
_private.Lean.Server.CodeActions.Basic.0.Lean.Server.handleCodeActionResolve.match_3 | Lean.Server.CodeActions.Basic | (motive : Option (IO Lean.Lsp.CodeAction) → Sort u_1) →
(x : Option (IO Lean.Lsp.CodeAction)) →
((lazy : IO Lean.Lsp.CodeAction) → motive (some lazy)) →
((x : Option (IO Lean.Lsp.CodeAction)) → motive x) → motive x | null | false |
_private.Mathlib.Util.AddRelatedDecl.0.Mathlib.Tactic.checkImplicitTransparency._sparseCasesOn_1 | Mathlib.Util.AddRelatedDecl | {motive : Lean.ReducibilityStatus → Sort u} →
(t : Lean.ReducibilityStatus) →
motive Lean.ReducibilityStatus.semireducible → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.initFn._regBuiltin._private.Lean.Meta.Constructions.CtorElim.0.Lean.initFn.docString_1._@.Lean.Meta.Constructions.CtorElim.299025572._hygCtx._hyg.2 | Lean.Meta.Constructions.CtorElim | IO Unit | null | false |
Lean.Syntax.TSepArray.mk | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → {sep : String} → Array Lean.Syntax → Lean.Syntax.TSepArray ks sep | null | true |
Lean.Int.mkInstHPow | Lean.Expr | Lean.Expr | null | true |
ContMDiffSection.toFun | Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{M : Type u_4} →
... | the underlying function of this section | true |
_private.Mathlib.RingTheory.HahnSeries.Summable.0.HahnSeries.SummableFamily.hsum._simp_1 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
(a ∈ x.support) = (x.coeff a ≠ 0) | null | false |
Finsupp.mapRange.equiv._proof_2 | Mathlib.Data.Finsupp.Defs | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Zero M] [inst_1 : Zero N] (e : M ≃ N) (hf : e 0 = 0)
(x : ι →₀ M), Finsupp.mapRange ⇑e.symm ⋯ (Finsupp.mapRange (⇑e) hf x) = x | null | false |
WithTop.instMulZeroOneClass._proof_2 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroOneClass α] [Nontrivial α] (x : WithTop α), x * 1 = x | null | false |
Std.TreeMap.getKey_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k a : α}
{v : β} {h₁ : a ∈ t.insert k v}, (t.insert k v).getKey a h₁ = if h₂ : cmp k a = Ordering.eq then k else t.getKey a ⋯ | null | true |
Std.Http.Header.Name.setCookie | Std.Http.Data.Headers.Name | Std.Http.Header.Name | Standard Set-Cookie header name (server → client)
| true |
alternatingGroup.normal_subgroup_eq_bot_or_eq_top_of_card_ne_six | Mathlib.GroupTheory.SpecificGroups.Alternating.Simple | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α],
5 ≤ Nat.card α → Nat.card α ≠ 6 → ∀ {N : Subgroup ↥(alternatingGroup α)} [N.Normal], N = ⊥ ∨ N = ⊤ | If `α` has at least 5 elements, but not 6,
then the only nontrivial normal subgroup of `alternatingGroup α`
is `⊤`. | true |
Submodule.toLocalized' | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_1} →
(S : Type u_2) →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | The localization map of a submodule. | true |
_private.Mathlib.Computability.EpsilonNFA.0.εNFA.MemεClosure.base | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} {M : εNFA α σ} {S : Set σ}, ∀ s ∈ S, εNFA.MemεClosure✝ M S s | null | true |
SimpleGraph.neighborFinset_nonempty._simp_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)],
(G.neighborFinset v).Nonempty = ¬G.IsIsolated v | null | false |
isGLB_ciInf_set | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : β → α} {s : Set β},
BddBelow (f '' s) → s.Nonempty → IsGLB (f '' s) (⨅ i, f ↑i) | null | true |
Fin.one_eq_zero_iff | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n], 1 = 0 ↔ n = 1 | null | true |
Finset.attach_empty | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1}, ∅.attach = ∅ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.filter_equiv_self_iff._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
Finset.exists_subsuperset_card_eq | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s t : Finset α} {n : ℕ}, s ⊆ t → s.card ≤ n → n ≤ t.card → ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.card = n | Given a subset `s` of a set `t`, of sizes at most and at least `n` respectively, there exists a
set `u` of size `n` which is both a superset of `s` and a subset of `t`. | true |
SheafOfModules.mk.noConfusion | Mathlib.Algebra.Category.ModuleCat.Sheaf | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
{P : Sort u_1} →
{val : PresheafOfModules R.obj} →
{isSheaf : CategoryTheory.Presheaf.IsSheaf J val.presheaf} →
{val'... | null | false |
Orientation.rotation_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)), o.rotation ↑(Real.pi / 2) = o.rightAngleRotation | Rotation by π / 2 is the "right-angle-rotation" map `J`. | true |
MeasureTheory.Measure.isAddLeftInvariant_eq_smul_of_innerRegular | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsAddHaarMeasure] [inst_7 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_8 : μ'.IsAddLe... | **Uniqueness of left-invariant measures**:
Given two left-invariant measures which are finite
on compacts and inner regular, they coincide up to a multiplicative constant. | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ring.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_4 : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof) →
t.ctorIdx = 2 →
((c : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr) →
(lhs : Lean.Meta.Grind.Arith.Linear.LinExpr) →
motive_4 (Lean.Meta.Grind.Arith.Linear.IneqCnstrPro... | null | false |
String.posGE_eq_posGE_toSlice | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} (h : p ≤ s.rawEndPos), s.posGE p h = String.Pos.ofToSlice (s.toSlice.posGE p ⋯) | null | true |
LaurentPolynomial.trunc | Mathlib.Algebra.Polynomial.Laurent | {R : Type u_1} → [inst : Semiring R] → LaurentPolynomial R →+ Polynomial R | `trunc : R[T;T⁻¹] →+ R[X]` maps a Laurent polynomial `f` to the polynomial whose terms of
nonnegative degree coincide with the ones of `f`. The terms of negative degree of `f` "vanish".
`trunc` is a left-inverse to `Polynomial.toLaurent`. | true |
CategoryTheory.Oplax.OplaxTrans.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{t : CategoryTheory.Oplax.OplaxTrans.Hom η θ} →
{B' : Type u₁} ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.