name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
PiTensorProduct.distribMulAction'._proof_1 | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {R₁ : Type u_4} {s : ι → Type u_3}
[inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
[inst_4 : DistribMulAction R₁ R] [inst_5 : SMulCommClass R₁ R R] (r r' : R₁) {r'' : R} {f : (i : ι) → s i},
(r * r') • PiTens... | null | false |
List.minimum_cons | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] (a : α) (l : List α), (a :: l).minimum = min (↑a) l.minimum | null | true |
List.SortedLT | Mathlib.Data.List.Sort | {α : Type u_1} → [Preorder α] → List α → Prop | `l.SortedLT` means that the list is strictly monotonic. | true |
Lean.PrettyPrinter.Delaborator.delabAttribute | Lean.PrettyPrinter.Delaborator.Basic | Lean.KeyedDeclsAttribute Lean.PrettyPrinter.Delaborator.Delab | Registers a delaborator.
`@[delab k]` registers a declaration of type `Lean.PrettyPrinter.Delaborator.Delab` for the
`Lean.Expr` constructor `k`. Multiple delaborators for a single constructor are tried in turn until
the first success. If the term to be delaborated is an application of a constant `c`, elaborators
for ... | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrM._proof_5 | Batteries.Data.Vector.Basic | ∀ {n : ℕ}, ∀ i ≤ n, 0 < i → ¬n - i + 1 = n - (i - 1) → False | null | false |
Int.mul_tdiv_cancel_left | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} (b : ℤ), a ≠ 0 → (a * b).tdiv a = b | null | true |
Finset.HasMulAntidiagonal.mem_mulAntidiagonal | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_1} {inst : Mul A} [self : Finset.HasMulAntidiagonal A] {n : A} {a : A × A},
a ∈ Finset.HasMulAntidiagonal.mulAntidiagonal n ↔ a.1 * a.2 = n | A pair belongs to `mulAntidiagonal n` iff the product of its components is equal to `n`. | true |
Lean.Lsp.instToJsonTextDocumentIdentifier.toJson | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentIdentifier → Lean.Json | null | true |
MulEquiv.instFintype._proof_2 | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β] [inst_2 : DecidableEq β] [inst_3 : Fintype α]
(a a' : α ≃ β),
∀ b ∈ if h : ∀ (a_1 b : α), a (a_1 * b) = a a_1 * a b then some { toEquiv := a, map_mul' := h } else none,
(b ∈ if h : ∀ (a b : α), a' (a * b) = a' a * a' b then some { toEquiv := a', ma... | null | false |
Quot.out | Mathlib.Data.Quot | {α : Sort u_1} → {r : α → α → Prop} → Quot r → α | Choose an element of the equivalence class using the axiom of choice.
Sound but noncomputable. | true |
Lean.PArray | Lean.Data.PersistentArray | Type u → Type u | null | true |
CategoryTheory.CommComon.instCategory._proof_8 | Mathlib.CategoryTheory.Monoidal.CommComon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {X Y : CategoryTheory.CommComon C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryT... | null | false |
AddSubgroup.orderIsoAddCon._proof_7 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {a b : { N // N.Normal }},
{ toFun := fun N => QuotientAddGroup.con ↑N, invFun := fun c => ⟨c.addSubgroup, ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
a ≤
{ toFun := fun N => QuotientAddGroup.con ↑N, invFun := fun c => ⟨c.addSubgroup, ⋯⟩, left_inv := ⋯,
right_inv :... | null | false |
HasDerivAt.congr_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' g' : F} {x : 𝕜}, HasDerivAt f f' x → f' = g' → HasDerivAt f g' x | null | true |
AddUnits.map._proof_6 | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : AddMonoid N] (f : M →+ N) (x x_1 : AddUnits M),
{ val := f ↑(x + x_1), neg := f (x + x_1).neg, val_neg := ⋯, neg_val := ⋯ } =
{ val := f ↑x, neg := f x.neg, val_neg := ⋯, neg_val := ⋯ } +
{ val := f ↑x_1, neg := f x_1.neg, val_neg := ⋯, neg_val ... | null | false |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.Functor.copyObj._proof_3 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (obj : C → D)
(e : (X : C) → F.obj X ≅ obj X) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (e X).inv
(CategoryTheory.Categ... | null | false |
PMF.mem_support_ofMultiset_iff | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_2} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {s : Multiset α} (a : α),
(MeasureTheory.Measure.ofMultiset s) {a} = ↑(Multiset.count a s) / ↑s.card | **Alias** of `MeasureTheory.Measure.ofMultiset_apply_singleton`. | true |
Matrix.vec2_add | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} [inst : Add α] (a₀ a₁ b₀ b₁ : α), ![a₀, a₁] + ![b₀, b₁] = ![a₀ + b₀, a₁ + b₁] | null | true |
_private.Mathlib.Data.EReal.Basic.0.Mathlib.Meta.Positivity.evalRealToEReal._proof_2 | Mathlib.Data.EReal.Basic | ∀ (α : Q(Type)) (val : Q(PartialOrder «$α»)) (__defeqres : PLift («$val» =Q instPartialOrderEReal)),
«$val» =Q instPartialOrderEReal | null | false |
Valuation.OrderMonoidWithZeroHom.ofClass_monotone | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀),
MonoidWithZeroHom.ofClass v = ↑v | **Alias** of `Valuation.ofClass_eq_toMonoidWithZeroHom`. | true |
_private.Lean.Elab.RecAppSyntax.0.Lean.getRecAppSyntax?.match_1 | Lean.Elab.RecAppSyntax | (motive : Option Lean.DataValue → Sort u_1) →
(x : Option Lean.DataValue) →
((stx : Lean.Syntax) → motive (some (Lean.DataValue.ofSyntax stx))) →
((x : Option Lean.DataValue) → motive x) → motive x | null | false |
CategoryTheory.isCoseparator_of_isLimit_fan | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {β : Type w}
{f : β → C},
(CategoryTheory.ObjectProperty.ofObj f).IsCoseparating →
∀ {c : CategoryTheory.Limits.Fan f} (hc : CategoryTheory.Limits.IsLimit c), CategoryTheory.IsCoseparator c.pt | null | true |
Lean.Compiler.LCNF.CSE.State.mk.injEq | Lean.Compiler.LCNF.CSE | ∀ (map : Lean.PHashMap Lean.Expr Lean.FVarId) (subst : Lean.Compiler.LCNF.FVarSubst Lean.Compiler.LCNF.Purity.pure)
(map_1 : Lean.PHashMap Lean.Expr Lean.FVarId) (subst_1 : Lean.Compiler.LCNF.FVarSubst Lean.Compiler.LCNF.Purity.pure),
({ map := map, subst := subst } = { map := map_1, subst := subst_1 }) = (map = ma... | null | true |
ContinuousLinearMapWOT.toCLM_surjective._simp_1 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_4} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F],
Function.Surjecti... | null | false |
TopologicalSpace.Opens.instIsDenseSubsiteOverSubtypeMemOverGrothendieckTopologyInverseSymmOverEquivalence | Mathlib.Topology.Sheaves.Over | ∀ {X : Type u} [inst : TopologicalSpace X] (U : TopologicalSpace.Opens X),
CategoryTheory.Functor.IsDenseSubsite ((Opens.grothendieckTopology X).over U) (Opens.grothendieckTopology ↥U)
U.overEquivalence.symm.inverse | null | true |
AddCon.addGroup._proof_4 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : AddGroup M] (c : AddCon M),
autoParam (∀ (n : ℕ) (a : c.Quotient), Int.negSucc n • a = -(↑n.succ • a)) SubNegMonoid.zsmul_neg'._autoParam | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_121 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Subtype.coind.congr_simp | Mathlib.Data.Set.Operations | ∀ {α : Sort u_4} {β : Sort u_5} (f f_1 : α → β) (e_f : f = f_1) {p : β → Prop} (h : ∀ (a : α), p (f a)) (a a_1 : α),
a = a_1 → Subtype.coind f h a = Subtype.coind f_1 ⋯ a_1 | null | true |
AbstractSimplicialComplex.instCompleteSemilatticeInf._proof_1 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ {ι : Type u_1} (x : Set (AbstractSimplicialComplex ι)), sInf x ∈ lowerBounds x ∧ sInf x ∈ upperBounds (lowerBounds x) | null | false |
Std.TransCmp.lt_of_isLE_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
(cmp a b).isLE = true → cmp b c = Ordering.lt → cmp a c = Ordering.lt | null | true |
Std.WP.StateT.instWPMonad | Std.WP.Monad.Instances | {m : Type u → Type z} →
{EPred : Type v} →
{σ : Type u} →
{Pred : Type w} →
[inst : Monad m] →
[inst_1 : Std.WP.Assertion Pred] →
[inst_2 : Std.WP.Assertion EPred] →
[Std.WP.WPMonad m Pred EPred] → Std.WP.WPMonad (StateT σ m) (σ → Pred) EPred | `StateT` lifts a `WPMonad` instance by adding a state argument. | true |
StarAlgEquiv.toNonUnitalStarAlgHom._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A₁ : Type u_2} {A₂ : Type u_1} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A₁]
[inst_2 : DistribMulAction R A₁] [inst_3 : Star A₁] [inst_4 : NonUnitalNonAssocSemiring A₂]
[inst_5 : DistribMulAction R A₂] [inst_6 : Star A₂] (e : A₁ ≃⋆ₐ[R] A₂) (r : R) (a : A₁),
e.toFun (r • a) = r • e.to... | null | false |
Modular.«_aux_Mathlib_NumberTheory_Modular___macroRules_Modular_term𝒟ᵒ_1» | Mathlib.NumberTheory.Modular | Lean.Macro | null | false |
_private.Lean.Meta.Injective.0.Lean.Meta.MkHInjTypeResult.mk._flat_ctor | Lean.Meta.Injective | Lean.Expr → List Lean.Level → ℕ → Lean.Meta.MkHInjTypeResult✝ | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_603 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Manifold.IsImmersionAtOfComplement.instNormedAddCommGroupSmallComplement._aux_34 | Mathlib.Geometry.Manifold.Immersion | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_3} →
{E'' : Type u_1} →
{F : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup E''] →
[inst_4 : NormedSpace 𝕜 E''] →
... | null | false |
Profinite.NobelingProof.C0 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | {I : Type u} →
Set (I → Bool) →
[inst : LinearOrder I] →
[inst_1 : WellFoundedLT I] → {o : Ordinal.{u}} → (o < Ordinal.type fun x1 x2 => x1 < x2) → Set (I → Bool) | The subset of `C` consisting of those elements whose `o`-th entry is `false`. | true |
WithLp.linearEquiv_apply | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) (K : Type u_1) (V : Type u_4) [inst : Semiring K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(a : WithLp p V), (WithLp.linearEquiv p K V) a = (WithLp.addEquiv p V).toFun a | null | true |
Subspace.top_mem_of_biUnion_eq_univ | Mathlib.GroupTheory.CosetCover | ∀ {k : Type u_1} {E : Type u_2} [inst : DivisionRing k] [Infinite k] [inst_2 : AddCommGroup E] [inst_3 : Module k E]
{s : Finset (Subspace k E)}, ⋃ p ∈ s, ↑p = Set.univ → ⊤ ∈ s | A vector space over an infinite field cannot be a finite union of proper subspaces. | true |
Mathlib.Meta.NormNum.isNat_clog | Mathlib.Tactic.NormNum.NatLog | ∀ {b nb n nn k : ℕ},
Mathlib.Meta.NormNum.IsNat b nb →
Mathlib.Meta.NormNum.IsNat n nn → Nat.clog nb nn = k → Mathlib.Meta.NormNum.IsNat (Nat.clog b n) k | null | true |
Lean.Order.FlatOrder | Init.Internal.Order.Basic | {α : Sort u} → α → Sort u | `FlatOrder b` wraps the type `α` with the flat partial order generated by `∀ x, b ⊑ x`.
This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
| true |
CategoryTheory.AddGrp.comp'_assoc | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A₁ A₂ A₃ : CategoryTheory.AddGrp C} (f : A₁ ⟶ A₂) (g : A₂ ⟶ A₃) {Z : CategoryTheory.AddMon C} (h : A₃.toAddMon ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g).hom h =
... | null | true |
CategoryTheory.Limits.Sigma.π.hcongr_8 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ (C C' : Type u),
C = C' →
∀ (inst : CategoryTheory.Category.{v, u} C) (inst' : CategoryTheory.Category.{v, u} C'),
inst ≍ inst' →
∀ (inst_1 : CategoryTheory.Limits.HasZeroMorphisms C) (inst'_1 : CategoryTheory.Limits.HasZeroMorphisms C'),
inst_1 ≍ inst'_1 →
∀ (β β' : Type w),... | null | true |
Polynomial.smeval_at_natCast | Mathlib.Algebra.Polynomial.Smeval | ∀ {S : Type u_2} [inst : NonAssocSemiring S] [inst_1 : Pow S ℕ] [NatPowAssoc S] (q : Polynomial ℕ) (n : ℕ),
q.smeval ↑n = ↑(q.smeval n) | null | true |
Ideal.quotEquivPowQuotPowSuccEquiv | Mathlib.RingTheory.Ideal.IsPrincipalPowQuotient | {R : Type u_1} →
[inst : CommRing R] →
[IsDomain R] → {I : Ideal R} → Submodule.IsPrincipal I → I ≠ ⊥ → (n : ℕ) → R ⧸ I ≃ ↥(I ^ n) ⧸ I • ⊤ | For a principal ideal `I`, `R ⧸ I ≃ I ^ n ⧸ I ^ (n + 1)`. Supplied as a plain equiv to bypass
typeclass synthesis issues on complex `Module` goals. To convert into a form
that uses the ideal of `R ⧸ I ^ (n + 1)`, compose with
`Ideal.powQuotPowSuccEquivMapMkPowSuccPow`. | true |
CochainComplex.singleFunctors._proof_7 | Mathlib.Algebra.Homology.HomotopyCategory.SingleFunctors | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (a : ℤ),
CategoryTheory.NatIso.ofComponents
(fun X => HomologicalComplex.Hom.isoOfComponents (fun i => CategoryTheory.eqToIso ⋯) ⋯) ⋯ =
(HomologicalComple... | null | false |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.Scheme.Opens.nonempty_iff._simp_1_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {α : Sort u_3} {p : α → Prop}, Nonempty (Subtype p) = ∃ a, p a | null | false |
MonoidHom.comp_noncommCoprod | Mathlib.GroupTheory.NoncommCoprod | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : Monoid P]
(f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) {Q : Type u_4} [inst_3 : Monoid Q]
(h : P →* Q), h.comp (f.noncommCoprod g comm) = (h.comp f).noncommCoprod (h.comp g) ⋯ | null | true |
_private.Init.PropLemmas.0.exists_and_self.match_1_3 | Init.PropLemmas | ∀ (P : Prop) (Q : P → Prop) (motive : (∃ (p : P), Q p) → Prop) (x : ∃ (p : P), Q p),
(∀ (p : P) (q : Q p), motive ⋯) → motive x | null | false |
Lean.Elab.Command.State.noConfusion | Lean.Elab.Command | {P : Sort u} → {t t' : Lean.Elab.Command.State} → t = t' → Lean.Elab.Command.State.noConfusionType P t t' | null | false |
CategoryTheory.GrpObj.eq_lift_inv_left | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.GrpObj B] (f g h : A ⟶ B),
f =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.comp g Ca... | null | true |
IndepMatroid.ofBddAugment_E | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} (E : Set α) (Indep : Set α → Prop) (indep_empty : Indep ∅)
(indep_subset : ∀ ⦃I J : Set α⦄, Indep J → I ⊆ J → Indep I)
(indep_aug : ∀ ⦃I J : Set α⦄, Indep I → Indep J → I.encard < J.encard → ∃ e ∈ J, e ∉ I ∧ Indep (insert e I))
(indep_bdd : ∃ n, ∀ (I : Set α), Indep I → I.encard ≤ ↑n) (subset_gro... | null | true |
CategoryTheory.ObjectProperty.singleton_le_iff._simp_1 | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {X : C} {P : CategoryTheory.ObjectProperty C},
(CategoryTheory.ObjectProperty.singleton X ≤ P) = P X | null | false |
_private.Init.Prelude.0.Nat.le_trans.match_1_1 | Init.Prelude | ∀ {n m : ℕ} (motive : (k : ℕ) → n ≤ m → m ≤ k → Prop) (k : ℕ) (x : n ≤ m) (x_1 : m ≤ k),
(∀ (h : n ≤ m), motive m h ⋯) → (∀ (h₁ : n ≤ m) (m_1 : ℕ) (h₂ : m.le m_1), motive m_1.succ h₁ ⋯) → motive k x x_1 | null | false |
_private.Mathlib.MeasureTheory.Integral.SetToL1.Function.0.MeasureTheory.continuous_setToFun._simp_1_2 | Mathlib.MeasureTheory.Integral.SetToL1.Function | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {y : Y},
(Continuous fun x => y) = True | null | false |
CategoryTheory.sheafify_hom_ext | Mathlib.CategoryTheory.Sites.Sheafification | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
{P Q : CategoryTheory.Functor Cᵒᵖ D} (η γ : CategoryTheory.sheafify J P ⟶ Q),
CategoryTheory.Presheaf... | null | true |
IsCyclotomicExtension.autEquivPow._proof_3 | Mathlib.NumberTheory.Cyclotomic.Gal | ∀ {n : ℕ} [inst : NeZero n] {K : Type u_1} [inst_1 : Field K] (L : Type u_2) [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L],
Irreducible (Polynomial.cyclotomic n K) →
∀ (t : (ZMod n)ˣ), minpoly K (IsPrimitiveRoot.powerBasis K ⋯).gen = minpoly K (IsPri... | null | false |
Lean.Grind.LinarithConfig.locals._inherited_default | Init.Grind.Config | Bool | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.disjoint_of_disjoint_support._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} (H : SimpleGraph V),
(∀ ⦃a : V⦄, (∃ w, G.Adj a w) → ¬∃ w, H.Adj a w) →
∀ (x y : V),
Quot.mk (Sym2.Rel V) (x, y) ∈ (SimpleGraph.edgeSetEmbedding V) G →
Quot.mk (Sym2.Rel V) (x, y) ∉ (SimpleGraph.edgeSetEmbedding V) H | null | false |
PFunctor.Approx.CofixA._sizeOf_1 | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {a : ℕ} → PFunctor.Approx.CofixA F a → ℕ | null | false |
CategoryTheory.leftDistributor_ext₂_left_iff | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {X Y Z : C} {f : J → C}
{g h :
Catego... | null | true |
PFunctor.MIntl.mk._flat_ctor | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → (approx : (n : ℕ) → PFunctor.Approx.CofixA F n) → PFunctor.Approx.AllAgree approx → F.MIntl | null | false |
Lean.Elab.Tactic.Location.wildcard | Lean.Elab.Tactic.Location | Lean.Elab.Tactic.Location | Apply the tactic everywhere. | true |
Subsemiring.smul_def | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R' : Type u_1} {α : Type u_2} [inst : NonAssocSemiring R'] [inst_1 : SMul R' α] {S : Subsemiring R'} (g : ↥S)
(m : α), g • m = ↑g • m | null | true |
QuadraticMap.map_sum | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] {ι : Type u_8} [inst_5 : DecidableEq ι] (Q : QuadraticMap R M N)
(s : Finset ι) (f : ι → M),
Q (∑ i ∈ s, f i) = ∑ i ∈ s, Q (f i) + ∑ ij ∈ s.sym2 with ¬... | null | true |
EReal.le_mul_of_forall_lt | Mathlib.Data.EReal.Inv | ∀ {a b c : EReal}, 0 < a ∨ b ≠ ⊤ → a ≠ ⊤ ∨ 0 < b → (∀ a' > a, ∀ b' > b, c ≤ a' * b') → c ≤ a * b | null | true |
toLex_neg | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Neg α] (a : α), toLex (-a) = -toLex a | null | true |
_private.Mathlib.NumberTheory.ModularForms.Bounds.0.UpperHalfPlane.qExpansion_coeff_eq_exp_mul_fourierCoeffOn._simp_1_1 | Mathlib.NumberTheory.ModularForms.Bounds | ∀ (x : ℂ) (n : ℕ), Complex.exp x ^ n = Complex.exp (↑n * x) | null | false |
Ring.multichoose_eq | Mathlib.RingTheory.Binomial | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : Pow R ℕ] [inst_2 : BinomialRing R] (r : R) (n : ℕ),
Ring.multichoose r n = Ring.choose (r + ↑n - 1) n | null | true |
SimpleGraph.Walk.firstDart.congr_simp | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} (p p_1 : G.Walk v w) (e_p : p = p_1) (hp : ¬p.Nil),
p.firstDart hp = p_1.firstDart ⋯ | null | true |
QuotientGroup.coe_mk' | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal], ⇑(QuotientGroup.mk' N) = QuotientGroup.mk | null | true |
CategoryTheory.GrothendieckTopology.recOn | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.GrothendieckTopology C → Sort u_1} →
(t : CategoryTheory.GrothendieckTopology C) →
((sieves : (X : C) → Set (CategoryTheory.Sieve X)) →
(top_mem' : ∀ (X : C), ⊤ ∈ sieves X) →
(pullback_stabl... | null | false |
Std.Rxc.Iterator.pairwise_toList_upwardEnumerableLt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α] [Std.Rxc.IsAlwaysFinite α]
(it : Std.Iter α), List.Pairwise (fun a b => Std.PRange.UpwardEnumerable.LT a b) it.toList | null | true |
CategoryTheory.IsCoseparator.rightAdjoint_obj | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : C},
CategoryTheory.IsCoseparator X →
∀ {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} [G.Faithful] (adj : G ⊣ F),
CategoryTheory.IsCoseparator (F.obj X) | null | true |
Tactic.ComputeAsymptotics.Majorized.zero | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Majorized | ∀ {b : ℝ → ℝ} {exp : ℝ}, Tactic.ComputeAsymptotics.Majorized 0 b exp | The zero function is majorized with any exponent. | true |
String.Slice.RevPosIterator.mk | Init.Data.String.Iterate | {s : String.Slice} → s.Pos → s.RevPosIterator | null | true |
AlgebraicGeometry.pullbackRestrictIsoRestrict_inv_fst_assoc | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.pullbackRestrictIsoRestrict f U).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f U.ι) h) =
CategoryTheory.CategoryStruc... | null | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.succ_signVariations_le_X_sub_C_mul._proof_1_1 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {P : Polynomial R},
P ≠ 0 → ¬0 < P.leadingCoeff → 0 < (-P).leadingCoeff | null | false |
CategoryTheory.MorphismProperty.pushout_inr_iff | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {Z X Y : C}
{f : Z ⟶ X} {g : Z ⟶ Y} [P.IsStableUnderCobaseChange] [P.CodescendsAlong Q]
[inst_3 : CategoryTheory.Limits.HasPushout f g], Q g → (P (CategoryTheory.Limits.pushout.inr f g) ↔ P f) | null | true |
CommSemiring.toBialgebra | Mathlib.RingTheory.Bialgebra.Basic | (R : Type u) → [inst : CommSemiring R] → Bialgebra R R | Every commutative (semi)ring is a bialgebra over itself | true |
Orthonormal.inner_left_finsupp | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {v : ι → E},
Orthonormal 𝕜 v → ∀ (l : ι →₀ 𝕜) (i : ι), inner 𝕜 ((Finsupp.linearCombination 𝕜 v) l) (v i) = (starRingEnd 𝕜) (l i) | The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector. | true |
Std.Http.Protocol.H1.PulledChunk.recOn | Std.Http.Protocol.H1 | {motive : Std.Http.Protocol.H1.PulledChunk → Sort u} →
(t : Std.Http.Protocol.H1.PulledChunk) →
((final incomplete : Bool) →
(chunk : Std.Http.Chunk) → motive { final := final, incomplete := incomplete, chunk := chunk }) →
motive t | null | false |
_private.Mathlib.Topology.LocallyConstant.Basic.0.LocallyConstant.piecewise._simp_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x : p → α} {y : α},
((if h : p then x h else y) = y) = ∀ (h : p), x h = y | null | false |
Real.expPartialHomeomorph._proof_2 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ x ∈ Set.Ioi 0, Real.log x ∈ Set.univ | null | false |
AlgebraicGeometry.PresheafedSpace | Mathlib.Geometry.RingedSpace.PresheafedSpace | (C : Type u_1) → [CategoryTheory.Category.{v_1, u_1} C] → Type (max (max (u + 1) u_1) v_1) | A `PresheafedSpace C` is a topological space equipped with a presheaf of `C`s. | true |
Std.ExtHashSet.getD_inter_of_not_mem_right | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k fallback : α}, k ∉ m₂ → (m₁ ∩ m₂).getD k fallback = fallback | null | true |
Orientation.definition._proof_7._@.Mathlib.Analysis.InnerProductSpace.TwoDim.1773570744._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E], SMulCommClass ℝ ℝ (E →ₗ[ℝ] ℝ) | null | false |
CategoryTheory.instNontrivialEndOfSimple | Mathlib.CategoryTheory.Simple | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
[CategoryTheory.Simple X], Nontrivial (CategoryTheory.End X) | null | true |
Sum.elim_intCast_intCast | Mathlib.Data.Int.Cast.Pi | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : IntCast γ] (n : ℤ), Sum.elim ↑n ↑n = ↑n | null | true |
ContDiffMapSupportedIn.structureMapLM._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (i : ℕ), BoundedAdd (E [×i]→L[ℝ] F) | null | false |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.Composition.recOnSingleAppend.match_3._arg_pusher | Mathlib.Combinatorics.Enumerative.Composition | ∀ (motive : (n : ℕ) → Composition n → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x)
(rel : (n : ℕ) → Composition n → α → Prop) (n : ℕ) (c : Composition n)
(h_1 :
(blocks : List ℕ) →
(blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i) →
((y : α) → rel blocks.sum { blocks := blocks, blocks_... | null | false |
FirstOrder.Language.Structure.funMap | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} → {M : Type w} → [self : L.Structure M] → {n : ℕ} → L.Functions n → (Fin n → M) → M | Interpretation of the function symbols | true |
String.intercalate_singleton | Init.Data.String.Lemmas.Intercalate | ∀ {s t : String}, s.intercalate [t] = t | null | true |
Std.HashMap.getKey!_ofList_of_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] [inst : Inhabited α]
{l : List (α × β)} {k : α}, (List.map Prod.fst l).contains k = false → (Std.HashMap.ofList l).getKey! k = default | null | true |
CategoryTheory.Groupoid.isIsomorphic_iff_nonempty_hom | Mathlib.CategoryTheory.IsomorphismClasses | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {X Y : C}, CategoryTheory.IsIsomorphic X Y ↔ Nonempty (X ⟶ Y) | null | true |
Multiset.rel_add_left | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} {β : Type v} {r : α → β → Prop} {as₀ as₁ : Multiset α} {bs : Multiset β},
Multiset.Rel r (as₀ + as₁) bs ↔ ∃ bs₀ bs₁, Multiset.Rel r as₀ bs₀ ∧ Multiset.Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁ | null | true |
instULiftableId | Mathlib.Control.ULiftable | ULiftable Id Id | null | true |
Metric.mem_closedEBall._simp_1 | Mathlib.Topology.EMetricSpace.Defs | ∀ {ε : ENNReal} {α : Type u_4} [inst : EDist α] {x y : α}, (y ∈ Metric.closedEBall x ε) = (edist y x ≤ ε) | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.bmod_natAbs_add_one._proof_1_4 | Init.Data.Int.DivMod.Lemmas | ∀ x < 0, ¬- -1 - x = ↑(x.natAbs + 1) * 1 → False | null | false |
Real.rpow_eq_const_mul_integral_rpowIntegrand₁₂ | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p x : ℝ},
p ∈ Set.Ioo 1 2 →
0 ≤ x →
x ^ p = (∫ (t : ℝ) in Set.Ioi 0, (p - 1).rpowIntegrand₀₁ t 1)⁻¹ * ∫ (t : ℝ) in Set.Ioi 0, p.rpowIntegrand₁₂ t x | The integral representation of the function `x ↦ x^p` (where `p ∈ (1, 2)`) . | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.