name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.instInterOfBEq_batteries | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → Inter (List α) | null | true |
Lean.Meta.Simp.Context.simpTheorems._default | Lean.Meta.Tactic.Simp.Types | Lean.Meta.SimpTheoremsArray | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.setWidth_ofNat_of_le_of_lt._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w v x : ℕ}, ¬1 < 2 → False | null | false |
LinearMap.range_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : I... | null | true |
Int.gcd_mul_lcm | Init.Data.Int.Gcd | ∀ (m n : ℤ), m.gcd n * m.lcm n = m.natAbs * n.natAbs | null | true |
RelEmbedding.natLT._proof_2 | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {r : α → α → Prop} [IsStrictOrder α r] (f : ℕ → α),
(∀ (n : ℕ), r (f n) (f (n + 1))) → ∀ ⦃a b : ℕ⦄, a < b → r (f a) (f b) | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace.0.volumePreservingSymmMeasurableEquivToLpProdAux._proof_5 | Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace | ∀ (U : Type u_1) [inst : NormedAddCommGroup U] [inst_1 : InnerProductSpace ℝ U], BorelSpace (PiLp 2 fun x => ℝ) | null | false |
CategoryTheory.Limits.isoZeroBiprod_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (hY : CategoryTheory.Limits.IsZero X),
(CategoryTheory.Limits.isoZeroBiprod hY).inv = CategoryTheory.Limits.biprod.snd | null | true |
Std.HashMap.Raw.getElem?_filter' | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [LawfulBEq α]
{f : α → β → Bool} {k : α}, m.WF → (Std.HashMap.Raw.filter f m)[k]? = Option.filter (f k) m[k]? | Simpler variant of `getElem?_filter` when `LawfulBEq` is available. | true |
Real.arcsin_nonpos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, Real.arcsin x ≤ 0 ↔ x ≤ 0 | null | true |
CategoryTheory.NatIso.pi._proof_2 | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type u_3} {C : I → Type u_1} [inst : (i : I) → CategoryTheory.Category.{u_5, u_1} (C i)] {D : I → Type u_4}
[inst_1 : (i : I) → CategoryTheory.Category.{u_2, u_4} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)}
(e : (i : I) → F i ≅ G i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTra... | null | false |
MulOpposite.instSemifield._proof_3 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [inst : Semifield α] (n : ℕ) (a : αᵐᵒᵖ),
DivisionSemiring.zpow (↑n.succ) a = DivisionSemiring.zpow (↑n) a * a | null | false |
Batteries.mkHashMap | Batteries.Data.HashMap.Basic | {α : Type u_1} → {β : Type u_2} → [inst : BEq α] → [inst_1 : Hashable α] → optParam ℕ 0 → Batteries.HashMap α β | Make a new hash map with the specified capacity. | true |
Action.FunctorCategoryEquivalence.unitIso_inv_app_hom | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] (X : Action V G),
(Action.FunctorCategoryEquivalence.unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.V | null | true |
posMulReflectLT_iff | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ (α : Type u_1) [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α],
PosMulReflectLT α ↔ ContravariantClass { x // 0 ≤ x } α (fun x y => ↑x * y) fun x1 x2 => x1 < x2 | null | true |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.Const.minEntry.match_1._arg_pusher | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3)
(α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → α_1 → Prop)
(x : Std.DTreeMap.Internal.Impl α fun x => β)... | null | false |
SubalgebraClass.toAlgebra._proof_6 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {S : Type u_2} {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [SubsemiringClass S A] [hSR : SMulMemClass S R A] (s : S) (r : R), (algebraMap R A) r ∈ s | null | false |
_private.Mathlib.MeasureTheory.Integral.TorusIntegral.0.term___ | Mathlib.MeasureTheory.Integral.TorusIntegral | Lean.TrailingParserDescr | null | true |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖᵒᵖ)
(n m : ℤ) (hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._auto_1),
(CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso C n).inv.app X =
... | null | true |
dvd_mul | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : CommSemigroup α] [DecompositionMonoid α] {k m n : α},
k ∣ m * n ↔ ∃ d₁ d₂, d₁ ∣ m ∧ d₂ ∣ n ∧ k = d₁ * d₂ | null | true |
Subsemiring.instMin._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (s t : Subsemiring R) {a b : R},
a ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier →
b ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier → a * b ∈ (s.toSubmonoid ⊓ t.toSubmonoid).carrier | null | false |
Lean.Name.isAtomic | Lean.Data.Name | Lean.Name → Bool | null | true |
Lean.LibrarySuggestions.Suggestion.name | Lean.LibrarySuggestions.Basic | Lean.LibrarySuggestions.Suggestion → Lean.Name | null | true |
Set.addAntidiagonal_mono_left | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : Add α] {s₁ s₂ t : Set α} {a : α}, s₁ ⊆ s₂ → s₁.addAntidiagonal t a ⊆ s₂.addAntidiagonal t a | null | true |
LinearEquiv.ofSubmodules_symm_apply | Mathlib.Algebra.Module.Submodule.Equiv | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂}
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (e : ... | null | true |
Fintype.card_coe | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} (s : Finset α) [inst : Fintype ↥s], Fintype.card ↥s = s.card | null | true |
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.ctorIdx | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} → CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → ℕ | null | false |
SimpleGraph.hasse | Mathlib.Combinatorics.SimpleGraph.Hasse | (α : Type u_1) → [Preorder α] → SimpleGraph α | The Hasse diagram of an order as a simple graph. The graph of the covering relation. | true |
_private.Mathlib.Data.Int.Cast.Basic.0.Int.cast_neg.match_1_1 | Mathlib.Data.Int.Cast.Basic | ∀ (motive : ℤ → Prop) (x : ℤ),
(∀ (a : Unit), motive (Int.ofNat 0)) →
(∀ (n : ℕ), motive (Int.ofNat n.succ)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
Finsupp.Internal.elabSingle₀ | Mathlib.Data.Finsupp.Notation | Lean.Elab.Term.TermElab | `Finsupp` elaborator for `single₀`. | true |
GenContFract.IntFractPair.one_le_succ_nth_stream_b | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
[inst_3 : FloorRing K] {ifp_succ_n : GenContFract.IntFractPair K},
GenContFract.IntFractPair.stream v (n + 1) = some ifp_succ_n → 1 ≤ ifp_succ_n.b | Shows that the integer parts of the stream are at least one. | true |
Set.subset_insert_diff_singleton | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (x : α) (s : Set α), s ⊆ insert x (s \ {x}) | **Alias** of `Set.subset_insert_sdiff_singleton`. | true |
AddGroupSeminormClass.toSeminormedAddGroup._proof_2 | Mathlib.Analysis.Normed.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddGroup α] [AddGroupSeminormClass F α ℝ] (f : F)
(x y : α), f (-x + y) = f (-y + x) | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.LinearIsometryEquiv.conjStarAlgEquiv_ext_iff._simp_1_5 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_4}
... | null | false |
RestrictedProduct.mul_apply | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Mul (R i)] [inst_2 : ∀ (i : ι), MulMemClass (S i) (R i)]
(x y : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (i : ι), (x * y) i = x i * y i | null | true |
_private.Lean.Server.References.0.Lean.Server.findModuleRefs._sparseCasesOn_1 | Lean.Server.References | {motive : Lean.Lsp.RefIdent → Sort u} →
(t : Lean.Lsp.RefIdent) →
((moduleName id : String) → motive (Lean.Lsp.RefIdent.fvar moduleName id)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.slice_lt_slice_iff._simp_1_3 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
OrderIsoClass.toSupHomClass | Mathlib.Order.Hom.Lattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : EquivLike F α β] [inst_1 : SemilatticeSup α]
[inst_2 : SemilatticeSup β] [OrderIsoClass F α β], SupHomClass F α β | null | true |
CategoryTheory.CommComon.instCategory._proof_9 | Mathlib.CategoryTheory.Monoidal.CommComon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {W X Y Z : CategoryTheory.CommComon C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruc... | null | false |
Lean.Meta.DSimp.Config.failIfUnchanged | Init.MetaTypes | Lean.Meta.DSimp.Config → Bool | If `failIfUnchanged` is `true` (default: `true`), then calls to `simp`, `dsimp`, or `simp_all`
will fail if they do not make progress.
| true |
Lean.Omega.instDecidableEqConstraint.decEq.match_1 | Init.Omega.Constraint | (motive : Lean.Omega.Constraint → Lean.Omega.Constraint → Sort u_1) →
(x x_1 : Lean.Omega.Constraint) →
((a : Lean.Omega.LowerBound) →
(a_1 : Lean.Omega.UpperBound) →
(b : Lean.Omega.LowerBound) →
(b_1 : Lean.Omega.UpperBound) →
motive { lowerBound := a, upperBound := a... | null | false |
CategoryTheory.FreeMonoidalCategory.instMonoidalCategory._proof_4 | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u_1} {X Y : CategoryTheory.FreeMonoidalCategory C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(Quot.map
(fun f => CategoryTheory.FreeMonoidalCategory.Hom.whiskerLeft CategoryTheory.FreeMonoidalCategory.unit f) ⋯ f)
{ hom := ⟦CategoryTheory.FreeMonoidalCategory.Hom.l_hom Y⟧,
... | null | false |
Composition.ext_iff | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {x y : Composition n}, x = y ↔ x.blocks = y.blocks | null | true |
CharacterModule.int | Mathlib.Algebra.Module.CharacterModule | Type | `ℤ⋆`, the character module of `ℤ` in the unit rational circle.
| true |
AddMonoidHom.mker.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F), AddMonoidHom.mker f = AddSubmonoid.comap f ⊥ | null | true |
Lean.ConstantKind._sizeOf_1 | Lean.Environment | Lean.ConstantKind → ℕ | null | false |
Matroid.mem_closure_sdiff_singleton_iff_closure._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax | null | false |
StarConvex.add_left | Mathlib.Analysis.Convex.Star | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {x : E} {s : Set E}, StarConvex 𝕜 x s → ∀ (z : E), StarConvex 𝕜 (z + x) ((fun x => z + x) '' s) | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.expandAssert._regBuiltin.Lean.Elab.Term.expandAssert.declRange_3 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
PowerSeries.X_dvd_iff | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R}, PowerSeries.X ∣ φ ↔ PowerSeries.constantCoeff φ = 0 | null | true |
CategoryTheory.Limits.hasFiniteWidePullbacks_of_hasFiniteLimits | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteLimits C],
CategoryTheory.Limits.HasFiniteWidePullbacks C | Finite wide pullbacks are finite limits, so if `C` has all finite limits,
it also has finite wide pullbacks
| true |
Real.lt_pow_iff_log_lt | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x y : ℝ} {n : ℕ}, 0 < x → 0 < y → (x < y ^ n ↔ Real.log x < ↑n * Real.log y) | null | true |
CategoryTheory.Abelian.PullbackToBiproductIsKernel.pullbackToBiproduct._proof_2 | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C},
CategoryTheory.Limits.HasBinaryBiproduct X Y | null | false |
MulEquiv.toGrpIso_hom | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} (e : ↑X ≃* ↑Y), e.toGrpIso.hom = GrpCat.ofHom e.toMonoidHom | null | true |
PSigma.fst | Init.Core | {α : Sort u} → {β : α → Sort v} → PSigma β → α | The first component of a dependent pair.
| true |
Char.leRefl | Init.Data.Char.Lemmas | Std.Refl fun x1 x2 => x1 ≤ x2 | null | true |
Lean.Widget.PanelWidgetsExtEntry.ctorElim | Lean.Widget.UserWidget | {motive : Lean.Widget.PanelWidgetsExtEntry → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Widget.PanelWidgetsExtEntry) →
ctorIdx = t.ctorIdx → Lean.Widget.PanelWidgetsExtEntry.ctorElimType ctorIdx → motive t | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.factorization_succ_le_sub_one | Mathlib.NumberTheory.Bernoulli | ∀ {p d : ℕ} [Fact (Nat.Prime p)], d ≥ 2 → (d + 1).factorization p ≤ d - 1 | null | true |
PeriodPair.not_continuousAt_weierstrassP | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), ∀ x ∈ L.lattice, ¬ContinuousAt L.weierstrassP x | null | true |
CategoryTheory.ObjectProperty.IsCardinalFilteredGenerator.presentable | Mathlib.CategoryTheory.Presentable.CardinalFilteredPresentation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {κ : Cardinal.{w}}
[inst_1 : Fact κ.IsRegular],
P.IsCardinalFilteredGenerator κ →
∀ [CategoryTheory.LocallySmall.{w, v, u} C] (X : C), CategoryTheory.IsPresentable.{w, v, u} X | null | true |
FormalMultilinearSeries.rightInv._proof_15 | Mathlib.Analysis.Analytic.Inverse | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousAdd F | null | false |
MeasureTheory.Submartingale.sum_mul_sub' | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0}
[MeasureTheory.IsFiniteMeasure μ] {R : ℝ} {ξ f : ℕ → Ω → ℝ},
MeasureTheory.Submartingale f 𝒢 μ →
(MeasureTheory.StronglyAdapted 𝒢 fun n => ξ (n + 1)) →
(∀ (n : ℕ) (ω : Ω), ξ n ω ≤ R) →
(∀... | Given a discrete submartingale `f` and a predictable process `ξ` (i.e. `ξ (n + 1)` is strongly
adapted) the process defined by `fun n => ∑ k ∈ Finset.range n, ξ (k + 1) * (f (k + 1) - f k)` is
also a submartingale. | true |
Ideal.Quotient.instRingQuotient | Mathlib.RingTheory.Ideal.Quotient.Defs | {R : Type u_1} → [inst : CommRing R] → (I : Ideal R) → Ring (R ⧸ I) | null | true |
Polynomial.expand.eq_1 | Mathlib.Algebra.Polynomial.Expand | ∀ (R : Type u) [inst : CommSemiring R] (p : ℕ),
Polynomial.expand R p = { toRingHom := Polynomial.eval₂RingHom Polynomial.C (Polynomial.X ^ p), commutes' := ⋯ } | null | true |
_private.Mathlib.RingTheory.FractionalIdeal.Extended.0.FractionalIdeal.extended_ne_zero._simp_1_1 | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{I J : FractionalIdeal S P}, (I = J) = (↑I = ↑J) | null | false |
Std.Legacy.Range.«_aux_Init_Data_Range_Basic___macroRules_Std_Legacy_Range_term[_:_:_]_1» | Init.Data.Range.Basic | Lean.Macro | null | false |
IsPurelyInseparable.instNonemptyAlgHomOfPerfectField | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [IsPurelyInseparable F E]
(L : Type u_2) [inst_4 : Field L] [PerfectField L] [inst_6 : Algebra F L], Nonempty (E →ₐ[F] L) | null | true |
CategoryTheory.Pseudofunctor.StrongTrans.whiskerRight_naturality_comp_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {F G : CategoryTheory.Pseudofunctor B CategoryTheory.Cat}
(η : F ⟶ G) {a b c : B} {a' : CategoryTheory.Cat} (f : a ⟶ b) (g : b ⟶ c) (h : G.obj c ⟶ a') (X : ↑(F.obj a)),
CategoryTheory.CategoryStruct.comp
(h.toFunctor.map ((η.naturality (CategoryTheory.Cate... | null | true |
Graph.bouquet_isLoopAt | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} (v : α) (edgeSet : Set β),
(Graph.bouquet v edgeSet).IsLoopAt e x ↔ e ∈ edgeSet ∧ x = v | null | true |
SSet.Truncated.ev12₂._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2} (φ : V.obj (Opposite.op { obj := { len := 2 }, property := SSet.Truncated.ι0₂._proof_3 })),
(CategoryTheory.ConcreteCategory.hom
(V.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op))
((CategoryTheory.ConcreteCategory.hom (V.map SS... | null | false |
Lean.Elab.Tactic.elabLinarithConfig | Lean.Elab.Tactic.Grind.Config | Lean.Syntax → optParam Lean.Grind.LinarithConfig { } → optParam Bool true → Lean.Elab.Tactic.TacticM Lean.Grind.Config | null | true |
Int.Linear.Poly.isUnsatEq.eq_2 | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly), (∀ (k : ℤ), p = Int.Linear.Poly.num k → False) → p.isUnsatEq = false | null | true |
CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor_map_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasProduct I.left]
[inst_2 : CategoryTheory.Limits.HasProduct I.right] {K₁ K₂ : CategoryTheory.Limits.Multifork I} (f : K₁ ⟶ K₂),
(... | null | true |
IsCoveringMapOn | Mathlib.Topology.Covering.Basic | {E : Type u_1} → {X : Type u_2} → [TopologicalSpace E] → [TopologicalSpace X] → (E → X) → Set X → Prop | A covering map is a continuous function `f : E → X` with discrete fibers such that each point
of `X` has an evenly covered neighborhood. | true |
Finset.sup'_singleton | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] (f : β → α) {b : β}, {b}.sup' ⋯ f = f b | null | true |
Lean.Compiler.CSimp.State.casesOn | Lean.Compiler.CSimpAttr | {motive : Lean.Compiler.CSimp.State → Sort u} →
(t : Lean.Compiler.CSimp.State) →
((map : Lean.SMap Lean.Name Lean.Compiler.CSimp.Entry) →
(thmNames : Lean.SSet Lean.Name) → motive { map := map, thmNames := thmNames }) →
motive t | null | false |
MeasureTheory.Measure.rnDeriv_smul_same | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (ν μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure ν]
[ν.HaveLebesgueDecomposition μ] {r : NNReal}, r ≠ 0 → (r • ν).rnDeriv (r • μ) =ᵐ[μ] ν.rnDeriv μ | null | true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestImpl.evalSuggestCore._sparseCasesOn_1 | Lean.Elab.Tactic.Try | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
EisensteinSeries.E2_eq_tsum_cexp | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ (z : UpperHalfPlane),
EisensteinSeries.E2 z =
1 - 24 * ∑' (n : ℕ+), ↑((ArithmeticFunction.sigma 1) ↑n) * Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ ↑n | The q-expansion of the normalised weight-2 Eisenstein series:
`E₂(z) = 1 - 24 ∑_{n≥1} σ₁(n) qⁿ`. | true |
Lean.Doc.Inline.link.elim | Lean.DocString.Types | {i : Type u} →
{motive_1 : Lean.Doc.Inline i → Sort u_1} →
(t : Lean.Doc.Inline i) →
t.ctorIdx = 6 →
((content : Array (Lean.Doc.Inline i)) → (url : String) → motive_1 (Lean.Doc.Inline.link content url)) →
motive_1 t | null | false |
AddOreLocalization.add_cancel | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {r : R} {s t : ↥S},
↑s -ₒ t + (r -ₒ s) = r -ₒ t | null | true |
Lean.Meta.Sym.Arith.getPowFn | Lean.Meta.Sym.Arith.Functions | {m : Type → Type} →
[MonadLiftT Lean.MetaM m] →
[Lean.MonadError m] →
[Monad m] → [Lean.Meta.Sym.Arith.MonadCanon m] → [Lean.Meta.Sym.Arith.MonadRing m] → m Lean.Expr | null | true |
Module.Invertible.rTensorEquiv_symm_apply_apply | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} {M : Type v} {N : Type u_1} (P : Type u_2) (Q : Type u_3) [inst : CommSemiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q]
(e : TensorProduct R ... | null | true |
Lean.Grind.NatModule.mk._flat_ctor | Init.Grind.Module.Basic | {M : Type u} →
(zero : M) →
(add : M → M → M) →
(∀ (a : M), a + 0 = a) →
(∀ (a b : M), a + b = b + a) →
(∀ (a b c : M), a + b + c = a + (b + c)) →
[nsmul : SMul ℕ M] →
(∀ (a : M), 0 • a = 0) → (∀ (n : ℕ) (a : M), (n + 1) • a = n • a + a) → Lean.Grind.NatModule M | null | false |
CategoryTheory.ExponentiableMorphism.coev_ev_assoc | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I J : C} (f : I ⟶ J)
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] [inst_2 : CategoryTheory.ExponentiableMorphism f]
(Y : CategoryTheory.Over I) {Z : CategoryTheory.Over J}
(h : (CategoryTheory.ExponentiableMorphism.pushforward f).obj Y ⟶ Z),
Category... | The second triangle identity for the counit and unit of the adjunction. | true |
ContinuousLinearMap.isEmbedding_postcomp | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂]
[inst_2 : NormedField 𝕜₃] {σ : 𝕜₁ →+* 𝕜₂} {τ : 𝕜₂ →+* 𝕜₃} {ρ : 𝕜₁ →+* 𝕜₃} [inst_3 : RingHomCompTriple σ τ ρ]
{E : Type u_4} {F : Type u_5} {G : Type u_6} [inst_4 : AddCommGroup E] [inst_5 : Module 𝕜₁ E]
... | null | true |
MonoidHom.coe_prod | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : MulOneClass P]
(f : M →* N) (g : M →* P), ⇑(f.prod g) = Function.prod ⇑f ⇑g | null | true |
MeasureTheory.SimpleFunc.sup_eq_map₂ | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Max β] (f g : MeasureTheory.SimpleFunc α β),
f ⊔ g = MeasureTheory.SimpleFunc.map (fun p => p.1 ⊔ p.2) (f.pair g) | null | true |
HilbertSpace._sizeOf_inst | Mathlib.Analysis.InnerProductSpace.Defs | (𝕜 : Type u_4) →
(E : Type u_5) →
{inst : RCLike 𝕜} →
{inst_1 : NormedAddCommGroup E} →
{inst_2 : InnerProductSpace 𝕜 E} →
{inst_3 : CompleteSpace E} → [SizeOf 𝕜] → [SizeOf E] → SizeOf (HilbertSpace 𝕜 E) | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop_actionUnitIso_hom | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) [inst_3 : F.Monoidal] (d : D),
(CategoryTheory.MonoidalCategory.MonoidalLeftActi... | null | true |
LaurentSeries.coeff_zero_of_lt_valuation | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] {n D : ℤ} {f : LaurentSeries K},
Valued.v f ≤ WithZero.exp (-D) → n < D → f.coeff n = 0 | The coefficients of a Laurent series vanish in degree strictly less than its valuation. | true |
ModuleCat.extendRestrictScalarsAdj | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] → (f : R →+* S) → ModuleCat.extendScalars f ⊣ ModuleCat.restrictScalars f | Given commutative rings `R, S` and a ring hom `f : R →+* S`, the extension and restriction of
scalars by `f` are adjoint to each other.
| true |
Algebra.SubmersivePresentation.cotangentEquiv_apply | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (x : P.toExtension.Cotangent)
(a : σ), P.cotangentEquiv x a = P.cotangentComplexAux x a | null | true |
Std.Slice.forIn_iter | Std.Data.Iterators.Lemmas.Producers.Slice | ∀ {α : Type v} {γ : Type u} {β : Type v} {m : Type w → Type x} [inst : Monad m] {δ : Type w}
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
{s : Std.Slice γ} {init : δ} {f : β → δ → m (ForInStep δ)}, forIn s.iter init f = forIn s init f | null | true |
Nat.log_pos_iff._simp_1 | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, (0 < Nat.log b n) = (b ≤ n ∧ 1 < b) | null | false |
Lean.Elab.Do.ReturnCont.resultType | Lean.Elab.Do.Basic | Lean.Elab.Do.ReturnCont → Lean.Expr | null | true |
OreLocalization.instDivisionRingNonZeroDivisors._proof_3 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : Nontrivial R] [inst_2 : NoZeroDivisors R]
[inst_3 : OreLocalization.OreSet (nonZeroDivisors R)] (a b : OreLocalization (nonZeroDivisors R) R), a / b = a * b⁻¹ | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_eq_maxKeyD._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Commute.add_left._simp_1 | Mathlib.Algebra.Ring.Commute | ∀ {R : Type u} [inst : Distrib R] {a b c : R}, Commute a c → Commute b c → Commute (a + b) c = True | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.bipartiteDoubleCover.match_1.splitter._sparseCasesOn_5 | Mathlib.Combinatorics.SimpleGraph.Bipartite | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.