name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ENNReal.ofReal_rpow_of_pos | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x p : ℝ}, 0 < x → ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p) | null | true |
Lean.Parser.suppressInsideQuot | Lean.Parser.Basic | Lean.Parser.Parser → Lean.Parser.Parser | null | true |
Path.Homotopic.equivalence | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ : X}, Equivalence Path.Homotopic | null | true |
PredOrder.pred | Mathlib.Order.SuccPred.Basic | {α : Type u_3} → {inst : Preorder α} → [self : PredOrder α] → α → α | Predecessor function | true |
Stream'.Seq.mem_cons_of_mem | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (y : α) {a : α} {s : Stream'.Seq α}, a ∈ s → a ∈ Stream'.Seq.cons y s | null | true |
_private.Mathlib.Analysis.FunctionalSpaces.SobolevInequality.0.«_aux_Mathlib_Analysis_FunctionalSpaces_SobolevInequality___macroRules__private_Mathlib_Analysis_FunctionalSpaces_SobolevInequality_0_term#__1» | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | Lean.Macro | null | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._simp_1_5 | Mathlib.Probability.ProductMeasure | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.IsZeroOrProbabilityMeasure μ]
{s : Set α}, (μ s ≤ 1) = True | null | false |
_private.Mathlib.LinearAlgebra.PiTensorProduct.Basis.0.Basis.piTensorProduct_apply._simp_1_1 | Mathlib.LinearAlgebra.PiTensorProduct.Basis | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) = (f = g) | null | false |
Filter.Germ.liftPred_const | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {x : β}, p x → Filter.Germ.LiftPred p ↑x | null | true |
Lean.Elab.Term.LetIdDeclView.recOn | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetIdDeclView → Sort u} →
(t : Lean.Elab.Term.LetIdDeclView) →
((id : Lean.Syntax) →
(binders : Array Lean.Syntax) →
(type value : Lean.Syntax) → motive { id := id, binders := binders, type := type, value := value }) →
motive t | null | false |
SummationFilter.NeBot.ne_bot | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_2} {L : SummationFilter β} [self : L.NeBot], L.filter.NeBot | null | true |
Mathlib.Tactic.TFAE.Parser.impFrom.formatter | Mathlib.Tactic.TFAE | Lean.PrettyPrinter.Formatter | null | true |
CategoryTheory.Bicategory.postcomposing₂_obj_app_toFunctor_obj | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (a b : B) (f : a ⟶ b) (x : Bᵒᵖ) (x_1 : Opposite.unop x ⟶ a),
(((CategoryTheory.Bicategory.postcomposing₂ a b).obj f).app x).toFunctor.obj x_1 =
CategoryTheory.CategoryStruct.comp x_1 f | null | true |
ContFract.instCoeGenContFract | Mathlib.Algebra.ContinuedFractions.Basic | {α : Type u_1} → [inst : One α] → [inst_1 : Zero α] → [inst_2 : LT α] → Coe (ContFract α) (GenContFract α) | Lift a cf to a scf using the inclusion map. | true |
Set.Nonempty.right | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty → t.Nonempty | null | true |
_private.Init.Data.String.Lemmas.Iterate.0.String.foldl.eq_1 | Init.Data.String.Lemmas.Iterate | ∀ {α : Type u} (f : α → Char → α) (init : α) (s : String), String.foldl f init s = String.Slice.foldl f init s.toSlice | null | true |
CategoryTheory.MonoidalCategory.DayConvolutionUnit.noConfusion | Mathlib.CategoryTheory.Monoidal.DayConvolution | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{V : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} V} →
{inst_2 : CategoryTheory.MonoidalCategory C} →
{inst_3 : CategoryTheory.MonoidalCategory V} →
{F : CategoryTheory.Functor C... | null | false |
Nat.range_nth_of_infinite | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop}, (setOf p).Infinite → Set.range (Nat.nth p) = setOf p | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_filter_iff._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (p : α → Bool) (x : Option α), (Option.any p x = true) = ∃ y, x = some y ∧ p y = true | null | false |
CategoryTheory.Retract.projective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Retract X Y)
[p : CategoryTheory.Projective Y], CategoryTheory.Projective X | null | true |
LinearMap.toMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {M₂ : Type u_2} [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂],
SMulCommClass R R M₂ | null | false |
continuous_iff_ultrafilter | Mathlib.Topology.Ultrafilter | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f ↔ ∀ (x : X) (g : Ultrafilter X), ↑g ≤ nhds x → Filter.Tendsto f (↑g) (nhds (f x)) | null | true |
Filter.map₂_inf_subset_left | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g : Filter β},
Filter.map₂ m (f₁ ⊓ f₂) g ≤ Filter.map₂ m f₁ g ⊓ Filter.map₂ m f₂ g | null | true |
NumberField.Units.regOfFamily_div_regulator | Mathlib.NumberTheory.NumberField.Units.Regulator | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(u : Fin (NumberField.Units.rank K) → (NumberField.RingOfIntegers K)ˣ),
NumberField.Units.regOfFamily u / NumberField.Units.regulator K =
↑(Subgroup.closure (Set.range u) ⊔ NumberField.Units.torsion K).index | Let `u` be a family of units. Then the ratio `regOfFamily u / regulator K` is equal to the index
of the subgroup generated by `u` and `torsion K` inside the group of units of `K`.
| true |
StandardEtalePair.lift.eq_1 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : StandardEtalePair R) (x : S) (h : P.HasMap x),
P.lift x h =
Ideal.Quotient.liftₐ (Ideal.span {Polynomial.C P.f, Polynomial.X * Polynomial.C P.g - 1})
(Polynomial.aevalAeval x ↑⋯.unit⁻¹) ⋯ | null | true |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.comp.match_1.eq_4 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1}
(motive : CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → Sort u_2)
(x : CategoryTheory.WithTerminal C) (_Y : C)
(h_1 :
(_X _Y _Z : C) →
motive (CategoryTheory.WithTerminal.of _X) (CategoryTheory.WithTerminal.of _Y)
(CategoryTheory... | null | true |
NNReal.exists_pow_lt_of_lt_one | Mathlib.Data.NNReal.Defs | ∀ {a b : NNReal}, 0 < a → b < 1 → ∃ n, b ^ n < a | null | true |
IsFractionRing.isAlgebraic_iff | Mathlib.RingTheory.Localization.Integral | ∀ (A : Type u_3) (K : Type u_4) (C : Type u_5) [inst : CommRing A] [IsDomain A] [inst_2 : Field K]
[inst_3 : Algebra A K] [IsFractionRing A K] [inst_5 : CommRing C] [inst_6 : Algebra A C] [inst_7 : Algebra K C]
[IsScalarTower A K C] {x : C}, IsAlgebraic A x ↔ IsAlgebraic K x | An element of a ring is algebraic over the ring `A` iff it is algebraic
over the field of fractions of `A`.
| true |
Sym2.IsDiag._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x x_1 : α), (x = x_1) = (x_1 = x) | null | false |
Quiver.Path.length_eq_zero_iff._simp_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {V : Type u_1} [inst : Quiver V] {a : V} (p : Quiver.Path a a), (p.length = 0) = (p = Quiver.Path.nil) | null | false |
idRestrGroupoid._proof_3 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H],
∃ s, ∃ (h : IsOpen s), OpenPartialHomeomorph.refl H ≈ OpenPartialHomeomorph.ofSet s h | null | false |
RatFunc.CompletionAtInfty | Mathlib.FieldTheory.RatFunc.Valuation | (F : Type u_1) → [inst : Field F] → [DecidableEq (RatFunc F)] → Type u_1 | The completion `F((t⁻¹))` of `F(t)` with respect to the valuation at infinity. | true |
BitVec.ushiftRight_eq_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ}, w ≤ n → x >>> n = 0#w | Shifting right by `n`, which is larger than the bitwidth `w` produces `0. | true |
MeasureTheory.Filtration.piFinset | Mathlib.Probability.Process.Filtration | {ι : Type u_4} →
{X : ι → Type u_5} → [inst : (i : ι) → MeasurableSpace (X i)] → MeasureTheory.Filtration (Finset ι) MeasurableSpace.pi | The filtration of events which only depends on finitely many coordinates
on the product space `Π i, X i`, `piFinset s` consists of measurable sets depending only on
coordinates in `s`, where `s : Finset ι`. | true |
_private.Mathlib.Tactic.Abel.0.Mathlib.Tactic.Abel.eval._sparseCasesOn_5 | Mathlib.Tactic.Abel | {motive : Lean.Literal → Sort u} →
(t : Lean.Literal) →
((val : ℕ) → motive (Lean.Literal.natVal val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
isSaddlePointOn_value | Mathlib.Order.SaddlePoint | ∀ {E : Type u_1} {F : Type u_2} {β : Type u_3} {X : Set E} {Y : Set F} {f : E → F → β} [inst : CompleteLinearOrder β]
{a : E},
a ∈ X →
∀ {b : F}, b ∈ Y → IsSaddlePointOn X Y f a b → ⨅ x ∈ X, ⨆ y ∈ Y, f x y = f a b ∧ ⨆ y ∈ Y, ⨅ x ∈ X, f x y = f a b | Minimax formulation of saddle points | true |
PrimeSpectrum.BasicConstructibleSetData.mk.sizeOf_spec | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} [inst : SizeOf R] (f : R) (n : ℕ) (g : Fin n → R),
sizeOf { f := f, n := n, g := g } = 1 + sizeOf f + sizeOf n | null | true |
CpltSepUniformSpace.coe_of | Mathlib.Topology.Category.UniformSpace | ∀ (X : Type u) [inst : UniformSpace X] [inst_1 : CompleteSpace X] [inst_2 : T0Space X], (CpltSepUniformSpace.of X).α = X | null | true |
_private.Mathlib.Algebra.Exact.Sequence.0.Module.sum_neg_one_pow_finrank_eq_zero_of_exact_six._simp_1_1 | Mathlib.Algebra.Exact.Sequence | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {P : Type u_6} {P' : Type u_7} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid P']
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R P'] {f : M →ₗ[R] N}
{g... | null | false |
Fin.image_succ_Ioc | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.succ '' Set.Ioc i j = Set.Ioc i.succ j.succ | null | true |
Std.HashSet.Raw.get!_diff | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α]
[inst_4 : Inhabited α], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ \ m₂).get! k = if k ∈ m₂ then default else m₁.get! k | null | true |
_private.Mathlib.RingTheory.LocalProperties.InjectiveDimension.0.ModuleCat.localizedModule_hasInjectiveDimensionLE._simp_1_1 | Mathlib.RingTheory.LocalProperties.InjectiveDimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C},
CategoryTheory.HasInjectiveDimensionLT X 1 = CategoryTheory.Injective X | null | false |
Std.DTreeMap.Internal.Impl.empty | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Impl α β | An empty tree. | true |
ContinuousMapZero.nonUnitalStarAlgHom_precomp | Mathlib.Topology.ContinuousMap.ContinuousMapZero | {X : Type u_1} →
{Y : Type u_2} →
(R : Type u_4) →
[inst : Zero X] →
[inst_1 : Zero Y] →
[inst_2 : TopologicalSpace X] →
[inst_3 : TopologicalSpace Y] →
[inst_4 : TopologicalSpace R] →
[inst_5 : CommSemiring R] →
[inst_6 : StarRin... | The functor `C(·, R)₀` from topological spaces with zero (and `ContinuousMapZero` maps) to
non-unital star algebras. | true |
_private.Init.Data.String.Slice.0.String.Slice.eqIgnoreAsciiCase.go._unary._proof_2 | Init.Data.String.Slice | ∀ (s1 s2 : String.Slice) (s1Curr s2Curr : String.Pos.Raw),
s1Curr < s1.rawEndPos ∧ s2Curr < s2.rawEndPos → s2Curr < s2.rawEndPos | null | false |
StieltjesFunction.instModuleNNReal._proof_1 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (c : NNReal) (f : StieltjesFunction R),
Monotone fun x => ↑c * ↑f x | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone.0.NumberField.mixedEmbedding.fundamentalCone.mem_integerSet._simp_1_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
AddValuation.map_lt_sum | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{ι : Type u_6} {s : Finset ι} {f : ι → R} {g : Γ₀}, g ≠ ⊤ → (∀ i ∈ s, g < v (f i)) → g < v (∑ i ∈ s, f i) | null | true |
UInt16.toUInt8_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ},
UInt16.size ≤ n →
(UInt16.ofNatClamp n).toUInt8 = UInt8.ofNatLT (UInt8.size - 1) UInt16.toUInt8_ofNatClamp_of_le._proof_1 | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.adj_incidenceSet_inter._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {α : Type u} {s : Set α} {p : α → Prop} {x : α}, (x ∈ {x | x ∈ s ∧ p x}) = (x ∈ s ∧ p x) | null | false |
_private.Mathlib.SetTheory.Cardinal.NatCount.0.Nat.count_le_setENCard._simp_1_1 | Mathlib.SetTheory.Cardinal.NatCount | ∀ {c : Cardinal.{u}} {n : ℕ}, (↑n ≤ Cardinal.toENat c) = (↑n ≤ c) | null | false |
CategoryTheory.ObjectProperty.limitsClosure.below.of_mem | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)]
{motive : (a : C) → P.limitsClosure J a → Prop} (X : C) (hX : P X),
CategoryTheory.ObjectProperty.limitsClosure.below ⋯ | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.isStarProjection_iff_eq_starProjection_range._simp_1_2 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {f g : M₁ →SL[σ₁₂] M₂}... | null | false |
Set.Icc_top | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, Set.Icc a ⊤ = Set.Ici a | null | true |
Filter.tendsto_div_const_atBot_iff | Mathlib.Order.Filter.AtTopBot.Field | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {l : Filter β}
{f : β → α} {r : α} [l.NeBot],
Filter.Tendsto (fun x => f x / r) l Filter.atBot ↔
0 < r ∧ Filter.Tendsto f l Filter.atBot ∨ r < 0 ∧ Filter.Tendsto f l Filter.atTop | The function `fun x ↦ f x / r` tends to negative infinity along a nontrivial filter
if and only if `r > 0` and `f` tends to negative infinity or `r < 0` and `f` tends to infinity. | true |
RatFunc._sizeOf_inst | Mathlib.FieldTheory.RatFunc.Defs | (K : Type u) → {inst : CommRing K} → [SizeOf K] → SizeOf (RatFunc K) | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopTreeTarget.x | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} → (self : Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopTreeTarget aig w) → aig.RefVec (self.len * w) | null | true |
Subgroup.ofUnitsEquivType._proof_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Subgroup Mˣ) (x : ↥S.ofUnits), ↑x ∈ S.ofUnits | null | false |
Lean.Meta.Grind.SplitStatus.ready | Lean.Meta.Tactic.Grind.Split | ℕ → optParam Bool false → optParam Bool false → Lean.Meta.Grind.SplitStatus | null | true |
CategoryTheory.ObjectProperty.instNonemptyUnopOfOpposite | Mathlib.CategoryTheory.ObjectProperty.Opposite | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ) [P.Nonempty],
P.unop.Nonempty | null | true |
tprod_setProd_singleton_right | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] (s : Set β) (c : γ)
(f : β × γ → α), ∏' (x : ↑(s ×ˢ {c})), f ↑x = ∏' (b : ↑s), f (↑b, c) | null | true |
Lean.Export.Entry.ctorIdx | Mathlib.Util.Export | Lean.Export.Entry → ℕ | null | false |
RingCat.instConcreteCategoryRingHomCarrier._proof_4 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y Z : RingCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | null | false |
Finset.iSup_singleton | Mathlib.Order.CompleteLattice.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (a : α) (s : α → β), ⨆ x ∈ {a}, s x = s a | null | true |
Std.ExtTreeMap.minKeyD_insertIfNew_of_isEmpty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, t.isEmpty = true → ∀ {fallback : α}, (t.insertIfNew k v).minKeyD fallback = k | null | true |
LieSubmodule.normalizer._proof_3 | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [LieModule R L M]
(N : LieSubmodule R L M) (t : R), ∀ m ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N}, ∀ (x : L), ⁅x, t • m⁆ ∈ N | null | false |
minpoly.dvd_iff | Mathlib.FieldTheory.Minpoly.Field | ∀ {A : Type u_1} {B : Type u_2} [inst : Field A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} {p : Polynomial A},
minpoly A x ∣ p ↔ (Polynomial.aeval x) p = 0 | null | true |
_private.Mathlib.Order.Types.Defs.0.OrderType.lift._proof_1 | Mathlib.Order.Types.Defs | ∀ (_α : Type u_1) (x : LinearOrder _α) (_β : Type u_1) (x_1 : LinearOrder _β),
OrderType.type _α = OrderType.type _β → OrderType.type (ULift.{u_2, u_1} _α) = OrderType.type (ULift.{u_2, u_1} _β) | null | false |
Lean.Meta.Grind.TopSort.State._sizeOf_1 | Lean.Meta.Tactic.Grind.EqResolution | Lean.Meta.Grind.TopSort.State → ℕ | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_310 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
¬(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] 0] = 0 →
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (... | null | false |
CategoryTheory.GradedObject.ι_mapBifunctorComp₂₃MapObjIso_hom_assoc | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.insertUnitInvariant_insertUnit.match_1_16 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (assignments0 : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(assignments0_size : assignments0.size = n)
(units : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (assignments_size : assignments.size = n)
(i... | null | false |
Equiv.subtypeProdEquivProd._proof_3 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {q : β → Prop} (x : { c // p c.1 ∧ q c.2 }), p (↑x).1 | null | false |
commHopfAlgCatEquivCogrpCommAlgCat._proof_9 | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ (R : Type u_1) [inst : CommRing R],
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id (CommHopfAlgCat R)))
(CategoryTheory.CategoryStruct.id
({ obj := fun A => Opposite.op { X := Opposite.op (CommAlgCat.of R ↑A), grp := CommAlgCat.grpObjOpOf },
... | null | false |
_private.Init.Data.List.TakeDrop.0.List.dropWhile_beq_eq_self_of_head?_ne._simp_1_1 | Init.Data.List.TakeDrop | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
LinearMap.toContinuousLinearMap.congr_simp | 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 |
List.zipWithLeft'TR.go._unsafe_rec | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (α → Option β → γ) → List α → List β → Array γ → List γ × List β | null | false |
IO.FS.realPath | Init.System.IO | System.FilePath → IO System.FilePath | Resolves a path to an absolute path that contains no '.', '..', or symbolic links.
This function coincides with the [POSIX `realpath`
function](https://pubs.opengroup.org/onlinepubs/9699919799/functions/realpath.html).
| true |
Derivation.mk'._proof_2 | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_3} [inst : CommSemiring R] {A : Type u_2} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {M : Type u_1}
[inst_3 : AddCancelCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] (D : A →ₗ[R] M),
(∀ (a b : A), D (a * b) = a • D b + b • D a) → D 1 = 0 | null | false |
ShrinkingLemma.PartialRefinement.rec | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
{motive : ShrinkingLemma.PartialRefinement u s p → Sort u} →
((toFun : ι → Set X) →
(carrier : Set ι) →
(isOp... | null | false |
Set.biUnion_diff_biUnion_subset | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} (t : α → Set β) (s₁ s₂ : Set α), (⋃ x ∈ s₁, t x) \ ⋃ x ∈ s₂, t x ⊆ ⋃ x ∈ s₁ \ s₂, t x | **Alias** of `Set.biUnion_sdiff_biUnion_subset`. | true |
SimpleGraph.IsMatchingFree | Mathlib.Combinatorics.SimpleGraph.Matching | {V : Type u_1} → SimpleGraph V → Prop | A graph is matching free if it has no perfect matching. It does not make much sense to
consider a graph being free of just matchings, because any non-trivial graph has those.
| true |
WeierstrassCurve.Jacobian.negY_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} (X Y Z : R),
W'.negY ![X, Y, Z] = -Y - W'.a₁ * X * Z - W'.a₃ * Z ^ 3 | null | true |
SemiRingCat.limitSemiring._proof_10 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections],
autoParam
(∀ (x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt),
... | null | false |
ContinuousLinearMap.module._proof_1 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R : Type u_1} {R₃ : Type u_2} {S₃ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₃] [inst_2 : Semiring S₃]
{M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid M] [inst_5 : Module R M] {M₃ : Type u_4}
[inst_6 : TopologicalSpace M₃] [inst_7 : AddCommMonoid M₃] [inst_8 : Module R₃ M₃] [inst_9 ... | null | false |
Std.Http.Server.mk._flat_ctor | Std.Http.Server | Std.CancellationContext →
Std.Mutex ℕ →
Option Std.Semaphore → Std.Channel Unit → Std.Http.Config → Option Std.Net.SocketAddress → Std.Http.Server | null | false |
invertibleSucc | Mathlib.Algebra.CharP.Invertible | {K : Type u_2} → [inst : DivisionSemiring K] → [CharZero K] → (n : ℕ) → Invertible ↑n.succ | null | true |
CategoryTheory.Limits.coconeOpEquiv_counitIso | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C},
CategoryTheory.Limits.coconeOpEquiv.counitIso =
CategoryTheory.Iso.refl
({ obj := fun c => Opposite.op c.unop, map := fun {x x_1} f => Opposite.op { hom... | null | true |
ContinuousMultilinearMap.iteratedFDerivComponent._proof_3 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_5} {ι : Type u_1} {E₁ : ι → Type u_4} {G : Type u_2} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E₁ i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E₁ i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] {α : Type u_3}
[inst_6 : Fintyp... | null | false |
List.getElem_modifyHead._proof_3 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {l : List α} {f : α → α} {i : ℕ}, i < (List.modifyHead f l).length → i < l.length | null | false |
Function.Periodic.map_vadd_multiples | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddCommMonoid α],
Function.Periodic f c → ∀ (a : ↥(AddSubmonoid.multiples c)) (x : α), f (a +ᵥ x) = f x | null | true |
Lean.Doc.instFromDocArgMessageSeverity | Lean.Elab.DocString | Lean.Doc.FromDocArg Lean.MessageSeverity | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_505 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
integral_log_sin_zero_pi | Mathlib.Analysis.SpecialFunctions.Integrals.LogTrigonometric | ∫ (x : ℝ) in 0..Real.pi, Real.log (Real.sin x) = -Real.log 2 * Real.pi | The integral of `log ∘ sin` on `0 … π` equals `-log 2 * π`.
| true |
AddMonoidHom.coprod_inl_inr | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_6} {N : Type u_7} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N],
(AddMonoidHom.inl M N).coprod (AddMonoidHom.inr M N) = AddMonoidHom.id (M × N) | null | true |
ArithmeticFunction.sigma_one | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (k : ℕ), (ArithmeticFunction.sigma k) 1 = 1 | null | true |
List.head_attach | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α} (h : xs.attach ≠ []), xs.attach.head h = ⟨xs.head ⋯, ⋯⟩ | null | true |
_private.Mathlib.NumberTheory.LSeries.AbstractFuncEq.0.WeakFEPair.f_modif_aux2._simp_1_1 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {α : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : SMulZeroClass R M] (s : Set α) (r : α → R)
(f : α → M), (fun a => r a • s.indicator f a) = s.indicator fun a => r a • f a | null | false |
AddChar | Mathlib.Algebra.Group.AddChar | (A : Type u_1) → [AddMonoid A] → (M : Type u_2) → [Monoid M] → Type (max u_1 u_2) | `AddChar A M` is the type of maps `A → M`, for `A` an additive monoid and `M` a multiplicative
monoid, which intertwine addition in `A` with multiplication in `M`.
We only put the typeclasses needed for the definition, although in practice we are usually
interested in much more specific cases (e.g. when `A` is a group... | true |
CategoryTheory.Pretriangulated.Triangle.rotate_mor₃ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C),
T.rotate.mor₃ = -(CategoryTheory.shiftFunctor C 1).map T.mor₁ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.