name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.SymmetricCategory.recOn | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{motive : CategoryTheory.SymmetricCategory C → Sort u_1} →
(t : CategoryTheory.SymmetricCategory C) →
([toBraidedCategory : CategoryTheory.BraidedCategory C] →
(symmetry ... | null | false |
Lean.Omega.LinearCombo.coordinate_eval_0 | Init.Omega.LinearCombo | ∀ {a0 : ℤ} {t : List ℤ}, (Lean.Omega.LinearCombo.coordinate 0).eval (Lean.Omega.Coeffs.ofList (a0 :: t)) = a0 | null | true |
Bundle.Pretrivialization.linearMapAt_def_of_notMem | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : AddCommMonoid F] [inst_4 : Module R F]
[inst_5 : (x : B) → AddCommMonoid (E x)] [inst_6 : (x : B) → Module R (E x)]
(e : Bundle.Pretrivialization F Bundle.Tot... | null | true |
AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.isLocallyFraction | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
TopCat.LocalPredicate fun x => HomogeneousLocalization.AtPrime 𝒜 x.asHomogeneousIdeal.toIdeal | We will define the structure sheaf as the subsheaf of all dependent functions in
`Π x : U, HomogeneousLocalization 𝒜 x` consisting of those functions which can locally be expressed
as a ratio of `A` of same grading. | true |
List.eq_nil_of_map_eq_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, List.map f l = [] → l = [] | null | true |
ContDiffOn.inv | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : WithTop ℕ∞} {𝕜' : Type u_4} [inst_3 : NormedField 𝕜']
[inst_4 : NormedAlgebra 𝕜 𝕜'] {f : E → 𝕜'}, ContDiffOn 𝕜 n f s → (∀ x ∈ s, f x ≠ 0) → ContDiffOn 𝕜 n f⁻¹ s | null | true |
Lean.Elab.ContextInfo.parentDecl?._default | Lean.Elab.InfoTree.Types | Option Lean.Name | null | false |
TensorPower.multilinearMapToDual._proof_4 | Mathlib.LinearAlgebra.TensorPower.Pairing | ∀ (R : Type u_1) [inst : CommSemiring R], SMulCommClass R R R | null | false |
CategoryTheory.Limits.filteredColimitsModule._proof_1 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.IsFiltered C]
(R : CategoryTheory.Functor C RingCat) (M : CategoryTheory.Functor C Ab)
[inst_2 : (i : C) → Module ↑(R.obj i) ↑(M.obj i)]
(H :
∀ {i j : C} (f : i ⟶ j) (r : ↑(R.obj i)) (m : ↑(M.obj i)),
(CategoryTheory.Concr... | null | false |
HeytAlg.ofHom_id | Mathlib.Order.Category.HeytAlg | ∀ {X : Type u} [inst : HeytingAlgebra X], HeytAlg.ofHom (HeytingHom.id X) = CategoryTheory.CategoryStruct.id ↧X | null | true |
CategoryTheory.OplaxFunctor.comp | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{D : Type u₃} →
[inst_2 : CategoryTheory.Bicategory D] →
CategoryTheory.OplaxFunctor B C → CategoryTheory.OplaxFunctor C D → CategoryTheory.OplaxFunctor B D | Composition of oplax functors. | true |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.msgToInteractive.match_3 | Lean.Widget.InteractiveDiagnostic | (motive : Lean.Widget.EmbedFmt✝ → Sort u_1) →
(x : Lean.Widget.EmbedFmt✝) →
((ctx : Lean.Elab.ContextInfo) →
(infos : Std.TreeMap ℕ Lean.Elab.Info compare) → motive (Lean.Widget.EmbedFmt.code✝ ctx infos)) →
((ctx : Lean.Elab.ContextInfo) →
(lctx : Lean.LocalContext) → (g : Lean.MVarId) → m... | null | false |
CategoryTheory.Reflective.casesOn | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Reflective R → Sort u} →
(t : CategoryTheory.Reflective R) →
([toFull : R.Full... | null | false |
AddMonCat.of | Mathlib.Algebra.Category.MonCat.Basic | (M : Type u) → [AddMonoid M] → AddMonCat | Construct a bundled `AddMonCat` from the underlying type and typeclass. | true |
Associates.FactorSet.prod | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {α : Type u_1} → [inst : CommMonoidWithZero α] → Associates.FactorSet α → Associates α | Evaluates the product of a `FactorSet` to be the product of the corresponding multiset,
or `0` if there is none. | true |
Module.subsingleton_of_rank_zero | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M]
[StrongRankCondition R], Module.rank R M = 0 → Subsingleton M | A free module of rank zero is trivial. | true |
List.length_product | Mathlib.Data.List.ProdSigma | ∀ {α : Type u_1} {β : Type u_2} (l₁ : List α) (l₂ : List β), (l₁ ×ˢ l₂).length = l₁.length * l₂.length | null | true |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.crown._proof_1_2 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {k₁ k₂ : C} {ι : Type u_3} (j : Option ι → C)
(f : (i : Option ι) → j i ⟶ k₁) (g : (i : Option ι) → j i ⟶ k₂) (s₁ : C) (α₁ : k₁ ⟶ s₁) (β₁ : k₂ ⟶ s₁),
(∀ (i : ι), CategoryTheory.CategoryStruct.comp (f (some i)) α₁ = CategoryTheory.CategoryStruct.comp (g ... | null | false |
_private.Mathlib.Algebra.Lie.Weights.Killing.0.LieAlgebra.IsKilling.corootSpace_eq_bot_iff._simp_1_1 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M), (N = ⊥) = (↑N = ⊥) | null | false |
FirstOrder.Language.IsRelational | Mathlib.ModelTheory.Basic | FirstOrder.Language → Prop | A language is relational when it has no function symbols. | true |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_12 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊥) = (x = 0) | null | false |
isZGroup_of_coprime | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} {G' : Type u_2} {G'' : Type u_3} [inst : Group G] [inst_1 : Group G'] [inst_2 : Group G'']
{f : G →* G'} {f' : G' →* G''} [Finite G] [IsZGroup G] [IsZGroup G''],
f'.ker ≤ f.range → (Nat.card G).Coprime (Nat.card G'') → IsZGroup G' | An extension of coprime Z-groups is a Z-group. | true |
Submodule.map.congr_simp | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] (f f_1 : M →ₛₗ[σ₁₂] M₂),
f = f_1 → ∀ (p p_1 : Submodule ... | null | true |
Lean.instToExprListOfToLevel | Lean.ToExpr | {α : Type u} → [Lean.ToLevel] → [Lean.ToExpr α] → Lean.ToExpr (List α) | null | true |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_obj_left_right_as | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor T D) (Y : D) (X : T)
(Y_1 : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X),
((CategoryTheory.CostructuredArrow.ofCostructuredArrowPro... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Operations.0.SimpleGraph.Walk.dropLast_support_concat.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v_1 : V} (h : G.Adj u v_1) (p : G.Walk v_1 v)
(motive : (∃ x q, ∃ (h' : G.Adj x v), SimpleGraph.Walk.cons h p = q.concat h') → Prop)
(x : ∃ x q, ∃ (h' : G.Adj x v), SimpleGraph.Walk.cons h p = q.concat h'),
(∀ (w : V) (w_1 : G.Walk u w) (w_2 : G.Adj w v) (hp : SimpleGraph... | null | false |
Order.krullDim_eq_zero | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α] [Subsingleton α], Order.krullDim α = 0 | null | true |
AlgebraicGeometry.Scheme.AffineCover.noConfusionType | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | Sort u_1 →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S : AlgebraicGeometry.Scheme} →
AlgebraicGeometry.Scheme.AffineCover P S →
{P' : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S' : AlgebraicGeometry.Scheme} → AlgebraicGeometry.Scheme.AffineCover P... | null | false |
MvPowerSeries.coeff_index_single_self_X | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (s : σ), (MvPowerSeries.coeff fun₀ | s => 1) (MvPowerSeries.X s) = 1 | null | true |
CategoryTheory.ShortComplex.moduleCat_exact_iff | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
S.Exact ↔
∀ (x₂ : ↑S.X₂),
(CategoryTheory.ConcreteCategory.hom S.g) x₂ = 0 → ∃ x₁, (CategoryTheory.ConcreteCategory.hom S.f) x₁ = x₂ | null | true |
Algebra.HasSeparableResidueFieldsAt.isSeparable_quotient | Mathlib.RingTheory.LocalRing.ResidueField.Separable | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (p : Ideal A)
[inst_3 : p.IsMaximal] [Algebra.HasSeparableResidueFieldsAt A B p] (q : Ideal B) [q.IsMaximal]
[inst_6 : q.LiesOver p], Algebra.IsSeparable (A ⧸ p) (B ⧸ q) | At a maximal prime `p`, `Algebra.HasSeparableResidueFieldsAt` also gives the separability of
the extension of quotient rings `(B ⧸ q)/(A ⧸ p)` for every maximal ideal `q` of `B` lying over
`p`. Maximality is needed for the quotient rings to be fields; they are then canonically
isomorphic to the residue fields. | true |
CategoryTheory.IsCofiltered.nonempty | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.IsCofiltered C], Nonempty C | a cofiltered category must be non-empty | true |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.splitStr | Lean.Server.FileWorker.SemanticHighlighting | Lean.FileMap → Lean.Syntax → Array Lean.Syntax | Split the token at newline boundaries to support LSP clients such as VS Code that can't deal with
newline-spanning tokens.
| true |
Lean.Widget.inst._@.Lean.Widget.Basic.2038268869._hygCtx._hyg.3 | Lean.Widget.Basic | TypeName Lean.Elab.InfoWithCtx | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate.noConfusionType | Lean.Meta.Tactic.Grind.Split | Sort u → Lean.Meta.Grind.SplitCandidate✝ → Lean.Meta.Grind.SplitCandidate✝ → Sort u | null | false |
Computation.think.eq_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u} (c : Computation α), c.think = ⟨Stream'.cons none ↑c, ⋯⟩ | null | true |
CategoryTheory.Retract.op_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Retract X Y), h.op.i = h.r.op | null | true |
HeytingHom.mk | Mathlib.Order.Heyting.Hom | {α : Type u_6} →
{β : Type u_7} →
[inst : HeytingAlgebra α] →
[inst_1 : HeytingAlgebra β] →
(toLatticeHom : LatticeHom α β) →
toLatticeHom.toFun ⊥ = ⊥ →
(∀ (a b : α), toLatticeHom.toFun (a ⇨ b) = toLatticeHom.toFun a ⇨ toLatticeHom.toFun b) → HeytingHom α β | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.isHashSelf_filterMapₘ._simp_1_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | null | false |
Std.DHashMap.isEmpty_insertMany_list | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)}, (m.insertMany l).isEmpty = (m.isEmpty && l.isEmpty) | null | true |
Matrix.eq_zero_of_vecMul_eq_zero | Mathlib.LinearAlgebra.Matrix.Nondegenerate | ∀ {m : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : Fintype m] [inst_2 : DecidableEq m] {M : Matrix m m R}
[NoZeroDivisors R], M.det ≠ 0 → ∀ {v : m → R}, Matrix.vecMul v M = 0 → v = 0 | null | true |
CategoryTheory.Functor.WellOrderInductionData.Extension.mk.injEq | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type v)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} {j : J}
(val : F.obj (Opposite.op j))
(map_zero : (CategoryTheory.ConcreteCategory.hom (F.map (CategoryTheory.homOfLE ⋯).op)) v... | null | true |
Std.TreeMap.Raw.Equiv.insertManyIfNewUnit_list | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {t₁ t₂ : Std.TreeMap.Raw α Unit cmp},
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (l : List α), (t₁.insertManyIfNewUnit l).Equiv (t₂.insertManyIfNewUnit l) | null | true |
CategoryTheory.Limits.spanExt_inv_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z X' Y' Z' : C} (iX : X ≅ X') (iY : Y ≅ Y') (iZ : Z ≅ Z')
{f : X ⟶ Y} {g : X ⟶ Z} {f' : X' ⟶ Y'} {g' : X' ⟶ Z'}
(wf : CategoryTheory.CategoryStruct.comp iX.hom f' = CategoryTheory.CategoryStruct.comp f iY.hom)
(wg : CategoryTheory.CategoryStruct.comp i... | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs.0.IsLinearSet.closure._simp_1_4 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | null | false |
CategoryTheory.IsAccessibleCategory.rec | Mathlib.CategoryTheory.Presentable.LocallyPresentable | {C : Type u} →
[hC : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.IsAccessibleCategory.{w, v, u} C → Sort u_1} →
((exists_cardinal : ∃ κ, ∃ (x : Fact κ.IsRegular), CategoryTheory.IsCardinalAccessibleCategory C κ) → motive ⋯) →
(t : CategoryTheory.IsAccessibleCategory.{w, v, u} C) → m... | null | false |
Std.Net.SocketAddressV6.mk | Std.Net.Addr | Std.Net.IPv6Addr → UInt16 → Std.Net.SocketAddressV6 | null | true |
IntermediateField.isIntegral_iff | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {S : IntermediateField K L}
{x : ↥S}, IsIntegral K x ↔ IsIntegral K ↑x | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit.0.CochainComplex.mappingConeHomOfDegreewiseSplitIso._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | ∀ (p : ℤ), p + 1 + 1 + -1 = p + 1 | null | false |
Nat.gcd_sub_mul_right_right | Init.Data.Nat.Gcd | ∀ {m n k : ℕ}, k * m ≤ n → m.gcd (n - k * m) = m.gcd n | null | true |
SimpleGraph.pathGraph3ComplEmbeddingOf._proof_1 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u_1} {G : SimpleGraph α} (h : ¬G.IsCompleteMultipartite), ∃ w₁ w₂, G.IsPathGraph3Compl ⋯.choose w₁ w₂ | null | false |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_3.splitter | Std.Data.Iterators.Lemmas.Producers.Monadic.List | {m : Type u_1 → Type u_2} →
{α : Type u_1} →
(motive : Std.IterM m α → Sort u_3) →
(it : Std.IterM m α) →
(Unit → motive { internalState := { list := [] } }) →
((x : α) → (xs : List α) → motive { internalState := { list := x :: xs } }) → motive it | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.support_antitone | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Antitone AlgebraicGeometry.Scheme.IdealSheafData.support | null | true |
Int64.toInt_sub | Init.Data.SInt.Lemmas | ∀ (a b : Int64), (a - b).toInt = (a.toInt - b.toInt).bmod (2 ^ 64) | null | true |
CategoryTheory.is_coprod_iff_isPushout | Mathlib.CategoryTheory.Adhesive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X E Y YE : C} (c : CategoryTheory.Limits.BinaryCofan X E)
(hc : CategoryTheory.Limits.IsColimit c) {f : X ⟶ Y} {iY : Y ⟶ YE} {fE : c.pt ⟶ YE},
CategoryTheory.CommSq f c.inl iY fE →
(Nonempty
(CategoryTheory.Limits.IsColimit
(CategoryThe... | null | true |
Algebra.TensorProduct.algHomOfLinearMapTensorProduct._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_1} {S : Type u_2} {A : 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] [IsScalarTower R S A], SMulCommClass R S A | null | false |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_6 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x | null | false |
CategoryTheory.CatCenter.localizationRingHom | Mathlib.CategoryTheory.Center.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →
[inst_3 : CategoryTheory.Preadditive C... | The morphism of rings `CatCenter C →+* CatCenter D` when `L : C ⥤ D`
is an additive localization functor between preadditive categories. | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary._proof_3 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ),
acc + ↑(Std.Time.Month.Ordinal.days leap idx) - acc = ↑(Std.Time.Month.Ordinal.days leap idx) | null | false |
Matroid.contract_inter_ground_eq | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} (M : Matroid α) (C : Set α), M.contract (C ∩ M.E) = M.contract C | null | true |
Pell.Solution₁.instCommGroup._proof_5 | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a b c : Pell.Solution₁ d), a * b * c = a * (b * c) | null | false |
Commute.isNilpotent_mul_left_iff | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_1} {x y : R} [inst : Semiring R],
Commute x y → x ∈ nonZeroDivisorsLeft R → (IsNilpotent (x * y) ↔ IsNilpotent y) | null | true |
Std.DHashMap.Internal.Raw₀.insertIfNew_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α} {v : β k}, (↑(m₁.insertIfNew k v)).Equiv ↑(m₂.insertIfNew k v) | null | true |
_private.Mathlib.Data.Set.Image.0.Set.preimage_eq_empty_iff._simp_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
CategoryTheory.AddMon.Hom.recOn | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.AddMon C} →
{motive : M.Hom N → Sort u} →
(t : M.Hom N) →
((hom : M.X ⟶ N.X) →
[isAddMonHom_hom : CategoryTheory.IsAddMonHom hom] →... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.inter_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
AddCircle.gcd_mul_addOrderOf_div_eq | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (p : 𝕜) [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [hp : Fact (0 < p)] {n : ℕ}
(m : ℕ), 0 < n → m.gcd n * addOrderOf ↑(↑m / ↑n * p) = n | null | true |
IsCompact.locallyCompactSpace_of_mem_nhds_of_group | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {K : Set G},
IsCompact K → ∀ {x : G}, K ∈ nhds x → LocallyCompactSpace G | If a point in a topological group has a compact neighborhood, then the group is
locally compact. | true |
ringChar.of_eq | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] {p : ℕ}, ringChar R = p → CharP R p | null | true |
Std.Internal.Parsec.ParseResult.success.noConfusion | Std.Internal.Parsec.Basic | {α ι : Type} →
{P : Sort u} →
{pos : ι} →
{res : α} →
{pos' : ι} →
{res' : α} →
Std.Internal.Parsec.ParseResult.success pos res = Std.Internal.Parsec.ParseResult.success pos' res' →
(pos ≍ pos' → res ≍ res' → P) → P | null | false |
WittVector.poly_eq_of_wittPolynomial_bind_eq | Mathlib.RingTheory.WittVector.IsPoly | ∀ (p : ℕ) [Fact (Nat.Prime p)] (f g : ℕ → MvPolynomial ℕ ℤ),
(∀ (n : ℕ), (MvPolynomial.bind₁ f) (wittPolynomial p ℤ n) = (MvPolynomial.bind₁ g) (wittPolynomial p ℤ n)) → f = g | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.σ_σ₀Iter'._proof_1_11 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i : ℕ) {n : ℕ}, i = 0 → n + 1 + i = n + 1 | null | false |
TwoSidedIdeal.orderIsoIsTwoSided_symm_apply | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : { I // I.IsTwoSided }),
(RelIso.symm TwoSidedIdeal.orderIsoIsTwoSided) I =
have this := ⋯;
(↑I).toTwoSided | null | true |
IsPreconnected.eq_one_or_eq_neg_one_of_sq_eq | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} {𝕜 : Type u_3} {f : α → 𝕜} {S : Set α} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace 𝕜]
[T1Space 𝕜] [inst_3 : Ring 𝕜] [NoZeroDivisors 𝕜],
IsPreconnected S → ContinuousOn f S → Set.EqOn (f ^ 2) 1 S → Set.EqOn f 1 S ∨ Set.EqOn f (-1) S | If `f` is a function `α → 𝕜` which is continuous on a preconnected set `S`, and
`f ^ 2 = 1` on `S`, then either `f = 1` on `S`, or `f = -1` on `S`. | true |
Std.DHashMap.Raw.toList_insert_perm | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k : α} {v : β k},
(m.insert k v).toList.Perm (⟨k, v⟩ :: List.filter (fun x => decide ¬(k == x.fst) = true) m.toList) | null | true |
Fin.preimage_natAdd_uIoc_natAdd | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n), Fin.natAdd m ⁻¹' Set.uIoc (Fin.natAdd m i) (Fin.natAdd m j) = Set.uIoc i j | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Span.Basic.0.CategoryTheory.Span.SpanBicat.associator._proof_9 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
CategoryTheory.Functor.CoconeTypes.IsColimit.equiv.congr_simp | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimit), hc.equiv = hc.equiv | null | true |
LieRinehartSubalgebra.lieAlgebra._proof_1 | Mathlib.Algebra.LieRinehartAlgebra.Subalgebra | ∀ {A : Type u_2} {L : Type u_1} [inst : CommRing A] [inst_1 : LieRing L] [inst_2 : Module A L],
AddSubmonoidClass (LieRinehartSubalgebra A L) L | null | false |
Lean.Parser.TokenCacheEntry.startPos._default | Lean.Parser.Types | String.Pos.Raw | null | false |
_private.Mathlib.Util.AtomM.Recurse.0.Mathlib.Tactic.AtomM.Recurse.instBEqConfig.beq.match_1 | Mathlib.Util.AtomM.Recurse | (motive : Mathlib.Tactic.AtomM.Recurse.Config → Mathlib.Tactic.AtomM.Recurse.Config → Sort u_1) →
(x x_1 : Mathlib.Tactic.AtomM.Recurse.Config) →
((a : Lean.Meta.TransparencyMode) →
(a_1 a_2 : Bool) →
(b : Lean.Meta.TransparencyMode) →
(b_1 b_2 : Bool) →
motive { red :=... | null | false |
ContMDiffWithinAt.clm_postcomp | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : 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] {F₁ : Type u_8} [inst_6 : NormedAddComm... | null | true |
IsClub.isStationary | Mathlib.SetTheory.Cardinal.Cofinality.Club | ∀ {α : Type v} {s : Set α} [inst : LinearOrder α] [WellFoundedLT α] [Nonempty α],
Order.cof α ≠ Cardinal.aleph0 → IsClub s → IsStationary s | null | true |
FirstOrder.Language.Substructure.closure_induction | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {s : Set M} {p : M → Prop} {x : M},
x ∈ (FirstOrder.Language.Substructure.closure L).toFun s →
(∀ x ∈ s, p x) → (∀ {n : ℕ} (f : L.Functions n), FirstOrder.Language.ClosedUnder f (Set.ofPred p)) → p x | An induction principle for closure membership. If `p` holds for all elements of `s`, and
is preserved under function symbols, then `p` holds for all elements of the closure of `s`. | true |
Equiv.compl | Mathlib.Order.OrderDual | {α : Type u_1} → {β : Type u_2} → α ≃ β → [Compl β] → Compl α | Transfer `Compl` across an `Equiv`. | true |
String.utf8ByteSize_sliceFrom | Init.Data.String.Basic | ∀ {s : String} {p : s.Pos}, (s.sliceFrom p).utf8ByteSize = s.utf8ByteSize - p.offset.byteIdx | null | true |
Mathlib.Tactic.Conv.Path.ctorElimType | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} → ℕ → Sort (max 1 u) | null | false |
_private.Mathlib.Geometry.Convex.Cone.Pointed.0.PointedCone.le_hull_singleton_iff._simp_1_1 | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
OrderMonoidHom.fst._proof_1 | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : Monoid α] [inst_1 : PartialOrder α] [inst_2 : Monoid β] [inst_3 : Preorder β],
Monotone ⇑(MonoidHom.fst α β) | null | false |
_private.Std.Data.TreeSet.Lemmas.0.Std.TreeSet.size_toArray._simp_1_1 | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp}, t.toArray = t.toList.toArray | null | false |
Inclusion.InclusionFamily.mk.inj | Mathlib.Tactic.Inclusion.Core.Extensions | ∀ {inclusionExt : DiscrTreeExt.EnvExt Inclusion.InclusionExt}
{hypothesisExt : DiscrTreeExt.EnvExt Inclusion.HypothesisExt}
{inclusionExt_1 : DiscrTreeExt.EnvExt Inclusion.InclusionExt}
{hypothesisExt_1 : DiscrTreeExt.EnvExt Inclusion.HypothesisExt},
{ inclusionExt := inclusionExt, hypothesisExt := hypothesisEx... | null | true |
Set.preimage_const | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} (b : β) (s : Set β) [inst : Decidable (b ∈ s)],
(fun x => b) ⁻¹' s = if b ∈ s then Set.univ else ∅ | null | true |
Multiset.union_le_iff | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Multiset α}, s ∪ t ≤ u ↔ s ≤ u ∧ t ≤ u | null | true |
genericPoint_specializes | Mathlib.Topology.Sober | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : QuasiSober α] [inst_2 : IrreducibleSpace α] (x : α),
genericPoint α ⤳ x | null | true |
OrderMonoidWithZeroHom._sizeOf_inst | Mathlib.Algebra.Order.Hom.MonoidWithZero | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : MulZeroOneClass α} → {inst_3 : MulZeroOneClass β} → [SizeOf α] → [SizeOf β] → SizeOf (α →*₀o β) | null | false |
Mathlib.Meta.NormNum.Result.toSimpResult.match_1 | Mathlib.Tactic.NormNum.Result | {u : Lean.Level} →
{α : Q(Type u)} →
{e : Q(«$α»)} →
(motive : (e' : Q(«$α»)) × Q(«$e» = «$e'») → Sort u_1) →
(x : (e' : Q(«$α»)) × Q(«$e» = «$e'»)) →
((expr : Q(«$α»)) → (proof? : Q(«$e» = «$expr»)) → motive ⟨expr, proof?⟩) → motive x | null | false |
PositiveLinearMap.gnsStarAlgHom._proof_13 | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : StarOrderedRing A] (f : A →ₚ[ℂ] ℂ),
IsTopologicalAddGroup f.GNS | null | false |
Batteries.BinomialHeap.Imp.Heap.headD._f | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
(α → α → Bool) →
(x : Batteries.BinomialHeap.Imp.Heap α) → Batteries.BinomialHeap.Imp.Heap.below (motive := fun x => α → α) x → α → α | null | false |
SSet.N.mk_surjective | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} (x : X.N), ∃ n y, x = SSet.N.mk ↑y ⋯ | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Cell.Const.get?.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_2} →
{β : Type u_1} →
(motive : Option ((_ : α) × β) → Sort u_3) →
(x : Option ((_ : α) × β)) → (Unit → motive none) → ((p : (_ : α) × β) → motive (some p)) → motive x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.