name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
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 |
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 |
_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 |
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 |
DeltaGenerated.instLargeCategory._aux_5 | Mathlib.Topology.Category.DeltaGenerated | {X Y Z : DeltaGenerated} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
_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 |
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 |
TrivSqZeroExt.isNilpotent_inr | Mathlib.RingTheory.DualNumber | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] (x : M), IsNilpotent (TrivSqZeroExt.inr x) | null | true |
WithCStarModule.instNormedAddCommGroupProd._proof_18 | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
(x : WithCStarModule A (E × F)),
nhds x =
Filter.comap (Prod.mk x)
(Filter.comap (fun p => ((WithCStarModule.equiv A (E × F)) p.1, (WithCStarModule.equiv A (E × F)) p.2))
(uniformity (E × F... | null | false |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset._sparseCasesOn_1 | Lean.Meta.Sym.Offset | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSliceFrom_ne_startPos._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} (p : s.Pos), (p ≠ s.startPos) = (s.startPos < p) | null | false |
Summable.tsum_of_nat_of_neg | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{f : ℤ → G},
(Summable fun n => f ↑n) →
(Summable fun n => f (-↑n)) → ∑' (n : ℤ), f n = ∑' (n : ℕ), f ↑n + ∑' (n : ℕ), f (-↑n) - f 0 | null | true |
Lean.Elab.Command.CtorView.modifiers | Lean.Elab.MutualInductive | Lean.Elab.Command.CtorView → Lean.Elab.Modifiers | null | true |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.revMatchAt?_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt c pos pos' =
∃ (h : pos' ≠ s.startPos), pos = pos'.prev h ∧ (pos'.prev h).get ⋯ = c | null | false |
Algebra.IsAlgebraic.mk._flat_ctor | Mathlib.RingTheory.Algebraic.Defs | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
(∀ (x : A), IsAlgebraic R x) → Algebra.IsAlgebraic R A | null | false |
CategoryTheory.Functor.LaxMonoidal.ofBifunctor.bottomMapᵣ | Mathlib.CategoryTheory.Monoidal.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u_2} →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj
... | The bottom map in the right unitality square.
| true |
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.MvPolynomial.schwartz_zippel_sup_sum._simp_1_5 | Mathlib.Algebra.MvPolynomial.SchwartzZippel | ∀ {a b c d : Prop}, ((a ∧ b) ∧ c ∧ d) = ((a ∧ c) ∧ b ∧ d) | null | false |
NonUnitalStarAlgHom.mk | Mathlib.Algebra.Star.StarAlgHom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : DistribMulAction R B] →
... | null | true |
SSet.prodStdSimplex.pairingCore.IsType₂.simplex.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x x_1 : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N}
(e_x : x = x_1) (hx : SSet.prodStdSimplex.pairingCore.IsType₂ x) {d : ℕ} (hd : x.dim = d), hx.simplex hd = ⋯.simplex ⋯ | null | true |
Subarray.mkSlice_roi_eq_mkSlice_rco | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs lo<...* = Std.Rco.Sliceable.mkSlice xs (lo + 1)...Std.Slice.size xs | null | true |
LinearEquiv.cast_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_14} {M : ι → Type u_15} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] {i j : ι} (h : i = j) (a : M j), (LinearEquiv.cast h).symm a = cast ⋯ a | null | true |
ContinuousOrderHom._sizeOf_inst | Mathlib.Topology.Order.Hom.Basic | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : TopologicalSpace α} → {inst_3 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → SizeOf (α →Co β) | null | false |
MeasureTheory.MemLp.integrable_enorm_pow | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε} {p : ℕ},
MeasureTheory.MemLp f (↑p) μ → p ≠ 0 → MeasureTheory.Integrable (fun x => ‖f x‖ₑ ^ p) μ | null | true |
Std.DTreeMap.isEmpty_toList | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.toList.isEmpty = t.isEmpty | null | true |
SkewMonoidAlgebra.liftNCRingHom._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} [inst : Semiring k] {R : Type u_2} [inst_1 : Semiring R], AddMonoidHomClass (k →+* R) k R | null | false |
HahnModule.instAddCommGroup._proof_9 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommGroup V],
autoParam
(∀ (n : ℕ) (a : HahnModule Γ R V),
HahnModule.instAddCommGroup._aux_6 (↑n.succ) a = HahnModule.instAddCommGroup._aux_6 (↑n) a + a)
SubNegMonoid.zsmul_succ'._autoParam | null | false |
Nat.recOnPrimePow._proof_5 | Mathlib.Data.Nat.Factorization.Induction | ∀ (k : ℕ), (k + 2) / (k + 2).minFac ^ (k + 2).factorization (k + 2).minFac < k + 2 | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.toTriangle._simp_5 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
Real.geom_mean_le_arith_mean3_weighted | Mathlib.Analysis.MeanInequalities | ∀ {w₁ w₂ w₃ p₁ p₂ p₃ : ℝ},
0 ≤ w₁ →
0 ≤ w₂ →
0 ≤ w₃ → 0 ≤ p₁ → 0 ≤ p₂ → 0 ≤ p₃ → w₁ + w₂ + w₃ = 1 → p₁ ^ w₁ * p₂ ^ w₂ * p₃ ^ w₃ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ | null | true |
AddMonCat.HasLimits.limitConeIsLimit._proof_5 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddMonCat)
(s : CategoryTheory.Limits.Cone F) (x y : ↑s.1) {j j' : J} (f : j ⟶ j'),
(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct.comp (((CategoryTheory.forget AddMonCat).mapCone s).π.app j)
... | null | false |
AddMonoidHom.mulOp._proof_4 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) (x y : Mᵐᵒᵖ),
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) (x + y) =
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) x + (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) y | null | false |
CategoryTheory.comp_eqToHom_iff | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Y' : C} (p : Y = Y') (f : X ⟶ Y) (g : X ⟶ Y'),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom p) = g ↔
f = CategoryTheory.CategoryStruct.comp g (CategoryTheory.eqToHom ⋯) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.