name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Coalgebra.IsFrobenius.right | Mathlib.RingTheory.Coalgebra.IsFrobenius | (R : Type u_1) →
(A : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] → [CoalgebraStruct R A] → TensorProduct R A A →ₗ[R] TensorProduct R A A | The right-hand side of the Frobenius equation: `(mul ⊗ id) ∘ assoc.symm ∘ (id ⊗ comul)`. | true |
CategoryTheory.EnrichedCategory | Mathlib.CategoryTheory.Enriched.Basic | (V : Type v) →
[inst : CategoryTheory.Category.{w, v} V] → [CategoryTheory.MonoidalCategory V] → Type u₁ → Type (max (max u₁ v) w) | A `V`-category is a category enriched in a monoidal category `V`.
Note that we do not assume that `V` is a concrete category,
so there may not be an "honest" underlying category at all!
| true |
Ideal.instLiesOverUnder | Mathlib.RingTheory.Ideal.Over | ∀ {A : Type u_2} [inst : CommSemiring A] {B : Type u_3} [inst_1 : CommSemiring B] {C : Type u_4} [inst_2 : Semiring C]
[inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C] [IsScalarTower A B C] (𝔓 : Ideal C) (P : Ideal B)
[𝔓.LiesOver P], 𝔓.LiesOver (Ideal.under A P) | null | true |
Lean.Meta.isCoeDecl | Lean.Meta.Coe | Lean.Environment → Lean.Name → Bool | Return true iff `declName` is one of the auxiliary definitions/projections used to implement
coercions.
| true |
Matroid.eRk_singleton_eq | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {e : α} [M.Loopless],
autoParam (e ∈ M.E) Matroid.eRk_singleton_eq._auto_1 → M.eRk {e} = 1 | null | true |
_private.Mathlib.Topology.Instances.AddCircle.Defs.0.AddCircle.coe_eq_zero_of_pos_iff._simp_1_1 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a : α}, (a ≤ 0) = (0 ≤ -a) | null | false |
FixedPoints.subring | Mathlib.Algebra.Algebra.Subalgebra.Operations | (B : Type u_2) → [inst : Ring B] → (G : Type u_4) → [inst_1 : Monoid G] → [MulSemiringAction G B] → Subring B | The set of fixed points under a group action, as a subring. | true |
CategoryTheory.ExponentiableMorphism.instChosenPullbacksAlongHomMk | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I J : C} →
{f : I ⟶ J} →
[CategoryTheory.ChosenPullbacksAlong f] → CategoryTheory.ChosenPullbacksAlong (CategoryTheory.Over.mk f).hom | null | true |
SlashInvariantForm.trace.eq_1 | Mathlib.NumberTheory.ModularForms.NormTrace | ∀ {𝒢 : Subgroup (GL (Fin 2) ℝ)} (ℋ : Subgroup (GL (Fin 2) ℝ)) {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {k : ℤ}
[inst_1 : SlashInvariantFormClass F 𝒢 k] (f : F) [inst_2 : 𝒢.IsFiniteRelIndex ℋ],
SlashInvariantForm.trace ℋ f =
{
toFun :=
have this := Fintype.ofFinite (↥ℋ ⧸ 𝒢.subgroupOf ... | null | true |
LieModule.genWeightSpace_neg_add_chainBot | Mathlib.Algebra.Lie.Weights.Chain | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {M : Type u_3}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [inst_8 : HasUniqueDiv R] [inst_9 : IsDomain R] [inst_10 : Module... | null | true |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.elabDocsToVerso._regBuiltin.Lean.Elab.Command.elabDocsToVerso_1 | Lean.Elab.BuiltinCommand | IO Unit | null | false |
Homeomorph.secondCountableTopology | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [SecondCountableTopology Y]
(h : X ≃ₜ Y), SecondCountableTopology X | null | true |
Basis.piTensorProduct._proof_1 | Mathlib.LinearAlgebra.PiTensorProduct.Basis | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
Equiv.sumEmbeddingEquivProdEmbeddingDisjoint._proof_8 | Mathlib.Logic.Equiv.Embedding | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α ↪ γ) (g : β ↪ γ),
Disjoint (Set.range ⇑(f, g).1) (Set.range ⇑(f, g).2) →
Function.Injective fun x =>
match x with
| Sum.inl a => f a
| Sum.inr b => g b | null | false |
_private.Mathlib.MeasureTheory.Function.ContinuousMapDense.0.MeasureTheory.Integrable.exists_hasCompactSupport_integral_sub_le._simp_1_2 | Mathlib.MeasureTheory.Function.ContinuousMapDense | 1 = ENNReal.ofReal 1 | null | false |
instAddMonoidWithOneENat._proof_7 | Mathlib.Data.ENat.Monoid | autoParam (∀ (n : ℕ) (x : ℕ∞), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
MeasurableEquiv.piCongrLeft_apply_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {ι : Type u_8} {ι' : Type u_9} (e : ι ≃ ι') {β : ι' → Type u_10} [inst : (i' : ι') → MeasurableSpace (β i')]
(x : (i : ι) → β (e i)) (i : ι), (MeasurableEquiv.piCongrLeft (fun i' => β i') e) x (e i) = x i | null | true |
RestrictedProduct.range_coe | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) (A : (i : ι) → Set (R i)) {𝓕 : Filter ι},
Set.range DFunLike.coe = {x | ∀ᶠ (i : ι) in 𝓕, x i ∈ A i} | null | true |
ConvexBody.instAddCommMonoid | Mathlib.Analysis.Convex.Body | {V : Type u_1} →
[inst : TopologicalSpace V] →
[inst_1 : AddCommGroup V] → [inst_2 : Module ℝ V] → [ContinuousAdd V] → AddCommMonoid (ConvexBody V) | null | true |
SSet.Truncated.hoFunctor.monoidal._proof_17 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | autoParam
(∀ (X : SSet),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (SSet.hoFunctor.obj X)).inv =
CategoryTheory.CategoryStruct.comp (SSet.hoFunctor.map (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).inv)
(CategoryTheory.CategoryStruct.comp
(SSet.Truncated.hoFunctor.monoidal._... | null | false |
MulEquiv.monoidHomCongrLeft_refl | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M : Type u_4} {N : Type u_8} [inst : MulOneClass M] [inst_1 : CommMonoid N],
(MulEquiv.refl M).monoidHomCongrLeft = MulEquiv.refl (M →* N) | null | true |
Topology.IsOpenEmbedding.adjunctionNhds | Mathlib.Topology.Category.TopCat.OpenNhds | {X Y : TopCat} →
{f : X ⟶ Y} →
(h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)) →
(x : ↑X) → ⋯.functorNhds x ⊣ TopologicalSpace.OpenNhds.map f x | An open embedding `f : X ⟶ Y` induces an adjunction between `OpenNhds x` and `OpenNhds (f x)`.
We define `IsOpenEmbedding.adjunctionNhds` as `IsOpenEmbedding.isOpenMap.adjunctionNds`, so it
won't default to `IsInducing.adjunctionNhds`, which is an adjunction in the other direction.
| true |
instAndOpUInt8 | Init.Data.UInt.Basic | AndOp UInt8 | null | true |
_private.Mathlib.Algebra.Ring.GeomSum.0.Commute.geom_sum₂_succ_eq._simp_1_3 | Mathlib.Algebra.Ring.GeomSum | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), a * a ^ n = a ^ (n + 1) | null | false |
GradedTensorProduct.mulHom._proof_6 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_2} {A : Type u_1} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
AddSubgroupClass (Submodule R A) A | null | false |
IsDedekindDomain.HeightOneSpectrum.equivMaximalSpectrum._proof_5 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [IsDedekindDomain R], ¬IsField R → ∀ (v : MaximalSpectrum R), v.asIdeal ≠ ⊥ | null | false |
IsFreeGroupoid.quiverGenerators | Mathlib.GroupTheory.FreeGroup.NielsenSchreier | {G : Type u_1} → {inst : CategoryTheory.Groupoid G} → [self : IsFreeGroupoid G] → Quiver (IsFreeGroupoid.Generators G) | null | true |
TopCat.subpresheafContinuousPrelocalIsoPresheafToTop._proof_1 | Mathlib.Topology.Sheaves.LocalPredicate | ∀ {X : TopCat} (T : TopCat) (X_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
CategoryTheory.CategoryStruct.comp (TypeCat.ofHom fun f => TopCat.ofHom { toFun := ↑f, continuous_toFun := ⋯ })
(TypeCat.ofHom fun f => ⟨⇑f.hom', ⋯⟩) =
CategoryTheory.CategoryStruct.id ((TopCat.subpresheafToTypes (X.continuousPrelocal ↑T)).o... | null | false |
Bundle.ContMDiffRiemannianMetric.mk | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | {EB : Type u_1} →
[inst : NormedAddCommGroup EB] →
[inst_1 : NormedSpace ℝ EB] →
{HB : Type u_2} →
[inst_2 : TopologicalSpace HB] →
{IB : ModelWithCorners ℝ EB HB} →
{n : WithTop ℕ∞} →
{B : Type u_3} →
[inst_3 : TopologicalSpace B] →
... | null | true |
MonoidHom.codRestrict.congr_simp | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : SubmonoidClass S N] (f f_1 : M →* N) (e_f : f = f_1) (s : S) (h : ∀ (x : M), f x ∈ s),
f.codRestrict s h = f_1.codRestrict s ⋯ | null | true |
IsOpen.exists_is_const_of_deriv_eq_zero | Mathlib.Analysis.Calculus.MeanValue | ∀ {𝕜 : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] {f : 𝕜 → G}
{s : Set 𝕜}, IsOpen s → IsPreconnected s → DifferentiableOn 𝕜 f s → Set.EqOn (deriv f) 0 s → ∃ a, ∀ x ∈ s, f x = a | null | true |
SSet.nonDegenerateEquivOfIso.match_1 | Mathlib.AlgebraicTopology.SimplicialSet.Degenerate | {X : SSet} →
{n : ℕ} →
(motive : ↑(X.nonDegenerate n) → Sort u_2) →
(x : ↑(X.nonDegenerate n)) →
((x : X.obj (Opposite.op { len := n })) → (hx : x ∈ X.nonDegenerate n) → motive ⟨x, hx⟩) → motive x | null | false |
LieAlgebra.InvariantForm.restrict_nondegenerate | Mathlib.Algebra.Lie.InvariantForm | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L] [Module.Finite K L]
(Φ : LinearMap.BilinForm K L),
Φ.Nondegenerate →
LinearMap.BilinForm.lieInvariant L Φ →
Φ.IsRefl →
(∀ (I : LieIdeal K L), IsAtom I → ¬IsLieAbelian ↥I) →
∀ (I : LieIdeal K L... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go_denote_eq._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (distance : ℕ)
(input : aig.RefVec w) (assign : α → Bool) (idx : ℕ) (hidx1 : idx < w)
(_x : (curr : ℕ) ×' (_ : curr ≤ w) ×' (_ : aig.RefVec curr) ×' curr ≤ idx),
⟦assign,
{ aig := (Std.Tactic.BVDecide.BVExpr.bitblast.bla... | null | false |
Lean.Parser.Term.doLet.formatter | Lean.Parser.Do | Lean.PrettyPrinter.Formatter | null | true |
Vector.append_assoc_symm._proof_2 | Init.Data.Vector.Lemmas | ∀ {n m k : ℕ}, n + m + k = n + (m + k) | null | false |
_private.Mathlib.Analysis.InnerProductSpace.TensorProduct.0.TensorProduct.adjoint_map._simp_1_1 | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : 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]
{x y : TensorProduct 𝕜 E F}, (x = y) = ∀ (a : E) (b : F), inner 𝕜 x (a ⊗ₜ[𝕜] b) = inner 𝕜 y (a ⊗ₜ[𝕜] b) | null | false |
ContinuousLinearMap.smulRightₗ | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | {R : Type u_1} →
{S : Type u_2} →
{T : Type u_3} →
{M : Type u_4} →
{M₂ : Type u_5} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : Semiring T] →
[inst_3 : Module R S] →
[inst_4 : AddCommMonoid M₂] →
... | Given `c : E →L[R] S`, `c.smulRightₗ` is the linear map from `F` to `E →L[R] F`
sending `f` to `fun e => c e • f`. See also `ContinuousLinearMap.smulRightL`. | true |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.Extension.ofTwoCocycle._simp_9 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {L₂ : Type w}
[inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L →ₗ⁅R⁆ L₂) (x : L₂), (x ∈ f.range) = ∃ y, f y = x | null | false |
LinearMap.BilinForm.tensorDistribEquiv._proof_7 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_1) [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
Real.rpow_lt_one | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x z : ℝ}, 0 ≤ x → x < 1 → 0 < z → x ^ z < 1 | null | true |
_private.Mathlib.Algebra.QuadraticAlgebra.Discriminant.0.QuadraticAlgebra.nonempty_algEquiv_iff._proof_1_5 | Mathlib.Algebra.QuadraticAlgebra.Discriminant | ∀ {R : Type u_1} [inst : CommRing R] {b b' : R} (u : Rˣ) (k : R), b - ↑u * b' = 2 * k → b = ↑u * b' + 2 * k | null | false |
Substring.Raw.trimRight | Init.Data.String.Substring | Substring.Raw → Substring.Raw | Removes trailing whitespace from a substring by moving its end position to the last non-whitespace
character, or to its start position if there is no non-whitespace character.
“Whitespace” is defined as characters for which `Char.isWhitespace` returns `true`.
| true |
Irrational.div_cases | Mathlib.NumberTheory.Real.Irrational | ∀ {x y : ℝ}, Irrational (x / y) → Irrational x ∨ Irrational y | null | true |
QuadraticAlgebra.basis_repr_apply | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} (a b : R) [inst : Semiring R] (x : QuadraticAlgebra R a b),
⇑((QuadraticAlgebra.basis a b).repr x) = ![x.re, x.im] | null | true |
ContinuousLinearMap.toSeminormedRing._proof_15 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1) | null | false |
CategoryTheory.Subgroupoid.map.congr_simp | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {D : Type u_1} [inst_1 : CategoryTheory.Groupoid D]
(φ φ_1 : CategoryTheory.Functor C D) (e_φ : φ = φ_1) (hφ : Function.Injective φ.obj)
(S S_1 : CategoryTheory.Subgroupoid C),
S = S_1 → CategoryTheory.Subgroupoid.map φ hφ S = CategoryTheory.Subgroupoid.map φ_1 ⋯ ... | null | true |
Std.Http.Internal.Char.quotedPairChar.eq_2 | Std.Http.Internal.Char | Std.Http.Internal.Char.quotedPairChar ' ' = (true || Std.Http.Internal.Char.vchar ' ') | null | true |
_private.Mathlib.Algebra.Group.Torsion.0.pow_eq_one_iff._simp_1_1 | Mathlib.Algebra.Group.Torsion | ∀ {M : Type u_1} [inst : Monoid M] [IsMulTorsionFree M] {n : ℕ} {a : M}, n ≠ 0 → (a ^ n = 1) = (a = 1) | null | false |
_private.Mathlib.LinearAlgebra.Vandermonde.0.Matrix.det_vandermonde_eq_zero_iff._simp_1_2 | Mathlib.LinearAlgebra.Vandermonde | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
CategoryTheory.Limits.IsInitial.ofIso.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z : C} (hY : CategoryTheory.Limits.IsInitial Y)
(i : Y ≅ Z),
hY.ofIso i =
CategoryTheory.Limits.IsColimit.ofIsoColimit hY
{ hom := { hom := i.hom, w := ⋯ }, inv := { hom := i.inv, w := ⋯ }, hom_inv_id := ⋯, inv_hom_id := ⋯ } | null | true |
Lean.Elab.Command.elabOpenPrivate | Batteries.Tactic.OpenPrivate | Lean.Elab.Command.CommandElab | Elaborator for `open private`. | true |
Lean.Meta.Cases.Context._sizeOf_1 | Lean.Meta.Tactic.Cases | Lean.Meta.Cases.Context → ℕ | null | false |
Order.IsSuccLimit.le_iff_forall_le | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a b : α} [inst : LinearOrder α], Order.IsSuccLimit a → (a ≤ b ↔ ∀ c < a, c ≤ b) | null | true |
Std.WP.Spec.throw_ExceptT | Std.WP.Triple.SpecLemmas | ∀ {m : Type u → Type v} {Pred EPred : Type u} [inst : Monad m] [inst_1 : Std.WP.Assertion Pred]
[inst_2 : Std.WP.Assertion EPred] [inst_3 : Std.WP.WPMonad m Pred EPred] {ε α : Type u} (err : ε) (post : α → Pred)
(epost : (ε → Pred) × EPred), ⦃ epost.1 err ⦄ MonadExceptOf.throw err ⦃ post; epost ⦄ | null | true |
IsLeftUniformGroup.recOn | Mathlib.Topology.Algebra.IsUniformGroup.Defs | {G : Type u_4} →
[inst : UniformSpace G] →
[inst_1 : Group G] →
{motive : IsLeftUniformGroup G → Sort u} →
(t : IsLeftUniformGroup G) →
([toIsTopologicalGroup : IsTopologicalGroup G] →
(uniformity_eq : uniformity G = Filter.comap (fun x => x.1⁻¹ * x.2) (nhds 1)) → motive ⋯) →... | null | false |
ContinuousLinearMap.semiring._proof_6 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_2} [inst : Semiring R₁] {M₁ : Type u_1} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] [inst_4 : ContinuousAdd M₁],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Basic.0.MeasureTheory.lintegral_max._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_3} (p : α → Prop), {a | ¬p a} = {a | p a}ᶜ | null | false |
Std.TreeSet.Raw.contains_iff_mem._simp_1 | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} {k : α}, (t.contains k = true) = (k ∈ t) | null | false |
Subrelation | Init.Core | {α : Sort u} → (α → α → Prop) → (α → α → Prop) → Prop | `Subrelation q r` means that `q ⊆ r` or `∀ x y, q x y → r x y`.
It is the analogue of the subset relation on relations.
| true |
_private.Mathlib.Algebra.MvPolynomial.Equiv.0.MvPolynomial.sumRingEquiv_symm_C_C._simp_1_1 | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R] (r : R),
MvPolynomial.C (MvPolynomial.C r) = (MvPolynomial.sumRingEquiv R S₁ S₂) (MvPolynomial.C r) | null | false |
_private.Mathlib.Topology.DiscreteSubset.0.discreteTopology_biUnion_finset._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X}, DiscreteTopology ↑s = IsDiscrete s | null | false |
Std.IterM.IsPlausibleNthOutputStep.rec | Init.Data.Iterators.Consumers.Monadic.Access | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β]
{motive :
(a : ℕ) →
(a_1 : Std.IterM m β) →
(a_2 : Std.IterStep (Std.IterM m β) β) → Std.IterM.IsPlausibleNthOutputStep a a_1 a_2 → Prop},
(∀ {it' : Std.IterM m β} {out : β} {it : Std.IterM m β} (a : it.IsPlausibleStep (Std.IterSt... | null | false |
Polynomial.isFixedPt_newtonMap_of_aeval_eq_zero | Mathlib.Dynamics.Newton | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Polynomial R}
{x : S}, (Polynomial.aeval x) P = 0 → Function.IsFixedPt P.newtonMap x | null | true |
_private.Init.Data.SInt.Lemmas.0.Int64.toInt_eq_toNatClampNeg._simp_1_1 | Init.Data.SInt.Lemmas | ∀ (x : Int64), x.toNatClampNeg = x.toInt.toNat | null | false |
Task.Priority | Init.Core | Type | Task priority.
Tasks with higher priority will always be scheduled before tasks with lower priority. Tasks with a
priority greater than `Task.Priority.max` are scheduled on dedicated threads.
| true |
ModuleCat.restrictCoextendScalarsAdj | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : Ring R] → [inst_1 : Ring S] → (f : R →+* S) → ModuleCat.restrictScalars f ⊣ ModuleCat.coextendScalars f | Restriction of scalars is left adjoint to coextension of scalars. | true |
Lean.AttributeKind.noConfusion | Lean.Attributes | {P : Sort v✝} → {x y : Lean.AttributeKind} → x = y → Lean.AttributeKind.noConfusionType P x y | null | false |
DFA.union | Mathlib.Computability.DFA | {α : Type u} → {σ1 σ2 : Type v} → DFA α σ1 → DFA α σ2 → DFA α (σ1 × σ2) | DFAs are closed under union. | true |
IsSelfAdjoint.norm_le_max_of_le_of_le | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a b c : A},
a ≤ b → b ≤ c → autoParam (IsSelfAdjoint b) IsSelfAdjoint.norm_le_max_of_le_of_le._auto_1 → ‖b‖ ≤ max ‖a‖ ‖c‖ | null | true |
DomAddAct.instAddCommGroupOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [AddCommGroup Mᵃᵒᵖ] → AddCommGroup Mᵈᵃᵃ | null | true |
List.kunion._f | Mathlib.Data.List.Sigma | {α : Type u} →
{β : α → Type v} →
[DecidableEq α] →
(x : List (Sigma β)) →
List.below (motive := fun x => List (Sigma β) → List (Sigma β)) x → List (Sigma β) → List (Sigma β) | null | false |
MeasureTheory.unifTight_congr_ae | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup β] {f : ι → α → β} {p : ENNReal} {g : ι → α → β},
(∀ (n : ι), f n =ᵐ[μ] g n) → (MeasureTheory.UnifTight f p μ ↔ MeasureTheory.UnifTight g p μ) | If two functions agree a.e., then one is tight iff the other is tight. | true |
MvPolynomial.optionEquivLeft_symm_C_C | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) [inst : CommSemiring R] (x : R),
(MvPolynomial.optionEquivLeft R S₁).symm (Polynomial.C (MvPolynomial.C x)) = MvPolynomial.C x | null | true |
IO.Error.invalidArgument | Init.System.IOError | Option String → UInt32 → String → IO.Error | An argument to an I/O operation was invalid.
This corresponds to the POSIX errors `ELOOP`, `ENAMETOOLONG`, `EDESTADDRREQ`, `EILSEQ`, `EINVAL`, `EDOM`, `EBADF`
`ENOEXEC`, `ENOSTR`, `ENOTCONN`, and `ENOTSOCK`.
| true |
Nat.dfoldRev_add._proof_8 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, n + m ≤ n + m | null | false |
TopCommRingCat.instFunLikeSubtypeRingHomαContinuousCoe | Mathlib.Topology.Category.TopCommRingCat | (R S : TopCommRingCat) → FunLike { f // Continuous ⇑f } R.α S.α | null | true |
Mathlib.Tactic.Linarith.ExprMap | Mathlib.Tactic.Linarith.Parsing | Type | `ExprMap` is used to record atomic expressions which have been seen while processing inequality
expressions.
| true |
_private.Mathlib.Data.EReal.Operations.0.EReal.mul_bot_of_pos.match_1_1 | Mathlib.Data.EReal.Operations | ∀ (motive : (x : EReal) → 0 < x → Prop) (x : EReal) (x_1 : 0 < x),
(∀ (h : 0 < ⊥), motive none h) →
(∀ (x : ℝ) (h : 0 < ↑x), motive (some (some x)) h) → (∀ (x : 0 < ⊤), motive (some none) x) → motive x x_1 | null | false |
ONote.sub.eq_2 | Mathlib.SetTheory.Ordinal.Notation | ∀ (x : ONote), (x = ONote.zero → False) → x.sub ONote.zero = x | null | true |
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_inverse_obj_pt | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [inst_1 : CategoryTheory.Limits.HasCoproduct I.left]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.right]
(a :
CategoryTheory.Limits.Cofork
(I.fstSigmaMapOf... | null | true |
QPF.SuppPreservation | Mathlib.Data.QPF.Univariate.Basic | {F : Type u → Type u} → [q : QPF F] → Prop | does `abs` preserve `supp`? | true |
inv_mul_le_of_le_mul | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulLeftMono α] {a b c : α}, a ≤ b * c → b⁻¹ * a ≤ c | **Alias** of the reverse direction of `inv_mul_le_iff_le_mul`. | true |
PadicAlgCl.isAlgebraic | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], Algebra.IsAlgebraic ℚ_[p] (PadicAlgCl p) | `PadicAlgCl p` is an algebraic extension of `ℚ_[p]`. | true |
PositiveContinuousLinearMap.instFunLike | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Positive | {R : Type u_1} →
{E₁ : Type u_2} →
{E₂ : Type u_3} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid E₁] →
[inst_2 : PartialOrder E₁] →
[inst_3 : AddCommMonoid E₂] →
[inst_4 : PartialOrder E₂] →
[inst_5 : Module R E₁] →
[inst_6 : Mo... | null | true |
HahnEmbedding.Seed.hahnCoeff._proof_1 | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K], RingHomInvPair (RingHom.id K) (RingHom.id K) | null | false |
NormalSpace.of_compactSpace_r1Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [CompactSpace X] [R1Space X], NormalSpace X | null | true |
AddGroupFilterBasis.noConfusion | Mathlib.Topology.Algebra.FilterBasis | {P : Sort u_1} →
{A : Type u} →
{inst : AddGroup A} →
{t : AddGroupFilterBasis A} →
{A' : Type u} →
{inst' : AddGroup A'} →
{t' : AddGroupFilterBasis A'} → A = A' → inst ≍ inst' → t ≍ t' → AddGroupFilterBasis.noConfusionType P t t' | null | false |
AddGroupSeminorm.toSeminormedAddCommGroup.eq_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_2} [inst : AddCommGroup E] (f : AddGroupSeminorm E),
f.toSeminormedAddCommGroup =
{ toNorm := f.toSeminormedAddGroup.toNorm, toAddGroup := f.toSeminormedAddGroup.toAddGroup, add_comm := ⋯,
toPseudoMetricSpace := f.toSeminormedAddGroup.toPseudoMetricSpace, dist_eq := ⋯ } | null | true |
Rat.sqrt | Mathlib.Data.Rat.Sqrt | ℚ → ℚ | Square root function on rational numbers, defined by taking the (integer) square root of the
numerator and the square root (on natural numbers) of the denominator. | true |
Lean.PersistentArray.findSomeRevM? | Lean.Data.PersistentArray | {α : Type u} →
{m : Type v → Type w} → [Monad m] → {β : Type v} → Lean.PersistentArray α → (α → m (Option β)) → m (Option β) | null | true |
DenselyNormedField.rec | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_3} →
{motive : DenselyNormedField α → Sort u} →
([toNormedField : NormedField α] →
(lt_norm_lt : ∀ (x y : ℝ), 0 ≤ x → x < y → ∃ a, x < ‖a‖ ∧ ‖a‖ < y) →
motive { toNormedField := toNormedField, lt_norm_lt := lt_norm_lt }) →
(t : DenselyNormedField α) → motive t | null | false |
UpperSet.coe_Ioi | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] (a : α), ↑(UpperSet.Ioi a) = Set.Ioi a | null | true |
CategoryTheory.Arrow.AugmentedCechNerve.ExtraDegeneracy.s._proof_2 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] (n : ℕ),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom | null | false |
AffineBasis.coe_smul._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {ι : Type u_1} {G : Type u_3} {k : Type u_5} {V : Type u_6} [inst : AddCommGroup V] [inst_1 : Ring k]
[inst_2 : Module k V] [inst_3 : Group G] [inst_4 : DistribMulAction G V] [inst_5 : SMulCommClass G k V] (a : G)
(b : AffineBasis ι k V), a • ⇑b = ⇑(a • b) | null | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabNameMkStr._regBuiltin.Lean.PrettyPrinter.Delaborator.delabNameMkStr_3 | Lean.PrettyPrinter.Delaborator.Builtins | IO Unit | null | false |
Lean.Meta.Match.Pattern.recOn | Lean.Meta.Match.Basic | {motive_1 : Lean.Meta.Match.Pattern → Sort u} →
{motive_2 : List Lean.Meta.Match.Pattern → Sort u} →
(t : Lean.Meta.Match.Pattern) →
((e : Lean.Expr) → motive_1 (Lean.Meta.Match.Pattern.inaccessible e)) →
((fvarId : Lean.FVarId) → motive_1 (Lean.Meta.Match.Pattern.var fvarId)) →
((ctorName... | null | false |
QuotientAddGroup.mk' | Mathlib.GroupTheory.QuotientGroup.Defs | {G : Type u_1} → [inst : AddGroup G] → (N : AddSubgroup G) → [nN : N.Normal] → G →+ G ⧸ N | The additive group homomorphism from `G` to `G/N`. | true |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.antisymm_aux.match_1_1 | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Finset α} ⦃a : α⦄ (motive : (∃ b ∈ s, b ∉ s ∧ a ≤ b) → Prop)
(x : ∃ b ∈ s, b ∉ s ∧ a ≤ b), (∀ (_b : α) (hb₁ : _b ∈ s) (hb₂ : _b ∉ s) (right : a ≤ _b), motive ⋯) → motive x | null | false |
CategoryTheory.BiconeHom.decidableEq._proof_20 | Mathlib.CategoryTheory.Limits.Bicones | ∀ (J : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} J] (j : J)
(g : CategoryTheory.BiconeHom J CategoryTheory.Bicone.right (CategoryTheory.Bicone.diagram j)),
g ≍ CategoryTheory.BiconeHom.right j → CategoryTheory.BiconeHom.right j = g | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.