name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ENNReal.isConjExponent_iff_eq_conjExponent | Mathlib.Basic.Real.ConjExponents | ∀ {p q : ENNReal}, 1 ≤ p → (p.HolderConjugate q ↔ q = 1 + (p - 1)⁻¹) | null | true |
_private.Mathlib.Algebra.Category.Ring.Basic.0.CommSemiRingCat.Hom.ext.match_1 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommSemiRingCat} (motive : R.Hom S → Prop) (h : R.Hom S),
(∀ (hom' : ↑R →+* ↑S), motive { hom' := hom' }) → motive h | null | false |
CategoryTheory.MorphismProperty.rlp_isStableUnderProductsOfShape | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C) (J : Type u_1),
T.rlp.IsStableUnderProductsOfShape J | null | true |
Aesop.GoalData.mvars | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → Aesop.UnorderedArraySet Lean.MVarId | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toList._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 |
UInt64.toUInt32_toUSize | Init.Data.UInt.Lemmas | ∀ (n : UInt64), n.toUSize.toUInt32 = n.toUInt32 | null | true |
CategoryTheory.Functor.IsEventuallyConstantFrom.coconeιApp_eq_id | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] {F : CategoryTheory.Functor J C} {i₀ : J}
(h : F.IsEventuallyConstantFrom i₀) [inst_2 : CategoryTheory.IsFiltered J],
h.coconeιApp i₀ = CategoryTheory.CategoryStruct.id (F.obj i₀) | null | true |
Std.Rcc.Sliceable.recOn | Init.Data.Slice.Notation | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : Std.Rcc.Sliceable α β γ → Sort u_1} →
(t : Std.Rcc.Sliceable α β γ) → ((mkSlice : α → Std.Rcc β → γ) → motive { mkSlice := mkSlice }) → motive t | null | false |
String.Pos.prev! | Init.Data.String.FindPos | {s : String} → s.Pos → s.Pos | Returns the previous valid position before the given position, or panics if the position is
the start position. | true |
CategoryTheory.Sum.swapCompInl | Mathlib.CategoryTheory.Sums.Basic | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(CategoryTheory.Sum.inl_ C D).comp (CategoryTheory.Sum.swap C D) ≅ CategoryTheory.Sum.inr_ D C | Precomposing `swap` with the left inclusion gives the right inclusion. | true |
Cardinal.power_mul | Mathlib.SetTheory.Cardinal.Order | ∀ {a b c : Cardinal.{u_1}}, a ^ (b * c) = (a ^ b) ^ c | null | true |
Batteries.BinomialHeap.Imp.FindMin.mk | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
(Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α) →
α → Batteries.BinomialHeap.Imp.HeapNode α → Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.FindMin α | null | true |
Matrix.SpecialLinearGroup.map_intCast_injective | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] [CharZero R],
Function.Injective ⇑(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) | null | true |
MvPowerSeries.coeff_mul_left_one_sub_of_lt_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} (w : σ → ℕ) {R : Type u_3} [inst : Ring R] {f g : MvPowerSeries σ R} {d : σ →₀ ℕ},
↑((Finsupp.weight w) d) < MvPowerSeries.weightedOrder w g →
(MvPowerSeries.coeff d) (f * (1 - g)) = (MvPowerSeries.coeff d) f | null | true |
DirichletCharacter.LSeries_ne_zero_of_one_lt_re | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ}, 1 < s.re → LSeries (fun n => χ ↑n) s ≠ 0 | The L-series of a Dirichlet character does not vanish on the right half-plane `re s > 1`. | true |
Std.Internal.instPureForInList | Std.Internal.ForIn.Lemmas | ∀ {m : Type u → Type v} [inst : Monad m] {α : Type u₁}, Std.Internal.PureForIn m (List α) α | null | true |
ContinuousAffineMap.instSub._proof_1 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_4} {V : Type u_3} {W : Type u_2} {P : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace W] [IsTopologicalAddGroup W] (f g : P →ᴬ[R] W), Continuous (... | null | false |
Equiv.apply_swap_eq_self | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} [inst : DecidableEq α] {v : α → β} {i j : α},
v i = v j → ∀ (k : α), v ((Equiv.swap i j) k) = v k | A function is invariant to a swap if it is equal at both elements | true |
Std.Rio.pairwise_toList_upwardEnumerableLt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite α], List... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_empty._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Std.TreeMap.isEmpty_emptyc | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, ∅.isEmpty = true | null | true |
_private.Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions.0.hasMFDerivAt_inr._simp_1_1 | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
Int.neg_modEq_neg._simp_1 | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ}, (-a ≡ -b [ZMOD n]) = (a ≡ b [ZMOD n]) | null | false |
SimpleGraph.Walk.isSubwalk_nil_iff_mem_support._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v' : V} (p : G.Walk u v), SimpleGraph.Walk.nil.IsSubwalk p = (v' ∈ p.support) | null | false |
TopRep.Hom.toTopModuleCatHom._proof_1 | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u_2} {G : Type u_3} [inst : TopologicalSpace k] [inst_1 : Ring k] [inst_2 : Monoid G] {A : TopRep k G},
ContinuousAdd ↑A | null | false |
CliffordAlgebra.changeFormEquiv._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q Q' : QuadraticForm R M} {B : LinearMap.BilinForm R M} (h : LinearMap.BilinMap.toQuadraticMap B = Q' - Q)
(x : CliffordAlgebra Q), (CliffordAlgebra.changeForm ⋯) ((CliffordAlgebra.changeForm h) x) = x | null | false |
Std.DTreeMap.Raw.WF.casesOn | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{t : Std.DTreeMap.Raw α β cmp} →
{motive : t.WF → Sort u_1} → (t_1 : t.WF) → ((out : t.inner.WF) → motive ⋯) → motive t_1 | null | false |
IsCyclotomicExtension.Rat.zeta_sub_one_dvd_intCast_iff | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p k : ℕ) [hp : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] {ζ : K} (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))) {n : ℤ},
hζ.toInteger - 1 ∣ ↑n ↔ ↑p ∣ n | An integer `n` is divisible by `ζ - 1` in `𝓞 K` if and only if it is divisible by `p`,
where `ζ` is a primitive `p ^ (k + 1)`-th root of unity. | true |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_iff_exists._simp_1_3 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (a b : G), f a - f b = f (a - b) | null | false |
Part.getOrElse_of_not_dom | Mathlib.Data.Part | ∀ {α : Type u_1} (a : Part α), ¬a.Dom → ∀ [inst : Decidable a.Dom] (d : α), a.getOrElse d = d | null | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex_left | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {A : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} A] {X : C}
(data : F.PreOneHypercoverDenseData X) (P : CategoryTheory.Functor C₀ᵒᵖ A) (i : data.multicospa... | null | true |
Mathlib.TacticAnalysis.TacticNode.ctxI | Mathlib.Tactic.TacticAnalysis | Mathlib.TacticAnalysis.TacticNode → Lean.Elab.ContextInfo | `ContextInfo` at the infotree node. | true |
Set.Ico_subset_Icc_union_Ico | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a c ⊆ Set.Icc a b ∪ Set.Ico b c | null | true |
_private.Init.Data.String.Decode.0.String.utf8EncodeChar_eq_utf8EncodeCharFast._proof_1_12 | Init.Data.String.Decode | ∀ (c : Char), ¬c.val.toNat ≤ 2047 → c.val.toNat ≤ 65535 → ¬c.val.toNat / 2 ^ 12 < 256 → False | null | false |
Equiv.group.eq_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : Group β], e.group = Function.Injective.group ⇑e ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ | null | true |
Submonoid.orderOf_le_card | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : Group G] (s : Submonoid G), (↑s).Finite → ∀ {x : G}, x ∈ s → orderOf x ≤ Nat.card ↥s | null | true |
_private.Mathlib.Data.Fintype.Quotient.0.Quotient.list_ind.match_1_1 | Mathlib.Data.Fintype.Quotient | ∀ {ι : Type u_1} (motive : (a : ι) → a ∈ [] → Prop) (a : ι) (a_1 : a ∈ []), motive a a_1 | null | false |
IsCoveringMap.exists_path_lifts | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X},
IsCoveringMap p → ∀ (γ : C(↑unitInterval, X)) (e : E), γ 0 = p e → ∃ Γ, p ∘ ⇑Γ = ⇑γ ∧ Γ 0 = e | The path lifting property (existence) for covering maps. | true |
String.isNat_iff | Std.Data.String.ToNat | ∀ {s : String},
s.isNat = true ↔
s ≠ "" ∧
(∀ c ∈ s.toList, c.isDigit = true ∨ c = '_') ∧
¬['_', '_'] <:+: s.toList ∧ s.toList.head? ≠ some '_' ∧ s.toList.getLast? ≠ some '_' | null | true |
MvPolynomial.algebraTensorAlgEquiv_symm_monomial | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ (R : Type u) [inst : CommSemiring R] {σ : Type u_1} (A : Type u_4) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(m : σ →₀ ℕ) (a : A),
(MvPolynomial.algebraTensorAlgEquiv R A).symm ((MvPolynomial.monomial m) a) = a ⊗ₜ[R] (MvPolynomial.monomial m) 1 | null | true |
Nat.doubleFactorial.eq_2 | Mathlib.Data.Nat.Factorial.DoubleFactorial | Nat.doubleFactorial 1 = 1 | null | true |
PresentedGroup.mk_eq_mk_of_inv_mul_mem | Mathlib.GroupTheory.PresentedGroup | ∀ {α : Type u_1} {rels : Set (FreeGroup α)} {x y : FreeGroup α},
x⁻¹ * y ∈ rels → (PresentedGroup.mk rels) x = (PresentedGroup.mk rels) y | null | true |
Std.Ric.LawfulRcoIntersection.mk | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type w} [inst : LT α] [inst_1 : LE α] [inst_2 : Std.Ric.HasRcoIntersection α],
(∀ {a : α} {r : Std.Ric α} {s : Std.Rco α}, a ∈ Std.Ric.HasRcoIntersection.intersection r s ↔ a ∈ r ∧ a ∈ s) →
Std.Ric.LawfulRcoIntersection α | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0.Char.reduceToString._regBuiltin.Char.reduceToString.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.3888730479._hygCtx._hyg.27 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | null | false |
CategoryTheory.MorphismProperty.RightFraction.rec | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
{motive : W.RightFraction X Y → Sort u} →
({X' : C} → (s : X' ⟶ X) → (hs : W s) → (f : X' ⟶ Y) → motive { X' := X', s := s, hs := hs, f := f }) →
(t : W.RightF... | null | false |
CategoryTheory.ObjectProperty.ContainsUnit.mk | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{P : CategoryTheory.ObjectProperty C}, P (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) → P.ContainsUnit | null | true |
MeasureTheory.Measure.ext_prod₃_iff' | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_4} {β : Type u_5} {γ : Type u_6} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {μ ν : MeasureTheory.Measure ((α × β) × γ)} [MeasureTheory.IsFiniteMeasure μ],
μ = ν ↔
∀ {s : Set α} {t : Set β} {u : Set γ},
MeasurableSet s → MeasurableSet t → MeasurableSet u → μ ((... | Two finite measures on a product `(α × β) × γ` are equal iff they are equal on products of sets.
See `ext_prod₃_iff` for the same statement for `α × β × γ`. | true |
Std.Iterators.Types.Map | Init.Data.Iterators.Combinators.Monadic.FilterMap | Type w →
{β γ : Type w} →
(m : Type w → Type w') →
(n : Type w → Type w'') →
(⦃α : Type w⦄ → m α → n α) → [Functor n] → (β → Std.Iterators.PostconditionT n γ) → Type w | Internal state of the `map` combinator. Do not depend on its internals.
| true |
Qq.SortLocalDecls.Context | Qq.SortLocalDecls | Type | null | true |
Std.TreeSet.max!_erase_eq_of_not_compare_max!_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).isEmpty = false → ¬cmp k t.max! = Ordering.eq → (t.erase k).max! = t.max! | null | true |
List.length_sym._unary | Mathlib.Data.List.Sym | ∀ {α : Type u_1} (_x : (_ : ℕ) ×' List α), (List.sym _x.1 _x.2).length = _x.2.length.multichoose _x.1 | null | false |
Lean.Elab.WF.GuessLex.RecCallWithContext.mk.injEq | Lean.Elab.PreDefinition.WF.GuessLex | ∀ (ref : Lean.Syntax) (caller : ℕ) (params : Array Lean.Expr) (callee : ℕ) (args : Array Lean.Expr)
(ctxt : Lean.Elab.WF.GuessLex.SavedLocalContext) (ref_1 : Lean.Syntax) (caller_1 : ℕ) (params_1 : Array Lean.Expr)
(callee_1 : ℕ) (args_1 : Array Lean.Expr) (ctxt_1 : Lean.Elab.WF.GuessLex.SavedLocalContext),
({ re... | null | true |
Fin.add.match_1 | Init.Data.Fin.Basic | {n : ℕ} →
(motive : Fin n → Fin n → Sort u_1) →
(x x_1 : Fin n) → ((a : ℕ) → (h : a < n) → (b : ℕ) → (isLt : b < n) → motive ⟨a, h⟩ ⟨b, isLt⟩) → motive x x_1 | null | false |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go | Lean.Data.RArray | {α : Type u_1} → {n : ℕ} → (Fin n → α) → (lb ub : ℕ) → lb < ub → ub ≤ n → Lean.RArray α | null | true |
Polynomial.Chebyshev.coeff_le_of_forall_abs_le_one | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {n : ℕ} {P : Polynomial ℝ},
P.degree ≤ ↑n → (∀ x ∈ Set.Icc (-1) 1, |Polynomial.eval x P| ≤ 1) → P.coeff n ≤ 2 ^ (n - 1) | null | true |
CategoryTheory.MorphismProperty.Arrow.forget_comp_rightFunc_map | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P Q W : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] [inst_2 : W.IsMultiplicative] {A B : P.Arrow Q W} (f : A ⟶ B),
((CategoryTheory.MorphismProperty.Arrow.forget P Q W).comp CategoryTheory.Arrow.rightFunc).map f = f.right | Occasionally useful for rewriting in the backwards direction. | true |
Lean.instReprBinderInfo | Lean.Expr | Repr Lean.BinderInfo | null | true |
CategoryTheory.Arrow.augmentedCechNerve._proof_2 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
⦃X Y : SimplexCategoryᵒᵖ⦄ (f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.id (CategoryT... | null | false |
Mathlib.Meta.FunProp.Mor.isCoeFunName | Mathlib.Tactic.FunProp.Mor | Lean.Name → Lean.CoreM Bool | Is `name` a coercion from some function space to functions? | true |
BitVec._sizeOf_1 | Init.SizeOf | {w : ℕ} → BitVec w → ℕ | null | false |
QuadraticModuleCat.mk | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | {R : Type u} → [inst : CommRing R] → (toModuleCat : ModuleCat R) → QuadraticForm R ↑toModuleCat → QuadraticModuleCat R | null | true |
_private.Lean.Class.0.Lean.addClass._sparseCasesOn_1 | Lean.Class | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
((val : Lean.AxiomVal) → motive (Lean.ConstantInfo.axiomInfo val)) →
(Nat.hasNotBit 33 t.ctorIdx → motive t) → motive t | null | false |
irrational_sqrt_of_multiplicity_odd | Mathlib.NumberTheory.Real.Irrational | ∀ (m : ℤ), 0 < m → ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], multiplicity (↑p) m % 2 = 1 → Irrational √↑m | null | true |
PosNum.cast_to_num | Mathlib.Data.Num.Lemmas | ∀ (n : PosNum), ↑n = Num.pos n | null | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.getMatchLoop._proof_5 | Lean.Meta.Sym.Simp.DiscrTree | ∀ {α : Type} (cs : Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α)), ¬cs.size = 0 → ¬0 < cs.size → False | null | false |
ImportGraph.Shake.instReprImportNeeds | ImportGraph.Shake.DeclNeeds | Repr ImportGraph.Shake.ImportNeeds | null | true |
Std.Sat.CNF.Clause.not_unsat_unit._simp_1 | Std.Sat.CNF.Unit | ∀ {α : Type u_1} {atom : α} {p : Bool}, (Std.Sat.CNF.Clause.unit atom p).Unsat = False | null | false |
Lean.Lsp.DidOpenTextDocumentParams.recOn | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.DidOpenTextDocumentParams → Sort u} →
(t : Lean.Lsp.DidOpenTextDocumentParams) →
((textDocument : Lean.Lsp.TextDocumentItem) → motive { textDocument := textDocument }) → motive t | null | false |
Filter.instCountableInterFilterCountableGenerate | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u_1} (g : Set (Set α)), CountableInterFilter (Filter.countableGenerate g) | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs.0.CategoryTheory.IsPullback.isoIsPullback_inv_fst._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | null | false |
Aesop.EqualUpToIds.readAllowAssignmentDiff | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIdsM Bool | null | true |
Seminorm._sizeOf_inst | Mathlib.Analysis.Normed.Module.Seminorm.Basic | (𝕜 : Type u_12) →
(E : Type u_13) →
{inst : SeminormedRing 𝕜} →
{inst_1 : AddGroup E} → {inst_2 : SMul 𝕜 E} → [SizeOf 𝕜] → [SizeOf E] → SizeOf (Seminorm 𝕜 E) | null | false |
Matrix.exp_nsmul | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {m : Type u_1} {𝔸 : Type u_5} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NormedRing 𝔸] [NormedAlgebra ℚ 𝔸]
[CompleteSpace 𝔸] (n : ℕ) (A : Matrix m m 𝔸), NormedSpace.exp (n • A) = NormedSpace.exp A ^ n | null | true |
Module.Finite.of_localizationSpan_finite | Mathlib.RingTheory.Localization.Finiteness | ∀ {R : Type u} [inst : CommSemiring R] {M : Type w} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (t : Finset R),
Ideal.span ↑t = ⊤ →
(∀ (g : ↥t), Module.Finite (Localization.Away ↑g) (LocalizedModule.Away (↑g) M)) → Module.Finite R M | If there exists a finite set `{ r }` of `R` that generates the unit ideal and such that `Mᵣ` is
`Rᵣ`-finite for each `r`, then `M` is a finite `R`-module.
See `of_localizationSpan` for a version without the finite set assumption.
| true |
CategoryTheory.MorphismProperty.MapFactorizationData.ofIsEquivalence | Mathlib.CategoryTheory.MorphismProperty.Factorization | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{W₁ W₂ : CategoryTheory.MorphismProperty C} →
{F : CategoryTheory.Functor D C} →
[F.IsEquivalence] →
[W₁.RespectsIso] →
... | The term in `MapFactorizationData (W₁.inverseImage F) (W₂.inverseImage F) f`
deduced from `h : MapFactorizationData W₁ W₂ (F.map f)` when `F` is an equivalence
of categories and both `W₁` and `W₂` respect isomorphisms. | true |
MvPFunctor.M.Path._sizeOf_inst | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → (a : P.last.M) → (a_1 : Fin2 n) → SizeOf (MvPFunctor.M.Path P a a_1) | null | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabLit.match_1 | Lean.PrettyPrinter.Delaborator.Builtins | (motive : Lean.Literal → Sort u_1) →
(l : Lean.Literal) →
((n : ℕ) → motive (Lean.Literal.natVal n)) → ((s : String) → motive (Lean.Literal.strVal s)) → motive l | null | false |
MulHom.coeFn | Mathlib.Algebra.Group.Pi.Lemmas | (α : Type u_5) → (β : Type u_6) → [inst : Mul α] → [inst_1 : CommSemigroup β] → (α →ₙ* β) →ₙ* α → β | Coercion of a `MulHom` into a function is itself a `MulHom`.
See also `MulHom.eval`. | true |
Float.Model.UnpackedFloat.lt | Init.Data.Float.Model.Unpacked.Operations.Compare | Float.Model.UnpackedFloat → Float.Model.UnpackedFloat → Bool | Determines whether `a` is less than `b` according to IEEE rules.
This is not a total ordering.
| true |
Polynomial.Chebyshev.roots_U_real_nodup | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ (n : ℕ), (Multiset.map (fun k => Real.cos ((↑k + 1) * Real.pi / (↑n + 1))) (Multiset.range n)).Nodup | null | true |
TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst | Mathlib.Topology.Sheaves.CommRingCat | ∀ {X : TopCat} (F : TopCat.Sheaf CommRingCat X) (U V : TopologicalSpace.Opens ↑X)
(x :
↑↧↥(((CommRingCat.Hom.hom (F.obj.map (CategoryTheory.homOfLE ⋯).op)).comp
(RingHom.fst ↑(F.obj.obj (Opposite.op U)) ↑(F.obj.obj (Opposite.op V)))).eqLocus
((CommRingCat.Hom.hom (F.obj.map (CategoryTh... | null | true |
IsPrimitiveRoot.subOneIntegralPowerBasis_gen | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n), hζ.subOneIntegralPowerBasis.gen = ⟨ζ - 1, ⋯⟩ | null | true |
Lean.Doc.Parser.bold | Lean.DocString.Parser | Lean.Doc.Parser.InlineCtxt → Lean.Parser.ParserFn | Parses bold: a matched pair of one or more `*`.
| true |
Std.DHashMap.Internal.List.HashesTo.mk._flat_ctor | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List ((a : α) × β a)} {i size : ℕ},
(∀ (h : 0 < size), ∀ p ∈ l, (↑(Std.DHashMap.Internal.mkIdx size h (hash p.fst))).toNat = i) →
Std.DHashMap.Internal.List.HashesTo l i size | null | false |
instAddGroupUniformFun._proof_3 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup β],
autoParam (∀ (n : ℕ) (a : UniformFun α β), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
ProbabilityTheory.integrable_rpow_abs_mul_exp_add_of_integrable_exp_mul | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t v x : ℝ},
MeasureTheory.Integrable (fun ω => Real.exp ((v + t) * X ω)) μ →
MeasureTheory.Integrable (fun ω => Real.exp ((v - t) * X ω)) μ →
0 ≤ x →
x < |t| → ∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun a => |X... | If `exp ((v + t) * X)` and `exp ((v - t) * X)` are integrable
then for nonnegative `p : ℝ` and any `x ∈ [0, |t|)`,
`|X| ^ p * exp (v * X + x * |X|)` is integrable. | true |
Set.infinite_union._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s t : Set α}, (s ∪ t).Infinite = (s.Infinite ∨ t.Infinite) | null | false |
Real.logb_lt_logb_iff_of_base_lt_one._simp_1 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x y : ℝ}, 0 < b → b < 1 → 0 < x → 0 < y → (Real.logb b x < Real.logb b y) = (y < x) | null | false |
Std.DHashMap.Internal.Raw₀.Const.size_le_size_insertMany | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
{ρ : Type w} [inst_2 : ForIn Id ρ (α × β)] [EquivBEq α] [LawfulHashable α],
(↑m).WF → ∀ {l : ρ}, (↑m).size ≤ (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m l)).size | null | true |
GenContFract.IntFractPair.of_inv_fr_num_lt_num_of_pos | Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | ∀ {q : ℚ}, 0 < q → (GenContFract.IntFractPair.of q⁻¹).fr.num < q.num | Shows that for any `q : ℚ` with `0 < q < 1`, the numerator of the fractional part of
`IntFractPair.of q⁻¹` is smaller than the numerator of `q`.
| true |
Batteries.Tactic.CollectOpaques.M | Batteries.Tactic.PrintOpaques | Type → Type | The monad used by `CollectOpaques`. | true |
ProfiniteGrp.ofFiniteGrp._proof_2 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (G : FiniteGrp.{u_1}), CompactSpace ↑G.toGrp | null | false |
IccLeftChart_symm_apply_of_le._proof_2 | Mathlib.Geometry.Manifold.Instances.Real | ∀ {x y : ℝ} {z : EuclideanHalfSpace 1}, (↑z).ofLp 0 ≤ y - x → (↑z).ofLp 0 + x ∈ Set.Icc x y | null | false |
_private.Lean.Meta.SizeOf.0.Lean.Meta.initFn._@.Lean.Meta.SizeOf.3942519336._hygCtx._hyg.4 | Lean.Meta.SizeOf | IO (Lean.Option Bool) | null | false |
_private.Mathlib.Tactic.Basify.0.Mathlib.Tactic.Basify.casesAtom.match_1 | Mathlib.Tactic.Basify | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
differentiable_pow | Mathlib.Analysis.Calculus.FDeriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕜 𝔸]
(n : ℕ), Differentiable 𝕜 fun x => x ^ n | null | true |
_private.Mathlib.Topology.Algebra.Valued.WithVal.0.WithVal.valueGroupOrderIso₀_restrict._simp_1_1 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
(x : WithVal v), v x.ofVal = (WithVal.valuation v) x | null | false |
Function.invFunOn_apply_mem._simp_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {a : α} [inst : Nonempty α],
a ∈ s → (Function.invFunOn f s (f a) ∈ s) = True | null | false |
Std.Roo.size.eq_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.Rxo.HasSize α] [inst_1 : Std.PRange.UpwardEnumerable α] (r : Std.Roo α),
r.size =
match Std.PRange.succ? r.lower with
| none => 0
| some lower => Std.Rxo.HasSize.size lower r.upper | null | true |
_private.Mathlib.Analysis.Analytic.IteratedFDeriv.0.HasFPowerSeriesOnBall.iteratedFDeriv_eq_sum_of_completeSpace._simp_1_2 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal},
HasFPowerSeriesOnBall f p x r = HasFPo... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.