name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Pi.isLeftRegular_iff | Mathlib.Algebra.Regular.Pi | ∀ {ι : Type u_1} {R : ι → Type u_3} [inst : (i : ι) → Mul (R i)] {a : (i : ι) → R i},
IsLeftRegular a ↔ ∀ (i : ι), IsLeftRegular (a i) | null | true |
List.le_minIdxOn_of_apply_getElem_lt_apply_getElem | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [inst_2 : LT β] [Std.IsLinearPreorder β]
[Std.LawfulOrderLT β] {f : α → β} {xs : List α} (h : xs ≠ []) {i : ℕ} (hi : i < xs.length),
(∀ (j : ℕ) (x : j < i), f xs[i] < f xs[j]) → i ≤ List.minIdxOn f xs h | null | true |
LinearMap.BilinForm.mul_toMatrix | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (b : Module.Basis n R₁ M₁)
(B : LinearMap.BilinForm R₁ M₁) (M : Matrix n n R₁),
M * (LinearMap.BilinForm.toMatrix b) B =
(LinearMap.BilinF... | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified.0.AlgebraicGeometry.FormallyUnramified.of_hom_ext._simp_1_3 | Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
(φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B), (↑φ₁).comp ↑φ₂ = ↑(φ₁.comp φ₂) | null | false |
continuum_le_cardinal_of_module | Mathlib.Topology.Algebra.Module.Cardinality | ∀ (𝕜 : Type u) (E : Type v) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [inst_2 : AddCommGroup E] [Module 𝕜 E]
[Nontrivial E], Cardinal.continuum ≤ Cardinal.mk E | A nontrivial module over a complete nontrivially normed field has cardinality at least
continuum. | true |
Polynomial.eval₂AlgHom | Mathlib.Algebra.Polynomial.AlgebraMap | {R : Type u} →
{A : Type z} →
{B : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] → (f : A →ₐ[R] B) → (b : B) → (∀ (a : A), Commute (f a) b) → Polynomial A →ₐ[R] B | `Polynomial.eval₂` as an `AlgHom` for noncommutative algebras.
This is `Polynomial.eval₂RingHom'` for `AlgHom`s. | true |
_private.Mathlib.RingTheory.Localization.Ideal.0.IsLocalization.surjective_quotientMap_of_maximal_of_localization._simp_1_2 | Mathlib.RingTheory.Localization.Ideal | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | null | false |
HomogeneousIdeal.toIdeal_iInf₂ | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜] {κ : Sort u_4}
{κ' : κ → Sort u_5} (s : (i : κ) → κ' i → HomogeneousIdeal 𝒜), (⨅ i, ⨅ j, s i j).toIdeal = ... | null | true |
Std.PRange.UpwardEnumerable.exists_of_succ_lt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LT (Std.PRange.succ a) b →
∃ b', b = Std.PRange.succ b' ∧ Std.PRange.UpwardEnumerable.LT a b' | null | true |
ProbabilityTheory.HasSubgaussianMGF.sum_of_iIndepFun | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ι : Type u_2} {X : ι → Ω → ℝ},
ProbabilityTheory.iIndepFun X μ →
∀ {c : ι → NNReal} {s : Finset ι},
(∀ i ∈ s, ProbabilityTheory.HasSubgaussianMGF (X i) (c i) μ) →
ProbabilityTheory.HasSubgaussianMGF (fun ω => ∑ i ∈ s, X i ω) (∑... | null | true |
CategoryTheory.Abelian.Ext.mk₀_addEquiv₀_apply | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (f : CategoryTheory.Abelian.Ext X Y 0),
CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.Abelian.Ext.addEquiv₀ f) = f | null | true |
MonomialOrder.leadingCoeff_prod_of_regular | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {ι : Type u_3} {P : ι → MvPolynomial σ R}
{s : Finset ι},
(∀ i ∈ s, IsRegular (m.leadingCoeff (P i))) → m.leadingCoeff (∏ i ∈ s, P i) = ∏ i ∈ s, m.leadingCoeff (P i) | null | true |
CategoryTheory.MonObj.casesOn | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
{motive : CategoryTheory.MonObj X → Sort u} →
(t : CategoryTheory.MonObj X) →
((one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
... | null | false |
isRelPrime_one_right | Mathlib.Algebra.Divisibility.Units | ∀ {α : Type u_1} [inst : CommMonoid α] {x : α}, IsRelPrime x 1 | null | true |
CircularPreorder.noConfusion | Mathlib.Order.Circular | {P : Sort u} →
{α : Type u_1} →
{t : CircularPreorder α} →
{α' : Type u_1} → {t' : CircularPreorder α'} → α = α' → t ≍ t' → CircularPreorder.noConfusionType P t t' | null | false |
le_of_tendsto' | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [ClosedIicTopology α] {f : β → α}
{a b : α} {x : Filter β} [x.NeBot], Filter.Tendsto f x (nhds a) → (∀ (c : β), f c ≤ b) → a ≤ b | null | true |
ContinuousOpenMap.comp._proof_1 | Mathlib.Topology.Hom.Open | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : β →CO γ) (g : α →CO β), IsOpenMap (f.toFun ∘ ⇑g.toContinuousMap) | null | false |
CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj._proof_3 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_8} {C₂ : Type u_10} {C₃ : Type u_6} {C₄ : Type u_3} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_9, u_10} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_2, u_3} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Funct... | null | false |
Std.ExtTreeSet.size_diff_le_size_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp],
(t₁ \ t₂).size ≤ t₁.size | null | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.downMulHom | Mathlib.Algebra.Group.UniqueProds.Basic | (G : Type u) → [inst : Mul G] → ULift.{u_1, u} G →ₙ* G | null | true |
Lean.Server.FileWorker.EditableDocumentCore.mk.inj | Lean.Server.FileWorker.Utils | ∀ {«meta» : Lean.Server.DocumentMeta} {initSnap : Lean.Language.Lean.InitialSnapshot}
{cmdSnaps : IO.AsyncList IO.Error Lean.Server.Snapshots.Snapshot}
{diagnosticsMutex : Std.Mutex Lean.Server.FileWorker.DiagnosticsState} {meta_1 : Lean.Server.DocumentMeta}
{initSnap_1 : Lean.Language.Lean.InitialSnapshot} {cmdS... | null | true |
nonpos_of_add_le_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α] [AddLeftReflectLE α] {a b : α}, a + b ≤ a → b ≤ 0 | null | true |
Std.HashMap.getKey!_diff | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, (m₁ \ m₂).getKey! k = if k ∈ m₂ then default else m₁.getKey! k | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.isNClique_one._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {s : Finset α}, (s.card = 1) = ∃ a, s = {a} | null | false |
Std.ExtHashMap.getD_modify_self | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β} {f : β → β},
(m.modify k f).getD k fallback = (Option.map f m[k]?).getD fallback | null | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault.noConfusion | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | {P : Sort u} →
{info : Lean.InductiveVal} →
{ctors : Array Lean.ConstructorVal} →
{info' : Lean.InductiveVal} →
{ctors' : Array Lean.ConstructorVal} →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault info ctors =
Lean.Elab.Tactic.BVDecide.Frontend.Normal... | null | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer.0.SubMulAction.ofStabilizer._simp_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
Frm.hasForgetToLat | Mathlib.Order.Category.Frm | CategoryTheory.HasForget₂ Frm Lat | null | true |
Partition.IsRepFun.idem | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {u : Set α} {P : Partition u} {f : α → α} {a : α}, P.IsRepFun f → f (f a) = f a | null | true |
Polynomial.degreeLT.basis_repr | Mathlib.RingTheory.Polynomial.DegreeLT | ∀ {R : Type u_1} [inst : Semiring R] {n : ℕ} (i : Fin n) (P : ↥(Polynomial.degreeLT R n)),
((Polynomial.degreeLT.basis R n).repr P) i = (↑P).coeff ↑i | null | true |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.substRHS.match_1 | Lean.Meta.Match.SimpH | (motive : Lean.Meta.FVarSubst × Lean.MVarId → Sort u_1) →
(x : Lean.Meta.FVarSubst × Lean.MVarId) →
((subst : Lean.Meta.FVarSubst) → (mvarId : Lean.MVarId) → motive (subst, mvarId)) → motive x | null | false |
norm_indicator_eq_indicator_norm | Mathlib.Analysis.Normed.Group.Indicator | ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedAddGroup E] {s : Set α} (f : α → E) (a : α),
‖s.indicator f a‖ = s.indicator (fun a => ‖f a‖) a | null | true |
Metric.minimalCover.eq_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] (ε : NNReal) (A : Set X),
Metric.minimalCover ε A = if h : Metric.coveringNumber ε A ≠ ⊤ then ⋯.choose else ∅ | null | true |
MeasureTheory.Measure.withDensity._proof_1 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal), ∫⁻ (a : α) in ∅, f a ∂μ = 0 | null | false |
Vector.toList_ofFn | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → α}, (Vector.ofFn f).toList = List.ofFn f | null | true |
_private.Aesop.Util.Basic.0.Aesop.hasSorry.go._unsafe_rec | Aesop.Util.Basic | Lean.MetavarContext → Lean.Expr → Bool | null | false |
Int.Linear.Poly.mul_k_eq_mul | Init.Data.Int.Linear | ∀ (k : ℤ) (p : Int.Linear.Poly), p.mul_k k = p.mul k | null | true |
OpenPartialHomeomorph.continuousAt_iff_continuousAt_comp_right | Mathlib.Topology.OpenPartialHomeomorph.Continuity | ∀ {X : Type u_1} {Y : Type u_3} {Z : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : OpenPartialHomeomorph X Y) {f : Y → Z} {x : Y},
x ∈ e.target → (ContinuousAt f x ↔ ContinuousAt (f ∘ ↑e) (↑e.symm x)) | Continuity at a point can be read under right composition with an open partial homeomorphism, if
the point is in its target | true |
IsQuotientCoveringMap.toPermFiber | Mathlib.Topology.Covering.Quotient | {E : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace X] →
{f : E → X} →
{G : Type u_3} →
[inst_2 : Group G] →
[inst_3 : MulAction G E] → IsQuotientCoveringMap f G → (x : X) → G →* Equiv.Perm ↑(f ⁻¹' {x}) | A quotient covering map `f` induces a permutation action on each fiber. | true |
Lie.Derivation.ofDerivation._proof_3 | Mathlib.Algebra.Lie.Derivation.BaseChange | ∀ {R : Type u_3} [inst : CommRing R] {A : Type u_1} [inst_1 : CommRing A] [inst_2 : Algebra R A] (L : Type u_2)
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (d : Derivation R A A) (x y : TensorProduct R A L),
{ toFun := ⇑(LinearMap.rTensor L ↑d), map_add' := ⋯, map_smul' := ⋯ } ⁅x, y⁆ =
⁅x, { toFun := ⇑(Linea... | null | false |
Combinatorics.Line.coe_injective | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_2} {ι : Type u_3} [Nontrivial α], Function.Injective Combinatorics.Line.toFun | null | true |
_private.Lean.Elab.InfoTree.Main.0.Lean.Elab.formatElabInfo | Lean.Elab.InfoTree.Main | Lean.Elab.ContextInfo → Lean.Elab.ElabInfo → Std.Format | null | true |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_4 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M) {x : M}, (x ∈ ↑N) = (x ∈ N) | null | false |
CategoryTheory.MorphismProperty.HasLocalization.noConfusion | Mathlib.CategoryTheory.Localization.HasLocalization | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{W : CategoryTheory.MorphismProperty C} →
{t : W.HasLocalization} →
{C' : Type u} →
{inst' : CategoryTheory.Category.{v, u} C'} →
{W' : CategoryTheory.MorphismProperty C'} →
... | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.sliceFrom_le_sliceFrom_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
Std.Http.Header.Name.casesOn | Std.Http.Data.Headers.Name | {motive : Std.Http.Header.Name → Sort u} →
(t : Std.Http.Header.Name) →
((value : String) →
(isValidHeaderValue : Std.Http.Header.IsValidHeaderName value) →
(isLowerCase : Std.Http.Internal.IsLowerCase value) →
motive { value := value, isValidHeaderValue := isValidHeaderValue, isLowe... | null | false |
Lean.Doc.Parser.document.formatter | Lean.DocString.Formatter | Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.CoordinateRing.norm_smul_basis._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Affine R},
1 = (WeierstrassCurve.Affine.CoordinateRing.basis W') 0 | null | false |
Equiv.setDiffEquiv | Mathlib.Logic.Equiv.Fintype | {α : Type u_1} →
{s t : Set α} → [inst : Fintype ↑s] → [inst_1 : Fintype ↑t] → Fintype.card ↑s = Fintype.card ↑t → ↑(s \ t) ≃ ↑(t \ s) | If two sets have the same finite cardinality, their set differences are equivalent. | true |
ContinuousAt.cexp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ} {x : α},
ContinuousAt f x → ContinuousAt (fun y => Complex.exp (f y)) x | null | true |
Lean.Elab.abortTermExceptionId | Lean.Elab.Exception | Lean.InternalExceptionId | null | true |
Module.DirectLimit.congr_symm_apply_of | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] {G : ι → Type u_3}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] {G' : ι → Type u_5} [inst_5 : (i : ι) → AddCommMonoid (G' i)]
[inst_6 : (i : ι)... | null | true |
apply_le_nnnorm_cfc_nnreal._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
Additive.seminormedCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (a b : Additive E), a + b = b + a | null | false |
AddEquiv.coprodAssoc._proof_2 | Mathlib.GroupTheory.Coprod.Basic | ∀ (M : Type u_1) (N : Type u_2) (P : Type u_3) [inst : AddMonoid M] [inst_1 : AddMonoid N] [inst_2 : AddMonoid P],
(AddMonoid.Coprod.lift (AddMonoid.Coprod.map (AddMonoidHom.id M) AddMonoid.Coprod.inl)
(AddMonoid.Coprod.inr.comp AddMonoid.Coprod.inr)).comp
(AddMonoid.Coprod.lift (AddMonoid.Coprod.inl.... | null | false |
Real.leftDeriv_mul_log | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ∀ {x : ℝ}, x ≠ 0 → derivWithin (fun x => x * Real.log x) (Set.Iio x) x = Real.log x + 1 | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.1240114214._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
CategoryTheory.Functor.FullyFaithful.mapAddGrp._proof_4 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.Monoidal] (hF : F.FullyFaithful) {X Y... | null | false |
FGModuleRepr.instCategory._aux_5 | Mathlib.Algebra.Category.FGModuleCat.EssentiallySmall | (R : Type u_1) → [inst : CommRing R] → {X Y Z : FGModuleRepr R} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Affine.CoordinateRing.mk_ψ._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R),
(WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C W.Ψ₂Sq) =
(WeierstrassCurve.Affine.CoordinateRing.mk W) W.ψ₂ ^ 2 | null | false |
VonNeumannAlgebra.mk.inj | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} {inst : NormedAddCommGroup H} {inst_1 : InnerProductSpace ℂ H} {inst_2 : CompleteSpace H}
{toStarSubalgebra : StarSubalgebra ℂ (H →L[ℂ] H)}
{centralizer_centralizer' : toStarSubalgebra.carrier.centralizer.centralizer = toStarSubalgebra.carrier}
{toStarSubalgebra_1 : StarSubalgebra ℂ (H →L[ℂ] H)}
... | null | true |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat._proof_3 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (pq : ℕ × ℕ), WithBotTop.coe (-↑pq.2) ≤ WithBotTop.coe (-↑pq.2 + 1) | null | false |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.exists_range_eq_graph._simp_1_7 | Mathlib.LinearAlgebra.Prod | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
Int64.zero_sub | Init.Data.SInt.Lemmas | ∀ (a : Int64), 0 - a = -a | null | true |
Lean.Core.mkSnapshot?._auto_1 | Lean.CoreM | Lean.Syntax | null | false |
Polynomial.HasSeparableContraction.dvd_degree' | Mathlib.RingTheory.Polynomial.SeparableDegree | ∀ {F : Type u_1} [inst : CommSemiring F] {q : ℕ} {f : Polynomial F} (hf : Polynomial.HasSeparableContraction q f),
∃ m, hf.degree * q ^ m = f.natDegree | null | true |
ContDiff.fun_smul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{𝕜' : Type u_3} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F... | Eta-expanded form of `ContDiff.smul`
---
The scalar multiplication of two `C^n` functions is `C^n`. | true |
_private.Mathlib.Order.Atoms.0.SetLike.isCoatom_iff._simp_1_6 | Mathlib.Order.Atoms | ∀ {a b c : Prop}, (a → b → c) = (a ∧ b → c) | null | false |
CategoryTheory.Functor.isDenseAt_iff | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X : D},
F.isDenseAt X ↔
Nonempty
(CategoryTheory.Limits.IsColimit
((CategoryTheory.Functor.LeftExtension.mk (CategoryTheory.Functor.id D) F.righ... | null | true |
LipschitzWith.min_const | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : α → ℝ} {Kf : NNReal},
LipschitzWith Kf f → ∀ (a : ℝ), LipschitzWith Kf fun x => min (f x) a | null | true |
IsClosed.isCompletelyPseudoMetrizableSpace | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_1} [inst : TopologicalSpace X] [TopologicalSpace.IsCompletelyPseudoMetrizableSpace X] {s : Set X},
IsClosed s → TopologicalSpace.IsCompletelyPseudoMetrizableSpace ↑s | A closed subset of a completely pseudometrizable space is also completely pseudometrizable. | true |
Std.DHashMap.Internal.exists_bucket' | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α]
(self : Array (Std.DHashMap.Internal.AssocList α β)) (i : USize) (hi : i.toNat < self.size),
∃ l,
(List.flatMap Std.DHashMap.Internal.AssocList.toList self.toList).Perm (self[i.toNat].toList ++ l) ∧
∀ [LawfulHashable α],
Std.DHas... | null | true |
Module.Flat.baseChange | Mathlib.RingTheory.Flat.Stability | ∀ (R : Type u) (S : Type v) (M : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [Module.Flat R M], Module.Flat S (TensorProduct R S M) | If `M` is a flat `R`-module and `S` is any `R`-algebra, `S ⊗[R] M` is `S`-flat. | true |
_private.Mathlib.Data.Nat.ModEq.0.Nat.ModEq.mul_right_cancel'._simp_1_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, (a ≡ b [MOD n]) = (↑n ∣ ↑b - ↑a) | null | false |
PrimeMultiset.prod_sup | Mathlib.Data.PNat.Factors | ∀ (u v : PrimeMultiset), (u ⊔ v).prod = u.prod.lcm v.prod | null | true |
MeasureTheory.Measure.restrict_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {_m0 : MeasurableSpace α} (s : Set α), MeasureTheory.Measure.restrict 0 s = 0 | null | true |
Acc.of_subrel | Mathlib.Order.RelIso.Set | ∀ {α : Type u_1} {r : α → α → Prop} [IsTrans α r] {b : α} (a : { a // r a b }),
Acc (Subrel r fun x => r x b) a → Acc r ↑a | null | true |
ModelWithCorners.t1Space | 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] (I : ModelWithCorners 𝕜 E H) (M : Type u_4)
[inst : TopologicalSpace M] [ChartedSpace H M], T1Space M | Every manifold is a Fréchet space (T1 space) -- regardless of whether it is
Hausdorff. | true |
LinearMap.IsSymmetric.toMatrix_eigenvectorBasis | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E} [inst_3 : FiniteDimensional 𝕜 E] {n : ℕ} (hT : T.IsSymmetric) (hn : Module.finrank 𝕜 E = n),
(LinearMap.toMatrix (hT.eigenvectorBasis hn).toBasis (hT.eigenvectorBasis hn).toBasis)... | null | true |
Lean.Parser.Tactic.anyGoals | Init.Tactics | Lean.ParserDescr | `any_goals tac` applies the tactic `tac` to every goal,
concatenating the resulting goals for successful tactic applications.
If the tactic fails on all of the goals, the entire `any_goals` tactic fails.
This tactic is like `all_goals try tac` except that it fails if none of the applications of `tac` succeeds.
| true |
WittVector.polyOfInterest | Mathlib.RingTheory.WittVector.MulCoeff | (p : ℕ) → [hp : Fact (Nat.Prime p)] → ℕ → MvPolynomial (Fin 2 × ℕ) ℤ | This is the polynomial whose degree we want to get a handle on. | true |
Finset.ruzsa_triangle_inequality_addNeg_addNeg_addNeg | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
(A + -C).card * B.card ≤ (A + -B).card * (C + -B).card | **Ruzsa's triangle inequality**. Addneg-addneg-addneg version. | true |
Lean.PersistentHashMap.Zipper.consCollision.noConfusion | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u} →
{β : Type v} →
{P : Sort u_1} →
{keys : Subarray α} →
{vals : Subarray β} →
{a : Std.Slice.size keys = Std.Slice.size vals} →
{a_1 : Lean.PersistentHashMap.Zipper α β} →
{keys' : Subarray α} →
{vals' : Subarray β} →
... | null | false |
UpperSet.upper' | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} [inst : LE α] (self : UpperSet α), IsUpperSet self.carrier | The carrier of an `UpperSet` is an upper set. | true |
Frm.instCategory._proof_2 | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} (f : X.Hom Y), { hom' := { hom' := FrameHom.id ↑Y }.hom'.comp f.hom' } = f | null | false |
_private.Lean.Level.0.Lean.Level.addOffsetAux.match_1 | Lean.Level | (motive : ℕ → Lean.Level → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.Level) → ((u : Lean.Level) → motive 0 u) → ((n : ℕ) → (u : Lean.Level) → motive n.succ u) → motive x x_1 | null | false |
_private.Init.Data.Array.Range.0.Array.mk_add_mem_zipIdx_iff_getElem?._simp_1_2 | Init.Data.Array.Range | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | null | false |
TwoSidedIdeal.mem_mk | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] {x : R} {c : RingCon R}, x ∈ { ringCon := c } ↔ c x 0 | null | true |
Lean.MetavarDecl | Lean.MetavarContext | Type | Information about a metavariable. | true |
Lean.Meta.Grind.Arith.CommRing.EqCnstr.recOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive_1 : Lean.Meta.Grind.Arith.CommRing.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.EqCnstr) →
((p : Lean.Grind.CommRing.Poly) →
(h : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof) →
(sugar id : ℕ) → motiv... | null | false |
Std.Internal.List.containsKey_maxKeyD | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false → ∀ {fallback : α}, Std.Internal.List.containsKey (Std.Internal.List.maxKeyD l fallback) l = true | null | true |
NonemptyFinLinOrd.instLargeCategory._proof_9 | Mathlib.Order.Category.NonemptyFinLinOrd | autoParam
(∀ {W X Y Z : NonemptyFinLinOrd} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
CategoryTheory.Category.assoc._autoParam | null | false |
ContinuousAt.integral_sub_linear_isLittleO_ae | Mathlib.MeasureTheory.Integral.Bochner.FundThmCalculus | ∀ {X : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : MeasurableSpace X] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [CompleteSpace E] [inst_4 : TopologicalSpace X] [OpensMeasurableSpace X]
{μ : MeasureTheory.Measure X} [MeasureTheory.IsLocallyFiniteMeasure μ] {x : X} {f : X → E},
ContinuousAt f x... | Fundamental theorem of calculus for set integrals, `nhds` version: if `μ` is a locally finite
measure and `f` is an almost everywhere measurable function that is continuous at a point `a`, then
`∫ x in s i, f x ∂μ = μ (s i) • f a + o(μ (s i))` at `li` provided that `s` tends to
`(𝓝 a).smallSets` along `li`. Since `μ (... | true |
AlgebraicGeometry.IsProper.toIsSeparated | Mathlib.AlgebraicGeometry.Morphisms.Proper | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.IsProper f], AlgebraicGeometry.IsSeparated f | null | true |
CategoryTheory.IsUniversalColimit.nonempty_isColimit_prod_of_pullbackCone._auto_3 | Mathlib.CategoryTheory.Limits.VanKampen | Lean.Syntax | null | false |
Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : Type u} → Std.Tactic.BVDecide.LRAT.Internal.ReduceResult α | null | true |
BoxIntegral.Prepartition.recOn | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} →
{I : BoxIntegral.Box ι} →
{motive : BoxIntegral.Prepartition I → Sort u} →
(t : BoxIntegral.Prepartition I) →
((boxes : Finset (BoxIntegral.Box ι)) →
(le_of_mem' : ∀ J ∈ boxes, J ≤ I) →
(pairwiseDisjoint : (↑boxes).Pairwise (Function.onFun Disjoint BoxInteg... | null | false |
_private.Mathlib.Analysis.Convex.Segment.0.segment_symm.match_1_1 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_2) {E : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y x_1 : E) (motive : x_1 ∈ segment 𝕜 x y → Prop) (x_2 : x_1 ∈ segment 𝕜 x y),
(∀ (a b : 𝕜) (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1) (H : a • x + b • y = x_1), motive ⋯) → motive ... | null | false |
setOf_minimal_antichain | Mathlib.Order.Antichain | ∀ {α : Type u_1} [inst : PartialOrder α] (P : α → Prop), IsAntichain (fun x1 x2 => x1 ≤ x2) {x | Minimal P x} | null | true |
NumberField.Units.instNeZeroNatTorsionOrder | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], NeZero (NumberField.Units.torsionOrder K) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.