name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Lie.Weights.Killing.0.LieAlgebra.IsKilling.span_weight_isNonZero_eq_top._simp_1_1 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
Lean.Elab.Modifiers.addFirstAttr | Lean.Elab.DeclModifiers | Lean.Elab.Modifiers → Lean.Elab.Attribute → Lean.Elab.Modifiers | Adds attribute `attr` in `modifiers`, at the beginning | true |
ContDiff.comp₂_contDiffOn | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {E₁ : Type u_6}
{E₂ : Type u_7} [inst_5 : NormedAddCommGroup E₁] [inst_6 : NormedAddCommGroup E... | null | true |
RingCat.FilteredColimits.colimitCocone | Mathlib.Algebra.Category.Ring.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.IsFiltered J] → (F : CategoryTheory.Functor J RingCat) → CategoryTheory.Limits.Cocone F | The cocone over the proposed colimit ring. | true |
Polynomial.degree_sub_lt_right | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R},
p.degree = q.degree → q ≠ 0 → p.leadingCoeff = q.leadingCoeff → (p - q).degree < q.degree | null | true |
Lean.AxiomVal.isUnsafe | Lean.Declaration | Lean.AxiomVal → Bool | null | true |
CategoryTheory.regularTopology.parallelPair_pullback_initial | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X B : C} (π : X ⟶ B)
(c : CategoryTheory.Limits.PullbackCone π π) (hc : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.Limits.parallelPair (CategoryTheory.ObjectProperty.homMk (CategoryTheory.Over.homMk c.fst ⋯)).op
(CategoryTheory.ObjectPrope... | null | true |
List.head?_concat_concat | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {a b : α}, (l ++ [a, b]).head? = (l ++ [a]).head? | null | true |
Lean.isNonRecStructure | Lean.Structure | Lean.Environment → Lean.Name → Bool | Returns true iff `constName` is a non-recursive inductive datatype that has only one constructor and no indices.
Such types have special kernel support (e.g. the eta rule). This must be in sync with `is_non_rec_structure()`.
| true |
List.all_filter | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {p q : α → Bool}, (List.filter p l).all q = l.all fun a => !p a || q a | null | true |
Function.HasTemperateGrowth.fun_mul | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {R : Type u_3} {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedRing R]
[inst_3 : NormedAlgebra ℝ R] {f g : E → R},
Function.HasTemperateGrowth f → Function.HasTemperateGrowth g → Function.HasTemperateGrowth fun i => f i * g i | Eta-expanded form of `Function.HasTemperateGrowth.mul`
---
The product of two functions of temperate growth is again of temperate growth. | true |
Lean.Elab.Term.Quotation.HeadInfo.mk.noConfusion | Lean.Elab.Quotation | {P : Sort u} →
{check : Lean.Elab.Term.Quotation.HeadCheck} →
{onMatch : Lean.Elab.Term.Quotation.HeadCheck → Lean.Elab.Term.Quotation.MatchResult} →
{doMatch :
(List Lean.Term → Lean.Elab.TermElabM Lean.Term) →
Lean.Elab.TermElabM Lean.Term → Lean.Elab.TermElabM Lean.Term} →
{... | null | false |
Nat.instLawfulOrderLT | Init.Data.Nat.Order | Std.LawfulOrderLT ℕ | null | true |
CommRing.toNonUnitalCommRing._proof_3 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [s : CommRing α] (n : ℕ) (a : α), ↑n.succ • a = ↑n • a + a | null | false |
Matrix.seminormedAddCommGroup._proof_2 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] (x y : Matrix m n α), dist x y = dist y x | null | false |
Subring.mem_sInf | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R] {S : Set (Subring R)} {x : R}, x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p | null | true |
FirstOrder.Language.Relations.realize_transitive | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {r : L.Relations 2},
M ⊨ r.transitive ↔ IsTrans M fun x y => FirstOrder.Language.Structure.RelMap r ![x, y] | null | true |
IsLocalHomeomorph.map_nhds_eq | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsLocalHomeomorph f → ∀ (x : X), Filter.map f (nhds x) = nhds (f x) | null | true |
_private.Mathlib.Algebra.Order.Ring.Ordering.Defs.0.RingPreordering.instHasIdealSupportOfHasMemOrNegMem.match_1 | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] {P : RingPreordering R} (x : R) (motive : x ∈ P ∨ -x ∈ P → Prop)
(x_1 : x ∈ P ∨ -x ∈ P), (∀ (hx : x ∈ P), motive ⋯) → (∀ (hx : -x ∈ P), motive ⋯) → motive x_1 | null | false |
CochainComplex.HomComplex.Cochain.InductionUp.sequence._unsafe_rec | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexInduction | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{K L : CochainComplex C ℤ} →
{d : ℤ} →
{X : ℕ → Set (CochainComplex.HomComplex.Cochain K L d)} →
((n : ℕ) → ↑(X n) → ↑(X (n + 1))) → ↑(X 0) → (n : ℕ) → ↑(X n) | null | false |
_private.Mathlib.Analysis.Distribution.ContDiffMapSupportedIn.0.ContDiffMapSupportedIn.continuous_iff_comp_order_le._simp_1_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {α : Prop}, (True → α) = α | null | false |
RootPairing.chainTopCoeff_of_not_linearIndependent | Mathlib.LinearAlgebra.RootSystem.Chain | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Finite ι] [inst_1 : CommRing R]
[inst_2 : CharZero R] [inst_3 : IsDomain R] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N]
[inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsCrystallographic] {i j : ι},
¬Li... | null | true |
Matrix.eq_zero_of_mulVec_eq_zero | Mathlib.LinearAlgebra.Matrix.Nondegenerate | ∀ {m : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : Fintype m] [inst_2 : DecidableEq m] {M : Matrix m m R}
[NoZeroDivisors R], M.det ≠ 0 → ∀ {v : m → R}, M.mulVec v = 0 → v = 0 | null | true |
MeasurableSpace.generateFrom_singleton_univ | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1}, MeasurableSpace.generateFrom {Set.univ} = ⊥ | null | true |
Function.Embedding.nonempty_of_card_le | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β],
Fintype.card α ≤ Fintype.card β → Nonempty (α ↪ β) | null | true |
_private.Mathlib.Combinatorics.SetFamily.Compression.Down.0.Down.erase_mem_compression._simp_1_2 | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {a : Prop}, (a ∧ a) = a | null | false |
MeasurableEquiv.symm_addLeft | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableAdd G] (g : G),
(MeasurableEquiv.addLeft g).symm = MeasurableEquiv.addLeft (-g) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKeyD_le_minKeyD_erase._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
HahnSeries.finiteArchimedeanClassOrderIsoLex._proof_1 | Mathlib.RingTheory.HahnSeries.Lex | ∀ (Γ : Type u_1) (R : Type u_2) [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[inst_3 : IsOrderedAddMonoid R],
(HahnSeries.finiteArchimedeanClassOrderHomLex Γ R).comp (HahnSeries.finiteArchimedeanClassOrderHomInvLex Γ R) =
OrderHom.id | null | false |
GrpCat.SurjectiveOfEpiAuxs.instDecidableEqXWithInfinity | Mathlib.Algebra.Category.Grp.EpiMono | {A B : GrpCat} → (f : A ⟶ B) → DecidableEq (GrpCat.SurjectiveOfEpiAuxs.XWithInfinity f) | null | true |
Lean.PrefixTreeNode._sizeOf_3_eq | Lean.Data.PrefixTree | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : SizeOf α] [inst_1 : SizeOf β]
(x : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp), Lean.PrefixTreeNode._sizeOf_3 x = sizeOf x | null | false |
CategoryTheory.BraidedCategory.hexagon_reverse_inv_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y Z : C) {Z_1 : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z) ⟶ Z_1),
CategoryTheory.CategoryStruct... | null | true |
Lean.getFieldInfo? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.StructureFieldInfo | Gets the `StructureFieldInfo` for the given direct field of the structure. | true |
Complex.exp_ofReal_mul_I | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Complex.exp (↑x * Complex.I) = ↑(Real.cos x) + ↑(Real.sin x) * Complex.I | null | true |
UniformEquiv.neg._proof_2 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous ⇑(Equiv.neg G) | null | false |
Prod.instZeroLEOneClass | Mathlib.Algebra.Order.ZeroLEOne | ∀ {R : Type u_2} {S : Type u_3} [inst : Zero R] [inst_1 : One R] [inst_2 : LE R] [ZeroLEOneClass R] [inst_4 : Zero S]
[inst_5 : One S] [inst_6 : LE S] [ZeroLEOneClass S], ZeroLEOneClass (R × S) | null | true |
OpenPartialHomeomorph.symm_piecewise | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e e' : OpenPartialHomeomorph X Y) {s : Set X} {t : Set Y} [inst_2 : (x : X) → Decidable (x ∈ s)]
[inst_3 : (y : Y) → Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t)
(Hs : e.source ∩ frontier s = e'.source ∩ fro... | null | true |
Finset.lt_sup'_iff | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
a < s.sup' H f ↔ ∃ b ∈ s, a < f b | null | true |
TannakaDuality.FiniteGroup.equivApp_hom | Mathlib.RepresentationTheory.Tannaka | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (g : G) (X : FDRep k G),
(TannakaDuality.FiniteGroup.equivApp g X).hom = CategoryTheory.InducedCategory.homMk (ModuleCat.ofHom (X.ρ g)) | null | true |
_private.Mathlib.Order.Filter.Subsingleton.0.Filter.subsingleton_iff_exists_le_pure._simp_1_1 | Mathlib.Order.Filter.Subsingleton | ∀ {α : Type u_1} {l : Filter α}, l.Subsingleton = (l = ⊥ ∨ ∃ a, l = pure a) | null | false |
fourierCoeffOn_of_hasDerivAt | Mathlib.Analysis.Fourier.AddCircle | ∀ {a b : ℝ} (hab : a < b) {f f' : ℝ → ℂ} {n : ℤ},
n ≠ 0 →
(∀ x ∈ Set.uIcc a b, HasDerivAt f (f' x) x) →
IntervalIntegrable f' MeasureTheory.volume a b →
fourierCoeffOn hab f n =
1 / (-2 * ↑Real.pi * Complex.I * ↑n) * ((fourier (-n)) ↑a * (f b - f a) - (↑b - ↑a) * fourierCoeffOn hab f' n) | Express Fourier coefficients of `f` on an interval in terms of those of its derivative. | true |
Vector.findSomeRev?_push | Init.Data.Vector.Find | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {xs : Vector α n} {a : α} {f : α → Option β},
Vector.findSomeRev? f (xs.push a) = (f a).or (Vector.findSomeRev? f xs) | null | true |
CommSemiRingCat.Hom._mkInternal.injEq | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommSemiRingCat} (hom' hom'_1 : ↑R →+* ↑S), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | null | false |
CategoryTheory.IsComonHom.hom_comul_assoc | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {M N : C}
{inst_2 : CategoryTheory.ComonObj M} {inst_3 : CategoryTheory.ComonObj N} (f : M ⟶ N)
[self : CategoryTheory.IsComonHom f] {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj N N ⟶ Z),
Categ... | null | true |
CategoryTheory.Limits.BinaryFan.IsLimit.lift'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryFan X Y}
(h : CategoryTheory.Limits.IsLimit s) (f : W ⟶ X) (g : W ⟶ Y),
CategoryTheory.CategoryStruct.comp (h.lift (CategoryTheory.Limits.BinaryFan.mk f g)) s.fst = f ∧
CategoryTheory.CategoryStruct.comp ... | null | false |
Aesop.Script.Step.mk | Aesop.Script.Step | Lean.Meta.SavedState →
Lean.MVarId → Aesop.Script.Tactic → Lean.Meta.SavedState → Array Aesop.GoalWithMVars → Aesop.Script.Step | null | true |
Int64.ofInt_eq_iff_bmod_eq_toInt | Init.Data.SInt.Lemmas | ∀ (a : ℤ) (b : Int64), Int64.ofInt a = b ↔ a.bmod (2 ^ 64) = b.toInt | null | true |
Additive.toMul_le | Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags | ∀ {α : Type u_1} [inst : Preorder α] {a b : Additive α}, Additive.toMul a ≤ Additive.toMul b ↔ a ≤ b | null | true |
CategoryTheory.Adjunction.Triple.leftToRight._proof_1 | Mathlib.CategoryTheory.Adjunction.Triple | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{H : CategoryTheory.Functor C D} (t : CategoryTheory.Adjunction.Triple F G H) [F.Full] [F.Faithful],
CategoryTheory.IsIso ... | null | false |
Units.isIsometricSMul | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X] [IsIsometricSMul M X] [inst_3 : Monoid M],
IsIsometricSMul Mˣ X | null | true |
FrameHom.instFunLike | Mathlib.Order.Hom.CompleteLattice | {α : Type u_2} → {β : Type u_3} → [inst : CompleteLattice α] → [inst_1 : CompleteLattice β] → FunLike (FrameHom α β) α β | null | true |
_private.Mathlib.RingTheory.Coalgebra.TensorProduct.0.Coalgebra._aux_Mathlib_RingTheory_Coalgebra_TensorProduct___delab_app__private_Mathlib_RingTheory_Coalgebra_TensorProduct_0_Coalgebra_termμ_1 | Mathlib.RingTheory.Coalgebra.TensorProduct | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
Lean.Elab.ConfigEval.EvalConfigItemHandler.noConfusion | Lean.Elab.ConfigEval.DeriveEvalConfigItem | {P : Sort u} →
{t t' : Lean.Elab.ConfigEval.EvalConfigItemHandler} →
t = t' → Lean.Elab.ConfigEval.EvalConfigItemHandler.noConfusionType P t t' | null | false |
Turing.TM2to1.StAct.push.noConfusion | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{P : Sort u} → {a a' : σ → Γ k} → Turing.TM2to1.StAct.push a = Turing.TM2to1.StAct.push a' → (a ≍ a' → P) → P | null | false |
_private.Mathlib.MeasureTheory.Integral.IntegralEqImproper.0.MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi._simp_1_3 | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
MulChar.mem_subgroupOrderIsoSubgroupMulChar_symm_iff._simp_1 | Mathlib.NumberTheory.MulChar.Duality | ∀ {M : Type u_1} {R : Type u_2} [inst : CommMonoid M] [inst_1 : CommRing R] [inst_2 : Finite M]
[inst_3 : HasEnoughRootsOfUnity R (Monoid.exponent Mˣ)] {X : Subgroup (MulChar M R)} {m : Mˣ},
(m ∈ (MulChar.subgroupOrderIsoSubgroupMulChar M R).symm (OrderDual.toDual X)) = ∀ χ ∈ X, χ ↑m = 1 | null | false |
Lean.Elab.ChoiceInfo.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.ChoiceInfo → ℕ | null | false |
AddSubmonoid.map._proof_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_3}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid M) {a b : N},
a ∈ ⇑f '' ↑S → b ∈ ⇑f '' ↑S → a + b ∈ ⇑f '' ↑S | null | false |
Polynomial.powAddExpansion._proof_1 | Mathlib.Algebra.Polynomial.Identities | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (n : ℕ) (z : R),
(x + y) ^ (n + 1) = x ^ (n + 1) + ↑(n + 1) * x ^ (n + 1 - 1) * y + z * y ^ 2 →
(x + y) ^ (n + 2) = x ^ (n + 2) + ↑(n + 2) * x ^ (n + 1) * y + (x * z + (↑n + 1) * x ^ n + z * y) * y ^ 2 | null | false |
OrderMonoidHom.noConfusionType | Mathlib.Algebra.Order.Hom.Monoid | Sort u →
{α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : MulOneClass α] →
[inst_3 : MulOneClass β] →
(α →*o β) →
{α' : Type u_6} →
{β' : Type u_7} →
[inst' : Preorder α... | null | false |
openSegment_subset_iff | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] {s : Set E} {x y : E},
openSegment 𝕜 x y ⊆ s ↔ ∀ (a b : 𝕜), 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s | null | true |
Compactum.continuous_of_hom | Mathlib.Topology.Category.Compactum | ∀ {X Y : Compactum} (f : X ⟶ Y), Continuous ⇑(CategoryTheory.ConcreteCategory.hom f) | Any morphism of compacta is continuous. | true |
Finset.sum_nonneg | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι}
[AddLeftMono N], (∀ i ∈ s, 0 ≤ f i) → 0 ≤ ∑ i ∈ s, f i | null | true |
HomologicalComplex.extend.leftHomologyData._proof_4 | Mathlib.Algebra.Homology.Embedding.ExtendHomology | ∀ {ι : Type u_3} {c : ComplexShape ι} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c) {i j k : ι},
CategoryTheory.CategoryStruct.comp (K.sc' i j k).f (K.sc' i j k).g = 0 | null | false |
String.Slice.Pattern.Model.ForwardStringSearcher.isLongestMatchAt_iff_isLongestMatchAt_toSlice | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat : String} {s : String.Slice} {pos₁ pos₂ : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt pat pos₁ pos₂ ↔
String.Slice.Pattern.Model.IsLongestMatchAt pat.toSlice pos₁ pos₂ | null | true |
Fin.isSome_findSome?_iff._simp_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → Option α}, ((Fin.findSome? f).isSome = true) = ∃ i, (f i).isSome = true | null | false |
FintypeCat.hom_apply | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y : FintypeCat} (f : X ⟶ Y) (x : X.obj),
(CategoryTheory.ConcreteCategory.hom f.hom) x = (CategoryTheory.ConcreteCategory.hom f) x | null | true |
_private.Mathlib.CategoryTheory.MorphismProperty.IsSmall.0.CategoryTheory.MorphismProperty.isSmall_iSup.match_1 | Mathlib.CategoryTheory.MorphismProperty.IsSmall | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_3, u_2} C] →
{α : Type u_1} →
(W : α → CategoryTheory.MorphismProperty C) →
(motive : (i : α) × ↑(W i).toSet → Sort u_4) →
(x : (i : α) × ↑(W i).toSet) → ((i : α) → (f : ↑(W i).toSet) → motive ⟨i, f⟩) → motive x | null | false |
_private.Mathlib.Tactic.ProdAssoc.0.Lean.Expr.mkProdTree._sparseCasesOn_4 | Mathlib.Tactic.ProdAssoc | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
AddChar.toAddMonoidHomEquiv._proof_4 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_2} {M : Type u_1} [inst : AddMonoid A] [inst_1 : Monoid M] (f : A →+ Additive M) (x y : A),
(↑f).toFun (x + y) = (↑f).toFun x + (↑f).toFun y | null | false |
rootsOfUnityCircleEquiv._proof_2 | Mathlib.Analysis.SpecialFunctions.Complex.CircleAddChar | ∀ (n : ℕ) [inst : NeZero n] (z : ↥(rootsOfUnity n ℂ)), (rootsOfUnitytoCircle n).toHomUnits z ∈ rootsOfUnity n Circle | null | false |
MeasurableEquiv.continuousMapToFun._proof_8 | Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousMap | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [SecondCountableTopology X]
[SecondCountableTopology Y] [LocallyCompactSpace X] [RegularSpace Y] [inst_6 : MeasurableSpace Y] [BorelSpace Y],
Measurable
⇑{ toFun := fun f => ⟨⇑f, ⋯⟩, invFun := fun f => { toFun := ↑f, conti... | null | false |
CategoryTheory.End.group._proof_3 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] (X : C) (n : ℕ) (a : CategoryTheory.End X), a ^ ↑n.succ = a ^ ↑n * a | null | false |
USize.ofFin_uint32ToFin | Init.Data.UInt.Lemmas | ∀ (n : UInt32), USize.ofFin (Fin.castLE UInt32.size_le_usizeSize n.toFin) = n.toUSize | null | true |
_private.Init.Data.Array.Bootstrap.0.Array.isEqvAux.match_1.eq_1 | Init.Data.Array.Bootstrap | ∀ {α : Type u_1} (xs : Array α) (motive : (x : ℕ) → x ≤ xs.size → Sort u_2) (x : 0 ≤ xs.size)
(h_1 : (x : 0 ≤ xs.size) → motive 0 x) (h_2 : (i : ℕ) → (h : i + 1 ≤ xs.size) → motive i.succ h),
(match 0, x with
| 0, x => h_1 x
| i.succ, h => h_2 i h) =
h_1 x | null | true |
T5Space.of_forall_isOpen_t4Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X], (∀ (s : Set X), IsOpen s → T4Space ↑s) → T5Space X | **Alias** of the reverse direction of `t5Space_iff_forall_isOpen_t4Space`.
---
A space is a `T5Space` iff all its open subspaces are `T4Space`.
| true |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Basic.0.CategoryTheory.Localization.Monoidal.pentagon_natTrans._simp_1_2 | Mathlib.CategoryTheory.Localization.Monoidal.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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : W.IsMonoidal]
[inst_4 : L.IsLocalization W] {unit : D} (ε : ... | null | false |
SheafOfModules.Presentation.noConfusion | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {P : Sort u_1} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
{inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat} →
{inst_2 : J.WEqualsLocallyBijective AddCommGrpCat} →
... | null | false |
Traversable.foldrm_toList | Mathlib.Control.Fold | ∀ {α β : Type u} {t : Type u → Type u} [inst : Traversable t] [LawfulTraversable t] {m : Type u → Type u}
[inst_2 : Monad m] [LawfulMonad m] (f : α → β → m β) (x : β) (xs : t α),
Traversable.foldrM f x xs = List.foldrM f x (Traversable.toList xs) | **Alias** of `Traversable.foldrM_toList`. | true |
BitVec.toFin_injective | Mathlib.Data.BitVec | ∀ {n : ℕ}, Function.Injective BitVec.toFin | null | true |
IsNormalClosure.lift | Mathlib.FieldTheory.Normal.Closure | {F : Type u_1} →
{K : Type u_2} →
{L : Type u_3} →
[inst : Field F] →
[inst_1 : Field K] →
[inst_2 : Field L] →
[inst_3 : Algebra F K] →
[inst_4 : Algebra F L] →
[h : IsNormalClosure F K L] →
{L' : Type u_4} →
... | A normal closure of `K/F` embeds into any `L/F`
where the minimal polynomials of `K/F` splits. | true |
Std.DTreeMap.Internal.Impl.minView.induct | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v}
(motive :
(k : α) →
β k →
(l r : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → r.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Prop),
(∀ (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hl : Std.DTreeM... | null | true |
Lean.Parser.ParserAttributeHook.postAdd | Lean.Parser.Extension | Lean.Parser.ParserAttributeHook → Lean.Name → Lean.Name → Bool → Lean.AttrM Unit | Called after a parser attribute is applied to a declaration. | true |
AEMeasurable.const_sup | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → M} [inst_1 : Max M] [MeasurableSup M], AEMeasurable f μ → ∀ (c : M), AEMeasurable (fun x => c ⊔ f x) μ | null | true |
Std.Internal.LawfulMonadLiftBindFunction.liftBind_bind | Init.Data.Iterators.Internal.LawfulMonadLiftFunction | ∀ {m : Type u → Type v} {n : Type w → Type x} {inst : Monad m} {inst_1 : Monad n}
{liftBind : (γ : Type u) → (δ : Type w) → (γ → n δ) → m γ → n δ}
[self : Std.Internal.LawfulMonadLiftBindFunction liftBind] {β γ : Type u} {δ : Type w} (f : γ → n δ) (x : m β)
(g : β → m γ), liftBind γ δ f (x >>= g) = liftBind β δ (... | null | true |
sign_nonneg_iff._simp_1 | Mathlib.Basic.Sign.Defs | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] {a : α}, (0 ≤ SignType.sign a) = (0 ≤ a) | null | false |
Lean.LocalDecl.binderInfo | Lean.LocalContext | Lean.LocalDecl → Lean.BinderInfo | null | true |
MeasureTheory.locallyIntegrable_of_norm_le_rpow | Mathlib.Analysis.SpecialFunctions.Pow.Integral | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [BorelSpace E] [inst_5 : NormedAddCommGroup F] {μ : MeasureTheory.Measure E}
[μ.IsAddHaarMeasure],
1 ≤ Module.finrank ℝ E →
∀ {f : E → F} {C α : ℝ},
α < ↑(Module.... | A function that is dominated by `‖x‖ ^ (-d + ε)` is locally integrable | true |
Char.notLTTrans | Init.Data.Char.Lemmas | Trans (fun x1 x2 => ¬x1 < x2) (fun x1 x2 => ¬x1 < x2) fun x1 x2 => ¬x1 < x2 | null | true |
_private.Init.Data.Int.Order.0.Int.sign_sign.match_1_1 | Init.Data.Int.Order | ∀ (motive : ℤ → Prop) (x : ℤ),
(∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive (Int.ofNat n.succ)) → (∀ (a : ℕ), motive (Int.negSucc a)) → motive x | null | false |
Std.Iter.allM_eq_forIn | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} {m : Type → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α Id m] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {p : β → m Bool},
Std.Iter.allM p it =
forIn it true fun x x_1 => do
let __do_lift ← p x
... | null | true |
Lean.Parser.Tactic.MRefinePat.tuple.elim | Std.Tactic.Do.Syntax | {motive_1 : Lean.Parser.Tactic.MRefinePat → Sort u} →
(t : Lean.Parser.Tactic.MRefinePat) →
t.ctorIdx = 1 →
((args : List Lean.Parser.Tactic.MRefinePat) → motive_1 (Lean.Parser.Tactic.MRefinePat.tuple args)) → motive_1 t | null | false |
DifferentiableWithinAt.of_dslope | Mathlib.Analysis.Calculus.DSlope | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {a b : 𝕜} {s : Set 𝕜},
DifferentiableWithinAt 𝕜 (dslope f a) s b → DifferentiableWithinAt 𝕜 f s b | null | true |
iter_deriv_inv' | Mathlib.Analysis.Calculus.Deriv.ZPow | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (k : ℕ),
deriv^[k] Inv.inv = fun x => (-1) ^ k * ↑k.factorial * x ^ (-1 - ↑k) | null | true |
Set.bijOn_empty_iff_right | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {t : Set β} {f : α → β}, Set.BijOn f ∅ t ↔ t = ∅ | null | true |
WithBot.coe_bot_le._simp_2 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Preorder α] {x : WithBot α} [inst_1 : OrderBot α], (↑⊥ ≤ x) = (x ≠ ⊥) | null | false |
_private.Mathlib.Data.List.Interleave.0.List.interleaves_ofFn_even._proof_1_58 | Mathlib.Data.List.Interleave | ∀ {n : ℕ} (i : Fin n), 2 * ↑i + 6 ≤ 2 * n → (2 * ↑i + 5) / 2 < n | null | false |
CategoryTheory.Mon.monMonoidalStruct_tensorObj_X | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M N : CategoryTheory.Mon C),
(CategoryTheory.MonoidalCategoryStruct.tensorObj M N).X = CategoryTheory.MonoidalCategoryStruct.tensorObj M.X N.X | null | true |
RootPairing.weylGroup.induction | Mathlib.LinearAlgebra.RootSystem.WeylGroup | ∀ {ι : 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)
{pred : (g : P.Aut) → g ∈ P.weylGroup → Prop},
(∀ (i : ι), pred (RootPairing.Equiv.reflection P i) ⋯) →
pr... | null | true |
WeierstrassCurve.Affine.Point.xRep_add_self_of_Y_ne | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] {x y : F}
(h : W.Nonsingular x y),
y ≠ W.negY x y →
(WeierstrassCurve.Affine.Point.some x y h + WeierstrassCurve.Affine.Point.some x y h).xRep =
![(x ^ 4 - WeierstrassCurve.b₄ W * x ^ 2 - 2 * WeierstrassCurve.b₆ W * x... | We give an explicit expression for `xRep` of `P + P` when `2*P ≠ 0`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.