name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
bUnion_mem_nhdsSet | Mathlib.Topology.NhdsSet | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X} {t : X → Set X},
(∀ x ∈ s, t x ∈ nhds x) → ⋃ x ∈ s, t x ∈ nhdsSet s | null | true |
Finset.smul_finset_neg | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : Monoid α] [inst_2 : AddGroup β]
[inst_3 : DistribMulAction α β] (a : α) (t : Finset β), a • -t = -(a • t) | null | true |
Nat.clog_mono | Mathlib.Data.Nat.Log | ∀ {b c m n : ℕ}, 1 < c → c ≤ b → m ≤ n → Nat.clog b m ≤ Nat.clog c n | null | true |
Filter.Germ.instSemiring._proof_11 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {l : Filter α} {R : Type u_1} [inst : Semiring R] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Std.Http.Request.options | Std.Http.Data.Request | Std.Http.RequestTarget → Std.Http.Request.Builder | Creates a new HTTP OPTIONS Request builder with the specified URI.
Use `Request.options (RequestTarget.asteriskForm)` for server-wide OPTIONS.
| true |
CategoryTheory.Limits.IsColimit.whiskerEquivalenceEquiv._proof_2 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} J] {K : Type u_4}
[inst_1 : CategoryTheory.Category.{u_6, u_4} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_3, u_2} C]
{F : CategoryTheory.Functor J C} {s : CategoryTheory.Limits.Cocone F} (e : K ≌ J),
Function.LeftInverse (CategoryTheory.Limit... | null | false |
LinearPMap.apply_comp_inclusion | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {T S_1 : E →ₛₗ.[σ] F}
(h : T ≤ S_1) (x : ↥T.domain), ↑T x = ↑S_1 ((Submodule.inclusion ⋯) x) | null | true |
AlgebraicGeometry.RingedSpace.zeroLocus_singleton | Mathlib.Geometry.RingedSpace.Basic | ∀ (X : AlgebraicGeometry.RingedSpace) {U : TopologicalSpace.Opens ↑↑X.toPresheafedSpace}
(f : ↑(X.presheaf.obj (Opposite.op U))), X.zeroLocus {f} = (X.basicOpen f).carrierᶜ | null | true |
three'_nsmul | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_2} [inst : AddMonoid M] (a : M), 3 • a = a + a + a | null | true |
CategoryTheory.InjectiveResolution.descFSucc._proof_2 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Z : C}
(J : CategoryTheory.InjectiveResolution Z) (n : ℕ),
CategoryTheory.CategoryStruct.comp (J.cocomplex.d n (n + 1)) (J.cocomplex.d (n + 1) (n + 2)) = 0 | null | false |
Lean.Parser.Syntax.nonReserved.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjId_hom_app_snd_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] (X_1 : C... | null | true |
Con.gi.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ (M : Type u_1) [inst : Mul M], Con.gi M = { choice := fun r x => conGen r, gc := ⋯, le_l_u := ⋯, choice_eq := ⋯ } | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_160 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
ValueDistribution.proximity_pow_zero | Mathlib.Analysis.Complex.ValueDistribution.Proximity.Basic | ∀ {f : ℂ → ℂ} {n : ℕ}, ValueDistribution.proximity (f ^ n) 0 = n • ValueDistribution.proximity f 0 | For natural numbers `n`, the proximity function of `f ^ n` at `0` equals `n` times the proximity
function of `f` at `0`.
| true |
Mathlib.Meta.Positivity.nonneg_of_isNat' | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n : ℕ} [inst : AddMonoidWithOne A] [inst_1 : PartialOrder A] [AddLeftMono A]
[ZeroLEOneClass A], Mathlib.Meta.NormNum.IsNat e n → 0 ≤ e | null | true |
Cardinal.beth_natCast_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {c : Cardinal.{u}} {n : ℕ}, (Cardinal.beth ↑n ≤ Cardinal.lift.{v, u} c) = (Cardinal.beth ↑n ≤ c) | null | false |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.μ_bddAbove | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (μ : RingSeminorm R),
μ 1 ≤ 1 →
∀ {s : ℕ → ℕ},
(∀ (n : ℕ), s n ≤ n) → ∀ (x : R) (ψ : ℕ → ℕ), BddAbove (Set.range fun n => μ (x ^ s (ψ n)) ^ (1 / ↑(ψ n))) | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.cos_angle_mul_norm_mul_norm._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | null | false |
Lean.Meta.ExprParamInfo.mk.noConfusion | Lean.Meta.Basic | {P : Sort u} →
{name : Lean.Name} →
{type : Lean.Expr} →
{binderInfo : Lean.BinderInfo} →
{name' : Lean.Name} →
{type' : Lean.Expr} →
{binderInfo' : Lean.BinderInfo} →
{ name := name, type := type, binderInfo := binderInfo } =
{ name := name', ty... | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal._proof_3 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (Z : TopologicalSpace.Closeds ↥X) (U : ↑X.affineOpens),
∀ x ∈ ↑U,
x ∈ ↑Z ↔ x ∈ X.zeroLocus ↑(PrimeSpectrum.vanishingIdeal (⇑(AlgebraicGeometry.IsAffineOpen.fromSpec ⋯) ⁻¹' ↑Z)) | null | false |
Lean.Linter.MissingDocs.Handler | Lean.Linter.MissingDocs | Type | null | true |
_private.Mathlib.Order.KrullDimension.0.Order.krullDim_lt_coe_iff._simp_1_2 | Mathlib.Order.KrullDimension | ∀ {n : WithBot ℕ∞} {m : ℕ}, (n < ↑m + 1) = (n ≤ ↑m) | null | false |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.mkProdEqQ.makeRHS._sunfold | Mathlib.Data.Fin.Tuple.Reflection | {u : Lean.Level} →
{α : Q(Type u)} → Q(CommMonoid «$α») → (n : ℕ) → Q(Fin «$n» → «$α») → Q(NeZero «$n») → ℕ → Lean.MetaM Q(«$α») | null | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.cmdCodeActionProvider._sparseCasesOn_2 | Lean.Server.CodeActions.Provider | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.CommandInfo) → motive (Lean.Elab.Info.ofCommandInfo i)) →
(Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
List.partition.loop.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (p : α → Bool) (a : α) (as bs cs : List α),
List.partition.loop p (a :: as) (bs, cs) =
match p a with
| true => List.partition.loop p as (a :: bs, cs)
| false => List.partition.loop p as (bs, a :: cs) | null | true |
Polynomial.hilbertPoly_mul_one_sub_succ | Mathlib.RingTheory.Polynomial.HilbertPoly | ∀ {F : Type u_1} [inst : Field F] [CharZero F] (p : Polynomial F) (d : ℕ),
(p * (1 - Polynomial.X)).hilbertPoly (d + 1) = p.hilbertPoly d | null | true |
Mathlib.Tactic.Bicategory.Mor₂OfExpr | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Lean.Expr → Mathlib.Tactic.Bicategory.BicategoryM Mathlib.Tactic.BicategoryLike.Mor₂ | Construct a `Mor₂` term from a Lean expression. | true |
Lean.Meta.Simp.ConfigCtx.arith._inherited_default | Init.MetaTypes | Bool | null | false |
Computation.Mem | Mathlib.Data.Seq.Computation | {α : Type u} → Computation α → α → Prop | Assertion that a `Computation` limits to a given value | true |
Int64.ofIntClamp_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec 64), Int64.ofIntClamp n.toInt = Int64.ofBitVec n | null | true |
GroupLike.val_inj._simp_1 | Mathlib.RingTheory.Coalgebra.GroupLike | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] {a b : GroupLike R A}, (↑a = ↑b) = (a = b) | null | false |
Lean.Meta.mkSizeOfFns | Lean.Meta.SizeOf | Lean.Name → Lean.MetaM (Array Lean.Name × Lean.NameMap Lean.Name) | Create `sizeOf` functions for all inductive datatypes in the mutual inductive declaration containing `typeName`
The resulting array contains the generated functions names. The `NameMap` maps recursor names into the generated function names.
There is a function for each element of the mutual inductive declaration, and f... | true |
skewAdjointLieSubalgebra | Mathlib.Algebra.Lie.SkewAdjoint | {R : Type u} →
{M : Type v} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → LinearMap.BilinForm R M → LieSubalgebra R (Module.End R M) | Given an `R`-module `M`, equipped with a bilinear form, the skew-adjoint endomorphisms form a
Lie subalgebra of the Lie algebra of endomorphisms. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.forM_eq_forM_toArray._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t : Std.DTreeMap.Internal.Impl α β}, t.toArray = t.toList.toArray | null | false |
forall_gt_imp_ne_iff_le | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ (c : α), a < c → c ≠ b) ↔ b ≤ a | null | true |
ContinuousLinearMapWOT._sizeOf_inst | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | {𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
{inst : Semiring 𝕜₁} →
{inst_1 : Semiring 𝕜₂} →
(σ : 𝕜₁ →+* 𝕜₂) →
(E : Type u_3) →
(F : Type u_4) →
{inst_2 : AddCommGroup E} →
{inst_3 : TopologicalSpace E} →
{inst_4 : Module 𝕜₁ E} →
... | null | false |
IsLocalDiffeomorphAt.localInverse_eqOn_left | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H₁ : Type u_5}
[inst_5 : TopologicalSpace H₁] {H₂ : Type u_6} [inst_6 : TopologicalSpace H₂] {I : ModelWithCorn... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.instDecidableEqLiteral.decEq._proof_1 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | ∀ (a : ℕ) (a_1 : BitVec a), { n := a, value := a_1 } = { n := a, value := a_1 } | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.List.getValue?_filter_containsKey._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {x : Option α} {α_1 : Type u_2} {f : α → α_1}, (Option.map f x = none) = (x = none) | null | false |
Lean.Meta.Grind.AC.MonadGetStruct.noConfusion | Lean.Meta.Tactic.Grind.AC.Util | {P : Sort u} →
{m : Type → Type} →
{t : Lean.Meta.Grind.AC.MonadGetStruct m} →
{m' : Type → Type} →
{t' : Lean.Meta.Grind.AC.MonadGetStruct m'} →
m = m' → t ≍ t' → Lean.Meta.Grind.AC.MonadGetStruct.noConfusionType P t t' | null | false |
BitVec.reduceGetMsb | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | Simplification procedure for `getMsb` (most significant bit) on `BitVec`. | true |
PseudoMetricSpace.replaceUniformity_eq | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_3} [U : UniformSpace α] (m : PseudoMetricSpace α) (H : uniformity α = uniformity α),
m.replaceUniformity H = m | null | true |
MulOpposite.isCancelMulZero_iff | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α], IsCancelMulZero αᵐᵒᵖ ↔ IsCancelMulZero α | null | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind | Lean.Elab.Tactic.Do.Internal.VCGen.SpecDB | Type | The kind of a spec theorem.
| true |
Submodule.mem_sSup | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{s : Set (Submodule R M)} {m : M}, m ∈ sSup s ↔ ∀ (N : Submodule R M), (∀ p ∈ s, p ≤ N) → m ∈ N | null | true |
Lean.Elab.Term.GeneralizeResult.altViews | Lean.Elab.Match | Lean.Elab.Term.GeneralizeResult → Array Lean.Elab.Term.TermMatchAltView | null | true |
CategoryTheory.MorphismProperty.multiplicativeClosure.below.casesOn | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure x → Prop}
{motive_1 :
{X Y : C} →
{x : X ⟶ Y} →
(t : W.multiplicativeClosure x) → CategoryTheory.MorphismProperty.multiplicativeClosure.below... | null | false |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.IsSelfAdjoint.sub._simp_1_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x = (star x = x) | null | false |
instCompactSpaceMultiplicative | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactSpace X], CompactSpace (Multiplicative X) | null | true |
Aesop.UnsafeQueueEntry.instToString.match_1 | Aesop.Tree.UnsafeQueue | (motive : Aesop.UnsafeQueueEntry → Sort u_1) →
(x : Aesop.UnsafeQueueEntry) →
((r : Aesop.IndexMatchResult Aesop.UnsafeRule) → motive (Aesop.UnsafeQueueEntry.unsafeRule r)) →
((r : Aesop.PostponedSafeRule) → motive (Aesop.UnsafeQueueEntry.postponedSafeRule r)) → motive x | null | false |
ContinuousMultilinearMap.smulRightL._proof_2 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_4) {ι : Type u_1} (E : ι → Type u_2) (G : Type u_3) [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E... | null | false |
modelWithCornersEuclideanQuadrant | Mathlib.Geometry.Manifold.Instances.Real | (n : ℕ) → ModelWithCorners ℝ (EuclideanSpace ℝ (Fin n)) (EuclideanQuadrant n) | Definition of the model with corners `(EuclideanSpace ℝ (Fin n), EuclideanQuadrant n)`, used as a
model for manifolds with corners | true |
CategoryTheory.EnrichedCat.comp_whiskerRight | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₁} [inst_3 : CategoryTheory.EnrichedCategory V D]
{E : Type u₂} [inst_4 : CategoryTheory.EnrichedCategory V E] {F G H : CategoryTheory.Enriched... | null | true |
ModularForm.trace | Mathlib.NumberTheory.ModularForms.NormTrace | {𝒢 : Subgroup (GL (Fin 2) ℝ)} →
(ℋ : Subgroup (GL (Fin 2) ℝ)) →
{F : Type u_1} →
F →
[inst : FunLike F UpperHalfPlane ℂ] →
{k : ℤ} → [𝒢.IsFiniteRelIndex ℋ] → [ModularFormClass F 𝒢 k] → ModularForm ℋ k | The trace of a modular form, as a modular form. | true |
equivShrink_le_equivShrink._simp_1 | Mathlib.Order.Shrink | ∀ {α : Type u_1} [inst : Small.{u, u_1} α] [inst_1 : Preorder α] {x y : α},
((equivShrink α) x ≤ (equivShrink α) y) = (x ≤ y) | null | false |
OrderDual.instMulOneClass | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [MulOneClass α] → MulOneClass αᵒᵈ | null | true |
CompleteOrthogonalIdempotents.ringEquivOfIsMulCentral._proof_3 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {I : Type u_2} {e : I → R} [inst : Semiring R] (r : R) (i : I), ∃ y, e i * y * e i = e i * r * e i | null | false |
AddMonoidHom.eqLocusM | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_1} →
{N : Type u_2} → [inst : AddZeroClass M] → [inst_1 : AddZeroClass N] → (M →+ N) → (M →+ N) → AddSubmonoid M | The additive submonoid of elements `x : M` such that `f x = g x` | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs.0.CategoryTheory.IsPushout.inr_isoIsPushout_inv._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) | null | false |
Mathlib.Tactic.Ring.Common.evalMul₁._sunfold | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
{a b : Q(«$α»)} →
Mathli... | null | false |
Set.inter_sub_union_subset_union | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Sub α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ∩ s₂ - (t₁ ∪ t₂) ⊆ s₁ - t₁ ∪ (s₂ - t₂) | null | true |
CommMonCat.forget₂_map_ofHom | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : Type u} [inst : CommMonoid X] [inst_1 : CommMonoid Y] (f : X →* Y),
(CategoryTheory.forget₂ CommMonCat MonCat).map (CommMonCat.ofHom f) = MonCat.ofHom f | null | true |
Path.Homotopic.Quotient.trans_assoc | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ x₂ x₃ : X} (γ₀ : Path.Homotopic.Quotient x₀ x₁)
(γ₁ : Path.Homotopic.Quotient x₁ x₂) (γ₂ : Path.Homotopic.Quotient x₂ x₃),
(γ₀.trans γ₁).trans γ₂ = γ₀.trans (γ₁.trans γ₂) | null | true |
RelIso.toRelEmbedding | Mathlib.Order.RelIso.Basic | {α : Type u_1} → {β : Type u_2} → {r : α → α → Prop} → {s : β → β → Prop} → r ≃r s → r ↪r s | Convert a `RelIso` to a `RelEmbedding`. This function is also available as a coercion
but often it is easier to write `f.toRelEmbedding` than to write explicitly `r` and `s`
in the target type. | true |
_private.Mathlib.Analysis.Complex.OpenMapping.0.AnalyticOnNhd.eq_const_of_re_eq_const._proof_1_2 | Mathlib.Analysis.Complex.OpenMapping | ∀ {f : ℂ → ℂ} {U : Set ℂ} {c₀ : ℝ},
AnalyticOnNhd ℂ f U → (∀ x ∈ U, (f x).re = c₀) → IsOpen U → IsConnected U → ∀ z₀ ∈ U, (¬∃ c, ∀ x ∈ U, f x = c) → False | null | false |
Lean.Doc.Part.below_2 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{p : Type w} →
{motive_1 : Lean.Doc.Part i b p → Sort u_1} →
{motive_2 : Array (Lean.Doc.Part i b p) → Sort u_1} →
{motive_3 : List (Lean.Doc.Part i b p) → Sort u_1} →
List (Lean.Doc.Part i b p) → Sort (max ((max (max u v) w) + 1) u_1) | null | false |
LawfulBitraversable.bitraverse_eq_bimap_id' | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} {inst : Bitraversable t} [self : LawfulBitraversable t] {α α' β β' : Type u}
(f : α → β) (f' : α' → β'), bitraverse (pure ∘ f) (pure ∘ f') = pure ∘ bimap f f' | null | true |
MeasureTheory.setToFun_mono_left' | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {G'' : Type u_8} [inst_2 : NormedAddCommGroup G''] [inst_3 : PartialOrder G'']
[IsOrderedAddMonoid G''] [inst_5 : NormedSpace ℝ G''] [OrderClosedTopology G''] {T T' : Set α ... | null | true |
PNat.instSuccAddOrder | Mathlib.Data.PNat.Order | SuccAddOrder ℕ+ | null | true |
Array.size_filterMap_lt_size_iff_exists | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Option β},
(Array.filterMap f xs).size < xs.size ↔ ∃ x, ∃ (_ : x ∈ xs), f x = none | null | true |
Equiv.prodPEmpty | Mathlib.Logic.Equiv.Prod | (α : Type u_9) → α × PEmpty.{u_10 + 1} ≃ PEmpty.{u_11} | `PEmpty` type is a right absorbing element for type product up to an equivalence. | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.weierstrassPExcept_eq_tsum._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Array.lt_size_left_of_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {i : ℕ} {as : Array α} {bs : Array β},
i < (Array.zipWith f as bs).size → i < as.size | null | true |
contMDiff_zero_iff | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | zero-smoothness is equivalent to continuity. | true |
_private.Init.Data.Vector.OfFn.0.Vector.map_ofFn._simp_1_1 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} {n : ℕ} {xs ys : Vector α n}, (xs = ys) = (xs.toArray = ys.toArray) | null | false |
UniformSpaceCat.instFunLike | Mathlib.Topology.Category.UniformSpace | (X : UniformSpaceCat) → (Y : UniformSpaceCat) → FunLike { f // UniformContinuous f } X.carrier Y.carrier | null | true |
Std.DTreeMap.Internal.Impl.get?_erase_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k : α}, (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.get? k = none | null | true |
Nat.log_le_clog._simp_1 | Mathlib.Data.Nat.Log | ∀ (b n : ℕ), (Nat.log b n ≤ Nat.clog b n) = True | null | false |
dvd_differentIdeal_iff | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {B : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[IsDedekindDomain A] [inst_5 : IsDedekindDomain B] [inst_6 : Module.IsTorsionFree A B] [Module.Finite A B]
[Algebra.IsSeparable (FractionRing A) (FractionRing B)] {P : Ideal B} [inst_9 : P.IsPrime]... | A prime divides the different ideal iff it is ramified. | true |
IsPicardLindelof.exists_forall_mem_closedBall_eq_hasDerivWithinAt_lipschitzOnWith | Mathlib.Analysis.ODE.ExistUnique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E → E}
{tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E} {a r L K : NNReal},
IsPicardLindelof f t₀ x₀ a r L K →
∃ α,
(∀ x ∈ Metric.closedBall x₀ ↑r,
α x ↑t₀ = x ∧ ∀ t ∈ Set.Icc tmin tmax, HasD... | **Picard-Lindelöf (Cauchy-Lipschitz) theorem**, differential form. This version shows the
existence of a local flow and that it is Lipschitz continuous in the initial point. | true |
WType.toList.match_1 | Mathlib.Data.W.Constructions | (γ : Type u_1) →
(motive : WType (WType.Listβ γ) → Sort u_2) →
(x : WType (WType.Listβ γ)) →
((f : WType.Listβ γ WType.Listα.nil → WType (WType.Listβ γ)) → motive (WType.mk WType.Listα.nil f)) →
((hd : γ) →
(f : WType.Listβ γ (WType.Listα.cons hd) → WType (WType.Listβ γ)) →
... | null | false |
Ordnode.rec.eq._@.Mathlib.Data.Ordmap.Ordnode.1389437611._hygCtx._hyg.4 | Mathlib.Data.Ordmap.Ordnode | @Ordnode.rec = @Ordnode.rec✝ | null | false |
_private.Mathlib.LinearAlgebra.Complex.Module.0.mem_unitary_iff_isStarNormal_and_realPart_sq_add_imaginaryPart_sq_eq_one._simp_1_5 | Mathlib.LinearAlgebra.Complex.Module | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | null | false |
_private.Aesop.Util.Basic.0.Aesop.filterTrieM.go.match_3 | Aesop.Util.Basic | {α : Type} →
(motive : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α → Sort u_1) →
(x : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) →
((key : Lean.Meta.DiscrTree.Key) → (t : Lean.Meta.DiscrTree.Trie α) → motive (key, t)) → motive x | null | false |
Array.reverse_pmap | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} {f : (a : α) → P a → β} {xs : Array α} (H : ∀ a ∈ xs, P a),
(Array.pmap f xs H).reverse = Array.pmap f xs.reverse ⋯ | null | true |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.coe_auxContinuousLinearEquiv | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {𝕜 : Type u_1} {V : Type u_2} {W : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] [inst_4 : NormedAddCommGroup W]
[inst_5 : InnerProductSpace 𝕜 W] [inst_6 : CompleteSpace W] (e : V ≃L[𝕜] W) {α α' : 𝕜} (hα : α ≠ 0)
(hα2 : α' * α' = α⁻... | null | true |
CategoryTheory.CartesianMonoidalCategory.prodComparisonNatTrans | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{D : Type u₁} →
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
... | The product comparison morphism from `F(A ⊗ -)` to `FA ⊗ F-`, whose components are given by
`prodComparison`. | true |
AddCommGroup.toAddGroup | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : AddCommGroup G] → AddGroup G | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.Bicone.IsBilimit.ext.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_1} {C : Type u_3} {inst : CategoryTheory.Category.{u_2, u_3} C}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} {F : J → C} {B : CategoryTheory.Limits.Bicone F}
(motive : B.IsBilimit → Prop) (h : B.IsBilimit),
(∀ (isLimit : CategoryTheory.Limits.IsLimit B.toCone) (isColimit : CategoryTheory.Limi... | null | false |
Aesop.ElabM.Context.casesOn | Aesop.ElabM | {motive : Aesop.ElabM.Context → Sort u} →
(t : Aesop.ElabM.Context) →
((parsePriorities : Bool) → (goal : Lean.MVarId) → motive { parsePriorities := parsePriorities, goal := goal }) →
motive t | null | false |
Lean.JsonRpc.MessageKind._sizeOf_1 | Lean.Data.JsonRpc | Lean.JsonRpc.MessageKind → ℕ | null | false |
Lean.MessageData.withContext | Lean.Message | Lean.MessageDataContext → Lean.MessageData → Lean.MessageData | `withContext ctx d` specifies the pretty printing context `(env, mctx, lctx, opts)` for the nested expressions in `d`. | true |
CategoryTheory.Mon.hom_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Mon C) [inst_3 : CategoryTheory.IsCommMonObj M.X],
CategoryTheory.MonObj.one.hom = CategoryTheory.MonObj.one | null | true |
FiberBundle.extChartAt_target | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_4 : (x : B) → TopologicalSpace (E x)] {EB : Type u_7} [inst_5 : NormedAddCommGroup EB]
[inst_... | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.mkOfLe.match_1.splitter | Mathlib.AlgebraicTopology.SimplexCategory.Basic | (motive : Fin (1 + 1) → Sort u_1) → (x : Fin (1 + 1)) → (Unit → motive 0) → (Unit → motive 1) → motive x | null | true |
Convexity.StdSimplex.casesOn | Mathlib.Geometry.Convex.ConvexSpace.Defs | {R : Type u} →
[inst : LE R] →
[inst_1 : AddCommMonoid R] →
[inst_2 : One R] →
{M : Type v} →
{motive : Convexity.StdSimplex R M → Sort u_1} →
(t : Convexity.StdSimplex R M) →
((weights : M →₀ R) →
(nonneg : 0 ≤ weights) →
(to... | null | false |
Lean.Lsp.WaitForILeans | Lean.Data.Lsp.Extra | Type | null | true |
WithAbs.instField._proof_8 | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Field R]
(v : AbsoluteValue R S), autoParam (∀ (q : ℚ≥0), ↑q = ↑q.num / ↑q.den) DivisionRing.nnratCast_def._autoParam | null | false |
Real.commRing._proof_11 | Mathlib.Data.Real.Basic | ∀ (n : ℕ) (x : ℝ), npowRec (n + 1) x = npowRec n x * x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.