name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Time.Month.Ordinal.june | Std.Time.Date.Unit.Month | Std.Time.Month.Ordinal | The ordinal value representing the month of June.
| true |
Std.Http.Headers.mk.injEq | Std.Http.Data.Headers | ∀ (map map_1 : Std.Internal.IndexMultiMap Std.Http.Header.Name Std.Http.Header.Value),
({ map := map } = { map := map_1 }) = (map = map_1) | null | true |
Std.HashMap.Raw.toList_keysArray | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α],
m.WF → m.keysArray.toList = m.keys | null | true |
BumpCovering.mk.sizeOf_spec | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {s : optParam (Set X) Set.univ} [inst_1 : SizeOf ι]
[inst_2 : SizeOf X] [inst_3 : (a : X) → SizeOf (s a)] (toFun : ι → C(X, ℝ))
(locallyFinite' : LocallyFinite fun i => Function.support ⇑(toFun i)) (nonneg' : 0 ≤ toFun) (le_one' : toFun ≤ 1)
(eventuallyE... | null | true |
SaturatedSubmonoid.mem_sInf | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : MulOneClass M] {f : Set (SaturatedSubmonoid M)} {x : M}, x ∈ sInf f ↔ ∀ s ∈ f, x ∈ s | null | true |
spectrum.zero_mem_iff | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
0 ∈ spectrum R a ↔ ¬IsUnit a | null | true |
Std.Slice.foldl | Init.Data.Slice.Operations | {α : Type v} →
{γ : Type u} →
{β : Type v} →
{δ : Type w} →
(δ → β → δ) →
δ →
[Std.ToIterator (Std.Slice γ) Id α β] →
[inst : Std.Iterator α Id β] → [Std.IteratorLoop α Id Id] → Std.Slice γ → δ | Folds an operation from left to right over the elements in a slice.
An accumulator of type `β` is constructed by starting with `init` and combining each
element of the slice with the current accumulator value in turn.
Examples for the special case of subarrays:
* `#["red", "green", "blue"].toSubarray.foldl (· + ·.leng... | true |
cfc_smul_id._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Std.Rci.forIn'_toArray_eq_forIn' | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rci α} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerableLE α] [inst_3 : Std.Rxi.IsAlwaysFinite α]
[inst_4 : Std.PRange.LawfulUpwardEnumerable α] {γ : Type u} {init : γ} {m : Type u → Type w} [inst_5 : Monad m]
[LawfulMonad m] {f : (a : α) → ... | null | true |
BddOrd.hom_inv_apply | Mathlib.Order.Category.BddOrd | ∀ {X Y : BddOrd} (e : X ≅ Y) (s : ↑Y.toPartOrd),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s | null | true |
AlgCat.limitSemiring._aux_13 | Mathlib.Algebra.Category.AlgCat.Limits | {R : Type u_4} →
[inst : CommRing R] →
{J : Type u_3} →
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J (AlgCat R)) →
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections] →
(CategoryTheory.Limits.Types.Small.l... | null | false |
ContinuousLinearMap.homeomorphOfUnit._proof_3 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_2} [inst : Semiring R₁] {M₁ : Type u_1} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] (T : (M₁ →L[R₁] M₁)ˣ), Continuous ⇑↑T | null | false |
AddCommGrpCat.Colimits.colimitCocone._proof_1 | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[inst_1 : DecidableEq J] [inst_2 : Small.{u_1, max u_1 u_3} (AddCommGrpCat.Colimits.Quot F)] (x x_1 : J)
(x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp (F.map x_2)
(AddCommGrpCat.ofHom (Shrink.ad... | null | false |
_private.Mathlib.Data.Finset.Union.0.Finset.disjiUnion_singleton_eq_self._proof_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} (s : Finset α), s.disjiUnion singleton ⋯ = s | null | false |
Lean.Data.AC.Expr.ctorElimType | Init.Data.AC | {motive : Lean.Data.AC.Expr → Sort u} → ℕ → Sort (max 1 u) | null | false |
USize.ofNatLT.congr_simp | Init.Data.UInt.Lemmas | ∀ (n n_1 : ℕ) (e_n : n = n_1) (h : n < USize.size), USize.ofNatLT n h = USize.ofNatLT n_1 ⋯ | null | true |
AddMonoid.Coprod.instNeg._proof_1 | Mathlib.GroupTheory.Coprod.Basic | ∀ {G : Type u_2} {H : Type u_1} [inst : AddGroup G] [inst_1 : AddGroup H] (x x_1 : FreeAddMonoid (G ⊕ H)),
(AddMonoid.coprodCon G H) x x_1 →
(AddMonoid.coprodCon G H)
(FreeAddMonoid.ofList (List.map (Sum.map Neg.neg Neg.neg) (FreeAddMonoid.toList x)).reverse)
(FreeAddMonoid.ofList (List.map (Sum.map N... | null | false |
instLawfulMonadLiftTOfLawfulMonadLift | Init.Control.Lawful.MonadLift.Instances | ∀ (m : Type u → Type v) (n : Type u → Type w) (o : Type u → Type x) [inst : Monad m] [inst_1 : Monad n]
[inst_2 : Monad o] [inst_3 : MonadLift n o] [inst_4 : MonadLiftT m n] [LawfulMonadLift n o] [LawfulMonadLiftT m n],
LawfulMonadLiftT m o | null | true |
continuousMultilinearCurryRightEquiv_apply | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ {𝕜 : Type u} {n : ℕ} {Ei : Fin n.succ → Type wEi} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : Fin n.succ) → NormedAddCommGroup (Ei i)] [inst_2 : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)]
[inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] (f : ContinuousMultilinearMap 𝕜 Ei G)
(v :... | null | true |
Hypergraph.adj_comm | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_1} {H : Hypergraph α} (x y : α), H.Adj x y ↔ H.Adj y x | null | true |
Std.Roo.recOn | Init.Data.Range.Polymorphic.PRange | {α : Type u} →
{motive : Std.Roo α → Sort u_1} → (t : Std.Roo α) → ((lower upper : α) → motive (lower<...upper)) → motive t | null | false |
ProbabilityTheory.IsGaussianProcess.indepFun_of_covariance_eq_zero | Mathlib.Probability.Distributions.Gaussian.IsGaussianProcess.Independence | ∀ {T : Type u_1} {Ω : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {S : Type u_4} {X : S → Ω → ℝ}
{Y : T → Ω → ℝ},
ProbabilityTheory.IsGaussianProcess (Sum.elim X Y) P →
(∀ (s : S), AEMeasurable (X s) P) →
(∀ (t : T), AEMeasurable (Y t) P) →
(∀ (s : S) (t : T), ProbabilityTheor... | Two Gaussian processes $(X_s)_{s \in S}$ and $(Y_t)_{t \in T}$ that are jointly Gaussian
are independent if for all $s \in S$ and $t \in T$, $X_s$ and $Y_t$ are uncorrelated. | true |
ExceptT.run_adapt | Init.Control.Lawful.Instances | ∀ {m : Type u_1 → Type u_2} {ε ε' α : Type u_1} [inst : Monad m] (f : ε → ε') (x : ExceptT ε m α),
(ExceptT.adapt f x).run = Except.mapError f <$> x.run | null | true |
Lean.JsonRpc.instInhabitedErrorCode.default | Lean.Data.JsonRpc | Lean.JsonRpc.ErrorCode | null | true |
SimpleGraph.mem_finsetWalkLength_iff | Mathlib.Combinatorics.SimpleGraph.Walk.Counting | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] [inst_1 : G.LocallyFinite] {n : ℕ} {u v : V} {p : G.Walk u v},
p ∈ G.finsetWalkLength n u v ↔ p.length = n | null | true |
_private.Mathlib.LinearAlgebra.FixedSubmodule.0.LinearEquiv.fixedReduce_eq_one._simp_1_1 | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} {e e' : M ≃ₛₗ[σ] M₂... | null | false |
HomologicalComplex.homologyπ_restrictionHomologyIso_hom_assoc | Mathlib.Algebra.Homology.Embedding.RestrictionHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j k : ι) (hi : c.prev j = i)
(hk : c.next j = k)... | null | true |
Lean.PrettyPrinter.Delaborator.ParamKind.noConfusion | Lean.PrettyPrinter.Delaborator.Builtins | {P : Sort u} →
{t t' : Lean.PrettyPrinter.Delaborator.ParamKind} →
t = t' → Lean.PrettyPrinter.Delaborator.ParamKind.noConfusionType P t t' | null | false |
_private.Mathlib.RingTheory.RegularLocalRing.Polynomial.0.Polynomial.isRegularLocalRing_localization_atPrime_of_comap_eq_maximalIdeal._simp_1_2 | Mathlib.RingTheory.RegularLocalRing.Polynomial | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
SetLike.vadd_of_tower_def | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {S : Type u'} {M : Type v} {N : Type u_1} {α : Type u_2} [inst : SetLike S α] [inst_1 : VAdd M N] [inst_2 : VAdd M α]
[inst_3 : AddMonoid N] [inst_4 : AddAction N α] [inst_5 : VAddMemClass S N α] [inst_6 : VAddAssocClass M N α] (s : S)
(r : M) (x : ↥s), r +ᵥ x = ⟨r +ᵥ ↑x, ⋯⟩ | null | true |
List.Perm.kunion_left._f | Mathlib.Data.List.Sigma | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (x : List (Sigma β))
(f :
List.below (motive := fun x =>
∀ (x_1 x_2 : List (Sigma β)), x_1.NodupKeys → x_1.Perm x_2 → (x.kunion x_1).Perm (x.kunion x_2)) x)
(x_1 x_2 : List (Sigma β)), x_1.NodupKeys → x_1.Perm x_2 → (x.kunion x_1).Perm (x.kunion x_2) | null | false |
AlgebraicGeometry.Scheme.localRingHom_comp_stalkIso_apply | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {R S : CommRingCat} (f : R ⟶ S) (p : PrimeSpectrum ↑S)
(x : ↑((AlgebraicGeometry.Spec R).presheaf.stalk (PrimeSpectrum.comap (CommRingCat.Hom.hom f) p))),
(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Spec.stalkIso S p).inv)
((Localization.localRingHom (Ideal.comap (CommRingCat.Hom.hom f) p.asIdea... | Variant of `AlgebraicGeometry.localRingHom_comp_stalkIso` for `Spec.map`. | true |
Set.piecewise_smul | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {α : ι → Type u_4} [inst : (i : ι) → SMul M (α i)] (s : Set ι)
[inst_1 : (i : ι) → Decidable (i ∈ s)] (c : M) (f₁ g₁ : (i : ι) → α i),
s.piecewise (c • f₁) (c • g₁) = c • s.piecewise f₁ g₁ | null | true |
Subalgebra.LinearDisjoint.linearIndependent_mul_of_flat_left | Mathlib.RingTheory.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {A B : Subalgebra R S},
A.LinearDisjoint B →
∀ [Module.Flat R ↥A] {κ : Type u_1} {ι : Type u_2} {a : κ → ↥A} {b : ι → ↥B},
LinearIndependent R a → LinearIndependent R b → LinearIndependent R fun i => ↑(a i.1) * ↑(b i.2) | If `A` and `B` are linearly disjoint, if `A` is flat, then for any family of
`R`-linearly independent elements `{ a_i }` of `A`, and any family of
`R`-linearly independent elements `{ b_j }` of `B`, the family `{ a_i * b_j }` in `S` is
also `R`-linearly independent. | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.Ctx.mk.inj | Lean.Compiler.LCNF.InferBorrow | ∀ {decls : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.impure)} {currDecl : Lean.Name}
{paramSet : Lean.FVarIdSet} {decls_1 : Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.impure)}
{currDecl_1 : Lean.Name} {paramSet_1 : Lean.FVarIdSet},
{ decls := decls, currDecl := currDecl, paramSet := p... | null | true |
Lean.instInhabitedFileMap | Lean.Data.Position | Inhabited Lean.FileMap | null | true |
Con.recOn | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} →
[inst : Mul M] →
{motive : Con M → Sort u} →
(t : Con M) →
((toSetoid : Setoid M) →
(mul' : ∀ {w x y z : M}, toSetoid w x → toSetoid y z → toSetoid (w * y) (x * z)) →
motive { toSetoid := toSetoid, mul' := mul' }) →
motive t | null | false |
add_thirds | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Semifield α] [inst_1 : PartialOrder α] [IsStrictOrderedRing α] (a : α),
a / 3 + a / 3 + a / 3 = a | null | true |
IsSimpleAddGroup.isSimpleAddGroup_of_surjective | Mathlib.GroupTheory.Subgroup.Simple | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_3} [inst_1 : AddGroup H] [IsSimpleAddGroup G] [Nontrivial H]
(f : G →+ H), Function.Surjective ⇑f → IsSimpleAddGroup H | null | true |
FirstOrder.Language.ElementaryEmbedding.ofModelsElementaryDiagram_toFun | Mathlib.ModelTheory.ElementaryMaps | ∀ (L : FirstOrder.Language) (M : Type u_1) [inst : L.Structure M] (N : Type u_5) [inst_1 : L.Structure N]
[inst_2 : (L.withConstants M).Structure N] [inst_3 : (L.lhomWithConstants M).IsExpansionOn N]
[inst_4 : N ⊨ L.elementaryDiagram M] (a : M),
(FirstOrder.Language.ElementaryEmbedding.ofModelsElementaryDiagram L... | null | true |
HomologicalComplex.Hom.fAddMonoidHom._proof_1 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {V : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c} (i : ι) (x x_1 : C₁ ⟶ C₂), (x + x_1).f i = (x + x_1).f i | null | false |
_private.Batteries.Data.Vector.Lemmas.0.Vector.scanlM.loop_toArray._proof_1_2 | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} (as : Vector α n), ∀ i ≤ n, n - i = 0 → ¬i = n → False | null | false |
PrimeSpectrum.preimageEquivFiber._proof_14 | Mathlib.RingTheory.LocalRing.ResidueField.Fiber | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : PrimeSpectrum R)
(q : ↑(PrimeSpectrum.comap (algebraMap R S) ⁻¹' {p})),
IsScalarTower R S (IsLocalRing.ResidueField (Localization.AtPrime (↑q).asIdeal)) | null | false |
LE.toBtw | Mathlib.Order.Circular | (α : Type u_1) → [LE α] → Btw α | The betweenness relation obtained from "looping around" `≤`.
See note [reducible non-instances]. | true |
LatticeHom.coe_toSupHom | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] (f : LatticeHom α β), ⇑f.toSupHom = ⇑f | null | true |
SeparationQuotient.mk_algebraMap | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : TopologicalSpace A] [inst_4 : IsTopologicalSemiring A] [inst_5 : ContinuousConstSMul R A] (r : R),
SeparationQuotient.mk ((algebraMap R A) r) = (algebraMap R (SeparationQuotient A)) r | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Drop.0.Std.Iter.step_drop.match_1.splitter | Std.Data.Iterators.Lemmas.Combinators.Drop | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((k : ℕ) → motive k.succ) → motive n | null | true |
iInf_ulift | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Type u_8} [inst : InfSet α] (f : ULift.{u_9, u_8} ι → α), ⨅ i, f i = ⨅ i, f { down := i } | null | true |
Multiset.mem_toFinset | Mathlib.Data.Finset.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, a ∈ s.toFinset ↔ a ∈ s | null | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizeMatchCond.internalizeSimpleMatchCondImp | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → ℕ → Lean.Meta.Grind.GoalM Unit | We say `MatchCond` is simple if its argument is an implication such as `x = 0 -> ...`
If that is the case, we also internalize the implication to ensure grind can split on the antecedents.
We added this extra case to make sure the user is not surprised by `grind` failing at
```
example (x y : Nat)
: 0 < match x, y ... | true |
MeasureTheory.condExpL1CLM.congr_simp | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1 | ∀ {α : Type u_1} (F' : Type u_3) [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F'] {m m0 : MeasurableSpace α}
(hm : m ≤ m0) (μ : MeasureTheory.Measure α) [inst_2 : CompleteSpace ↥(MeasureTheory.Lp F' 1 μ)]
[inst_3 : MeasureTheory.SigmaFinite (μ.trim hm)],
MeasureTheory.condExpL1CLM F' hm μ = MeasureTheor... | null | true |
LocallyFiniteOrder.mk._proof_6 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] (finsetIco : α → α → Finset α),
(∀ (a b x : α), x ∈ finsetIco a b ↔ x ≤ a ∧ b < x) → ∀ (a b x : α), x ∈ Function.swap finsetIco a b ↔ a < x ∧ x ≤ b | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.ofNatClamp_eq_allOnes_of_le._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ}, 2 ^ w ≤ n → n < 2 ^ w → False | null | false |
MvPolynomial.idealOfVars.eq_1 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ (σ : Type u_1) (R : Type u_2) [inst : CommSemiring R],
MvPolynomial.idealOfVars σ R = Ideal.span (Set.range MvPolynomial.X) | null | true |
Localization.localRingHom._proof_2 | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (I : Ideal R) [hI : I.IsPrime],
IsLocalization I.primeCompl (Localization I.primeCompl) | null | false |
Finset.prod_range_add_one_eq_factorial | Mathlib.Data.Nat.Factorial.BigOperators | ∀ (n : ℕ), ∏ i ∈ Finset.range n, (i + 1) = n.factorial | null | true |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso._proof_2 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (n : ℤ)
{X Y : Cᵒᵖᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.shiftFunctor Cᵒᵖᵒᵖ n).comp (CategoryTheory.unopUnop C)).map f)
(((CategoryTheory.Pretriangulated.shiftFunctorOpIso Cᵒᵖ n... | null | false |
CategoryTheory.SpectralSequence.pageFunctor | Mathlib.Algebra.Homology.SpectralSequence.Basic | (C : Type u_1) →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{κ : Type u_2} →
(c : ℤ → ComplexShape κ) →
(r₀ r : ℤ) →
autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence.pageFunctor._auto_1 →
CategoryTheory.Functor (Categor... | The functor `SpectralSequence C c r₀ ⥤ HomologicalComplex C (c r)` which
sends a spectral sequence to its `r`th page. | true |
Lean.Compiler.LCNF.FixedParams.AbsValue.top | Lean.Compiler.LCNF.FixedParams | Lean.Compiler.LCNF.FixedParams.AbsValue | null | true |
UInt8.toBitVec_shiftRight | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a >>> b).toBitVec = a.toBitVec >>> (b.toBitVec % 8) | null | true |
Std.Internal.UV.UDP.Socket.new | Std.Internal.UV.UDP | IO Std.Internal.UV.UDP.Socket | Creates a new UDP socket.
| true |
Submonoid.LocalizationMap.mk'_sec | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) (z : N), f.mk' (f.sec z).1 (f.sec z).2 = z | Given a localization map `f : M →* N` for a submonoid `S ⊆ M`, for all `z : N` we have that if
`x : M, y ∈ S` are such that `z * f y = f x`, then `f x * (f y)⁻¹ = z`. | true |
ContinuousMapZero.instFunLike | Mathlib.Topology.ContinuousMap.ContinuousMapZero | {X : Type u_1} →
{R : Type u_3} →
[inst : Zero X] →
[inst_1 : Zero R] →
[inst_2 : TopologicalSpace X] → [inst_3 : TopologicalSpace R] → FunLike (ContinuousMapZero X R) X R | null | true |
_private.Mathlib.Algebra.Lie.Free.0.«termLib.lift_of_apply» | Mathlib.Algebra.Lie.Free | Lean.ParserDescr | null | true |
CategoryTheory.ObjectProperty.SerreClassLocalization.epi_map_tfae | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] [L.IsLocalization P.isoModSerre] [inst_5 : CategoryTheory.Preaddit... | null | true |
GroupExtension.Splitting.noConfusionType | Mathlib.GroupTheory.GroupExtension.Defs | Sort u →
{N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
[inst : Group N] →
[inst_1 : Group E] →
[inst_2 : Group G] →
{S : GroupExtension N E G} →
S.Splitting →
{N' : Type u_1} →
{E' : Type u_2} →
... | null | false |
instMulSemiringActionQuotientSubgroupSubtypeMemSubringSubring._proof_1 | Mathlib.RingTheory.Invariant.Basic | ∀ {B : Type u_1} [inst : CommRing B] {G : Type u_2} [inst_1 : Group G] [inst_2 : MulSemiringAction G B] (H : Subgroup G)
[H.Normal] (g : G) (x : ↥(FixedPoints.subring B ↥H)) (h : ↥H), h • g • ↑x = g • ↑x | null | false |
Class.notMem_empty | Mathlib.SetTheory.ZFC.Class | ∀ (x : Class.{u}), x ∉ ∅ | null | true |
Finsupp.indicator | Mathlib.Data.Finsupp.Indicator | {ι : Type u_1} → {α : Type u_2} → [inst : Zero α] → (s : Finset ι) → ((i : ι) → i ∈ s → α) → ι →₀ α | Create an element of `ι →₀ α` from a finset `s` and a function `f` defined on this finset. | true |
AlgebraicIndependent.repr_ker | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(hx : AlgebraicIndependent R x), RingHom.ker ↑hx.repr = ⊥ | null | true |
UInt64.toNat_ofNat | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, (OfNat.ofNat n).toNat = n % 2 ^ 64 | null | true |
Affine.Simplex.signedInfDist.eq_1 | Mathlib.Geometry.Euclidean.SignedDist | ∀ {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) (i : Fin (n + 1)),
s.signedInfDist i = (affineSpan ℝ (s.points '' {i}ᶜ)).signedInfDist (s.points i) | null | true |
Lean.Meta.Match.MatchEqns.eqnNames | Lean.Meta.Match.MatchEqsExt | Lean.Meta.Match.MatchEqns → Array Lean.Name | null | true |
Aesop.FIFOQueue.mk.sizeOf_spec | Aesop.Search.Queue | ∀ (goals : Array Aesop.GoalRef) (pos : ℕ), sizeOf { goals := goals, pos := pos } = 1 + sizeOf goals + sizeOf pos | null | true |
LSeries.notation.«term_⍟_» | Mathlib.NumberTheory.LSeries.Convolution | Lean.TrailingParserDescr | Dirichlet convolution of two sequences.
We define this in terms of the already existing definition for arithmetic functions. | true |
_private.Init.Data.List.MinMaxIdx.0.List.combineMinIdxOn_assoc | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} {xys : List α} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β]
{xs ys zs : List α} {i j k : ℕ} {f : α → β} (hi : i < xs.length) (hj : j < ys.length) (hk : k < zs.length)
(h : xys = xs ++ ys),
List.combineMinIdxOn✝ f (List.combineMinIdxOn✝ f i j hi hj) k ⋯ hk =
L... | null | true |
Nat.dvd_sub | Init.Data.Nat.Dvd | ∀ {k m n : ℕ}, k ∣ m → k ∣ n → k ∣ m - n | null | true |
AddOpposite.unop_nonpos | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] {a : αᵃᵒᵖ}, AddOpposite.unop a ≤ 0 ↔ a ≤ 0 | null | true |
Nat.getElem?_toList_rco_eq_some_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k m n i : ℕ}, (m...n).toList[i]? = some k ↔ i < n - m ∧ m + i = k | null | true |
SSet.Truncated.HomotopyCategory.BinaryProduct.inverse | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | (X Y : SSet.Truncated 2) →
CategoryTheory.Functor (X.HomotopyCategory × Y.HomotopyCategory)
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).HomotopyCategory | The functor `X.HomotopyCategory × Y.HomotopyCategory ⥤ (X ⊗ Y).HomotopyCategory`
when `X` and `Y` are `2`-truncated simplicial sets. | true |
ContinuousLinearMap.toSpanSingletonLIE._proof_3 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], SMulCommClass 𝕜 𝕜 E | null | false |
_private.Init.Data.Vector.Lemmas.0.Vector.forall_mem_singleton._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {a b : α}, (a ∈ #v[b]) = (a = b) | null | false |
List.mapFinIdxM.go._f | Init.Data.List.MapIdx | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
[Monad m] →
(as : List α) →
((i : ℕ) → α → i < as.length → m β) →
(bs : List α) →
List.below (motive := fun bs => (acc : Array β) → bs.length + acc.size = as.length → m (List β)) bs →
(a... | null | false |
Lean.MethodSpecsAttrData.noConfusion | Lean.Meta.MethodSpecs | {P : Sort u} → {t t' : Lean.MethodSpecsAttrData} → t = t' → Lean.MethodSpecsAttrData.noConfusionType P t t' | null | false |
TopologicalSpace.OpenNhds.infLELeft._proof_1 | Mathlib.Topology.Category.TopCat.OpenNhds | ∀ {X : TopCat} {x : ↑X} (U V : TopologicalSpace.OpenNhds x), U ⊓ V ≤ U | null | false |
UnivLE.mk._flat_ctor | Mathlib.Basic.UnivLE | (∀ (α : Type u), Small.{v, u} α) → UnivLE.{u, v} | null | false |
Algebra.IsAlgebraic.instIsLocalizedModuleNonZeroDivisorsToLinearMapToAlgHom | Mathlib.RingTheory.Algebraic.Integral | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (S' : Type u_5)
[inst_3 : CommRing S'] [FaithfulSMul R S] [alg : Algebra.IsAlgebraic R S] [NoZeroDivisors S] [inst_6 : Algebra S S']
[IsFractionRing S S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R S S'],
IsLoc... | null | true |
MeromorphicOn.divisor_prod | Mathlib.Analysis.Meromorphic.Divisor | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {U : Set 𝕜} {ι : Type u_3} {s : Finset ι} {f : ι → 𝕜 → 𝕜},
(∀ i ∈ s, MeromorphicOn (f i) U) →
(∀ i ∈ s, ∀ z ∈ U, meromorphicOrderAt (f i) z ≠ ⊤) →
MeromorphicOn.divisor (∏ i ∈ s, f i) U = ∑ i ∈ s, MeromorphicOn.divisor (f i) U | If orders are finite, the divisor of a product of meromorphic functions is the sum of the divisors.
| true |
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap.eq_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap =
{
forget₂ :=
{ obj := fun G => G.toProfinite,
map := fun {X Y} f =>
CompHausLike.ofHom (fun X => TotallyDisconnectedSpace ↑X)
{ toFun := ⇑(ProfiniteGrp.Hom.hom ... | null | true |
HomotopicalAlgebra.Cylinder.ofFactorizationData | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
{A : C} →
(HomotopicalAlgebra.cofibrations C).MapFactorizationData (HomotopicalAlgebra.trivialFibrations C)
(CategoryTheory.Limits.codiag A) →
HomotopicalAlgebra.Cylinder ... | A cylinder object for `A` can be obtained from a factorization of the obvious
map `A ⨿ A ⟶ A` as a cofibration followed by a trivial fibration. | true |
CategoryTheory.Limits.Wedge.mk._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] {F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)} (pt : C)
(π : (j : J) → pt ⟶ (F.obj (Opposite.op j)).obj j),
(∀ ⦃i j : J⦄ (f : i ⟶ j),
CategoryTheory.CategoryStruct.com... | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult | Init.Data.Format.Basic | Type | null | true |
_private.Init.Data.Range.Basic.0.Std.Legacy.Range.forIn'._proof_2 | Init.Data.Range.Basic | ∀ (range : Std.Legacy.Range), range.start ≤ range.start | null | false |
_private.Mathlib.Data.Seq.Computation.0.Computation.LiftRelAux.ret_left.match_1_3 | Mathlib.Data.Seq.Computation | ∀ {α : Type u_1} {β : Type u_2} (R : α → β → Prop) (C : Computation α → Computation β → Prop) (a : α)
(cb : Computation β) (motive : Computation.LiftRelAux R C (Sum.inl a) (Sum.inr cb) → Prop)
(x : Computation.LiftRelAux R C (Sum.inl a) (Sum.inr cb)), (∀ (b : β) (h : b ∈ cb) (r : R a b), motive ⋯) → motive x | null | false |
Matrix.GeneralLinearGroup.isParabolic_conj_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {R : Type u_1} [inst : CommRing R] (g h : GL (Fin 2) R), (g * h * g⁻¹).IsParabolic = h.IsParabolic | null | false |
RingHom.HasEqualizers.isClosedUnderLimitsOfShape | Mathlib.Algebra.Category.Ring.Under.Property | ∀ {Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
(RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => Q) →
(RingHom.HasEqualizers fun {R S} [CommRing R] [CommRing S] => Q) →
∀ (R : CommRingCat),
(RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRi... | null | true |
MvPolynomial.mem_vars_iff_mem_support | Mathlib.Algebra.MvPolynomial.Variables | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} (i : σ),
i ∈ p.vars ↔ ∃ d ∈ p.support, i ∈ d.support | null | true |
_private.Lean.Meta.Tactic.Grind.Anchor.0.Lean.Meta.Grind.mix | Lean.Meta.Tactic.Grind.Anchor | UInt64 → UInt64 → UInt64 | null | true |
FractionalIdeal.extended_ne_zero | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ {A : Type u_1} [inst : CommRing A] {B : Type u_2} [inst_1 : CommRing B] {f : A →+* B} {K : Type u_3} {M : Submonoid A}
[inst_2 : CommRing K] [inst_3 : Algebra A K] [inst_4 : IsLocalization M K] (L : Type u_4) {N : Submonoid B}
[inst_5 : CommRing L] [inst_6 : Algebra B L] [inst_7 : IsLocalization N L] (hf : M ≤ Su... | null | true |
_private.Lean.Data.JsonRpc.0.Lean.JsonRpc.instBEqNotification.beq.match_1 | Lean.Data.JsonRpc | {α : Type u_1} →
(motive : Lean.JsonRpc.Notification α → Lean.JsonRpc.Notification α → Sort u_2) →
(x x_1 : Lean.JsonRpc.Notification α) →
((a : String) →
(a_1 : α) → (b : String) → (b_1 : α) → motive { method := a, param := a_1 } { method := b, param := b_1 }) →
((x x_2 : Lean.JsonRpc.Not... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.