name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
instHasCountableLimitsLightCondMod | Mathlib.Condensed.Light.Limits | ∀ (R : Type u) [inst : Ring R], CategoryTheory.Limits.HasCountableLimits (LightCondMod R) | null | true |
Lean.Parser.Term.doContinue | Lean.Parser.Do | Lean.Parser.Parser | `continue` skips to the next iteration of the surrounding `for` loop. | true |
AddCommGroupWithOne.toNatCast | Mathlib.Data.Int.Cast.Defs | {R : Type u} → [self : AddCommGroupWithOne R] → NatCast R | null | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.useImplicitLambda | Lean.Elab.Term.TermElabM | Lean.Syntax → Option Lean.Expr → Lean.Elab.TermElabM Lean.Elab.Term.UseImplicitLambdaResult | Return normalized expected type if it is of the form `{a : α} → β` or `[a : α] → β` and
`blockImplicitLambda stx` is not true, else return `none`.
Remark: implicit lambdas are not triggered by the strict implicit binder annotation `{{a : α}} → β`
| true |
Affine.Simplex.centroid_reindex | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {m n : ℕ} (s : Affine.Simplex k P m) (e : Fin (m + 1) ≃ Fin (n + 1)),
(s.reindex e).centroid = s.centroid | null | true |
ENNReal.div_lt_top | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ 0 → x / y < ⊤ | null | true |
List.length_range | Init.Data.List.Range | ∀ {n : ℕ}, (List.range n).length = n | null | true |
CategoryTheory.Monad.ForgetCreatesColimits.coconePoint._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {D : CategoryTheory.Functor J T.Algebra}
(c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
[inst_2 : CategoryTheory.... | null | false |
MeasureTheory.integral_union_eq_left_of_forall | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{s t : Set X} {μ : MeasureTheory.Measure X} {f : X → E},
MeasurableSet t → (∀ x ∈ t, f x = 0) → ∫ (x : X) in s ∪ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ | null | true |
ModuleCat.linearOverField._proof_2 | Mathlib.Algebra.Category.ModuleCat.Algebra | ∀ {k : Type u_3} [inst : Field k] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra k A] (X Y Z : ModuleCat A) (r : k)
(f : X ⟶ Y) (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (r • f) g = r • CategoryTheory.CategoryStruct.comp f g | null | false |
Lean.Meta.CaseValuesSubgoal.noConfusion | Lean.Meta.Match.CaseValues | {P : Sort u} → {t t' : Lean.Meta.CaseValuesSubgoal} → t = t' → Lean.Meta.CaseValuesSubgoal.noConfusionType P t t' | null | false |
TensorPower.gmonoid._proof_1 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : GradedMonoid fun i => TensorPower R i M), GradedMonoid.mk (0 • a.fst) (GradedMonoid.GMonoid.gnpowRec 0 a.snd) = 1 | null | false |
ContDiffWithinAt.sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {s : Set E}
{n : WithTop ℕ∞}, ContDiffWithinAt ℝ n f s x → ContDiffWithinAt ℝ n (fun x => Real.sinh (f x)) s x | null | true |
_private.Init.Data.Vector.Count.0.Vector.count_le_count_map._simp_1_1 | Init.Data.Vector.Count | ∀ {α : Type u_2} [inst : BEq α] [LawfulBEq α] {β : Type u_1} [inst_2 : BEq β] [LawfulBEq β] {xs : Array α} {f : α → β}
{x : α}, (Array.count x xs ≤ Array.count (f x) (Array.map f xs)) = True | null | false |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk.noConfusion | Lean.Meta.Tactic.Grind.Theorems | {α : Type} →
{P : Sort u} →
{smap : Lean.PHashMap Lean.Name (List α)} →
{origins erased : Lean.PHashSet Lean.Meta.Grind.Origin} →
{omap : Lean.PHashMap Lean.Meta.Grind.Origin (List α)} →
{smap' : Lean.PHashMap Lean.Name (List α)} →
{origins' erased' : Lean.PHashSet Lean.Meta.Gr... | null | false |
AlgebraicGeometry.ProjIsoSpecTopComponent.ToSpec.carrier._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] {f : A},
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (ProjectiveSpectrum.basicOpen 𝒜 f).inclusion') | null | false |
CategoryTheory.RigidCategory.ctorIdx | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} → CategoryTheory.RigidCategory C → ℕ | null | false |
Array.all_subtype | Init.Data.Array.Attach | ∀ {α : Type u_1} {stop : ℕ} {p : α → Prop} {xs : Array { x // p x }} {f : { x // p x } → Bool} {g : α → Bool},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → stop = xs.size → xs.all f 0 stop = xs.unattach.all g | null | true |
Ordinal.ToType.mk._proof_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ {o : Ordinal.{u_1}} (x : ↑(Set.Iio o)), ↑x ∈ Set.Iio (Ordinal.type fun x1 x2 => x1 < x2) | null | false |
List.hasDecEq.match_1 | Init.Prelude | {α : Type u_1} →
(as bs : List α) →
(motive : Decidable (as = bs) → Sort u_2) →
(x : Decidable (as = bs)) →
((habs : as = bs) → motive (isTrue habs)) → ((nabs : ¬as = bs) → motive (isFalse nabs)) → motive x | null | false |
gcd_comm | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a b : α), gcd a b = gcd b a | null | true |
Finset.fold_const | Mathlib.Data.Finset.Fold | ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {b : β}
{s : Finset α} [hd : Decidable (s = ∅)] (c : β),
op c (op b c) = op b c → Finset.fold op b (fun x => c) s = if s = ∅ then b else op b c | null | true |
MonadStateOf.casesOn | Init.Prelude | {σ : Type u} →
{m : Type u → Type v} →
{motive : MonadStateOf σ m → Sort u_1} →
(t : MonadStateOf σ m) →
((get : m σ) →
(set : σ → m PUnit.{u + 1}) →
(modifyGet : {α : Type u} → (σ → α × σ) → m α) →
motive { get := get, set := set, modifyGet := modifyGet }) ... | null | false |
BoxIntegral.Box.instPartialOrder._proof_3 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (a b : BoxIntegral.Box ι), a < b ↔ a ≤ b ∧ ¬b ≤ a | null | false |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.map_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) | null | false |
SemimoduleCat.hom_ext_iff | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ {R : Type u} [inst : Semiring R] {M N : SemimoduleCat R} {f g : M ⟶ N},
f = g ↔ SemimoduleCat.Hom.hom f = SemimoduleCat.Hom.hom g | null | true |
Real.pow_mul_norm_iteratedFDeriv_fourier_le | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
{f : V → E} {K N : ℕ∞},
ContDiff ℝ (↑N) f →
(∀ (k n : ℕ),
↑k ≤... | One can bound `‖w‖^n * ‖D^k (𝓕 f) w‖` in terms of integrals of the derivatives of `f` (or order
at most `n`) multiplied by powers of `v` (of order at most `k`). | true |
ContinuousMap.toAEEqFunAddHom._proof_1 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) [inst_1 : TopologicalSpace α]
[inst_2 : BorelSpace α] [inst_3 : TopologicalSpace β] [inst_4 : SecondCountableTopologyEither α β]
[inst_5 : TopologicalSpace.PseudoMetrizableSpace β] [inst_6 : AddGroup β] [inst_7 : IsTopologicalA... | null | false |
_private.Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect.0.Std.IterM.Equiv.toList_eq._simp_1_1 | Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {it : Std.IterM m β}, it.toList = List.reverse <$> it.toListRev | null | false |
groupHomology.H0π_comp_H0Iso_hom_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) {Z : ModuleCat k}
(h : (Rep.coinvariantsFunctor k G).obj A ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupHomology.H0π A)
(CategoryTheory.CategoryStruct.comp (groupHomology.H0Iso A).hom h) =
CategoryTheory.CategoryStruct.comp ... | null | true |
SzemerediRegularity.increment.congr_simp | Mathlib.Combinatorics.SimpleGraph.Regularity.Increment | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P P_1 : Finpartition Finset.univ} (e_P : P = P_1)
(hP : P.IsEquipartition) (G G_1 : SimpleGraph α),
G = G_1 →
∀ {inst_2 : DecidableRel G.Adj} [inst_3 : DecidableRel G_1.Adj] (ε ε_1 : ℝ),
ε = ε_1 → SzemerediRegularity.increment hP G ε = Szemered... | null | true |
SkewMonoidAlgebra.equivMapDomain._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_3} {G : Type u_2} {H : Type u_1} [inst : AddCommMonoid k] (f : G ≃ H) (l : SkewMonoidAlgebra k G) (a : H),
a ∈ Finset.map f.toEmbedding l.support ↔ l.coeff (f.symm a) ≠ 0 | null | false |
Finsupp.support_indicator_subset | Mathlib.Data.Finsupp.Indicator | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) (f : (i : ι) → i ∈ s → α),
(Finsupp.indicator s f).support ⊆ s | null | true |
ArchimedeanClass.FiniteElement._proof_1 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [IsOrderedRing K], IsOrderedAddMonoid K | null | false |
AddSubsemigroup.centerToAddOpposite._proof_4 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Add M] (r : ↥(AddSubsemigroup.center Mᵃᵒᵖ)), AddOpposite.unop ↑r ∈ Set.addCenter M | null | false |
Substring.Raw.Valid.data_drop | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → ∀ (n : ℕ), (s.drop n).toString.toList = List.drop n s.toString.toList | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalAverage.0.exists_eq_interval_average_of_noAtoms._proof_1_1 | Mathlib.MeasureTheory.Integral.IntervalAverage | ∀ {a b : ℝ} ⦃x : ℝ⦄, min a b < x → x < max a b → x ∈ Set.uIoc a b | null | false |
Int.getElem?_toArray_roo_eq_none | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, (n - (m + 1)).toNat ≤ i → (m<...n).toArray[i]? = none | null | true |
Lean.Widget.WidgetSource.mk.noConfusion | Lean.Widget.UserWidget | {P : Sort u} →
{sourcetext sourcetext' : String} →
{ sourcetext := sourcetext } = { sourcetext := sourcetext' } → (sourcetext = sourcetext' → P) → P | null | false |
Lean.Grind.IntModule.OfNatModule.mk_le_mk | Init.Grind.Module.Envelope | ∀ {α : Type u} [inst : Lean.Grind.NatModule α] [inst_1 : LE α] [inst_2 : Std.IsPreorder α]
[inst_3 : Lean.Grind.OrderedAdd α] {a₁ a₂ b₁ b₂ : α},
Lean.Grind.IntModule.OfNatModule.Q.mk (a₁, a₂) ≤ Lean.Grind.IntModule.OfNatModule.Q.mk (b₁, b₂) ↔ a₁ + b₂ ≤ a₂ + b₁ | null | true |
_private.Mathlib.Algebra.Category.ModuleCat.Semi.0.SemimoduleCat.mk | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} →
[inst : Semiring R] →
(carrier : Type v) → [isAddCommMonoid : AddCommMonoid carrier] → [isModule : Module R carrier] → SemimoduleCat R | null | true |
StructureGroupoid.id_mem_maximalAtlas | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} [inst : TopologicalSpace H] (G : StructureGroupoid H),
OpenPartialHomeomorph.refl H ∈ StructureGroupoid.maximalAtlas H G | In the model space, the identity is in any maximal atlas. | true |
_private.Mathlib.Algebra.Exact.Sequence.0.Module.sum_neg_one_pow_finrank_eq_zero_of_exact._proof_1_3 | Mathlib.Algebra.Exact.Sequence | ∀ {k : Type u_1} [inst : DivisionRing k] {n : ℕ} (V : Fin (n + 2) → Type u_2)
[inst_1 : (i : Fin (n + 2)) → AddCommGroup (V i)] [inst_2 : (i : Fin (n + 2)) → Module k (V i)]
(f : (i : Fin (n + 1)) → V i.castSucc →ₗ[k] V i.succ) (i : Fin n),
Module.finrank k ↥(f i.succ).range + Module.finrank k ↥(f i.succ).ker = M... | null | false |
Array.mapIdx_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {xs : Array α} {f : ℕ → α → β} {g : ℕ → β → γ},
Array.mapIdx g (Array.mapIdx f xs) = Array.mapIdx (fun i => g i ∘ f i) xs | null | true |
QuasiconcaveOn.dual | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LE β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconcaveOn 𝕜 s f → QuasiconvexOn 𝕜 s (⇑OrderDual.toDual ∘ f) | null | true |
IsDedekindDomain.HeightOneSpectrum.under._proof_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ (A : Type u_1) [inst : CommRing A] {B : Type u_2} [inst_1 : CommRing B] [inst_2 : Algebra A B]
(w : IsDedekindDomain.HeightOneSpectrum B), (Ideal.under A w.asIdeal).IsPrime | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.isValidSearchFrom_iff_isValidSearchFrom_beq._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt c pos pos' =
String.Slice.Pattern.Model.IsLongestMatchAt (fun x => x == c) pos pos' | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order.0.isStrictlyPositive_add._proof_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a b : A},
IsStrictlyPositive a ∧ 0 ≤ b ∨ 0 ≤ a ∧ IsStrictlyPositive b → IsStrictlyPositive (a + b) | null | false |
_private.Mathlib.Algebra.Star.Module.0.selfAdjointPart_comp_subtype_skewAdjoint.match_1_1 | Mathlib.Algebra.Star.Module | ∀ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
(motive : ↥(skewAdjoint.submodule R A) → Prop) (x : ↥(skewAdjoint.submodule R A)),
(∀ (x : A) (hx : star x = -x), m... | null | false |
Std.ExtDTreeMap.Const.alter_eq_empty_iff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : Option β → Option β},
Std.ExtDTreeMap.Const.alter t k f = ∅ ↔ (t = ∅ ∨ t.size = 1 ∧ k ∈ t) ∧ f (Std.ExtDTreeMap.Const.get? t k) = none | null | true |
Set.image_list_prod._f | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {α : Type u_2} {β : Type u_3} {F : Type u_4} [inst : FunLike F α β] [inst_1 : Monoid α] [inst_2 : Monoid β]
[MonoidHomClass F α β] (f : F) (x : List (Set α)) (f_1 : List.below x),
⇑f '' x.prod = (List.map (fun s => ⇑f '' s) x).prod | null | false |
CategoryTheory.Sheaf.instPreservesFiniteLimitsFunctorOppositeSheafToPresheafOfHasFiniteLimits | Mathlib.CategoryTheory.Sites.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D] [CategoryTheory.Limits.HasFiniteLimits D],
CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.sheafToPresheaf J D) | null | true |
AddCon.addSubgroup_quotientAddGroupCon | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [inst_1 : H.Normal], (QuotientAddGroup.con H).addSubgroup = H | null | true |
ContinuousMultilinearMap.uniformContinuous_restrictScalars | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup... | null | true |
BoxIntegral.unitPartition.prepartition_isHenstock | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] [inst_1 : Fintype ι] (B : BoxIntegral.Box ι),
(BoxIntegral.unitPartition.prepartition n B).IsHenstock | null | true |
Finset.gcd_congr | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s₁ s₂ : Finset β}
{f g : β → α}, s₁ = s₂ → (∀ a ∈ s₂, f a = g a) → s₁.gcd f = s₂.gcd g | null | true |
LowerSet.notMem_bot._simp_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {a : α}, (a ∈ ⊥) = False | null | false |
Std.DHashMap.Equiv.constGet_eq | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (hk : k ∈ m₁) (h : m₁.Equiv m₂),
Std.DHashMap.Const.get m₁ k hk = Std.DHashMap.Const.get m₂ k ⋯ | null | true |
CategoryTheory.NatTrans.removeOp._proof_2 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F G : CategoryTheory.Functor C D} (α : F.op ⟶ G.op) (X Y : C)
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (G.map f) (α.app (Opposite.op Y)).unop =
CategoryTheory.CategoryStruct.co... | null | false |
Valuation.mem_nhds_iff | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] {Γ₀ : Type u_3} [inst_2 : LinearOrderedCommGroupWithZero Γ₀]
[inst_3 : TopologicalSpace R] [IsValuativeTopology R] (v : Valuation R Γ₀) [v.Compatible] {s : Set R} {x : R},
s ∈ nhds x ↔ ∃ γ, {z | v.restrict (z - x) < ↑γ} ⊆ s | null | true |
_private.Std.Http.Protocol.H1.Message.0.Std.Http.Protocol.H1.Message.Head.getSize.match_3 | Std.Http.Protocol.H1.Message | (motive : Option Bool → Option (Array Std.Http.Header.Value) → Sort u_1) →
(x : Option Bool) →
(contentLength : Option (Array Std.Http.Header.Value)) →
(Unit → motive (some true) none) →
((x : Option Bool) → (x_1 : Option (Array Std.Http.Header.Value)) → motive x x_1) → motive x contentLength | null | false |
Std.TreeMap.getKeyD_insert_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α}
{b : β}, (t.insert a b).getKeyD a fallback = a | null | true |
_private.Init.Data.String.Basic.0.String.Slice.utf8ByteSize_slice._proof_1_2 | Init.Data.String.Basic | ∀ {s : String.Slice} {newStart newEnd : s.Pos},
¬s.startInclusive.offset.byteIdx + newEnd.offset.byteIdx -
(s.startInclusive.offset.byteIdx + newStart.offset.byteIdx) =
newEnd.offset.byteIdx - newStart.offset.byteIdx →
False | null | false |
Representation.instAddCommGroupAsModule._proof_8 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Ring k] [inst_1 : Monoid G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V),
autoParam (∀ (a : ρ.asModule), Representation.instAddCommGroupAsModule._aux_6 ρ 0 a = 0)
SubNegMonoid.zsmul_zero'._autoParam | null | false |
PositiveLinearMap.toOrderHom_comp | Mathlib.Algebra.Order.Module.PositiveLinearMap | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} {E₃ : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : AddCommMonoid E₃]
[inst_6 : PartialOrder E₃] [inst_7 : Module R E₁] [inst_8 : Module R E₂] [inst_9 : Module R E... | null | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit'.eq_def | Lean.Elab.DeclNameGen | ∀ (e : Lean.Expr) (omitTopForall : Bool),
Lean.Elab.Command.NameGen.mkBaseNameCore.visit'✝ e omitTopForall =
match e with
| Lean.Expr.const name us => do
modify fun st =>
{ seen := Lean.Elab.Command.NameGen.MkNameState.seen✝ st,
consts := (Lean.Elab.Command.NameGen.MkNameState.cons... | null | true |
TopCat.ι₁_fst_assoc | Mathlib.Topology.Category.TopCat.Monoidal | ∀ (X : TopCat) {Z : TopCat} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp TopCat.ι₁
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.fst X TopCat.I) h) =
h | null | true |
CategoryTheory.rightExactFunctor | Mathlib.CategoryTheory.Limits.ExactFunctor | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.ObjectProperty (CategoryTheory.Functor C D) | Right-exactness, as a property of objects in `C ⥤ D`. | true |
Mathlib.Tactic.ClickSuggestions.RwKind.hasBVars.elim | Mathlib.Tactic.ClickSuggestions.Util | {motive : Mathlib.Tactic.ClickSuggestions.RwKind → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.RwKind) →
t.ctorIdx = 0 → motive Mathlib.Tactic.ClickSuggestions.RwKind.hasBVars → motive t | null | false |
AddGrpCat.limitAddGroup._aux_4 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J AddGrpCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddGrpCat)).sections] →
(CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddGrpCat))).pt | null | false |
DilationEquiv.coe_one | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X], ⇑1 = id | null | true |
OrderType.instOfNat | Mathlib.Order.Types.Arithmetic | (n : ℕ) → OfNat OrderType.{0} n | null | true |
CategoryTheory.Subfunctor.Subpresheaf.range_id | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)),
CategoryTheory.Subfunctor.range (CategoryTheory.CategoryStruct.id F) = ⊤ | **Alias** of `CategoryTheory.Subfunctor.range_id`. | true |
Std.TreeSet.getD_diff_of_mem_right | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
k ∈ t₂ → (t₁ \ t₂).getD k fallback = fallback | null | true |
List.length_mapFinIdx | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {as : List α} {f : (i : ℕ) → α → i < as.length → β}, (as.mapFinIdx f).length = as.length | null | true |
Subalgebra.normedCommRing._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {𝕜 : Type u_2} [inst : CommRing 𝕜] {E : Type u_1} [inst_1 : NormedCommRing E] [inst_2 : Algebra 𝕜 E]
(s : Subalgebra 𝕜 E) {x y : ↥s}, dist x y = 0 → x = y | null | false |
RelSeries.head_fromListIsChain | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (l : List α) (l_ne_nil : l ≠ []) (hl : List.IsChain (fun x1 x2 => (x1, x2) ∈ r) l),
(RelSeries.fromListIsChain l l_ne_nil hl).head = l.head l_ne_nil | null | true |
_private.Mathlib.Tactic.Hint.0.Mathlib.Tactic.Hint._aux_Mathlib_Tactic_Hint___elabRules_Mathlib_Tactic_Hint_registerHintStx_1._sparseCasesOn_1 | Mathlib.Tactic.Hint | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Graph.IsLoopAt.mono | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β}, H ≤ G → H.IsLoopAt e x → G.IsLoopAt e x | null | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.take.match_1.splitter | Mathlib.Data.Seq.Basic | {α : Type u_1} →
(motive : ℕ → Stream'.Seq α → Sort u_2) →
(x : ℕ) →
(x_1 : Stream'.Seq α) →
((x : Stream'.Seq α) → motive 0 x) → ((n : ℕ) → (s : Stream'.Seq α) → motive n.succ s) → motive x x_1 | null | true |
IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_nth_roots | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {A : Type u} {B : Type v} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain B]
{ζ : B} {n : ℕ} [NeZero n],
IsPrimitiveRoot ζ n →
Algebra.adjoin A ((Polynomial.cyclotomic n A).rootSet B) = Algebra.adjoin A {b | ∃ a ∈ {n}, a ≠ 0 ∧ b ^ a = 1} | null | true |
ExteriorAlgebra.ι_inj._simp_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ (R : Type u1) [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x y : M),
((ExteriorAlgebra.ι R) x = (ExteriorAlgebra.ι R) y) = (x = y) | null | false |
CategoryTheory.NatTrans.leftOpWhiskerRight_assoc | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C Dᵒᵖ} {E : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} E]
{H : CategoryTheory.Functor E C} (α : F ⟶ G) {Z : CategoryTheory.Functor Eᵒᵖ D} (h : (H.comp F).... | null | true |
NumberField.IsCMField.complexConj_eq_self_iff | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (x : K),
(NumberField.IsCMField.complexConj K) x = x ↔ x ∈ NumberField.maximalRealSubfield K | An element of `K` is fixed by the complex conjugation iff it lies in `K⁺`.
| true |
_private.Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape.0.CategoryTheory.ObjectProperty.limitsOfShape_isEmpty_iff.match_1_1 | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] (P : CategoryTheory.ObjectProperty C) (J : Type u_2)
[inst_1 : CategoryTheory.Category.{u_1, u_2} J] (X : C) (motive : P.limitsOfShape J X → Prop)
(x : P.limitsOfShape J X),
(∀ (f : CategoryTheory.Functor J C) (p : (CategoryTheory.Functor.const J).obj... | null | false |
IsSemitopologicalSemiring | Mathlib.Topology.Algebra.Ring.Basic | (R : Type u_2) → [TopologicalSpace R] → [NonUnitalNonAssocSemiring R] → Prop | A semitopological semiring is a semiring `R` where addition is jointly continuous and
multiplication is continuous in each variable separately.
We allow for non-unital and non-associative semirings as well.
The `IsSemitopologicalSemiring` class should *only* be instantiated in the presence of a
`NonUnitalNonAssocSemir... | true |
LieAlgebra.IsKilling.disjoint_ker_weight_corootSpace | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_3} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra] [LieAlgebra.IsKilling K L]
[LieModule.IsTriangularizable K (↥H) L] [inst_7 : CharZero K] (α : LieModule.Weight K (↥H) L),
Disjoin... | null | true |
edist_nndist | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), edist x y = ↑(nndist x y) | Express `edist` in terms of `nndist` | true |
List.forM_nil | Init.Data.List.Control | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} [inst : Monad m] {f : α → m PUnit.{u_1 + 1}}, forM [] f = pure PUnit.unit | null | true |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T)
{Y_1 Z : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y} (m : Y_1 ⟶ Z),
CategoryTheory.CategoryStruct.comp
... | null | false |
PNat.XgcdType.mk.sizeOf_spec | Mathlib.Data.PNat.Xgcd | ∀ (wp x y zp ap bp : ℕ),
sizeOf { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp } =
1 + sizeOf wp + sizeOf x + sizeOf y + sizeOf zp + sizeOf ap + sizeOf bp | null | true |
linearOrderOfSTO._proof_1 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) [IsStrictTotalOrder α r] (x y : α), ¬r y x ↔ x = y ∨ r x y | null | false |
CategoryTheory.ProjectiveResolution.quasiIso._autoParam | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | Lean.Syntax | null | false |
bihimp_comm | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] (a b : α), bihimp a b = bihimp b a | null | true |
Lean.Expr.proj.elim | Lean.Expr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
t.ctorIdx = 11 →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
motive t | null | false |
CategoryTheory.PreZeroHypercoverFamily._sizeOf_inst | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | (C : Type u) →
{inst : CategoryTheory.Category.{v, u} C} → [SizeOf C] → SizeOf (CategoryTheory.PreZeroHypercoverFamily C) | null | false |
Lean.Lsp.InitializationOptions.ctorIdx | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializationOptions → ℕ | null | false |
instDecidableIrrationalSqrtOfNatReal | Mathlib.NumberTheory.Real.Irrational | {n : ℕ} → [inst : n.AtLeastTwo] → Decidable (Irrational √(OfNat.ofNat n)) | This can be used as
```lean
unseal Nat.sqrt.iter in
example : Irrational √24 := by decide
```
| true |
mul_le_mul_of_nonpos_of_nonneg' | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : Preorder R] {a b c d : R} [ExistsAddOfLE R] [PosMulMono R] [MulPosMono R]
[AddRightMono R] [AddRightReflectLE R], c ≤ a → b ≤ d → 0 ≤ a → d ≤ 0 → a * b ≤ c * d | null | true |
ZeroAtInftyContinuousMap.rec | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : Zero β] →
[inst_2 : TopologicalSpace β] →
{motive : ZeroAtInftyContinuousMap α β → Sort u_1} →
((toContinuousMap : C(α, β)) →
(zero_at_infty' : Filter.Tendsto toContinuousMap.toFun (Filter.coc... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.