name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Ideal.Quotient.algebraMap_quotient_of_ramificationIdx_neZero | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R) (P : Ideal S)
[inst_3 : NeZero (p.ramificationIdx' P)] (x : R),
(algebraMap (R ⧸ p) (S ⧸ P)) ((Ideal.Quotient.mk p) x) = (Ideal.Quotient.mk P) ((algebraMap R S) x) | null | true |
QuotientAddGroup.equivIcoMod._proof_2 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a : α) (b : α ⧸ AddSubgroup.zmultiples p), ⋯.lift b ∈ Set.Ico a (a + p) | null | false |
Lean.Compiler.LCNF.Check.Pure.State._sizeOf_inst | Lean.Compiler.LCNF.Check | SizeOf Lean.Compiler.LCNF.Check.Pure.State | null | false |
_private.Mathlib.Topology.UniformSpace.Defs.0.isOpen_uniformity._simp_1_2 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} {x : α} {s : Set β} {F : Filter (α × β)},
(s ∈ Filter.comap (Prod.mk x) F) = ({p | p.1 = x → p.2 ∈ s} ∈ F) | null | false |
Std.Rcc.isSome_succMany?_of_lt_length_toList | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.Rxc.IsAlwaysFinite α] {i : ℕ}, i < r.toList.length → (Std.PRange.succMany? i r.lower).isSome = true | null | true |
Multiset.rel_zero_right._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {β : Type v} {r : α → β → Prop} {a : Multiset α}, Multiset.Rel r a 0 = (a = 0) | null | false |
_private.Batteries.Data.Array.Scan.0.Array.back?_scanr._simp_1_1 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} (xs : Array α), xs.back? = xs.toList.getLast? | null | false |
SimpleGraph.Subgraph.Preconnected.casesOn | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | {V : Type u} →
{G : SimpleGraph V} →
{H : G.Subgraph} →
{motive : H.Preconnected → Sort u_1} → (t : H.Preconnected) → ((coe : H.coe.Preconnected) → motive ⋯) → motive t | null | false |
ContinuousLinearMap.isBigOTVS_fun_comp | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} (g : E →L[𝕜] F),
(fun x => g ... | null | true |
Lean.Meta.DefaultInstanceEntry.rec | Lean.Meta.Instances | {motive : Lean.Meta.DefaultInstanceEntry → Sort u} →
((className instanceName : Lean.Name) →
(priority : ℕ) → motive { className := className, instanceName := instanceName, priority := priority }) →
(t : Lean.Meta.DefaultInstanceEntry) → motive t | null | false |
_private.Mathlib.Algebra.Polynomial.Inductions.0.Polynomial.natDegree_divX_eq_natDegree_tsub_one._simp_1_2 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.divX = 0) = (p = Polynomial.C (p.coeff 0)) | null | false |
Nat.Internal.SOM.Expr.num | Init.Data.Nat.Internal.SOM | ℕ → Nat.Internal.SOM.Expr | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_129 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
CategoryTheory.Bicategory.hom_inv_whiskerRight_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f g : a ⟶ b} (η : f ≅ g) (h : b ⟶ c) (k : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h) k ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.... | null | true |
lowerHemicontinuousWithinAt_singleton_iff._simp_1 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
{x : α}, LowerHemicontinuousWithinAt (fun x => {f x}) s x = ContinuousWithinAt f s x | null | false |
_private.Mathlib.Topology.InductiveDimension.Classes.0.exists_clopen_partition_of_clopen_cover._proof_1_12 | Mathlib.Topology.InductiveDimension.Classes | ∀ {X : Type u_1} {I : Type u_2} {D : Option I → Set X} (V : Set X) (C' : I → Set X),
(∀ (i : I), C' i ⊆ (fun i => D (some i) \ V) i) →
∀ (i : I), (fun i => Option.casesOn i (D none \ ⋃ i, C' i) C') (some i) ⊆ D (some i) | null | false |
Booleanisation.instBooleanAlgebra._proof_14 | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (x : Booleanisation α), ⊤ ≤ x ⊔ xᶜ | null | false |
Finset.convexHull_eq | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_1} {E : Type u_3} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
[inst_3 : LinearOrder R] [IsStrictOrderedRing R] (s : Finset E),
(convexHull R) ↑s = {x | ∃ w, (∀ y ∈ s, 0 ≤ w y) ∧ ∑ y ∈ s, w y = 1 ∧ s.centerMass w id = x} | null | true |
Submodule.prodEquivOfIsCompl_symm_apply_right | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] (p q : Submodule R E)
(h : IsCompl p q) (x : ↥q), (p.prodEquivOfIsCompl q h).symm ↑x = (0, x) | null | true |
Mathlib.Tactic.Push.Head.noConfusionType | Mathlib.Tactic.Push.Attr | Sort u → Mathlib.Tactic.Push.Head → Mathlib.Tactic.Push.Head → Sort u | null | false |
biInf_sigma | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_3} {β : Type u_4} [inst : CompleteLattice β] (s : Set ι) (t : (i : ι) → Set (α i))
(f : Sigma α → β), ⨅ ij ∈ s.sigma t, f ij = ⨅ i ∈ s, ⨅ j ∈ t i, f ⟨i, j⟩ | null | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_isBasis_iff._simp_1_2 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : NoZeroDivisors A] {s : Set A},
(AlgebraicIndependent.matroid R A).Indep s = AlgebraicIndepOn R id s | null | false |
ContinuousMap.mem_nhds_iff | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{s : Set C(X, Y)},
s ∈ nhds f ↔
∃ S,
S.Finite ∧
(∀ (K : Set X) (U : Set Y), (K, U) ∈ S → IsCompact K ∧ IsOpen U ∧ Set.MapsTo (⇑f) K U) ∧
{g | ∀ (K : Set X) (U : Set Y), (K, U) ∈ S → Se... | null | true |
IsMulCommutative.instNonAssocCommSemiring._proof_1 | Mathlib.Algebra.Ring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : IsMulCommutative R] (a b : R), a * b = b * a | null | false |
sub_one_div_inv_le_two | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a : α},
2 ≤ a → (1 - 1 / a)⁻¹ ≤ 2 | An inequality involving `2`. | true |
NumberField.mixedEmbedding.fundamentalCone.hasDerivAt_expMap_single | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] (w : NumberField.InfinitePlace K) (x : ℝ),
HasDerivAt (↑(NumberField.mixedEmbedding.fundamentalCone.expMap_single w))
(NumberField.mixedEmbedding.fundamentalCone.deriv_expMap_single w x) x | null | true |
Std.DHashMap.Raw.Const.get_map' | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {γ : Type w} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → γ} {k : α} {h' : k ∈ Std.DHashMap.Raw.map f m}
(h : m.WF),
Std.DHashMap.Raw.Const.get (Std.DHashMap.Raw.map f m) k h' = f (m.getKey k ⋯) ... | Variant of `get_map` that holds with `EquivBEq` (i.e. without `LawfulBEq`). | true |
AbstractMeasure.monoidAlgebraHom | Mathlib.NumberTheory.Padics.Measure.Monoid | {G : Type u_1} →
{R : Type u_2} →
[inst : TopologicalSpace G] →
[inst_1 : CommRing R] →
[inst_2 : TopologicalSpace R] →
[inst_3 : IsTopologicalRing R] →
[inst_4 : Monoid G] →
[inst_5 : ContinuousMul G] →
[inst_6 : LocallyCompactSpace G] → MonoidAlg... | The canonical homomorphism from the monoid algebra `R[G]` to `D(G, R)`. | true |
List.getElem?_iterate | Mathlib.Data.List.Iterate | ∀ {α : Type u_1} (f : α → α) (a : α) (n i : ℕ), i < n → (List.iterate f a n)[i]? = some (f^[i] a) | null | true |
Finset.traverse.eq_1 | Mathlib.Data.Finset.Functor | ∀ {α β : Type u} {F : Type u → Type u} [inst : Applicative F] [inst_1 : CommApplicative F] [inst_2 : DecidableEq β]
(f : α → F β) (s : Finset α), Finset.traverse f s = Multiset.toFinset <$> Multiset.traverse f s.val | null | true |
MeasureTheory.FiniteMeasure.instModuleNNReal | Mathlib.MeasureTheory.Measure.FiniteMeasure | {Ω : Type u_3} → [inst : MeasurableSpace Ω] → Module NNReal (MeasureTheory.FiniteMeasure Ω) | null | true |
CoeFun.recOn | Init.Coe | {α : Sort u} →
{γ : α → Sort v} →
{motive : CoeFun α γ → Sort u_1} → (t : CoeFun α γ) → ((coe : (f : α) → γ f) → motive { coe := coe }) → motive t | null | false |
Lean.Compiler.LCNF.Decl.isTemplateLike | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Decl pu → Lean.CoreM Bool | Return `true` if `decl` is supposed to be inlined/specialized.
| true |
IsLocalExtr.comp_continuous | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} {δ : Type x} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β}
[inst_2 : TopologicalSpace δ] {g : δ → α} {b : δ}, IsLocalExtr f (g b) → ContinuousAt g b → IsLocalExtr (f ∘ g) b | null | true |
Matroid.IsBasis.subset_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X I : Set α}, M.IsBasis I X → X ⊆ M.closure I | null | true |
IsDiscrete.preimage' | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
IsDiscrete s → ContinuousOn f (f ⁻¹' s) → (∀ (x : Y), IsDiscrete (f ⁻¹' {x})) → IsDiscrete (f ⁻¹' s) | If `f` is continuous with discrete fibers, then the preimage of discrete sets are discrete. | true |
_private.Mathlib.Data.Nat.GCD.Basic.0.Nat.coprime_iff_isRelPrime._simp_1_5 | Mathlib.Data.Nat.GCD.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] {x : α}, IsUnit x = (x ∣ 1) | null | false |
NonUnitalSubring.add_mem | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R) {x y : R}, x ∈ s → y ∈ s → x + y ∈ s | A non-unital subring is closed under addition. | true |
SSet.Truncated.HomotopyCategory₂._sizeOf_1 | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | {A : SSet.Truncated 2} → A.HomotopyCategory₂ → ℕ | null | false |
SimpleGraph.IsClique.mono | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G H : SimpleGraph α} {s : Set α}, G ≤ H → G.IsClique s → H.IsClique s | null | true |
MonCat | Mathlib.Algebra.Category.MonCat.Basic | Type (u + 1) | The category of monoids and monoid morphisms. | true |
Topology.CWComplex.instRelCWComplex._proof_3 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (C : Set X) [inst_1 : Topology.CWComplex C] (n : ℕ)
(i : Topology.CWComplex.cell C n),
∃ I,
Set.MapsTo (↑(Topology.CWComplex.map n i)) (Metric.sphere 0 1)
(∅ ∪ ⋃ m, ⋃ (_ : m < n), ⋃ j ∈ I m, ↑(Topology.CWComplex.map m j) '' Metric.closedBall 0 1) | null | false |
WithTopology.instSemilatticeSup | Mathlib.Topology.WithTopology | {X : Type u_1} → (t : TopologicalSpace X) → [SemilatticeSup X] → SemilatticeSup (WithTopology X t) | null | true |
Lean.Grind.CommRing.Poly.checkCoeffs._unsafe_rec | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.Poly → Bool | null | false |
EuclideanDomain.remainder | Mathlib.Algebra.EuclideanDomain.Defs | {R : Type u} → [self : EuclideanDomain R] → R → R → R | A remainder function (denoted `%`) on `R`.
This satisfies the property `b * (a / b) + a % b = a`, where `/` denotes `quotient`. | true |
UInt64.lt_irrefl | Init.Data.UInt.Lemmas | ∀ (a : UInt64), ¬a < a | null | true |
RootPairing.Base.mk._flat_ctor | Mathlib.LinearAlgebra.RootSystem.Base | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{P : RootPairing ι R M N} →
... | null | false |
lie_eq_smul | Mathlib.Algebra.Lie.OfAssociative | ∀ {A : Type v} [inst : Ring A] {M : Type w} [inst_1 : AddCommGroup M] [inst_2 : Module A M] (a : A) (m : M),
⁅a, m⁆ = a • m | null | true |
_private.Mathlib.Algebra.Homology.CochainComplexOpposite.0.CochainComplex.homotopyUnop._proof_5 | Mathlib.Algebra.Homology.CochainComplexOpposite | ∀ (q q' : ℤ), q = q' → ComplexShape.embeddingUpIntDownInt.f q = ComplexShape.embeddingUpIntDownInt.f q' | null | false |
CategoryTheory.Coyoneda.punitIso | Mathlib.CategoryTheory.Yoneda | CategoryTheory.coyoneda.obj (Opposite.op PUnit.{v₁ + 1}) ≅ CategoryTheory.Functor.id (Type v₁) | The identity functor on `Type` is isomorphic to the coyoneda functor coming from `PUnit`. | true |
_private.Lean.Meta.MatchUtil.0.Lean.Meta.matchHelper?.match_1 | Lean.Meta.MatchUtil | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → (Unit → motive none) → ((s : Option α) → motive s) → motive __do_lift | null | false |
List.getElem_cons_length | Init.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {xs : List α} {i : ℕ} (h : i = xs.length), (x :: xs)[i] = (x :: xs).getLast ⋯ | null | true |
CategoryTheory.Functor.FullyFaithful.hasShift.map_zero_inv_app | Mathlib.CategoryTheory.Shift.Basic | ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] [inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift D A]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (s : A → CategoryTheory.Functor C C)
(i : (i : A) → (s i).com... | null | true |
String.Pos.Raw.isValid.eq_def | Init.Data.String.Basic | ∀ (s : String) (p : String.Pos.Raw),
String.Pos.Raw.isValid s p =
if h : p < s.rawEndPos then decide (s.getUTF8Byte p h).IsUTF8FirstByte else decide (p = s.rawEndPos) | null | true |
UInt64.lt_trans | Init.Data.UInt.Lemmas | ∀ {a b c : UInt64}, a < b → b < c → a < c | null | true |
_private.Mathlib.Computability.NFA.0.NFA.mem_evalFrom_iff_nonempty_path.match_1_7 | Mathlib.Computability.NFA | ∀ {α : Type u_1} {σ : Type u_2} {M : NFA α σ} (motive : (x : List α) → (t s : σ) → Nonempty (M.Path s t x) → Prop)
(x : List α) (t s : σ) (p : Nonempty (M.Path s t x)),
(∀ (s : σ), motive [] s s ⋯) →
(∀ (t s s' : σ) (a : α) (x : List α) (h₁ : s' ∈ M.step s a) (h₂ : M.Path s' t x), motive (a :: x) t s ⋯) →
... | null | false |
Representation.Coinvariants.induction_on | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] {ρ : Representation k G V} {motive : ρ.Coinvariants → Prop} (x : ρ.Coinvariants),
(∀ (v : V), motive ((Representation.Coinvariants.mk ρ) v)) → motive x | null | true |
CochainComplex.HomComplex.Cochain.rightUnshift_comp._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {n m a nm : ℤ}, n + m = nm → ∀ (nm' : ℤ), nm + a = nm' → ∀ (m' : ℤ), m + a = m' → n + m' = nm' | null | false |
CentroidHom.coe_neg | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocRing α] (f : CentroidHom α), ⇑(-f) = -⇑f | null | true |
Subtype.coe_eq_iff | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} {a : { a // p a }} {b : α}, ↑a = b ↔ ∃ (h : p b), a = ⟨b, h⟩ | null | true |
Std.Roo.size | Init.Data.Range.Polymorphic.Iterators | {α : Type u} → [Std.Rxo.HasSize α] → [Std.PRange.UpwardEnumerable α] → Std.Roo α → ℕ | Returns the number of elements contained in the given open range.
| true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.UniformSpace.secondCountable_of_separable._simp_3 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
DistLat.instConcreteCategoryLatticeHomCarrier._proof_4 | Mathlib.Order.Category.DistLat | ∀ {X Y Z : DistLat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | null | false |
Finsupp.embDomain_zero | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_4} [inst : Zero M] (f : α ↪ β), Finsupp.embDomain f 0 = 0 | null | true |
CategoryTheory.CatCommSq.iso | Mathlib.CategoryTheory.CatCommSq | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C₃} →
{inst_3 : CategoryTheory.Category.{v_4, u... | Assuming `[CatCommSq T L R B]`, `iso T L R B` is the isomorphism `T ⋙ R ≅ L ⋙ B`
given by the 2-commutative square. | true |
TemperedDistribution.instLineDeriv | Mathlib.Analysis.Distribution.TemperedDistribution | {E : Type u_3} →
{F : Type u_4} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : AddCommGroup F] →
[inst_3 : Module ℂ F] →
[inst_4 : TopologicalSpace F] →
[IsTopologicalAddGroup F] →
[ContinuousConstSMul ℂ F] → LineDeriv E (... | The partial derivative (or directional derivative) in the direction `m : E` as a
continuous linear map on tempered distributions. | true |
CategoryTheory.effectiveEpiFamily_of_effectiveEpi_epi_comp | Mathlib.CategoryTheory.EffectiveEpi.Comp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {α : Type u_2} {B : C} {X Y : α → C}
(f : (a : α) → X a ⟶ B) (g : (a : α) → Y a ⟶ X a) [∀ (a : α), CategoryTheory.Epi (g a)]
[CategoryTheory.EffectiveEpiFamily Y fun a => CategoryTheory.CategoryStruct.comp (g a) (f a)],
CategoryTheory.EffectiveEpiFami... | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.eqImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.Code pu → Bool | null | true |
Graph.IsClosedSubgraph.rfl | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β}, G.IsClosedSubgraph G | null | true |
AffineIsometryEquiv.pointReflection_midpoint_right | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {V : Type u_2} {P : Type u_7} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] [inst_3 : NormedSpace ℝ V] (x y : P),
(AffineIsometryEquiv.pointReflection ℝ (midpoint ℝ x y)) y = x | null | true |
_private.Lean.Meta.Tactic.Contradiction.0.Lean.Meta.processGenDiseq.match_7 | Lean.Meta.Tactic.Contradiction | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((args : Array Lean.Expr) → (fst : Array Lean.BinderInfo) → (snd : Lean.Expr) → motive (args, fst, snd)) → motive x | null | false |
Nat.gcd_pos_of_pos_left | Init.Data.Nat.Gcd | ∀ {m : ℕ} (n : ℕ), 0 < m → 0 < m.gcd n | null | true |
AddGroup.instResiduallyFiniteOfFinite | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : AddGroup G] [Finite G], AddGroup.ResiduallyFinite G | null | true |
FinEnum.recEmptyOption.eq_def | Mathlib.Data.FinEnum.Option | ∀ {P : Type u → Sort v} (finChoice : (n : ℕ) → Fin (n + 1))
(congr : {α β : Type u} → (x : FinEnum α) → (x_1 : FinEnum β) → FinEnum.card β = FinEnum.card α → P α → P β)
(empty : P PEmpty.{u + 1}) (option : {α : Type u} → FinEnum α → P α → P (Option α)) (α : Type u) [inst : FinEnum α],
FinEnum.recEmptyOption finCh... | null | true |
TopologicalSpace.indiscrete_iff_forall_inseparable | Mathlib.Topology.Order | ∀ {α : Type u} {t : TopologicalSpace α}, IndiscreteTopology α ↔ ∀ (x y : α), Inseparable x y | null | true |
CategoryTheory.JointlyFaithful.jointlyReflectsIsomorphisms | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)}
[CategoryTheory.Balanced C], CategoryTheory.JointlyFaithful F → CategoryTheory.JointlyReflectIsomorphisms F | null | true |
CliffordAlgebra.contractLeft._proof_4 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | null | false |
SheafOfModules.relationsOfIsCokernelFree_I | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {ι σ : Type u} {M : SheafOfModules R}
(f : SheafOfModules.free ι ⟶ S... | null | true |
PowerSeries.HasSubst.smul_X' | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {A : Type u_1} [inst : CommRing A] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Algebra A R] (a : A),
PowerSeries.HasSubst (a • PowerSeries.X) | null | true |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.elabDeprecatedModule._regBuiltin.Lean.Elab.Command.elabDeprecatedModule_1 | Lean.Elab.BuiltinCommand | IO Unit | null | false |
_private.Mathlib.Order.GaloisConnection.Basic.0.GaloisConnection.bddBelow_u_image.match_1_1 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder β] {u : α → β} {s : Set α} (motive : BddBelow (u '' s) → Prop)
(x : BddBelow (u '' s)), (∀ (x : β) (hx : x ∈ lowerBounds (u '' s)), motive ⋯) → motive x | null | false |
Lean.Meta.instMonadMetaM | Lean.Meta.Basic | Monad Lean.MetaM | null | true |
Set.injOn_subtype_val | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {p : α → Prop} {s : Set { x // p x }}, Set.InjOn Subtype.val s | null | true |
Std.Iter.atIdxSlow?._proof_8 | Init.Data.Iterators.Consumers.Access | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β) (n : ℕ) (it' : Std.Iter β),
it.IsPlausibleStep (Std.IterStep.skip it') →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨it', n⟩ ⟨it, n⟩ | null | false |
Array.getElem_set_self | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} (h : i < xs.size) {v : α}, (xs.set i v h)[i] = v | null | true |
LieAlgebra.equivOfRootSystemEquiv._proof_12 | Mathlib.Algebra.Lie.Basis.Base | ∀ {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] {H : LieSubalgebra K L} [inst_5 : H.IsCartanSubalgebra]
[inst_6 : LieModule.IsTriangularizable K (↥H) L] [inst_7 : LieAlgebra.IsSimple K L],
∃ B, B.A = ⋯.some.cart... | null | false |
Batteries.Tactic.Alias.AliasInfo.forward.elim | Batteries.Tactic.Alias | {motive : Batteries.Tactic.Alias.AliasInfo → Sort u} →
(t : Batteries.Tactic.Alias.AliasInfo) →
t.ctorIdx = 1 → ((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.forward n)) → motive t | null | false |
UniformSpace.noConfusion | Mathlib.Topology.UniformSpace.Defs | {P : Sort u_1} →
{α : Type u} →
{t : UniformSpace α} →
{α' : Type u} → {t' : UniformSpace α'} → α = α' → t ≍ t' → UniformSpace.noConfusionType P t t' | null | false |
CategoryTheory.ModObj.assoc_flip | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
{M : C} [inst_4 : CategoryTheory.MonObj M] (X : D) [inst_5 : CategoryTheory.ModObj M ... | null | true |
Filter.Tendsto.isCompact_insert_range | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {f : ℕ → X} {x : X},
Filter.Tendsto f Filter.atTop (nhds x) → IsCompact (insert x (Set.range f)) | null | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.rec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
((e : Lean.Expr) →
(f g h : Mathlib.Tactic.BicategoryLike.Mor₁) →
motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.associator e f g h)) →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) →
motive (Mat... | null | false |
CochainComplex.ConnectData.X | Mathlib.Algebra.Homology.Embedding.Connect | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → ChainComplex C ℕ → CochainComplex C ℕ → ℤ → C | Auxiliary definition for `ConnectData.cochainComplex`. | true |
Monotone.ae_differentiableAt | Mathlib.Analysis.Calculus.Monotone | ∀ {f : ℝ → ℝ}, Monotone f → ∀ᵐ (x : ℝ), DifferentiableAt ℝ f x | A monotone real function is differentiable Lebesgue-almost everywhere. | true |
AList.lookup.eq_1 | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
AList.lookup a s = List.dlookup a s.entries | null | true |
_private.Mathlib.Analysis.Calculus.DSlope.0.differentiableAt_dslope_of_ne._simp_1_1 | Mathlib.Analysis.Calculus.DSlope | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E}, DifferentiableAt 𝕜 f x = DifferentiableWithinAt 𝕜 f... | null | false |
Lean.Lsp.DidSaveTextDocumentParams | Lean.Data.Lsp.TextSync | Type | null | true |
Complex.sin_sub_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℕ), Complex.sin (x - ↑n * (2 * ↑Real.pi)) = Complex.sin x | null | true |
BitVec.DivModState.recOn | Init.Data.BitVec.Bitblast | {w : ℕ} →
{motive : BitVec.DivModState w → Sort u} →
(t : BitVec.DivModState w) →
((wn wr : ℕ) → (q r : BitVec w) → motive { wn := wn, wr := wr, q := q, r := r }) → motive t | null | false |
_private.Mathlib.Combinatorics.Quiver.SingleObj.0.Quiver.SingleObj.toPrefunctor_symm_comp._simp_1_1 | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e.symm x = y) = (x = e y) | null | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preregular C] →
[inst_2 : CategoryTheory.FinitaryExtensive C] →
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type v))} →
(∀ (n : ℕ), CategoryTheory.Sheaf.IsLoca... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.