name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Internal.List.getValue?_filter_containsKey_of_containsKey_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = false →
Std.Internal.List.getValue? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) = none | null | true |
Finset.intervalGapsWithin.snd.congr_simp | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} [inst : LinearOrder α] (F F_1 : Finset (α × α)) (e_F : F = F_1) {k : ℕ} (h : F.card = k) (b b_1 : α),
b = b_1 →
∀ (i i_1 : Fin (k + 1)),
i = i_1 → Finset.intervalGapsWithin.snd F h b i = Finset.intervalGapsWithin.snd F_1 ⋯ b_1 i_1 | null | true |
Mathlib.Tactic.Sat.buildProof.match_5 | Mathlib.Tactic.Sat.FromLRAT | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → (Unit → motive none) → ((a : Lean.Expr) → motive (some a)) → motive x | null | false |
Option.elim | Init.Data.Option.Basic | {α : Type u_1} → {β : Sort u_2} → Option α → β → (α → β) → β | A case analysis function for `Option`.
Given a value for `none` and a function to apply to the contents of `some`, `Option.elim` checks
which constructor a given `Option` consists of, and uses the appropriate argument.
`Option.elim` is an elimination principle for `Option`. In particular, it is a non-dependent versio... | true |
CategoryTheory.Functor.CoreMonoidal.μIso_hom_natural_left._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
SSet.Augmented.stdSimplex._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ (X : SimplexCategory),
{ left := SSet.stdSimplex.map (CategoryTheory.CategoryStruct.id X),
right :=
CategoryTheory.Limits.terminal.from
{ left := SSet.stdSimplex.obj X, right := ⊤_ Type u_1,
hom :=
{
app := fun x =>
Category... | null | false |
MeasureTheory.«term__[_|_]» | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | Lean.TrailingParserDescr | Conditional expectation of a function, with notation `μ[f | m]`.
It is defined as 0 if any one of the following conditions is true:
- `m` is not a sub-σ-algebra of `m₀`,
- `μ` is not σ-finite with respect to `m`,
- `f` is not integrable. | true |
Option.not_lt_pfilter | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α],
(∀ (x : α), ¬x < x) → ∀ {o : Option α} {p : (a : α) → o = some a → Bool}, ¬o < o.pfilter p | null | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.match_1 | Lean.Elab.Syntax | (motive : (Lean.Term × ℕ) × Option ℕ → Sort u_1) →
(x : (Lean.Term × ℕ) × Option ℕ) →
((newStx : Lean.Term) → (snd : ℕ) → (lhsPrec? : Option ℕ) → motive ((newStx, snd), lhsPrec?)) → motive x | null | false |
ClosedSubgroup.instSetLike | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [inst : Group G] → [inst_1 : TopologicalSpace G] → SetLike (ClosedSubgroup G) G | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_artanh._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ x ∈ Set.Ioo (-1) 1, 0 ≤ 1 - x | null | false |
CategoryTheory.Localization.Construction.natTransExtension | Mathlib.CategoryTheory.Localization.Construction | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
{W : CategoryTheory.MorphismProperty C} →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{uD', uD} D] →
{F₁ F₂ : CategoryTheory.Functor W.Localization D} → (W.Q.comp F₁ ⟶ W.Q.comp F₂) → (F₁ ⟶ F₂) | If `F₁` and `F₂` are functors `W.Localization ⥤ D`, a natural transformation `F₁ ⟶ F₂`
can be obtained from a natural transformation `W.Q ⋙ F₁ ⟶ W.Q ⋙ F₂`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.degree_eq_zero._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)], G.degree v = (G.neighborFinset v).card | null | false |
Computability.instDecidableEqΓ'.decEq._proof_6 | Mathlib.Computability.Encoding | ¬Computability.Γ'.blank = Computability.Γ'.comma | null | false |
_private.Mathlib.Analysis.Complex.ValueDistribution.Cartan.0.ValueDistribution.log_trailingCoeff_eq_zero_on_unitSphere | Mathlib.Analysis.Complex.ValueDistribution.Cartan | ∀ {f : ℂ → ℂ} {a : ℂ},
0 < meromorphicOrderAt f 0 → a ∈ Metric.sphere 0 |1| → Real.log ‖meromorphicTrailingCoeffAt (fun x => f x - a) 0‖ = 0 | null | true |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.finitenessRelation._proof_2 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice) [inst : String.Slice.Pattern.BackwardPattern pat]
[String.Slice.Pattern.StrictBackwardPattern pat] {it it' : Std.IterM Id (String.Slice.Pattern.SearchStep s)},
it'.IsPlausibleSuccessorOf it → InvImage WellFoundedRelation.rel (fun it => it.internalState.currPos.down) it' it | null | false |
ModuleFilterBasis.smul_right' | Mathlib.Topology.Algebra.FilterBasis | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : TopologicalSpace R] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] (self : ModuleFilterBasis R M) (m₀ : M) {U : Set M},
U ∈ self.sets → ∀ᶠ (x : R) in nhds 0, x • m₀ ∈ U | null | true |
Homeomorph.isCompact_image | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} (h : X ≃ₜ Y),
IsCompact (⇑h '' s) ↔ IsCompact s | If `h : X → Y` is a homeomorphism, `h(s)` is compact iff `s` is. | true |
topologicalNilradical._proof_1 | Mathlib.Topology.Algebra.TopologicallyNilpotent | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommRing R], IsTopologicallyNilpotent 0 | null | false |
Std.Rio.length_iter | Std.Data.Iterators.Lemmas.Producers.Range | ∀ {α : Type u_1} [inst : Std.PRange.Least? α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α] [Std.Rxo.IsAlwaysFinite α]
[inst_6 : Std.PRange.LawfulUpwardEnumerable α] [inst_7 : Std.Rxo.HasSize α] [Std.Rxo.LawfulHasSize α] {r : Std.R... | null | true |
Std.Iter.filterMapWithPostcondition_eq_toIter_filterMapWithPostcondition_toIterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β γ : Type w} [inst : Std.Iterator α Id β] {it : Std.Iter β} {m : Type w → Type w'} [inst_1 : Monad m]
{f : β → Std.Iterators.PostconditionT m (Option γ)},
Std.Iter.filterMapWithPostcondition f it = Std.IterM.filterMapWithPostcondition f it.toIterM | null | true |
MulArchimedeanClass.instLinearOrder._proof_19 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] (b : MulArchimedeanClass M)
(a b_1 : MulArchimedeanOrder M),
(AntisymmRel.setoid (MulArchimedeanOrder M) fun x1 x2 => x1 ≤ x2) a b_1 →
Quot.indep (fun a => Quot.recOnSubsingleton b fun a_2 => Classical.propDecidable (a <... | null | false |
Language.mem_one._simp_1 | Mathlib.Computability.Language | ∀ {α : Type u_1} (x : List α), (x ∈ 1) = (x = []) | null | false |
nontrivial_iff_exists_ne | Mathlib.Logic.Nontrivial.Defs | ∀ {α : Type u_1} (x : α), Nontrivial α ↔ ∃ y, y ≠ x | null | true |
instDecidableEqNum.decEq._proof_4 | Mathlib.Data.Num.Basic | ∀ (a : PosNum), ¬Num.pos a = Num.zero | null | false |
LeftInvariantDerivation.instCoeDerivationContMDiffMapModelWithCornersSelfSomeENatTop._proof_2 | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], ContMDiffAdd (modelWithCornersSelf 𝕜 𝕜) (↑⊤) 𝕜 | null | false |
Std.DTreeMap.Internal.Impl.contains | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → [Ord α] → α → Std.DTreeMap.Internal.Impl α β → Bool | Returns `true` if the given key is contained in the map. | true |
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {Z : CategoryTheory.ObjectProperty.FullSubcategory fun a => a.len ≤ 2}
(h : { obj := { len := 1 }, property := SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp
(SimplexCategory.Truncated.δ₂ 0 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_1
Simp... | null | true |
Lean.Meta.MVarRenaming | Lean.Meta.Match.MVarRenaming | Type | A mapping from MVarId to MVarId | true |
Lean.Order.SeqLeft.monotone_seqLeft | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m]
{α β : Type u} {γ : Type w} [inst_3 : Lean.Order.PartialOrder γ] [LawfulMonad m] (f : γ → m α) (g : γ → m β),
Lean.Order.monotone g → Lean.Order.monotone f → Lean.Order.monotone fun x => g x <* f... | null | true |
AddSemigroupAction | Mathlib.Algebra.Group.Action.Defs | (G : Type u_9) → Type u_10 → [AddSemigroup G] → Type (max u_10 u_9) | Type class for actions by additive semigroups, with notation `g +ᵥ p`.
The `AddSemigroupAction G P` typeclass says that the additive semigroup `G` acts additively on a
type `P`. More precisely this means that the action satisfies the axiom
`(g₁ + g₂) +ᵥ p = g₁ +ᵥ (g₂ +ᵥ p)`. A mathematician might simply say that the... | true |
CategoryTheory.Functor.mapAddGrpFunctor._proof_2 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{F G : C ⥤ₗ D} (α : F ⟶ G) (A : CategoryTheory.AddGrp C),
CategoryTheory.Categor... | null | false |
PrimitiveSpectrum.gc | Mathlib.Topology.Order.HullKernel | ∀ {α : Type u_1} [inst : CompleteLattice α] {T : Set α},
GaloisConnection (fun S => OrderDual.toDual (PrimitiveSpectrum.kernel S)) fun a =>
PrimitiveSpectrum.hull T (OrderDual.ofDual a) | The pair of maps `kernel` and `hull` form an antitone Galois connection between the
subsets of `T` and `α`. | true |
TopCat.instCommRingHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier._proof_11 | Mathlib.Topology.Sheaves.CommRingCat | ∀ (X : TopCat) (R : TopCommRingCat) (x : ℕ),
CategoryTheory.ConcreteCategory.hom ↑x = CategoryTheory.ConcreteCategory.hom ↑x | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.typeHasRecFun.match_4 | Lean.Elab.MutualDef | (motive : Option Lean.Expr → Sort u_1) →
(occ? : Option Lean.Expr) →
((fvarId : Lean.FVarId) → motive (some (Lean.Expr.fvar fvarId))) → ((x : Option Lean.Expr) → motive x) → motive occ? | null | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanShape_L | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X), data.multicospanShape.L = data.I₀ | null | true |
_private.Lean.Data.NameTrie.0.Lean.toKey.loop._f | Lean.Data.NameTrie | (x : Lean.Name) →
Lean.Name.below (motive := fun x => List Lean.NamePart → List Lean.NamePart) x →
List Lean.NamePart → List Lean.NamePart | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.parseFromSymbols | Std.Time.Format.Basic | {α : Type} → Array (String × α) → Std.Internal.Parsec.String.Parser α | null | true |
SeparationQuotient.instNonUnitalnonAssocSemiring | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocSemiring R] →
[IsTopologicalSemiring R] → NonUnitalNonAssocSemiring (SeparationQuotient R) | null | true |
List.zipWith_map_left | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {α' : Type u_3} {γ : Type u_4} {l₁ : List α} {l₂ : List β} {f : α → α'}
{g : α' → β → γ}, List.zipWith g (List.map f l₁) l₂ = List.zipWith (fun a b => g (f a) b) l₁ l₂ | null | true |
Lean.Lsp.CompletionItemKind.value.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.CompletionItemKind.value = 1 | null | true |
Lean.PrefixTreeNode.brecOn_3.eq | Lean.Data.PrefixTree | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1}
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1}
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1}
{motive_4 : (Std.DTreeMap.Internal.Impl α fun x... | null | true |
Std.Http.Protocol.H1.Error.timeout.elim | Std.Http.Protocol.H1.Error | {motive : Std.Http.Protocol.H1.Error → Sort u} →
(t : Std.Http.Protocol.H1.Error) → t.ctorIdx = 2 → motive Std.Http.Protocol.H1.Error.timeout → motive t | null | false |
SimpleGraph.lapMatrix_ker_basis | Mathlib.Combinatorics.SimpleGraph.LapMatrix | {V : Type u_1} →
[inst : Fintype V] →
(G : SimpleGraph V) →
[inst_1 : DecidableRel G.Adj] →
[inst_2 : DecidableEq V] →
[DecidableEq G.ConnectedComponent] →
Module.Basis G.ConnectedComponent ℝ ↥(Matrix.toLin' (SimpleGraph.lapMatrix ℝ G)).ker | `lapMatrix_ker_basis G` is a basis of the nullspace indexed by its connected components,
the basis is made up of the functions `V → ℝ` which are `1` on the vertices of the given
connected component and `0` elsewhere. | true |
isClopen_connectedComponent | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α] [LocallyConnectedSpace α] {x : α}, IsClopen (connectedComponent x) | null | true |
NONote.ofNat | Mathlib.SetTheory.Ordinal.Notation | ℕ → NONote | Convert a natural number to an ordinal notation | true |
ContinuousOpenMapClass.casesOn | Mathlib.Topology.Hom.Open | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : FunLike F α β] →
{motive : ContinuousOpenMapClass F α β → Sort u} →
(t : ContinuousOpenMapClass F α β) →
([toContinuousMapCla... | null | false |
ONote.mul.eq_def | Mathlib.SetTheory.Ordinal.Notation | ∀ (x x_1 : ONote),
x.mul x_1 =
match x, x_1 with
| ONote.zero, x => 0
| x, ONote.zero => 0
| o₁@h:(e₁.oadd n₁ a₁), e₂.oadd n₂ a₂ => if e₂ = 0 then e₁.oadd (n₁ * n₂) a₁ else (e₁ + e₂).oadd n₂ (o₁.mul a₂) | null | true |
AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.match_3 | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {N : Type u_1} [inst : AddCommMonoid N] {P : Type u_2} [inst_1 : AddCommMonoid P] (k : N ≃+ P) (v : P)
(motive : (∃ a, k a = v) → Prop) (x : ∃ a, k a = v), (∀ (z : N) (hz : k z = v), motive ⋯) → motive x | null | false |
AddSubgroup.closure_le_centralizer_centralizer | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_1} [inst : AddGroup G] (s : Set G),
AddSubgroup.closure s ≤ AddSubgroup.centralizer ↑(AddSubgroup.centralizer s) | null | true |
Batteries.AssocList.mapKey.eq_2 | Batteries.Data.AssocList | ∀ {α : Type u_1} {δ : Type u_2} {β : Type u_3} (f : α → δ) (a : α) (b : β) (es : Batteries.AssocList α β),
Batteries.AssocList.mapKey f (Batteries.AssocList.cons a b es) =
Batteries.AssocList.cons (f a) b (Batteries.AssocList.mapKey f es) | null | true |
Matrix.IsHermitian.charpoly_cfc_eq | Mathlib.Analysis.Matrix.HermitianFunctionalCalculus | ∀ {n : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {A : Matrix n n 𝕜}
(hA : A.IsHermitian) (f : ℝ → ℝ), (cfc f A).charpoly = ∏ i, (Polynomial.X - Polynomial.C ↑(f (hA.eigenvalues i))) | null | true |
Aesop.AddRapp.mk.injEq | Aesop.Tree.AddRapp | ∀ (toRuleApplication : Aesop.RuleApplication) (parent : Aesop.GoalRef) (appliedRule : Aesop.RegularRule)
(successProbability : Aesop.Percent) (toRuleApplication_1 : Aesop.RuleApplication) (parent_1 : Aesop.GoalRef)
(appliedRule_1 : Aesop.RegularRule) (successProbability_1 : Aesop.Percent),
({ toRuleApplication :=... | null | true |
compl_bihimp_self | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), bihimp aᶜ a = ⊥ | null | true |
_private.Std.Sync.Notify.0.Std.Notify.notify.match_1 | Std.Sync.Notify | (motive : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit)) → Sort u_1) →
(x : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit))) →
((consumer : Std.Notify.Consumer Unit) →
(rest : Std.Queue (Std.Notify.Consumer Unit)) → motive (some (consumer, rest))) →
... | null | false |
instGradedAlgebraRestrictScalars._proof_3 | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_2} {R : Type u_3} {A : Type u_1} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : CommSemiring R]
[inst_3 : Semiring A] [inst_4 : Algebra R A] (𝒜 : ι → Submodule R A) [i : GradedAlgebra 𝒜],
Function.RightInverse (⇑(DirectSum.coeAddMonoidHom 𝒜)) DirectSum.Decomposition.decompose' | null | false |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.elabLetIDecl._regBuiltin.Lean.Elab.Term.elabLetIDecl_1 | Lean.Elab.Binders | IO Unit | null | false |
Aesop.UnsafeRuleInfo.successProbability | Aesop.Rule | Aesop.UnsafeRuleInfo → Aesop.Percent | null | true |
Lean.Meta.abstractProof | Lean.Meta.AbstractNestedProofs | {m : Type → Type} →
[inst : Monad m] →
[MonadLiftT Lean.MetaM m] →
[Lean.MonadEnv m] →
[Lean.MonadOptions m] →
[MonadFinally m] → Lean.Expr → optParam Bool true → optParam (Lean.Expr → m Lean.Expr) pure → m Lean.Expr | Abstracts the given proof into an auxiliary theorem, suitably pre-processing its type. | true |
Finset.consPiProd_fst | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α} (f : α → Type u_3) (has : a ∉ s) (x : (i : α) → i ∈ Finset.cons a s has → f i),
(Finset.consPiProd f has x).1 = x a ⋯ | null | true |
normGroupNorm | Mathlib.Analysis.Normed.Group.Basic | (E : Type u_5) → [inst : NormedGroup E] → GroupNorm E | The norm of a normed group as a group norm. | true |
Submodule.injective_tensorToSpan | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ {R : Type u_1} (A : Type u_2) {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [inst_6 : IsScalarTower R A M]
(p : Submodule R M) [Algebra.IsEpi R A] [Module.Flat R A], Function.Injective ⇑(Submodule.tens... | null | true |
Lean.Parser.ppAllowUngrouped.parenthesizer | Lean.Parser.Extra | Lean.PrettyPrinter.Parenthesizer | null | true |
Stream'.WSeq.mem_think | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (s : Stream'.WSeq α) (a : α), a ∈ s.think ↔ a ∈ s | null | true |
Bitraversable.id_tsnd | Mathlib.Control.Bitraversable.Lemmas | ∀ {t : Type u → Type u → Type u} [inst : Bitraversable t] [LawfulBitraversable t] {α β : Type u} (x : t α β),
Bitraversable.tsnd pure x = pure x | null | true |
Subspace.dualLift_injective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {W : Subspace K V},
Function.Injective ⇑W.dualLift | null | true |
Finmap.instDecidableMem | Mathlib.Data.Finmap | {α : Type u} → {β : α → Type v} → [DecidableEq α] → (a : α) → (s : Finmap β) → Decidable (a ∈ s) | null | true |
_private.Lean.Meta.Offset.0.Lean.Meta.getOffset | Lean.Meta.Offset | Lean.Expr → Lean.MetaM (Lean.Expr × ℕ) | Quick function for converting `e` into `s + k` s.t. `e` is definitionally equal to `Nat.add s k`.
This function always succeeds in finding such `s` and `k`
(as a last resort it returns `e` and `0`).
| true |
Aesop.Safety.ctorIdx | Aesop.Rule | Aesop.Safety → ℕ | null | false |
Lean.Meta.Grind.PendingSolverPropagations._sizeOf_inst | Lean.Meta.Tactic.Grind.Types | SizeOf Lean.Meta.Grind.PendingSolverPropagations | null | false |
MvPFunctor.wRec_eq | Mathlib.Data.PFunctor.Multivariate.W | ∀ {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {C : Sort u_1}
(g : (a : P.A) → (P.drop.B a).Arrow α → (P.last.B a → P.W α) → (P.last.B a → C) → C) (a : P.A)
(f' : (P.drop.B a).Arrow α) (f : P.last.B a → P.W α), P.wRec g (P.wMk a f' f) = g a f' f fun i => P.wRec g (f i) | Defining equation for the recursor of `W` | true |
Lean.Meta.Grind.Arith.isNatAdd? | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Option (Lean.Expr × Lean.Expr) | Returns `some (a, b)` if `e` is of the form
```
@HAdd.hAdd Nat Nat Nat (instHAdd Nat instAddNat) a b
```
| true |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.merge? | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic → Lean.TSyntax `tactic → Option (Lean.TSyntax `tactic) | null | true |
Lean.SMap.mk.injEq | Lean.Data.SMap | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (stage₁ : Bool) (map₁ : Std.HashMap α β)
(map₂ : Lean.PHashMap α β) (stage₁_1 : Bool) (map₁_1 : Std.HashMap α β) (map₂_1 : Lean.PHashMap α β),
({ stage₁ := stage₁, map₁ := map₁, map₂ := map₂ } = { stage₁ := stage₁_1, map₁ := map₁_1, map₂ := map₂_1 }) ... | null | true |
Finset.mk_mem_sigmaLift | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
(f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (i : ι) (a : α i) (b : β i) (x : γ i),
⟨i, x⟩ ∈ Finset.sigmaLift f ⟨i, a⟩ ⟨i, b⟩ ↔ x ∈ f a b | null | true |
PrimeMultiset.coeNat | Mathlib.Data.PNat.Factors | Coe PrimeMultiset (Multiset ℕ) | null | true |
Module.End.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice | Mathlib.Algebra.Module.Submodule.Invariant | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (f : Module.End R M) → BoundedOrder ↥f.invtSubmodule | null | true |
DMatrix.map_zero | Mathlib.Data.Matrix.DMatrix | ∀ {m : Type u_1} {n : Type u_2} {α : m → n → Type v} [inst : (i : m) → (j : n) → Zero (α i j)] {β : m → n → Type w}
[inst_1 : (i : m) → (j : n) → Zero (β i j)] {f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j},
(∀ (i : m) (j : n), f 0 = 0) → DMatrix.map 0 f = 0 | null | true |
_private.Lean.Meta.FunInfo.0.Lean.Meta.getFunInfoAux.match_4 | Lean.Meta.FunInfo | (motive : Option (Array ℕ) → Sort u_1) →
(x : Option (Array ℕ)) →
((outParamPositions : Array ℕ) → motive (some outParamPositions)) → ((x : Option (Array ℕ)) → motive x) → motive x | null | false |
Polynomial.evalEval_surjective | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : Semiring R] (x y : R), Function.Surjective (Polynomial.evalEval x y) | null | true |
List.continuous_prod | Mathlib.Topology.List | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MulOneClass α] [ContinuousMul α], Continuous List.prod | null | true |
Nat.shiftRight_succ_inside | Init.Data.Nat.Lemmas | ∀ (m n : ℕ), m >>> (n + 1) = (m / 2) >>> n | Shift right on successor with division moved inside. | true |
WeierstrassCurve.preΨ₄._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | (4 + 1).AtLeastTwo | null | false |
MDifferentiableAt.prodMap | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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 |
AddChar.starComp_apply | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {R : Type u_1} [inst : CommRing R], 0 < ringChar R → ∀ {φ : AddChar R ℂ} (a : R), (starRingEnd ℂ) (φ a) = φ⁻¹ a | null | true |
Std.DTreeMap.getKeyD_maxKeyD | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback fallback' : α}, t.getKeyD (t.maxKeyD fallback) fallback' = t.maxKeyD fallback | null | true |
_private.Mathlib.Computability.DFA.0.DFA.accepts_reindex._simp_1_1 | Mathlib.Computability.DFA | ∀ {α : Type u} {σ : Type v} (M : DFA α σ) {x : List α}, (x ∈ M.accepts) = (M.eval x ∈ M.accept) | null | false |
DirectSum.id._proof_5 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι] (x : DirectSum ι fun x => M),
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) x) = x | null | false |
Valuation.IsRankOneDiscrete.generator_zpowers_eq_valueGroup | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] (v : Valuation A Γ)
[inst_2 : v.IsRankOneDiscrete],
Subgroup.zpowers (Valuation.IsRankOneDiscrete.generator v) = (MonoidWithZeroHom.ofClass v).valueGroup | null | true |
Std.Http.Status.isError | Std.Http.Data.Status | Std.Http.Status → Bool | Checks if the status code indicates an error (either client error 4xx or server error 5xx).
Reference: https://httpwg.org/specs/rfc9110.html#status.codes
| true |
CategoryTheory.SimplicialObject.Splitting.IndexSet.epiComp_fst | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : CategoryTheory.SimplicialObject.Splitting.IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂)
[inst : CategoryTheory.Epi p.unop], (A.epiComp p).fst = A.fst | null | true |
CategoryTheory.AbelianOfAdjunction.hasKernels | Mathlib.CategoryTheory.Abelian.Transfer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D C) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.Pres... | No point making this an instance, as it requires `i`. | true |
Set.mem_vadd_set_iff_neg_vadd_mem | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] {A : Set β} {a : α} {x : β},
x ∈ a +ᵥ A ↔ -a +ᵥ x ∈ A | null | true |
equicontinuous_iInf_rng | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {κ : Type u_2} {X : Type u_3} {α' : Type u_7} [tX : TopologicalSpace X] {u : κ → UniformSpace α'}
{F : ι → X → α'}, Equicontinuous F ↔ ∀ (k : κ), Equicontinuous F | null | true |
Lean.SyntaxNodeKinds | Init.Prelude | Type | `SyntaxNodeKinds` is a set of `SyntaxNodeKind`, implemented as a list.
Singleton `SyntaxNodeKinds` are extremely common. They are written as name literals, rather than as
lists; list syntax is required only for empty or non-singleton sets of kinds.
| true |
Lean.ModuleIdx.toNat | Lean.Environment | Lean.ModuleIdx → ℕ | null | true |
WeierstrassCurve.Projective.polynomial.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Projective R),
W'.polynomial =
MvPolynomial.X 1 ^ 2 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₁ * MvPolynomial.X 0 * MvPolynomial.X 1 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₃ * MvPolynomial.X 1 * MvPolynomial.X 2 ^ 2 -
(MvPolynomial.... | null | true |
ULift.instLinearOrder._proof_3 | Mathlib.Order.Lattice | ∀ {α : Type u_2} [inst : LinearOrder α] (a b : ULift.{u_1, u_2} α), (min a b).down = min a.down b.down | null | false |
Std.DTreeMap.Internal.Impl.Equiv.constModify | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t₁.WF →
t₂.WF →
t₁.Equiv t₂ →
∀ {k : α} {f : β → β},
(Std.DTreeMap.Internal.Impl.Const.modify k f t₁).Equiv (Std.DTreeMap.Internal.Impl.Const.modify k f t₂) | null | true |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet.0.«term_~ᵤ_» | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | Lean.TrailingParserDescr | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.