name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddSubgroup.characteristic_of_characteristic_of_characteristic | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} [H.Characteristic] {K : AddSubgroup ↥H}
[hK : K.Characteristic], (AddSubgroup.map H.subtype K).Characteristic | If `H` is a characteristic additive subgroup of `G` and `K` is a characteristic additive
subgroup of `H`, then `K` is a characteristic additive subgroup of `G`. | true |
_private.Mathlib.RingTheory.Smooth.StandardSmoothCotangent.0.Algebra.SubmersivePresentation.sectionCotangent_zero_of_notMem_range._proof_1_1 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_3} {S : Type u_4} {ι : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (i : ι),
(¬∀ (i_1 : σ), (if i = P.map i_1 then 1 else 0) = 0) → i ∈ Set.range P.map | null | false |
IsDiscrete.mono | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsDiscrete s → t ⊆ s → IsDiscrete t | Let `s, t ⊆ X` be two subsets of a topological space `X`. If `t ⊆ s` and `s` is discrete,
then `t` is discrete.
(Compare `DiscreteTopology.of_subset` which is the same thing stated in terms of subtypes.) | true |
_private.Std.Time.Date.Basic.0.Std.Time.Millisecond.Offset.ofDays._proof_1 | Std.Time.Date.Basic | 86400 / ↑86400000 = 1 / 1000 | null | false |
Option.bind_eq_none' | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {o : Option α} {f : α → Option β},
o.bind f = none ↔ ∀ (b : β) (a : α), o = some a → f a ≠ some b | null | true |
PresheafOfModules.Submodule.mem_toSubfunctor_obj._simp_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Submodule | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M : PresheafOfModules R} (N : M.Submodule) {X : Cᵒᵖ} (r : ↑(M.obj X)), (r ∈ N.toSubfunctor.obj X) = (r ∈ N.obj X) | null | false |
MvQPF.Comp | Mathlib.Data.QPF.Multivariate.Constructions.Comp | {n m : ℕ} → (TypeVec.{u} n → Type u_1) → (Fin2 n → TypeVec.{u} m → Type u) → TypeVec.{u} m → Type u_1 | Composition of an `n`-ary functor with `n` `m`-ary
functors gives us one `m`-ary functor | true |
AddMonoidHom.toMultiplicative | Mathlib.Algebra.Group.TypeTags.Hom | {α : Type u_3} →
{β : Type u_4} →
[inst : AddZeroClass α] → [inst_1 : AddZeroClass β] → (α →+ β) ≃ (Multiplicative α →* Multiplicative β) | Reinterpret `α →+ β` as `Multiplicative α →* Multiplicative β`. | true |
CategoryTheory.MonoidalCategory.DayConvolution.unit_naturality | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {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 G : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolution F G] {x x' y y... | null | true |
CategoryTheory.BasedFunctor.mk | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{𝒳 : CategoryTheory.BasedCategory 𝒮} →
{𝒴 : CategoryTheory.BasedCategory 𝒮} →
(toFunctor : CategoryTheory.Functor 𝒳.obj 𝒴.obj) →
autoParam (toFunctor.comp 𝒴.p = 𝒳.p) CategoryTheory.BasedFunctor.w._autoParam →
... | null | true |
ExpChar.congr | Mathlib.Algebra.CharP.Defs | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] {p : ℕ} (q : ℕ) [hq : ExpChar R q], q = p → ExpChar R p | null | true |
Std.HashMap.getElem_filterMap'._proof_1 | Std.Data.HashMap.Lemmas | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : LawfulBEq α]
{f : α → β → Option γ} {k : α} {h : k ∈ Std.HashMap.filterMap f m}, (f k m[k]).isSome = true | null | false |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.expandShow._regBuiltin.Lean.Elab.Term.expandShow_1 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
CategoryTheory.Enriched.Functor.functorHom_whiskerLeft_natTransEquiv_symm_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(K L : CategoryTheory.Functor C D) (X : C) (f : L ⟶ L)
(x :
CategoryTheory.MonoidalCategoryStruct.tensorObj ((K.functorHom L).obj X)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (Type ... | null | true |
Std.Async.TCP.Socket.Server.recOn | Std.Async.TCP | {motive : Std.Async.TCP.Socket.Server → Sort u} →
(t : Std.Async.TCP.Socket.Server) → ((native : Std.Internal.UV.TCP.Socket) → motive { native := native }) → motive t | null | false |
String.utf8Len_le_of_infix | Batteries.Data.String.Lemmas | ∀ {cs₁ cs₂ : List Char}, cs₁ <:+: cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂ | null | true |
FiniteAddGrp.of.eq_1 | Mathlib.Algebra.Category.Grp.FiniteGrp | ∀ (G : Type u) [inst : AddGroup G] [inst_1 : Finite G], ↧G = { toAddGrp := ↧G, isFinite := inst_1 } | null | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.mem_part_ofSetSetoid_iff_rel._simp_1_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) {a b : α},
(a ∈ P.part b) = ∃ p ∈ P.parts, a ∈ p ∧ b ∈ p | null | false |
MonoidHom.inr_apply | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : MulOneClass M] [inst_1 : MulOneClass N] (y : N), (MonoidHom.inr M N) y = (1, y) | null | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr} {lhs : Lean.Meta.Grind.Arith.Linear.LinExpr}
{c_1 : Lean.Meta.Grind.Arith.Linear.RingEqCnstr} {lhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr},
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq c lhs =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq c_1 lhs_1... | null | true |
Std.DTreeMap.Internal.Impl.Equiv.minEntry_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → ∀ (h : t₁.Equiv t₂) {he : t₁.isEmpty = false}, t₁.minEntry he = t₂.minEntry ⋯ | null | true |
constFormalMultilinearSeries.match_1 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((x : ℕ) → motive x) → motive x | null | false |
_private.Mathlib.Order.SuccPred.InitialSeg.0.InitialSeg.isSuccLimit_apply_iff._simp_1_1 | Mathlib.Order.SuccPred.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] (a : α), Order.IsSuccLimit a = (¬IsMin a ∧ Order.IsSuccPrelimit a) | null | false |
Lean.Doc.Block.rec_5 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1... | null | false |
Std.DTreeMap.getKey!_eq_get!_getKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {a : α}, t.getKey! a = (t.getKey? a).get! | null | true |
List.max!.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α] [inst_1 : Max α] (xs : List α),
xs.max! =
match xs.max? with
| none => panicWithPosWithDecl "Batteries.Data.List.Basic" "List.max!" 19 12 "List.max! called on empty list"
| some x => x | null | true |
IsLocalization.IsInteger.eq_1 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ (R : Type u_1) [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (a : S),
IsLocalization.IsInteger R a = (a ∈ (algebraMap R S).rangeS) | null | true |
CategoryTheory.Limits.equalizerSubobject_arrow | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizerSubobjectIso f g).hom
(CategoryTheory.Limits.equalizer.ι f g) =
(CategoryTheory.Limits.equalizerSubobject f... | null | true |
MeasureTheory.AECover.integral_tendsto_of_countably_generated | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [l.IsCountablyGenerated] {φ : ι → Set α},
MeasureTheory.AECover μ l φ →
∀ {f : α → E},
MeasureTheory.Integrable f μ → Filter.Ten... | null | true |
ScottContinuous.comp | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
{f : α → β} {g : β → γ}, ScottContinuous f → ScottContinuous g → ScottContinuous (g ∘ f) | null | true |
FiniteField.exists_nonsquare | Mathlib.FieldTheory.Finite.Basic | ∀ {F : Type u_3} [inst : Field F] [Finite F], ringChar F ≠ 2 → ∃ a, ¬IsSquare a | In a finite field of odd characteristic, not every element is a square. | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.toString.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (motive : (x : Substring.Raw) → Substring.Raw.ValidFor l m r x → Prop) (x : Substring.Raw)
(x_1 : Substring.Raw.ValidFor l m r x),
(∀ (_ : Unit),
motive
{ str := String.ofList (l ++ m ++ r), startPos := { byteIdx := String.utf8Len l },
stopPos := { byteIdx := String.utf... | null | false |
Lean.Meta.ArgsPacker.noConfusionType | Lean.Meta.ArgsPacker.Basic | Sort u → Lean.Meta.ArgsPacker → Lean.Meta.ArgsPacker → Sort u | null | false |
Interval.recBotCoe | Mathlib.Order.Interval.Basic | {α : Type u_1} →
[inst : LE α] → {C : Interval α → Sort u_6} → C ⊥ → ((a : NonemptyInterval α) → C ↑a) → (n : Interval α) → C n | Recursor for `Interval` using the preferred forms `⊥` and `↑a`. | true |
Fin.univ_def | Mathlib.Data.Fintype.Basic | ∀ (n : ℕ), Finset.univ = { val := ↑(List.finRange n), nodup := ⋯ } | null | true |
EuclideanGeometry.Sphere.isIntTangent_self_iff | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [Nontrivial V] {s : EuclideanGeometry.Sphere P}, s.IsIntTangent s ↔ 0 ≤ s.radius | null | true |
Lean.Elab.Command.Scope.levelNames._default | Lean.Elab.Command.Scope | List Lean.Name | null | false |
Polynomial.div_tendsto_atBot_zero_iff_degree_lt | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P Q : Polynomial 𝕜)
[OrderTopology 𝕜],
Q ≠ 0 →
(Filter.Tendsto (fun x => Polynomial.eval x P / Polynomial.eval x Q) Filter.atBot (nhds 0) ↔ P.degree < Q.degree) | null | true |
_private.Mathlib.Topology.Compactness.CompactlyCoherentSpace.0.CompactCoherentification.continuous_dom_iff._simp_1_1 | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {f : α → β} {g : β → γ} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace γ},
Continuous g = Continuous (g ∘ f) | null | false |
CategoryTheory.Deterministic | Mathlib.CategoryTheory.CopyDiscardCategory.Deterministic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → [CategoryTheory.CopyDiscardCategory C] → {X Y : C} → (X ⟶ Y) → Prop | A morphism is deterministic if it preserves the comonoid structure.
In probabilistic contexts, these are morphisms without randomness. | true |
FunLike.addCommSemigroup.eq_1 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : Add F] [inst_2 : AddCommSemigroup β]
[inst_3 : IsAddApply F α β], FunLike.addCommSemigroup = Function.Injective.addCommSemigroup (fun f => ⇑f) ⋯ ⋯ | null | true |
OrderIso.map_ciSup_set_of_directedOn | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompletePartialOrderSup α]
[inst_1 : ConditionallyCompletePartialOrderSup β] (e : α ≃o β) {s : Set γ} {f : γ → α},
DirectedOn (fun x1 x2 => x1 ≤ x2) (f '' s) → BddAbove (f '' s) → s.Nonempty → e (⨆ i, f ↑i) = ⨆ i, e (f ↑i) | null | true |
Subgroup.exists_pow_mem_of_index_ne_zero | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.index ≠ 0 → ∀ (a : G), ∃ n, 0 < n ∧ n ≤ H.index ∧ a ^ n ∈ H | null | true |
CategoryTheory.ShortComplex.SnakeInput.mono_v₀₁_τ₂ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.Mono S.v₀₁.τ₂ | null | true |
Nat.fact_prime_two | Mathlib.Data.Nat.Prime.Defs | Fact (Nat.Prime 2) | null | true |
DirichletCharacter.isPrimitive_one_level_one | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R], DirichletCharacter.IsPrimitive 1 | null | true |
Std.ExtDTreeMap.le_minKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, (∀ (k' : α), t.minKey? = some k' → (cmp k k').isLE = true) ↔ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
lp.singleAddMonoidHom | Mathlib.Analysis.Normed.Lp.lpSpace | {α : Type u_3} →
{E : α → Type u_4} →
[inst : (i : α) → NormedAddCommGroup (E i)] → [DecidableEq α] → (p : ENNReal) → (i : α) → E i →+ ↥(lp E p) | `single` as an `AddMonoidHom`. | true |
UpperSet.coe_zero | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α], ↑0 = Set.Ici 0 | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Checker.0.Std.Tactic.BVDecide.LRAT.Internal.check.go.eq_def | Std.Tactic.BVDecide.LRAT.Internal.Checker | ∀ (state : Std.Tactic.BVDecide.LRAT.Internal.State) (proof : Array Std.Tactic.BVDecide.LRAT.IntAction) (idx : ℕ),
Std.Tactic.BVDecide.LRAT.Internal.check.go✝ state proof idx =
if h : idx < proof.size then
have step := proof[idx];
match step with
| Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupH... | null | true |
isSelfAdjoint_iff_isStarNormal_and_quasispectrumRestricts | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalRing A] [inst_2 : StarRing A] [inst_3 : Module ℂ A]
[inst_4 : IsScalarTower ℂ A A] [inst_5 : SMulCommClass ℂ A A] [NonUnitalContinuousFunctionalCalculus ℂ A IsStarNormal]
{a : A}, IsSelfAdjoint a ↔ IsStarNormal a ∧ QuasispectrumRestricts a ⇑Complex.reC... | An element in a non-unital C⋆-algebra is selfadjoint if and only if it is normal and its
quasispectrum is contained in `ℝ`. | true |
ProbabilityTheory.lintegral_condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ] (x : ℝ),
∫⁻ (a : α), ENNReal.ofReal (↑(ProbabilityTheory.condCDF ρ a) x) ∂ρ.fst = ρ (Set.univ ×ˢ Set.Iic x) | null | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_9 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι},
b ≤ c → ∀ (w : ι), a < w → w ≤ b → w ∈ Finset.Ioc a c | null | false |
Filter.boundedFilterSubalgebra._proof_2 | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | ∀ (𝕜 : Type u_3) {α : Type u_1} {β : Type u_2} [inst : SeminormedCommRing 𝕜] [inst_1 : SeminormedRing β]
[inst_2 : Algebra 𝕜 β] [inst_3 : IsBoundedSMul 𝕜 β] (l : Filter α) (f g : α → β),
f ∈ Filter.boundedFilterSubmodule 𝕜 l →
g ∈ Filter.boundedFilterSubmodule 𝕜 l → f * g ∈ Filter.boundedFilterSubmodule �... | null | false |
MvPowerSeries.instModuleRestricted | Mathlib.RingTheory.MvPowerSeries.Restricted | {R : Type u_1} →
[inst : NormedRing R] →
{σ : Type u_2} → [inst_1 : IsUltrametricDist R] → (c : σ → ℝ) → Module R (MvPowerSeries.Restricted R c) | `R`-module structure on `Restricted R c`. | true |
_private.Init.Data.SInt.Lemmas.0.ISize.ofNat_mul._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, ISize.ofNat n = ISize.ofInt ↑n | null | false |
TrivSqZeroExt.snd_mul | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : Mul R] [inst_1 : Add M] [inst_2 : SMul R M] [inst_3 : SMul Rᵐᵒᵖ M]
(x₁ x₂ : TrivSqZeroExt R M), (x₁ * x₂).snd = x₁.fst • x₂.snd + MulOpposite.op x₂.fst • x₁.snd | null | true |
AddSubgroup.nontrivial_iff_exists_ne_zero | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 0 | null | true |
ByteArray.Iterator.casesOn | Init.Data.ByteArray.Basic | {motive : ByteArray.Iterator → Sort u} →
(t : ByteArray.Iterator) → ((array : ByteArray) → (idx : ℕ) → motive { array := array, idx := idx }) → motive t | null | false |
BitVec.hash._unary.eq_def | Init.Data.BitVec.Basic | ∀ (_x : (n : ℕ) ×' BitVec n),
BitVec.hash._unary _x =
PSigma.casesOn _x fun n bv =>
if n ≤ 64 then (↑bv.toFin).toUInt64
else mixHash (↑bv.toFin).toUInt64 (BitVec.hash._unary ⟨n - 64, BitVec.setWidth (n - 64) (bv >>> 64)⟩) | null | false |
Std.DTreeMap.Internal.Unit.RoiSliceData.mk | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] → (Std.DTreeMap.Internal.Impl α fun x => Unit) → Std.Roi α → Std.DTreeMap.Internal.Unit.RoiSliceData α | null | true |
Complex.norm_ofNat | Mathlib.Analysis.Complex.Norm | ∀ (n : ℕ) [inst : n.AtLeastTwo], ‖OfNat.ofNat n‖ = OfNat.ofNat n | null | true |
Lean.Lsp.instFromJsonSignatureHelpTriggerKind | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SignatureHelpTriggerKind | null | true |
iterate_map_sub | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} {F : Type u_11} [inst : AddGroup M] [inst_1 : FunLike F M M] [AddMonoidHomClass F M M] (f : F) (n : ℕ)
(x y : M), (⇑f)^[n] (x - y) = (⇑f)^[n] x - (⇑f)^[n] y | null | true |
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.nonzero_span_atom._simp_1_1 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M)
(p : Submodule R M), (R ∙ m ≤ p) = (m ∈ p) | null | false |
Sigma.Lex.linearOrder._proof_4 | Mathlib.Order.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)] (a b : (i : ι) × α i),
Sigma.Lex (fun x1 x2 => x1 < x2) (fun x x1 x2 => x1 ≤ x2) a b ∨
Sigma.Lex (fun x1 x2 => x1 < x2) (fun x x1 x2 => x1 ≤ x2) b a | null | false |
ENNReal.coe_natCast._simp_1 | Mathlib.Basic.ENNReal.Basic | ∀ (n : ℕ), ↑n = ↑↑n | null | false |
ContDiffMapSupportedIn.instSMul | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {E : Type u_2} →
{F : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
{R : Type u_5} →
[inst_4 ... | null | true |
Lean.Expr.foldRelevantConstants | Lean.LibrarySuggestions.Basic | {α : Type} → Lean.Expr → α → (Lean.Name → α → Lean.MetaM α) → Lean.MetaM α | Apply `f` to every constant occurring in `e` once, skipping instance arguments and proofs. | true |
Subalgebra.involutiveStar._proof_11 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] (S : Subalgebra R A),
{
carrier :=
star
{ carrier := star S.carrier, mul_mem' := ⋯, one_mem' := ⋯, add_mem' := ⋯, zero_me... | null | false |
StieltjesFunction.instModuleNNReal._proof_5 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : NNReal), x • 0 = 0 | null | false |
BoundedOrder.noConfusionType | Mathlib.Order.BoundedOrder.Basic | Sort u_1 → {α : Type u} → [inst : LE α] → BoundedOrder α → {α' : Type u} → [inst' : LE α'] → BoundedOrder α' → Sort u_1 | null | false |
_private.Mathlib.Data.Set.Finite.Lattice.0.Set.Finite.bddAbove_biUnion._simp_1_1 | Mathlib.Data.Set.Finite.Lattice | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], BddAbove ∅ = True | null | false |
SheafOfModules.Submodule.ctorIdx | Mathlib.Algebra.Category.ModuleCat.Sheaf.Submodule | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} → {M : SheafOfModules R} → M.Submodule → ℕ | null | false |
CategoryTheory.Functor.instEffectiveEpiEffectiveEpiOver | Mathlib.CategoryTheory.EffectiveEpi.Enough | ∀ {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] (F : CategoryTheory.Functor C D) [inst_2 : F.EffectivelyEnough]
(X : D), CategoryTheory.EffectiveEpi (F.effectiveEpiOver X) | null | true |
derivWithin_fun_const | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (c : F), derivWithin (fun x => c) s = 0 | null | true |
CoeOut.mk | Init.Coe | {α : Sort u} → {β : semiOutParam (Sort v)} → (α → β) → CoeOut α β | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt64.reduceBEq.declare_295._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.869070958._hygCtx.9.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.869070958._hygCtx._hyg.302 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
CategoryTheory.Functor.IsCoverDense.sheafYonedaHom | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{K : CategoryTheory.GrothendieckTopology D} →
{A : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] →
{G : CategoryTheory... | (Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
| true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.IsCompact.nhds_hausdorff_eq_nhds_vietoris._simp_1_2 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.II.0.SimplexCategory.II.last_mem_finset._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialObject.II | ∀ {n m : ℕ} (f : Fin (n + 1) →o Fin (m + 1)) (x : Fin (m + 2)) (i : Fin (n + 2)),
(i ∈ SimplexCategory.II.finset f x) =
(i = Fin.last (n + 1) ∨ ∃ (h : i ≠ Fin.last (n + 1)), x ≤ (f (i.castPred h)).castSucc) | null | false |
Stream'.Seq1.bind_assoc | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.Seq1 α) (f : α → Stream'.Seq1 β) (g : β → Stream'.Seq1 γ),
(s.bind f).bind g = s.bind fun x => (f x).bind g | null | true |
Mathlib.Tactic.ClickSuggestions.GrwLemma.casesOn | Mathlib.Tactic.ClickSuggestions.GRewrite | {motive : Mathlib.Tactic.ClickSuggestions.GrwLemma → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.GrwLemma) →
((name : Mathlib.Tactic.ClickSuggestions.Premise) →
(symm : Bool) → (relName : Lean.Name) → motive { name := name, symm := symm, relName := relName }) →
motive t | null | false |
Std.Time.Month.instInhabitedOrdinal | Std.Time.Date.Unit.Month | Inhabited Std.Time.Month.Ordinal | null | true |
Nat.le_three_of_sqrt_eq_one | Mathlib.Data.Nat.Sqrt | ∀ {n : ℕ}, n.sqrt = 1 → n ≤ 3 | null | true |
Derivation.couple._proof_10 | Mathlib.RingTheory.Derivation.Lie | ∀ (A : Type u_1) [inst : CommRing A], SMulCommClass A A A | null | false |
_private.Mathlib.Order.ModularLattice.0.Set.Iic.isCompl_inf_inf_of_isCompl_of_le._simp_1_1 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | null | false |
Lean.Elab.Term.TacticMVarKind.term.sizeOf_spec | Lean.Elab.Term.TermElabM | sizeOf Lean.Elab.Term.TacticMVarKind.term = 1 | null | true |
_private.Lean.Meta.Tactic.Grind.Homo.0.Lean.Meta.Grind.initFn._@.Lean.Meta.Tactic.Grind.Homo.2438845489._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Homo | IO Lean.Meta.Sym.Simp.SymSimpExtension | null | false |
_private.Mathlib.Analysis.Normed.Field.Dense.0.IsAlgClosed.of_denseRange._simp_1_3 | Mathlib.Analysis.Normed.Field.Dense | ∀ {α : Type u_1} {s : Finset α}, (¬s.Nonempty) = (s = ∅) | null | false |
CategoryTheory.Functor.WellOrderInductionData.Extension.limit._proof_3 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_2} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_1)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} [inst_3 : WellFoundedLT J] (j : J)
(hj : Order.IsSuccLimit j) (e : (i : J) → i < j → d.Extension val₀ i),
(CategoryTheory.C... | null | false |
PresheafOfModulesOfCommRing.Monoidal.tensorObjMap._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ CommRingCat}
(M₁ M₂ : PresheafOfModulesOfCommRing R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (m₁ m₂ : ↑(M₁.obj X)) (n : ↑(M₂.obj X)),
(CategoryTheory.ConcreteCategory.hom (M₁.map f)) (m₁ + m₂) ⊗ₜ[↑(R.obj Y)]
(CategoryTheory.Concret... | null | false |
Partition.mk._flat_ctor | Mathlib.Order.Partition.Basic | {α : Type u_1} →
[inst : CompleteLattice α] → {s : α} → (parts : Set α) → sSupIndep parts → ⊥ ∉ parts → sSup parts = s → Partition s | null | false |
instCStarAlgebraSubtypeMemStarSubalgebraComplexElemental._proof_5 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : CStarAlgebra A], ContinuousStar A | null | false |
MvPolynomial.degrees_neg | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {R : Type u} {σ : Type u_1} [inst : CommRing R] (p : MvPolynomial σ R), (-p).degrees = p.degrees | null | true |
AddSubgroup.mem_normalizer_iff_addConj_image_eq | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {s : Set G} {g : G}, g ∈ AddSubgroup.normalizer s ↔ ⇑(AddAut.addConj g) '' s = s | null | true |
Mathlib.Tactic.BicategoryLike.MkMor₂.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkMor₂ m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkMor₂ m) →
((ofExpr : Lean.Expr → m Mathlib.Tactic.BicategoryLike.Mor₂) → motive { ofExpr := ofExpr }) → motive t | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_5 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.ball 0 r) = (‖a‖ < r) | null | false |
CategoryTheory.RightRigidCategory.noConfusionType | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.RightRigidCategory C →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
[inst'_1 : CategoryTheory.MonoidalCategory C'] ... | null | false |
AlgebraicGeometry.SheafedSpace.mk.injEq | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (toPresheafedSpace : AlgebraicGeometry.PresheafedSpace C)
(IsSheaf : toPresheafedSpace.presheaf.IsSheaf) (toPresheafedSpace_1 : AlgebraicGeometry.PresheafedSpace C)
(IsSheaf_1 : toPresheafedSpace_1.presheaf.IsSheaf),
({ toPresheafedSpace := toPresheafedSpac... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.