name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.Partrec.Code.pappAck.match_1 | Mathlib.Computability.Ackermann | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
PosPart.noConfusionType | Mathlib.Algebra.Notation | Sort u → {α : Type u_1} → PosPart α → {α' : Type u_1} → PosPart α' → Sort u | null | false |
Algebra.FormallySmooth.liftOfSurjective.eq_1 | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {B : Type u_1}
[inst_3 : CommRing B] [inst_4 : Algebra R B] {C : Type u_4} [inst_5 : CommRing C] [inst_6 : Algebra R C]
[inst_7 : Algebra.FormallySmooth R A] (f : A →ₐ[R] C) (g : B →ₐ[R] C) (hg : Function.Surjective ⇑g)
(... | null | true |
Lean.Meta.Grind.NormalizePattern.State.recOn | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.NormalizePattern.State → Sort u} →
(t : Lean.Meta.Grind.NormalizePattern.State) →
((symbols : Array Lean.HeadIndex) →
(symbolSet : Std.HashSet Lean.HeadIndex) →
(bvarsFound : Std.HashSet ℕ) →
motive { symbols := symbols, symbolSet := symbolSet, bvarsFound :=... | null | false |
Lean.Omega.IntList.dvd_gcd | Init.Omega.IntList | ∀ (xs : Lean.Omega.IntList) (c : ℕ), (∀ {a : ℤ}, a ∈ xs → ↑c ∣ a) → c ∣ xs.gcd | null | true |
Std.ExtDHashMap.Const.get_modify_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : β → β} {h : k ∈ Std.ExtDHashMap.Const.modify m k f},
Std.ExtDHashMap.Const.get (Std.ExtDHashMap.Const.modify m k f) k h = f (Std.ExtDHashMap.Const.get m k ⋯) | null | true |
Module.Relations.Solution.IsPresentation.desc.congr_simp | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution solution_1 : relations.Solution M} (e_solution : solution = solution_1)
(h : solution.IsPresentation) {N : Type v'} [inst_3 : AddCommGroup N] [inst_4 : Module A N]
(s s_1 : relati... | null | true |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory.termπ_3 | Mathlib.MeasureTheory.Group.FundamentalDomain | Lean.ParserDescr | null | true |
Std.DTreeMap.Internal.Impl.Const.maxKeyD_alter!_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).isEmpty = false →
∀ {fallback : α},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).maxK... | null | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal.0.IsCyclotomicExtension.Rat.«term𝒑» | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | Lean.ParserDescr | null | true |
FloatArray.map | Batteries.Data.FloatArray | FloatArray → (Float → Float) → FloatArray | `map f a` applies the function `f` to each element of the array. | true |
_private.Mathlib.Algebra.Module.ZLattice.Summable.0.ZLattice.sum_piFinset_Icc_rpow_le._simp_1_9 | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | null | false |
CategoryTheory.Mod.Hom.mk | Mathlib.CategoryTheory.Monoidal.Mod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] →
{A : C} →
[inst_4 : Cat... | null | true |
AddGroup.residuallyFinite_of_forall_exists_finite_addMonoidHom | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : AddGroup G],
(∀ (g : G), g ≠ 0 → ∃ H x, ∃ (_ : Finite H), ∃ f, f g ≠ 0) → AddGroup.ResiduallyFinite G | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_22 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls size : ℕ) (l r : Std.DTreeMap.Internal.Impl α β),
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(size + 0 ≤ 1 ∨ size ≤ 3 * 0 ∧ 0 ≤ 3 * size) ∧ ls = size + 1 + 0 →
¬l.size + 1 + r.si... | null | false |
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalClear._regBuiltin.Lean.Elab.Tactic.Conv.evalClear_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
NNReal.instLinearOrderedCommGroupWithZero._proof_1 | Mathlib.Data.NNReal.Defs | ∀ (h : NNReal), 0 ≤ ↑h | null | false |
RingHom.Etale.toAlgebra | Mathlib.RingTheory.RingHom.Etale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] {f : R →+* S}, f.Etale → Algebra.Etale R S | Helper lemma for the `algebraize` tactic | true |
Finset.prod_insert_of_eq_one_if_notMem | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} {a : ι} [inst : CommMonoid M] {f : ι → M} [inst_1 : DecidableEq ι],
(a ∉ s → f a = 1) → ∏ x ∈ insert a s, f x = ∏ x ∈ s, f x | The product of `f` over `insert a s` is the same as
the product over `s`, as long as `a` is in `s` or `f a = 1`. | true |
_aux_Mathlib_Data_Fintype_Sets___elabRules_finsetStx_1 | Mathlib.Data.Fintype.Sets | Lean.Elab.Term.TermElab | `finset% t` elaborates `t` as a `Finset`.
If `t` is a `Set`, then inserts `Set.toFinset`.
Does not make use of the expected type; useful for big operators over finsets.
```
#check finset% Finset.range 2 -- Finset Nat
#check finset% (Set.univ : Set Bool) -- Finset Bool
```
| false |
BooleanSubalgebra.copy._proof_3 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (L : BooleanSubalgebra α) (s : Set α) (hs : s = ↑L), ⊥ ∈ (L.copy s ⋯).carrier | null | false |
isOpen_iff_generate_intervals._to_dual_1 | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [ts : TopologicalSpace α] [inst : Preorder α] [t : OrderTopology α] {s : Set α},
IsOpen s ↔ TopologicalSpace.GenerateOpen {s | ∃ a, s = Set.Iio a ∨ s = Set.Ioi a} s | null | false |
CategoryTheory.Subobject.instLattice._proof_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasImages C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] {B : C} (a b : CategoryTheory.Subobject B),
a ≤ SemilatticeSup.sup a b | null | false |
_private.Mathlib.Tactic.ClickSuggestions.Util.0.Mathlib.Tactic.ClickSuggestions.isExplicitEq.getBinderInfos.match_4 | Mathlib.Tactic.ClickSuggestions.Util | (motive : MProd Lean.Expr (MProd ℕ (Array Lean.BinderInfo)) → Sort u_1) →
(r : MProd Lean.Expr (MProd ℕ (Array Lean.BinderInfo))) →
((fnType : Lean.Expr) → (j : ℕ) → (result : Array Lean.BinderInfo) → motive ⟨fnType, j, result⟩) → motive r | null | false |
CategoryTheory.CatEnrichedOrdinary.instCategoryHom._proof_2 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {X Y : CategoryTheory.CatEnrichedOrdinary C}
{X_1 Y_1 : X ⟶ Y} (f : X_1 ⟶ Y_1), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X_1) f = f | null | false |
CategoryTheory.Abelian.LeftResolution.karoubi.π | Mathlib.Algebra.Homology.LeftResolution.Reduced | {A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{ι : CategoryTheory.Functor C A} →
(Λ : CategoryTheory.Abelian.LeftResolution ι) →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3... | Auxiliary definition for `LeftResolution.karoubi`. | true |
codisjoint_bot._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] {a : α}, Codisjoint a ⊥ = (a = ⊤) | null | false |
HomologicalComplex.eval._proof_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (c : ComplexShape ι) (i : ι) (X : HomologicalComplex V c),
(CategoryTheory.CategoryStruct.id X).f i = CategoryTheory.CategoryStruct.id (X.X i) | null | false |
SimpleGraph.not_isCompleteMultipartite_iff_exists_isPathGraph3Compl | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u} {G : SimpleGraph α}, ¬G.IsCompleteMultipartite ↔ ∃ v w₁ w₂, G.IsPathGraph3Compl v w₁ w₂ | null | true |
Set.Subsingleton.countable | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Subsingleton → s.Countable | null | true |
Submodule.range_projectionL | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : Submodule R M} (h : Submodule.IsTopCompl p q), (↑(p.projectionL q h)).range = p | null | true |
RCLike.inv_re | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] (z : K), RCLike.re z⁻¹ = RCLike.re z / RCLike.normSq z | null | true |
QuadraticMap.Isometry.ofEq | Mathlib.LinearAlgebra.QuadraticForm.Isometry | {R : Type u_1} →
{M₁ : Type u_3} →
{N : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M₁] → [inst_4 : Module R N] → {Q₁ Q₂ : QuadraticMap R M₁ N} → Q₁ = Q₂ → Q₁ →qᵢ Q₂ | The identity isometry between equal quadratic forms. | true |
MeasureTheory.Measure.AbsolutelyContinuous.add_left_iff | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ₁ μ₂ ν : MeasureTheory.Measure α},
(μ₁ + μ₂).AbsolutelyContinuous ν ↔ μ₁.AbsolutelyContinuous ν ∧ μ₂.AbsolutelyContinuous ν | null | true |
Matrix.comp_diagonal_diagonal | Mathlib.Data.Matrix.Composition | ∀ {I : Type u_1} {J : Type u_2} {R : Type u_5} [inst : DecidableEq I] [inst_1 : DecidableEq J] [inst_2 : Zero R]
(d : I → J → R),
(Matrix.comp I I J J R) (Matrix.diagonal fun i => Matrix.diagonal fun j => d i j) =
Matrix.diagonal fun ij => d ij.1 ij.2 | null | true |
Equiv.Perm.apply_mem_support | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α}, f x ∈ f.support ↔ x ∈ f.support | null | true |
iteratedDerivWithin_fun_id | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : ℕ} {x : 𝕜} {s : Set 𝕜},
x ∈ s → UniqueDiffOn 𝕜 s → iteratedDerivWithin n (fun x => x) s x = if n = 0 then x else if n = 1 then 1 else 0 | Eta-expanded form of `iteratedDerivWithin_id` | true |
PeriodPair.derivWeierstrassPExcept_def | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair) (l₀ : ↥L.lattice) (z : ℂ),
L.derivWeierstrassPExcept (↑l₀) z = L.derivWeierstrassP z + 2 / (z - ↑l₀) ^ 3 | null | true |
MeasurableSpace.CountablySeparated.rec | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | {α : Type u_3} →
[inst : MeasurableSpace α] →
{motive : MeasurableSpace.CountablySeparated α → Sort u} →
((countably_separated : HasCountableSeparatingOn α MeasurableSet Set.univ) → motive ⋯) →
(t : MeasurableSpace.CountablySeparated α) → motive t | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get!_empty._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 |
FreeAddMagma.length | Mathlib.Algebra.Free | {α : Type u} → FreeAddMagma α → ℕ | Length of an element of a free additive magma. | true |
ContDiffWithinAt.mul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {n : WithTop ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸]
[inst_4 : NormedAlgebra 𝕜 𝔸] {s : Set E} {f g : E → 𝔸},
ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n g s x → C... | The product of two `C^n` functions within a set at a point is `C^n` within this set
at this point. | true |
PresheafOfModules.colimitPresheafOfModules_map | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
[inst_2 :
∀ {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.Limits.PreservesColimit (F.comp (Preshea... | null | true |
Finset.mem_attachFin._simp_1 | Mathlib.Data.Finset.Fin | ∀ {n : ℕ} {s : Finset ℕ} (h : ∀ m ∈ s, m < n) {a : Fin n}, (a ∈ s.attachFin h) = (↑a ∈ s) | null | false |
CategoryTheory.ProjectiveResolution.extAddEquivCohomologyClass._proof_1 | Mathlib.CategoryTheory.Abelian.Projective.Ext | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.ProjectiveResolution X) {n : ℕ}
(x y : CochainComplex.HomComplex.CohomologyClass R.cochainComplex ((CochainComplex.singleFunctor C 0).obj Y) ↑n),
R.ex... | null | false |
Lean.Compiler.LCNF.Code.isDecl | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Bool | null | true |
CategoryTheory.Functor.Elements.coconeπOpCompShrinkYonedaObj_pt | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.LocallySmall.{w, v₁, u₁} C]
(F : CategoryTheory.Functor C (Type w)) (X : C),
(CategoryTheory.Functor.Elements.coconeπOpCompShrinkYonedaObj F X).pt = F.obj X | null | true |
CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimIso._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete α) C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C), CategoryTheory.Limits.HasColimit F | null | false |
CategoryTheory.Sieve.functorPullback_monotone | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (X : C), Monotone (CategoryTheory.Sieve.functorPullback F) | null | true |
_private.Std.Data.Iterators.Lemmas.Consumers.Monadic.Set.0.Std.IterM.toExtTreeSet_eq_ofList._simp_1_3 | Std.Data.Iterators.Lemmas.Consumers.Monadic.Set | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {l : List α},
List.foldl (fun acc a => acc.insert a) ∅ l = Std.ExtTreeSet.ofList l cmp | null | false |
exists_orderEmbedding_covby_of_forall_covby_finite | Mathlib.Order.KonigLemma | ∀ {α : Type u_1} [inst : PartialOrder α] [IsStronglyAtomic α] {b : α},
(∀ (a : α), {x | a ⋖ x}.Finite) → (Set.Ici b).Infinite → ∃ f, f 0 = b ∧ ∀ (i : ℕ), f i ⋖ f (i + 1) | The sequence given by Kőnig's lemma as an order embedding | true |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.aestronglyMeasurable_union_iff._simp_1_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {p : Bool → Prop}, (∀ (b : Bool), p b) = (p false ∧ p true) | null | false |
Lean.Meta.checkAssignment | Lean.Meta.ExprDefEq | Lean.MVarId → Array Lean.Expr → Lean.Expr → Lean.MetaM (Option Lean.Expr) | Auxiliary function for handling constraints of the form `?m a₁ ... aₙ =?= v`.
It will check whether we can perform the assignment
```
?m := fun fvars => v
```
The result is `none` if the assignment can't be performed.
The result is `some newV` where `newV` is a possibly updated `v`. This method may need
to unfold let-d... | true |
himp_inf_le | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, (a ⇨ b) ⊓ a ≤ b | `(p → q) ∧ p → q` | true |
isMulTorsionFree_iff_not_isOfFinOrder | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : CommGroup G], IsMulTorsionFree G ↔ ∀ ⦃a : G⦄, a ≠ 1 → ¬IsOfFinOrder a | null | true |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_58 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x : α) (xs : List α) (head : α) (tail : List α),
head :: tail = xs → ¬(head :: (tail ++ [x])).dropLast ++ [(head :: (tail ++ [x])).getLast ⋯].dropLast = [] | null | false |
GetElem.getElem.congr_simp | Init.GetElem | ∀ {coll : Type u} {idx : Type v} {elem : Type w} {valid : coll → idx → Prop} [self : GetElem coll idx elem valid]
(xs xs_1 : coll) (e_xs : xs = xs_1) (i i_1 : idx) (e_i : i = i_1) (h : valid xs i), xs[i] = xs_1[i_1] | null | true |
Aesop.Frontend.evalSaturate? | Aesop.Frontend.Saturate | Lean.Elab.Tactic.Tactic | null | true |
Lean.Elab.CommandContextInfo.fileMap | Lean.Elab.InfoTree.Types | Lean.Elab.CommandContextInfo → Lean.FileMap | null | true |
Topology.IsLocallyConstructible.preimage_of_isOpenEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Topology.IsLocallyConstructible s → Topology.IsOpenEmbedding f → Topology.IsLocallyConstructible (f ⁻¹' s) | null | true |
zero_le_four | Mathlib.Algebra.Order.Monoid.NatCast | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : Preorder α] [ZeroLEOneClass α] [AddLeftMono α], 0 ≤ 4 | null | true |
CoalgCat.forget₂_obj | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u} [inst : CommRing R] (X : CoalgCat R),
(CategoryTheory.forget₂ (CoalgCat R) (ModuleCat R)).obj X = ModuleCat.of R ↑X.toModuleCat | null | true |
Lean.Server.References.ParentDecl._sizeOf_inst | Lean.Server.References | SizeOf Lean.Server.References.ParentDecl | null | false |
Aesop.NormM.Context.mk | Aesop.Search.Expansion.Norm | Aesop.Options' → Aesop.LocalRuleSet → Aesop.NormSimpContext → Aesop.NormM.Context | null | true |
toIocMod_eq_sub | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIocMod hp a b = toIocMod hp 0 (b - a) + a | null | true |
_private.Lean.Meta.Constructions.BRecOn.0.Lean.buildBelowMinorPremise.go._unsafe_rec | Lean.Meta.Constructions.BRecOn | Lean.Level → Array Lean.Expr → Array Lean.Expr → List Lean.Expr → Lean.MetaM Lean.Expr | null | false |
Std.Net.SocketAddressV4._sizeOf_1 | Std.Net.Addr | Std.Net.SocketAddressV4 → ℕ | null | false |
_private.Mathlib.RingTheory.Localization.Module.0.IsLocalizedModule.linearIndependent_lift._simp_1_1 | Mathlib.RingTheory.Localization.Module | ∀ {M' : Type u_1} {α : Type u_2} [inst : MulOneClass M'] [inst_1 : SMul M' α] {S : Submonoid M'} (g : ↥S) (a : α),
↑g • a = g • a | null | false |
_private.Lean.PrettyPrinter.Parenthesizer.0.Lean.PrettyPrinter.categoryParenthesizerAttribute._regBuiltin.Lean.PrettyPrinter.categoryParenthesizerAttribute.declRange_3 | Lean.PrettyPrinter.Parenthesizer | IO Unit | null | false |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.expandFun._regBuiltin.Lean.Elab.Term.expandFun_1 | Lean.Elab.Binders | IO Unit | null | false |
ENNReal.hasSum_coe._simp_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → NNReal} {r : NNReal}, HasSum (fun a => ↑(f a)) ↑r = HasSum f r | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.sum_fin_Icc_eq_sum_nat_Icc._proof_1_6 | Mathlib.Algebra.BigOperators.Intervals | ∀ {α : Type u_1} [inst : AddCommMonoid α] {n : ℕ} (a b : Fin n) (f : Fin n → α),
∀ a_1 ∈ Finset.range n,
a_1 ∈ Finset.Icc ↑a ↑b →
(if h : a_1 < n then if ⟨a_1, h⟩ ∈ Finset.Icc a b then f ⟨a_1, h⟩ else 0 else 0) =
if h : a_1 < n then f ⟨a_1, h⟩ else 0 | null | false |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.densityProcess_mono_kernel_left._simp_1_2 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {a b : ENNReal}, (a / b = ⊤) = (a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤) | null | false |
Turing.FinTM2.casesOn | Mathlib.Computability.TuringMachine.Computable | {motive : Turing.FinTM2 → Sort u} →
(t : Turing.FinTM2) →
({K : Type} →
[kDecidableEq : DecidableEq K] →
[kFin : Fintype K] →
(k₀ k₁ : K) →
(Γ : K → Type) →
(Λ : Type) →
(main : Λ) →
[ΛFin : Fintype Λ] →
... | null | false |
SimpleGraph.addCayley_insert_zero | Mathlib.Combinatorics.SimpleGraph.Cayley | ∀ {M : Type u_1} (s : Set M) [inst : AddZeroClass M], SimpleGraph.addCayley (insert 0 s) = SimpleGraph.addCayley s | null | true |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.abstractGroundMismatches?.goCore._sparseCasesOn_4 | Lean.Meta.Tactic.Grind.ProveEq | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
(Nat.hasNotBit 2048 t.ctorIdx → motive t) → motive t | null | false |
SpecializingMap.stableUnderSpecialization_range | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
SpecializingMap f → StableUnderSpecialization (Set.range f) | null | true |
OrderMonoidHom._sizeOf_inst | Mathlib.Algebra.Order.Hom.Monoid | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : MulOneClass α} → {inst_3 : MulOneClass β} → [SizeOf α] → [SizeOf β] → SizeOf (α →*o β) | null | false |
Module.finBasisOfFinrankEq | Mathlib.LinearAlgebra.Dimension.Free | (R : Type u) →
(M : Type v) →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[Module.Free R M] →
[StrongRankCondition R] → [Module.Finite R M] → {n : ℕ} → Module.finrank R M = n → Module.Basis (Fin n) R M | A rank `n` free module has a basis indexed by `Fin n`. | true |
LinearMap.toDistribMulActionHom | Mathlib.Algebra.Module.LinearMap.Defs | {R : Type u_1} →
{S : Type u_5} →
{M : Type u_8} →
{M₃ : Type u_11} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : Module R M] → [inst_5 : Module S M₃] → {σ : R →+* S} → (M →ₛₗ[σ... | The `DistribMulActionHom` underlying a `LinearMap`. | true |
_private.Lean.Meta.Tactic.Cbv.Util.0.Lean.Meta.Tactic.Cbv.isNatValue | Lean.Meta.Tactic.Cbv.Util | Lean.Expr → Bool | null | true |
Mathlib.Tactic.Algebra.Cache._sizeOf_inst | Mathlib.Tactic.Algebra.Basic | {u : Lean.Level} → {A : Q(Type u)} → (sA : Q(CommSemiring «$A»)) → SizeOf (Mathlib.Tactic.Algebra.Cache sA) | null | false |
Nat.mod_pow_succ | Init.Data.Nat.Mod | ∀ {x b k : ℕ}, x % b ^ (k + 1) = x % b ^ k + b ^ k * (x / b ^ k % b) | null | true |
_private.Mathlib.Algebra.Lie.Killing.0.LieAlgebra.killingForm_of_equiv_apply._simp_1_1 | Mathlib.Algebra.Lie.Killing | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (e : L ≃ₗ⁅R⁆ L') (x : L),
(LieAlgebra.ad R L') (e x) = e.toLinearEquiv.conj ((LieAlgebra.ad R L) x) | null | false |
CategoryTheory.Limits.colimitConstInitial | Mathlib.CategoryTheory.Limits.Shapes.Terminal | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{C : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasInitial C] →
CategoryTheory.Limits.colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) ≅ ⊥_ C | The colimit of the constant `⊥_ C` functor is `⊥_ C`. | true |
ContextFreeRule.reverse_injective | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {N : Type u_2}, Function.Injective ContextFreeRule.reverse | null | true |
FractionalIdeal.map_div | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
[inst_3 : IsFractionRing R₁ K] [inst_4 : IsDomain R₁] {K' : Type u_5} [inst_5 : Field K'] [inst_6 : Algebra R₁ K']
[inst_7 : IsFractionRing R₁ K'] (I J : FractionalIdeal (nonZeroDivisors R₁) K) (h : K ≃ₐ[R₁] K'),
Frac... | null | true |
Std.Iterators.Types.ULiftIterator.instIterator._proof_1 | Init.Data.Iterators.Combinators.Monadic.ULift | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {n : Type (max u_1 u_3) → Type u_4} {β : Type u_1}
{lift : ⦃γ : Type u_1⦄ → m γ → Std.Iterators.ULiftT n γ} [inst : Std.Iterator α m β]
(it : Std.IterM n (ULift.{u_3, u_1} β)) (__do_lift : ULift.{u_3, u_1} (Std.Shrink it.internalState.inner.Step)),
∃ step',
it.intern... | null | false |
MvPolynomial.finSuccEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) [inst : CommSemiring R] (n : ℕ) (p : MvPolynomial (Fin (n + 1)) R),
(MvPolynomial.finSuccEquiv R n) p =
(MvPolynomial.eval₂Hom (Polynomial.C.comp MvPolynomial.C) fun i =>
Fin.cases Polynomial.X (fun k => Polynomial.C (MvPolynomial.X k)) i)
p | null | true |
AddSubmonoid.zero_mem' | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_3} [inst : AddZeroClass M] (self : AddSubmonoid M), 0 ∈ self.carrier | An additive submonoid contains `0`. | true |
iInf_uniformity | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {ι : Sort u_2} {u : ι → UniformSpace α}, uniformity α = ⨅ i, uniformity α | null | true |
Std.LawfulOrderLeftLeaningMax.max_eq_left | Init.Data.Order.Classes | ∀ {α : Type u} {inst : Max α} {inst_1 : LE α} [self : Std.LawfulOrderLeftLeaningMax α] (a b : α), b ≤ a → a ⊔ b = a | null | true |
Int8.ofInt_neg | Init.Data.SInt.Lemmas | ∀ (a : ℤ), Int8.ofInt (-a) = -Int8.ofInt a | null | true |
List.pairwise_cons_cons | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α},
List.Pairwise R (a :: b :: l) ↔ R a b ∧ List.Pairwise R (a :: l) ∧ List.Pairwise R (b :: l) | null | true |
ProbabilityTheory.integral_tilted_mul_eq_mgf | Mathlib.Probability.Moments.Tilted | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ} {t : ℝ} {E : Type u_2}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (g : Ω → E),
(∫ (ω : Ω), g ω ∂μ.tilted fun x => t * X x) = ∫ (ω : Ω), (Real.exp (t * X ω) / ProbabilityTheory.mgf X μ t) • g ω ∂μ | null | true |
Fin.forall_fin_zero._simp_1 | Init.Data.Fin.Lemmas | ∀ {p : Fin 0 → Prop}, (∀ (i : Fin 0), p i) = True | null | false |
Aesop.TreeRef.markSubtreeIrrelevant | Aesop.Tree.State | Aesop.TreeRef → BaseIO Unit | null | true |
Lean.Elab.Command.instMonadLogCommandElabM | Lean.Elab.Command | Lean.MonadLog Lean.Elab.Command.CommandElabM | null | true |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.State.map | Lean.Meta.Sym.AlphaShareCommon | Lean.Meta.Sym.State✝ → Std.HashMap Lean.Meta.Sym.ExprPtr Lean.Expr | null | true |
MeasureTheory.SimpleFunc.approxOn.congr_simp | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : PseudoEMetricSpace α]
[inst_2 : OpensMeasurableSpace α] [inst_3 : MeasurableSpace β] (f f_1 : β → α) (e_f : f = f_1) (hf : Measurable f)
(s s_1 : Set α) (e_s : s = s_1) (y₀ y₀_1 : α) (e_y₀ : y₀ = y₀_1) (h₀ : y₀ ∈ s)
[inst_4 : TopologicalSpace.Se... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.