name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Time.PlainDateTime.withMilliseconds | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Millisecond.Ordinal → Std.Time.PlainDateTime | Creates a new `PlainDateTime` by adjusting the milliseconds component inside the `nano` component of its `time` to the given value.
| true |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_mul_nontrivial._simp_1_3 | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
CategoryTheory.Limits.limitIsoSwapCompLim_inv_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
(G : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (X : K),
(CategoryTheor... | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.ideal_sSup | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} {I : Set X.IdealSheafData},
(sSup I).ideal = sSup (AlgebraicGeometry.Scheme.IdealSheafData.ideal '' I) | null | true |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_62 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (k : Turing.PartrecToTM2.Cont') (k_1 : Turing.PartrecToTM2.K')
(s : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ') (q : Turing.PartrecToTM2.Λ'),
¬Turing.PartrecToTM2.Λ'.ret k = Turing.PartrecToTM2.Λ'.push k_1 s q | null | false |
Std.Internal.List.getValueD | Std.Data.Internal.List.Associative | {α : Type u} → {β : Type v} → [BEq α] → α → List ((_ : α) × β) → β → β | Internal implementation detail of the hash map | true |
Finset.toDual_sup' | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_5} [inst : SemilatticeSup α] {s : Finset ι} (hs : s.Nonempty) (f : ι → α),
OrderDual.toDual (s.sup' hs f) = s.inf' hs (⇑OrderDual.toDual ∘ f) | null | true |
_private.Mathlib.Algebra.QuadraticDiscriminant.0.quadratic_eq_zero_iff._simp_1_2 | Mathlib.Algebra.QuadraticDiscriminant | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
StandardEtalePresentation.toPresentation._proof_1 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : StandardEtalePresentation R S),
Ideal.span
(Set.range
![(Polynomial.Bivariate.equivMvPolynomial R) (Polynomial.C P.f),
(Polynomial.Bivariate.equivMvPolynomial R) (Polynomial.X * Polynomial.C... | null | false |
eventuallyEq_nhdsWithin_of_eqOn | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f g : α → β} {s : Set α} {a : α},
Set.EqOn f g s → f =ᶠ[nhdsWithin a s] g | null | true |
Perfection.instCommMonoid._aux_3 | Mathlib.RingTheory.Perfection | (M : Type u_1) → [inst : CommMonoid M] → (p : ℕ) → Perfection M p → Perfection M p → Perfection M p | null | false |
TopCat.sigmaCofanIsColimit._proof_3 | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ {ι : Type u_2} (β : ι → TopCat) (s : CategoryTheory.Limits.Cocone (CategoryTheory.Discrete.functor β))
(j : CategoryTheory.Discrete ι),
CategoryTheory.CategoryStruct.comp ((TopCat.sigmaCofan β).ι.app j)
(TopCat.ofHom
{ toFun := fun s_1 => (CategoryTheory.ConcreteCategory.hom (s.ι.app { as := s_1.fst... | null | false |
Equiv.Perm.OnCycleFactors.toPermHom | Mathlib.GroupTheory.Perm.Centralizer | {α : Type u_1} →
[inst : DecidableEq α] →
[inst_1 : Fintype α] → (g : Equiv.Perm α) → ↥(Subgroup.centralizer {g}) →* Equiv.Perm ↥g.cycleFactorsFinset | The canonical morphism from `Subgroup.centralizer {g}`
to the group of permutations of `g.cycleFactorsFinset` | true |
Matrix.kroneckerMapBilinear._proof_5 | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {R : Type u_9} {S : Type u_8} {α : Type u_3} {β : Type u_6} {γ : Type u_7} {l : Type u_1} {m : Type u_2}
{n : Type u_4} {p : Type u_5} [inst : Semiring S] [inst_1 : Semiring R] [inst_2 : AddCommMonoid α]
[inst_3 : AddCommMonoid β] [inst_4 : AddCommMonoid γ] [inst_5 : Module R α] [inst_6 : Module R γ]
[inst_7 : ... | null | false |
_private.Mathlib.Analysis.InnerProductSpace.OfNorm.0.inner_ | Mathlib.Analysis.InnerProductSpace.OfNorm | (𝕜 : Type u_1) → [inst : RCLike 𝕜] → {E : Type u_2} → [inst_1 : NormedAddCommGroup E] → [NormedSpace 𝕜 E] → E → E → 𝕜 | Auxiliary definition of the inner product derived from the norm. | true |
Subgroup.quotientEquivProdOfLE' | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} →
[inst : Group α] →
{s t : Subgroup α} →
s ≤ t → (f : α ⧸ t → α) → Function.RightInverse f QuotientGroup.mk → α ⧸ s ≃ (α ⧸ t) × ↥t ⧸ s.subgroupOf t | If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
of the quotient map `G → G/K`. The classical version is `Subgroup.quotientEquivProdOfLE`. | true |
_private.Mathlib.Data.List.MinMax.0.List.argmax_cons._proof_1_1 | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder β] (f : α → β) (a tl m : α),
f a < f m →
f m < f tl →
Option.rec (some tl) (fun val => if f val < f tl then some tl else some val) (some m) =
Option.rec (some a) (fun val => if f a < f val then some val else some a) (some tl) | null | false |
Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.extended.sizeOf_spec | Std.Tactic.BVDecide.LRAT.Internal.Rup | ∀ (assign : Std.Tactic.BVDecide.LRAT.Internal.Assignment),
sizeOf (Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.extended assign) = 1 + sizeOf assign | null | true |
_private.Init.Data.List.MinMax.0.List.max?_attach | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Max α] [inst_1 : Std.MaxEqOr α] {xs : List α},
xs.attach.max? = Option.pmap (fun m hm => ⟨m, ⋯⟩) xs.max? ⋯ | null | true |
IsAddUnit.add_val_neg | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {a : M} (h : IsAddUnit a), a + ↑(-h.addUnit) = 0 | null | true |
Vector.reverse_attach | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n},
xs.attach.reverse =
Vector.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨x, ⋯⟩)
xs.reverse.attach | null | true |
Std.Format.FlattenAllowability | Init.Data.Format.Basic | Type | A directive indicating whether a given work group is able to be flattened.
- `allow` indicates that the group is allowed to be flattened; its argument is `true` if
there is sufficient space for it to be flattened (and so it should be), or `false` if not.
- `disallow` means that this group should not be flattened irr... | true |
_private.Mathlib.Topology.Spectral.Prespectral.0.instTotallySeparatedSpaceOfT2SpaceOfPrespectralSpace.match_1 | Mathlib.Topology.Spectral.Prespectral | ∀ {X : Type u_1} [inst : TopologicalSpace X] (x x_1 : X)
(motive : (∃ v ∈ {U | IsOpen U ∧ IsCompact U}, x ∈ v ∧ v ⊆ {x_1}ᶜ) → Prop)
(x_2 : ∃ v ∈ {U | IsOpen U ∧ IsCompact U}, x ∈ v ∧ v ⊆ {x_1}ᶜ),
(∀ (U : Set X) (hU₁ : IsOpen U) (hU₂ : IsCompact U) (hxU : x ∈ U) (hyU : U ⊆ {x_1}ᶜ), motive ⋯) → motive x_2 | null | false |
Finset.piecewise_mem_Icc_of_mem_of_mem | Mathlib.Data.Finset.Piecewise | ∀ {ι : Type u_1} (s : Finset ι) [inst : (j : ι) → Decidable (j ∈ s)] {π : ι → Type u_3} {f g f' g' : (i : ι) → π i}
[inst_1 : (i : ι) → Preorder (π i)], f ∈ Set.Icc f' g' → g ∈ Set.Icc f' g' → s.piecewise f g ∈ Set.Icc f' g' | null | true |
MeasureTheory.addFundamentalFrontier.eq_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] (s : Set α),
MeasureTheory.addFundamentalFrontier G s = s ∩ ⋃ g, ⋃ (_ : g ≠ 0), g +ᵥ s | null | true |
Lean.hasAssignedLevelMVar._unsafe_rec | Lean.MetavarContext | {m : Type → Type} → [Monad m] → [Lean.MonadMCtx m] → Lean.Level → m Bool | null | false |
Nat.prod_modEq_ite | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℕ} {f : α → ℕ} [inst : DecidableEq α] {s : Finset α} {a : α},
(∀ x ∈ s, x ≠ a → f x ≡ 1 [MOD n]) → ∏ x ∈ s, f x ≡ if a ∈ s then f a else 1 [MOD n] | null | true |
DirichletCharacter.absicssaOfAbsConv_eq_one | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ}, N ≠ 0 → ∀ (χ : DirichletCharacter ℂ N), (LSeries.abscissaOfAbsConv fun n => χ ↑n) = 1 | **Alias** of `DirichletCharacter.abscissaOfAbsConv_eq_one`.
---
The abscissa of absolute convergence of the L-series of a Dirichlet character mod `N > 0`
is `1`. | true |
SummationFilter.casesOn | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | {β : Type u_4} →
{motive : SummationFilter β → Sort u} →
(t : SummationFilter β) → ((filter : Filter (Finset β)) → motive { filter := filter }) → motive t | null | false |
Lean.Lsp.WorkDoneProgressReport.mk.noConfusion | Lean.Data.Lsp.Basic | {P : Sort u} →
{kind : String} →
{message? : Option String} →
{cancellable : Bool} →
{percentage? : Option ℕ} →
{kind' : String} →
{message?' : Option String} →
{cancellable' : Bool} →
{percentage?' : Option ℕ} →
{ kind := kind, m... | null | false |
AlgEquiv.coe_restrictScalars_symm | Mathlib.Algebra.Algebra.Tower | ∀ (R : Type u) {S : Type v} {A : Type w} {B : Type u₁} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Semiring B] [inst_4 : Algebra R S] [inst_5 : Algebra S A] [inst_6 : Algebra S B]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R S A] [inst_10 : IsScalarTo... | null | true |
_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiffTag.noConfusionType | Lean.Widget.Diff | Sort v✝ → Lean.Widget.ExprDiffTag✝ → Lean.Widget.ExprDiffTag✝ → Sort v✝ | null | true |
Std.IterM.any_map | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[inst_3 : Std.IteratorLoop α m m] [LawfulMonad m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β} {f : β → β'}
{p : β' → Bool}, Std.IterM.any p (Std.IterM.map f it) = Std.IterM.any (fun x => p (f... | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Model.0.Lean.Meta.Grind.Arith.Linear.assignTerms.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.Model | (motive : Lean.Expr × ℕ → Sort u_1) →
(x : Lean.Expr × ℕ) → ((e : Lean.Expr) → (structId' : ℕ) → motive (e, structId')) → motive x | null | false |
Int32.sub | Init.Data.SInt.Basic | Int32 → Int32 → Int32 | Subtracts one 32-bit signed integer from another, wrapping around on over- or underflow. Usually
accessed via the `-` operator.
This function is overridden at runtime with an efficient implementation.
| true |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.support_noncommProd._simp_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} (x : α) (s : Set α), (s ⊆ insert x s) = True | null | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.Metric.0.UpperHalfPlane.dist_log_im_le._simp_1_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | ∀ {E : Type u_4} [inst : SeminormedAddCommGroup E] (a b : E), ‖a - b‖ = dist a b | null | false |
CategoryTheory.MorphismProperty.isSmall_iSup | Mathlib.CategoryTheory.MorphismProperty.IsSmall | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type u_1} (W : α → CategoryTheory.MorphismProperty C)
[Small.{w, u_1} α] [∀ (a : α), CategoryTheory.MorphismProperty.IsSmall.{w, v, u} (W a)],
CategoryTheory.MorphismProperty.IsSmall.{w, v, u} (iSup W) | null | true |
CondensedSet.toTopCatMap | Mathlib.Condensed.TopCatAdjunction | {X Y : CondensedSet} → (X ⟶ Y) → (X.toTopCat ⟶ Y.toTopCat) | The map part of the functor `CondensedSet ⥤ TopCat` | true |
Std.DHashMap.Raw.Equiv.getKeyD_eq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {k fallback : α}, m₁.WF → m₂.WF → m₁.Equiv m₂ → m₁.getKeyD k fallback = m₂.getKeyD k fallback | null | true |
AddOpposite.instAddCommGroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [AddCommGroup α] → AddCommGroup αᵃᵒᵖ | null | true |
Path.Homotopy.map._proof_4 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x₀ x₁ : X} {p q : Path x₀ x₁}
(F : p.Homotopy q) (f : C(X, Y)) (t x : ↑unitInterval),
x ∈ {0, 1} → { toFun := fun x => (⇑f ∘ ⇑F) (t, x), continuous_toFun := ⋯ } x = (p.map ⋯).toContinuousMap x | null | false |
Affine.Simplex.ExcenterExists.excenter_mem_affineSpan_range | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] {s : Affine.Simplex ℝ P n} {signs : Finset (Fin (n + 1))},
s.ExcenterExists signs → s.excenter signs ∈ affineSpan ℝ (Set.range s.points) | null | true |
_private.Lean.Level.0.Lean.Level.substParams.go._sparseCasesOn_3 | Lean.Level | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
motive Lean.Level.zero →
((a : Lean.Level) → motive a.succ) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) →
((a : Lean.Name) → motive (Lean.Level.param a)) → (Nat.hasNotBit 31 t.c... | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt64.le_refl._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a ≤ b) = (a.toBitVec ≤ b.toBitVec) | null | false |
CategoryTheory.Triangulated.TStructure.le_isClosedUnderIsomorphisms | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(self : Catego... | null | true |
Lean.IR.VarId.ctorIdx | Lean.Compiler.IR.Basic | Lean.IR.VarId → ℕ | null | false |
Nat.shiftRight_one | Mathlib.Data.Nat.BinaryRec | ∀ (n : ℕ), n >>> 1 = n / 2 | null | true |
BialgHom.toAlgHom_convMul | Mathlib.RingTheory.Bialgebra.Convolution | ∀ {R : Type u_1} {A : Type u_2} {C : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Semiring C]
[inst_3 : Bialgebra R A] [inst_4 : Bialgebra R C] [inst_5 : Coalgebra.IsCocomm R C] (f g : WithConv (C →ₐc[R] A)),
WithConv.toConv ↑(f * g).ofConv = WithConv.toConv ↑f.ofConv * WithConv.toConv ↑g.o... | null | true |
ULift.mulAction' | Mathlib.Algebra.Module.ULift | {R : Type u} → {M : Type v} → [inst : Monoid R] → [MulAction R M] → MulAction R (ULift.{u_1, v} M) | null | true |
_private.Init.Data.Vector.Basic.0.Vector.flatMapM.go._proof_3 | Init.Data.Vector.Basic | ∀ {n k : ℕ}, ∀ i ≤ n, ¬i < n → i * k = n * k | null | false |
_private.Mathlib.NumberTheory.Divisors.0.Nat.reverse_divisorsAntidiagonalList._simp_1_1 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.reverse.Perm l₂ = l₁.Perm l₂ | null | false |
HomotopicalAlgebra.trivialFibrations | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[HomotopicalAlgebra.CategoryWithFibrations C] →
[HomotopicalAlgebra.CategoryWithWeakEquivalences C] → CategoryTheory.MorphismProperty C | A trivial fibration is a morphism that is both a fibration and a weak equivalence. | true |
HomologicalComplex.cylinder.mapHomologicalComplexObjIso._proof_2 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_1}
{c : ComplexShape ι} (F : HomologicalComplex C c) {D : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} D]
[inst_3 : CategoryTheory.Preadditive D] (H : CategoryTheory.Functor C D) [inst_4 : H.... | null | false |
CategoryTheory.preadditiveYoneda_obj | Mathlib.CategoryTheory.Preadditive.Yoneda.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (Y : C),
CategoryTheory.preadditiveYoneda.obj Y =
(CategoryTheory.preadditiveYonedaObj Y).comp
(CategoryTheory.forget₂ (ModuleCat (CategoryTheory.End Y)) AddCommGrpCat) | null | true |
AddConjClasses.mk.eq_1 | Mathlib.Algebra.Group.Conj | ∀ {α : Type u_1} [inst : AddMonoid α] (a : α), AddConjClasses.mk a = ⟦a⟧ | null | true |
FreeAbelianGroup.seqAddGroupHom._simp_1 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {ι : Type u_1} {M : ι → Type u_5} [inst : (i : ι) → Add (M i)] (f g : (i : ι) → M i), (fun i => f i + g i) = f + g | null | false |
uniformity_eq_comap_nhds_zero_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (Gᵣ : Type u_3) [inst : UniformSpace Gᵣ] [inst_1 : AddGroup Gᵣ] [IsRightUniformAddGroup Gᵣ],
uniformity Gᵣ = Filter.comap (fun x => x.1 - x.2) (nhds 0) | null | true |
LinearOrderedCommGroupWithZero.mul_inv_cancel | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_3} [self : LinearOrderedCommGroupWithZero α] (a : α), a ≠ 0 → a * a⁻¹ = 1 | Every nonzero element of a group with zero is invertible. | true |
Mathlib.Tactic.BicategoryLike.MkEvalWhiskerRight.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkEvalWhiskerRight m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkEvalWhiskerRight m) →
((mkEvalWhiskerRightAuxOf :
Mathlib.Tactic.BicategoryLike.WhiskerRight → Mathlib.Tactic.BicategoryLike.Atom₁ → m Lean.Expr) →
(mkEvalW... | null | false |
Std.DHashMap.Raw.forM_eq_forM | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} {m' : Type w → Type w'} [inst : Monad m'] [LawfulMonad m']
{f : (a : α) → β a → m' PUnit.{w + 1}}, Std.DHashMap.Raw.forM f m = forM m fun a => f a.fst a.snd | null | true |
CategoryTheory.Artinian.mk._flat_ctor | Mathlib.CategoryTheory.Noetherian | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C],
(∃ S x, Nonempty (C ≌ S)) → (∀ (X : C), CategoryTheory.IsArtinianObject X) → CategoryTheory.Artinian C | null | false |
CategoryTheory.ShortComplex.RightHomologyData.unop._proof_4 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.RightHomologyData),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.CokernelCofork.IsColimit.ofπUnop h.p ⋯ h.hp).lift
(CategoryTheo... | null | false |
CategoryTheory.Functor.Initial.extendCone._proof_4 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {F : CategoryTheory.Functor C D} [inst_2 : F.Initial] {E : Type u_4}
[inst_3 : CategoryTheory.Category.{u_2, u_4} E] {G : CategoryTheory.Functor D E}
(X : CategoryTheory.Limits.Cone (F.com... | null | false |
CategoryTheory.Limits.CoconeMorphism.map_w_assoc | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{c c' : CategoryTheory.Limits.Cocone F} (f : c' ⟶ c) (G : CategoryTheory.Functor C D) (j : J) {Z : D}
... | null | true |
AddCircle.ergodic_nsmul | Mathlib.Dynamics.Ergodic.AddCircle | ∀ {T : ℝ} [hT : Fact (0 < T)] {n : ℕ}, 1 < n → Ergodic (fun y => n • y) MeasureTheory.volume | null | true |
String.Pos.next._proof_2 | Init.Data.String.Basic | ∀ {s : String} (pos : s.Pos), pos ≠ s.endPos → pos.toSlice ≠ s.toSlice.endPos | null | false |
WithLp.prod_norm_sq_eq_of_L2 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddCommGroup α] [inst_1 : SeminormedAddCommGroup β]
(x : WithLp 2 (α × β)), ‖x‖ ^ 2 = ‖x.fst‖ ^ 2 + ‖x.snd‖ ^ 2 | null | true |
FirstOrder.Language.LHom.comp_onBoundedFormula | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} {n : ℕ} {L'' : FirstOrder.Language} (φ : L' →ᴸ L'')
(ψ : L →ᴸ L'), (φ.comp ψ).onBoundedFormula = φ.onBoundedFormula ∘ ψ.onBoundedFormula | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix.delabMatrixNotation._sparseCasesOn_7 | Mathlib.LinearAlgebra.Matrix.Notation | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
SimpleGraph.Walk.isSubwalk_iff_darts_isInfix | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'},
¬p₁.Nil → (p₁.IsSubwalk p₂ ↔ p₁.darts <:+: p₂.darts) | null | true |
_private.Mathlib.Topology.DiscreteSubset.0.IsDiscrete.biUnion._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {α : Sort u_1} {p : α → Prop} {q : (x : α) → p x → Prop}, (∀ (x : α) (h : p x), q x h) = ∀ (x : { a // p a }), q ↑x ⋯ | null | false |
IntermediateField.map._proof_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_2} {L : Type u_3} {L' : Type u_1} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] (f : L →ₐ[K] L') (S : IntermediateField K L),
∀ x ∈ (Subalgebra.map f S.toSubalgebra).carrier, x⁻¹ ∈ (Subalgebra.map f S.toSubalgebra).carrier | null | false |
Lean.SMap.forM | Lean.Data.SMap | {α : Type u} →
{β : Type v} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{m : Type u_1 → Type u_2} → [Monad m] → Lean.SMap α β → (α → β → m PUnit.{u_1 + 1}) → m PUnit.{u_1 + 1} | null | true |
ISize.toInt_toBitVec | Init.Data.SInt.Lemmas | ∀ (x : ISize), x.toBitVec.toInt = x.toInt | null | true |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse._proof_2 | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_3) [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)),
CategoryTheory.CategoryStruct.comp (F.whiskerLeft CategoryTheory.ShortCo... | null | false |
HasFDerivWithinAt.of_comp_of_isEmbedding | Mathlib.Analysis.Calculus.FDeriv.OfCompLeft | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {g : E → F} {f : F → G} {h : E → G} {... | null | true |
Sum.Lex.noMinOrder | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [NoMinOrder α] [NoMinOrder β], NoMinOrder (α ⊕ₗ β) | null | true |
IsAddQuotientCoveringMap.unop_fundamentalGroupToMulOpposite_smul | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X} {G : Type u_4}
[inst_2 : AddGroup G] [inst_3 : AddAction G E] (hp : IsAddQuotientCoveringMap p G) {x : X} {e : ↑(p ⁻¹' {x})}
{γ : FundamentalGroup X x}, MulOpposite.unop ((hp.fundamentalGroupToMulOpposite e) γ) • ↑... | null | true |
CategoryTheory.Coverage.Saturate.top | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {K : CategoryTheory.Coverage C} (X : C), K.Saturate X ⊤ | null | true |
Std.ExtDTreeMap.maxKey!_erase_eq_of_not_compare_maxKey!_eq | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α}, t.erase k ≠ ∅ → ¬cmp k t.maxKey! = Ordering.eq → (t.erase k).maxKey! = t.maxKey! | null | true |
CauchyFilter.monotone_gen | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u} [inst : UniformSpace α], Monotone CauchyFilter.gen | null | true |
_private.Mathlib.Analysis.Hofer.0.hofer._simp_1_4 | Mathlib.Analysis.Hofer | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton._simp_1_20 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
RootPairing.Equiv.instSMulCommClassMulOppositeAut | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N),
SMulCommClass P.Autᵐᵒᵖ R N | null | true |
MvPolynomial.support_X | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} {n : σ} [inst : CommSemiring R] [Nontrivial R],
(MvPolynomial.X n).support = {fun₀ | n => 1} | null | true |
Class.coe_sUnion._simp_1 | Mathlib.SetTheory.ZFC.Class | ∀ (x : ZFSet.{u}), (↑x).sUnion = ↑x.sUnion | null | false |
_private.Mathlib.Order.Filter.Basic.0.Filter.mem_iInf_of_directed._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Affine.Simplex.excenterWeightsUnnorm | Mathlib.Geometry.Euclidean.Incenter.Basic | {V : Type u_1} →
{P : Type u_2} →
[inst : NormedAddCommGroup V] →
[inst_1 : InnerProductSpace ℝ V] →
[inst_2 : MetricSpace P] →
[inst_3 : NormedAddTorsor V P] →
{n : ℕ} → [NeZero n] → Affine.Simplex ℝ P n → Finset (Fin (n + 1)) → Fin (n + 1) → ℝ | The unnormalized weights of the vertices in an affine combination that gives an excenter with
signs determined by the given set of indices (for the empty set, this is the incenter; for a
singleton set, this is the excenter opposite a vertex). An excenter with those signs exists if
and only if the sum of these weights ... | true |
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.MvPolynomial.schwartz_zippel_totalDegree._simp_1_2 | Mathlib.Algebra.MvPolynomial.SchwartzZippel | ∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),
∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a | null | false |
Submodule.smithNormalFormOfLE._proof_5 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(N O : Submodule R M) (n o : ℕ),
(∃ (hno : n ≤ o), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.castLE hno i))) → n ≤ o | null | false |
Lean.Grind.imp_eq_of_eq_false_left | Init.Grind.Lemmas | ∀ {a b : Prop}, a = False → (a → b) = True | null | true |
instLEBitVec | Init.Prelude | {w : ℕ} → LE (BitVec w) | null | true |
Std.WP.WPMonad.wp_throw_Option_apply_eq | Std.WP.Monad.Lemmas | ∀ {α : Type u_1} {post : α → Prop} {epost : Unit → Prop} (e : PUnit.{1}),
Std.WP.wp (MonadExceptOf.throw e) post epost = epost () | null | true |
tangentMapWithin_eq_tangentMap | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
ImportGraph.Widget.RelativeRangeLocation.ctorElim | ImportGraph.Widget.GoToModule | {motive : ImportGraph.Widget.RelativeRangeLocation → Sort u} →
(ctorIdx : ℕ) →
(t : ImportGraph.Widget.RelativeRangeLocation) →
ctorIdx = t.ctorIdx → ImportGraph.Widget.RelativeRangeLocation.ctorElimType ctorIdx → motive t | null | false |
Std.DTreeMap.Internal.Impl.getKey?._f | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} → [Ord α] → α → (t : Std.DTreeMap.Internal.Impl α β) → Std.DTreeMap.Internal.Impl.below t → Option α | null | false |
CategoryTheory.GrothendieckTopology.pointBot_fiber | Mathlib.CategoryTheory.Sites.Point.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] (X : C),
(CategoryTheory.GrothendieckTopology.pointBot X).fiber =
CategoryTheory.shrinkYoneda.{w, v, u}.flip.obj (Opposite.op X) | null | true |
DirectLimit.NonUnitalStarRing.lift_apply | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonUnitalNonA... | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.red_iff_irreducible._simp_1_4 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (a : α) (l : List α), (a :: l = []) = False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.