name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nucleus.mem_toSublocale | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {n : Nucleus X} {x : X}, x ∈ n.toSublocale ↔ ∃ y, n y = x | null | true |
_private.Init.Data.Array.Lemmas.0.Array.range.eq_1 | Init.Data.Array.Lemmas | ∀ (n : ℕ), Array.range n = Array.ofFn fun i => ↑i | null | true |
CategoryTheory.LaxFunctor.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{P : Sort u} →
{toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C} →
{mapId :
(a : B) →
CategoryTheory.CategoryStruct.id (toPrelaxF... | null | false |
ULift.div | Mathlib.Algebra.Group.ULift | {α : Type u} → [Div α] → Div (ULift.{u_1, u} α) | null | true |
List.merge_of_le | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} {xs ys : List α},
(∀ (a b : α), a ∈ xs → b ∈ ys → le a b = true) → xs.merge ys le = xs ++ ys | null | true |
Std.TreeMap.Raw.Equiv.getEntryLT?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α},
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getEntryLT? k = t₂.getEntryLT? k | null | true |
LinearIsometryEquiv.symm_conjStarAlgEquiv | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (e : H ≃ₗᵢ[𝕜] K), e.conjStarAlgEquiv.symm = e.symm.conjStarAlg... | null | true |
CategoryTheory.Functor.prod._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{u_7, u_1} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_3, u_5} B] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_8, u_2} C]
{D : Type u_6} [inst_3 : CategoryTheory.Category.{u_4, u_6} D] (F : CategoryTheory.Functor A B)
(G : CategoryTheory.Functor C... | null | false |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map₂_comp | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
self.map₂ (CategoryTheory.CategoryStruct.comp η θ) = CategoryTheory.CategoryStruct.comp (self.map₂ η)... | null | true |
Lean.Parser.Tactic.quot | Lean.Parser.Term | Lean.Parser.Parser | null | true |
MeasureTheory.lintegral_lintegral_symm | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] ⦃f : α → β → ENNReal⦄,
AEMeasurable (Function.uncurry f) (μ.prod ν) →
∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (... | The reversed version of **Tonelli's Theorem** (symmetric version). In this version `f` is in
curried form, which makes it easier for the elaborator to figure out `f` automatically. | true |
String.toInt?_toSlice | Std.Data.String.ToInt | ∀ {s : String}, s.toSlice.toInt? = s.toInt? | null | true |
CompactlySupportedContinuousMap._sizeOf_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_5} →
{β : Type u_6} →
{inst : TopologicalSpace α} →
{inst_1 : Zero β} →
{inst_2 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → CompactlySupportedContinuousMap α β → ℕ | null | false |
Mathlib.Tactic.BicategoryCoherence.LiftHom.recOn | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom f → Sort u_1} →
(t : Mathlib.Tactic.BicategoryCoherence.LiftHom f) →
((lift : CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicateg... | null | false |
ContinuousMultilinearMap.currySumEquiv._proof_10 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G']
[inst_2 : NormedSpace 𝕜 G'], SMulCommClass 𝕜 𝕜 G' | null | false |
StarMemClass.rec | Mathlib.Algebra.Star.Basic | {S : Type u_1} →
{R : Type u_2} →
[inst : Star R] →
[inst_1 : SetLike S R] →
{motive : StarMemClass S R → Sort u} →
((star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s) → motive ⋯) → (t : StarMemClass S R) → motive t | null | false |
Std.IterM.stepSize | Std.Data.Iterators.Combinators.Monadic.StepSize | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] → [Std.IteratorAccess α m] → [Monad m] → Std.IterM m β → ℕ → Std.IterM m β | Produces an iterator that emits one value of `it`, then drops `n - 1` elements, then emits another
value, and so on. In other words, it emits every `n`-th value of `it`, starting with the first one.
If `n = 0`, the iterator behaves like for `n = 1`: It emits all values of `it`.
**Marble diagram:**
```
it ... | true |
CommRingCat.limitCommRing._aux_36 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J CommRingCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections] →
CommRing ↑(F.comp (CategoryTheory.forget CommRingCat)).sections →
ℤ →
(Cate... | null | false |
Std.TreeSet.Raw.toList_roc | Std.Data.TreeSet.Raw.Slice | ∀ {α : Type u} (cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw.toList_roc._auto_1) [Std.TransCmp cmp]
{t : Std.TreeSet.Raw α cmp},
t.WF →
∀ {lowerBound upperBound : α},
Std.Slice.toList (Std.Roc.Sliceable.mkSlice t lowerBound<...=upperBound) =
List.filter (fun e => decide ((cmp e lowerBound).i... | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._proof_1_6 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (y : BitVec w), ¬2 ^ w - 1 - y.toNat < 2 ^ w → False | null | false |
contMDiffOn_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 on a set is equivalent to continuity on this set. | true |
LibraryNote.foundational_algebra_order_theory | Mathlib.Data.Nat.Init | Batteries.Util.LibraryNote | Batteries has a home-baked development of the algebraic and order-theoretic theory of `ℕ` and `ℤ`
which, in particular, is not typeclass-mediated. This is useful to set up the algebra and finiteness
libraries in mathlib (naturals and integers show up as indices/offsets in lists, cardinality in
finsets, powers in groups... | true |
Fintype | Mathlib.Data.Fintype.Defs | Type u_4 → Type u_4 | `Fintype α` means that `α` is finite, i.e. there are only
finitely many distinct elements of type `α`. The evidence of this
is a finset `elems` (a list up to permutation without duplicates),
together with a proof that everything of type `α` is in the list. | true |
ContMDiffVAdd.mk._flat_ctor | 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}
[inst_4 : TopologicalSpace H'] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : Normed... | null | false |
Subalgebra.val._proof_5 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (x : R), ↑((algebraMap R ↥S) x) = ↑((algebraMap R ↥S) x) | null | false |
ContinuousMap.Homotopy.extend_one | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(F : f₀.Homotopy f₁), F.extend 1 = f₁ | null | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.isType2Type._sparseCasesOn_2 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
MeasureTheory.exists_subordinate_pairwise_disjoint | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {ι : Type u_1} {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Countable ι] {s : ι → Set α},
(∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) →
Pairwise (Function.onFun (MeasureTheory.AEDisjoint μ) s) →
∃ t,
(∀ (i : ι), t i ⊆ s i) ∧
(∀ (i : ι), s i =ᵐ[μ] t i) ∧... | If `sᵢ` is a countable family of (null) measurable pairwise `μ`-a.e. disjoint sets, then there
exists a subordinate family `tᵢ ⊆ sᵢ` of measurable pairwise disjoint sets such that
`tᵢ =ᵐ[μ] sᵢ`. | true |
Rat.instNormedField | Mathlib.Analysis.Normed.Field.Lemmas | NormedField ℚ | null | true |
RightCancelMonoid.Nat.card_submonoidPowers | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : RightCancelMonoid G] {a : G}, Nat.card ↥(Submonoid.powers a) = orderOf a | See also `orderOf_eq_card_powers`. | true |
SimplexCategory.toTopHomeo_symm_naturality_apply | Mathlib.AlgebraicTopology.SimplicialSet.TopAdj | ∀ {n m : SimplexCategory} (f : n ⟶ m) (x : ↑(stdSimplex ℝ (Fin (n.len + 1)))),
m.toTopHomeo.symm (stdSimplex.map (⇑(CategoryTheory.ConcreteCategory.hom f)) x) =
(CategoryTheory.ConcreteCategory.hom (SSet.toTop.map (SSet.stdSimplex.map f))) (n.toTopHomeo.symm x) | null | true |
_private.Mathlib.Algebra.Lie.Ideal.0.LieIdeal.comap._simp_2 | Mathlib.Algebra.Lie.Ideal | ∀ {M : Type u_1} [inst : AddZeroClass M] {s : AddSubmonoid M} {x : M}, (x ∈ s.toAddSubsemigroup) = (x ∈ s) | null | false |
sqrt_one_add_norm_sq_le | Mathlib.Analysis.SpecialFunctions.JapaneseBracket | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (x : E), √(1 + ‖x‖ ^ 2) ≤ 1 + ‖x‖ | null | true |
Mul.recOn | Init.Prelude | {α : Type u} → {motive : Mul α → Sort u_1} → (t : Mul α) → ((mul : α → α → α) → motive { mul := mul }) → motive t | null | false |
SubmoduleClass.module'._proof_2 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_4} {M : Type u_1} {T : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Semiring S] [inst_3 : Module R M] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M]
[inst_7 : SetLike T M] [inst_8 : SMulMemClass T R M] (t : T) (x : ↥t), 1 • x = x | null | false |
instAddUInt32 | Init.Data.UInt.BasicAux | Add UInt32 | null | true |
IsOpen.convexHull | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
[ZeroLEOneClass 𝕜] {s : Set E}, IsOpen s → IsOpen ((convexHull 𝕜) s) | null | true |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.Subgroup.normal_iff_map_conj_eq._simp_1_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.Normal = (Subgroup.normalizer ↑H = ⊤) | null | false |
CategoryTheory.GrothendieckTopology.Point.over | Mathlib.CategoryTheory.Sites.Point.Over | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
[CategoryTheory.LocallySmall.{w, v, u} C] → (Φ : J.Point) → {X : C} → Φ.fiber.obj X → (J.over X).Point | Given a point `Φ` of a site `(C, J)`, an object `X : C`, and `x : Φ.fiber.obj X`,
this is the point of the site `(Over X, J.over X)` such that the fiber of
an object of `Over X` corresponding to a morphism `f : Y ⟶ X` identifies
to subtype of `Φ.fiber.obj Y` consisting of elements `y` such
that `Φ.fiber.map f y = x`. | true |
_private.Mathlib.NumberTheory.Divisors.0.Nat.pairwise_divisorsAntidiagonalList_snd._simp_1_4 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
CategoryTheory.GrothendieckTopology.Point.skyscraperSheafAdjunction_homEquiv_apply_val | Mathlib.CategoryTheory.Sites.Point.Skyscraper | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
{A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
[inst_3 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A] {F : CategoryTheory.Sheaf ... | **Alias** of `CategoryTheory.GrothendieckTopology.Point.skyscraperSheafAdjunction_homEquiv_apply_hom`. | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact.0.AlgebraicGeometry.instHasAffinePropertyQuasiCompactCompactSpaceCarrierCarrierCommRingCat._simp_2 | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s = CompactSpace ↑s | null | false |
div_right_injective | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {b : G}, Function.Injective fun a => b / a | null | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow._proof_1_3 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n m : ℕ}, m < n → ¬m ≤ n → False | null | false |
Prod.mk_le_mk._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {a₁ a₂ : α} {b₁ b₂ : β},
((a₁, b₁) ≤ (a₂, b₂)) = (a₁ ≤ a₂ ∧ b₁ ≤ b₂) | null | false |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups.0.alternatingGroup.exists_mem_stabilizer_smul_eq._proof_1_3 | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Set α},
∀ a ∈ t, ∀ b ∈ t, ∀ c ∈ t, ∀ ⦃b_1 : α⦄, b_1 ∈ t → (⇑(Equiv.swap c a) ∘ ⇑(Equiv.swap a b)) b_1 ∈ t | null | false |
USize.lt_of_le_of_lt | Init.Data.UInt.Lemmas | ∀ {a b c : USize}, a ≤ b → b < c → a < c | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt32.ofNat_mul._simp_1_1 | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt32), (UInt32.ofNat a = b) = (a % 2 ^ 32 = b.toNat) | null | false |
Lean.FileMap.lineStart | Lean.Data.Position | Lean.FileMap → ℕ → String.Pos.Raw | Returns the position of the start of (1-based) line `line`.
This gives the same result as `map.ofPosition ⟨line, 0⟩`, but is more efficient.
| true |
SimpleGraph.isNIndepSet_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) (n : ℕ) (s : Finset α), G.IsNIndepSet n s ↔ G.IsIndepSet ↑s ∧ s.card = n | null | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_natAdd_Icc._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
CategoryTheory.Functor.LaxMonoidal.μ_whiskerRight_comp_μ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {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 D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
F.obj (Category... | null | true |
Nat.gcd_sub_right_right_of_dvd | Init.Data.Nat.Gcd | ∀ {m k : ℕ} (n : ℕ), k ≤ m → n ∣ k → n.gcd (m - k) = n.gcd m | null | true |
FundamentalGroupoid.instIsEmpty | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (X : Type u_3) [IsEmpty X], IsEmpty (FundamentalGroupoid X) | null | true |
CategoryTheory.monoidalCategoryMop._proof_11 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(W X Y Z : Cᴹᵒᵖ),
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z.unmop
(CategoryTheory.MonoidalCategoryStruct.associator Y.unmop X.unmop W.unmop).... | null | false |
ZSpan.fract_eq_self | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] {b : Module.Basis ι K E} [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] {x : E}, ZSpan.fract b x = x ↔ x ∈ ZSpan.fundamentalDomain b | null | true |
signedDist_vadd_right_swap | Mathlib.Geometry.Euclidean.SignedDist | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v w : V) (p q : P), ((signedDist v) p) (w +ᵥ q) = ((signedDist v) (-w +ᵥ p)) q | null | true |
CategoryTheory.Lax.OplaxTrans.Hom._sizeOf_1 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.LaxFunctor B C} →
{η θ : F ⟶ G} → [SizeOf B] → [SizeOf C] → CategoryTheory.Lax.OplaxTrans.Hom η θ → ℕ | null | false |
hasFDerivAt_inv | Mathlib.Analysis.Calculus.Deriv.Inv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜},
x ≠ 0 → HasFDerivAt (fun x => x⁻¹) (ContinuousLinearMap.toSpanSingleton 𝕜 (-(x ^ 2)⁻¹)) x | null | true |
groupHomology.inhomogeneousChains.d._proof_4 | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (n : ℕ),
SMulCommClass k k ((Fin n → G) →₀ ↑A) | null | false |
DenselyOrdered.rec | Mathlib.Order.Basic | {α : Type u_5} →
[inst : LT α] →
{motive : DenselyOrdered α → Sort u} →
((dense : ∀ (a₁ a₂ : α), a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂) → motive ⋯) → (t : DenselyOrdered α) → motive t | null | false |
instDecidableIsValidUTF8 | Init.Data.String.Basic | {b : ByteArray} → Decidable b.IsValidUTF8 | null | true |
Matroid.IsBasis'.eRk_eq_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis' I X → M.eRk X = I.encard | null | true |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Name.fromComponents.go._unsafe_rec | Mathlib.Lean.Expr.Basic | Lean.Name → List Lean.Name → Lean.Name | null | false |
Turing.ToPartrec.Cfg.ctorIdx | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Cfg → ℕ | null | false |
AddOpposite.coe_symm_opAddEquiv | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} [inst : AddCommMonoid M], ⇑AddOpposite.opAddEquiv.symm = AddOpposite.unop | null | true |
LocalSubring.exists_le_valuationSubring | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_3} [inst : Field K] (A : LocalSubring K), ∃ B, A ≤ B.toLocalSubring | [Stacks Tag 00IA](https://stacks.math.columbia.edu/tag/00IA) | true |
Nat.shiftLeft'._unsafe_rec | Mathlib.Data.Nat.Bits | Bool → ℕ → ℕ → ℕ | null | false |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_iff_le_and_ne._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x ≤ y) = (x.toInt ≤ y.toInt) | null | false |
AddMonCat.forget_createsLimit._proof_6 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget AddMonCat))) (t : CategoryTheory.Limits.IsLimit c)
(this : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections)
(x : Cate... | null | false |
Complex.tan | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ | The complex tangent function, defined as `sin z / cos z` | true |
isMinOn_Iic_of_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b c : ℝ},
ContinuousAt f b →
ContinuousAt f c →
DifferentiableOn ℝ f (Set.Iio b) →
DifferentiableOn ℝ f (Set.Ioo b c) →
(∀ x ∈ Set.Iio b, deriv f x ≤ 0) → (∀ x ∈ Set.Ioo b c, 0 ≤ deriv f x) → IsMinOn f (Set.Iic c) b | Suppose `f : ℝ → ℝ` is continuous at `b` and `c`, the derivative `f'` is nonpositive on
`Iio b` and nonnegative on `Ioo b c`. Then `f` attains its minimum on `Iic c` at `b`. | true |
Mathlib.Tactic.BicategoryLike.AtomIso.mk.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | ∀ (e : Lean.Expr) (src tgt : Mathlib.Tactic.BicategoryLike.Mor₁),
sizeOf { e := e, src := src, tgt := tgt } = 1 + sizeOf e + sizeOf src + sizeOf tgt | null | true |
CategoryTheory.Bicategory.RightLift.mk | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : b ⟶ a} →
{g : c ⟶ a} →
(h : c ⟶ b) → (CategoryTheory.CategoryStruct.comp h f ⟶ g) → CategoryTheory.Bicategory.RightLift f g | Construct a right lift from a 1-morphism and a 2-morphism. | true |
Submodule.mem_adjoint_iff | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(g : Submodule 𝕜 (E × F)) (x : F × E),
x ∈ g.adjoint ↔ ∀ (a : E) (b : F), (a, b) ∈ g → inner 𝕜 b x.1 - inner 𝕜 a... | null | true |
ContinuousLinearMap.opNorm_linearIsometryEquiv_comp | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜₁ : Type u_2} {𝕜₂ : Type u_3} {𝕜₃ : Type u_4} {E : Type u_5} {F : Type u_6} {G : Type u_8}
[inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜₁] [inst_4 : NormedSpace 𝕜₁ E] [inst_5 : NontriviallyNormedField 𝕜₂]
[inst_6 : Norme... | Postcomposition with a linear isometry preserves the operator norm. | true |
CategoryTheory.Functor.pointwiseLeftKanExtensionCompIsoOfPreserves_fac_app | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B... | null | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.termProj | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.ParserDescr | `Proj` as a locally ringed space | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_12 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
↑j < ↑i → ¬↑k + 1 < ↑j → ↑k < ↑j → ¬↑k < ↑i → ↑k + 1 + 1 = ↑k + 1 | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic.0.tacticEval_simp | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | Lean.ParserDescr | null | true |
Finset.sup_eq_bot_of_isEmpty | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] [IsEmpty β] (f : β → α) (S : Finset β),
S.sup f = ⊥ | null | true |
QuasiconcaveOn.convex_gt | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconcaveOn 𝕜 s f → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ r < f x} | null | true |
Nat.prod_divisors_prime_pow | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} [inst : CommMonoid α] {k p : ℕ} {f : ℕ → α},
Nat.Prime p → ∏ x ∈ (p ^ k).divisors, f x = ∏ x ∈ Finset.range (k + 1), f (p ^ x) | null | true |
IsPrimitiveRoot.idealQuotient_mk | Mathlib.NumberTheory.NumberField.Ideal.Basic | ∀ {K : Type u_1} [inst : Field K] {I : Ideal (NumberField.RingOfIntegers K)} [inst_1 : NumberField K] {n : ℕ} [NeZero n]
{ζ : NumberField.RingOfIntegers K},
IsPrimitiveRoot ζ n → Ideal.absNorm I ≠ 1 → (Ideal.absNorm I).Coprime n → IsPrimitiveRoot ((Ideal.Quotient.mk I) ζ) n | null | true |
Stream'.WSeq.ofList_cons | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (a : α) (l : List α), ↑(a :: l) = Stream'.WSeq.cons a ↑l | null | true |
_private.Mathlib.NumberTheory.Divisors.0.Int.mul_mem_zero_one_two_three_four_iff._simp_1_1 | Mathlib.NumberTheory.Divisors | ∀ {x y z : ℤ}, z ≠ 0 → (x * y = z) = ((x, y) ∈ z.divisorsAntidiag) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.IsStrictlyPositive.sqrt._proof_1_8 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A] [inst_5 : Algebra ℝ A]
[inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint], NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap.0.WeierstrassCurve.addSubMapCoeff._proof_13 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | (47 + 1).AtLeastTwo | null | false |
CompareReals.compareEquiv | Mathlib.Topology.UniformSpace.CompareReals | CompareReals.Bourbakiℝ ≃ᵤ ℝ | The uniform bijection between Bourbaki and Cauchy reals. | true |
Equiv.semilatticeInf | Mathlib.Order.Lattice | {α : Type u} → {β : Type v} → α ≃ β → [SemilatticeInf β] → SemilatticeInf α | Transfer `SemilatticeInf` across an `Equiv`. | true |
StrictMonoOn.add | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f g : β → α} {s : Set β}
[AddLeftStrictMono α] [AddRightStrictMono α],
StrictMonoOn f s → StrictMonoOn g s → StrictMonoOn (fun x => f x + g x) s | The sum of two strictly monotone functions is strictly monotone. | true |
Lean.Options.getInPattern | Lean.Data.Options | Lean.Options → Bool | null | true |
Submodule.mem_span_set | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : M}
{s : Set M}, m ∈ Submodule.span R s ↔ ∃ c, ↑c.support ⊆ s ∧ (c.sum fun mi r => r • mi) = m | An element `m ∈ M` is contained in the `R`-submodule spanned by a set `s ⊆ M`, if and only if
`m` can be written as a finite `R`-linear combination of elements of `s`.
The implementation uses `Finsupp.sum`. | true |
_private.Init.Data.Int.Gcd.0.Int.lcm_mul_right_dvd_mul_lcm._simp_1_1 | Init.Data.Int.Gcd | ∀ (k m n : ℕ), (k.lcm (m * n) ∣ k.lcm m * k.lcm n) = True | null | false |
MulOpposite.instCancelCommMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CancelCommMonoid α],
MulOpposite.instCancelCommMonoid = { toCommMonoid := MulOpposite.instCommMonoid, toIsLeftCancelMul := ⋯ } | null | true |
StandardEtalePair.instEtaleRing | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R), Algebra.Etale R P.Ring | null | true |
CategoryTheory.Equivalence.counitInv.eq_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D), e.counitInv = e.counitIso.inv | null | true |
MulSemiringActionHom.map_mul' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_10} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_12} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S]
(self : R →ₑ+*[φ] S) (x y : R), self.toFun (x * y) = self.toFun x * self.toFun y | The proposition that the function preserves multiplication | true |
_private.Mathlib.Algebra.MonoidAlgebra.Module.0.MonoidAlgebra.single_mem_span_single._simp_1_2 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {α : Type u_1} (R : Type u_5) [inst : Semiring R] [Nontrivial R] {a : α} {s : Set α},
((fun₀ | a => 1) ∈ Submodule.span R ((fun x => fun₀ | x => 1) '' s)) = (a ∈ s) | null | false |
AdicCompletion.AdicCauchySequence.instAddCommGroup._proof_4 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : AdicCompletion.AdicCauchySequence I M), ↑(-x) = ↑(-x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.