name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL!.match_1.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (size : ℕ) (lk : α) (lv : β lk)
(size_1 : ℕ) (lrk : α) (lrv : β lrk) (l r : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
... | null | true |
IsTopologicalGroup.toHSpace._proof_1 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : MulOneClass M] [inst_1 : TopologicalSpace M] [inst_2 : ContinuousMul M],
{ toFun := Function.uncurry Mul.mul, continuous_toFun := ⋯ }.comp
((ContinuousMap.const M 1).prodMk (ContinuousMap.id M)) =
ContinuousMap.id M | null | false |
instCommMonoidPNat._proof_7 | Mathlib.Data.PNat.Basic | autoParam (∀ (n : ℕ) (x : ℕ+), instCommMonoidPNat._aux_4 (n + 1) x = instCommMonoidPNat._aux_4 n x * x)
Monoid.npow_succ._autoParam | null | false |
Std.DHashMap.Internal.Raw₀.toListModel_unionₘ | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β},
Std.DHashMap.Internal.Raw.WFImp ↑m₁ →
Std.DHashMap.Internal.Raw.WFImp ↑m₂ →
(Std.DHashMap.Internal.toListModel (↑(m₁.unionₘ m₂)).buckets).Perm
(Std.Interna... | null | true |
Units.coe_star_inv | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (u : Rˣ), ↑(star u)⁻¹ = star ↑u⁻¹ | null | true |
Order.IsSuccLimit.bot_lt | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : OrderBot α], Order.IsSuccLimit a → ⊥ < a | null | true |
Min.mk._flat_ctor | Init.Prelude | {α : Type u} → (α → α → α) → Min α | null | false |
Std.Net.IPv6Addr.toString | Std.Net.Addr | Std.Net.IPv6Addr → String | Turn `addr` into a `String` in the IPv6 format described in
[RFC 2373](https://datatracker.ietf.org/doc/html/rfc2373).
| true |
AlgebraicGeometry.mono_pushoutSection_of_iSup_eq | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : U... | null | true |
_private.Init.Data.Nat.Fold.0.Nat.foldTR.loop | Init.Data.Nat.Fold | {α : Type u} → (n : ℕ) → ((i : ℕ) → i < n → α → α) → (j : ℕ) → j ≤ n → α → α | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.two_mul_toInt_lt._simp_1_4 | Init.Data.BitVec.Lemmas | ∀ (n : ℕ), (0 < n.succ) = True | null | false |
addConj_eq_zero_iff | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a + b + -a = 0 ↔ b = 0 | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Pred.0.String.revAll_prop_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.BackwardPattern pat] {s : String},
s.revAll pat = s.toSlice.revAll pat | null | false |
Lean.Elab.InlayHintKind | Lean.Elab.InfoTree.InlayHints | Type | null | true |
CategoryTheory.forget_obj | Mathlib.CategoryTheory.ConcreteCategory.Forget | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {FC : outParam (C → C → Type u_2)}
{CC : outParam (C → Type w)} [inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))]
[inst_2 : CategoryTheory.ConcreteCategory C FC] (X : C), (CategoryTheory.forget C).obj X = CategoryTheory.ToType X | null | true |
SimpleGraph.natCast_card_dart_eq_dotProduct | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} (G : SimpleGraph V) [inst : DecidableRel G.Adj] [inst_1 : Fintype V]
[inst_2 : NonAssocSemiring α], ↑(Fintype.card G.Dart) = (SimpleGraph.adjMatrix α G).mulVec 1 ⬝ᵥ 1 | The number of all darts in a simple finite graph is equal to the dot product of
`G.adjMatrix α *ᵥ 1` and `1`. | true |
instIsScalarTowerUniformFun | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} {N : Type u_6} [inst : SMul M N] [inst_1 : SMul M β] [inst_2 : SMul N β]
[IsScalarTower M N β], IsScalarTower M N (UniformFun α β) | null | true |
WittVector.teichmuller_mul_pow_coeff_of_ne | Mathlib.RingTheory.WittVector.TeichmullerSeries | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {R : Type u_1} [inst : CommRing R] [CharP R p] (x : R) {m n : ℕ},
m ≠ n → ((WittVector.teichmuller p) x * ↑p ^ n).coeff m = 0 | null | true |
FreeAbelianGroup.liftMonoid._proof_8 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} {R : Type u_2} [inst : Monoid α] [inst_1 : Ring R] (f : α →* R),
(↑{ toFun := ⇑(FreeAbelianGroup.lift ⇑f), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).comp
FreeAbelianGroup.ofMulHom =
f | null | false |
RingHom.id_apply | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {x : NonAssocSemiring α} (x_1 : α), (RingHom.id α) x_1 = x_1 | null | true |
Nat.cast_pow._simp_1 | Mathlib.Data.Nat.Cast.Basic | ∀ {α : Type u_1} [inst : Semiring α] (m n : ℕ), ↑m ^ n = ↑(m ^ n) | null | false |
SymbolicDynamics.FullShift.Subshift.ofForbidden | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
[inst : TopologicalSpace A] →
[inst_1 : Inhabited A] →
{G : Type u_2} →
[inst_2 : AddMonoid G] →
[IsLeftCancelAdd G] →
[DiscreteTopology A] →
Set (SymbolicDynamics.FullShift.Pattern A G) → SymbolicDynamics.FullShift.Subshift A G | The subshift defined by a family of forbidden patterns `F`.
This is a standard way to construct subshifts:
`Subshift.ofForbidden F` consists of all configurations `x : G → A` in which no pattern
`p ∈ F` occurs at any position.
Formally:
* the carrier is `forbidden F` (configurations avoiding `F`),
* it is closed beca... | true |
Qq.synthInstanceQ? | Qq.MetaM | {u : Lean.Level} → (α : Q(Sort u)) → Lean.MetaM (Option Q(«$α»)) | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rio.pairwise_toList_upwardEnumerableLt._simp_1_5 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α] {a b : α},
(a < b) = Std.PRange.UpwardEnumerable.LT a b | null | false |
IsPGroup.card_orbit | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G],
IsPGroup p G →
∀ [hp : Fact (Nat.Prime p)] {α : Type u_2} [inst_1 : MulAction G α] (a : α) [Finite ↑(MulAction.orbit G a)],
∃ n, Nat.card ↑(MulAction.orbit G a) = p ^ n | null | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Zipper.size_prependMap | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} (t : Std.DTreeMap.Internal.Impl α β) (it : Std.DTreeMap.Internal.Zipper α β),
Std.DTreeMap.Internal.Zipper.size✝ (Std.DTreeMap.Internal.Zipper.prependMap t it) =
t.treeSize + Std.DTreeMap.Internal.Zipper.size✝ it | null | true |
UpperHalfPlane.instContinuousGLSMul | Mathlib.Analysis.Complex.UpperHalfPlane.Topology | ContinuousConstSMul (GL (Fin 2) ℝ) UpperHalfPlane | Each element of `GL(2, ℝ)` defines a continuous map `ℍ → ℍ`. | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPoly.match_4.eq_6 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a b : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_3 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (L... | null | true |
_private.Mathlib.Algebra.Homology.ModelCategory.Injective.0.CochainComplex.Plus.modelCategoryQuillen.instHasFactorizationTrivialCofibrationsFibrations.match_3 | Mathlib.Algebra.Homology.ModelCategory.Injective | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(K : CochainComplex C ℤ) (n : ℤ) (hn : K.IsStrictlyGE n) (L : CochainComplex C ℤ) (m : ℤ) (hm : L.IsStrictlyGE m)
(motive : ({ obj := K, property := ⋯ } ⟶ { obj := L, property := ⋯ }) → Prop)
(h : { obj := K, proper... | null | false |
List.Cursor.casesOn | Std.Do.Triple.SpecLemmas | {α : Type u} →
{l : List α} →
{motive : l.Cursor → Sort u_1} →
(t : l.Cursor) →
((«prefix» suffix : List α) →
(property : «prefix» ++ suffix = l) →
motive { «prefix» := «prefix», suffix := suffix, property := property }) →
motive t | null | false |
Std.ExtDTreeMap.instBEqOfLawfulEqCmpOfTransCmp | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.LawfulEqCmp cmp] → [Std.TransCmp cmp] → [(k : α) → BEq (β k)] → BEq (Std.ExtDTreeMap α β cmp) | null | true |
Prefunctor.symmetrify_mapReverse | Mathlib.Combinatorics.Quiver.Symmetric | ∀ {U : Type u_1} {V : Type u_2} [inst : Quiver U] [inst_1 : Quiver V] (φ : U ⥤q V), φ.symmetrify.MapReverse | null | true |
WithIdealFilter.instTopologicalSpace._proof_2 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] {F : IdealFilter A} (s t : Set (WithIdealFilter F)),
(∀ a ∈ s, s ∈ F.addGroupFilterBasis.N a) →
(∀ a ∈ t, t ∈ F.addGroupFilterBasis.N a) → ∀ a ∈ s ∩ t, s ∩ t ∈ F.addGroupFilterBasis.N a | null | false |
Lean.IR.IRType.isDefiniteRef | Lean.Compiler.IR.Basic | Lean.IR.IRType → Bool | null | true |
VectorFourier.fourierSMulRight._proof_5 | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E], ContinuousConstSMul ℂ E | null | false |
Algebra.Etale.instProd_2 | Mathlib.RingTheory.Etale.Basic | ∀ {R : Type u} [inst : CommRing R] (S : Type u_2) [inst_1 : CommRing S], Algebra.Etale (R × S) S | null | true |
_private.Init.Data.Sum.Lemmas.0.Sum.exists.match_1_3 | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {p : α ⊕ β → Prop} (motive : ((∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)) → Prop)
(x : (∃ a, p (Sum.inl a)) ∨ ∃ b, p (Sum.inr b)),
(∀ (a : α) (h : p (Sum.inl a)), motive ⋯) → (∀ (b : β) (h : p (Sum.inr b)), motive ⋯) → motive x | null | false |
Nat.exists_strictMono | Mathlib.Order.Monotone.Basic | ∀ (α : Type u) [inst : Preorder α] [Nonempty α] [NoMaxOrder α], ∃ f, StrictMono f | If `α` is a nonempty preorder with no maximal elements, then there exists a strictly monotone
function `ℕ → α`. | true |
Lean.Grind.instCommRingBitVec._proof_2 | Init.GrindInstances.Ring.BitVec | ∀ {w : ℕ} (n : ℕ) (a : BitVec w), n • a = ↑n * a | null | false |
Metric.infDist_le_dist_of_mem | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α} {x y : α}, y ∈ s → Metric.infDist x s ≤ dist x y | The minimal distance to a set is bounded by the distance to any point in this set. | true |
ContinuousLinearMap.piEquivL._proof_9 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ (𝕜 : Type u_1) [inst : NormedField 𝕜] (E : Type u_2) {ι : Type u_4} (F : ι → Type u_3) [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : (i : ι) → AddCommGroup (F i)]
[inst_5 : (i : ι) → Module 𝕜 (F i)] [inst_6 : (i : ι) → TopologicalSpace (F i)]
[inst_7 : ∀ (i : ι), Is... | null | false |
CategoryTheory.Limits.pushoutPushoutRightIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ X₃ Z₁ Z₂ : C} →
(g₁ : Z₁ ⟶ X₁) →
(g₂ : Z₁ ⟶ X₂) →
(g₃ : Z₂ ⟶ X₂) →
(g₄ : Z₂ ⟶ X₃) →
[inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂] →
[inst_2 : CategoryTheory.Limits.HasPushout g₃ ... | `X₁ ⨿[Z₁] (X₂ ⨿[Z₂] X₃)` is the pushout `(X₁ ⨿[Z₁] X₂) ×[X₂] (X₂ ⨿[Z₂] X₃)`. | true |
Affine.Simplex.exsphere_compl | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1))),
s.exsphere signsᶜ = s.exsphere signs | null | true |
Subspace.orderIsoFiniteCodimDim | Mathlib.LinearAlgebra.Dual.Lemmas | {K : Type u_4} →
{V : Type u_5} →
[inst : Field K] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module K V] → { W // FiniteDimensional K (V ⧸ W) } ≃o { W // FiniteDimensional K ↥W }ᵒᵈ | For any vector space, `dualAnnihilator` and `dualCoannihilator` gives an antitone order
isomorphism between the finite-codimensional subspaces in the vector space and the
finite-dimensional subspaces in its dual. | true |
OrderIso.setCongr_symm_apply | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} [inst : Preorder α] (s t : Set α) (h : s = t) (b : { b // (fun x => x ∈ t) b }),
(RelIso.symm (OrderIso.setCongr s t h)) b = ⟨↑b, ⋯⟩ | null | true |
Lean.LevelMVarId.casesOn | Lean.Level | {motive : Lean.LevelMVarId → Sort u} →
(t : Lean.LevelMVarId) → ((name : Lean.Name) → motive { name := name }) → motive t | null | false |
Module.AEval.mapSubmodule._proof_3 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ (R : Type u_2) {A : Type u_3} (M : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M], AddMonoidHomClass (M ≃ₗ[R] Module.AEval R M a) M (Module.AEval R M a) | null | false |
MeasureTheory.Measure.ae_le_pi | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] {β : ι → Type u_4}
[inst_3 : (i : ι) → Preorder (β i)] {f f' : (i : ι) → α i → β i},
(∀ (i : ι), f i ≤ᵐ[μ i] f' i) → (fun x i =... | null | true |
PosNum.succ | Mathlib.Data.Num.Basic | PosNum → PosNum | The successor of a `PosNum`. | true |
Aesop.ForwardRulePriority.normSafe.sizeOf_spec | Aesop.Rule.Forward | ∀ (n : ℤ), sizeOf (Aesop.ForwardRulePriority.normSafe n) = 1 + sizeOf n | null | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorInl | Mathlib.AlgebraicGeometry.PullbackCarrier | {X Y S : AlgebraicGeometry.Scheme} →
{f : X ⟶ S} → {g : Y ⟶ S} → (T : AlgebraicGeometry.Scheme.Pullback.Triplet f g) → X.residueField T.x ⟶ T.tensor | Given `x : X` and `y : Y` such that `f x = s = g y`, this is the
canonical map `κ(x) ⟶ κ(x) ⊗[κ(s)] κ(y)`. | true |
String.Pos.mk.inj | Init.Data.String.Defs | ∀ {s : String} {offset : String.Pos.Raw} {isValid : String.Pos.Raw.IsValid s offset} {offset_1 : String.Pos.Raw}
{isValid_1 : String.Pos.Raw.IsValid s offset_1},
{ offset := offset, isValid := isValid } = { offset := offset_1, isValid := isValid_1 } → offset = offset_1 | null | true |
LinearMap.kerComplementEquivRange._proof_1 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} [inst : Ring R], RingHomSurjective (RingHom.id R) | null | false |
Lean.Expr.letE.sizeOf_spec | Lean.Expr | ∀ (declName : Lean.Name) (type value body : Lean.Expr) (nondep : Bool),
sizeOf (Lean.Expr.letE declName type value body nondep) =
1 + sizeOf declName + sizeOf type + sizeOf value + sizeOf body + sizeOf nondep | null | true |
CategoryTheory.CommaMorphism.ctorIdx | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} A} →
{B : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} B} →
{T : Type u₃} →
{inst_2 : CategoryTheory.Category.{v₃, u₃} T} →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B T} → {X Y... | null | false |
Function.Bijective.existsUnique_iff | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → ∀ {p : β → Prop}, (∃! y, p y) ↔ ∃! x, p (f x) | null | true |
CategoryTheory.Limits.isColimitAux._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} (t : CategoryTheory.Limits.CokernelCofork f)
(desc : (s : CategoryTheory.Limits.CokernelCofork f) → t.pt ⟶ s.pt),
(∀ (s : CategoryTheory.Limits.CokernelCofork f) (m : t.pt ⟶ s.p... | null | false |
BitVec.msb_neg_of_ne_intMin_of_ne_zero | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x ≠ BitVec.intMin w → x ≠ 0#w → (-x).msb = !x.msb | null | true |
_private.Mathlib.Order.Lattice.Nat.0.Nat.sSup_mem.match_1_1 | Mathlib.Order.Lattice.Nat | ∀ {s : Set ℕ} (motive : BddAbove s → Prop) (h₂ : BddAbove s), (∀ (k : ℕ) (hk : k ∈ upperBounds s), motive ⋯) → motive h₂ | null | false |
AbsolutelyContinuousOnInterval.fun_smul | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {F : Type u_2} [inst : SeminormedAddCommGroup F] {a b : ℝ} {M : Type u_3} [inst_1 : SeminormedRing M]
[inst_2 : Module M F] [NormSMulClass M F] {f : ℝ → M} {g : ℝ → F},
AbsolutelyContinuousOnInterval f a b →
AbsolutelyContinuousOnInterval g a b → AbsolutelyContinuousOnInterval (fun i => f i • g i) a b | Eta-expanded form of `AbsolutelyContinuousOnInterval.smul`
---
If `f` and `g` are absolutely continuous on `uIcc a b`, then `f • g` is absolutely continuous
on `uIcc a b`. | true |
SubMulAction.rec | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} →
{M : Type v} →
[inst : SMul R M] →
{motive : SubMulAction R M → Sort u_1} →
((carrier : Set M) →
(smul_mem' : ∀ (c : R) {x : M}, x ∈ carrier → c • x ∈ carrier) →
motive { carrier := carrier, smul_mem' := smul_mem' }) →
(t : SubMulAction R M) → motiv... | null | false |
_private.Mathlib.Geometry.Manifold.IsManifold.Basic.0.IsManifold.instLEInftyOfNatWithTopENat_1._proof_1 | Mathlib.Geometry.Manifold.IsManifold.Basic | ENat.LEInfty 1 | null | false |
Std.ExtDHashMap.getKey?_inter_of_not_mem_right | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, k ∉ m₂ → (m₁ ∩ m₂).getKey? k = none | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.card_nonuniformWitness_sdiff_biUnion_star._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
CharTwo.natCast_cases | Mathlib.Algebra.CharP.Two | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] [CharP R 2] (n : ℕ), ↑n = 0 ∨ ↑n = 1 | null | true |
Std.Internal.List.getValue?_filter_not_contains_map_fst_of_contains_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getValue? k (List.filter (fun p => !(List.map Sigma.fst l₂).contains p.fst) l₁) = none | null | true |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.Valuation.apply_posSubmonoid_ne_zero._simp_1_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : ValuativeRel R] (x : ↥(ValuativeRel.posSubmonoid R)),
((ValuativeRel.valuation R) ↑x = 0) = False | null | false |
Lean.Server.ServerTask.waitAny | Lean.Server.ServerTask | {α : Type} →
(tasks : List (Lean.Server.ServerTask α)) →
autoParam (tasks.length > 0) Lean.Server.ServerTask.waitAny._auto_1 → BaseIO α | null | true |
Std.TreeSet.get?_congr | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k k' : α},
cmp k k' = Ordering.eq → t.get? k = t.get? k' | null | true |
Cardinal.add_nat_le_add_nat_iff._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}} (n : ℕ), (α + ↑n ≤ β + ↑n) = (α ≤ β) | null | false |
Bundle.Pretrivialization.continuousAlternatingMap | Mathlib.Topology.VectorBundle.ContinuousAlternatingMap | (𝕜 : Type u_1) →
(ι : Type u_2) →
[inst : NontriviallyNormedField 𝕜] →
{B : Type u_3} →
[inst_1 : TopologicalSpace B] →
{F₁ : Type u_4} →
[inst_2 : NormedAddCommGroup F₁] →
[inst_3 : NormedSpace 𝕜 F₁] →
{E₁ : B → Type u_5} →
[i... | Given trivializations `e₁`, `e₂` for vector bundles `E₁`, `E₂` over a base `B`,
`Pretrivialization.continuousAlternatingMap 𝕜 ι e₁ e₂` is the induced pretrivialization for the
continuous `σ`-semilinear maps from `E₁` to `E₂`. That is, the map which will later become a
trivialization, after the bundle of continuous sem... | true |
Int.log_zpow | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : FloorSemiring R]
{b : ℕ}, 1 < b → ∀ (z : ℤ), Int.log b (↑b ^ z) = z | null | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.Filter.EventuallyEq.mlieBracketWithin_vectorField_eq._aux_1_1 | Mathlib.Geometry.Manifold.VectorField.LieBracket | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_4} →
[inst_1 : TopologicalSpace H] →
{E : Type u_1} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{M : Type u_3} →
... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_39 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'},
¬p₁.Nil →
∀ (k : ℕ),
(∀ (i : ℕ) (h : i < p₁.darts.length), p₂.darts[i + k]? = some p₁.darts[i]) →
∀ (i : ℕ), i = p₁.length → k < p₂.support.tail.length | null | false |
ProbabilityTheory.condExpKernel_ae_eq_condExp | Mathlib.Probability.Kernel.Condexp | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ],
m ≤ mΩ →
∀ {s : Set Ω},
MeasurableSet s → (fun ω => ((ProbabilityTheory.condExpKernel μ m) ω).real s) =ᵐ[μ] μ[s.indicator fun ω => 1 | m... | null | true |
Subfield.mk.injEq | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u} [inst : DivisionRing K] (toSubring : Subring K)
(inv_mem' : ∀ x ∈ toSubring.carrier, x⁻¹ ∈ toSubring.carrier) (toSubring_1 : Subring K)
(inv_mem'_1 : ∀ x ∈ toSubring_1.carrier, x⁻¹ ∈ toSubring_1.carrier),
({ toSubring := toSubring, inv_mem' := inv_mem' } = { toSubring := toSubring_1, inv_mem' := in... | null | true |
_private.Mathlib.Algebra.Notation.Indicator.0.Set.mulIndicator_eq_self._simp_1_1 | Mathlib.Algebra.Notation.Indicator | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
RCLike.realRingEquiv._proof_1 | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.I = 0 → ∀ (x : K), ↑(RCLike.re x) = x | null | false |
_private.Batteries.Tactic.Lint.Simp.0.Batteries.Tactic.Lint.simpNF.match_3 | Batteries.Tactic.Lint.Simp | (motive : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats → Sort u_1) →
(__discr : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats) →
((hType' : Lean.Expr) →
(proof? : Option Lean.Expr) →
(cache : Bool) →
(stats : Lean.Meta.Simp.Stats) → motive ({ expr := hType', proof? := proof?, cache :=... | null | false |
CategoryTheory.Triangulated.Octahedron'.triangle_mor₁ | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | null | true |
Relation.transGen_eq_self | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} [IsTrans α r], Relation.TransGen r = r | null | true |
CategoryTheory.SimplicialObject.augmentOfIsTerminal._proof_2 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : CategoryTheory.SimplicialObject C) {T : C}
(hT : CategoryTheory.Limits.IsTerminal T) ⦃X_1 Y : SimplexCategoryᵒᵖ⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.id (CategoryTheory.SimplicialObject C)).obj X).map f)
... | null | false |
_private.Init.Data.List.Sublist.0.List.cons_subset_cons._simp_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | null | false |
FirstOrder.Language.DefinableSet.coe_compl | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {A : Set M} {α : Type u₁} (s : L.DefinableSet A α),
↑sᶜ = (↑s)ᶜ | null | true |
_private.Mathlib.RingTheory.MvPolynomial.EulerIdentity.0.MvPolynomial.IsWeightedHomogeneous.sum_weight_X_mul_pderiv._simp_1_3 | Mathlib.RingTheory.MvPolynomial.EulerIdentity | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : ℕ) (a : α), ↑n * a = n • a | null | false |
FirstOrder.Language.Substructure.gciMapComap | Mathlib.ModelTheory.Substructures | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type u_1} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{f : L.Hom M N} →
Function.Injective ⇑f →
GaloisCoinsertion (FirstOrder.Language.Substructure.map f) (FirstOrder.Language.Substructure.comap f) | `map f` and `comap f` form a `GaloisCoinsertion` when `f` is injective. | true |
Std.Time.Month.instTransOrdOffset | Std.Time.Date.Unit.Month | Std.TransOrd Std.Time.Month.Offset | null | true |
ContinuousMonoidHom.instContinuousEval | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ (A : Type u_2) (B : Type u_3) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] [LocallyCompactPair A B], ContinuousEval (A →ₜ* B) A B | null | true |
Polynomial.Splits.neg | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Ring R] {f : Polynomial R}, f.Splits → (-f).Splits | null | true |
ContinuousMap.liftCover_coe' | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {A : Set (Set α)}
{F : (s : Set α) → s ∈ A → C(↑s, β)}
{hF :
∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
(F s hs) ⟨x, hxi⟩ = (F t ht) ⟨x, hxj⟩}
{hA : ∀ (x : α), ∃ i ∈ A,... | null | true |
Std.Time.Day.instLEOffset._aux_1 | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Day.Offset → Prop | null | false |
AffineSubspace.instCompleteLattice._proof_13 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_3} {V : Type u_2} {P : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (x : k) (x_1 x_2 x_3 : P), False → x_2 ∈ ∅ → x_3 ∈ ∅ → x • (x_1 -ᵥ x_2) +ᵥ x_3 ∈ ∅ | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt8.reduceOfNatLT._regBuiltin.UInt8.reduceOfNatLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.322 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
not_isLeftRegular_zero | Mathlib.Algebra.GroupWithZero.Regular | ∀ {R : Type u_1} [inst : MulZeroClass R] [nR : Nontrivial R], ¬IsLeftRegular 0 | In a non-trivial ring, the element `0` is not left-regular -- with typeclasses. | true |
CategoryTheory.Sieve._sizeOf_1 | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} → {inst : CategoryTheory.Category.{v₁, u₁} C} → {X : C} → [SizeOf C] → CategoryTheory.Sieve X → ℕ | null | false |
Ideal.minimalPrimes.equivIrreducibleComponents._proof_4 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} [inst : CommSemiring R] (I : Ideal R) (x : ↑{p | p.IsPrime ∧ I ≤ p}),
(↑⟨{ asIdeal := ↑x, isPrime := ⋯ }, ⋯⟩).asIdeal.IsPrime ∧ I ≤ (↑⟨{ asIdeal := ↑x, isPrime := ⋯ }, ⋯⟩).asIdeal | null | false |
MeasureTheory.VectorMeasure.«_aux_Mathlib_MeasureTheory_VectorMeasure_Integral___delab_app_MeasureTheory_VectorMeasure_term∫ᵛ_,_∂[_;_]_1» | Mathlib.MeasureTheory.VectorMeasure.Integral | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
FreeAlgebra.cardinalMk_le_max_lift | Mathlib.Algebra.FreeAlgebra.Cardinality | ∀ (R : Type u) [inst : CommSemiring R] (X : Type v),
Cardinal.mk (FreeAlgebra R X) ≤
max (max (Cardinal.lift.{v, u} (Cardinal.mk R)) (Cardinal.lift.{u, v} (Cardinal.mk X))) Cardinal.aleph0 | null | true |
CommMonoid.mul_comm | Mathlib.Algebra.Group.Defs | ∀ {M : Type u} [self : CommMonoid M] (a b : M), a * b = b * a | Multiplication is commutative in a commutative multiplicative magma. | true |
Lean.SubExpr.Pos.typeCoord | Lean.SubExpr | ℕ | The coordinate `3 = maxChildren - 1` is
reserved to denote the type of the expression. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.