name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
isOpen_iff_generate_intervals._to_dual_1 | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [ts : TopologicalSpace α] [inst : Preorder α] [t : OrderTopology α] {s : Set α},
IsOpen s ↔ TopologicalSpace.GenerateOpen {s | ∃ a, s = Set.Iio a ∨ s = Set.Ioi a} s | null | false |
CategoryTheory.Subobject.instLattice._proof_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasImages C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] {B : C} (a b : CategoryTheory.Subobject B),
a ≤ SemilatticeSup.sup a b | null | false |
CategoryTheory.CatEnrichedOrdinary.instCategoryHom._proof_2 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {X Y : CategoryTheory.CatEnrichedOrdinary C}
{X_1 Y_1 : X ⟶ Y} (f : X_1 ⟶ Y_1), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X_1) f = f | null | false |
CategoryTheory.Abelian.LeftResolution.karoubi.π | Mathlib.Algebra.Homology.LeftResolution.Reduced | {A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{ι : CategoryTheory.Functor C A} →
(Λ : CategoryTheory.Abelian.LeftResolution ι) →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3... | Auxiliary definition for `LeftResolution.karoubi`. | true |
Inclusion.Interval.lt | Mathlib.Tactic.Inclusion.Extension.Interval | {α : Type u_1} → [inst : LT α] → [DecidableLT α] → Inclusion.Interval α → Inclusion.Interval α → Inclusion.IntervalBool | Check if `x < y` is implied (true or false) by `x ∈ I` and `y ∈ J`. | true |
HomologicalComplex.eval._proof_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (c : ComplexShape ι) (i : ι) (X : HomologicalComplex V c),
(CategoryTheory.CategoryStruct.id X).f i = CategoryTheory.CategoryStruct.id (X.X i) | null | false |
SimpleGraph.not_isCompleteMultipartite_iff_exists_isPathGraph3Compl | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u} {G : SimpleGraph α}, ¬G.IsCompleteMultipartite ↔ ∃ v w₁ w₂, G.IsPathGraph3Compl v w₁ w₂ | null | true |
Set.Subsingleton.countable | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Subsingleton → s.Countable | null | true |
Submodule.range_projectionL | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : Submodule R M} (h : Submodule.IsTopCompl p q), (↑(p.projectionL q h)).range = p | null | true |
QuadraticMap.Isometry.ofEq | Mathlib.LinearAlgebra.QuadraticForm.Isometry | {R : Type u_1} →
{M₁ : Type u_3} →
{N : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M₁] → [inst_4 : Module R N] → {Q₁ Q₂ : QuadraticMap R M₁ N} → Q₁ = Q₂ → Q₁ →qᵢ Q₂ | The identity isometry between equal quadratic forms. | true |
Equiv.Perm.apply_mem_support | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α}, f x ∈ f.support ↔ x ∈ f.support | null | true |
PeriodPair.derivWeierstrassPExcept_def | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair) (l₀ : ↥L.lattice) (z : ℂ),
L.derivWeierstrassPExcept (↑l₀) z = L.derivWeierstrassP z + 2 / (z - ↑l₀) ^ 3 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get!_empty._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 |
FreeAddMagma.length | Mathlib.Algebra.Free | {α : Type u} → FreeAddMagma α → ℕ | Length of an element of a free additive magma. | true |
ContDiffWithinAt.mul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {n : WithTop ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸]
[inst_4 : NormedAlgebra 𝕜 𝔸] {s : Set E} {f g : E → 𝔸},
ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n g s x → C... | The product of two `C^n` functions within a set at a point is `C^n` within this set
at this point. | true |
Finset.mem_attachFin._simp_1 | Mathlib.Data.Finset.Fin | ∀ {n : ℕ} {s : Finset ℕ} (h : ∀ m ∈ s, m < n) {a : Fin n}, (a ∈ s.attachFin h) = (↑a ∈ s) | null | false |
Lean.Compiler.LCNF.Code.isDecl | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Bool | null | true |
CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimIso._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete α) C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C), CategoryTheory.Limits.HasColimit F | null | false |
CategoryTheory.Sieve.functorPullback_monotone | Mathlib.CategoryTheory.Sites.Sieves.Functoriality | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (X : C), Monotone (CategoryTheory.Sieve.functorPullback F) | null | true |
exists_orderEmbedding_covby_of_forall_covby_finite | Mathlib.Order.KonigLemma | ∀ {α : Type u_1} [inst : PartialOrder α] [IsStronglyAtomic α] {b : α},
(∀ (a : α), {x | a ⋖ x}.Finite) → (Set.Ici b).Infinite → ∃ f, f 0 = b ∧ ∀ (i : ℕ), f i ⋖ f (i + 1) | The sequence given by Kőnig's lemma as an order embedding | true |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.aestronglyMeasurable_union_iff._simp_1_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {p : Bool → Prop}, (∀ (b : Bool), p b) = (p false ∧ p true) | null | false |
himp_inf_le | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, (a ⇨ b) ⊓ a ≤ b | `(p → q) ∧ p → q` | true |
isMulTorsionFree_iff_not_isOfFinOrder | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Group G], IsMulTorsionFree G ↔ ∀ ⦃a : G⦄, a ≠ 1 → ¬IsOfFinOrder a | null | true |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_58 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x : α) (xs : List α) (head : α) (tail : List α),
head :: tail = xs → ¬(head :: (tail ++ [x])).dropLast ++ [(head :: (tail ++ [x])).getLast ⋯].dropLast = [] | null | false |
Topology.IsLocallyConstructible.preimage_of_isOpenEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Topology.IsLocallyConstructible s → Topology.IsOpenEmbedding f → Topology.IsLocallyConstructible (f ⁻¹' s) | null | true |
CoalgCat.forget₂_obj | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u} [inst : CommRing R] (X : CoalgCat R),
(CategoryTheory.forget₂ (CoalgCat R) (ModuleCat R)).obj X = ↧↑X.toModuleCat | null | true |
Lean.Server.References.ParentDecl._sizeOf_inst | Lean.Server.References | SizeOf Lean.Server.References.ParentDecl | null | false |
toIocMod_eq_sub | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIocMod hp a b = toIocMod hp 0 (b - a) + a | null | true |
_private.Lean.Meta.Constructions.BRecOn.0.Lean.buildBelowMinorPremise.go._unsafe_rec | Lean.Meta.Constructions.BRecOn | Lean.Level → Array Lean.Expr → Array Lean.Expr → List Lean.Expr → Lean.MetaM Lean.Expr | null | false |
Std.Net.SocketAddressV4._sizeOf_1 | Std.Net.Addr | Std.Net.SocketAddressV4 → ℕ | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.sum_fin_Icc_eq_sum_nat_Icc._proof_1_6 | Mathlib.Algebra.BigOperators.Intervals | ∀ {α : Type u_1} [inst : AddCommMonoid α] {n : ℕ} (a b : Fin n) (f : Fin n → α),
∀ a_1 ∈ Finset.range n,
a_1 ∈ Finset.Icc ↑a ↑b →
(if h : a_1 < n then if ⟨a_1, h⟩ ∈ Finset.Icc a b then f ⟨a_1, h⟩ else 0 else 0) =
if h : a_1 < n then f ⟨a_1, h⟩ else 0 | null | false |
_private.Lean.Compiler.IR.LLVMBindings.0.Lean.LLVM.Context.mk.inj | Lean.Compiler.IR.LLVMBindings | ∀ {ptr ptr_1 : USize}, { ptr := ptr } = { ptr := ptr_1 } → ptr = ptr_1 | null | true |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.densityProcess_mono_kernel_left._simp_1_2 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {a b : ENNReal}, (a / b = ⊤) = (a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤) | null | false |
Turing.FinTM2.casesOn | Mathlib.Computability.TuringMachine.Computable | {motive : Turing.FinTM2 → Sort u} →
(t : Turing.FinTM2) →
({K : Type} →
[kDecidableEq : DecidableEq K] →
[kFin : Fintype K] →
(k₀ k₁ : K) →
(Γ : K → Type) →
(Λ : Type) →
(main : Λ) →
[ΛFin : Fintype Λ] →
... | null | false |
SimpleGraph.addCayley_insert_zero | Mathlib.Combinatorics.SimpleGraph.Cayley | ∀ {M : Type u_1} (s : Set M) [inst : AddZeroClass M], SimpleGraph.addCayley (insert 0 s) = SimpleGraph.addCayley s | null | true |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.abstractGroundMismatches?.goCore._sparseCasesOn_4 | Lean.Meta.Tactic.Grind.ProveEq | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
(Nat.hasNotBit 2048 t.ctorIdx → motive t) → motive t | null | false |
SpecializingMap.stableUnderSpecialization_range | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
SpecializingMap f → StableUnderSpecialization (Set.range f) | null | true |
OrderMonoidHom._sizeOf_inst | Mathlib.Algebra.Order.Hom.Monoid | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : MulOneClass α} → {inst_3 : MulOneClass β} → [SizeOf α] → [SizeOf β] → SizeOf (α →*o β) | null | false |
Module.finBasisOfFinrankEq | Mathlib.LinearAlgebra.Dimension.Free | (R : Type u) →
(M : Type v) →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[Module.Free R M] →
[StrongRankCondition R] → [Module.Finite R M] → {n : ℕ} → Module.finrank R M = n → Module.Basis (Fin n) R M | A rank `n` free module has a basis indexed by `Fin n`. | true |
LinearMap.toDistribMulActionHom | Mathlib.Algebra.Module.LinearMap.Defs | {R : Type u_1} →
{S : Type u_5} →
{M : Type u_8} →
{M₃ : Type u_11} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : Module R M] → [inst_5 : Module S M₃] → {σ : R →+* S} → (M →ₛₗ[σ... | The `DistribMulActionHom` underlying a `LinearMap`. | true |
Mathlib.Tactic.Algebra.Cache._sizeOf_inst | Mathlib.Tactic.Algebra.Basic | {u : Lean.Level} → {A : Q(Type u)} → (sA : Q(CommSemiring «$A»)) → SizeOf (Mathlib.Tactic.Algebra.Cache sA) | null | false |
_private.Mathlib.Algebra.Lie.Killing.0.LieAlgebra.killingForm_of_equiv_apply._simp_1_1 | Mathlib.Algebra.Lie.Killing | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (e : L ≃ₗ⁅R⁆ L') (x : L),
(LieAlgebra.ad R L') (e x) = e.toLinearEquiv.conj ((LieAlgebra.ad R L) x) | null | false |
CategoryTheory.Limits.colimitConstInitial | Mathlib.CategoryTheory.Limits.Shapes.Terminal | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{C : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasInitial C] →
CategoryTheory.Limits.colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) ≅ ⊥_ C | The colimit of the constant `⊥_ C` functor is `⊥_ C`. | true |
ContextFreeRule.reverse_injective | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {N : Type u_2}, Function.Injective ContextFreeRule.reverse | null | true |
Std.Iterators.Types.ULiftIterator.instIterator._proof_1 | Init.Data.Iterators.Combinators.Monadic.ULift | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {n : Type (max u_1 u_3) → Type u_4} {β : Type u_1}
{lift : ⦃γ : Type u_1⦄ → m γ → Std.Iterators.ULiftT n γ} [inst : Std.Iterator α m β]
(it : Std.IterM n (ULift.{u_3, u_1} β)) (__do_lift : ULift.{u_3, u_1} (Std.Shrink it.internalState.inner.Step)),
∃ step',
it.intern... | null | false |
MvPolynomial.finSuccEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) [inst : CommSemiring R] (n : ℕ) (p : MvPolynomial (Fin (n + 1)) R),
(MvPolynomial.finSuccEquiv R n) p =
(MvPolynomial.eval₂Hom (Polynomial.C.comp MvPolynomial.C) fun i =>
Fin.cases Polynomial.X (fun k => Polynomial.C (MvPolynomial.X k)) i)
p | null | true |
AddSubmonoid.zero_mem' | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_3} [inst : AddZeroClass M] (self : AddSubmonoid M), 0 ∈ self.carrier | An additive submonoid contains `0`. | true |
iInf_uniformity | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {ι : Sort u_2} {u : ι → UniformSpace α}, uniformity α = ⨅ i, uniformity α | null | true |
Std.LawfulOrderLeftLeaningMax.max_eq_left | Init.Data.Order.Classes | ∀ {α : Type u} {inst : Max α} {inst_1 : LE α} [self : Std.LawfulOrderLeftLeaningMax α] (a b : α), b ≤ a → a ⊔ b = a | null | true |
List.pairwise_cons_cons | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α},
List.Pairwise R (a :: b :: l) ↔ R a b ∧ List.Pairwise R (a :: l) ∧ List.Pairwise R (b :: l) | null | true |
Fin.forall_fin_zero._simp_1 | Init.Data.Fin.Lemmas | ∀ {p : Fin 0 → Prop}, (∀ (i : Fin 0), p i) = True | null | false |
Aesop.TreeRef.markSubtreeIrrelevant | Aesop.Tree.State | Aesop.TreeRef → BaseIO Unit | null | true |
Lean.Elab.Command.instMonadLogCommandElabM | Lean.Elab.Command | Lean.MonadLog Lean.Elab.Command.CommandElabM | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks.0.CategoryTheory.Limits.widePullbackShapeOpMap.match_1.eq_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type u_1) (motive : (x x_1 : CategoryTheory.Limits.WidePullbackShape J) → (x ⟶ x_1) → Sort u_2) (j : J)
(h_1 :
(X : CategoryTheory.Limits.WidePullbackShape J) → motive X X (CategoryTheory.Limits.WidePullbackShape.Hom.id X))
(h_2 : (j : J) → motive (some j) none (CategoryTheory.Limits.WidePullbackShape.Ho... | null | true |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.State.map | Lean.Meta.Sym.AlphaShareCommon | Lean.Meta.Sym.State✝ → Std.HashMap Lean.Meta.Sym.ExprPtr Lean.Expr | null | true |
List.isChain_of_isChain_map | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {β : Type u_2} {R : α → α → Prop} {S : β → β → Prop} (f : α → β),
(∀ (a b : α), S (f a) (f b) → R a b) → ∀ {l : List α}, List.IsChain S (List.map f l) → List.IsChain R l | null | true |
Matroid.isBase_restrict_iff._simp_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α},
autoParam (X ⊆ M.E) Matroid.isBase_restrict_iff._auto_1 → (M.restrict X).IsBase I = M.IsBasis I X | null | false |
Std.TreeMap.Raw.getElem_filterMap'._proof_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp}
[inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp] {f : α → β → Option γ} {k : α} {g : k ∈ Std.TreeMap.Raw.filterMap f t}
(h : t.WF), (f k t[k]).isSome = true | null | false |
Std.instAntisymmOfAsymm | Init.Data.Order.Lemmas | ∀ {α : Sort u_1} (r : α → α → Prop) [Std.Asymm r], Std.Antisymm r | null | true |
List.suffix_cons._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (a : α) (l : List α), (l <:+ a :: l) = True | null | false |
CategoryTheory.Pseudofunctor.StrongTrans.whiskerLeft_naturality_naturality_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{G H : CategoryTheory.Pseudofunctor B C} (θ : G ⟶ H) {a b : B} {a' : C} (f : a' ⟶ G.obj a) {g h : a ⟶ b} (β : g ⟶ h)
{Z : a' ⟶ H.obj b}
(h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStru... | null | true |
_private.Mathlib.Algebra.Group.Pointwise.Set.Basic.0.Set.one_mem_div_iff._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, (a / b = 1) = (a = b) | null | false |
Std.Internal.UV.UDP.Socket.bind | Std.Internal.UV.UDP | Std.Internal.UV.UDP.Socket → Std.Net.SocketAddress → IO Unit | Binds an UDP socket to a specific address. Address reuse is enabled to allow rebinding the
same address.
| true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.mk | Std.Time.Format.Basic | Option Std.Time.Year.Era →
Option Std.Time.Year.Offset →
Option Std.Time.Year.Offset →
Option Std.Time.Year.Offset →
Option (Sigma Std.Time.Day.Ordinal.OfYear) →
Option Std.Time.Month.Ordinal →
Option Std.Time.Month.Ordinal →
Option Std.Time.Day.Ordinal →
... | null | true |
Lean.getStructureCtor | Lean.Structure | Lean.Environment → Lean.Name → Lean.ConstructorVal | Gets the constructor of an inductive type that has exactly one constructor.
This is meant to be used with types that have had been registered as a structure by `registerStructure`,
but this is not checked.
Warning: this does not check that the type has no indices.
| true |
AffineIsometryEquiv.linearIsometryEquiv._proof_1 | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
LinearMap.mulRight_inj._simp_1 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_6} {A : Type u_7} [inst : Semiring R] [inst_1 : NonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {a b : A}, (LinearMap.mulRight R a = LinearMap.mulRight R b) = (a = b) | null | false |
_private.Mathlib.Analysis.Distribution.SchwartzSpace.Basic.0.SchwartzMap.seminormAux_le_bound | 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] (k n : ℕ) (f : SchwartzMap E F) {M : ℝ},
0 ≤ M → (∀ (x : E), ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ ≤ M) → SchwartzMap.seminormAux✝ k n f ≤ M | If one controls the norm of every `A x`, then one controls the norm of `A`. | true |
Task.spawn | Init.Core | {α : Type u} → (Unit → α) → optParam Task.Priority Task.Priority.default → Task α | `spawn fn : Task α` constructs and immediately launches a new task for
evaluating the function `fn () : α` asynchronously.
`prio`, if provided, is the priority of the task.
| true |
ContinuousLinearMap.flipₗᵢ._proof_7 | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ (𝕜 : Type u_1) (E : Type u_2) (Fₗ : Type u_4) (Gₗ : Type u_3) [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup Fₗ] [inst_2 : SeminormedAddCommGroup Gₗ] [inst_3 : NontriviallyNormedField 𝕜]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 Fₗ] [inst_6 : NormedSpace 𝕜 Gₗ] (f g : E →L[𝕜] Fₗ ... | null | false |
Int.sum_div | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_5} {s : Finset ι} {f : ι → ℤ} {n : ℤ}, (∀ i ∈ s, n ∣ f i) → (∑ i ∈ s, f i) / n = ∑ i ∈ s, f i / n | null | true |
OreLocalization.lift₂Expand_of | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_3}
[inst_2 : MulAction R X] {C : Sort u_2} {P : X → ↥S → X → ↥S → C}
{hP :
∀ (r₁ : X) (t₁ : R) (s₁ : ↥S) (ht₁ : t₁ * ↑s₁ ∈ S) (r₂ : X) (t₂ : R) (s₂ : ↥S) (ht₂ : t₂ * ↑s₂ ∈ S),
P r₁ s₁ r₂ s₂ = P (t₁ • r₁) ⟨... | null | true |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_4 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂}, (f.range = ⊤) = Function.Surjective ⇑... | null | false |
infIccOrderIsoIccSup._to_dual_3._proof_8 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : Lattice α] (a b : α) (x : ↑(Set.Icc (a ⊓ b) b)), ↑⟨a ⊔ ↑x, ⋯⟩ ⊓ b ∈ Set.Icc (a ⊓ b) b | null | false |
WithLp.pseudoMetricSpaceToProd._proof_1 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) [hp : Fact (1 ≤ p)] (α : Type u_1) (β : Type u_2) [inst : PseudoMetricSpace α]
[inst_1 : PseudoMetricSpace β], IsUniformInducing (WithLp.toLp p) | null | false |
CategoryTheory.Limits.CokernelCofork.isColimitTensor._proof_2 | Mathlib.CategoryTheory.Monoidal.Limits.Cokernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C] {X₁ Y₁ : C} {f₁ : X₁ ⟶ Y₁}
{c₁ : CategoryTheory.Limits.CokernelCofork f₁},
((CategoryTheory.MonoidalCategory.curriedTensor C).o... | null | false |
nhdsWithin_restrict | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} (s : Set α) {t : Set α},
a ∈ t → IsOpen t → nhdsWithin a s = nhdsWithin a (s ∩ t) | null | true |
_private.Init.Data.List.Impl.0.List.takeTR.go._unsafe_rec | Init.Data.List.Impl | {α : Type u_1} → List α → List α → ℕ → Array α → List α | null | false |
Set.preimage_mul_const_Ico₀ | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {c : G₀} (a b : G₀),
0 < c → (fun x => x * c) ⁻¹' Set.Ico a b = Set.Ico (a / c) (b / c) | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.δ_shift._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ (a m p q : ℤ), p + m = q → p + a + m = q + a | null | false |
instCommSemiringWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : CommSemiring α] (a b : WithConv (Matrix m n α)), a * b = b * a | null | false |
AddCommGrpCat.kernelIsoKer._proof_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {G H : AddCommGrpCat} (f : G ⟶ H), ⟨(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.kernel.ι f)) 0, ⋯⟩ = 0 | null | false |
Finsupp.sigmaFinsuppLEquivPiFinsupp_apply | Mathlib.LinearAlgebra.Finsupp.SumProd | ∀ (R : Type u_3) [inst : Semiring R] {η : Type u_4} [inst_1 : Fintype η] {M : Type u_6} {ιs : η → Type u_7}
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (f : (j : η) × ιs j →₀ M) (j : η) (i : ιs j),
((Finsupp.sigmaFinsuppLEquivPiFinsupp R) f j) i = f ⟨j, i⟩ | null | true |
Lean.Compiler.LCNF.FixedParams.AbsValue.val | Lean.Compiler.LCNF.FixedParams | ℕ → Lean.Compiler.LCNF.FixedParams.AbsValue | null | true |
Class.mem_wf | Mathlib.SetTheory.ZFC.Class | WellFounded fun x1 x2 => x1 ∈ x2 | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.kfSc_X₃ | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {C : Type u_1} {ι : Type u_2} {κ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Abelian C] [inst_2 : Preorder ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{c : ℤ → ComplexShape κ} {r₀ : ℤ} (data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀)
(r... | null | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.liftRel_congr._proof_1_2 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {ca ca' : Computation α} {cb cb' : Computation β},
ca.Equiv ca' → cb.Equiv cb' → (Computation.LiftRel R ca cb ↔ Computation.LiftRel R ca' cb') | null | false |
finTwoEquiv._proof_6 | Mathlib.Logic.Equiv.Defs | NeZero (1 + 1) | null | false |
TypeVec.repeatEq.match_1 | Mathlib.Data.TypeVec | (motive : (x : ℕ) → TypeVec.{u_1} x → Sort u_2) →
(x : ℕ) →
(x_1 : TypeVec.{u_1} x) →
((x : TypeVec.{u_1} 0) → motive 0 x) → ((n : ℕ) → (α : TypeVec.{u_1} n.succ) → motive n.succ α) → motive x x_1 | null | false |
NonUnitalSubsemiring.mem_map._simp_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] {f : R →ₙ+* S}
{s : NonUnitalSubsemiring R} {y : S}, (y ∈ NonUnitalSubsemiring.map f s) = ∃ x ∈ s, f x = y | null | false |
PartOrdEmb.Hom.noConfusionType | Mathlib.Order.Category.PartOrdEmb | Sort u_1 → {X Y : PartOrdEmb} → X.Hom Y → {X' Y' : PartOrdEmb} → X'.Hom Y' → Sort u_1 | null | false |
meromorphicAt_comp_add_const_iff_meromorphicAt | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x c : 𝕜} {f : 𝕜 → E}, MeromorphicAt (f ∘ fun x => x + c) x ↔ MeromorphicAt f (x + c) | `MeromorphicAt` is invariant under translation. | true |
Prime.coprime_iff_not_dvd | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u} [inst : CommRing R] [IsBezout R] [IsDomain R] {p n : R}, Prime p → (IsCoprime p n ↔ ¬p ∣ n) | null | true |
singleton_div_ball | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x y : E), {x} / Metric.ball y δ = Metric.ball (x / y) δ | null | true |
ENNReal.rpow_add_rpow_le_add | Mathlib.Analysis.MeanInequalitiesPow | ∀ {p : ℝ} (a b : ENNReal), 1 ≤ p → (a ^ p + b ^ p) ^ (1 / p) ≤ a + b | null | true |
Equiv.prodCongr_apply | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Type u_9} {α₂ : Type u_10} {β₁ : Type u_11} {β₂ : Type u_12} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂),
⇑(e₁.prodCongr e₂) = Prod.map ⇑e₁ ⇑e₂ | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.orthonormal_subsingleton_iff._simp_1_3 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a : M₀} {n : ℕ}
[ZeroLEOneClass M₀], 0 ≤ a → n ≠ 0 → (a ^ n = 1) = (a = 1) | null | false |
Filter.Realizer.comap | Mathlib.Data.Analysis.Filter | {α : Type u_1} → {β : Type u_2} → (m : α → β) → {f : Filter β} → f.Realizer → (Filter.comap m f).Realizer | Construct a realizer for `comap m f` given a realizer for `f` | true |
Ctop.Realizer.isClosed_iff | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (F : Ctop.Realizer α) {s : Set α},
IsClosed s ↔ ∀ (a : α), (∀ (b : F.σ), a ∈ F.F.f b → ∃ z, z ∈ F.F.f b ∩ s) → a ∈ s | null | true |
Std.Time.GenericFormat.mk.injEq | Std.Time.Format.Basic | ∀ {awareness : Std.Time.Awareness} (config : Std.Time.FormatConfig) (string : Std.Time.FormatString)
(config_1 : Std.Time.FormatConfig) (string_1 : Std.Time.FormatString),
({ config := config, string := string } = { config := config_1, string := string_1 }) =
(config = config_1 ∧ string = string_1) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.