name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
List.maxOn_cons_cons | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {a b : α} {l : List α} {f : α → β},
List.maxOn f (a :: b :: l) ⋯ = List.maxOn f (maxOn f a b :: l) ⋯ |
Mathlib.Explode.instInhabitedEntries.default | Mathlib.Tactic.Explode.Datatypes | Mathlib.Explode.Entries |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Traj.0.ProbabilityTheory.Kernel.trajContent_tendsto_zero._proof_1_3 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ {X : ℕ → Type u_1} {p : ℕ} (x₀ : (i : ↥(Finset.Iic p)) → X ↑i)
(ind : (k : ℕ) → ((i : ↥(Finset.Iic k)) → X ↑i) → X (k + 1)) (i : ℕ),
iterateInduction x₀ ind i = iterateInduction x₀ ind i |
TwoP.casesOn | Mathlib.CategoryTheory.Category.TwoP | {motive : TwoP → Sort u_1} →
(t : TwoP) →
((X : Type u) → (toTwoPointing : TwoPointing X) → motive { X := X, toTwoPointing := toTwoPointing }) → motive t |
Mathlib.Tactic.CheckCompositions.checkCompositionsTac | Mathlib.Tactic.CategoryTheory.CheckCompositions | Lean.Elab.Tactic.TacticM Unit |
Nucleus.instMin._proof_3 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : SemilatticeInf X] (m n : Nucleus X) (x : X), x ≤ m x ⊓ n x |
CategoryTheory.StructuredArrow.mapIso_inverse_obj_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S S' : D} {T : CategoryTheory.Functor C D} (i : S ≅ S')
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S') T),
((CategoryTheory.StructuredArrow.mapIso i).inverse.obj X).right = X.right |
_private.Mathlib.ModelTheory.Algebra.Field.IsAlgClosed.0.FirstOrder.Field.finite_ACF_prime_not_realize_of_ACF_zero_realize._simp_1_3 | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, φ.not.Realize v xs = ¬φ.Realize v xs |
Algebra.Presentation.HasCoeffs.mk | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ} {R₀ : Type u_5} [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S],
P.coeffs ⊆ Set.range ⇑(algebraMap R₀ R) → P.HasCoeffs R₀ |
Lean.Grind.AC.Seq.sort | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq |
_private.Mathlib.RingTheory.Noetherian.OfPrime.0.IsNoetherianRing.of_prime._simp_1_2 | Mathlib.RingTheory.Noetherian.OfPrime | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) |
SimpleGraph.Walk.append_copy_copy | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v w u' v' w' : V} (p : G.Walk u v) (q : G.Walk v w) (hu : u = u') (hv : v = v')
(hw : w = w'), (p.copy hu hv).append (q.copy hv hw) = (p.append q).copy hu hw |
Lean.Compiler.LCNF.JoinPointContextExtender.ExtendState.fvarMap | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.JoinPointContextExtender.ExtendState →
Std.HashMap Lean.FVarId (Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) |
CompactExhaustion.shiftr._proof_1 | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] (K : CompactExhaustion X) (n : ℕ), IsCompact (Nat.casesOn n ∅ ⇑K) |
Fin.finsetImage_castAdd_Iic | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.image (Fin.castAdd m) (Finset.Iic i) = Finset.Iic (Fin.castAdd m i) |
RatFunc.liftOn | Mathlib.FieldTheory.RatFunc.Defs | {K : Type u_1} →
[inst : CommRing K] →
{P : Sort u_2} →
RatFunc K →
(f : Polynomial K → Polynomial K → P) →
(∀ {p q p' q' : Polynomial K},
q ∈ nonZeroDivisors (Polynomial K) →
q' ∈ nonZeroDivisors (Polynomial K) → q' * p = q * p' → f p q = f p' q') →
P |
TensorProduct.instSmall | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_22} {M : Type u_23} {N : Type u_24} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [Small.{u, u_23} M] [Small.{u, u_24} N],
Small.{u, max u_24 u_23} (TensorProduct R M N) |
Subgroup.quotientEquivProdOfLE'._proof_6 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {t : Subgroup α} (f : α ⧸ t → α),
Function.RightInverse f QuotientGroup.mk → ∀ (g : α), (f (Quotient.mk'' g))⁻¹ * g ∈ t |
Asymptotics.IsBigOWith.sub | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {c₁ c₂ : ℝ}
{g : α → F} {l : Filter α} {f₁ f₂ : α → E'},
Asymptotics.IsBigOWith c₁ l f₁ g →
Asymptotics.IsBigOWith c₂ l f₂ g → Asymptotics.IsBigOWith (c₁ + c₂) l (fun x => f₁ x - f₂ x) g |
Std.DTreeMap.Internal.Impl.rotateR.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (lk : α) (lv : β lk) (ll r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ)
(lk_1 : α) (lv_1 : β lk_1) (ll_1 lr_1 : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.rotateR k v lk lv ll (Std.DTreeMap.Internal.Impl.inner ls lk_1 lv_1 ll_1 lr_1) r =
if (Std.DTreeMap.Internal.Impl.inner ls lk_1 lv_1 ll_1 lr_1).size < Std.DTreeMap.Internal.ratio * ll.size then
Std.DTreeMap.Internal.Impl.singleR k v lk lv ll (Std.DTreeMap.Internal.Impl.inner ls lk_1 lv_1 ll_1 lr_1) r
else Std.DTreeMap.Internal.Impl.doubleR k v lk lv ll lk_1 lv_1 ll_1 lr_1 r |
ProbabilityTheory.beta_eq_betaIntegralReal | Mathlib.Probability.Distributions.Beta | ∀ (α β : ℝ), 0 < α → 0 < β → ProbabilityTheory.beta α β = ((↑α).betaIntegral ↑β).re |
PowerSeries.rescale._proof_1 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (a : R), (PowerSeries.mk fun n => a ^ n * (PowerSeries.coeff n) 1) = 1 |
_private.Lean.Elab.DocString.0.Lean.Doc.fixupInline.match_1 | Lean.Elab.DocString | (motive : Option (Lean.Doc.Ref✝ String) → Sort u_1) →
(x : Option (Lean.Doc.Ref✝¹ String)) →
((r : Lean.Doc.Ref✝² String) →
(url : String) →
(location : Lean.Syntax) →
(seen : Bool) →
(h : r = { content := url, location := location, seen := seen }) →
motive (some (namedPattern r { content := url, location := location, seen := seen } h))) →
((x : Option (Lean.Doc.Ref✝³ String)) → motive x) → motive x |
CategoryTheory.Arrow.hom.congr_left | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {f g : CategoryTheory.Arrow T} {φ₁ φ₂ : f ⟶ g},
φ₁ = φ₂ → φ₁.left = φ₂.left |
finsuppTensorFinsuppRid | Mathlib.LinearAlgebra.DirectSum.Finsupp | (R : Type u_1) →
(M : Type u_3) →
(ι : Type u_5) →
(κ : Type u_6) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → TensorProduct R (ι →₀ M) (κ →₀ R) ≃ₗ[R] ι × κ →₀ M |
Nat.not_dvd_of_pos_of_lt | Init.Data.Nat.Lemmas | ∀ {n m : ℕ}, 0 < n → n < m → ¬m ∣ n |
CategoryTheory.Pseudofunctor.DescentData'.comm | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Limits.ChosenPullback₃ (sq i₁ i₂) (sq i₂ i₃) (sq i₁ i₃)}
{D₁ D₂ : F.DescentData' sq sq₃} (φ : D₁ ⟶ D₂) ⦃Y : C⦄ (q : Y ⟶ S) ⦃i₁ i₂ : ι⦄ (f₁ : Y ⟶ X i₁) (f₂ : Y ⟶ X i₂)
(hf₁ :
autoParam (CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q) CategoryTheory.Pseudofunctor.DescentData'.comm._auto_1)
(hf₂ :
autoParam (CategoryTheory.CategoryStruct.comp f₂ (f i₂) = q)
CategoryTheory.Pseudofunctor.DescentData'.comm._auto_3),
CategoryTheory.CategoryStruct.comp ((F.map f₁.op.toLoc).toFunctor.map (φ.hom i₁))
(CategoryTheory.Pseudofunctor.DescentData'.pullHom' D₂.hom q f₁ f₂ hf₁ hf₂) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pseudofunctor.DescentData'.pullHom' D₁.hom q f₁ f₂ hf₁ hf₂)
((F.map f₂.op.toLoc).toFunctor.map (φ.hom i₂)) |
instDecidableEqFreeMagma.decEq | Mathlib.Algebra.Free | {α : Type u_1} → [DecidableEq α] → (x x_1 : FreeMagma α) → Decidable (x = x_1) |
CategoryTheory.IndParallelPairPresentation.F₂ | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{A B : CategoryTheory.Functor Cᵒᵖ (Type v₁)} →
{f g : A ⟶ B} → (self : CategoryTheory.IndParallelPairPresentation f g) → CategoryTheory.Functor self.I C |
Lean.Grind.AC.instBEqExpr | Init.Grind.AC | BEq Lean.Grind.AC.Expr |
Finset.card_mono | Mathlib.Data.Finset.Card | ∀ {α : Type u_1}, Monotone Finset.card |
Std.Time.HourMarker.rec | Std.Time.Time.HourMarker | {motive : Std.Time.HourMarker → Sort u} →
motive Std.Time.HourMarker.am → motive Std.Time.HourMarker.pm → (t : Std.Time.HourMarker) → motive t |
MonotoneOn.inv | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} {β : Type u_1} [inst : Group α] [inst_1 : Preorder α] [MulLeftMono α] [MulRightMono α]
[inst_4 : Preorder β] {f : β → α} {s : Set β}, MonotoneOn f s → AntitoneOn (fun x => (f x)⁻¹) s |
«term_→SWOT[_]_» | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | Lean.TrailingParserDescr |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_one_sub._simp_1_5 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {a : Prop}, (a → a) = True |
Int.tdiv_add_tmod | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.tdiv b + a.tmod b = a |
«termΣ'_,_» | Init.NotationExtra | Lean.ParserDescr |
Lean.LocalContext.modifyLocalDecls | Lean.LocalContext | Lean.LocalContext → (Lean.LocalDecl → Lean.LocalDecl) → Lean.LocalContext |
Fintype.card_fin_two | Mathlib.Data.Fintype.Parity | Fact (Even (Fintype.card (Fin 2))) |
_private.Init.Data.Array.InsertIdx.0.Array.getElem_insertIdx_of_gt._proof_1_1 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {xs : Array α} {i k : ℕ}, k > i → k < i → False |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.get?.match_1.eq_1 | Batteries.Data.String.Lemmas | ∀ (motive : String → String.Pos.Raw → Sort u_1) (s : String) (p : String.Pos.Raw)
(h_1 : (s : String) → (p : String.Pos.Raw) → motive s p),
(match s, p with
| s, p => h_1 s p) =
h_1 s p |
CochainComplex.instHasShiftInt._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | 0 = 0 |
HVertexOperator.compHahnSeries_add | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_5} {Γ' : Type u_6} [inst : PartialOrder Γ] [inst_1 : PartialOrder Γ'] {R : Type u_7} [inst_2 : CommRing R]
{U : Type u_8} {V : Type u_9} {W : Type u_10} [inst_3 : AddCommGroup U] [inst_4 : Module R U]
[inst_5 : AddCommGroup V] [inst_6 : Module R V] [inst_7 : AddCommGroup W] [inst_8 : Module R W]
(A : HVertexOperator Γ R V W) (B : HVertexOperator Γ' R U V) (u v : U),
A.compHahnSeries B (u + v) = A.compHahnSeries B u + A.compHahnSeries B v |
MeasurableEquiv.eq_image_iff_symm_image_eq | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β) (s : Set β)
(t : Set α), s = ⇑e '' t ↔ ⇑e.symm '' s = t |
Subsemiring.pointwise_smul_le_pointwise_smul_iff₀ | Mathlib.Algebra.Ring.Subsemiring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : GroupWithZero M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {a : M},
a ≠ 0 → ∀ {S T : Subsemiring R}, a • S ≤ a • T ↔ S ≤ T |
MonadFunctor.mk.noConfusion | Init.Prelude | {m : semiOutParam (Type u → Type v)} →
{n : Type u → Type w} →
{P : Sort u_1} →
{monadMap monadMap' : {α : Type u} → ({β : Type u} → m β → m β) → n α → n α} →
{ monadMap := monadMap } = { monadMap := monadMap' } → (monadMap ≍ monadMap' → P) → P |
_private.Init.Data.Nat.Lemmas.0.Nat.succ_mod_succ_eq_zero_iff._simp_1_1 | Init.Data.Nat.Lemmas | ∀ (n : ℕ), (n + 1 = 0) = False |
Lean.Data.AC.Context | Init.Data.AC | Sort u → Type u |
Turing.ToPartrec.Code.fix.noConfusion | Mathlib.Computability.TuringMachine.Config | {P : Sort u} → {a a' : Turing.ToPartrec.Code} → a.fix = a'.fix → (a = a' → P) → P |
AlgebraicGeometry.IsAffineOpen.image_of_isOpenImmersion | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X Y : AlgebraicGeometry.Scheme} {U : X.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (f : X ⟶ Y) [H : AlgebraicGeometry.IsOpenImmersion f],
AlgebraicGeometry.IsAffineOpen ((AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U) |
Num.div.eq_1 | Mathlib.Data.Num.ZNum | ∀ (x : Num), Num.zero.div x = 0 |
RealRMK.rieszMeasure.eq_1 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] [inst_2 : MeasurableSpace X] [inst_3 : BorelSpace X]
(Λ : CompactlySupportedContinuousMap X ℝ →ₚ[ℝ] ℝ) [inst_4 : LocallyCompactSpace X],
RealRMK.rieszMeasure Λ = (rieszContent (CompactlySupportedContinuousMap.toNNRealLinear Λ)).measure |
Lean.PersistentHashMap.instGetElemOptionTrue | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
{x : BEq α} → {x_1 : Hashable α} → GetElem (Lean.PersistentHashMap α β) α (Option β) fun x x_2 => True |
IsPrimitiveRoot.mk | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {ζ : M} {k : ℕ}, ζ ^ k = 1 → (∀ (l : ℕ), ζ ^ l = 1 → k ∣ l) → IsPrimitiveRoot ζ k |
Lean.Linter.UnusedVariables.FVarDefinition._sizeOf_1 | Lean.Linter.UnusedVariables | Lean.Linter.UnusedVariables.FVarDefinition → ℕ |
_private.Init.Data.Array.Basic.0.Array.firstM.go._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α), ∀ i < as.size, InvImage (fun x1 x2 => x1 < x2) (fun x => as.size - x) (i + 1) i |
Polynomial.expand_C | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p : ℕ) (r : R), (Polynomial.expand R p) (Polynomial.C r) = Polynomial.C r |
Filter.Germ.const_top | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [inst : Top β], ↑⊤ = ⊤ |
CategoryTheory.Mon.forgetMapConeLimitConeIso_hom_hom | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (hc : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.Mon.forgetMapConeLimitConeIso F c hc).hom.hom = CategoryTheory.CategoryStruct.id c.pt |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula.0.WeierstrassCurve.Affine.nonsingular_negAdd._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a ≠ 0) = (a ≠ 0) |
Std.Time.PlainDateTime.addWeeks | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Week.Offset → Std.Time.PlainDateTime |
CategoryTheory.GrothendieckTopology.plusCompIso.congr_simp | Mathlib.CategoryTheory.Sites.CompatiblePlus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} E]
(F : CategoryTheory.Functor D E)
[inst_3 :
∀ (J : CategoryTheory.Limits.MulticospanShape),
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan J) D]
[inst_4 :
∀ (J : CategoryTheory.Limits.MulticospanShape),
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan J) E]
[inst_5 :
∀ (X : C) (W : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D),
CategoryTheory.Limits.PreservesLimit (W.index P).multicospan F]
(P : CategoryTheory.Functor Cᵒᵖ D) [inst_6 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D]
[inst_7 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ E]
[inst_8 : ∀ (X : C), CategoryTheory.Limits.PreservesColimitsOfShape (J.Cover X)ᵒᵖ F],
J.plusCompIso F P = J.plusCompIso F P |
_private.Lean.Elab.Tactic.Do.VCGen.Basic.0.Lean.Elab.Tactic.Do.initFn._@.Lean.Elab.Tactic.Do.VCGen.Basic.540456248._hygCtx._hyg.2 | Lean.Elab.Tactic.Do.VCGen.Basic | IO Unit |
GroupSeminorm.funLike._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : Group E] (f g : GroupSeminorm E), (fun f => f.toFun) f = (fun f => f.toFun) g → f = g |
List.getElem?_set_self' | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {i : ℕ} {a : α}, (l.set i a)[i]? = Function.const α a <$> l[i]? |
_private.Mathlib.MeasureTheory.Measure.AEDisjoint.0.MeasureTheory.exists_null_pairwise_disjoint_diff._simp_1_2 | Mathlib.MeasureTheory.Measure.AEDisjoint | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) |
_private.Mathlib.Order.Interval.Set.OrdConnectedComponent.0.Set.dual_ordConnectedSection._simp_1_4 | Mathlib.Order.Interval.Set.OrdConnectedComponent | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x |
Std.DHashMap.Raw.Const.getKey?_insertManyIfNewUnit_list_of_mem | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α fun x => Unit} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {l : List α} {k : α}, k ∈ m → (Std.DHashMap.Raw.Const.insertManyIfNewUnit m l).getKey? k = m.getKey? k |
Quiver.freeGroupoidFunctor | Mathlib.CategoryTheory.Groupoid.FreeGroupoid | {V : Type u} →
[inst : Quiver V] →
{V' : Type u'} →
[inst_1 : Quiver V'] → V ⥤q V' → CategoryTheory.Functor (Quiver.FreeGroupoid V) (Quiver.FreeGroupoid V') |
Nat.add_mod_eq_add_mod_right | Init.Data.Nat.Lemmas | ∀ {a d b : ℕ} (c : ℕ), a % d = b % d → (a + c) % d = (b + c) % d |
CategoryTheory.Functor.lanAdjunction._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] (L : CategoryTheory.Functor C D) (H : Type u_3)
[inst_2 : CategoryTheory.Category.{u_2, u_3} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
{F : CategoryTheory.Functor C H} {G₁ G₂ : CategoryTheory.Functor D H} (β : L.lan.obj F ⟶ G₁) (f : G₁ ⟶ G₂),
((L.lan.obj F).homEquivOfIsLeftKanExtension (L.lanUnit.app F) G₂) (CategoryTheory.CategoryStruct.comp β f) =
CategoryTheory.CategoryStruct.comp (((L.lan.obj F).homEquivOfIsLeftKanExtension (L.lanUnit.app F) G₁) β)
(((CategoryTheory.Functor.whiskeringLeft C D H).obj L).map f) |
LinearEquiv.alternatingMapCongrRight._proof_4 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {ι : Type u_3} {R' : Type u_4} {M'' : Type u_1} {N'' : Type u_5} {N₂'' : Type u_2} [inst : CommSemiring R']
[inst_1 : AddCommMonoid M''] [inst_2 : AddCommMonoid N''] [inst_3 : AddCommMonoid N₂''] [inst_4 : Module R' M'']
[inst_5 : Module R' N''] [inst_6 : Module R' N₂''] (e : N'' ≃ₗ[R'] N₂'') (x : M'' [⋀^ι]→ₗ[R'] N₂''),
(fun f => (↑e).compAlternatingMap f) ((fun f => (↑e.symm).compAlternatingMap f) x) = x |
NumberField.prod_abs_eq_one | Mathlib.NumberTheory.NumberField.ProductFormula | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {x : K},
x ≠ 0 → (∏ w, w x ^ w.mult) * ∏ᶠ (w : NumberField.FinitePlace K), w x = 1 |
CategoryTheory.comonadToFunctor._proof_2 | Mathlib.CategoryTheory.Monad.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : CategoryTheory.Comonad C} (f : X ⟶ Y)
(g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).toNatTrans = CategoryTheory.CategoryStruct.comp f.toNatTrans g.toNatTrans |
Std.TreeMap.containsThenInsertIfNew | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → β → Bool × Std.TreeMap α β cmp |
Aesop.initFn._@.Aesop.Check.1191392668._hygCtx._hyg.5 | Aesop.Check | IO (Lean.Option Bool) |
Int.Linear.cooper_dvd_left_split_ineq | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p₁ p₂ p₃ : Int.Linear.Poly) (d : ℤ) (k : ℕ) (b : ℤ) (p' : Int.Linear.Poly),
Int.Linear.cooper_dvd_left_split ctx p₁ p₂ p₃ d k →
Int.Linear.cooper_dvd_left_split_ineq_cert p₁ p₂ (↑k) b p' = true → Int.Linear.Poly.denote' ctx p' ≤ 0 |
Lean.Parser.Command.namespace._regBuiltin.Lean.Parser.Command.namespace.declRange_5 | Lean.Parser.Command | IO Unit |
List.takeWhile._unsafe_rec | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → List α |
CategoryTheory.Bicategory.Strict.id_comp | Mathlib.CategoryTheory.Bicategory.Strict.Basic | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} [self : CategoryTheory.Bicategory.Strict B] {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f = f |
Affine.Simplex.excenterWeightsUnnorm_map | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {V₂ : Type u_3} {P₂ : Type u_4} [inst_4 : NormedAddCommGroup V₂]
[inst_5 : InnerProductSpace ℝ V₂] [inst_6 : MetricSpace P₂] [inst_7 : NormedAddTorsor V₂ P₂] {n : ℕ}
[inst_8 : NeZero n] (s : Affine.Simplex ℝ P n) (f : P →ᵃⁱ[ℝ] P₂),
(s.map f.toAffineMap ⋯).excenterWeightsUnnorm = s.excenterWeightsUnnorm |
ContextFreeGrammar.reverse_initial | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} (g : ContextFreeGrammar T), g.reverse.initial = g.initial |
Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mk.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
{P : Sort u} →
{mkNaturalityAssociator :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Lean.Expr} →
{mkNaturalityLeftUnitor mkNaturalityRightUnitor mkNaturalityId :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Lean.Expr} →
{mkNaturalityComp :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → Lean.Expr → m Lean.Expr} →
{mkNaturalityWhiskerLeft mkNaturalityWhiskerRight :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → m Lean.Expr} →
{mkNaturalityHorizontalComp :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → Lean.Expr → m Lean.Expr} →
{mkNaturalityInv :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → m Lean.Expr} →
{mkNaturalityAssociator' :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Lean.Expr} →
{mkNaturalityLeftUnitor' mkNaturalityRightUnitor' mkNaturalityId' :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Lean.Expr} →
{mkNaturalityComp' :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → Lean.Expr → m Lean.Expr} →
{mkNaturalityWhiskerLeft' mkNaturalityWhiskerRight' :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → m Lean.Expr} →
{mkNaturalityHorizontalComp' :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Lean.Expr → Lean.Expr → m Lean.Expr} →
{mkNaturalityInv' :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → Lean.Expr → m Lean.Expr} →
{ mkNaturalityAssociator := mkNaturalityAssociator,
mkNaturalityLeftUnitor := mkNaturalityLeftUnitor,
mkNaturalityRightUnitor := mkNaturalityRightUnitor, mkNaturalityId := mkNaturalityId,
mkNaturalityComp := mkNaturalityComp,
mkNaturalityWhiskerLeft := mkNaturalityWhiskerLeft,
mkNaturalityWhiskerRight := mkNaturalityWhiskerRight,
mkNaturalityHorizontalComp := mkNaturalityHorizontalComp,
mkNaturalityInv := mkNaturalityInv } =
{ mkNaturalityAssociator := mkNaturalityAssociator',
mkNaturalityLeftUnitor := mkNaturalityLeftUnitor',
mkNaturalityRightUnitor := mkNaturalityRightUnitor',
mkNaturalityId := mkNaturalityId', mkNaturalityComp := mkNaturalityComp',
mkNaturalityWhiskerLeft := mkNaturalityWhiskerLeft',
mkNaturalityWhiskerRight := mkNaturalityWhiskerRight',
mkNaturalityHorizontalComp := mkNaturalityHorizontalComp',
mkNaturalityInv := mkNaturalityInv' } →
(mkNaturalityAssociator ≍ mkNaturalityAssociator' →
mkNaturalityLeftUnitor ≍ mkNaturalityLeftUnitor' →
mkNaturalityRightUnitor ≍ mkNaturalityRightUnitor' →
mkNaturalityId ≍ mkNaturalityId' →
mkNaturalityComp ≍ mkNaturalityComp' →
mkNaturalityWhiskerLeft ≍ mkNaturalityWhiskerLeft' →
mkNaturalityWhiskerRight ≍ mkNaturalityWhiskerRight' →
mkNaturalityHorizontalComp ≍ mkNaturalityHorizontalComp' →
mkNaturalityInv ≍ mkNaturalityInv' → P) →
P |
AList.union_erase | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s₁ s₂ : AList β),
AList.erase a (s₁ ∪ s₂) = AList.erase a s₁ ∪ AList.erase a s₂ |
Complex.instContinuousMapUniqueHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {A : Type u_2} [inst : TopologicalSpace A] [T2Space A] [inst_2 : Ring A] [inst_3 : StarRing A] [inst_4 : Algebra ℂ A],
ContinuousMap.UniqueHom ℂ A |
Set.image_fintype_sum_pi | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : Fintype ι] (S : ι → Set α),
(fun f => ∑ i, f i) '' Set.univ.pi S = ∑ i, S i |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.Path.Ordered.erase.match_1_1 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering}
(motive :
(x : Batteries.RBNode.Path α) →
(x_1 : Batteries.RBNode α) →
Batteries.RBNode.Path.Ordered cmp x →
Batteries.RBNode.Ordered cmp x_1 → Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp x) x_1 → Prop)
(x : Batteries.RBNode.Path α) (x_1 : Batteries.RBNode α) (x_2 : Batteries.RBNode.Path.Ordered cmp x)
(x_3 : Batteries.RBNode.Ordered cmp x_1) (x_4 : Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp x) x_1),
(∀ (x : Batteries.RBNode.Path α) (hp : Batteries.RBNode.Path.Ordered cmp x)
(ht : Batteries.RBNode.Ordered cmp Batteries.RBNode.nil)
(tp : Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp x) Batteries.RBNode.nil),
motive x Batteries.RBNode.nil hp ht tp) →
(∀ (x : Batteries.RBNode.Path α) (c : Batteries.RBColor) (l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α)
(hp : Batteries.RBNode.Path.Ordered cmp x)
(ax : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x v) l)
(xb : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp v x) r) (ha : Batteries.RBNode.Ordered cmp l)
(hb : Batteries.RBNode.Ordered cmp r) (left : Batteries.RBNode.Path.RootOrdered cmp x v)
(ap : Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp x) l)
(bp : Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp x) r),
motive x (Batteries.RBNode.node c l v r) hp ⋯ ⋯) →
motive x x_1 x_2 x_3 x_4 |
FreeGroup.Lift.aux.eq_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {β : Type v} [inst : Group β] (f : α → β) (L : List (α × Bool)),
FreeGroup.Lift.aux f L = (List.map (fun x => bif x.2 then f x.1 else (f x.1)⁻¹) L).prod |
ProfiniteGrp._sizeOf_inst | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | SizeOf ProfiniteGrp.{u} |
Lean.Elab.Command.Structure.StructParentView.type | Lean.Elab.Structure | Lean.Elab.Command.Structure.StructParentView → Lean.Syntax |
LinearMap.BilinForm.isPosSemidef_iff | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : LE R]
{B : LinearMap.BilinForm R M}, B.IsPosSemidef ↔ LinearMap.IsPosSemidef B |
Lean.Lsp.instFromJsonWorkspaceFolder.fromJson | Lean.Data.Lsp.Workspace | Lean.Json → Except String Lean.Lsp.WorkspaceFolder |
NumberField.InfinitePlace.not_isReal_of_mk_isComplex | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] {φ : K →+* ℂ},
(NumberField.InfinitePlace.mk φ).IsComplex → ¬NumberField.ComplexEmbedding.IsReal φ |
CategoryTheory.sheafify | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[CategoryTheory.HasWeakSheafify J D] → CategoryTheory.Functor Cᵒᵖ D → CategoryTheory.Functor Cᵒᵖ D |
Mathlib.Meta.NormNum.NormNums.mk._flat_ctor | Mathlib.Tactic.NormNum.Core | Lean.Meta.DiscrTree Mathlib.Meta.NormNum.NormNumExt → Lean.PHashSet Lean.Name → Mathlib.Meta.NormNum.NormNums |
NonUnitalStarSubalgebra.copy | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Star A] → (S : NonUnitalStarSubalgebra R A) → (s : Set A) → s = ↑S → NonUnitalStarSubalgebra R A |
Std.DTreeMap.Internal.Impl.Const.get!_insert | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β] (h : t.WF) {k a : α} {v : β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl a =
if compare k a = Ordering.eq then v else Std.DTreeMap.Internal.Impl.Const.get! t a |
PrimeSpectrum.BasicConstructibleSetData.n | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} → PrimeSpectrum.BasicConstructibleSetData R → ℕ |
Nat.pos_of_lt_add_left | Init.Data.Nat.Lemmas | ∀ {n k : ℕ}, n < k + n → 0 < k |
isNilpotent_of_subsingleton | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_3} {x : R} [inst : Zero R] [inst_1 : Pow R ℕ] [Subsingleton R], IsNilpotent x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.