name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
sin_pi_mul_ne_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {x : ℂ}, x ∈ Complex.integerComplement → Complex.sin (↑Real.pi * x) ≠ 0 |
CommMonCat.forget₂_full | Mathlib.Algebra.Category.MonCat.Basic | (CategoryTheory.forget₂ CommMonCat MonCat).Full |
Preord.ofHom_hom | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (f : X ⟶ Y), Preord.ofHom (Preord.Hom.hom f) = f |
FinBoolAlg.Iso.mk._proof_4 | Mathlib.Order.Category.FinBoolAlg | ∀ {α β : FinBoolAlg} (e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg) (a b : ↑α.1), e (a ⊓ b) = e a ⊓ e b |
_private.Batteries.Data.Array.Pairwise.0.Array.pairwise_push._simp_1_2 | Batteries.Data.Array.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) |
MeasureTheory.VectorMeasure.restrict_add | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] {M : Type u_3} [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : ContinuousAdd M] (v w : MeasureTheory.VectorMeasure α M) (i : Set α),
(v + w).restrict i = v.restrict i + w.restrict i |
Equiv.finite_iff | Mathlib.Data.Finite.Defs | ∀ {α : Sort u_1} {β : Sort u_2} (f : α ≃ β), Finite α ↔ Finite β |
ConditionallyCompleteLinearOrderBot.toDecidableEq._inherited_default | Mathlib.Order.ConditionallyCompleteLattice.Defs | {α : Type u_5} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), le a b → le b a → a = b) → DecidableLE α → DecidableEq α |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.morphismRestrict_app._simp_1_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) |
TopCat.PrelocalPredicate.sheafify_inductionOn | Mathlib.Topology.Sheaves.LocalPredicate | ∀ {X : TopCat} {T : ↑X → Type u_2} (P : TopCat.PrelocalPredicate T) (op : {x : ↑X} → T x → T x),
(∀ {U : TopologicalSpace.Opens ↑X} {a : (x : ↥U) → T ↑x},
P.pred a → ∀ (p : ↥U), ∃ W i, ↑p ∈ W ∧ P.pred fun x => op (a (i x))) →
∀ {U : TopologicalSpace.Opens ↑X} {a : (x : ↥U) → T ↑x}, P.sheafify.pred a → P.sheafify.pred fun x => op (a x) |
Submonoid.instInfSet._proof_1 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set (Submonoid M)) {a : M}, a ∈ ⋂ t ∈ s, ↑t → ∀ i ∈ s, a ∈ i |
instLawfulIdentityInt32HAddOfNat | Init.Data.SInt.Lemmas | Std.LawfulIdentity (fun x1 x2 => x1 + x2) 0 |
ArchimedeanClass.instLinearOrderedAddCommGroupWithTop._proof_4 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [inst_2 : IsOrderedRing R] (n : ℕ) (x : ArchimedeanClass R),
Int.negSucc n • x = -(↑n.succ • x) |
Polynomial.Chebyshev.S | Mathlib.RingTheory.Polynomial.Chebyshev | (R : Type u_1) → [inst : CommRing R] → ℤ → Polynomial R |
Std.Do.Spec.forIn'_roo | Std.Do.Triple.SpecLemmas | ∀ {α β : Type u} {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps]
[inst_2 : LT α] [inst_3 : DecidableLT α] [inst_4 : Std.PRange.UpwardEnumerable α] [inst_5 : Std.Rxo.IsAlwaysFinite α]
[inst_6 : Std.PRange.LawfulUpwardEnumerable α] [inst_7 : Std.PRange.LawfulUpwardEnumerableLT α] {xs : Std.Roo α}
{init : β} {f : (a : α) → a ∈ xs → β → m (ForInStep β)} (inv : Std.Do.Invariant xs.toList β ps),
(∀ (pref : List α) (cur : α) (suff : List α) (h : xs.toList = pref ++ cur :: suff) (b : β),
⦃inv.1 ({ «prefix» := pref, suffix := cur :: suff, property := ⋯ }, b)⦄
f cur ⋯ b ⦃(fun r =>
match r with
| ForInStep.yield b' => inv.1 ({ «prefix» := pref ++ [cur], suffix := suff, property := ⋯ }, b')
| ForInStep.done b' => inv.1 ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b'),
inv.2)⦄) →
⦃inv.1 ({ «prefix» := [], suffix := xs.toList, property := ⋯ }, init)⦄
forIn' xs init f ⦃(fun b => inv.1 ({ «prefix» := xs.toList, suffix := [], property := ⋯ }, b), inv.2)⦄ |
Subsemigroup.mem_closure | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] {s : Set M} {x : M}, x ∈ Subsemigroup.closure s ↔ ∀ (S : Subsemigroup M), s ⊆ ↑S → x ∈ S |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._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) |
CategoryTheory.Limits.PreservesPullback.iso_hom | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullback f g] [inst_4 : CategoryTheory.Limits.HasPullback (G.map f) (G.map g)],
(CategoryTheory.Limits.PreservesPullback.iso G f g).hom = CategoryTheory.Limits.pullbackComparison G f g |
_private.Mathlib.Data.List.Chain.0.List.exists_isChain_ne_nil_of_relationReflTransGen._proof_1_3 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {a : α} (l : List α), ¬(a :: l).length - 1 = 0 → (a :: l).length - 2 < l.length |
cauchySeq_range_of_norm_bounded | Mathlib.Analysis.Normed.Group.InfiniteSum | ∀ {E : Type u_3} [inst : SeminormedAddCommGroup E] {f : ℕ → E} {g : ℕ → ℝ},
(CauchySeq fun n => ∑ i ∈ Finset.range n, g i) →
(∀ (i : ℕ), ‖f i‖ ≤ g i) → CauchySeq fun n => ∑ i ∈ Finset.range n, f i |
lp.norm_eq_card_dsupport | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_3} {E : α → Type u_4} [inst : (i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E 0)), ‖f‖ = ↑⋯.toFinset.card |
CategoryTheory.Functor.Elements.isColimitCoconeπOpCompShrinkYonedaObj._proof_1 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
(F : CategoryTheory.Functor C (Type u_1)) (X : C)
(x :
(((CategoryTheory.CategoryOfElements.π F).op.comp
(CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.obj X)).coconeTypesEquiv.symm
(CategoryTheory.Functor.Elements.coconeπOpCompShrinkYonedaObj F X)).pt),
((CategoryTheory.CategoryOfElements.π F).op.comp (CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.obj X)).descColimitType
(((CategoryTheory.CategoryOfElements.π F).op.comp
(CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.obj X)).coconeTypesEquiv.symm
(CategoryTheory.Functor.Elements.coconeπOpCompShrinkYonedaObj F X))
(((CategoryTheory.CategoryOfElements.π F).op.comp
(CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.obj X)).ιColimitType
(Opposite.op (F.elementsMk X x))
(CategoryTheory.shrinkYonedaObjObjEquiv.symm (CategoryTheory.CategoryStruct.id X))) =
x |
ContinuousAlgEquiv.trans._proof_1 | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_4} {A : Type u_1} {B : Type u_3} {C : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Semiring C]
[inst_6 : TopologicalSpace C] [inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : Algebra R C] (e₁ : A ≃A[R] B)
(e₂ : B ≃A[R] C), Continuous (e₂.toFun ∘ ⇑e₁.toRingEquiv.toMulEquiv.toEquiv) |
Lean.Elab.Tactic.Try.TrySuggestionEntry._sizeOf_1 | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.TrySuggestionEntry → ℕ |
Lean.Grind.Linarith.instBEqPoly.beq._sparseCasesOn_1.else_eq | Init.Grind.Ordered.Linarith | ∀ {motive : Lean.Grind.Linarith.Poly → Sort u} (t : Lean.Grind.Linarith.Poly)
(nil : motive Lean.Grind.Linarith.Poly.nil) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)
(h : Nat.hasNotBit 1 t.ctorIdx), Lean.Grind.Linarith.instBEqPoly.beq._sparseCasesOn_1 t nil «else» = «else» h |
nilpotencyClass_eq_quotient_center_plus_one | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [hH : Group.IsNilpotent G] [Nontrivial G],
Group.nilpotencyClass G = Group.nilpotencyClass (G ⧸ Subgroup.center G) + 1 |
StarRingEquiv.noConfusion | Mathlib.Algebra.Star.StarRingHom | {P : Sort u} →
{A : Type u_1} →
{B : Type u_2} →
{inst : Add A} →
{inst_1 : Add B} →
{inst_2 : Mul A} →
{inst_3 : Mul B} →
{inst_4 : Star A} →
{inst_5 : Star B} →
{t : A ≃⋆+* B} →
{A' : Type u_1} →
{B' : Type u_2} →
{inst' : Add A'} →
{inst'_1 : Add B'} →
{inst'_2 : Mul A'} →
{inst'_3 : Mul B'} →
{inst'_4 : Star A'} →
{inst'_5 : Star B'} →
{t' : A' ≃⋆+* B'} →
A = A' →
B = B' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
inst_4 ≍ inst'_4 →
inst_5 ≍ inst'_5 → t ≍ t' → StarRingEquiv.noConfusionType P t t' |
SmoothBumpCovering.IsSubordinate.toSmoothPartitionOfUnity | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] [inst_5 : FiniteDimensional ℝ E] {s : Set M} [inst_6 : T2Space M]
[inst_7 : IsManifold I (↑⊤) M] {f : SmoothBumpCovering ι I M s} {U : M → Set M},
f.IsSubordinate U → f.toSmoothPartitionOfUnity.IsSubordinate fun i => U (f.c i) |
Lean.Grind.ToInt.Zero.rec | Init.Grind.ToInt | {α : Type u} →
[inst : Zero α] →
{I : Lean.Grind.IntInterval} →
[inst_1 : Lean.Grind.ToInt α I] →
{motive : Lean.Grind.ToInt.Zero α I → Sort u_1} →
((toInt_zero : ↑0 = 0) → motive ⋯) → (t : Lean.Grind.ToInt.Zero α I) → motive t |
EReal.bot_lt_zero | Mathlib.Data.EReal.Basic | ⊥ < 0 |
ContinuousLineDeriv.rec | Mathlib.Analysis.Distribution.DerivNotation | {V : Type u} →
{E : Type v} →
{F : Type w} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace F] →
[inst_2 : LineDeriv V E F] →
{motive : ContinuousLineDeriv V E F → Sort u_1} →
((continuous_lineDerivOp : ∀ (v : V), Continuous (LineDeriv.lineDerivOp v)) → motive ⋯) →
(t : ContinuousLineDeriv V E F) → motive t |
UniqueDiffWithinAt.mono_nhds | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
UniqueDiffWithinAt 𝕜 s x → nhdsWithin x s ≤ nhdsWithin x t → UniqueDiffWithinAt 𝕜 t x |
eq_of_mabs_div_le_one | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, |a / b|ₘ ≤ 1 → a = b |
Fin.insertNthEquiv_symm_apply | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} (α : Fin (n + 1) → Type u) (p : Fin (n + 1)) (f : (i : Fin (n + 1)) → α i),
(Fin.insertNthEquiv α p).symm f = (f p, p.removeNth f) |
CategoryTheory.ihom.ev_naturality_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A : C)
[inst_2 : CategoryTheory.Closed A] {X Y : C} (f : X ⟶ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft A ((CategoryTheory.ihom A).map f))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.ev A).app Y) h) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.ev A).app X) (CategoryTheory.CategoryStruct.comp f h) |
meromorphicTrailingCoeffAt.eq_1 | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 → E) (x : 𝕜),
meromorphicTrailingCoeffAt f x =
if h₁ : MeromorphicAt f x then if h₂ : meromorphicOrderAt f x = ⊤ then 0 else ⋯.choose x else 0 |
CommRingCat.instCategory | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.Category.{u_1, u_1 + 1} CommRingCat |
CategoryTheory.Pi.instLaxBraidedForallPi | Mathlib.CategoryTheory.Pi.Monoidal | {I : Type w₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] →
[inst_2 : (i : I) → CategoryTheory.BraidedCategory (C i)] →
{D : I → Type u₂} →
[inst_3 : (i : I) → CategoryTheory.Category.{v₂, u₂} (D i)] →
[inst_4 : (i : I) → CategoryTheory.MonoidalCategory (D i)] →
[inst_5 : (i : I) → CategoryTheory.BraidedCategory (D i)] →
(F : (i : I) → CategoryTheory.Functor (D i) (C i)) →
[(i : I) → (F i).LaxBraided] → (CategoryTheory.Functor.pi F).LaxBraided |
MonoidWithZero.toMulActionWithZero._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] (b : M₀), 1 • b = b |
exteriorPower.linearMap_ext_iff | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} {M : Type u_1} {N : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f g : ↥(⋀[R]^n M) →ₗ[R] N},
f = g ↔ f.compAlternatingMap (exteriorPower.ιMulti R n) = g.compAlternatingMap (exteriorPower.ιMulti R n) |
CliffordAlgebra.EquivEven.e0_mul_e0 | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), CliffordAlgebra.EquivEven.e0 Q * CliffordAlgebra.EquivEven.e0 Q = -1 |
MeasureTheory.predictablePart | Mathlib.Probability.Martingale.Centering | {Ω : Type u_1} →
{E : Type u_2} →
[inst : NormedAddCommGroup E] →
[NormedSpace ℝ E] →
[CompleteSpace E] →
{m0 : MeasurableSpace Ω} → (ℕ → Ω → E) → MeasureTheory.Filtration ℕ m0 → MeasureTheory.Measure Ω → ℕ → Ω → E |
CategoryTheory.yonedaCommGrpGrpObj._proof_6 | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (G : CategoryTheory.CommGrp C) {X Y Z : (CategoryTheory.Grp C)ᵒᵖ}
(f : X ⟶ Y) (g : Y ⟶ Z),
CommGrpCat.ofHom
{ toFun := fun x => CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g).unop x,
map_one' := ⋯, map_mul' := ⋯ } =
CategoryTheory.CategoryStruct.comp
(CommGrpCat.ofHom { toFun := fun x => CategoryTheory.CategoryStruct.comp f.unop x, map_one' := ⋯, map_mul' := ⋯ })
(CommGrpCat.ofHom { toFun := fun x => CategoryTheory.CategoryStruct.comp g.unop x, map_one' := ⋯, map_mul' := ⋯ }) |
_private.Init.Data.Nat.Lemmas.0.Nat.add_eq_three_iff._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {m n : ℕ}, ¬(m + n = 3 ↔ m = 0 ∧ n = 3 ∨ m = 1 ∧ n = 2 ∨ m = 2 ∧ n = 1 ∨ m = 3 ∧ n = 0) → False |
_private.Batteries.Data.Array.Basic.0.Array.scanlMFast._proof_1 | Batteries.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (stop : ℕ), (USize.ofNat (min stop as.size)).toNat ≤ as.size |
ContinuousMultilinearMap.instCompleteSpace | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup F] [∀ (i : ι), ContinuousSMul 𝕜 (E i)] [ContinuousConstSMul 𝕜 F] [CompleteSpace F]
[∀ (i : ι), IsTopologicalAddGroup (E i)] [SequentialSpace ((i : ι) → E i)],
CompleteSpace (ContinuousMultilinearMap 𝕜 E F) |
TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverse_map_hom | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasProducts C] {X : TopCat}
(F : TopCat.Presheaf C X) {ι : Type v'} (U : ι → TopologicalSpace.Opens ↑X)
{c c' : CategoryTheory.Limits.Cone (TopCat.Presheaf.SheafConditionEqualizerProducts.diagram F U)} (f : c ⟶ c'),
((TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverse F U).map f).hom = f.hom |
ConcaveOn.right_le_of_le_left' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConcaveOn 𝕜 s f →
∀ {x y : E} {a b : 𝕜}, x ∈ s → y ∈ s → 0 ≤ a → 0 < b → a + b = 1 → f (a • x + b • y) ≤ f x → f y ≤ f (a • x + b • y) |
CategoryTheory.PreZeroHypercover.inv_hom_h₀_assoc | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F)
(i : F.I₀) {Z : C} (h : F.X (e.hom.s₀ (e.inv.s₀ i)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.inv.h₀ i) (CategoryTheory.CategoryStruct.comp (e.hom.h₀ (e.inv.s₀ i)) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) h |
RootPairing.pairingIn_eq_add_of_root_eq_add | Mathlib.LinearAlgebra.RootSystem.IsValuedIn | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} [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} {S : Type u_6}
[inst_5 : CommRing S] [inst_6 : Algebra S R] [FaithfulSMul S R] [inst_8 : P.IsValuedIn S] {i j k l : ι},
P.root k = P.root i + P.root l → P.pairingIn S k j = P.pairingIn S i j + P.pairingIn S l j |
_private.Lean.Meta.ExprTraverse.0.Lean.Meta.traverseForallWithPos.visit._sunfold | Lean.Meta.ExprTraverse | {M : Type → Type u_1} →
[Monad M] →
[MonadLiftT Lean.MetaM M] →
[MonadControlT Lean.MetaM M] →
(Lean.SubExpr.Pos → Lean.Expr → M Lean.Expr) → Array Lean.Expr → Lean.SubExpr.Pos → Lean.Expr → M Lean.Expr |
ContinuousLinearMapWOT.seminormFamily | 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 : IsTopologicalAddGroup F] →
[inst_9 : ContinuousConstSMul 𝕜₂ F] → SeminormFamily 𝕜₂ (E →SWOT[σ] F) (E × StrongDual 𝕜₂ F) |
SubarrayIterator.step.eq_1 | Init.Data.Slice.Array.Iterator | ∀ {α : Type u} {m : Type u → Type u_1} (xs : Subarray α),
SubarrayIterator.step { internalState := { xs := xs } } =
if h : xs.start < xs.stop then
have this := ⋯;
have this := ⋯;
Std.IterStep.yield
{
internalState :=
{
xs :=
{
internalRepresentation :=
{ array := xs.array, start := xs.start + 1, stop := xs.stop, start_le_stop := ⋯,
stop_le_array_size := ⋯ } } } }
xs.array[xs.start]
else Std.IterStep.done |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces.consumeSpaces._mutual._proof_2 | Init.Data.String.Extra | ∀ {s : String} (n : ℕ) (it : s.Pos) (r : String),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun n it => PSigma.casesOn it fun it r => (it, 1)) fun _x =>
PSigma.casesOn _x fun it r => (it, 0))
Prod.instWellFoundedRelation).1
(PSum.inr ⟨it, r⟩) (PSum.inl ⟨n, ⟨it, r⟩⟩) |
Fin.orderIsoPair.match_1 | Mathlib.Order.Fin.Finset | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α) (motive : ↥{a, b} → Prop) (x : ↥{a, b}),
(∀ (x : α) (hx : x ∈ {a, b}), motive ⟨x, hx⟩) → motive x |
Lean.IR.SimpleGroundArg.rawReference.noConfusion | Lean.Compiler.IR.SimpleGroundExpr | {P : Sort u} →
{s s' : String} → Lean.IR.SimpleGroundArg.rawReference s = Lean.IR.SimpleGroundArg.rawReference s' → (s = s' → P) → P |
CategoryTheory.Limits.equalizerPullbackMapIso_hom_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasEqualizers C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X Y S T : C} {f g : X ⟶ Y} {s : X ⟶ S} {t : Y ⟶ S}
(hf : CategoryTheory.CategoryStruct.comp f t = s) (hg : CategoryTheory.CategoryStruct.comp g t = s) (v : T ⟶ S)
{Z : C} (h : CategoryTheory.Limits.pullback s v ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizerPullbackMapIso hf hg v).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.equalizer.ι f g)
(CategoryTheory.Limits.pullback.fst s v))
h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.equalizer.ι
(CategoryTheory.Limits.pullback.map s v t v f (CategoryTheory.CategoryStruct.id T)
(CategoryTheory.CategoryStruct.id S) ⋯ ⋯)
(CategoryTheory.Limits.pullback.map s v t v g (CategoryTheory.CategoryStruct.id T)
(CategoryTheory.CategoryStruct.id S) ⋯ ⋯))
h |
Matrix.conjTranspose_fromRows_eq_fromCols_conjTranspose | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} [inst : Star R] (A₁ : Matrix m₁ n R)
(A₂ : Matrix m₂ n R), (A₁.fromRows A₂).conjTranspose = A₁.conjTranspose.fromCols A₂.conjTranspose |
MeasureTheory.Measure.count.instSigmaFinite | Mathlib.MeasureTheory.Measure.Count | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] [Countable α],
MeasureTheory.SigmaFinite MeasureTheory.Measure.count |
_private.Mathlib.CategoryTheory.Functor.Category.0.CategoryTheory.Functor.rightUnitor._proof_5 | Mathlib.CategoryTheory.Functor.Category | ∀ {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) (x : C),
(CategoryTheory.CategoryStruct.comp { app := fun X => CategoryTheory.CategoryStruct.id (F.obj X), naturality := ⋯ }
{ app := fun X => CategoryTheory.CategoryStruct.id (F.obj X), naturality := ⋯ }).app
x =
(CategoryTheory.CategoryStruct.id (F.comp (CategoryTheory.Functor.id D))).app x |
CategoryTheory.MorphismProperty.HasQuotient.mk | Mathlib.CategoryTheory.MorphismProperty.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C}
{homRel : HomRel C} [inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel]
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel],
(∀ ⦃X Y : C⦄ ⦃f g : X ⟶ Y⦄, homRel f g → (W f ↔ W g)) → W.HasQuotient homRel |
ProbabilityTheory.strong_law_Lp | Mathlib.Probability.StrongLaw | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [inst_3 : MeasurableSpace E] [BorelSpace E] {p : ENNReal},
1 ≤ p →
p ≠ ⊤ →
∀ (X : ℕ → Ω → E),
MeasureTheory.MemLp (X 0) p μ →
Pairwise (Function.onFun (fun x1 x2 => ProbabilityTheory.IndepFun x1 x2 μ) X) →
(∀ (i : ℕ), ProbabilityTheory.IdentDistrib (X i) (X 0) μ μ) →
Filter.Tendsto
(fun n =>
MeasureTheory.eLpNorm (fun ω => (↑n)⁻¹ • ∑ i ∈ Finset.range n, X i ω - ∫ (x : Ω), X 0 x ∂μ) p μ)
Filter.atTop (nhds 0) |
Std.TreeSet.min!_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.min! ∈ t |
MulDissociated.subset | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : CommGroup α] {s t : Set α}, s ⊆ t → MulDissociated t → MulDissociated s |
CategoryTheory.Limits.PullbackCone.combineIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Pullbacks | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_4, u_3} D] {F G H : CategoryTheory.Functor D C} (f : F ⟶ H) (g : G ⟶ H)
(c : (X : D) → CategoryTheory.Limits.PullbackCone (f.app X) (g.app X))
(hc : (X : D) → CategoryTheory.Limits.IsLimit (c X)) (k : D) (j : CategoryTheory.Limits.WalkingCospan),
((CategoryTheory.Limits.Cone.postcompose
(CategoryTheory.Limits.cospanIsoMk
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.cospan (f.app k) (g.app k)).obj CategoryTheory.Limits.WalkingCospan.one))
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.cospan (f.app k) (g.app k)).obj CategoryTheory.Limits.WalkingCospan.left))
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.cospan (f.app k) (g.app k)).obj
CategoryTheory.Limits.WalkingCospan.right))
⋯ ⋯).hom).obj
(c k)).π.app
j =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.Cone.postcompose
(CategoryTheory.Limits.cospanIsoMk
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.cospan (f.app k) (g.app k)).obj
CategoryTheory.Limits.WalkingCospan.one))
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.cospan (f.app k) (g.app k)).obj
CategoryTheory.Limits.WalkingCospan.left))
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.cospan (f.app k) (g.app k)).obj
CategoryTheory.Limits.WalkingCospan.right))
⋯ ⋯).hom).obj
(c k)).pt).hom
((((CategoryTheory.evaluation D C).obj k).mapCone (CategoryTheory.Limits.PullbackCone.combine f g c hc)).π.app j) |
Lean.mkListNode | Lean.Syntax | Array Lean.Syntax → Lean.Syntax |
CategoryTheory.Arrow.AugmentedCechNerve.extraDegeneracy._proof_3 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
(S : CategoryTheory.SplitEpi f.hom),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.AugmentedCechNerve.ExtraDegeneracy.s f S 0)
(f.augmentedCechNerve.left.δ 1) =
CategoryTheory.CategoryStruct.comp (f.augmentedCechNerve.hom.app (Opposite.op (SimplexCategory.mk 0)))
(CategoryTheory.CategoryStruct.comp S.section_
(CategoryTheory.Limits.WidePullback.lift f.hom
(fun x => CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id C).obj f.left)) ⋯)) |
SubgroupClass.coe_zpow._simp_2 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {S : Type u_4} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G] (x : ↥H)
(n : ℤ), ↑x ^ n = ↑(x ^ n) |
Monotone.ae_hasDerivAt | Mathlib.Analysis.Calculus.Monotone | ∀ {f : ℝ → ℝ} (hf : Monotone f),
∀ᵐ (x : ℝ), HasDerivAt f (hf.stieltjesFunction.measure.rnDeriv MeasureTheory.volume x).toReal x |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree.0.groupCohomology.mem_cocycles₁_iff._simp_1_3 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) |
Std.TreeMap.instSliceableRcoSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax |
CommRingCat.Colimits.Relation.below.mul | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
{motive : (a a_1 : CommRingCat.Colimits.Prequotient F) → CommRingCat.Colimits.Relation F a a_1 → Prop} (j : J)
(x y : ↑(F.obj j)), CommRingCat.Colimits.Relation.below ⋯ |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.State.found | Lean.Util.ParamMinimizer | Lean.Util.ParamMinimizer.State✝ → Bool |
nnnorm_pow_le_mul_norm | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] {a : E} {n : ℕ}, ‖a ^ n‖₊ ≤ ↑n * ‖a‖₊ |
Matrix.updateCol_self | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {j : n} {c : m → α} [inst : DecidableEq n],
M.updateCol j c i j = c i |
Lean.Nat.mkInstPow | Lean.Expr | Lean.Expr |
WithCStarModule.instUniformSpace | Mathlib.Analysis.CStarAlgebra.Module.Synonym | {A : Type u_3} → {E : Type u_4} → [u : UniformSpace E] → UniformSpace (WithCStarModule A E) |
Fin.univ_succAbove._proof_1 | Mathlib.Data.Fintype.Basic | ∀ (n : ℕ) (p : Fin (n + 1)), p ∉ Finset.map p.succAboveEmb Finset.univ |
RingTheory.Sequence.IsRegular.recIterModByRegularWithRing | Mathlib.RingTheory.Regular.RegularSequence | {motive :
(R : Type u) →
[inst : CommRing R] →
(M : Type v) →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (rs : List R) → RingTheory.Sequence.IsRegular M rs → Sort u_7} →
((R : Type u) →
[inst : CommRing R] →
(M : Type v) → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → [inst_3 : Nontrivial M] → motive R M [] ⋯) →
({R : Type u} →
[inst : CommRing R] →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(r : R) →
(rs : List R) →
(h1 : IsSMulRegular M r) →
(h2 :
RingTheory.Sequence.IsRegular (QuotSMulTop r M)
(List.map (⇑(Ideal.Quotient.mk (Ideal.span {r}))) rs)) →
motive (R ⧸ Ideal.span {r}) (QuotSMulTop r M)
(List.map (⇑(Ideal.Quotient.mk (Ideal.span {r}))) rs) h2 →
motive R M (r :: rs) ⋯) →
{R : Type u} →
[inst : CommRing R] →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → {rs : List R} → (h : RingTheory.Sequence.IsRegular M rs) → motive R M rs h |
CategoryTheory.ObjectProperty.monotone_retractClosure | Mathlib.CategoryTheory.ObjectProperty.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.retractClosure ≤ Q.retractClosure |
PseudoMetricSpace.toPseudoEMetricSpace | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u} → [PseudoMetricSpace α] → PseudoEMetricSpace α |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_add._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {i_lt : i < w}, ¬w - 1 - i < w → False |
CategoryTheory.ObjectProperty.colimitsClosure.recOn | Mathlib.CategoryTheory.ObjectProperty.ColimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)]
{motive : (a : C) → P.colimitsClosure J a → Prop} {a : C} (t : P.colimitsClosure J a),
(∀ (X : C) (hX : P X), motive X ⋯) →
(∀ {X Y : C} (e : X ≅ Y) (hX : P.colimitsClosure J X), motive X hX → motive Y ⋯) →
(∀ {X : C} {a : α} (pres : CategoryTheory.Limits.ColimitPresentation (J a) X)
(h : ∀ (j : J a), P.colimitsClosure J (pres.diag.obj j)),
(∀ (j : J a), motive (pres.diag.obj j) ⋯) → motive X ⋯) →
motive a t |
CategoryTheory.Center.ofBraidedObj_fst | Mathlib.CategoryTheory.Monoidal.Center | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C), (CategoryTheory.Center.ofBraidedObj X).fst = X |
_private.Mathlib.Algebra.Order.Star.Basic.0.StarOrderedRing.pos_iff._simp_1_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) |
Std.ExtDHashMap.getKey!_inter_of_mem_right | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {k : α}, k ∈ m₂ → (m₁ ∩ m₂).getKey! k = m₁.getKey! k |
CategoryTheory.PreZeroHypercover.pullback₁_X | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T : C} (f : S ⟶ T) (E : CategoryTheory.PreZeroHypercover T)
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback f (E.f i)] (i : E.I₀),
(CategoryTheory.PreZeroHypercover.pullback₁ f E).X i = CategoryTheory.Limits.pullback f (E.f i) |
Aesop.LIFOQueue.rec | Aesop.Search.Queue | {motive : Aesop.LIFOQueue → Sort u} →
((goals : Array Aesop.GoalRef) → motive { goals := goals }) → (t : Aesop.LIFOQueue) → motive t |
RKHS.kernel.congr_simp | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] (H : Type u_4) [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] [inst_6 : CompleteSpace H] [inst_7 : CompleteSpace V] (a a_1 : X),
a = a_1 → ∀ (a_2 a_3 : X), a_2 = a_3 → RKHS.kernel H a a_2 = RKHS.kernel H a_1 a_3 |
List.findIdx_eq_findIdx?.match_1 | Batteries.Data.List.Lemmas | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → ((i : ℕ) → motive (some i)) → (Unit → motive none) → motive x |
Metric.sphere_union_ball | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.sphere x ε ∪ Metric.ball x ε = Metric.closedBall x ε |
Rat.exists_eq_mul_div_num_and_eq_mul_div_den | Mathlib.Data.Rat.Lemmas | ∀ (n : ℤ) {d : ℤ}, d ≠ 0 → ∃ c, n = c * (↑n / ↑d).num ∧ d = c * ↑(↑n / ↑d).den |
AdicCompletion.AdicCauchySequence.instSMul._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(r : R) (x : AdicCompletion.AdicCauchySequence I M) {m n : ℕ}, m ≤ n → r • ↑x m ≡ r • ↑x n [SMOD I ^ m • ⊤] |
RingHom.frobenius_comm | Mathlib.Algebra.CharP.Frobenius | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (g : R →+* S) (p : ℕ)
[inst_2 : ExpChar R p] [inst_3 : ExpChar S p], g.comp (frobenius R p) = (frobenius S p).comp g |
Insert.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{γ : Type v} →
{P : Sort u_1} →
{insert insert' : α → γ → γ} → { insert := insert } = { insert := insert' } → (insert ≍ insert' → P) → P |
MvPolynomial.X_mul_pderiv_monomial | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} [inst : CommSemiring R] {i : σ} {m : σ →₀ ℕ} {r : R},
MvPolynomial.X i * (MvPolynomial.pderiv i) ((MvPolynomial.monomial m) r) = m i • (MvPolynomial.monomial m) r |
MvPolynomial.constantCoeff_comp_algebraMap | Mathlib.Algebra.MvPolynomial.Basic | ∀ (R : Type u) (σ : Type u_1) [inst : CommSemiring R],
MvPolynomial.constantCoeff.comp (algebraMap R (MvPolynomial σ R)) = RingHom.id R |
Finset.toSet | Mathlib.Data.Finset.Defs | {α : Type u_1} → Finset α → Set α |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_III._simp_1_4 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) |
Std.TreeMap.contains_insertIfNew | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k a : α} {v : β},
(t.insertIfNew k v).contains a = (cmp k a == Ordering.eq || t.contains a) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.