name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
DividedPowers.mk.injEq | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (dpow : ℕ → A → A)
(dpow_null : ∀ {n : ℕ} {x : A}, x ∉ I → dpow n x = 0) (dpow_zero : ∀ {x : A}, x ∈ I → dpow 0 x = 1)
(dpow_one : ∀ {x : A}, x ∈ I → dpow 1 x = x) (dpow_mem : ∀ {n : ℕ} {x : A}, n ≠ 0 → x ∈ I → dpow n x ∈ I)
(dpow_add :
∀ {n : ℕ} {x y : A}, x ∈ I → y ∈ I → dpow n (x + y) = ∑ k ∈ Finset.antidiagonal n, dpow k.1 x * dpow k.2 y)
(dpow_mul : ∀ {n : ℕ} {a x : A}, x ∈ I → dpow n (a * x) = a ^ n * dpow n x)
(mul_dpow : ∀ {m n : ℕ} {x : A}, x ∈ I → dpow m x * dpow n x = ↑((m + n).choose m) * dpow (m + n) x)
(dpow_comp : ∀ {m n : ℕ} {x : A}, n ≠ 0 → x ∈ I → dpow m (dpow n x) = ↑(m.uniformBell n) * dpow (m * n) x)
(dpow_1 : ℕ → A → A) (dpow_null_1 : ∀ {n : ℕ} {x : A}, x ∉ I → dpow_1 n x = 0)
(dpow_zero_1 : ∀ {x : A}, x ∈ I → dpow_1 0 x = 1) (dpow_one_1 : ∀ {x : A}, x ∈ I → dpow_1 1 x = x)
(dpow_mem_1 : ∀ {n : ℕ} {x : A}, n ≠ 0 → x ∈ I → dpow_1 n x ∈ I)
(dpow_add_1 :
∀ {n : ℕ} {x y : A}, x ∈ I → y ∈ I → dpow_1 n (x + y) = ∑ k ∈ Finset.antidiagonal n, dpow_1 k.1 x * dpow_1 k.2 y)
(dpow_mul_1 : ∀ {n : ℕ} {a x : A}, x ∈ I → dpow_1 n (a * x) = a ^ n * dpow_1 n x)
(mul_dpow_1 : ∀ {m n : ℕ} {x : A}, x ∈ I → dpow_1 m x * dpow_1 n x = ↑((m + n).choose m) * dpow_1 (m + n) x)
(dpow_comp_1 : ∀ {m n : ℕ} {x : A}, n ≠ 0 → x ∈ I → dpow_1 m (dpow_1 n x) = ↑(m.uniformBell n) * dpow_1 (m * n) x),
({ dpow := dpow, dpow_null := dpow_null, dpow_zero := dpow_zero, dpow_one := dpow_one, dpow_mem := dpow_mem,
dpow_add := dpow_add, dpow_mul := dpow_mul, mul_dpow := mul_dpow, dpow_comp := dpow_comp } =
{ dpow := dpow_1, dpow_null := dpow_null_1, dpow_zero := dpow_zero_1, dpow_one := dpow_one_1,
dpow_mem := dpow_mem_1, dpow_add := dpow_add_1, dpow_mul := dpow_mul_1, mul_dpow := mul_dpow_1,
dpow_comp := dpow_comp_1 }) =
(dpow = dpow_1) |
_private.Mathlib.Algebra.Star.NonUnitalSubalgebra.0.NonUnitalStarAlgebra.coe_bot._simp_1_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] {x : A}, (x ∈ ⊥) = (x = 0) |
DomAddAct.instIsCancelAddOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : Add Mᵃᵒᵖ] [IsCancelAdd Mᵃᵒᵖ], IsCancelAdd Mᵈᵃᵃ |
Lean.Meta.Grind.AC.modify' | Lean.Meta.Tactic.Grind.AC.Util | (Lean.Meta.Grind.AC.State → Lean.Meta.Grind.AC.State) → Lean.Meta.Grind.GoalM Unit |
rTensor.toFun.congr_simp | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g g_1 : N →ₗ[R] P} (e_g : g = g_1) (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module R Q]
(hfg : Function.Exact ⇑f ⇑g), rTensor.toFun Q hfg = rTensor.toFun Q ⋯ |
Multiset.disjSum_mono_left | Mathlib.Data.Multiset.Sum | ∀ {α : Type u_1} {β : Type u_2} (t : Multiset β), Monotone fun s => s.disjSum t |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.initFn.findIdx._@.Mathlib.Tactic.GCongr.Core.2213018204._hygCtx._hyg.2 | Mathlib.Tactic.GCongr.Core | (xs : Array Lean.Expr) → Lean.Name → (i : ℕ) → i ≤ xs.size → Lean.MetaM (Fin xs.size) |
MulAction.subsingleton_orbit_iff_mem_fixedPoints | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] {a : α},
(MulAction.orbit M a).Subsingleton ↔ a ∈ MulAction.fixedPoints M α |
_private.Mathlib.Algebra.Lie.Loop.0.LieAlgebra.LoopAlgebra.twoCocycleOfBilinear._proof_5 | Mathlib.Algebra.Lie.Loop | ∀ (A : Type u_1) [inst : CommRing A] (a b c : A), a + b + c = 0 → a + b = -c |
RingHom.kerLift._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Semiring S] (f : R →+* S), (RingHom.ker f).IsTwoSided |
MonoidHom.snd._proof_2 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_1) (N : Type u_2) [inst : MulOneClass M] [inst_1 : MulOneClass N] (x x_1 : M × N),
(x * x_1).2 = (x * x_1).2 |
Lean.Lsp.SemanticTokensParams.recOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokensParams → Sort u} →
(t : Lean.Lsp.SemanticTokensParams) →
((textDocument : Lean.Lsp.TextDocumentIdentifier) → motive { textDocument := textDocument }) → motive t |
_private.Lean.Language.Basic.0.Lean.Language.Snapshot.Diagnostics.mk | Lean.Language.Basic | Lean.MessageLog → Option (IO.Ref (Option Dynamic)) → Lean.Language.Snapshot.Diagnostics |
HSub.mk | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HSub α β γ |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn.primitiveTriangle._simp_33 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False |
Pi.instKleeneAlgebraForall._proof_4 | Mathlib.Algebra.Order.Kleene | ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → KleeneAlgebra (π i)] (x x_1 : (i : ι) → π i),
x_1 * x ≤ x_1 → ∀ (x_2 : ι), x_1 x_2 * KStar.kstar (x x_2) ≤ x_1 x_2 |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_roc_add_add_eq_append._proof_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n k : ℕ}, ¬m + n + 1 ≤ m + n + k + 1 → False |
Path.Homotopy.transAssoc._proof_3 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | Path.Homotopy.transAssocReparamAux 1 ∈ unitInterval |
FP.Float.isFinite | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → FP.Float → Bool |
Std.Tactic.BVDecide.BVPred.instToString | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ToString Std.Tactic.BVDecide.BVPred |
Subtype.coe_mk | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} (a : α) (h : p a), ↑⟨a, h⟩ = a |
bernsteinPolynomial.variance | Mathlib.RingTheory.Polynomial.Bernstein | ∀ (R : Type u_1) [inst : CommRing R] (n : ℕ),
∑ ν ∈ Finset.range (n + 1), (n • Polynomial.X - ↑ν) ^ 2 * bernsteinPolynomial R n ν =
n • Polynomial.X * (1 - Polynomial.X) |
CategoryTheory.Comon.monoidal_tensorUnit_comon_counit | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.ComonObj.counit = CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) |
Lean.Grind.ToInt.Neg.toInt_neg | Init.Grind.ToInt | ∀ {α : Type u} {inst : Neg α} {I : outParam Lean.Grind.IntInterval} {inst_1 : Lean.Grind.ToInt α I}
[self : Lean.Grind.ToInt.Neg α I] (x : α), ↑(-x) = I.wrap (-↑x) |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.reverse_balLeft._proof_1_10 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (l : Batteries.RBNode α) (v : α) (r' l' a : Batteries.RBNode α) (y : α) (b : Batteries.RBNode α),
r' = (Batteries.RBNode.node Batteries.RBColor.black a y b).reverse →
(∀ (a : Batteries.RBNode α) (x : α) (b : Batteries.RBNode α),
r' = Batteries.RBNode.node Batteries.RBColor.black a x b → False) →
(l.balance2 v (Batteries.RBNode.node Batteries.RBColor.red a y b)).reverse =
Batteries.RBNode.node Batteries.RBColor.red r' v l' |
_private.Mathlib.CategoryTheory.Bicategory.Coherence.0.CategoryTheory.FreeBicategory.inclusionPathAux.match_1.eq_1 | Mathlib.CategoryTheory.Bicategory.Coherence | ∀ {B : Type u_2} [inst : Quiver B] {a : B} (motive : (x : B) → Quiver.Path a x → Sort u_3)
(h_1 : Unit → motive a Quiver.Path.nil) (h_2 : (x b : B) → (p : Quiver.Path a b) → (f : b ⟶ x) → motive x (p.cons f)),
(match a, Quiver.Path.nil with
| .(a), Quiver.Path.nil => h_1 ()
| x, p.cons f => h_2 x b p f) =
h_1 () |
List.Nodup.insert | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l : List α} {a : α} [inst : BEq α] [LawfulBEq α], l.Nodup → (List.insert a l).Nodup |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.getParamTypes._sparseCasesOn_1 | Lean.Compiler.LCNF.MonoTypes | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t |
LinearMap.restrictScalars | Mathlib.Algebra.Module.LinearMap.Defs | (R : Type u_1) →
{S : Type u_5} →
{M : Type u_8} →
{M₂ : Type u_10} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R M₂] →
[inst_6 : Module S M] →
[inst_7 : Module S M₂] → [LinearMap.CompatibleSMul M M₂ R S] → (M →ₗ[S] M₂) → M →ₗ[R] M₂ |
Equiv.sigmaSubtypeFiberEquiv | Mathlib.Logic.Equiv.Basic | {α : Type u_9} →
{β : Type u_10} → (f : α → β) → (p : β → Prop) → (∀ (x : α), p (f x)) → (y : Subtype p) × { x // f x = ↑y } ≃ α |
BialgEquiv.ext | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
{e e' : A ≃ₐc[R] B}, (∀ (x : A), e x = e' x) → e = e' |
_private.Mathlib.RingTheory.PowerSeries.Evaluation.0.PowerSeries.HasEval.add._simp_1_1 | Mathlib.RingTheory.PowerSeries.Evaluation | ∀ {S : Type u_2} [inst : CommRing S] [inst_1 : TopologicalSpace S] {a : S},
PowerSeries.HasEval a = MvPowerSeries.HasEval fun x => a |
BoundedContinuousFunction.mkOfDiscrete | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
[DiscreteTopology α] →
(f : α → β) → (C : ℝ) → (∀ (x y : α), dist (f x) (f y) ≤ C) → BoundedContinuousFunction α β |
CategoryTheory.Limits.coequalizerComparison._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {X Y : C} (f g : X ⟶ Y) {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor C D)
[inst_2 : CategoryTheory.Limits.HasCoequalizer f g],
CategoryTheory.CategoryStruct.comp (G.map f) (G.map (CategoryTheory.Limits.coequalizer.π f g)) =
CategoryTheory.CategoryStruct.comp (G.map g) (G.map (CategoryTheory.Limits.coequalizer.π f g)) |
DivisionSemiring.zpow_succ' | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_2} [self : DivisionSemiring K] (n : ℕ) (a : K),
DivisionSemiring.zpow (↑n.succ) a = DivisionSemiring.zpow (↑n) a * a |
_private.Init.Data.Dyadic.Round.0.Dyadic.roundDown_le.match_1_3 | Init.Data.Dyadic.Round | ∀ (motive : ℤ → Prop) (x : ℤ),
(∀ (l : ℕ), x = Int.ofNat l → motive (Int.ofNat l)) →
(∀ (a : ℕ), x = Int.negSucc a → motive (Int.negSucc a)) → motive x |
Lean.Parser.«command__Builtin_simproc__[_]_(_):=_» | Init.Simproc | Lean.ParserDescr |
Set.dual_ordConnected_iff | Mathlib.Order.Interval.Set.OrdConnected | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, (⇑OrderDual.ofDual ⁻¹' s).OrdConnected ↔ s.OrdConnected |
egauge_smul_left | Mathlib.Analysis.Convex.EGauge | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] {c : 𝕜},
c ≠ 0 → ∀ (s : Set E) (x : E), egauge 𝕜 (c • s) x = egauge 𝕜 s x / ‖c‖ₑ |
StieltjesFunction.measure_Icc | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R] (a b : R),
f.measure (Set.Icc a b) = ENNReal.ofReal (↑f b - Function.leftLim (↑f) a) |
Batteries.RBMap.instCoeHeadKeysList | Batteries.Data.RBMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → CoeHead (Batteries.RBMap.Keys α β cmp) (List α) |
Quaternion.normSq_intCast._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (z : ℤ), ↑z ^ 2 = Quaternion.normSq ↑z |
FreeAddGroup.Red.Step.not_rev._simp_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {x : α} {b : Bool},
FreeAddGroup.Red.Step (L₁ ++ (x, !b) :: (x, b) :: L₂) (L₁ ++ L₂) = True |
CompHausLike.LocallyConstant.presheaf_ext | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{S : CompHausLike P} {Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))}
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}]
(f : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op (CompHausLike.of P PUnit.{u + 1}))))
(X : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))) [CategoryTheory.Limits.PreservesFiniteProducts X]
(x y : X.obj (Opposite.op S)) [CompHausLike.HasExplicitFiniteCoproducts P],
(∀ (a : Function.Fiber ⇑f),
X.map (CompHausLike.LocallyConstant.sigmaIncl f a).op x =
X.map (CompHausLike.LocallyConstant.sigmaIncl f a).op y) →
x = y |
LinearAlgebra.FreeProduct.lift_unique | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ {I : Type u} [inst : DecidableEq I] (R : Type v) [inst_1 : CommSemiring R] (A : I → Type w)
[inst_2 : (i : I) → Semiring (A i)] [inst_3 : (i : I) → Algebra R (A i)] {B : Type w'} [inst_4 : Semiring B]
[inst_5 : Algebra R B] (maps : {i : I} → A i →ₐ[R] B) (f : LinearAlgebra.FreeProduct R A →ₐ[R] B),
(∀ (i : I), f.comp (LinearAlgebra.FreeProduct.ι R A i) = maps) →
f = (LinearAlgebra.FreeProduct.lift R A) fun {i} => maps |
RingNormClass.casesOn | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : NonUnitalNonAssocRing α] →
[inst_1 : Semiring β] →
[inst_2 : PartialOrder β] →
[inst_3 : FunLike F α β] →
{motive : RingNormClass F α β → Sort u} →
(t : RingNormClass F α β) →
([toRingSeminormClass : RingSeminormClass F α β] →
(eq_zero_of_map_eq_zero : ∀ (f : F) {a : α}, f a = 0 → a = 0) → motive ⋯) →
motive t |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform.0.Finpartition.IsEquipartition.card_interedges_sparsePairs_le'._simp_1_9 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
RootPairingCat.mk | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {R : Type u} →
[inst : CommRing R] →
(weight : Type v) →
[weightIsAddCommGroup : AddCommGroup weight] →
[weightIsModule : Module R weight] →
(coweight : Type v) →
[coweightIsAddCommGroup : AddCommGroup coweight] →
[coweightIsModule : Module R coweight] →
(index : Type v) → RootPairing index R weight coweight → RootPairingCat R |
LightProfinite.Extend.functor._proof_4 | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {F : CategoryTheory.Functor ℕᵒᵖ FintypeCat} (c : CategoryTheory.Limits.Cone (F.comp FintypeCat.toLightProfinite))
{X Y Z : ℕᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.StructuredArrow.homMk (F.map (CategoryTheory.CategoryStruct.comp f g)) ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.homMk (F.map f) ⋯)
(CategoryTheory.StructuredArrow.homMk (F.map g) ⋯) |
_private.Mathlib.FieldTheory.Galois.Basic.0.IsGalois.map_fixingSubgroup._simp_1_1 | Mathlib.FieldTheory.Galois.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
UInt64.instCommMonoid | Mathlib.Data.UInt | CommMonoid UInt64 |
Quaternion.re_im | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), a.im.re = 0 |
_private.Mathlib.Data.List.Cycle.0.Cycle.Subsingleton.nodup._simp_1_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α}, (l.length = 0) = (l = []) |
CategoryTheory.GrothendieckTopology.instCompleteLattice._proof_5 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C], min = min |
AddAction.IsPreprimitive.isCoatom_stabilizer_of_isPreprimitive | Mathlib.GroupTheory.GroupAction.Primitive | ∀ (G : Type u_3) [inst : AddGroup G] {X : Type u_4} [inst_1 : AddAction G X] [Nontrivial X]
[AddAction.IsPreprimitive G X] (a : X), IsCoatom (AddAction.stabilizer G a) |
CauSeq.lim_le | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : CauSeq.IsComplete α abs] {f : CauSeq α abs} {x : α}, f ≤ CauSeq.const abs x → f.lim ≤ x |
differentiable_star_iff._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Star | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : StarRing 𝕜] {E : Type u_2} [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : StarAddMonoid F]
[inst_6 : NormedSpace 𝕜 F] [StarModule 𝕜 F] [ContinuousStar F] {f : E → F} [TrivialStar 𝕜],
(Differentiable 𝕜 fun y => star (f y)) = Differentiable 𝕜 f |
Lean.Meta.Grind.AC.DiseqCnstrProof.ctorElimType | Lean.Meta.Tactic.Grind.AC.Types | {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u} → ℕ → Sort (max 1 u) |
Lean.Elab.PartialFixpoint.fixpointType._default | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType |
Submodule.mapHom._proof_2 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A] {A' : Type u_1}
[inst_3 : Semiring A'] [inst_4 : Algebra R A'] (f : A →ₐ[R] A'), Submodule.map f.toLinearMap ⊥ = ⊥ |
Lean.Elab.Tactic.BVDecide.External.TimedOut.casesOn | Lean.Elab.Tactic.BVDecide.External | {α : Type u} →
{motive : Lean.Elab.Tactic.BVDecide.External.TimedOut α → Sort u_1} →
(t : Lean.Elab.Tactic.BVDecide.External.TimedOut α) →
((x : α) → motive (Lean.Elab.Tactic.BVDecide.External.TimedOut.success x)) →
motive Lean.Elab.Tactic.BVDecide.External.TimedOut.timeout → motive t |
List.mapIdx_ne_nil_iff | Init.Data.List.MapIdx | ∀ {α : Type u_1} {α_1 : Type u_2} {f : ℕ → α → α_1} {l : List α}, List.mapIdx f l ≠ [] ↔ l ≠ [] |
ZMod.expand_card | Mathlib.FieldTheory.Finite.Basic | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : Polynomial (ZMod p)), (Polynomial.expand (ZMod p) p) f = f ^ p |
String.Slice.Pos.splits | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} (p : s.Pos), p.Splits (s.sliceTo p).copy (s.sliceFrom p).copy |
CategoryTheory.mop_rightUnitor | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).mop =
CategoryTheory.MonoidalCategoryStruct.leftUnitor { unmop := X } |
MeasureTheory.SimpleFunc.instNonAssocSemiring._proof_6 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonAssocSemiring β]
(f g : MeasureTheory.SimpleFunc α β), ⇑(f + g) = ⇑f + ⇑g |
Representation.ind | Mathlib.RepresentationTheory.Induced | {k : Type u_1} →
{G : Type u_2} →
{H : Type u_3} →
[inst : CommRing k] →
[inst_1 : Group G] →
[inst_2 : Group H] →
(φ : G →* H) →
{A : Type u_4} →
[inst_3 : AddCommGroup A] →
[inst_4 : Module k A] → (ρ : Representation k G A) → Representation k H (Representation.IndV φ ρ) |
_private.Mathlib.Order.Basic.0.Function.Injective.linearOrder._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), (a ≤ b ∨ b ≤ a) = True |
ULift.up.noConfusion | Init.Prelude | {α : Type s} → {P : Sort u} → {down down' : α} → { down := down } = { down := down' } → (down ≍ down' → P) → P |
ContinuousMap.compStarAlgHom._proof_5 | Mathlib.Topology.ContinuousMap.Star | ∀ (X : Type u_1) {𝕜 : Type u_4} {A : Type u_3} {B : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommSemiring 𝕜]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : IsTopologicalSemiring A] [inst_5 : Star A]
[inst_6 : Algebra 𝕜 A] [inst_7 : TopologicalSpace B] [inst_8 : Semiring B] [inst_9 : IsTopologicalSemiring B]
[inst_10 : Star B] [inst_11 : Algebra 𝕜 B] (φ : A →⋆ₐ[𝕜] B) (hφ : Continuous ⇑φ) (r : 𝕜),
{ toFun := ⇑φ, continuous_toFun := hφ }.comp ((algebraMap 𝕜 C(X, A)) r) = (algebraMap 𝕜 C(X, B)) r |
Lean.Lsp.RpcRef.mk.injEq | Lean.Server.Rpc.Basic | ∀ (p p_1 : USize), ({ p := p } = { p := p_1 }) = (p = p_1) |
GrpCat.SurjectiveOfEpiAuxs.τ_apply_infinity | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B),
(GrpCat.SurjectiveOfEpiAuxs.tau f) GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.infinity =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨↑(GrpCat.Hom.hom f).range, ⋯⟩ |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.processNullaryOrCat.match_1 | Lean.Elab.Syntax | (motive : Array Lean.Syntax → Sort u_1) →
(x : Array Lean.Syntax) → ((arg : Lean.Syntax) → motive #[arg]) → ((x : Array Lean.Syntax) → motive x) → motive x |
CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKanLift._proof_2 | Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {u : b ⟶ a}
(adj : CategoryTheory.Bicategory.Adjunction f u) {x : B} (h : x ⟶ a)
(s :
CategoryTheory.Bicategory.LeftLift u (CategoryTheory.CategoryStruct.comp h (CategoryTheory.CategoryStruct.id a))),
CategoryTheory.bicategoricalComp
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp h (CategoryTheory.CategoryStruct.id a)))
(CategoryTheory.bicategoricalComp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft
(CategoryTheory.CategoryStruct.comp h (CategoryTheory.CategoryStruct.id a)) adj.unit)
(CategoryTheory.Bicategory.whiskerRight s.unit (CategoryTheory.CategoryStruct.comp f u)))
(CategoryTheory.bicategoricalComp
(CategoryTheory.Bicategory.whiskerLeft s.lift (CategoryTheory.Bicategory.whiskerRight adj.counit u))
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp s.lift u)))) =
CategoryTheory.bicategoricalComp s.unit
(CategoryTheory.bicategoricalComp
(CategoryTheory.Bicategory.whiskerLeft s.lift (CategoryTheory.Bicategory.rightZigzag adj.unit adj.counit))
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp s.lift u))) |
CategoryTheory.effectiveEpiStructOfRegularEpi._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B X : C} {f : X ⟶ B} (hf : CategoryTheory.RegularEpi f)
{W : C} (x : X ⟶ W),
(∀ {Z : C} (g₁ g₂ : Z ⟶ X),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategoryStruct.comp g₁ x = CategoryTheory.CategoryStruct.comp g₂ x) →
CategoryTheory.CategoryStruct.comp hf.left x = CategoryTheory.CategoryStruct.comp hf.right x |
Std.HashMap.Equiv.of_toList_perm | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β},
m₁.toList.Perm m₂.toList → m₁.Equiv m₂ |
CommAlgCat.instConcreteCategoryAlgHomCarrier._proof_4 | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {X Y Z : CommAlgCat R} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) |
exists_prop_of_true | Init.PropLemmas | ∀ {p : Prop} {q : p → Prop} (h : p), (∃ (h' : p), q h') ↔ q h |
MultipliableLocallyUniformlyOn.hasProdLocallyUniformlyOn | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β],
MultipliableLocallyUniformlyOn f s → HasProdLocallyUniformlyOn f (fun x => ∏' (i : ι), f i x) s |
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_iff._simp_1_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p : α → Prop} {f : Filter α},
(∃ᶠ (x : α) in f, p x) = ∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, p x ∧ q x |
seminormFromBounded_of_mul_apply | Mathlib.Analysis.Normed.Unbundled.SeminormFromBounded | ∀ {R : Type u_1} [inst : CommRing R] {f : R → ℝ} {c : ℝ},
0 ≤ f →
(∀ (x y : R), f (x * y) ≤ c * f x * f y) →
∀ {x : R}, (∀ (y : R), f (x * y) = f x * f y) → seminormFromBounded' f x = f x |
MonoidWithZeroHom.ValueGroup₀.restrict₀._proof_2 | Mathlib.Algebra.GroupWithZero.Range | ∀ {A : Type u_2} {B : Type u_1} {F : Type u_3} [inst : FunLike F A B] (f : F) [inst_1 : MonoidWithZero A]
[inst_2 : GroupWithZero B] [inst_3 : MonoidWithZeroHomClass F A B] (a : A) (h : ¬f a = 0),
Units.mk0 (f a) h ∈ MonoidWithZeroHom.valueGroup f |
SchwartzMap.smulLeftCLM_ofReal | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (𝕜' : Type u_10) [inst_4 : RCLike 𝕜'] [inst_5 : NormedSpace 𝕜' F] {g : E → ℝ},
Function.HasTemperateGrowth g →
∀ (f : SchwartzMap E F), (SchwartzMap.smulLeftCLM F fun x => ↑(g x)) f = (SchwartzMap.smulLeftCLM F g) f |
WittVector.inverseCoeff.match_1 | Mathlib.RingTheory.WittVector.DiscreteValuationRing | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
nhdsSet_interior | Mathlib.Topology.NhdsSet | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, nhdsSet (interior s) = Filter.principal (interior s) |
Std.TreeSet.Equiv.getLTD_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
t₁.Equiv t₂ → t₁.getLTD k fallback = t₂.getLTD k fallback |
HasCompactSupport.convolution_integrand_bound_right | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 F]
(L : E →L[𝕜] E' →L[𝕜] F) [inst_7 : AddGroup G] [inst_8 : TopologicalSpace G],
HasCompactSupport g →
Continuous g →
∀ {x t : G} {s : Set G},
x ∈ s → ‖(L (f t)) (g (x - t))‖ ≤ (-tsupport g + s).indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g i‖) t |
Lean.Elab.CompletionInfo.fieldId.injEq | Lean.Elab.InfoTree.Types | ∀ (stx : Lean.Syntax) (id : Option Lean.Name) (lctx : Lean.LocalContext) (structName : Lean.Name) (stx_1 : Lean.Syntax)
(id_1 : Option Lean.Name) (lctx_1 : Lean.LocalContext) (structName_1 : Lean.Name),
(Lean.Elab.CompletionInfo.fieldId stx id lctx structName =
Lean.Elab.CompletionInfo.fieldId stx_1 id_1 lctx_1 structName_1) =
(stx = stx_1 ∧ id = id_1 ∧ lctx = lctx_1 ∧ structName = structName_1) |
Lean.PrettyPrinter.Delaborator.OmissionReason.string.sizeOf_spec | Lean.PrettyPrinter.Delaborator.Basic | ∀ (s : String), sizeOf (Lean.PrettyPrinter.Delaborator.OmissionReason.string s) = 1 + sizeOf s |
_private.Mathlib.RingTheory.Ideal.Maximal.0.Ideal.exists_le_prime_disjoint.match_1_1 | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u_1} [inst : CommSemiring α] (I : Ideal α) (S : Submonoid α)
(motive : (∃ m, I ≤ m ∧ Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) m) → Prop)
(x : ∃ m, I ≤ m ∧ Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) m),
(∀ (p : Ideal α) (hIp : I ≤ p) (hp : Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) p), motive ⋯) → motive x |
MeasureTheory.ae_eq_trim_iff_of_aestronglyMeasurable | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] [TopologicalSpace.MetrizableSpace β]
{m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → β} (hm : m ≤ m0)
(hfm : MeasureTheory.AEStronglyMeasurable f μ) (hgm : MeasureTheory.AEStronglyMeasurable g μ),
MeasureTheory.AEStronglyMeasurable.mk f hfm =ᵐ[μ.trim hm] MeasureTheory.AEStronglyMeasurable.mk g hgm ↔ f =ᵐ[μ] g |
Lean.Meta.mkHEq | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr |
String.Pos.instTransLe | Init.Data.String.OrderInstances | {s : String} → Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 |
Submodule.mulRightMap | Mathlib.LinearAlgebra.Finsupp.LSum | {R : Type u_1} →
[inst : Semiring R] →
{S : Type u_4} →
[inst_1 : Semiring S] →
[inst_2 : Module R S] →
[SMulCommClass R R S] →
[IsScalarTower R S S] →
(M : Submodule R S) → {N : Submodule R S} → {ι : Type u_5} → (ι → ↥N) → (ι →₀ ↥M) →ₗ[R] S |
CategoryTheory.LiftRightAdjoint.constructRightAdjoint | Mathlib.CategoryTheory.Adjunction.Lifting.Right | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{U : CategoryTheory.Functor A B} →
{F : CategoryTheory.Functor B A} →
(L : CategoryTheory.Functor C B) →
(U' : CategoryTheory.Functor A C) →
(adj₁ : F ⊣ U) →
(L.comp F ⊣ U') →
[CategoryTheory.Limits.HasCoreflexiveEqualizers C] →
((X : B) → CategoryTheory.RegularMono (adj₁.unit.app X)) → CategoryTheory.Functor B C |
Bimod.AssociatorBimod.hom_inv_id | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
[inst_4 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorRight X)]
{R S T U : CategoryTheory.Mon C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U),
CategoryTheory.CategoryStruct.comp (Bimod.AssociatorBimod.hom P Q L) (Bimod.AssociatorBimod.inv P Q L) =
CategoryTheory.CategoryStruct.id ((P.tensorBimod Q).tensorBimod L).X |
Batteries.RBNode.Path.Balanced.ins | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} {c₀ : Batteries.RBColor} {n₀ : ℕ} {c : Batteries.RBColor} {n : ℕ} {t : Batteries.RBNode α}
{path : Batteries.RBNode.Path α},
Batteries.RBNode.Path.Balanced c₀ n₀ path c n →
Batteries.RBNode.RedRed (c = Batteries.RBColor.red) t n → ∃ n, (path.ins t).Balanced Batteries.RBColor.black n |
Ideal.snd_comp_quotientInfEquivQuotientProd | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_2} [inst : CommRing R] (I J : Ideal R) (coprime : IsCoprime I J),
(RingHom.snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientInfEquivQuotientProd J coprime) = Ideal.Quotient.factor ⋯ |
Subsemiring.mem_centralizer_iff | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] {s : Set R} {z : R}, z ∈ Subsemiring.centralizer s ↔ ∀ g ∈ s, g * z = z * g |
BitVec.extractLsb'_append_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {w len : ℕ} {x : BitVec (w + len)}, BitVec.extractLsb' len w x ++ BitVec.extractLsb' 0 len x = x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.