name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Qq.dropListLitQ._sunfold | Mathlib.Util.Qq | {u : Lean.Level} → {α : Q(Type u)} → ℕ → Q(List «$α») → Q(List «$α») | null | false |
TopCat.instCategorySheaf._proof_8 | Mathlib.Topology.Sheaves.Sheaf | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] (X : TopCat),
autoParam
(∀ {X_1 Y : TopCat.Sheaf C X} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
Lean.Elab.Term.precheckMatch | Lean.Elab.Match | Lean.Elab.Term.Quotation.Precheck | null | true |
MulZeroClass.casesOn | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
{motive : MulZeroClass M₀ → Sort u_1} →
(t : MulZeroClass M₀) →
([toMul : Mul M₀] →
[toZero : Zero M₀] →
(zero_mul : ∀ (a : M₀), 0 * a = 0) →
(mul_zero : ∀ (a : M₀), a * 0 = 0) →
motive { toMul := toMul, toZero := toZero, zero_mul := zero_m... | null | false |
String.Legacy.Iterator.prevn._sunfold | Init.Data.String.Iterator | String.Legacy.Iterator → ℕ → String.Legacy.Iterator | null | false |
Equiv.addCommGroup._proof_3 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : AddCommGroup β] (x : α), e (e.symm (-e.toFun x)) = -e.toFun x | null | false |
Int.zmultiples_le_zmultiples_iff | Mathlib.Algebra.Group.Subgroup.ZPowers.Basic | ∀ {a b : ℤ}, AddSubgroup.zmultiples a ≤ AddSubgroup.zmultiples b ↔ b ∣ a | null | true |
ENNReal.toReal_natCast | Mathlib.Basic.ENNReal.Basic | ∀ (n : ℕ), (↑n).toReal = ↑n | null | true |
intervalIntegrable_congr_ae | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] [TopologicalSpace.PseudoMetrizableSpace ε]
{f : ℝ → ε} {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {g : ℝ → ε},
f =ᵐ[μ.restrict (Set.uIoc a b)] g → (IntervalIntegrable f μ a b ↔ IntervalIntegrable g μ a b) | null | true |
Array.mapFinIdx_eq_empty_iff | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β}, xs.mapFinIdx f = #[] ↔ xs = #[] | null | true |
CategoryTheory.SimplicialObject.comp_left_app | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X Y Z : CategoryTheory.SimplicialObject.Augmented C}
(a : X ⟶ Y) (a_1 : Y ⟶ Z) (X_1 : SimplexCategoryᵒᵖ),
(CategoryTheory.CategoryStruct.comp a a_1).left.app X_1 =
CategoryTheory.CategoryStruct.comp (a.left.app X_1) (a_1.left.app X_1) | null | true |
ContinuousOn.continuous_restrict_iff_continuous_uniformOnFun | Mathlib.Topology.UniformSpace.CompactConvergence | ∀ {α : Type u₁} {β : Type u₂} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {X : Type u_1}
[inst_2 : TopologicalSpace X] {f : X → α → β} {s : Set α} (hf : ∀ (x : X), ContinuousOn (f x) s) [CompactSpace ↑s],
(Continuous fun x => { toFun := s.domRestrict (f x), continuous_toFun := ⋯ }) ↔
Continuous fun x ... | **Alias** of `ContinuousOn.continuous_domRestrict_iff_continuous_uniformOnFun`.
---
A family `f : X → α → β`, each of which is continuous on a compact set `s : Set α` is
continuous in the topology `X → α →ᵤ[{s}] β` if and only if the family of continuous restrictions
`X → C(s, β)` is continuous. | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.letrec._regBuiltin.Lean.Parser.Term.scoped.parenthesizer_67 | Lean.Parser.Term | IO Unit | null | false |
_private.Mathlib.Topology.DiscreteSubset.0.codiscreteWithin_iff_locallyEmptyComplementWithin._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S T : Set X},
(S ∈ Filter.codiscreteWithin T) = ∀ x ∈ T, Disjoint (nhdsWithin x {x}ᶜ) (Filter.principal (T \ S)) | null | false |
CategoryTheory.Functor.PushoutObjObj.ι_iso_of_iso_left_inv | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {f₁ f₁' : CategoryTheory.Arrow C₁}
{f₂ : CategoryTheory.Arrow C₂}... | null | true |
Lean.Parser.Attr.grind? | Init.Grind.Attr | Lean.ParserDescr | Like `@[grind]`, but also prints the pattern(s) selected by `grind`
as info messages. Useful for debugging annotations and modifiers.
| true |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.Subcomplex.mk'._simp_1 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {α : Type u} {s t u : Set α}, Disjoint (s ∪ t) u = (Disjoint s u ∧ Disjoint t u) | null | false |
AntilipschitzWith | Mathlib.Topology.MetricSpace.Antilipschitz | {α : Type u_1} → {β : Type u_2} → [PseudoEMetricSpace α] → [PseudoEMetricSpace β] → NNReal → (α → β) → Prop | We say that `f : α → β` is `AntilipschitzWith K` if for any two points `x`, `y` we have
`edist x y ≤ K * edist (f x) (f y)`. This can also be used as a predicate for bounded below
linear operators, see `antilipschitzWith_iff_exists_mul_le_norm`. | true |
OreLocalization.liftExpand._proof_7 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_3} [inst : Monoid R] {S : Submonoid R} {X : Type u_2} [inst_1 : MulAction R X] {C : Sort u_1}
(P : X → ↥S → C),
(∀ (r : X) (t : R) (s : ↥S) (ht : t * ↑s ∈ S), P r s = P (t • r) ⟨t * ↑s, ht⟩) →
∀ (r₁ : X) (s₁ : ↥S) (r₂ : X) (s₂ u : ↥S) (v : R),
u • (r₂, s₂).1 = v • (r₁, s₁).1 →
↑u * ↑... | null | false |
CategoryTheory.Span.SpanBicat.mkIso₂._proof_2 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
Option.filter_none | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (p : α → Bool), Option.filter p none = none | null | true |
OrderDual.instMulOneClass._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : MulOneClass α] (a : αᵒᵈ), 1 * a = a | null | false |
CategoryTheory.Comma.mapRightEq | Mathlib.CategoryTheory.Comma.Basic | {B : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} B] →
{A : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(L : CategoryTheory.Functor A T) →
{R₁ R₂ : CategoryTheory.Functor B T} →
... | Two equal natural transformations `R₁ ⟶ R₂` yield naturally isomorphic functors
`Comma L R₁ ⥤ Comma L R₂`. | true |
CategoryTheory.MorphismProperty.fst'_self_eq_snd | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.MorphismProperty C}
{G : CategoryTheory.Functor Cᵒᵖ (Type v₁)},
P ≤ CategoryTheory.MorphismProperty.monomorphisms C →
∀ {X : C} {f : CategoryTheory.yoneda.obj X ⟶ G} (hf : P.presheaf f), ⋯.fst' f = ⋯.snd f | null | true |
ZMod.cast_eq_val | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {R : Type u_1} [inst : AddGroupWithOne R] [NeZero n] (a : ZMod n), a.cast = ↑a.val | null | true |
_private.Mathlib.RingTheory.WittVector.MulCoeff.0.WittVector.term𝕄 | Mathlib.RingTheory.WittVector.MulCoeff | Lean.ParserDescr | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Dihedral.0.DihedralGroup.center_eq_closure_of_even_ne_two._proof_1_8 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ (m : ℕ) (i : ZMod 0), -i = i → i = 0 ∨ i = ↑m | null | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Piecewise.0.Finset.sum_dite_of_true._proof_1_4 | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {s : Finset ι} (a : ↥s) (ha : a ∈ Finset.univ), ⟨↑a, ⋯⟩ = a | null | false |
instBooleanAlgebraSubtypeIsIdempotentElem | Mathlib.Algebra.Order.Ring.Idempotent | {R : Type u_1} → [inst : CommRing R] → BooleanAlgebra { a // IsIdempotentElem a } | null | true |
InitialSeg.«_aux_Mathlib_Order_InitialSeg___macroRules_InitialSeg_term_≺i__1» | Mathlib.Order.InitialSeg | Lean.Macro | null | false |
_private.Mathlib.Algebra.Category.ModuleCat.Biproducts.0.lequivProdOfRightSplitExact'._proof_2 | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u_1} [inst : Ring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
Polynomial.natDegree_X_add_C | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [Nontrivial R] [inst : Semiring R] (x : R), (Polynomial.X + Polynomial.C x).natDegree = 1 | null | true |
Function.locallyFinsupp.map._proof_1 | Mathlib.Topology.LocallyFinsupp.Pushforward | ∀ {X : Type u_3} {Y : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] (f : X → Y) (w : X → R) [inst_1 : Semiring R]
(c : Function.locallyFinsupp X R), (Function.support fun z => ∑ᶠ (x : X) (_ : x ∈ f ⁻¹' {z}), c x * w x) ⊆ Set.univ | null | false |
DilationEquiv.smulTorsor.congr_simp | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : NormSMulClass 𝕜 E] {P : Type u_3} [inst_4 : PseudoMetricSpace P] [inst_5 : NormedAddTorsor E P] (c c_1 : P),
c = c_1 → ∀ {k k_1 : 𝕜} (e_k : k = k_1) (hk : k ≠ 0), DilationEquiv.smul... | null | true |
Std.LinearPreorderPackage.ofLE | Init.Data.Order.PackageFactories | (α : Type u) →
autoParam (Std.Packages.LinearPreorderOfLEArgs α) Std.LinearPreorderPackage.ofLE._auto_1 → Std.LinearPreorderPackage α | Use this factory to conveniently define a linear preorder on a type `α` and all the associated
operations and instances given an `LE α` instance.
Creates a `LinearPreorderPackage α` instance. Such an instance entails `LE α`, `LT α`, `BEq α` and
`Ord α` instances as well as an `IsLinearPreorder α` instance and `LawfulO... | true |
tsum_eisSummand_eq_riemannZeta_mul_eisensteinSeries | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {k : ℕ},
3 ≤ k →
∀ (z : UpperHalfPlane),
∑' (v : Fin 2 → ℤ), EisensteinSeries.eisSummand (↑k) v z = riemannZeta ↑k * eisensteinSeries 0 (↑k) z | null | true |
Module.End.toContinuousLinearMap._proof_7 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] (E : Type u_2) [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace 𝕜 E], IsScalarTower 𝕜 𝕜 E | null | false |
Nat.sub_one_lt_of_le | Init.Data.Nat.Lemmas | ∀ {a b : ℕ}, 0 < a → a ≤ b → a - 1 < b | null | true |
QuotientGroup.injective_lift_iff | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {M : Type u_4} [inst : Group G] [inst_1 : Monoid M] (N : Subgroup G) [nN : N.Normal] (φ : G →* M)
(HN : N ≤ φ.ker), Function.Injective ⇑(QuotientGroup.lift N φ HN) ↔ N = φ.ker | null | true |
ByteArray.casesOn | Init.Prelude | {motive : ByteArray → Sort u} → (t : ByteArray) → ((data : Array UInt8) → motive { data := data }) → motive t | null | false |
_private.Mathlib.Topology.EMetricSpace.Defs.0.EMetric.tendsto_nhdsWithin_nhds._simp_1_1 | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
_private.Mathlib.MeasureTheory.Group.Action.0.MeasureTheory.isLocallyFiniteMeasure_of_vaddInvariant.match_1_1 | Mathlib.MeasureTheory.Group.Action | ∀ (G : Type u_1) {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {U : Set α} (x : α)
(motive : (∃ c, c +ᵥ x ∈ U) → Prop) (x_1 : ∃ c, c +ᵥ x ∈ U), (∀ (g : G) (hg : g +ᵥ x ∈ U), motive ⋯) → motive x_1 | null | false |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.findTermInfo?._sparseCasesOn_1 | Batteries.CodeAction.Misc | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.TermInfo) → motive (Lean.Elab.Info.ofTermInfo i)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Finset.disjoint_preimage._simp_1 | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} {f : α → β} {s t : Finset β} {hs : Set.InjOn f (f ⁻¹' ↑s)} {ht : Set.InjOn f (f ⁻¹' ↑t)},
Disjoint s t → Disjoint (s.preimage f hs) (t.preimage f ht) = True | null | false |
Std.Http.Response.forbidden | Std.Http.Data.Response | Std.Http.Response.Builder | Creates a new HTTP Response builder with the 403 status code.
| true |
Lean.instOfNatLeanOptionValue | Lean.Util.LeanOptions | {n : ℕ} → OfNat Lean.LeanOptionValue n | null | true |
Lean.Grind.Order.eq_of_le_of_le | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [Std.IsPartialOrder α] {a b : α}, a ≤ b → b ≤ a → a = b | null | true |
UInt16.mul_def | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), a * b = { toBitVec := a.toBitVec * b.toBitVec } | null | true |
Continuous.tendsto_nhdsSet_nhds | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α} {b : β}
{f : α → β}, Continuous f → Set.EqOn f (fun x => b) s → Filter.Tendsto f (nhdsSet s) (nhds b) | null | true |
RingCon.lift_bijective_iff | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring P] {c : RingCon M} {f : M →+* P}
{h : c ≤ RingCon.ker f}, Function.Bijective ⇑(c.lift f h) ↔ c = RingCon.ker f ∧ Function.Surjective ⇑f | null | true |
QuadraticAlgebra.C_smul | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {S : Type u_2} {a b : R} [inst : Zero R] [inst_1 : SMulZeroClass S R] (s : S) (r : R),
QuadraticAlgebra.C (s • r) = s • QuadraticAlgebra.C r | null | true |
Lean.Lsp.DocumentColorParams._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DocumentColorParams → ℕ | null | false |
Valuation.Uniformizer.mk.inj | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} {inst : LinearOrderedCommGroupWithZero Γ} {A : Type u_2} {inst_1 : Ring A} {v : Valuation A Γ}
{hv : v.IsRankOneDiscrete} {val : ↥v.integer} {valuation_gt_one : v.IsUniformizer ↑val} {val_1 : ↥v.integer}
{valuation_gt_one_1 : v.IsUniformizer ↑val_1},
{ val := val, valuation_gt_one := valuation_gt... | null | true |
span_lt_of_subset_of_ncard_lt_finrank | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{s : Set M}, s.Finite → ∀ {t : Submodule R M}, s ⊆ ↑t → s.ncard < Module.finrank R ↥t → Submodule.span R s < t | null | true |
bijective_of_isLocalized_span | Mathlib.RingTheory.LocalProperties.Exactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (s : Set R),
Ideal.span s = ⊤ →
∀ (Mₚ : ↑s → Type u_5) [inst_5 : (r : ↑s) → AddCommMonoid (Mₚ r)] [inst_6 : (r : ↑s) → Module R (Mₚ r)]
(... | null | true |
AlgebraicGeometry.basicOpen_eq_of_affine | Mathlib.AlgebraicGeometry.Scheme | ∀ {R : CommRingCat} (f : ↑R),
(AlgebraicGeometry.Spec R).basicOpen
((CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.ΓSpecIso R).inv) f) =
PrimeSpectrum.basicOpen f | null | true |
SchwartzMap.decay' | 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] (self : SchwartzMap E F) (k n : ℕ),
∃ C, ∀ (x : E), ‖x‖ ^ k * ‖iteratedFDeriv ℝ n self.toFun x‖ ≤ C | null | true |
CategoryTheory.FreeBicategory.Rel.whisker_right_id | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b : B} {f g : CategoryTheory.FreeBicategory.Hom a b}
(η : CategoryTheory.FreeBicategory.Hom₂ f g),
CategoryTheory.FreeBicategory.Rel
(CategoryTheory.FreeBicategory.Hom₂.whisker_right (CategoryTheory.FreeBicategory.Hom.id b) η)
((CategoryTheory.FreeBicategory.Hom₂.right_un... | null | true |
MonTypeEquivalenceMon.monMonoid._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ (A : Type u_1) [inst : CategoryTheory.MonObj A] (x y z : A), x * y * z = x * (y * z) | null | false |
Lean.instBEqOpaqueVal.beq | Lean.Declaration | Lean.OpaqueVal → Lean.OpaqueVal → Bool | null | true |
FreeAddSemigroup.lift.eq_1 | Mathlib.Algebra.Free | ∀ {α : Type u} {β : Type v} [inst : AddSemigroup β],
FreeAddSemigroup.lift =
{ toFun := fun f => { toFun := fun x => List.foldl (fun a b => a + f b) (f x.head) x.tail, map_add' := ⋯ },
invFun := fun f => ⇑f ∘ FreeAddSemigroup.of, left_inv := ⋯, right_inv := ⋯ } | null | true |
Lean.Meta.Simp.Stats.rec | Lean.Meta.Tactic.Simp.Types | {motive : Lean.Meta.Simp.Stats → Sort u} →
((usedTheorems : Lean.Meta.Simp.UsedSimps) →
(diag : Lean.Meta.Simp.Diagnostics) → motive { usedTheorems := usedTheorems, diag := diag }) →
(t : Lean.Meta.Simp.Stats) → motive t | null | false |
Std.ExtDHashMap.get?_map | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : LawfulBEq α] {f : (a : α) → β a → γ a} {k : α}, (Std.ExtDHashMap.map f m).get? k = Option.map (f k) (m.get? k) | null | true |
CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.hom_ext | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.RightExtension F}
(h : E.IsPointwiseRightKanExtensio... | null | true |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.Function.FactorizedRational.log_norm_meromorphicTrailingCoeffAt._simp_1_1 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
List.instTransSublistMem | Init.Data.List.Sublist | {α : Type u_1} → Trans (fun l₁ l₂ => l₂.Sublist l₁) Membership.mem Membership.mem | null | true |
Graph.instReflCompatible | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2}, Std.Refl Graph.Compatible | null | true |
ByteArray.utf8Decode?.go.fun_cases_unfolding | Init.Data.String.Basic | ∀ (b : ByteArray) (i : ℕ) (acc : Array Char) (hi : i ≤ b.size) (motive : Option (Array Char) → Prop),
(i < b.size → b.utf8DecodeChar? i = none → motive none) →
(i < b.size →
∀ (c : Char) (h : b.utf8DecodeChar? i = some c),
motive (ByteArray.utf8Decode?.go b (i + c.utf8Size) (acc.push c) ⋯)) →
... | null | true |
true_eq_decide_iff | Init.Data.Bool | ∀ {p : Prop} [h : Decidable p], true = decide p ↔ p | null | true |
Std.Do.SPred.entails._f | Std.Do.SPred.SPred | {σs : List (Type u)} →
List.below (motive := fun {σs} => Std.Do.SPred σs → Std.Do.SPred σs → Prop) σs →
Std.Do.SPred σs → Std.Do.SPred σs → Prop | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.constEntryAtIdx!_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
instLTInt64 | Init.Data.SInt.Basic | LT Int64 | null | true |
OrderMonoidWithZeroHom.instCoeMonoidWithZeroHom | Mathlib.Algebra.Order.Hom.MonoidWithZero | {α : Type u_2} →
{β : Type u_3} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : MulZeroOneClass α] → [inst_3 : MulZeroOneClass β] → Coe (α →*₀o β) (α →*₀ β) | null | true |
ContinuousMap.tendsto_of_monotone_of_pointwise | Mathlib.Topology.UniformSpace.Dini | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α]
[inst_2 : NormedAddCommGroup G] [inst_3 : Lattice G] [HasSolidNorm G] [IsOrderedAddMonoid G] {F : ι → C(α, G)}
{f : C(α, G)},
Monotone F →
(∀ (x : α), Filter.Tendsto (fun x_1 => (F x_1) x) Filter.atTop (nhds (f x)... | **Dini's theorem**: if `F n` is a monotone increasing collection of continuous functions
converging pointwise to a continuous function `f`, then `F n` converges to `f` in the
compact-open topology. | true |
Vector.swap_same | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {v : Vector α n} {i : ℕ} (hi : i < n), v.swap i i hi hi = v | null | true |
Module.End.mem_eigenspace_iff | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {x : M}, x ∈ f.eigenspace μ ↔ f x = μ • x | null | true |
Polynomial.aeval_algebraMap_apply | Mathlib.RingTheory.Polynomial.Tower | ∀ {R : Type u_1} {A : Type u_2} (B : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra A B] [inst_5 : Algebra R B] [IsScalarTower R A B] (x : A) (p : Polynomial R),
(Polynomial.aeval ((algebraMap A B) x)) p = (algebraMap A B) ((Polynomial.aeva... | null | true |
ContMDiffVAdd.casesOn | Mathlib.Geometry.Manifold.Algebra.SMul | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{H' : Type u_4} →
... | null | false |
_private.Mathlib.Tactic.SplitIfs.0.Mathlib.Tactic.getSplitCandidates | Mathlib.Tactic.SplitIfs | Lean.Elab.Tactic.Location → Lean.Elab.Tactic.TacticM (List (Mathlib.Tactic.SplitPosition✝ × Lean.Expr)) | Collects a list of positions pointed to by `loc` and their types.
| true |
CategoryTheory.Limits.pair | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
C → C → CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C | The diagram on the walking pair, sending the two points to `X` and `Y`. | true |
SimpleGraph.Subgraph.map._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} (f : G →g G') (H : G.Subgraph) {v w : W},
Relation.Map H.Adj (⇑f) (⇑f) v w → G'.Adj v w | null | false |
IsOfFinAddOrder.mem_multiples_iff_mem_range_addOrderOf | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] {x y : G} [inst_1 : DecidableEq G],
IsOfFinAddOrder x →
(y ∈ AddSubmonoid.multiples x ↔ y ∈ Finset.image (fun x_1 => x_1 • x) (Finset.range (addOrderOf x))) | null | true |
PerfectClosure.instAddCommGroup._proof_6 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (m : ℕ) (x : K) (n : ℕ)
(y : K) (s : ℕ) (z : K),
Quot.mk (PerfectClosure.R K p) (m, x) + Quot.mk (PerfectClosure.R K p) (n, y) +
Quot.mk (PerfectClosure.R K p) (s, z) =
Quot.mk (PerfectClosure.R K p) (m, x) +
... | null | false |
CategoryTheory.Limits.ColimitCocone.mk | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor J C} →
(cocone : CategoryTheory.Limits.Cocone F) →
CategoryTheory.Limits.IsColimit cocone → CategoryTheory.Limits.ColimitCocone... | null | true |
Int16.ofBitVec_int64ToBitVec | Init.Data.SInt.Lemmas | ∀ (x : Int64), Int16.ofBitVec (BitVec.signExtend 16 x.toBitVec) = x.toInt16 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_maxKey?._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Std.Internal.List.getValueCastD_eraseKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {k : α}
{fallback : β k},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValueCastD k (Std.Internal.List.eraseKey k l) fallback = fallback | null | true |
CategoryTheory.IsHomLift.id_lift_eqToHom_domain | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} (hRS : R = S) {a : 𝒳},
p.obj a = R → p.IsHomLift (CategoryTheory.eqToHom hRS) (CategoryTheory.CategoryStruct.id a) | null | true |
Set.mem_image._simp_2 | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (∃ x ∈ s, f x = y) = (y ∈ f '' s) | null | false |
SimplexCategoryGenRel.generators | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | CategoryTheory.MorphismProperty SimplexCategoryGenRel | A morphism is a generator if it is either a face or a degeneracy. | true |
Unitization.fstHom._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A],
IsScalarTower R R A | null | false |
groupCohomology.iCocycles | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) → (n : ℕ) → groupCohomology.cocycles A n ⟶ (groupCohomology.inhomogeneousCochains A).X n | The natural inclusion of the `n`-cocycles `Zⁿ(G, A)` into the `n`-cochains `Cⁿ(G, A).` | true |
Std.DTreeMap.entryAtIdxD | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → ℕ → (a : α) × β a → (a : α) × β a | Returns the key-value pair with the `n`-th smallest key, or `fallback` if `n` is at least `t.size`. | true |
StarRing.mk | Mathlib.Algebra.Star.Basic | {R : Type u} →
[inst : NonUnitalNonAssocSemiring R] →
[toStarMul : StarMul R] → (∀ (r s : R), star (r + s) = star r + star s) → StarRing R | null | true |
BoundedOrder.copy._proof_2 | Mathlib.Order.Copy | ∀ {α : Type u_1} {h h' : LE α} (c : BoundedOrder α) (bot : α), bot = ⊥ → (∀ (x y : α), x ≤ y ↔ x ≤ y) → ∀ (x : α), ⊥ ≤ x | null | false |
AlgebraicGeometry.Scheme.basicOpen_pow | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (f : ↑(X.presheaf.obj (Opposite.op U))) {n : ℕ},
0 < n → X.basicOpen (f ^ n) = X.basicOpen f | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.keys_filter_key._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Std.DTreeMap.Internal.Impl.balanced_rotateL | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β) (rs : ℕ) (rk : α) (rv : β rk)
(rl rr : Std.DTreeMap.Internal.Impl α β),
l.Balanced →
(Std.DTreeMap.Internal.Impl.inner rs rk rv rl rr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond l.size rs ∨
Std... | null | true |
CategoryTheory.HasSplitEqualizer.isSplitEqualizer | Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f g : X ⟶ Y) →
[inst_1 : CategoryTheory.HasSplitEqualizer f g] →
CategoryTheory.IsSplitEqualizer f g (CategoryTheory.HasSplitEqualizer.equalizerι f g) | The equalizer morphism `equalizerι` gives a split equalizer on `f,g`. | true |
Inclusion.IntervalDyadicReal.pow_mem._inclusionExt_1 | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Basic | Inclusion.InclusionExt | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.