name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AffineMap.toFun_eq_coe | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2]
[inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2] (f : P1 →ᵃ[k] P2), f.toFun = ⇑f | `toFun` is the same as the result of coercing to a function. | true |
List.ofFnM_zero | Init.Data.List.OfFn | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] [LawfulMonad m] {f : Fin 0 → m α}, List.ofFnM f = pure [] | `ofFnM` on an empty domain is the empty list. | true |
WittVector.onePoly.eq_1 | Mathlib.RingTheory.WittVector.IsPoly | ∀ (n : ℕ), WittVector.onePoly n = if n = 0 then 1 else 0 | null | true |
Std.DTreeMap.Internal.Impl.getKeyGE._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) → (t : Std.DTreeMap.Internal.Impl α β) → t.Ordered → (∃ a ∈ t, (compare a k).isGE = true) → α | null | false |
CategoryTheory.ConcreteCategory.surjective_le_epimorphisms | Mathlib.CategoryTheory.ConcreteCategory.EpiMono | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC],
CategoryTheory.MorphismProperty.surjective C ≤ CategoryTheory.MorphismProperty.epimorphisms C | null | true |
_private.Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Independence.0.ProbabilityTheory.iIndepFun.hasGaussianLaw._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Independence | ∀ {ι : Type u_1} {G : Type u_5} {s : Finset ι} [inst : SubtractionCommMonoid G] (f g : ι → G),
∑ x ∈ s, f x - ∑ x ∈ s, g x = ∑ x ∈ s, (f x - g x) | null | false |
Int.decEq._proof_3 | Init.Data.Int.Basic | ∀ (a a_1 : ℕ), Int.ofNat a = Int.negSucc a_1 → Int.noConfusionType False (Int.ofNat a) (Int.negSucc a_1) | null | false |
instMonadAttachEIO | Init.System.IO | {ε : Type} → MonadAttach (EIO ε) | null | true |
AddMonoidAlgebra.singleAddHom | Mathlib.Algebra.MonoidAlgebra.Defs | {R : Type u_1} → {M : Type u_4} → [inst : Semiring R] → M → R →+ AddMonoidAlgebra R M | `AddMonoidAlgebra.single` as an `AddMonoidHom`.
TODO: Rename to `singleAddMonoidHom`. | true |
_private.Mathlib.Computability.AkraBazzi.SumTransform.0.AkraBazziRecurrence.eventually_r_ge._simp_1_1 | Mathlib.Computability.AkraBazzi.SumTransform | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] (a : R), (a ≤ ↑⌈a⌉₊) = True | null | false |
_private.Init.Data.Nat.Fold.0.Nat.fold._proof_2 | Init.Data.Nat.Fold | ∀ (n i : ℕ), i < n → i < n.succ | null | false |
Polynomial.emultiplicity_le_one_of_separable | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] {p q : Polynomial R}, ¬IsUnit q → p.Separable → emultiplicity q p ≤ 1 | null | true |
TopCat.Presheaf.SubmonoidPresheaf.localizationPresheaf._proof_1 | Mathlib.Topology.Sheaves.CommRingCat | ∀ {X : TopCat} {F : TopCat.Presheaf CommRingCat X} (G : F.SubmonoidPresheaf) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ),
CommRingCat.ofHom
(IsLocalization.map (Localization (G.obj U)) (CommRingCat.Hom.hom (F.map (CategoryTheory.CategoryStruct.id U)))
⋯) =
CategoryTheory.CategoryStruct.id ↧(Localization (G.... | null | false |
Vector.mem_of_back? | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {a : α}, xs.back? = some a → a ∈ xs | null | true |
CategoryTheory.hasCardinalLT_arrow_op_iff._simp_1 | Mathlib.CategoryTheory.Comma.CardinalArrow | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (κ : Cardinal.{w}),
HasCardinalLT (CategoryTheory.Arrow Cᵒᵖ) κ = HasCardinalLT (CategoryTheory.Arrow C) κ | null | false |
OrderedFinpartition.range_emb_extendMiddle_ne_singleton_zero | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition n) (i j : Fin c.length), Set.range ((c.extendMiddle i).emb j) ≠ {0} | null | true |
StarSubalgebra.topologicalClosure_coe | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
[inst_7 : IsSemitopologicalSemiring A] [inst_8 : ContinuousStar A] (s : StarSubalgebra R A),
↑s.topologicalClosur... | null | true |
OpenPartialHomeomorph.toHomeomorphOfSourceEqUnivTargetEqUniv | Mathlib.Topology.OpenPartialHomeomorph.Basic | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
(e : OpenPartialHomeomorph X Y) → e.source = Set.univ → e.target = Set.univ → X ≃ₜ Y | If an open partial homeomorphism has source and target equal to univ, then it induces a
homeomorphism between the whole spaces, expressed in this definition. | true |
List.getElem_set_ne._proof_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {i j : ℕ} {a : α}, j < (l.set i a).length → j < l.length | null | false |
Lean.Lsp.SignatureInformation.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | String →
Option Lean.Lsp.MarkupContent →
Option (Array Lean.Lsp.ParameterInformation) → Option ℕ → Lean.Lsp.SignatureInformation | null | false |
BinaryTree.rec | Mathlib.Data.Tree.Basic | {α : Type u} →
{motive : BinaryTree α → Sort u_1} →
motive BinaryTree.nil →
((value : α) →
(left right : BinaryTree α) → motive left → motive right → motive (BinaryTree.node value left right)) →
(t : BinaryTree α) → motive t | null | false |
CategoryTheory.Limits.cokernel.π_desc | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {W : C} (k : Y ⟶ W)
(h : CategoryTheory.CategoryStruct.comp f k = 0),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel... | null | true |
Lean.Core.Context.Cold.fileMap | Lean.CoreM | Lean.Core.Context.Cold → Lean.FileMap | Auxiliary datastructure for converting `String.Pos` into Line/Column number. | true |
Finsupp.mapRange.equiv_symm._proof_1 | Mathlib.Data.Finsupp.Defs | ∀ {M : Type u_1} {N : Type u_2} [inst : Zero M] [inst_1 : Zero N] (e : M ≃ N), e 0 = 0 → e.symm 0 = 0 | null | false |
WittVector.Isocrystal.recOn | Mathlib.RingTheory.WittVector.Isocrystal | {p : ℕ} →
[inst : Fact (Nat.Prime p)] →
{k : Type u_1} →
[inst_1 : CommRing k] →
[inst_2 : CharP k p] →
[inst_3 : PerfectRing k p] →
{V : Type u_2} →
[inst_4 : AddCommGroup V] →
{motive : WittVector.Isocrystal p k V → Sort u} →
(t... | null | false |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.parseSuggestionToTactic.match_1 | Mathlib.Tactic.TacticAnalysis.Declarations | (motive : Except String (Lean.TSyntax `Lean.Parser.Tactic.tacticSeq) → Sort u_1) →
(x : Except String (Lean.TSyntax `Lean.Parser.Tactic.tacticSeq)) →
((tacSeq : Lean.TSyntax `Lean.Parser.Tactic.tacticSeq) → motive (Except.ok tacSeq)) →
((err : String) → motive (Except.error err)) → motive x | null | false |
MeasureTheory.setLAverage_congr | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α} {f : α → ENNReal},
s =ᵐ[μ] t → ⨍⁻ (x : α) in s, f x ∂μ = ⨍⁻ (x : α) in t, f x ∂μ | null | true |
List.decidableInfix._proof_5 | Mathlib.Data.List.Infix | ∀ {α : Type u_1} (a : α) (l₁ s t : List α), s ++ a :: l₁ ++ t = [] → False | null | false |
Stream'.Seq.get?.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {α : Type u}, Stream'.Seq.get? = Subtype.val | null | true |
_private.Lean.Environment.0.Lean.Environment.setMainModule.unsafe_impl_2 | Lean.Environment | Lean.Environment → NonScalar | null | true |
_private.Lean.Meta.Tactic.Generalize.0.Lean.Meta.generalizeCore.go.match_1 | Lean.Meta.Tactic.Generalize | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → ((xName : Lean.Name) → motive (some xName)) → ((x : Option Lean.Name) → motive x) → motive x | null | false |
Filter.Tendsto.cauchy_map | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] {l : Filter β} [l.NeBot] {f : β → α} {a : α},
Filter.Tendsto f l (nhds a) → Cauchy (Filter.map f l) | null | true |
HasFDerivAt.add_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {f : E → F}
{f' : E →L[𝕜] F} {x : E} (c : F), HasFDerivAt f f' x → HasFDerivAt (fun x => f x + c) f' x | **Alias** of the reverse direction of `hasFDerivAt_add_const_iff`. | true |
alternatingGroup.coe_two_sylow_of_card_eq_four | Mathlib.GroupTheory.SpecificGroups.Alternating.KleinFour | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α],
Nat.card α = 4 → ∀ (S : Sylow 2 ↥(alternatingGroup α)), ↑S = {1} ∪ {g | (↑g).cycleType = {2, 2}} | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Nonsingular.0.SSet.instNonsingularNerve._simp_3 | Mathlib.AlgebraicTopology.SimplicialSet.Nonsingular | ∀ {K : Type u} [inst : CategoryTheory.Category.{v, u} K] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{F G : CategoryTheory.Functor K C} (f : F ⟶ G) [CategoryTheory.Limits.HasPullbacks C],
CategoryTheory.Mono f = ∀ (k : K), CategoryTheory.Mono (f.app k) | null | false |
Cardinal.cast_toNat_of_lt_aleph0 | Mathlib.SetTheory.Cardinal.ToNat | ∀ {c : Cardinal.{u_1}}, c < Cardinal.aleph0 → ↑(Cardinal.toNat c) = c | null | true |
MeasureTheory.Measure.map_sub_left_eq_self | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : SubtractionMonoid G] [MeasurableAdd G] [MeasurableNeg G]
(μ : MeasureTheory.Measure G) [μ.IsNegInvariant] [μ.IsAddLeftInvariant] (g : G),
MeasureTheory.Measure.map (fun t => g - t) μ = μ | null | true |
Filter.le_seq | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter (α → β)} {g : Filter α} {h : Filter β},
(∀ t ∈ f, ∀ u ∈ g, t.seq u ∈ h) → h ≤ f.seq g | null | true |
Std.ExtTreeMap.getKey!_ofList_of_contains_eq_false | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : BEq α] [Std.LawfulBEqCmp cmp]
[inst_3 : Inhabited α] {l : List (α × β)} {k : α},
(List.map Prod.fst l).contains k = false → (Std.ExtTreeMap.ofList l cmp).getKey! k = default | null | true |
_private.Mathlib.RingTheory.Polynomial.Dickson.0.Polynomial.dickson.match_1.splitter | Mathlib.RingTheory.Polynomial.Dickson | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → motive n.succ.succ) → motive x | null | true |
Homogenization.lift | Mathlib.LinearAlgebra.AffineSpace.Homogenization | {R : Type u_1} →
[inst : Ring R] →
{V : Type u_2} →
{P : Type u_3} →
[inst_1 : AddCommGroup V] →
[inst_2 : Module R V] →
[inst_3 : AddTorsor V P] →
{W : Type u_10} →
[inst_4 : AddCommGroup W] → [inst_5 : Module R W] → (P →ᵃ[R] W) ≃+ (Homogenization... | An affine map on `P` taking values in a vector space extends uniquely to a linear map on
`Homogenization R P`.
See also `Homogenization.liftₗ` for a version that is linear over some semiring. | true |
CategoryTheory.WithInitial.mkCommaMorphism_left | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
{F G : CategoryTheory.Functor (CategoryTheory.WithInitial C) D} (η : F ⟶ G),
(CategoryTheory.WithInitial.mkCommaMorphism η).left = η.app CategoryTheory.WithInitial.star | null | true |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.isCDot?._sparseCasesOn_1 | Mathlib.Tactic.Linter.Style | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
ProfiniteGrp.toFiniteQuotientFunctor._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u_1}) (H : OpenNormalSubgroup ↑P.toProfinite.toTop), (↑H.toOpenSubgroup).Normal | null | false |
Lean.Syntax.mkNameLit | Init.Meta.Defs | String → optParam Lean.SourceInfo Lean.SourceInfo.none → Lean.NameLit | Creates literal syntax for a name. The caller must ensure that the provided string is a valid name
literal.
If `info` is provided, then the literal's source information is copied from it.
| true |
CategoryTheory.PreGaloisCategory.fiberBinaryProductEquiv_symm_snd_apply | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.PreGaloisCategory C] [inst_2 : CategoryTheory.PreGaloisCategory.FiberFunctor F] {X Y : C}
(x : (F.obj X).obj) (y : (F.obj Y).obj),
(CategoryTheory.ConcreteCategory.hom (F.map CategoryTheo... | null | true |
SetSemiring.imageHom | Mathlib.Data.Set.Semiring | {α : Type u_1} →
{β : Type u_2} → [inst : MulOneClass α] → [inst_1 : MulOneClass β] → (α →* β) → SetSemiring α →+* SetSemiring β | The image of a set under a multiplicative homomorphism is a ring homomorphism
with respect to the pointwise operations on sets. | true |
instNSMulUniformFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_4} [inst : SMul M β],
instNSMulUniformFun = { smul := fun a a_1 => instNSMulUniformFun._aux_1 a_1 a } | null | true |
CategoryTheory.CommSq.coneUnop | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W X Y Z : Cᵒᵖ} →
{f : W ⟶ X} →
{g : W ⟶ Y} → {h : X ⟶ Z} → {i : Y ⟶ Z} → (p : CategoryTheory.CommSq f g h i) → p.cone.unop ≅ ⋯.cocone | The pushout cocone obtained from the pullback cone associated to a
commutative square in the opposite category identifies to the cocone associated
to the flipped square. | true |
QuadraticModuleCat.concreteCategory._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : QuadraticModuleCat R} (f : X.form →qᵢ Y.form),
{ toIsometry' := f }.toIsometry' = f | null | false |
ProbabilityTheory.condIndepFun_of_measurable_left | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {mβ : MeasurableSpace β}
{mβ' : MeasurableSpace β'} {X : Ω → β} {Y : Ω → β'},
Measurable X → Measurable Y → Probability... | null | true |
SimpleGraph.IsCompleteMultipartite.iso._proof_2 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u_1} {G : SimpleGraph α} (h : G.IsCompleteMultipartite)
(x : (i : Quotient h.setoid) × { x // h.setoid i.out x }),
h.setoid
⟦match x with
| ⟨fst, x⟩ => ↑x⟧.out
(match x with
| ⟨fst, x⟩ => ↑x) | null | false |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.size_insertMany_list._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
Algebra.Presentation.span_range_relation_eq_ker_baseChange | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(T : Type u_1) [inst_3 : CommRing T] [inst_4 : Algebra R T] (P : Algebra.Presentation R S ι σ),
Ideal.span (Set.range fun i => (MvPolynomial.map (algebraMap R T)) (P.relation i)) =
RingHom.ker ... | null | true |
DirichletCharacter.LFunctionTrivChar_eq_mul_riemannZeta | Mathlib.NumberTheory.LSeries.DirichletContinuation | ∀ {N : ℕ} [inst : NeZero N] {s : ℂ},
s ≠ 1 → DirichletCharacter.LFunctionTrivChar N s = (∏ p ∈ N.primeFactors, (1 - ↑p ^ (-s))) * riemannZeta s | The L function of the trivial Dirichlet character mod `N` is obtained from the Riemann
zeta function by multiplying with `∏ p ∈ N.primeFactors, (1 - (p : ℂ) ^ (-s))`. | true |
QuaternionGroup.a.sizeOf_spec | Mathlib.GroupTheory.SpecificGroups.Quaternion | ∀ {n : ℕ} (a : ZMod (2 * n)), sizeOf (QuaternionGroup.a a) = 1 + sizeOf a | null | true |
Isocrystal.«termΦ(_,_)» | Mathlib.RingTheory.WittVector.Isocrystal | Lean.ParserDescr | Project the Frobenius automorphism from an isocrystal. Denoted by `Φ(p, k)` when V can be inferred.
| true |
TopRep.Hom.ext | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u} {G : Type v} {inst : TopologicalSpace k} {inst_1 : Ring k} {inst_2 : Monoid G} {A : TopRep k G}
{B : TopRep k G} {x y : A.Hom B}, x.hom' = y.hom' → x = y | null | true |
Std.HashMap.all_eq_true_iff_forall_mem_getElem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] {p : α → β → Bool},
m.all p = true ↔ ∀ (a : α) (h : a ∈ m), p a m[a] = true | null | true |
Fin.lt_iff_val_lt_val._simp_1 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, (a < b) = (↑a < ↑b) | null | false |
Std.DHashMap.getD_insertMany_list_of_mem | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α]
{l : List ((a : α) × β a)} {k k' : α} (k_beq : (k == k') = true) {v : β k} {fallback : β k'},
List.Pairwise (fun a b => (a.fst == b.fst) = false) l → ⟨k, v⟩ ∈ l → (m.insertMany l).getD k' fallback = cast ⋯ v | null | true |
Sylow.ext | Mathlib.GroupTheory.Sylow | ∀ {p : ℕ} {G : Type u_1} [inst : Group G] {P Q : Sylow p G}, ↑P = ↑Q → P = Q | null | true |
_private.Mathlib.Algebra.Polynomial.Module.AEval.0.Module.AEval.annihilator_top_eq_ker_aeval._simp_1_2 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊤) = True | null | false |
RingCat.Colimits.Relation.zero_add | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J RingCat}
(x : RingCat.Colimits.Prequotient F), RingCat.Colimits.Relation F (RingCat.Colimits.Prequotient.zero.add x) x | null | true |
Std.TreeMap.Raw.getKey_alter | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[Inhabited α] (h : t.WF) {k k' : α} {f : Option β → Option β} {hc : k' ∈ t.alter k f},
(t.alter k f).getKey k' hc = if heq : cmp k k' = Ordering.eq then k else t.getKey k' ⋯ | null | true |
CategoryTheory.Adjunction.restrictFullyFaithful | Mathlib.CategoryTheory.Adjunction.Restrict | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{C' : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C'] →
{D' : Type u₄} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} D'] →
... | If `C` is a full subcategory of `C'` and `D` is a full subcategory of `D'`, then we can restrict
an adjunction `L' ⊣ R'` where `L' : C' ⥤ D'` and `R' : D' ⥤ C'` to `C` and `D`.
The construction here is slightly more general, in that `C` is required only to have a full and
faithful "inclusion" functor `iC : C ⥤ C'` (and... | true |
ProjectiveSpectrum.gc_homogeneousIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜],
GaloisConnection (fun I => ProjectiveSpectrum.zeroLocus 𝒜 ↑I) fun t => ProjectiveSpectrum.vanishingIdeal t | null | true |
Filter.exists_iInter_of_mem_iInf | Mathlib.Order.Filter.Finite | ∀ {ι : Sort u_1} {α : Type u_2} {f : ι → Filter α} {s : Set α},
s ∈ ⨅ i, f i → ∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ i, t i | null | true |
CategoryTheory.Functor.PreservesPointwiseLeftKanExtensionAt.mk._flat_ctor | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] {G : CategoryTheory.Functor B D} {F : CategoryTheory.Functor A B... | null | false |
HomotopicalAlgebra.Fibration.mk | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : HomotopicalAlgebra.CategoryWithFibrations C],
HomotopicalAlgebra.fibrations C f → HomotopicalAlgebra.Fibration f | null | true |
Finset.compls_eq_empty._simp_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {s : Finset α}, (s.compls = ∅) = (s = ∅) | null | false |
ContinuousLinearMap.IsStarNormal.adjoint_apply_eq_zero_iff | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →L[𝕜] E} [inst_3 : CompleteSpace E],
IsStarNormal T → ∀ (x : E), (ContinuousLinearMap.adjoint T) x = 0 ↔ T x = 0 | null | true |
Lean.Elab.Command.ComputedFieldView | Lean.Elab.MutualInductive | Type | null | true |
Lean.Compiler.LCNF.mkCasesResultType | Lean.Compiler.LCNF.InferType | {pu : Lean.Compiler.LCNF.Purity} → Array (Lean.Compiler.LCNF.Alt pu) → Lean.Compiler.LCNF.CompilerM Lean.Expr | null | true |
WeakDual.extendRCLikeL._proof_14 | Mathlib.Analysis.Normed.Module.WeakDual | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[inst_3 : TopologicalSpace F] [inst_4 : ContinuousConstSMul 𝕜 F] [inst_5 : Module ℝ F] [inst_6 : IsScalarTower ℝ 𝕜 F],
Continuous
(WeakDual.toStrongDual ≪≫ₗ StrongDual.extendRCLikeₗ ≪≫ₗ LinearEquiv.restrictSca... | null | false |
CategoryTheory.Limits.Cone.isLimitOfIsIsoLimMapπ._proof_2 | Mathlib.CategoryTheory.Limits.Connected | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.IsConnected J]
{F : CategoryTheory.Functor J C} [inst_3 : CategoryTheory.Limits.HasLimit F] (c : CategoryTheory.Limits.Cone F)
[inst_4 : CategoryTheory.IsIso (Cate... | null | false |
_private.Mathlib.Order.SupIndep.0.Finset.SupIndep.biUnion._proof_1_2 | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_2} {ι' : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq ι]
{s : Finset ι'} {g : ι' → Finset ι} {f : ι → α} ⦃b : ι⦄ (i' : ι'),
((s.erase i').biUnion g ∪ (g i').erase b).sup f ≤ ((s.erase i').sup fun i => (g i).sup f) ⊔ ((g i').erase b).sup f | null | false |
MeasurableSpace.instCountableOrCountablyGeneratedProd | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {β : Type u_2} {α : Type u_3} {γ : Type u_4} [inst : MeasurableSpace γ]
[hα : MeasurableSpace.CountableOrCountablyGenerated α γ] [hβ : MeasurableSpace.CountableOrCountablyGenerated β γ],
MeasurableSpace.CountableOrCountablyGenerated (α × β) γ | null | true |
NonUnitalSubring.closure_union | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s t : Set R),
NonUnitalSubring.closure (s ∪ t) = NonUnitalSubring.closure s ⊔ NonUnitalSubring.closure t | null | true |
CategoryTheory.ObjectProperty.opEquivalence | Mathlib.CategoryTheory.ObjectProperty.Opposite | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(P : CategoryTheory.ObjectProperty C) → P.op.FullSubcategory ≌ P.FullSubcategoryᵒᵖ | Given `P : ObjectProperty C`, this is the equivalence between `P.op.FullSubcategory`
and `P.FullSubcategoryᵒᵖ`. | true |
integral_re | Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap | ∀ {X : Type u_1} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} {𝕜 : Type u_6} [inst_1 : RCLike 𝕜]
{f : X → 𝕜}, MeasureTheory.Integrable f μ → ∫ (x : X), RCLike.re (f x) ∂μ = RCLike.re (∫ (x : X), f x ∂μ) | null | true |
AlgebraicGeometry.opensDiagramι_app | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u} [inst : CategoryTheory.Category.{u, u} I] (D : CategoryTheory.Functor I AlgebraicGeometry.Scheme) (i : I)
(U : (D.obj i).Opens) (j : CategoryTheory.Over i),
(AlgebraicGeometry.opensDiagramι D i U).app j = ((TopologicalSpace.Opens.map (D.map j.hom).base).obj U).ι | null | true |
_private.Lean.Meta.Instances.0.Lean.Meta.addInstanceEntry.match_1 | Lean.Meta.Instances | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → ((n : Lean.Name) → motive (some n)) → (Unit → motive none) → motive x | null | false |
Manifold.LocalPresentationAt.mk.inj | Mathlib.Geometry.Manifold.LocalSourceTargetProperty | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_4} {H : Type u_6} {G : Type u_8} {inst : NontriviallyNormedField 𝕜}
{inst_1 : NormedAddCommGroup E} {inst_2 : NormedSpace 𝕜 E} {inst_3 : NormedAddCommGroup F} {inst_4 : NormedSpace 𝕜 F}
{inst_5 : TopologicalSpace H} {inst_6 : TopologicalSpace G} {I : ModelWithCorners ... | null | true |
CategoryTheory.nerve.representableBy._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {n : ℕ} (α : Type u_1) [inst : Preorder α] (e : α ≃o Fin (n + 1)) {X : SimplexCategory}
(F : CategoryTheory.Functor (Fin (X.len + 1)) (Fin ({ len := n }.len + 1))) (x : Fin (X.len + 1)),
((fun F => CategoryTheory.Functor.comp F ⋯.functor) ((fun F => F.comp ⋯.functor) F)).obj x = F.obj x | null | false |
_private.Mathlib.RingTheory.DualNumber.0.DualNumber.ideal_trichotomy._simp_1_4 | Mathlib.RingTheory.DualNumber | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (∃ c, b = a * c) = (a ∣ b) | null | false |
FreeAddGroup.freeAddGroupCongr_symm | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β),
(FreeAddGroup.freeAddGroupCongr e).symm = FreeAddGroup.freeAddGroupCongr e.symm | null | true |
AlgebraicGeometry.SheafedSpace.GlueData.isoPresheafedSpace._proof_1 | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (D : AlgebraicGeometry.SheafedSpace.GlueData C)
[CategoryTheory.Limits.HasLimits C], CategoryTheory.Limits.HasColimit D.diagram.multispan | null | false |
EReal.add_eq_bot_iff._simp_1 | Mathlib.Data.EReal.Operations | ∀ {x y : EReal}, (x + y = ⊥) = (x = ⊥ ∨ y = ⊥) | null | false |
FiberBundleCore.fiberBundle._proof_1 | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_2} {B : Type u_3} {F : Type u_1} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (b : B) (x : Z.Fiber b), nhds x = Filter.comap (Bundle.TotalSpace.mk b) (nhds ⟨b, x⟩) | null | false |
CategoryTheory.Limits.preservesTerminal_of_iso | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Terminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) [inst_2 : CategoryTheory.Limits.HasTerminal C]
[inst_3 : CategoryTheory.Limits.HasTerminal D] (f : G.obj (⊤_ C) ≅ ⊤_ D),
CategoryTheory.Limits.PreservesLimit (Ca... | If there is any isomorphism `G.obj ⊤ ≅ ⊤`, then `G` preserves terminal objects. | true |
IO.instDecidableEqTaskState | Init.System.IO | DecidableEq IO.TaskState | null | true |
Matroid.IsBasis.isBase_restrict | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis I X → (M.restrict X).IsBase I | null | true |
Algebra.TensorProduct.liftEquiv._proof_2 | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_5} {S : Type u_4} {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommSemiring R]
[inst_1 : CommSemiring S] [inst_2 : Algebra R S] [inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A]
[inst_6 : IsScalarTower R S A] [inst_7 : Semiring B] [inst_8 : Algebra R B] [inst_9 : Semiring C]
... | null | false |
Specialization.rec | Mathlib.Topology.Specialization | {α : Type u_1} →
{β : Specialization α → Sort u_4} → ((a : α) → β (Specialization.toEquiv a)) → (a : Specialization α) → β a | A recursor for `Specialization`. Use as `induction x`. | true |
Algebra.denominator_def | Mathlib.RingTheory.Algebraic.Denominator | ∀ (R : Type u_1) {S : Type u_2} [inst : CommRing R] [inst_1 : IsPrincipalIdealRing R] [inst_2 : CommRing S]
[inst_3 : Algebra R S] (x : S),
Algebra.denominator R x = Submodule.IsPrincipal.generator ((Subalgebra.toSubmodule (integralClosure R S)).colon {x}) | null | true |
Set.instFintypeIic.eq_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Set.instFintypeIic a = Fintype.ofFinset (Finset.Iic a) ⋯ | null | true |
CategoryTheory.Triangulated.TStructure.instIsIsoMapTruncLEAppTruncLEι | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {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]
(t : CategoryT... | null | true |
_private.Mathlib.CategoryTheory.CommSq.0.CategoryTheory.CommSq.unop._simp_1_1 | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.unop f.unop = (CategoryTheory.CategoryStruct.comp f g).unop | null | false |
isNoetherian_span_of_finite | Mathlib.RingTheory.Noetherian.Basic | ∀ (R : Type u_1) {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsNoetherianRing R]
{A : Set M}, A.Finite → IsNoetherian R ↥(Submodule.span R A) | In a module over a Noetherian ring, the submodule generated by finitely many vectors is
Noetherian. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.