name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
EisensteinSeries.summand_bound_of_mem_verticalStrip | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {z : UpperHalfPlane} {k : ℝ},
0 ≤ k →
∀ (x : Fin 2 → ℤ) {A B : ℝ} (hB : 0 < B),
z ∈ UpperHalfPlane.verticalStrip A B →
‖↑(x 0) * ↑z + ↑(x 1)‖ ^ (-k) ≤
EisensteinSeries.r { coe := { re := A, im := B }, coe_im_pos := hB } ^ (-k) * ‖x‖ ^ (-k) | null | true |
Lean.Elab.Term.Do.mkReturn | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.Elab.Term.Do.CodeBlock | null | true |
_private.Mathlib.Analysis.Asymptotics.LinearGrowth.0.LinearGrowth.EReal.eventually_atTop_exists_nat_between.match_1_3 | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {b : EReal} (motive : (a : EReal) → a < b → Prop) (a : EReal) (h : a < b),
(∀ (h : ⊤ < b), motive (some none) h) →
(∀ (h : ⊥ < b), motive none h) → (∀ (a : ℝ) (h : ↑a < b), motive (some (some a)) h) → motive a h | null | false |
PontryaginDual.map_apply | Mathlib.Topology.Algebra.PontryaginDual | ∀ {A : Type u_1} {B : Type u_2} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] (f : A →ₜ* B) (x : PontryaginDual B) (y : A), ((PontryaginDual.map f) x) y = x (f y) | null | true |
SSet.Subcomplex.Pairing.RankFunction.filtration_monotone | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι),
Monotone f.filtration | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne.0.SimplexCategory.toMk₁_surjective._simp_1_5 | Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne | ∀ {n : ℕ} {a b : Fin n}, (a.castSucc < b.castSucc) = (a < b) | null | false |
BoundedContinuousFunction.instNSMul.eq_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : AddMonoid R]
[inst_3 : BoundedAdd R] [inst_4 : ContinuousAdd R],
BoundedContinuousFunction.instNSMul =
{ smul := fun x x_1 => { toFun := fun x_2 => x • x_1 x_2, continuous_toFun := ⋯, map_bounded' := ⋯ } } | null | true |
Int16.ofIntTruncate_int8ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int16.ofIntClamp x.toInt = x.toInt16 | null | true |
CategoryTheory.Limits.WidePullbackCone.reindex_pt | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_2} {X : C} {Y : ι → C} {f : (i : ι) → Y i ⟶ X}
(s : CategoryTheory.Limits.WidePullbackCone f) {ι' : Type u_3} (e : ι' ≃ ι), (s.reindex e).pt = s.pt | null | true |
CategoryTheory.Quotient.preadditive._proof_6 | Mathlib.CategoryTheory.Quotient.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (r : HomRel C)
[inst_2 : CategoryTheory.Congruence r]
(hr : ∀ ⦃X Y : C⦄ (f₁ f₂ g₁ g₂ : X ⟶ Y), r f₁ f₂ → r g₁ g₂ → r (f₁ + g₁) (f₂ + g₂)) (P Q : CategoryTheory.Quotient r)
(a b : P ⟶ Q), a - b = a + -b | null | false |
Lean.Meta.Match.Extension.Entry.name | Lean.Meta.Match.MatcherInfo | Lean.Meta.Match.Extension.Entry → Lean.Name | null | true |
CategoryTheory.Preadditive.instMonoNegHom | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q : C} {f : P ⟶ Q}
[CategoryTheory.Mono f], CategoryTheory.Mono (-f) | null | true |
_private.Lean.Environment.0.Lean.Environment.AddConstAsyncResult.allRealizationsPromise | Lean.Environment | Lean.Environment.AddConstAsyncResult → IO.Promise (Lean.NameMap Lean.AsyncConst✝) | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent.injEq | Lean.Meta.Tactic.Grind.AC.Types | ∀ (x : Lean.Grind.AC.Var) (c₁ : Lean.Meta.Grind.AC.EqCnstr) (x_1 : Lean.Grind.AC.Var)
(c₁_1 : Lean.Meta.Grind.AC.EqCnstr),
(Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x c₁ =
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x_1 c₁_1) =
(x = x_1 ∧ c₁ = c₁_1) | null | true |
ModuleCat.HasColimit.coconePointSMul._proof_12 | Mathlib.Algebra.Category.ModuleCat.Colimits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} J]
(F : CategoryTheory.Functor J (ModuleCat R)) (r s : R) (x x_1 : J) (x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat).map (F.map x_2))
((F.obj x_1).smul (r + s... | null | false |
CategoryTheory.CoreHom._sizeOf_1 | Mathlib.CategoryTheory.Core | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{X Y : CategoryTheory.Core C} → [SizeOf C] → CategoryTheory.CoreHom X Y → ℕ | null | false |
GradedTensorProduct.algebraMap_def | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | true |
UInt64.casesOn | Init.Prelude | {motive : UInt64 → Sort u} → (t : UInt64) → ((toBitVec : BitVec 64) → motive { toBitVec := toBitVec }) → motive t | null | false |
Fin.fin_two_eq_of_eq_zero_iff | Init.Data.Fin.Lemmas | ∀ {a b : Fin 2}, (a = 0 ↔ b = 0) → a = b | null | true |
instGroupObjOppositeOpensCarrierOfPresheafSmoothSheaf._aux_4 | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_3} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_4} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_5} →
... | null | false |
spectralNorm.nontriviallyNormedField | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | (K : Type u) →
[inst : NontriviallyNormedField K] →
(L : Type v) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
[Algebra.IsAlgebraic K L] → [hu : IsUltrametricDist K] → [CompleteSpace K] → NontriviallyNormedField L | `L` with the spectral norm is a `NontriviallyNormedField`. | true |
_private.Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas.0.iteratedDeriv_neg._simp_1_1 | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F}, iteratedDeriv n f = iteratedDerivWithin n f Set.univ | null | false |
ModelWithCorners.toFun' | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : 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] → ModelWithCorners 𝕜 E H → H → E | Coercion of a model with corners to a function. We don't use `e.toFun` because it is actually
`e.toPartialEquiv.toFun`, so `simp` will apply lemmas about `toPartialEquiv`. While we may want to
switch to this behavior later, doing it mid-port will break a lot of proofs. | true |
CategoryTheory.Comonad.mk.noConfusion | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{P : Sort u} →
{toFunctor : CategoryTheory.Functor C C} →
{ε : toFunctor ⟶ CategoryTheory.Functor.id C} →
{δ : toFunctor ⟶ toFunctor.comp toFunctor} →
{coassoc :
autoParam
(∀ (X : C)... | null | false |
CategoryTheory.GrothendieckTopology.instWEqualsLocallyBijectiveTypeFun | Mathlib.CategoryTheory.Sites.LocallyBijective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C),
J.WEqualsLocallyBijective (Type (max u v)) | null | true |
isFixedPt_of_tendsto_iterate | Mathlib.Dynamics.FixedPoints.Topology | ∀ {α : Type u_1} [inst : TopologicalSpace α] [T2Space α] {f : α → α} {x y : α},
Filter.Tendsto (fun n => f^[n] x) Filter.atTop (nhds y) → ContinuousAt f y → Function.IsFixedPt f y | If the iterates `f^[n] x` converge to `y` and `f` is continuous at `y`,
then `y` is a fixed point for `f`. | true |
_private.Init.Data.List.Impl.0.List.replaceTR.go.eq_def | Init.Data.List.Impl | ∀ {α : Type u_1} [inst : BEq α] (l : List α) (b c : α) (a : List α) (a_1 : Array α),
List.replaceTR.go✝ l b c a a_1 =
match a, a_1 with
| [], x => l
| a :: as, acc => bif b == a then acc.toListAppend (c :: as) else List.replaceTR.go✝ l b c as (acc.push a) | null | true |
MvPolynomial.eval₂Hom_X | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {S : Type v} [inst : CommRing S] {R : Type u} (c : ℤ →+* S) (f : MvPolynomial R ℤ →+* S) (x : MvPolynomial R ℤ),
MvPolynomial.eval₂ c (⇑f ∘ MvPolynomial.X) x = f x | A ring homomorphism `f : Z[X_1, X_2, ...] → R`
is determined by the evaluations `f(X_1)`, `f(X_2)`, ... | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.rec_2 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.C... | null | false |
ENNReal.log.eq_1 | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLog | ∀ (x : ENNReal), x.log = if x = 0 then ⊥ else if x = ⊤ then ⊤ else ↑(Real.log x.toReal) | null | true |
AlgebraicGeometry.Scheme.Pullback.t'._proof_1 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j k : 𝒰.I₀),
CategoryTheory.Limits.HasPullback (AlgebraicGeometry.Scheme.Pullback.fV 𝒰 f g i j)
(AlgebraicGeometry.Sc... | null | false |
MulEquiv.toMonoidHom._proof_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (h : M ≃* N) (x y : M),
h.toFun (x * y) = h.toFun x * h.toFun y | null | false |
OpenPartialHomeomorph.singletonChartedSpace_chartAt_eq | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} [inst : TopologicalSpace H] {α : Type u_5} [inst_1 : TopologicalSpace α] (e : OpenPartialHomeomorph α H)
(h : e.source = Set.univ) {x : α}, chartAt H x = e | null | true |
PresheafOfModules.colimitPresheafOfModules._proof_8 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ)
(x x_1 : ↑(R.obj X)), x * x_1 = x * x_1 | null | false |
AddCommute.addSemiconjBy | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Add S] {a b : S}, AddCommute a b → AddSemiconjBy a b b | null | true |
Pi.inv_apply | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : (i : ι) → Inv (G i)] (f : (i : ι) → G i) (i : ι), f⁻¹ i = (f i)⁻¹ | null | true |
ModuleCat.hom_add | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R} (f g : M ⟶ N),
ModuleCat.Hom.hom (f + g) = ModuleCat.Hom.hom f + ModuleCat.Hom.hom g | null | true |
MonadControl.noConfusion | Init.Control.Basic | {P : Sort u_1} →
{m : Type u → Type v} →
{n : Type u → Type w} →
{t : MonadControl m n} →
{m' : Type u → Type v} →
{n' : Type u → Type w} →
{t' : MonadControl m' n'} → m = m' → n = n' → t ≍ t' → MonadControl.noConfusionType P t t' | null | false |
IsCompact.diff | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsCompact s → IsOpen t → IsCompact (s \ t) | The set difference of a compact set and an open set is a compact set. | true |
ZFSet.Definable.noConfusion | Mathlib.SetTheory.ZFC.Basic | {P : Sort u_1} →
{n : ℕ} →
{f : (Fin n → ZFSet.{u}) → ZFSet.{u}} →
{t : ZFSet.Definable n f} →
{n' : ℕ} →
{f' : (Fin n' → ZFSet.{u}) → ZFSet.{u}} →
{t' : ZFSet.Definable n' f'} → n = n' → f ≍ f' → t ≍ t' → ZFSet.Definable.noConfusionType P t t' | null | false |
Set.image_insert_eq | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {s : Set α}, f '' insert a s = insert (f a) (f '' s) | null | true |
BialgHom.noConfusionType | Mathlib.RingTheory.Bialgebra.Hom | Sort u →
{R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
[inst_3 : Semiring B] →
[inst_4 : Algebra R B] →
[inst_5 : CoalgebraStruct R A] →
... | null | false |
Complex.not_continuousAt_Gamma_neg_nat | Mathlib.Analysis.SpecialFunctions.Gamma.Deriv | ∀ (n : ℕ), ¬ContinuousAt Complex.Gamma (-↑n) | null | true |
Associates.mkMonoidHom_apply | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), Associates.mkMonoidHom a = Associates.mk a | null | true |
Nat.toArray_roc_eq_nil_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...=n).toArray = #[] ↔ n ≤ m | null | true |
CategoryTheory.Triangulated.TStructure.natTransTruncLEOfLE.congr_simp | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
alexandrovDiscrete_coinduced | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {β : Type u_5} {f : α → β}, AlexandrovDiscrete β | null | true |
DivisibleHull.instIsOrderedCancelAddMonoid | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedCancelAddMonoid M],
IsOrderedCancelAddMonoid (DivisibleHull M) | null | true |
Finset.le_piecewise_of_le_of_le | Mathlib.Data.Finset.Piecewise | ∀ {ι : Type u_1} (s : Finset ι) [inst : (j : ι) → Decidable (j ∈ s)] {π : ι → Type u_3} {f g h : (i : ι) → π i}
[inst_1 : (i : ι) → Preorder (π i)], h ≤ f → h ≤ g → h ≤ s.piecewise f g | null | true |
Monoid.CoprodI.NeWord.inv_last | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : (i : ι) → Group (G i)] {i j : ι} (w : Monoid.CoprodI.NeWord G i j),
w.inv.last = w.head⁻¹ | null | true |
CategoryTheory.Limits.piConstAdj | Mathlib.CategoryTheory.Limits.Shapes.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasProducts C] →
(X : C) → (CategoryTheory.Limits.piConst.obj X).rightOp ⊣ CategoryTheory.yoneda.obj X | `n ↦ ∏ₙ X` is left adjoint to `Hom(-, X)`. | true |
Lean.Elab.Command.AssertExists.isDecl | Lean.Elab.AssertExists | Lean.Elab.Command.AssertExists → Bool | The type of the assertion: `true` means declaration, `false` means import. | true |
_private.BatteriesRecycling.MonadSatisfying.Basic.0.SatisfiesM.bind.match_1_6 | BatteriesRecycling.MonadSatisfying.Basic | ∀ {α : Type u_1} {p : α → Prop} (motive : { a // p a } → Prop) (h : { a // p a }),
(∀ (a : α) (h : p a), motive ⟨a, h⟩) → motive h | null | false |
Lean.PrettyPrinter.Delaborator.OmissionReason.string.noConfusion | Lean.PrettyPrinter.Delaborator.Basic | {P : Sort u} →
{s s' : String} →
Lean.PrettyPrinter.Delaborator.OmissionReason.string s = Lean.PrettyPrinter.Delaborator.OmissionReason.string s' →
(s = s' → P) → P | null | false |
Vector.get_ofFn | Batteries.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} (f : Fin n → α) (i : Fin n), (Vector.ofFn f).get i = f i | null | true |
List.gt_of_range'_eq_append_cons | Std.Do.Triple.SpecLemmas | ∀ {s n step : ℕ} {xs : List ℕ} {i : ℕ} {ys : List ℕ} {j : ℕ},
List.range' s n step = xs ++ i :: ys → 0 < step → j ∈ xs → j < i | null | true |
Subgroup.QuotientDiff | Mathlib.GroupTheory.SchurZassenhaus | {G : Type u_1} → [inst : Group G] → (H : Subgroup G) → [IsMulCommutative ↥H] → [H.FiniteIndex] → Type u_1 | The quotient of the transversals of an abelian normal `N` by the `diff` relation. | true |
Mathlib.Tactic.Ring.Common.instInhabitedBtℕ | Mathlib.Tactic.Ring.Common | (e : Lean.Expr) → Inhabited (Mathlib.Tactic.Ring.Common.btℕ e) | null | true |
Path.Homotopy.pathCast | Mathlib.Topology.Homotopy.Path | {X : Type u} →
[inst : TopologicalSpace X] →
{x x' y y' : X} →
{p q : Path x y} → p.Homotopy q → (hx : x' = x) → (hy : y' = y) → (p.cast hx hy).Homotopy (q.cast hx hy) | If paths `p` and `q` are homotopic as paths `x ⟶ y`,
then they are homotopic as paths `x' ⟶ y'`, where `x' = x` and `y' = y`. | true |
EIO.tryCatch | Init.System.IO | {ε α : Type} → EIO ε α → (ε → EIO ε α) → EIO ε α | null | true |
SkewMonoidAlgebra.instRing._proof_7 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Ring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k]
(a : SkewMonoidAlgebra k G), 0 * a = 0 | null | false |
Lean.instBEqDataValue | Lean.Data.KVMap | BEq Lean.DataValue | null | true |
IsUltrametricDist.isUltrametricDist_iff_isNonarchimedean_nnnorm | Mathlib.Analysis.Normed.Group.Ultra | ∀ {R : Type u_4} [inst : SeminormedAddCommGroup R], IsUltrametricDist R ↔ IsNonarchimedean fun x => ↑‖x‖₊ | null | true |
Interval.mem_pure | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ∈ Interval.pure a ↔ b = a | null | true |
IsCyclotomicExtension.autEquivPow._proof_4 | Mathlib.NumberTheory.Cyclotomic.Gal | ∀ {n : ℕ} [inst : NeZero n] {K : Type u_1} [inst_1 : Field K] (L : Type u_2) [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] (x y : L ≃ₐ[K] L),
(↑(IsPrimitiveRoot.autToPow K ⋯)).toFun (x * y) =
(↑(IsPrimitiveRoot.autToPow K ⋯)).toFun x * (↑(IsPrimitive... | null | false |
GradedAlgHom.id._proof_1 | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ (R : Type u_2) {A : Type u_1} {ι : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(𝒜 : ι → Submodule R A) {i : ι} {x : A}, x ∈ 𝒜 i → ↑(GradedRingHom.id 𝒜) x ∈ 𝒜 i | null | false |
PositiveLinearMap.instInnerProductSpaceComplexPreGNS | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | {A : Type u_1} →
[inst : NonUnitalCStarAlgebra A] →
[inst_1 : PartialOrder A] → (f : A →ₚ[ℂ] ℂ) → [inst_2 : StarOrderedRing A] → InnerProductSpace ℂ f.PreGNS | null | true |
Algebra.IsPushout.cancelBaseChangeAux._proof_13 | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_4) (S : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (A : Type u_2)
[inst_3 : CommRing A] [inst_4 : Algebra R A] (M : Type u_1) [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : Module A M] [inst_8 : IsScalarTower R A M],
LinearMap.CompatibleSMul (Tensor... | null | false |
Finset.subtractionCommMonoid._proof_6 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : SubtractionCommMonoid α] (s : Finset α) (n : ℤ), ↑(n • s) = n • ↑s | null | false |
SSet.isColimitCokernelCoforkChainComplexDOneZero._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.HomologyZero | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
(X : SSet) (R : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.sigmaConst.obj R).map (CategoryTheory.SimplicialObject.δ X 1))
((CategoryTheory.Limits.sigmaConst.obj R).map (Typ... | null | false |
MeasurableEquiv.Set.prod._proof_3 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_2} {β : Type u_1} (s : Set α) (t : Set β) (a : ↑(s ×ˢ t)), (↑a).2 ∈ t | null | false |
hasSum_of_isGLB_of_nonpos | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : TopologicalSpace α] [OrderTopology α] {f : ι → α} (i : α),
(∀ (i : ι), f i ≤ 0) → IsGLB (Set.range fun s => ∑ i ∈ s, f i) i → HasSum f i | null | true |
Std.Do.ExceptConds.imp.eq_def | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} (x y : Std.Do.ExceptConds ps),
(x →ₑ y) =
match ps, x, y with
| Std.Do.PostShape.pure, x, y => PUnit.unit
| Std.Do.PostShape.arg σ ps, x, y => x →ₑ y
| Std.Do.PostShape.except ε a, x, y => (fun e => spred(x.1 e → y.1 e), x.2 →ₑ y.2) | null | true |
Pi.list_sum_apply | Mathlib.Algebra.BigOperators.Pi | ∀ {α : Type u_7} {M : α → Type u_8} [inst : (a : α) → AddMonoid (M a)] (a : α) (l : List ((a : α) → M a)),
l.sum a = (List.map (fun f => f a) l).sum | null | true |
GrpMax | Mathlib.Algebra.Category.Grp.Basic | Type ((max u1 u2) + 1) | An alias for `GrpCat.{max u v}`, to deal around unification issues. | true |
GrpCat.forget_createsLimit.eq_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J GrpCat),
GrpCat.forget_createsLimit F =
CategoryTheory.createsLimitOfNatIso
(CategoryTheory.Iso.refl ((CategoryTheory.forget₂ GrpCat MonCat).comp (CategoryTheory.forget MonCat))) | null | true |
Ideal.powQuotSuccInclusion_injective | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R) (P : Ideal S)
(i : ℕ), Function.Injective ⇑(p.powQuotSuccInclusion P i) | null | true |
Lean.Elab.WF.EqnInfo._sizeOf_inst | Lean.Elab.PreDefinition.WF.Eqns | SizeOf Lean.Elab.WF.EqnInfo | null | false |
AlgebraicGeometry.«_aux_Mathlib_AlgebraicGeometry_OpenImmersion___delab_app_AlgebraicGeometry_term_''ᵁ__1» | Mathlib.AlgebraicGeometry.OpenImmersion | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
Topology.IsScott.scottContinuousOn_iff_continuous | Mathlib.Topology.Order.ScottTopology | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : TopologicalSpace α] [inst_2 : Preorder β]
[inst_3 : TopologicalSpace β] [Topology.IsScott β Set.univ] {f : α → β} {D : Set (Set α)} [Topology.IsScott α D],
(∀ (a b : α), a ≤ b → {a, b} ∈ D) → (ScottContinuousOn D f ↔ Continuous f) | null | true |
SimpleGraph.Walk.reverse_reverse | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.reverse.reverse = p | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.KInjective.0.CochainComplex.isKInjective_of_injective_aux._proof_1_5 | Mathlib.Algebra.Homology.HomotopyCategory.KInjective | ∀ (n : ℤ), n + 1 = n + 1 | null | false |
Algebra.QuasiFinite.recOn | Mathlib.RingTheory.QuasiFinite.Basic | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{motive : Algebra.QuasiFinite R S → Sort u} →
(t : Algebra.QuasiFinite R S) →
((finite_fiber : ∀ (P : Ideal R) [inst_3 : P.IsPrime], Module.Finite P.ResidueFie... | null | false |
Real.binEntropy_one_sub | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ (p : ℝ), Real.binEntropy (1 - p) = Real.binEntropy p | `binEntropy` is symmetric about 1/2. | true |
CategoryTheory.Adjunction.derived._proof_2 | Mathlib.CategoryTheory.Functor.Derived.Adjunction | ∀ {C₁ : Type u_4} {C₂ : Type u_8} {D₁ : Type u_2} {D₂ : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} C₁]
[inst_1 : CategoryTheory.Category.{u_7, u_8} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} D₁]
[inst_3 : CategoryTheory.Category.{u_5, u_6} D₂] {G : CategoryTheory.Functor C₁ C₂} {F : CategoryTheory.F... | null | false |
MonoidAlgebra.mapAlgEquiv_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_1) {A : Type u_4} {B : Type u_5} (M : Type u_7) [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Monoid M] (e : A ≃ₐ[R] B)
(a : MonoidAlgebra A M), (MonoidAlgebra.mapAlgEquiv R M e) a = (↑↑(MonoidAlgebra.mapAlgHom M ↑e).toRingH... | null | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGT?.go.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (k : α) (best : Option (α × β)) (size : ℕ) (k' : α) (v' : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.getEntryGT?.go k best (Std.DTreeMap.Internal.Impl.inner size k' v' l r) =
match compare k k' with
| Ordering.lt => Std.DTr... | null | true |
lift_trdeg_le_of_surjective | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {R : Type u_2} {A : Type v} {A' : Type v'} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing A']
[inst_3 : Algebra R A] [inst_4 : Algebra R A'] (f : A →ₐ[R] A'),
Function.Surjective ⇑f → Cardinal.lift.{v, v'} (Algebra.trdeg R A') ≤ Cardinal.lift.{v', v} (Algebra.trdeg R A) | null | true |
Std.ExtDHashMap.getKey_diff | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {h_mem : k ∈ m₁ \ m₂}, (m₁ \ m₂).getKey k h_mem = m₁.getKey k ⋯ | null | true |
Set.image_single_uIcc_left | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Lattice (α i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → Zero (α i)] (i : ι) (a : α i), Pi.single i '' Set.uIcc a 0 = Set.uIcc (Pi.single i a) 0 | null | true |
EReal.recENNReal_coe_ennreal | Mathlib.Data.EReal.Operations | ∀ {motive : EReal → Sort u_1} (coe : (x : ENNReal) → motive ↑x) (neg_coe : (x : ENNReal) → 0 < x → motive (-↑x))
(x : ENNReal), EReal.recENNReal coe neg_coe ↑x = coe x | null | true |
Std.DTreeMap.Internal.Impl.getD_insertMany_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {l : List ((a : α) × β a)} {k k' : α} (k_beq : compare k k' = Ordering.eq)
{v : β k} {fallback : β k'},
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
... | null | true |
Lean.Lsp.CompletionItemTag._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CompletionItemTag | null | false |
AddEquiv.symm.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} [inst : Add M] [inst_1 : Add N] (h : M ≃+ N),
h.symm = { toEquiv := h.symm, map_add' := ⋯ } | null | true |
_private.Init.Data.List.TakeDrop.0.List.drop_left.match_1_1 | Init.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (head : α) (l₁ x : List α), motive (head :: l₁) x) → motive x x_1 | null | false |
ite_neg | Mathlib.Algebra.Notation.Lemmas | ∀ {α : Type u_1} [inst : Zero α] {p : Prop} [inst_1 : Decidable p] {a b : α} [inst_2 : LT α],
a < 0 → b < 0 → (if p then a else b) < 0 | null | true |
LieDerivation.SMulBracketCommClass.casesOn | Mathlib.Algebra.Lie.Derivation.Basic | {S : Type u_4} →
{L : Type u_5} →
{α : Type u_6} →
[inst : SMul S α] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup α] →
[inst_3 : LieRingModule L α] →
{motive : LieDerivation.SMulBracketCommClass S L α → Sort u} →
(t : LieDerivation.SMulBracketCo... | null | false |
CategoryTheory.SimplicialThickening.functorMap._proof_6 | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J K : Type u_1} [inst : LinearOrder J] [inst_1 : LinearOrder K] (f : J →o K)
(i j : CategoryTheory.SimplicialThickening J) (I : i ⟶ j), f j.as ∈ ⇑f '' I.I | null | false |
Partition.rel_rfl_iff | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {x : α} {u : Set α} {P : Partition u}, P.Rel x x ↔ x ∈ u | null | true |
CategoryTheory.PreOneHypercover.Hom.s₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
(self : E.Hom F) → {i j : E.I₀} → E.I₁ i j → F.I₁ (self.s₀ i) (self.s₀ j) | The map between indexing types of the coverings of the fibre products over `S`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.