name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.ensureType._sparseCasesOn_1 | Lean.Meta.LetToHave | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t |
ContinuousMap.instCommGroupContinuousMap._proof_9 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : CommGroup β]
[inst_3 : IsTopologicalGroup β] (f : C(α, β)) (z : ℤ), ⇑(f ^ z) = ⇑f ^ z |
ConnectedSpace.recOn | Mathlib.Topology.Connected.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{motive : ConnectedSpace α → Sort u_1} →
(t : ConnectedSpace α) →
([toPreconnectedSpace : PreconnectedSpace α] → (toNonempty : Nonempty α) → motive ⋯) → motive t |
Polynomial.toAddCircle.integrable | Mathlib.Analysis.Polynomial.Fourier | ∀ (p : Polynomial ℂ), MeasureTheory.Integrable (⇑(Polynomial.toAddCircle p)) AddCircle.haarAddCircle |
DerivedCategory.instHasShiftInt | Mathlib.Algebra.Homology.DerivedCategory.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : HasDerivedCategory C] → CategoryTheory.HasShift (DerivedCategory C) ℤ |
_private.Mathlib.CategoryTheory.Functor.OfSequence.0.CategoryTheory.Functor.OfSequence.map_comp._proof_1_12 | Mathlib.CategoryTheory.Functor.OfSequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (i : ℕ) {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1))
(hij : i + 1 ≤ 0) (hjk : 0 ≤ 0),
CategoryTheory.Functor.OfSequence.map f (i + 1) 0 ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OfSequence.map f (i + 1) 0 hij)
(CategoryTheory.Functor.OfSequence.map f 0 0 hjk) |
Lean.Core.instMonadResolveNameCoreM | Lean.CoreM | Lean.MonadResolveName Lean.CoreM |
_private.Mathlib.Analysis.Analytic.CPolynomial.0.CPolynomialAt.add.match_1_1 | Mathlib.Analysis.Analytic.CPolynomial | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {g : E → F} {x : E}
(motive : CPolynomialAt 𝕜 g x → Prop) (hg : CPolynomialAt 𝕜 g x),
(∀ (w : FormalMultilinearSeries 𝕜 E F) (w_1 : ℕ) (hqf : HasFiniteFPowerSeriesAt g w x w_1), motive ⋯) → motive hg |
_private.Lean.Meta.InferType.0.Lean.Meta.inferFVarType | Lean.Meta.InferType | Lean.FVarId → Lean.MetaM Lean.Expr |
Std.DTreeMap.Internal.Impl.le_minKeyD | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
t.isEmpty = false →
∀ {k fallback : α}, (compare k (t.minKeyD fallback)).isLE = true ↔ ∀ k' ∈ t, (compare k k').isLE = true |
Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | ∀ (lhs : ℕ) (rhs : Lean.Meta.Grind.CnstrRHS),
sizeOf (Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq lhs rhs) = 1 + sizeOf lhs + sizeOf rhs |
CommSemiRingCat.instCategory._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {W X Y Z : CommSemiRingCat} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_alter_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
AlgebraicTopology.DoldKan.homotopyPToId.eq_2 | Mathlib.AlgebraicTopology.DoldKan.HomotopyEquivalence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C) (q : ℕ),
AlgebraicTopology.DoldKan.homotopyPToId X q.succ =
(Homotopy.ofEq ⋯).trans
(((AlgebraicTopology.DoldKan.homotopyPToId X q).add
((AlgebraicTopology.DoldKan.homotopyHσToZero q).compLeft (AlgebraicTopology.DoldKan.P q))).trans
(Homotopy.ofEq ⋯)) |
Localization.mk_lt_mk | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelMonoid α] {s : Submonoid α}
{a₁ b₁ : α} {a₂ b₂ : ↥s}, Localization.mk a₁ a₂ < Localization.mk b₁ b₂ ↔ ↑b₂ * a₁ < ↑a₂ * b₁ |
TwoSidedIdeal.coeAddMonoidHom._proof_1 | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R), ↑0 = ↑0 |
CategoryTheory.Functor.instLaxMonoidalActionMapAction._proof_5 | Mathlib.CategoryTheory.Action.Monoidal | ∀ {V : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} V] {G : Type u_2} [inst_1 : Monoid G] {W : Type u_3}
[inst_2 : CategoryTheory.Category.{u_1, u_3} W] [inst_3 : CategoryTheory.MonoidalCategory V]
[inst_4 : CategoryTheory.MonoidalCategory W] (F : CategoryTheory.Functor V W) [inst_5 : F.LaxMonoidal]
(x : Action V G),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor ((F.mapAction G).obj x)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight { hom := CategoryTheory.Functor.LaxMonoidal.ε F, comm := ⋯ }
((F.mapAction G).obj x))
(CategoryTheory.CategoryStruct.comp
{
hom :=
CategoryTheory.Functor.LaxMonoidal.μ F (CategoryTheory.MonoidalCategoryStruct.tensorUnit (Action V G)).V
x.V,
comm := ⋯ }
((F.mapAction G).map (CategoryTheory.MonoidalCategoryStruct.leftUnitor x).hom)) |
Vector.back_mk._proof_2 | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} [NeZero n] {xs : Array α}, xs.size = n → 0 < xs.size |
Std.Do.PostShape.arg.sizeOf_spec | Std.Do.PostCond | ∀ (σ : Type u) (a : Std.Do.PostShape), sizeOf (Std.Do.PostShape.arg σ a) = 1 + sizeOf σ + sizeOf a |
csSup_image2_eq_csInf_csSup | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompleteLattice α]
[inst_1 : ConditionallyCompleteLattice β] [inst_2 : ConditionallyCompleteLattice γ] {s : Set α} {t : Set β}
{l : α → β → γ} {u₁ : β → γ → α} {u₂ : α → γ → β},
(∀ (b : β), GaloisConnection (Function.swap l b ∘ ⇑OrderDual.ofDual) (⇑OrderDual.toDual ∘ u₁ b)) →
(∀ (a : α), GaloisConnection (l a) (u₂ a)) →
s.Nonempty → BddBelow s → t.Nonempty → BddAbove t → sSup (Set.image2 l s t) = l (sInf s) (sSup t) |
LinearIsometry.norm_map' | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂] {σ₁₂ : R →+* R₂} {E : Type u_11}
{E₂ : Type u_12} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (self : E →ₛₗᵢ[σ₁₂] E₂) (x : E), ‖self.toLinearMap x‖ = ‖x‖ |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula.0.WeierstrassCurve.Jacobian.toAffine_negAddY_of_eq._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
CategoryTheory.Limits.Concrete.isColimit_rep_eq_iff_exists | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type s}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {J : Type w}
[inst_3 : CategoryTheory.Category.{r, w} J] (F : CategoryTheory.Functor J C)
[CategoryTheory.Limits.PreservesColimit F (CategoryTheory.forget C)] [CategoryTheory.IsFiltered J]
{D : CategoryTheory.Limits.Cocone F} {i j : J} (hD : CategoryTheory.Limits.IsColimit D)
(x : CategoryTheory.ToType (F.obj i)) (y : CategoryTheory.ToType (F.obj j)),
(CategoryTheory.ConcreteCategory.hom (D.ι.app i)) x = (CategoryTheory.ConcreteCategory.hom (D.ι.app j)) y ↔
∃ k f g, (CategoryTheory.ConcreteCategory.hom (F.map f)) x = (CategoryTheory.ConcreteCategory.hom (F.map g)) y |
Lean.RBNode.max | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → Lean.RBNode α β → Option ((k : α) × β k) |
inf_le_sup | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b : α}, a ⊓ b ≤ a ⊔ b |
exists_or_eq_left' | Init.PropLemmas | ∀ {α : Sort u_1} (y : α) (p : α → Prop), ∃ x, y = x ∨ p x |
Plausible.InjectiveFunction.shrinkPerm | Mathlib.Testing.Plausible.Functions | {α : Type} →
[DecidableEq α] →
(xs : List α) ×' (ys : List α) ×' xs.Perm ys ∧ ys.Nodup →
List ((xs : List α) ×' (ys : List α) ×' xs.Perm ys ∧ ys.Nodup) |
EulerProduct.eulerProduct_hasProd | Mathlib.NumberTheory.EulerProduct.Basic | ∀ {R : Type u_1} [inst : NormedCommRing R] {f : ℕ → R} [CompleteSpace R],
f 1 = 1 →
(∀ {m n : ℕ}, m.Coprime n → f (m * n) = f m * f n) →
(Summable fun x => ‖f x‖) → f 0 = 0 → HasProd (fun p => ∑' (e : ℕ), f (↑p ^ e)) (∑' (n : ℕ), f n) |
CategoryTheory.Functor.IsLocallyFaithful.of_faithful | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | ∀ {C : Type uC} [inst : CategoryTheory.Category.{vC, uC} C] {D : Type uD} [inst_1 : CategoryTheory.Category.{vD, uD} D]
{K : CategoryTheory.GrothendieckTopology D} (G : CategoryTheory.Functor C D) [G.Faithful], G.IsLocallyFaithful K |
iInf_comm | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} [inst : CompleteLattice α] {f : ι → ι' → α},
⨅ i, ⨅ j, f i j = ⨅ j, ⨅ i, f i j |
AlgebraicGeometry.instFinitaryExtensiveScheme | Mathlib.AlgebraicGeometry.Limits | CategoryTheory.FinitaryExtensive AlgebraicGeometry.Scheme |
Mathlib.Tactic.Monoidal.Context.mk.injEq | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | ∀ (level₂ level₁ : Lean.Level) (C : Q(Type level₁)) (instCat : Q(CategoryTheory.Category.{level₂, level₁} «$C»))
(instMonoidal? : Option Q(CategoryTheory.MonoidalCategory «$C»)) (level₂_1 level₁_1 : Lean.Level)
(C_1 : Q(Type level₁_1)) (instCat_1 : Q(CategoryTheory.Category.{level₂_1, level₁_1} «$C_1»))
(instMonoidal?_1 : Option Q(CategoryTheory.MonoidalCategory «$C_1»)),
({ level₂ := level₂, level₁ := level₁, C := C, instCat := instCat, instMonoidal? := instMonoidal? } =
{ level₂ := level₂_1, level₁ := level₁_1, C := C_1, instCat := instCat_1, instMonoidal? := instMonoidal?_1 }) =
(level₂ = level₂_1 ∧ level₁ = level₁_1 ∧ C = C_1 ∧ instCat = instCat_1 ∧ instMonoidal? = instMonoidal?_1) |
MeasureTheory.integral_restrict_infinitePi | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {mX : (i : ι) → MeasurableSpace (X i)} (μ : (i : ι) → MeasureTheory.Measure (X i))
[hμ : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)] {E : Type u_3} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] {s : Finset ι} {f : ((i : ↥s) → X ↑i) → E},
MeasureTheory.AEStronglyMeasurable f (MeasureTheory.Measure.pi fun i => μ ↑i) →
∫ (y : (i : ι) → X i), f (s.restrict y) ∂MeasureTheory.Measure.infinitePi μ =
∫ (y : (i : ↥s) → X ↑i), f y ∂MeasureTheory.Measure.pi fun i => μ ↑i |
Set.decidableMemIoc | Mathlib.Order.Interval.Set.Basic | {α : Type u_1} →
[inst : Preorder α] → {a b x : α} → [Decidable (a < x)] → [Decidable (x ≤ b)] → Decidable (x ∈ Set.Ioc a b) |
Finset.Iio_filter_lt | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_3} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrderBot α] (a b : α),
{x ∈ Finset.Iio a | x < b} = Finset.Iio (min a b) |
Bicategory.Opposite.op2 | Mathlib.CategoryTheory.Bicategory.Opposites | {B : Type u} → [inst : CategoryTheory.Bicategory B] → {a b : B} → {f g : a ⟶ b} → (f ⟶ g) → (f.op ⟶ g.op) |
_private.Mathlib.Order.Filter.AtTopBot.BigOperators.0.Function.Injective.map_atTop_finset_prod_eq._simp_1_1 | Mathlib.Order.Filter.AtTopBot.BigOperators | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) |
Real.nnabs_of_nonneg | Mathlib.Data.NNReal.Defs | ∀ {x : ℝ}, 0 ≤ x → Real.nnabs x = x.toNNReal |
String.Slice.Pattern.ForwardPattern.rec | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
{motive : String.Slice.Pattern.ForwardPattern pat → Sort u} →
((dropPrefix? : (s : String.Slice) → Option s.Pos) →
(dropPrefixOfNonempty? : (s : String.Slice) → s.isEmpty = false → Option s.Pos) →
(startsWith : String.Slice → Bool) →
motive
{ dropPrefix? := dropPrefix?, dropPrefixOfNonempty? := dropPrefixOfNonempty?,
startsWith := startsWith }) →
(t : String.Slice.Pattern.ForwardPattern pat) → motive t |
Lean.Meta.Tactic.Cbv.CbvOpaqueExtension | Lean.Meta.Tactic.Cbv.Opaque | Type |
OpenNormalAddSubgroup.instNormal | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u} [inst : AddGroup G] [inst_1 : TopologicalSpace G] (H : OpenNormalAddSubgroup G),
(↑H.toOpenAddSubgroup).Normal |
CategoryTheory.Abelian.SpectralObject.comp_hom_assoc | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
{X Y Z : CategoryTheory.Abelian.SpectralObject C ι} (f : X.Hom Y) (g : Y.Hom Z) (n : ℤ)
{Z_1 : CategoryTheory.Functor (CategoryTheory.ComposableArrows ι 1) C} (h : Z.H n ⟶ Z_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.comp f g).hom n) h =
CategoryTheory.CategoryStruct.comp (f.hom n) (CategoryTheory.CategoryStruct.comp (g.hom n) h) |
_private.Mathlib.MeasureTheory.Measure.Tight.0.MeasureTheory.isTightMeasureSet_of_isCompact_closure._proof_1_5 | Mathlib.MeasureTheory.Measure.Tight | (1 + 1).AtLeastTwo |
LinearMap.mapMatrixModule_comp | Mathlib.LinearAlgebra.Matrix.Module | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : Ring R] [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] [inst_7 : AddCommGroup P] [inst_8 : Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P),
LinearMap.mapMatrixModule ι (g ∘ₗ f) = LinearMap.mapMatrixModule ι g ∘ₗ LinearMap.mapMatrixModule ι f |
MonCat.Colimits.descFunLift._unsafe_rec | Mathlib.Algebra.Category.MonCat.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{u, v} J] →
(F : CategoryTheory.Functor J MonCat) → (s : CategoryTheory.Limits.Cocone F) → MonCat.Colimits.Prequotient F → ↑s.pt |
CommBialgCat.casesOn | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} →
[inst : CommRing R] →
{motive : CommBialgCat R → Sort u_1} →
(t : CommBialgCat R) →
((carrier : Type v) →
[commRing : CommRing carrier] →
[bialgebra : Bialgebra R carrier] →
motive { carrier := carrier, commRing := commRing, bialgebra := bialgebra }) →
motive t |
Holor.CPRankMax1 | Mathlib.Data.Holor | {α : Type} → [Mul α] → {ds : List ℕ} → Holor α ds → Prop |
MeasureTheory.IsFundamentalDomain.projection_respects_measure | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α]
{ν : MeasureTheory.Measure α} (μ : MeasureTheory.Measure (Quotient (MulAction.orbitRel G α)))
[i : MeasureTheory.QuotientMeasureEqMeasurePreimage ν μ] {t : Set α},
MeasureTheory.IsFundamentalDomain G t ν →
μ = MeasureTheory.Measure.map (Quotient.mk (MulAction.orbitRel G α)) (ν.restrict t) |
LieIdeal.map_comap_eq | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {J : LieIdeal R L'},
f.IsIdealMorphism → LieIdeal.map f (LieIdeal.comap f J) = f.idealRange ⊓ J |
CategoryTheory.WithTerminal._sizeOf_1 | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} → [SizeOf C] → CategoryTheory.WithTerminal C → ℕ |
Batteries.HashMap.findD | Batteries.Data.HashMap.Basic | {α : Type u_1} → {x : BEq α} → {x_1 : Hashable α} → {β : Type u_2} → Batteries.HashMap α β → α → β → β |
PrespectralSpace.opensEquiv._proof_2 | Mathlib.Topology.Spectral.Prespectral | ∀ {X : Type u_1} [inst : TopologicalSpace X] (U : TopologicalSpace.Opens X) (U₁ U₂ : TopologicalSpace.CompactOpens X),
U₂ ≤ U₁ → U₁ ∈ {V | ↑V ⊆ ↑U} → ↑U₂ ⊆ ↑U |
TopologicalSpace.IsCompletelyMetrizableSpace.toIsCompletelyPseudoMetrizableSpace | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_1} [inst : TopologicalSpace X] [TopologicalSpace.IsCompletelyMetrizableSpace X],
TopologicalSpace.IsCompletelyPseudoMetrizableSpace X |
Std.Iterators.Types.Flatten.IsPlausibleStep.innerSkip_flatMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α β α₂ γ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m]
[inst_3 : Std.Iterator α m β] [inst_4 : Std.Iterator α₂ m γ] {f : β → m (Std.IterM m γ)} {it₁ : Std.IterM m β}
{it₂ it₂' : Std.IterM m γ},
it₂.IsPlausibleStep (Std.IterStep.skip it₂') →
(Std.IterM.flatMapAfterM f it₁ (some it₂)).IsPlausibleStep
(Std.IterStep.skip (Std.IterM.flatMapAfterM f it₁ (some it₂'))) |
_private.Mathlib.Data.Set.Function.0.Set.InjOn.imageFactorization_injective.match_1_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} (x : α) (hx : x ∈ s)
(motive : (x_1 : ↑s) → Set.imageFactorization f s ⟨x, hx⟩ = Set.imageFactorization f s x_1 → Prop) (x_1 : ↑s)
(h' : Set.imageFactorization f s ⟨x, hx⟩ = Set.imageFactorization f s x_1),
(∀ (y : α) (hy : y ∈ s) (h' : Set.imageFactorization f s ⟨x, hx⟩ = Set.imageFactorization f s ⟨y, hy⟩),
motive ⟨y, hy⟩ h') →
motive x_1 h' |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.isBlock_iff_disjoint_smul_of_ne._simp_1_2 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_3} {α : Type u_5} [inst : Group G] [inst_1 : MulAction G α] {g : G} {a b : α}, (a = g • b) = (g⁻¹ • a = b) |
ModularFormClass.exp_decay_sub_atImInfty' | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {k : ℤ} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {Γ : Subgroup (GL (Fin 2) ℝ)} (f : F)
[ModularFormClass F Γ k] [Γ.HasDetPlusMinusOne] [DiscreteTopology ↥Γ] [Fact (IsCusp OnePoint.infty Γ)],
∃ c > 0, (fun τ => f τ - UpperHalfPlane.valueAtInfty ⇑f) =O[UpperHalfPlane.atImInfty] fun τ => Real.exp (-c * τ.im) |
Std.DTreeMap.Internal.Impl.BalancedAtRoot.eq_1 | Std.Data.DTreeMap.Internal.Balanced | ∀ (left right : ℕ),
Std.DTreeMap.Internal.Impl.BalancedAtRoot left right =
(left + right ≤ 1 ∨ left ≤ Std.DTreeMap.Internal.delta * right ∧ right ≤ Std.DTreeMap.Internal.delta * left) |
fderivWithin_mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {𝔸' : Type u_6} [inst_3 : NormedCommRing 𝔸']
[inst_4 : NormedAlgebra 𝕜 𝔸'] {c d : E → 𝔸'},
UniqueDiffWithinAt 𝕜 s x →
DifferentiableWithinAt 𝕜 c s x →
DifferentiableWithinAt 𝕜 d s x →
fderivWithin 𝕜 (c * d) s x = c x • fderivWithin 𝕜 d s x + d x • fderivWithin 𝕜 c s x |
lt_norm_sub_of_not_sameRay | Mathlib.Analysis.Convex.StrictConvexSpace | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [StrictConvexSpace ℝ E] {x y : E},
¬SameRay ℝ x y → ‖x‖ - ‖y‖ < ‖x - y‖ |
AddValuation.map_le_sub | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{x y : R} {g : Γ₀}, g ≤ v x → g ≤ v y → g ≤ v (x - y) |
CategoryTheory.Limits.preservesFiniteLimits_of_preservesEqualizers_and_finiteProducts | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.Limits.HasEqualizers C] [CategoryTheory.Limits.HasFiniteProducts C] (G : CategoryTheory.Functor C D)
[CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingParallelPair G]
[CategoryTheory.Limits.PreservesFiniteProducts G], CategoryTheory.Limits.PreservesFiniteLimits G |
FormalMultilinearSeries.leftInv.eq_def | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) (x : E) (x_1 : ℕ),
p.leftInv i x x_1 =
match x_1 with
| 0 => ContinuousMultilinearMap.uncurry0 𝕜 F x
| 1 => (continuousMultilinearCurryFin1 𝕜 F E).symm ↑i.symm
| n.succ.succ =>
-∑ c,
ContinuousMultilinearMap.compAlongComposition (p.compContinuousLinearMap ↑i.symm) (↑c)
(p.leftInv i x (↑c).length) |
CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_inv_naturality_assoc | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (n : ℤ)
{X Y : Cᵒᵖ} (f : X ⟶ Y) {Z : Cᵒᵖ} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctor Cᵒᵖ n).map f).unop).op
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app Y) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app X) f)
h |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_11 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False |
Lean.Server.Ilean.version | Lean.Server.References | Lean.Server.Ilean → ℕ |
Nat.mul_sub_left_distrib | Init.Data.Nat.Basic | ∀ (n m k : ℕ), n * (m - k) = n * m - n * k |
Action.ofMulActionLimitCone._proof_3 | Mathlib.CategoryTheory.Action.Concrete | ∀ {ι : Type u_2} (G : Type (max u_2 u_1)) [inst : Monoid G] (F : ι → Type (max u_2 u_1))
[inst_1 : (i : ι) → MulAction G (F i)] (i : CategoryTheory.Discrete ι) (x : G),
(CategoryTheory.CategoryStruct.comp
((((CategoryTheory.Functor.const (CategoryTheory.Discrete ι)).obj (Action.ofMulAction G ((i : ι) → F i))).obj i).ρ
x)
fun x => x i.as) =
CategoryTheory.CategoryStruct.comp
((((CategoryTheory.Functor.const (CategoryTheory.Discrete ι)).obj (Action.ofMulAction G ((i : ι) → F i))).obj i).ρ
x)
fun x => x i.as |
_private.Batteries.Data.Char.Basic.0.Char.toNat_not_surrogate._proof_1_3 | Batteries.Data.Char.Basic | ∀ (c : Char), c.toNat < 55296 → ¬(55296 ≤ c.toNat ∧ c.toNat ≤ 57343) |
Int.reduceGE._regBuiltin.Int.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.1458257035._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit |
AddGroup.addRight_bijective | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddGroup G] (a : G), Function.Bijective fun x => x + a |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabTermAux | Lean.Elab.Term.TermElabM | Option Lean.Expr → Bool → Bool → Lean.Syntax → Lean.Elab.TermElabM Lean.Expr |
UInt32.toBitVec_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt32), (a ^^^ b).toBitVec = a.toBitVec ^^^ b.toBitVec |
CategoryTheory.Bicategory.Adjunction | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u} → [inst : CategoryTheory.Bicategory B] → {a b : B} → (a ⟶ b) → (b ⟶ a) → Type w |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvType._sparseCasesOn_4 | Lean.Compiler.LCNF.AlphaEqv | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t |
MeasureTheory.aecover_Ioc_of_Icc | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [OrderClosedTopology α] [OpensMeasurableSpace α] {a b : ι → α}
{A B : α} [MeasureTheory.NoAtoms μ],
Filter.Tendsto a l (nhds A) →
Filter.Tendsto b l (nhds B) → MeasureTheory.AECover (μ.restrict (Set.Ioc A B)) l fun i => Set.Icc (a i) (b i) |
WithBot.decidableLT.eq_3 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] [inst_1 : DecidableLT α] (a b : α),
WithBot.decidableLT (some a) (some b) = decidable_of_iff' (a < b) ⋯ |
CategoryTheory.Limits.IsZero.iso | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → CategoryTheory.Limits.IsZero X → CategoryTheory.Limits.IsZero Y → (X ≅ Y) |
MeasureTheory.unifTight_iff_real | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : NormedAddCommGroup β] {x : MeasurableSpace α} (f : ι → α → β)
(p : ENNReal) (μ : MeasureTheory.Measure α),
MeasureTheory.UnifTight f p μ ↔
∀ ⦃ε : ℝ⦄, 0 < ε → ∃ s, μ s ≠ ⊤ ∧ ∀ (i : ι), MeasureTheory.eLpNorm (sᶜ.indicator (f i)) p μ ≤ ENNReal.ofReal ε |
Module.End.eq_zero_of_isNilpotent_isSemisimple | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{f : Module.End R M}, IsNilpotent f → f.IsSemisimple → f = 0 |
CategoryTheory.InitialModel | Mathlib.CategoryTheory.Limits.FinallySmall | (J : Type u) → [inst : CategoryTheory.Category.{v, u} J] → [CategoryTheory.InitiallySmall J] → Type w |
_private.Lean.Meta.Tactic.FunIndCollect.0.Lean.Meta.FunInd.Collector.visit._sparseCasesOn_4 | Lean.Meta.Tactic.FunIndCollect | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((typeName : Lean.Name) →
(idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
(Nat.hasNotBit 3568 t.ctorIdx → motive t) → motive t |
Stream'.Seq.take.eq_def | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (x : ℕ) (x_1 : Stream'.Seq α),
Stream'.Seq.take x x_1 =
match x, x_1 with
| 0, x => []
| n.succ, s =>
match s.destruct with
| none => []
| some (x, r) => x :: Stream'.Seq.take n r |
BoundedContinuousFunction.instIntCast | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{β : Type u_2} → [inst_1 : PseudoMetricSpace β] → [IntCast β] → IntCast (BoundedContinuousFunction α β) |
WellFounded.isAsymm | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {r : α → α → Prop}, WellFounded r → Std.Asymm r |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_of_not_smulOverflow._proof_1_6 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
x.toInt * y.toInt < 2 ^ w ∧ -2 ^ w ≤ x.toInt * y.toInt → ¬-(2 ^ (w + 1) / 2) ≤ x.toInt * y.toInt → False |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence.0.groupCohomology.map_cochainsFunctor_shortExact._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
S.Exact = ((ModuleCat.Hom.hom S.f).range = (ModuleCat.Hom.hom S.g).ker) |
Std.Internal.List.getValueD_insertListConst_of_mem | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)} {k k' : α}
{v fallback : β},
Std.Internal.List.DistinctKeys l →
(k == k') = true →
List.Pairwise (fun a b => (a.1 == b.1) = false) toInsert →
(k, v) ∈ toInsert → Std.Internal.List.getValueD k' (Std.Internal.List.insertListConst l toInsert) fallback = v |
CategoryTheory.SimplicialObject.Augmented.rightOp_left | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C),
X.rightOp.left = Opposite.op X.right |
FreeSimplexQuiver.homRel.rec | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {motive : ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ → (a a_1 : X ⟶ Y) → FreeSimplexQuiver.homRel a a_1 → Prop},
(∀ {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ j.castSucc),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : j.castSucc < i),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.castSucc)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i)))
⋯) →
(∀ {n : ℕ} {i j : Fin (n + 1)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
⋯) →
∀ ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ {a a_1 : X ⟶ Y} (t : FreeSimplexQuiver.homRel a a_1),
motive a a_1 t |
IsStarProjection.add | Mathlib.Algebra.Star.StarProjection | ∀ {R : Type u_1} {p q : R} [inst : NonUnitalNonAssocSemiring R] [inst_1 : StarRing R],
IsStarProjection p → IsStarProjection q → p * q = 0 → IsStarProjection (p + q) |
NonUnitalAlgHom.equalizer._proof_3 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {F : Type u_3} {R : Type u_4} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R]
[inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B]
[inst_4 : Module R B] [inst_5 : FunLike F A B] [NonUnitalAlgHomClass F R A B] (ϕ ψ : F) {x y : A},
ϕ x = ψ x → ϕ y = ψ y → x * y ∈ {a | ϕ a = ψ a} |
Lean.PrettyPrinter.Formatter.checkTailWs.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter |
_private.Mathlib.Analysis.InnerProductSpace.LinearMap.0._aux_Mathlib_Analysis_InnerProductSpace_LinearMap___unexpand_Inner_inner_2 | Mathlib.Analysis.InnerProductSpace.LinearMap | Lean.PrettyPrinter.Unexpander |
_private.Mathlib.Data.Seq.Defs.0.Stream'.Seq.«_aux_Mathlib_Data_Seq_Defs___macroRules__private_Mathlib_Data_Seq_Defs_0_Stream'_Seq_term_~__1» | Mathlib.Data.Seq.Defs | Lean.Macro |
MeasureTheory.lintegral_add_left | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
Measurable f → ∀ (g : α → ENNReal), ∫⁻ (a : α), f a + g a ∂μ = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ |
CategoryTheory.Enriched.HasConicalProducts.hasConicalLimitsOfShape | Mathlib.CategoryTheory.Enriched.Limits.HasConicalProducts | ∀ {V : outParam (Type u')} {inst : CategoryTheory.Category.{v', u'} V} {inst_1 : CategoryTheory.MonoidalCategory V}
{C : Type u} {inst_2 : CategoryTheory.Category.{v, u} C} {inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C}
[self : CategoryTheory.Enriched.HasConicalProducts V C] (J : Type w),
CategoryTheory.Enriched.HasConicalLimitsOfShape (CategoryTheory.Discrete J) V C |
MulActionHom.fst | Mathlib.GroupTheory.GroupAction.Hom | (M : Type u_1) → (α : Type u_2) → (β : Type u_3) → [inst : SMul M α] → [inst_1 : SMul M β] → α × β →ₑ[id] α |
Lean.Elab.Term.LValResolution.noConfusion | Lean.Elab.App | {P : Sort u} → {t t' : Lean.Elab.Term.LValResolution} → t = t' → Lean.Elab.Term.LValResolution.noConfusionType P t t' |
Lean.Grind.CommRing.Poly.powC_nc._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → ℕ → Lean.Grind.CommRing.Poly |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.