name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.sublist_cons_of_sublist | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α} (a : α), l₁.Sublist l₂ → l₁.Sublist (a :: l₂) | null | true |
List.Nodup.eq_of_getElem?_eq | Init.Data.List.Pairwise | ∀ {α : Type u_1} {i j : ℕ} {xs : List α}, xs.Nodup → i < xs.length → xs[i]? = xs[j]? → i = j | null | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_add_mul_monomial_right._proof_1_24 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ (m n k : ℕ), k + m ≤ n → ∀ (j₂ : Fin m), ↑j₂ + 1 ≤ m → k + ↑j₂ < n | null | false |
Polynomial.IsMonicOfDegree.eq_isMonicOfDegree_two_mul_isMonicOfDegree | Mathlib.Analysis.Polynomial.Factorization | ∀ {f : Polynomial ℝ} {n : ℕ},
f.IsMonicOfDegree (n + 2) → ∃ f₁ f₂, f₁.IsMonicOfDegree 2 ∧ f₂.IsMonicOfDegree n ∧ f = f₁ * f₂ | If `f : ℝ[X]` is monic of degree `≥ 2`, then `f = f₁ * f₂` with `f₁` monic of degree `2`
and `f₂` monic of degree `f.natDegree - 2`.
This relies on the fact that irreducible polynomials over `ℝ` have degree at most `2`. | true |
Algebra.IsCentral.baseField_essentially_unique | Mathlib.Algebra.Central.Basic | ∀ (k : Type u_1) (K : Type u_2) (D : Type u_3) [inst : Field k] [inst_1 : Field K] [inst_2 : Ring D] [Nontrivial D]
[inst_4 : Algebra k K] [inst_5 : Algebra K D] [inst_6 : Algebra k D] [IsScalarTower k K D] [Algebra.IsCentral k D],
Function.Bijective ⇑(algebraMap k K) | null | true |
Submodule.coe_iSup_eq_iUnion_finset_coe_biSup | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_8}
(S : ι → Submodule R M), ↑(⨆ i, S i) = ⋃ s, ↑(⨆ i ∈ s, S i) | null | true |
_private.Batteries.Data.Char.AsciiCasing.0.Char.toLower_eq_of_isUpper._proof_1_4 | Batteries.Data.Char.AsciiCasing | ∀ {c : Char}, 65 ≤ c.toNat ∧ c.toNat ≤ 90 → c.toNat + 32 < 55296 ∨ 57343 < c.toNat + 32 ∧ c.toNat + 32 < 1114112 | null | false |
Stream'.take | Mathlib.Data.Stream.Defs | {α : Type u} → ℕ → Stream' α → List α | `take n s` returns a list of the `n` first elements of stream `s` | true |
OrderAddMonoidIso.coe_addEquiv | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : Add β]
(f : α ≃+o β), ⇑↑f = ⇑f | null | true |
Aesop.Script.Tactic.recOn | Aesop.Script.Tactic | {motive : Aesop.Script.Tactic → Sort u} →
(t : Aesop.Script.Tactic) →
((uTactic : Aesop.Script.UTactic) →
(sTactic? : Option Aesop.Script.STactic) → motive { uTactic := uTactic, sTactic? := sTactic? }) →
motive t | null | false |
CategoryTheory.nerveFunctor._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {X Y Z : CategoryTheory.Cat} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.nerveMap (CategoryTheory.CategoryStruct.comp f g).toFunctor =
CategoryTheory.CategoryStruct.comp (CategoryTheory.nerveMap f.toFunctor) (CategoryTheory.nerveMap g.toFunctor) | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.IsPos.add._proof_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {b : P.Base}
[inst_5 : CharZero R] {i j : ι}, 0 < b.height i → 0 < b.height j → 0 < b.height i + b.height j | null | false |
Antivary.antivaryOn | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
Antivary f g → ∀ (s : Set ι), AntivaryOn f g s | null | true |
Filter.frequently_neg_filter | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {f : Filter β} {a : α} {p : β → Prop},
(∃ᶠ (y : β) in a +ᵥ f, p y) ↔ ∃ᶠ (x : β) in f, p (a +ᵥ x) | null | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.injEq | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (f : Mathlib.Tactic.BicategoryLike.Mor₁) (e_1 : Lean.Expr) (f_1 : Mathlib.Tactic.BicategoryLike.Mor₁),
(Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f = Mathlib.Tactic.BicategoryLike.StructuralAtom.id e_1 f_1) =
(e = e_1 ∧ f = f_1) | null | true |
Ideal.span_pair_eq_span_right_iff_dvd._simp_1 | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, (Ideal.span {x, y} = Ideal.span {y}) = (y ∣ x) | null | false |
_private.Mathlib.Order.SuccPred.Tree.0.IsPredArchimedean.pred_findAtom._simp_1_1 | Mathlib.Order.SuccPred.Tree | ∀ {α : Type u} (f : α → α) (n : ℕ) (x : α), f (f^[n] x) = f^[n.succ] x | null | false |
Lean.Lsp.CompletionClientCapabilities._sizeOf_1 | Lean.Data.Lsp.Capabilities | Lean.Lsp.CompletionClientCapabilities → ℕ | null | false |
_private.Mathlib.NumberTheory.NumberField.Units.DirichletTheorem.0.NumberField.Units.dirichletUnitTheorem.unitLattice_span_eq_top.match_1_1 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(v : { w // w ≠ NumberField.Units.dirichletUnitTheorem.w₀ } → NumberField.Units.dirichletUnitTheorem.logSpace K)
(x : { w // w ≠ NumberField.Units.dirichletUnitTheorem.w₀ } → ℝ) (motive : x ∈ Set.range v → Prop)
(x_1 : x ∈ Set.range v),
(∀ (w : { w // w... | null | false |
DirectLimit.instMulOneClassOfMonoidHomClass.eq_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | true |
Monotone.neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} {β : Type u_1} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftMono α] [AddRightMono α]
[inst_4 : Preorder β] {f : β → α}, Monotone f → Antitone fun x => -f x | null | true |
AnalyticAt.fun_comp | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {g : F → G} {f : E → F} {x : E},
An... | Eta-expanded form of `AnalyticAt.comp`
---
If two functions `g` and `f` are analytic respectively at `f x` and `x`, then `g ∘ f` is
analytic at `x`. | true |
ImportGraph.Shake.ImportNeedsKind.metaPriv | ImportGraph.Shake.DeclNeeds | ImportGraph.Shake.ImportNeedsKind | null | true |
Polynomial.isUnit_leadingCoeff_mul_right_eq_zero_iff | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, IsUnit p.leadingCoeff → ∀ {q : Polynomial R}, p * q = 0 ↔ q = 0 | null | true |
MeasureTheory.ae_restrict_biUnion_finset_eq | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {ι : Type u_5} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : ι → Set α) (t : Finset ι),
MeasureTheory.ae (μ.restrict (⋃ i ∈ t, s i)) = ⨆ i ∈ t, MeasureTheory.ae (μ.restrict (s i)) | null | true |
Bool.eq_self_and._simp_1 | Init.Data.Bool | ∀ {a b : Bool}, (a = (a && b)) = (a = true → b = true) | null | false |
CategoryTheory.algebraEquivUnder._proof_11 | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C)
[inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C] (X_1 : (CategoryTheory.coprodMonad X).Algebra),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.algebraToUnder X).map
((CategoryTheory.NatIso.ofComponents
(... | null | false |
List.Cursor.length_suffix_le_length | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} {c : l.Cursor}, c.suffix.length ≤ l.length | null | true |
ContinuousMap.continuous | Mathlib.Topology.ContinuousMap.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y)), Continuous ⇑f | Deprecated. Use `map_continuous` instead. | true |
CategoryTheory.Limits.biprod.inl_desc | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{W X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (f : X ⟶ W) (g : Y ⟶ W),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.inl (CategoryTheory.Limits.biprod.desc f g) = ... | null | true |
Lean.Declaration.axiomDecl.elim | Lean.Declaration | {motive : Lean.Declaration → Sort u} →
(t : Lean.Declaration) → t.ctorIdx = 0 → ((val : Lean.AxiomVal) → motive (Lean.Declaration.axiomDecl val)) → motive t | null | false |
LinearEquiv.map_mem_invtSubmodule_conj_iff | Mathlib.Algebra.Module.Submodule.Invariant | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {f : Module.End R M} {e : M ≃ₗ[R] N} {p : Submodule R M},
Submodule.map (↑e) p ∈ (e.conj f).invtSubmodule ↔ p ∈ f.invtSubmodule | null | true |
Action.functorCategoryEquivalenceInverseMonoidal._proof_6 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (V : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} V] (G : Type u_1) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V],
autoParam
(∀ {X Y : CategoryTheory.Functor (CategoryTheory.SingleObj G) V}
(X' : CategoryTheory.Functor (CategoryTheory.SingleObj G) V) (f : X ⟶ Y),
Categor... | null | false |
_private.Mathlib.GroupTheory.GroupExtension.Defs.0.AddGroupExtension.Splitting.instFunLike.match_1 | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G]
(S : AddGroupExtension N E G) (motive : S.Splitting → Prop) (h : S.Splitting),
(∀ (toMonoidHom : G →+ E) (rightInverse_rightHom : Function.RightInverse (↑toMonoidHom).toFun ⇑S.rightHom),
motive { toA... | null | false |
localCohomology.instCategorySelfLERadical._aux_3 | Mathlib.Algebra.Homology.LocalCohomology | {R : Type u_1} → [inst : CommRing R] → (J : Ideal R) → (X : localCohomology.SelfLERadical J) → X ⟶ X | null | false |
autAdjoinRootXPowSubCHom._proof_9 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u_1} [inst : Field K] (n : ℕ) (a : K) (ε η : ↥(rootsOfUnity n K)),
Polynomial.eval₂ (↑(Algebra.ofId K (AdjoinRoot (Polynomial.X ^ n - Polynomial.C a))))
(↑↑(ε * η) • AdjoinRoot.root (Polynomial.X ^ n - Polynomial.C a)) (Polynomial.X ^ n - Polynomial.C a) =
0 | null | false |
_private.Lean.Elab.PreDefinition.Structural.IndPred.0.Lean.Elab.Structural.replaceIndPredRecApp.match_9 | Lean.Elab.PreDefinition.Structural.IndPred | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) →
((recArg : Lean.Expr) → motive (some recArg)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
Dense.extend.congr_simp | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α} (hs : Dense s)
(f f_1 : ↑s → β), f = f_1 → ∀ (a a_1 : α), a = a_1 → hs.extend f a = hs.extend f_1 a_1 | null | true |
ModularForm.summable_logDeriv_one_sub_eta_q | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ {z : ℂ}, z ∈ UpperHalfPlane.upperHalfPlaneSet → Summable fun i => logDeriv (fun x => 1 - ModularForm.eta_q i x) z | null | true |
NNReal.eq | Mathlib.Basic.NNReal.Defs | ∀ {n m : NNReal}, ↑n = ↑m → n = m | null | true |
_private.Mathlib.Data.Ordering.Lemmas.0.cmpUsing_eq_gt._simp_1_1 | Mathlib.Data.Ordering.Lemmas | ∀ {p q : Prop} [h : Decidable p], (if p then q else False) = (p ∧ q) | null | false |
Bundle.TotalSpace._sizeOf_1 | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_4} → {E : B → Type u_5} → [SizeOf B] → [SizeOf F] → [(a : B) → SizeOf (E a)] → Bundle.TotalSpace F E → ℕ | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Basic.0.SimpleGraph.Walk.mem_darts_iff_infix_support._proof_1_25 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p : G.Walk u v},
(∃ k,
[u', v'].length + k ≤ p.support.length ∧
∀ (i : ℕ) (h : i < [u', v'].length), p.support[i + k]? = some [u', v'][i]) →
∀ (i : ℕ) (hi : [u', v'].length + i ≤ p.support.length),
(∀ (h : 0 < [u', v'].length), p.support[0 ... | null | false |
LinearIsometryEquiv.refl | Mathlib.Analysis.Normed.Operator.LinearIsometry | (R : Type u_1) →
(E : Type u_4) → [inst : Semiring R] → [inst_1 : SeminormedAddCommGroup E] → [inst_2 : Module R E] → E ≃ₗᵢ[R] E | Identity map as a `LinearIsometryEquiv`. | true |
Std.DTreeMap.Equiv.keys_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t₁.Equiv t₂ → t₁.keys = t₂.keys | null | true |
CategoryTheory.Limits.createsColimitsOfSizeUnop | Mathlib.CategoryTheory.Limits.Preserves.Creates.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.CreatesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F] →
CategoryTheory.CreatesColimitsOfSize.{w, w', v₁,... | If `F : Cᵒᵖ ⥤ Dᵒᵖ` creates limits, then `F.unop : C ⥤ D` creates colimits. | true |
CochainComplex.HomComplex.Triplet.mk._flat_ctor | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {n : ℤ} → (p q : ℤ) → p + n = q → CochainComplex.HomComplex.Triplet n | null | false |
_private.Mathlib.Basic.ENNReal.Basic.0.ENNReal.instNoZeroDivisors._proof_1 | Mathlib.Basic.ENNReal.Basic | NoZeroDivisors ENNReal | null | false |
Matrix.transposeLinearEquiv._proof_1 | Mathlib.Data.Matrix.Basic | ∀ (m : Type u_1) (n : Type u_2) (α : Type u_3) [inst : AddCommMonoid α] (x y : Matrix m n α),
(Matrix.transposeAddEquiv m n α).toFun (x + y) =
(Matrix.transposeAddEquiv m n α).toFun x + (Matrix.transposeAddEquiv m n α).toFun y | null | false |
_private.Mathlib.Data.PFunctor.Univariate.M.0.PFunctor.M.eq_of_bisim._simp_1_1 | Mathlib.Data.PFunctor.Univariate.M | (¬False) = True | null | false |
Std.ExtDTreeMap.minKey?_insert_le_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k} {kmi : α}, (t.insert k v).minKey?.get ⋯ = kmi → (cmp kmi k).isLE = true | null | true |
MeasureTheory.sfinite_sum_of_countable | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {ι : Type u_3} {m0 : MeasurableSpace α} [Countable ι] (m : ι → MeasureTheory.Measure α)
[∀ (n : ι), MeasureTheory.IsFiniteMeasure (m n)], MeasureTheory.SFinite (MeasureTheory.Measure.sum m) | A countable sum of finite measures is s-finite.
This lemma is superseded by the instance below. | true |
Inseparable.map_of_continuousOn | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x y : X} {f : X → Y}
{s : Set X}, Inseparable x y → ContinuousOn f s → x ∈ s → y ∈ s → Inseparable (f x) (f y) | null | true |
Lean.Meta.Grind.SplitDiagInfo.splitSource | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SplitDiagInfo → Lean.Meta.Grind.SplitSource | null | true |
_private.Mathlib.FieldTheory.Galois.Basic.0.IsGalois.map_fixingSubgroup._simp_1_4 | Mathlib.FieldTheory.Galois.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
SemiRingCat.FilteredColimits.forget₂Mon_preservesFilteredColimits | Mathlib.Algebra.Category.Ring.FilteredColimits | CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget₂ SemiRingCat MonCat) | null | true |
Lean.Meta.Occurrences.contains | Init.Meta.Defs | Lean.Meta.Occurrences → ℕ → Bool | null | true |
Filter.Germ.coe_neg._simp_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {G : Type u_6} [inst : Neg G] (f : α → G), -↑f = ↑(-f) | null | false |
_private.Mathlib.Algebra.Polynomial.Div.0.Polynomial.modByMonic_zero._simp_1_1 | Mathlib.Algebra.Polynomial.Div | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
Lean.Doc.DeferredCheck.mk.injEq | Lean.DocString.DeferredCheck | ∀ (site : Lean.Doc.DeferredCheckSite) (index : ℕ) (sourceString : String) (imports : Array Lean.Name)
(currNamespace : Lean.Name) (openDecls : List Lean.OpenDecl) (options : Lean.Options) (check : Dynamic)
(site_1 : Lean.Doc.DeferredCheckSite) (index_1 : ℕ) (sourceString_1 : String) (imports_1 : Array Lean.Name)
... | null | true |
PartialEquiv.restr_univ | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β}, e.restr Set.univ = e | null | true |
FreeAlgebra.Pre.hasOne | Mathlib.Algebra.FreeAlgebra | (R : Type u_1) → (X : Type u_2) → [CommSemiring R] → One (FreeAlgebra.Pre R X) | One in `Pre R X` defined as the image of `1` from `R`. Note: Used for notation only. | true |
Finset.decidableDforallFinset | Mathlib.Data.Finset.Defs | {α : Type u_1} →
{s : Finset α} →
{p : (a : α) → a ∈ s → Prop} →
[_hp : (a : α) → (h : a ∈ s) → Decidable (p a h)] → Decidable (∀ (a : α) (h : a ∈ s), p a h) | null | true |
_private.Mathlib.RingTheory.NoetherNormalization.0.NoetherNormalization.eqv2._proof_3 | Mathlib.RingTheory.NoetherNormalization | ∀ {k : Type u_1} [inst : Field k] {n : ℕ} (f : MvPolynomial (Fin (n + 1)) k) (I : Ideal (MvPolynomial (Fin (n + 1)) k)),
I = Ideal.map (↑(NoetherNormalization.varChange f).symm) (Ideal.map (NoetherNormalization.varChange f) I) | null | false |
Homogenization.lift_symm_id | Mathlib.LinearAlgebra.AffineSpace.Homogenization | ∀ {R : Type u_1} [inst : Ring R] {V : Type u_2} {P : Type u_3} [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P], Homogenization.lift.symm LinearMap.id = Homogenization.ofPoint | null | true |
CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.isUniversal._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_3} {D : Type u_1} {H : Type u_4} [inst : CategoryTheory.Category.{u_6, u_3} C]
[inst_1 : CategoryTheory.Category.{u_5, u_1} D] [inst_2 : CategoryTheory.Category.{u_2, u_4} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.RightExtension F}
(h : E.IsPointwiseRightKanExtensio... | null | false |
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.neg.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_6 : Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof) →
t.ctorIdx = 3 →
((c : Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → motive_6 (Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.neg c)) →
motive_6 t | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.Literal.mk._flat_ctor | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | (n : ℕ) → BitVec n → BitVec.Literal✝ | null | false |
CauSeq.Completion.instNegCauchy | Mathlib.Algebra.Order.CauSeq.Completion | {α : Type u_1} →
[inst : Field α] →
[inst_1 : LinearOrder α] →
[inst_2 : IsStrictOrderedRing α] →
{β : Type u_2} →
[inst_3 : Ring β] → {abv : β → α} → [inst_4 : IsAbsoluteValue abv] → Neg (CauSeq.Completion.Cauchy abv) | null | true |
Module.Basis.det_apply | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_4}
[inst_3 : DecidableEq ι] [inst_4 : Fintype ι] (e : Module.Basis ι R M) (v : ι → M), e.det v = (e.toMatrix v).det | null | true |
Std.TreeMap.Raw.getElem?_ofList_of_mem | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → (Std.TreeMap.Raw.ofList l cmp)[k']? = some v | null | true |
ContinuousMapZero.instT2Space | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_3} [inst : Zero X] [inst_1 : Zero R] [inst_2 : TopologicalSpace X]
[inst_3 : TopologicalSpace R] [T2Space R], T2Space (ContinuousMapZero X R) | null | true |
ArchimedeanClass.instSMulNat | Mathlib.Algebra.Order.Ring.Archimedean | {R : Type u_1} →
[inst : LinearOrder R] → [inst_1 : CommRing R] → [inst_2 : IsStrictOrderedRing R] → SMul ℕ (ArchimedeanClass R) | null | true |
TensorProduct._aux_Mathlib_LinearAlgebra_TensorPower_Basic___unexpand_TensorPower_1 | Mathlib.LinearAlgebra.TensorPower.Basic | Lean.PrettyPrinter.Unexpander | null | false |
ContinuousLinearMap.map_tsum | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_4} {R : Type u_6} {R₂ : Type u_7} {M : Type u_8} {M₂ : Type u_9} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₂]
[inst_5 : Module R₂ M₂] [inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace M₂] {σ : R →+* R₂}
{L : SummationF... | null | true |
AddChar.compAddMonoidHom_apply | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {B : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : Monoid M]
(ψ : AddChar B M) (f : A →+ B) (a : A), (ψ.compAddMonoidHom f) a = ψ (f a) | null | true |
ContinuousMap.projIccCM | Mathlib.Topology.ContinuousMap.Interval | {α : Type u_1} →
[inst : LinearOrder α] →
[inst_1 : TopologicalSpace α] → [OrderTopology α] → {a b : α} → [Fact (a ≤ b)] → C(α, ↑(Set.Icc a b)) | The map `projIcc` from `α` onto an interval in `α`, as a `ContinuousMap`. | true |
HomotopyCategory.composableArrowsFunctor._proof_11 | Mathlib.Algebra.Homology.HomotopyCategory.SpectralObject | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{X Y Z : CategoryTheory.ComposableArrows (CochainComplex C ℤ) 1} (x : X ⟶ Y) (x_1 : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(X.map' 0 1 HomotopyCategory.composableArrowsFunctor._proof_1 HomotopyCategory.c... | null | false |
AkraBazziRecurrence.growsPolynomially_const | Mathlib.Computability.AkraBazzi.GrowsPolynomially | ∀ {c : ℝ}, AkraBazziRecurrence.GrowsPolynomially fun x => c | null | true |
Finset.inf_mul_left | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {β : Type u_4} [inst_2 : SemilatticeInf β]
[inst_3 : OrderTop β] (s t : Finset α) (f : α → β), (s * t).inf f = s.inf fun x => t.inf fun x_1 => f (x * x_1) | null | true |
_private.Mathlib.CategoryTheory.Limits.Set.0.Set.instPreservesColimitsOfShapeFunctorToTypesOfIsFilteredOrEmpty._simp_1 | Mathlib.CategoryTheory.Limits.Set | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
CategoryTheory.Limits.HasBiproduct.of_hasCoproduct | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
[Finite J] (f : J → C) [CategoryTheory.Limits.HasCoproduct f], CategoryTheory.Limits.HasBiproduct f | In a preadditive category, if the coproduct over `f : J → C` exists,
then the biproduct over `f` exists. | true |
ContinuousAt.rpow | Mathlib.Analysis.SpecialFunctions.Pow.Continuity | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f g : α → ℝ} {x : α},
ContinuousAt f x → ContinuousAt g x → f x ≠ 0 ∨ 0 < g x → ContinuousAt (fun t => f t ^ g t) x | null | true |
Filter.closure_singleton | Mathlib.Topology.Filter | ∀ {α : Type u_2} (l : Filter α), closure {l} = Set.Ici l | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.foldr_eq_foldr_toList._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
exists_smul_notMem_of_subset_orbit_closure | Mathlib.GroupTheory.Perm.ClosureSwap | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] (S : Set G) (T : Set α) {a : α},
(∀ g ∈ S, g⁻¹ ∈ S) → T ⊆ MulAction.orbit (↥(Subgroup.closure S)) a → a ∉ T → T.Nonempty → ∃ σ ∈ S, ∃ a ∈ T, σ • a ∉ T | Given a symmetric generating set of a permutation group, if T is a nonempty proper subset of
an orbit, then there exists a generator that sends some element of T into the complement of T. | true |
CategoryTheory.Functor.rightDerivedNatIso_hom | Mathlib.CategoryTheory.Functor.Derived.RightDerived | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} H]
(RF RF' : CategoryTheory.Functor D H) {F F' : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : F ⟶ L.comp RF... | null | true |
Lean.Meta.Match.MatcherResult.unusedAltIdxs | Lean.Meta.Match.Basic | Lean.Meta.Match.MatcherResult → List ℕ | null | true |
Nat.reduceBNe | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Meta.Simp.DSimproc | null | true |
BoundedOrderHom.dual._proof_4 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : BoundedOrder α] [inst_2 : Preorder β]
[inst_3 : BoundedOrder β] (f : BoundedOrderHom αᵒᵈ βᵒᵈ), f.toFun ⊤ = ⊤ | null | false |
Ideal.quotientAlgebra._proof_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {A : Type u_2} [inst : Ring A] {R : Type u_1} [inst_1 : CommRing R] {I : Ideal A} [inst_2 : Algebra R A],
Ideal.comap (algebraMap R A) I ≤ Ideal.comap (algebraMap R A) I | null | false |
ContinuousLinearMapWOT.toCLM_add | 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] [inst_8 : IsTopologi... | null | true |
Set.bounded_ge_Ici | Mathlib.Order.Bounded | ∀ {α : Type u_1} [inst : Preorder α] (a : α), Set.Bounded (fun x1 x2 => x1 ≥ x2) (Set.Ici a) | null | true |
DifferentiableAt.cpow_const | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {c : ℂ},
DifferentiableAt ℂ f x → f x ∈ Complex.slitPlane → DifferentiableAt ℂ (fun x => f x ^ c) x | null | true |
Filter.eventually_mem_set | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α} {l : Filter α}, (∀ᶠ (x : α) in l, x ∈ s) ↔ s ∈ l | null | true |
_private.Mathlib.Analysis.Complex.CauchyIntegral.0.Complex.circleIntegral_sub_center_inv_smul_eq_of_differentiable_on_annulus_off_countable._simp_1_4 | Mathlib.Analysis.Complex.CauchyIntegral | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
_private.Mathlib.Tactic.Translate.GuessName.0.Mathlib.Tactic.GuessName.fixAbbreviationAux.match_3 | Mathlib.Tactic.Translate.GuessName | (motive : List String → List String → Sort u_1) →
(x x_1 : List String) →
(Unit → motive [] []) →
((x : String) → (s : List String) → motive [] (x :: s)) →
((pre : String) → (l s' : List String) → motive (pre :: l) s') → motive x x_1 | null | false |
TopModuleCat.isLimit._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {J : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} J] {F : CategoryTheory.Functor J (TopModuleCat R)}
{c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget₂ (TopModuleCat R) (ModuleCat R)))}
(hc : CategoryTheory.Limits.IsLimit c) (s ... | null | false |
UInt32.ofBitVec.injEq | Init.Core | ∀ (toBitVec toBitVec_1 : BitVec 32), ({ toBitVec := toBitVec } = { toBitVec := toBitVec_1 }) = (toBitVec = toBitVec_1) | null | true |
Nat.Partition.instFintype | Mathlib.Combinatorics.Enumerative.Partition.Basic | (n : ℕ) → Fintype n.Partition | Show there are finitely many partitions by considering the surjection from compositions to
partitions.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.