name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Flow.mk | Mathlib.Dynamics.Flow | {τ : Type u_1} →
[inst : TopologicalSpace τ] →
[inst_1 : AddMonoid τ] →
[inst_2 : ContinuousAdd τ] →
{α : Type u_2} →
[inst_3 : TopologicalSpace α] →
(toFun : τ → α → α) →
Continuous (Function.uncurry toFun) →
(∀ (t₁ t₂ : τ) (x : α), toFun (t₁ + t₂... | null | true |
BitVec.getMsbD_or | Init.Data.BitVec.Lemmas | ∀ {w i : ℕ} {x y : BitVec w}, (x ||| y).getMsbD i = (x.getMsbD i || y.getMsbD i) | null | true |
CategoryTheory.Limits.colimit.isoColimitCocone.eq_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
(t : CategoryTheory.Limits.ColimitCocone F),
CategoryTheory.Limits.colimit.isoColimitCocone t =
(CategoryTheory.Li... | null | true |
Submodule.toLocalizedQuotient' | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_5} →
(S : Type u_6) →
{M : Type u_7} →
{N : Type u_8} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | The localization map of a quotient module. | true |
Finset.sum_sum_Ioi_add_eq_sum_sum_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : LinearOrder α] [inst_2 : Fintype α]
[inst_3 : LocallyFiniteOrderTop α] [LocallyFiniteOrderBot α] (f : α → α → M),
∑ i, ∑ j ∈ Finset.Ioi i, (f j i + f i j) = ∑ i, ∑ j ∈ {i}ᶜ, f j i | null | true |
Filter.Germ.liftPred_const_iff._simp_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [l.NeBot] {p : β → Prop} {x : β}, Filter.Germ.LiftPred p ↑x = p x | null | false |
Quantale.noConfusion | Mathlib.Algebra.Order.Quantale | {P : Sort u} →
{α : Type u_1} →
{inst : Semigroup α} →
{inst_1 : CompleteLattice α} →
{inst_2 : IsQuantale α} →
{t : Quantale α} →
{α' : Type u_1} →
{inst' : Semigroup α'} →
{inst'_1 : CompleteLattice α'} →
{inst'_2 : IsQuantale α... | null | false |
MoritaEquivalence.mk.inj | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} {inst : CommSemiring R} {A : Type u₁} {inst_1 : Ring A} {inst_2 : Algebra R A} {B : Type u₂}
{inst_3 : Ring B} {inst_4 : Algebra R B} {eqv : ModuleCat A ≌ ModuleCat B}
{linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) MoritaEquivalence.linear._autoParam}
{eqv_1 : ModuleCat A ≌ Modu... | null | true |
NNReal.natCast_iSup | Mathlib.Data.NNReal.Basic | ∀ {ι : Sort u_4} (f : ι → ℕ), ↑(⨆ i, f i) = ⨆ i, ↑(f i) | null | true |
Set.seq.eq_1 | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u} {β : Type v} (s : Set (α → β)) (t : Set α), s.seq t = Set.image2 (fun f => f) s t | null | true |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.instBEqKey.beq._sparseCasesOn_3 | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Key → Sort u} →
(t : Lean.Meta.LazyDiscrTree.Key) →
((a : Lean.Literal) → motive (Lean.Meta.LazyDiscrTree.Key.lit a)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
LieAlgebra.IsKilling.restr_invtSubmoduleToLieIdeal_eq_iSup | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] [inst_5 : LieAlgebra.IsKilling K L] {H : LieSubalgebra K L}
[inst_6 : H.IsCartanSubalgebra] [inst_7 : LieModule.IsTriangularizable K (↥H) L] (q : Submodule K (Module... | null | true |
Subgroup.mulSingle_mem_pi | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), Pi.mulSingle i x ∈ Subgroup.pi I H ↔ i ∈ I → x ∈ H i | null | true |
_private.Mathlib.CategoryTheory.EssentialImage.0.CategoryTheory.Functor.essImage_comp_apply_of_essSurj.match_1_3 | Mathlib.CategoryTheory.EssentialImage | ∀ {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (Y : D)
(motive : F.essImage Y → Prop) (x : F.essImage Y), (∀ (Z : C) (e' : F.obj Z ≅ Y), motive ⋯) → motive x | null | false |
List.transpose.go.match_1 | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : Id (Array (List α) × List α) → Sort u_2) →
(x : Id (Array (List α) × List α)) → ((acc : Array (List α)) → (l : List α) → motive (acc, l)) → motive x | null | false |
AddSubmonoid.multiples._proof_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_1} [inst : AddMonoid A] (x n : A) (i : ℕ), (fun i => i • x) i = n ↔ ((multiplesHom A) x) i = n | null | false |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_13 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] (I : Finset (Set α)),
↑I ⊆ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} →
∀ (u v : α),
v ∈ ⋃₀ ↑I →
∀ (u' : α),
v ∈ Set.Ioc u' v →
(Set.Ioc u' v ∪ ⋃₀ ↑(I.erase (Set.Ioc u' v))) \ Set.Ioc u' v = ⋃₀ ↑(I.erase (Set.Ioc u' v)) →
Set.Ioc ... | null | false |
MeasureTheory.aemeasurable_mlconvolution | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Group G] [MeasurableMul₂ G] [MeasurableInv G]
{μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant] [MeasureTheory.SFinite μ] {f g : G → ENNReal},
AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (MeasureTheory.mlconvolution f g μ) μ | The convolution of `AEMeasurable` functions is `AEMeasurable`. | true |
Lean.Meta.Instances._sizeOf_1 | Lean.Meta.Instances | Lean.Meta.Instances → ℕ | null | false |
Rep.FiniteCyclicGroup.chainComplexFunctor_map_f | Mathlib.RepresentationTheory.Homological.FiniteCyclic | ∀ (k : Type u) {G : Type u} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (g : G)
{X Y : Rep.{u_1, u, u} k G} (f : X ⟶ Y) (i : ℕ), ((Rep.FiniteCyclicGroup.chainComplexFunctor k g).map f).f i = f | null | true |
CategoryTheory.Monoidal.leftRigidFunctorCategory | Mathlib.CategoryTheory.Monoidal.Rigid.FunctorCategory | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Groupoid C] →
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[CategoryTheory.LeftRigidCategory D] → CategoryTheory.LeftRigidCategory (CategoryTheory.Functor C D) | null | true |
CategoryTheory.SmallObject.functor._proof_11 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {A B : I → C} (f : (i : I) → A i ⟶ B i)
[CategoryTheory.Limits.HasPushouts C]
[inst_2 :
∀ {X S : C} (πX : X ⟶ S),
CategoryTheory.Limits.HasColimitsOfShape
(CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIn... | null | false |
_private.Mathlib.Algebra.Category.ModuleCat.Ext.Basic.0.CategoryTheory.Abelian.Ext.postcomp_smul_id_mono_iff._simp_1_1 | Mathlib.Algebra.Category.ModuleCat.Ext.Basic | ∀ {A B : AddCommGrpCat} (f : A ⟶ B), CategoryTheory.Mono f = Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) | null | false |
LinearEquiv.multilinearMapCongrLeft._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_4} {ι : Type u_1} {M₁ : ι → Type u_5} {M₁' : ι → Type u_2} {M₂ : Type u_3} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → AddCommMonoid (M₁' i)] [inst_6 : (i : ι) → Module R (... | null | false |
CategoryTheory.Limits.CatCospanTransform.mkIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u_10} {B : Type u_6} {C : Type u_1} {A' : Type u_11} {B' : Type u_3} {C' : Type u_12}
[inst : CategoryTheory.Category.{u_7, u_10} A] [inst_1 : CategoryTheory.Category.{u_5, u_6} B]
[inst_2 : CategoryTheory.Category.{u_4, u_1} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3... | null | false |
_private.Mathlib.GroupTheory.ArchimedeanDensely.0.Subgroup.isLeast_of_closure_iff_eq_mabs._simp_1_3 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Lean.Elab.Structural.EqnInfo.fixedParamPerms | Lean.Elab.PreDefinition.Structural.Eqns | Lean.Elab.Structural.EqnInfo → Lean.Elab.FixedParamPerms | null | true |
List.Cursor.at._proof_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} (l : List α) (n : ℕ), List.take n l ++ List.drop n l = l | null | false |
CategoryTheory.Tor._proof_2 | Mathlib.CategoryTheory.Monoidal.Tor | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.HasProjectiveResolutions C] (n : ℕ) (X : C),
CategoryTheory.NatTrans.leftDerived
((Category... | null | false |
Nonneg.semiring._proof_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [AddLeftMono α] [inst_3 : PosMulMono α]
(a b c : { x // 0 ≤ x }), a * b * c = a * (b * c) | null | false |
Submodule.orthogonal_orthogonal | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [K.HasOrthogonalProjection], Kᗮᗮ = K | If `K` admits an orthogonal projection, then the orthogonal complement of its orthogonal
complement is itself. | true |
ODE.FunSpace.recOn | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} →
{t₀ : ↑(Set.Icc tmin tmax)} →
{x₀ : E} →
{r L : NNReal} →
{motive : ODE.FunSpace t₀ x₀ r L → Sort u} →
(t : ODE.FunSpace t₀ x₀ r L) →
((toFun : ↑(Set.Icc tmin tmax) → E) →
... | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.forallMetaTelescopeReducingAux.process._unsafe_rec | Lean.Meta.Basic | Bool →
Option ℕ →
Lean.MetavarKind →
Array Lean.Expr →
Array Lean.BinderInfo → ℕ → Lean.Expr → Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) | null | false |
instReprAtomBool | Init.Data.Repr | ReprAtom Bool | null | true |
AddMonoidAlgebra.exists_supDegree_mem_support | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : Semiring R] [inst_1 : LinearOrder B] [inst_2 : OrderBot B]
{p : AddMonoidAlgebra R A} (D : A → B), p ≠ 0 → ∃ a ∈ p.support, AddMonoidAlgebra.supDegree D p = D a | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_emod_unique'._simp_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (-a = -b) = (a = b) | null | false |
SubStarSemigroup.mk | Mathlib.Algebra.Star.NonUnitalSubsemiring | {M : Type v} →
[inst : Mul M] →
[inst_1 : Star M] →
(toSubsemigroup : Subsemigroup M) →
(∀ {a : M}, a ∈ toSubsemigroup.carrier → star a ∈ toSubsemigroup.carrier) → SubStarSemigroup M | null | true |
Lean.Meta.Grind.Arith.pickUnusedValue | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Meta.Grind.Goal → Std.HashMap Lean.Expr ℚ → Lean.Expr → ℤ → Std.HashSet ℤ → ℤ | Returns an integer value `i` for assigning to `e` s.t. adding `e := i` to `a` will not falsify any disequality
and `i` is not in `alreadyUsed`.
| true |
instIsSemitopologicalSemiringMulOpposite | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] [inst_1 : TopologicalSpace R] [IsSemitopologicalSemiring R],
IsSemitopologicalSemiring Rᵐᵒᵖ | null | true |
Ideal.quotEquivPowQuotPowSucc._proof_2 | Mathlib.RingTheory.Ideal.IsPrincipalPowQuotient | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | null | false |
smooth_functions_tower | Mathlib.Geometry.Manifold.DerivationBundle | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_4)
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M],
IsScalarTower 𝕜 (ContMDiffMap I (mo... | null | true |
CategoryTheory.Limits.CreatesFiniteProducts.creates._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | Lean.Syntax | null | false |
uniformContinuousOn_iff_restrict | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} {s : Set α},
UniformContinuousOn f s ↔ UniformContinuous (s.restrict f) | null | true |
Int.ediv_dvd_iff_dvd_mul._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, b ∣ a → b ≠ 0 → (a / b ∣ c) = (a ∣ b * c) | null | false |
Std.TreeMap.Raw.mem_of_mem_union_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∈ t₁ ∪ t₂ → k ∉ t₁ → k ∈ t₂ | null | true |
AlgebraicGeometry.Scheme.qcPrecoverage | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | CategoryTheory.Precoverage AlgebraicGeometry.Scheme | The quasi-compact precoverage on the category of schemes is the precoverage
given by quasi-compact covers. The intersection of this precoverage
with the precoverage defined by jointly surjective families of flat morphisms is
the fpqc-precoverage.
| true |
ContinuousMap.compStarAlgHom._proof_6 | Mathlib.Topology.ContinuousMap.Star | ∀ (X : Type u_1) {𝕜 : Type u_4} {A : Type u_2} {B : Type u_3} [inst : TopologicalSpace X] [inst_1 : CommSemiring 𝕜]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : Star A] [inst_5 : ContinuousStar A]
[inst_6 : Algebra 𝕜 A] [inst_7 : TopologicalSpace B] [inst_8 : Semiring B] [inst_9 : Star B]
[ins... | null | false |
Finsupp.degree_add | Mathlib.Data.Finsupp.Weight | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f (x + y) = f x + f y | **Alias** of `map_add`. | true |
Encodable.fintypeArrowOfEncodable | Mathlib.Logic.Encodable.Pi | {α : Type u_2} → {β : Type u_3} → [Encodable α] → [Fintype α] → [Encodable β] → Encodable (α → β) | If `α` and `β` are encodable and `α` is a fintype, then `α → β` is encodable as well. | true |
WellFounded.partialExtrinsicFix₂ | Init.WFExtrinsicFix | {α : Sort u_1} →
{β : α → Sort u_2} →
{C₂ : (a : α) → β a → Sort u_3} →
[∀ (a : α) (b : β a), Nonempty (C₂ a b)] →
(R : (a : α) ×' β a → (a : α) ×' β a → Prop) →
((a : α) → (b : β a) → ((a' : α) → (b' : β a') → R ⟨a', b'⟩ ⟨a, b⟩ → C₂ a' b') → C₂ a b) →
(a : α) → (b : β a) → C₂ ... | A 2-ary fixpoint combinator that can be used to construct recursive functions with an
**extrinsic, partial** proof of termination.
Given a relation `R` and a fixpoint functional `F` which must be decreasing with respect
to `R`, `partialExtrinsicFix₂ R F` is the recursive function obtained by having `F` call
itself rec... | true |
AugmentedSimplexCategory.inr_comp_associator_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (x y z : AugmentedSimplexCategory) {Z : AugmentedSimplexCategory}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj x (CategoryTheory.MonoidalCategoryStruct.tensorObj y z) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategoryStruct.tensorObj x y).inr z)
(CategoryTheory.CategoryStruct... | null | true |
continuousOn_tsum | Mathlib.Analysis.Normed.Group.FunctionSeries | ∀ {α : Type u_1} {β : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ}
[inst_2 : TopologicalSpace β] {f : α → β → F} {s : Set β},
(∀ (i : α), ContinuousOn (f i) s) →
Summable u → (∀ (n : α), ∀ x ∈ s, ‖f n x‖ ≤ u n) → ContinuousOn (fun x => ∑' (n : α), f n x) s | An infinite sum of functions with summable sup norm is continuous on a set if each individual
function is. | true |
Std.HashMap.Raw.Equiv.of_forall_contains_unit_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α] {m₁ m₂ : Std.HashMap.Raw α Unit},
m₁.WF → m₂.WF → (∀ (k : α), m₁.contains k = m₂.contains k) → m₁.Equiv m₂ | null | true |
HomotopicalAlgebra.CofibrantObject.instWeakEquivalenceHoCatAppιCompResolutionNatTrans | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(X : HomotopicalAlgebra.CofibrantObject C),
HomotopicalAlgebra.WeakEquivalence (HomotopicalAlgebra.CofibrantObject.HoCat.ιCompResolutionNatTrans.app X) | null | true |
Lean.IndirectModUse.recOn | Lean.ExtraModUses | {motive : Lean.IndirectModUse → Sort u} →
(t : Lean.IndirectModUse) →
((kind : String) → (declName : Lean.Name) → motive { kind := kind, declName := declName }) → motive t | null | false |
CategoryTheory.effectiveEpiFamilyStructOfIsColimit._proof_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {α : Type u_3} (X : α → C)
(π : (a : α) → X a ⟶ B) (obj : CategoryTheory.Over B) (hT : (CategoryTheory.Sieve.generateFamily X π).arrows obj.hom),
∃ g, CategoryTheory.CategoryStruct.comp g (π (Exists.choose hT)) = obj.hom | null | false |
VectorFourier.hasFDerivAt_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} [inst_6 : MeasurableSpace V] [BorelSpace V] [SecondCountab... | Main theorem of this section: if both `f` and `x ↦ ‖x‖ * ‖f x‖` are integrable, then the
Fourier transform of `f` has a Fréchet derivative (everywhere in its domain) and its derivative is
the Fourier transform of `smulRight L f`. | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.mem_nhdsLE_iff_exists_Ioc_subset.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} (motive : (∃ b, b < a) → Prop) (x : ∃ b, b < a),
(∀ (w : α) (hl' : w < a), motive ⋯) → motive x | null | false |
Bool.instDecidableLe | Init.Data.Bool | (x y : Bool) → Decidable (x ≤ y) | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache._sizeOf_1 | Std.Sat.AIG.CNF | {aig : Std.Sat.AIG ℕ} → {cnf : Std.Sat.CNF ℕ} → Std.Sat.AIG.toCNF.Cache✝ aig cnf → ℕ | null | false |
PredOrder.prelimitRecOn._proof_2 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] (a : α),
¬Order.IsPredPrelimit a → ∃ b, ¬IsMin b ∧ Order.pred b = a | null | false |
Lean.Doc.Syntax.footnote_ref | Lean.DocString.Syntax | Lean.ParserDescr | A footnote definition.
| true |
Ordinal.toZFSetIso_symm_apply | Mathlib.SetTheory.ZFC.Ordinal | ∀ (x : { x // x.IsOrdinal }), (RelIso.symm Ordinal.toZFSetIso) x = (↑x).rank | null | true |
CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_map_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (X : T × T)
{X_1 Y : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2} (g : X_1 ⟶ Y),
((CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse X).map g).left = CategoryTheory.Over.Hom.left g.left | null | true |
Batteries.Tactic.tacticSplit_ands | Batteries.Tactic.Init | Lean.ParserDescr | `split_ands` applies `And.intro` until it does not make progress. | true |
AnalyticAt.comp₂_analyticWithinAt | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : NormedAddCom... | `AnalyticAt.comp_analyticWithinAt` for functions on product spaces | true |
Batteries.Tactic.triv | Batteries.Tactic.Init | Lean.ParserDescr | Deprecated variant of `trivial`. | true |
_private.Batteries.Data.UnionFind.Lemmas.0.Batteries.UnionFind.equiv_union._simp_1_4 | Batteries.Data.UnionFind.Lemmas | ∀ {a b : ℕ} {self : Batteries.UnionFind} {x : Fin self.size}, (self.find x).fst.Equiv a b = self.Equiv a b | null | false |
Lean.Grind.Linarith.instReprPoly.repr._f | Init.Grind.Ordered.Linarith | (x : Lean.Grind.Linarith.Poly) → Lean.Grind.Linarith.Poly.below (motive := fun x => ℕ → Std.Format) x → ℕ → Std.Format | null | false |
Lean.Meta.Grind.Goal.ppENodeRef | Lean.Meta.Tactic.Grind.PP | Lean.Meta.Grind.Goal → Lean.Expr → Lean.MetaM Lean.MessageData | Helper function for pretty printing the state for debugging purposes. | true |
Append.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Append α} → {α' : Type u} → {t' : Append α'} → α = α' → t ≍ t' → Append.noConfusionType P t t' | null | false |
LightProfinite.Extend.cone._proof_2 | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (G : CategoryTheory.Functor LightProfinite C)
(S : LightProfinite) (x x_1 : CategoryTheory.StructuredArrow S FintypeCat.toLightProfinite) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const (CategoryTheory.StructuredA... | null | false |
TendstoUniformlyOn.add | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
{l : Filter ι} {f f' : ι → β → α} {g g' : β → α} {s : Set β},
TendstoUniformlyOn f g l s → TendstoUniformlyOn f' g' l s → TendstoUniformlyOn (f + f') (g + g') l s | null | true |
CategoryTheory.Abelian.SpectralObject.spectralSequenceHomologyData._auto_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | Lean.Syntax | null | false |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_13 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, p a ∧ q a ∧ a = a') = (p a' ∧ q a') | null | false |
_private.Mathlib.Util.PrintSorries.0.Mathlib.PrintSorries.collect._sparseCasesOn_1 | Mathlib.Util.PrintSorries | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_7 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {p : α → Prop} (head : α) (tail : List α), (∀ x ∈ head :: tail, p x) → tail = [] → ∀ x ∈ [], p x | null | false |
CategoryTheory.ComposableArrows.ext | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n}
(h : ∀ (i : Fin (n + 1)), F.obj i = G.obj i),
(∀ (i : ℕ) (hi : i < n),
F.map' i (i + 1) ⋯ hi =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.Cate... | null | true |
Subgroup.normalizer_eq_top | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [h : H.Normal], Subgroup.normalizer ↑H = ⊤ | null | true |
CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._proof_19 | Mathlib.CategoryTheory.Sites.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} A] [inst_2 : CategoryTheory.MonoidalCategory A]
[inst_3 : J.W.IsMonoidal] [inst_4 : CategoryTheory.HasWeakSheafify J A],
autoParam
(CategoryThe... | null | false |
circleMap_zero_zpow | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | ∀ (n : ℤ) (R θ : ℝ), circleMap 0 R θ ^ n = circleMap 0 (R ^ n) (↑n * θ) | null | true |
Lean.Grind.Linarith.Expr.intMul | Init.Grind.Ordered.Linarith | ℤ → Lean.Grind.Linarith.Expr → Lean.Grind.Linarith.Expr | null | true |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo.casesOn | Lean.Meta.Sym.Simp.Forall | {motive : Lean.Meta.Sym.Simp.ArrowInfo✝ → Sort u} →
(t : Lean.Meta.Sym.Simp.ArrowInfo✝) →
((binderName : Lean.Name) →
(binderInfo : Lean.BinderInfo) →
(u v : Lean.Level) → motive { binderName := binderName, binderInfo := binderInfo, u := u, v := v }) →
motive t | null | false |
CategoryTheory.Quotient.lift | Mathlib.CategoryTheory.Quotient | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(r : HomRel C) →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
(∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) →
CategoryTheory.Fu... | The induced functor on the quotient category. | true |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.Slice.startPos_eq_endPos_iff._simp_1_1 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
Equiv.piUnique | Mathlib.Logic.Equiv.Defs | {α : Sort u} → [inst : Unique α] → (β : α → Sort u_1) → ((i : α) → β i) ≃ β default | The equivalence `(∀ i, β i) ≃ β ⋆` when the domain of `β` only contains `⋆` | true |
PNat.modDivAux | Mathlib.Data.PNat.Defs | ℕ+ → ℕ → ℕ → ℕ+ × ℕ | We define `m % k` and `m / k` in the same way as for `ℕ`
except that when `m = n * k` we take `m % k = k` and
`m / k = n - 1`. This ensures that `m % k` is always positive
and `m = (m % k) + k * (m / k)` in all cases. Later we
define a function `div_exact` which gives the usual `m / k`
in the case where `k` divides `... | true |
SBtw.noConfusion | Mathlib.Order.Circular | {P : Sort u} →
{α : Type u_1} → {t : SBtw α} → {α' : Type u_1} → {t' : SBtw α'} → α = α' → t ≍ t' → SBtw.noConfusionType P t t' | null | false |
_private.Mathlib.CategoryTheory.Triangulated.Orthogonal.0.CategoryTheory.ObjectProperty.isLocal_trW.match_1_1 | Mathlib.CategoryTheory.Triangulated.Orthogonal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTh... | null | false |
SSet.Subcomplex.Pairing.I | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N | the set of type (I) simplices | true |
ENat.add_lt_add | Mathlib.Data.ENat.Basic | ∀ {a b c d : ℕ∞}, a < c → b < d → a + b < c + d | null | true |
EuclideanGeometry.Sphere._sizeOf_inst | Mathlib.Geometry.Euclidean.Sphere.Basic | (P : Type u_2) → {inst : MetricSpace P} → [SizeOf P] → SizeOf (EuclideanGeometry.Sphere P) | null | false |
ProbabilityTheory.Kernel.swapLeft_zero | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ}, ProbabilityTheory.Kernel.swapLeft 0 = 0 | null | true |
Mathlib.Meta.NormNum.deriveBool | Mathlib.Tactic.NormNum.Core | (p : Q(Prop)) → Lean.MetaM ((b : Bool) × Mathlib.Meta.NormNum.BoolResult p b) | Run each registered `norm_num` extension on a typed expression `p : Prop`,
and returning the truth or falsity of `p' : Prop` from an equivalence `p ↔ p'`. | true |
Filter.zeroAtFilterSubmodule | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | (𝕜 : Type u_1) →
{α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace β] →
[inst_1 : Semiring 𝕜] →
[inst_2 : AddCommMonoid β] →
[inst_3 : Module 𝕜 β] → [ContinuousAdd β] → [ContinuousConstSMul 𝕜 β] → Filter α → Submodule 𝕜 (α → β) | `zeroAtFilterSubmodule l` is the submodule of `f : α → β` which
tend to zero along `l`. | true |
AddSubsemigroup.le_op_iff | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] {S₁ : AddSubsemigroup Mᵃᵒᵖ} {S₂ : AddSubsemigroup M}, S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ | null | true |
Metric.mem_thickening_iff_exists_edist_lt | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} (E : Set α) (x : α),
x ∈ Metric.thickening δ E ↔ ∃ z ∈ E, edist x z < ENNReal.ofReal δ | null | true |
DomAddAct.instZeroOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [Zero Mᵃᵒᵖ] → Zero Mᵈᵃᵃ | null | true |
Std.DTreeMap.Const.ofList_eq_insertMany_empty | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {l : List (α × β)},
Std.DTreeMap.Const.ofList l cmp = Std.DTreeMap.Const.insertMany ∅ l | null | true |
Lean.LocalInstance.casesOn | Lean.MetavarContext | {motive : Lean.LocalInstance → Sort u} →
(t : Lean.LocalInstance) →
((className : Lean.Name) → (fvar : Lean.Expr) → motive { className := className, fvar := fvar }) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.