name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_filterMap_eq_size_iff._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Algebra.TensorProduct.piScalarRight_tmul_apply | Mathlib.RingTheory.TensorProduct.Pi | ∀ (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] [inst_6 : IsScalarTower R S A] {ι : Type u_4}
[inst_7 : Fintype ι] [inst_8 : DecidableEq ι] (x : A) (y : ι → R) (i : ι),
(Alge... | null | true |
OrderIso.locallyFiniteOrderBot._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrderBot β]
(f : α ≃o β) (a x : α),
x ∈ Finset.map { toEquiv := f.symm.toEquiv, map_rel_iff' := ⋯ }.toEmbedding (Finset.Iic (f a)) ↔ x ≤ a | null | false |
AlternatingMap.zero_apply | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Zero β}
{inst_2 : Zero F} [self : IsZeroApply F α β] (x : α), 0 x = 0 | **Alias** of `zero_apply`. | true |
Asymptotics.IsBigO.mul | Mathlib.Analysis.Asymptotics.Ring | ∀ {α : Type u_1} {R : Type u_4} [inst : SeminormedRing R] {S : Type u_7} [inst_1 : NormedRing S] [NormMulClass S]
{l : Filter α} {f₁ f₂ : α → R} {g₁ g₂ : α → S},
f₁ =O[l] g₁ → f₂ =O[l] g₂ → (fun x => f₁ x * f₂ x) =O[l] fun x => g₁ x * g₂ x | null | true |
FreeRing.of | Mathlib.RingTheory.FreeRing | {α : Type u} → α → FreeRing α | The canonical map from α to `FreeRing α`. | true |
ListSlice.toArray_mkSlice_roo | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α} {lo hi : ℕ},
Std.Slice.toArray (Std.Roo.Sliceable.mkSlice xs (lo<...hi)) = (Std.Slice.toArray xs).extract (lo + 1) hi | null | true |
Manifold.termCMDiffAt____ | Mathlib.Geometry.Manifold.Notation | Lean.ParserDescr | `CMDiffAt n f x` elaborates to `ContMDiffAt I J n f x`
trying to determine `I` and `J` from the local context.
`n` is coerced to `WithTop ℕ∞` if necessary (so passing a `ℕ`, `∞` or `ω` are all supported).
The argument `x` can be omitted. | true |
CategoryTheory.Limits.colimit_obj_ext | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K]
{H : CategoryTheory.Functor J (CategoryTheory.Functor K C)} [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
{k : K} {W : C} {f g ... | null | true |
CategoryTheory.Arrow.LeftHomotopy.compLeft._proof_1 | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{u v w : CategoryTheory.Arrow V} {f g : v ⟶ w} (h : CategoryTheory.Arrow.LeftHomotopy f g) (e : u ⟶ v),
CategoryTheory.Arrow.Hom.left (CategoryTheory.CategoryStruct.comp e f) -
CategoryTheory.Arrow.Hom.left ... | null | false |
CategoryTheory.Mod.instInhabited.eq_1 | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A : C)
[inst_2 : CategoryTheory.MonObj A], CategoryTheory.Mod.instInhabited A = { default := CategoryTheory.Mod.regular A } | null | true |
FreeAbelianGroup.ofMulHom._proof_2 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u_1} [inst : Monoid α] (x y : α),
FreeAbelianGroup.of (x * y) = FreeAbelianGroup.of x * FreeAbelianGroup.of y | null | false |
QuotientGroup.kerLift_injective | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u} [inst : Group G] {H : Type v} [inst_1 : Group H] (φ : G →* H),
Function.Injective ⇑(QuotientGroup.kerLift φ) | null | true |
Neg.noConfusionType | Init.Prelude | Sort u_1 → {α : Type u} → Neg α → {α' : Type u} → Neg α' → Sort u_1 | null | false |
Fin.consOrderIso_toEquiv | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_2) [inst : (i : Fin (n + 1)) → LE (α i)],
(Fin.consOrderIso α).toEquiv = Fin.consEquiv α | null | true |
Lean.Meta.ArgsPacker.mk.noConfusion | Lean.Meta.ArgsPacker.Basic | {P : Sort u} →
{varNamess varNamess' : Array (Array Lean.Name)} →
{ varNamess := varNamess } = { varNamess := varNamess' } → (varNamess = varNamess' → P) → P | null | false |
AddMonoidAlgebra.map_neg | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Ring R] [inst_1 : Ring S] (f : R →+ S)
(x : AddMonoidAlgebra R M), AddMonoidAlgebra.map f (-x) = -AddMonoidAlgebra.map f x | null | true |
_private.Init.System.FilePath.0.System.FilePath.normalize.normalizeDriveLetter.match_1 | Init.System.FilePath | (motive : List Char → Sort u_1) →
(x : List Char) → ((driveLetter : Char) → motive [driveLetter, ':']) → ((x : List Char) → motive x) → motive x | null | false |
Pi.addGroup.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → AddGroup (f i)],
Pi.addGroup = { toSubNegMonoid := Pi.subNegMonoid, neg_add_cancel := ⋯ } | null | true |
VectorBundleCore.ctorIdx | Mathlib.Topology.VectorBundle.Basic | {R : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
{inst : NontriviallyNormedField R} →
{inst_1 : NormedAddCommGroup F} →
{inst_2 : NormedSpace R F} → {inst_3 : TopologicalSpace B} → {ι : Type u_5} → VectorBundleCore R B F ι → ℕ | null | false |
MonoidHom.mulSingle.eq_1 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} (f : I → Type v) [inst : DecidableEq I] [inst_1 : (i : I) → MulOneClass (f i)] (i : I),
MonoidHom.mulSingle f i = { toOneHom := OneHom.mulSingle f i, map_mul' := ⋯ } | null | true |
Algebra.Extension.CotangentSpace._proof_1 | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S], IsScalarTower R R S | null | false |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.one_sub_eta_q_ne_zero._simp_1_1 | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Polynomial.IsSplittingField.lift._proof_6 | Mathlib.FieldTheory.SplittingField.IsSplittingField | ∀ {F : Type u_1} {K : Type u_3} (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Field F]
[inst_3 : Algebra K L] [inst_4 : Algebra K F] (f : Polynomial K),
(Polynomial.map (algebraMap K F) f).Splits → ¬f = 0 → Nonempty (↥(Algebra.adjoin K ↑(f.aroots L).toFinset) →ₐ[K] F) | null | false |
Int.neg_nonpos_iff._simp_1 | Init.Data.Int.LemmasAux | ∀ (i : ℤ), (-i ≤ 0) = (0 ≤ i) | null | false |
cfcₙ_realPart._auto_5 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.RealImaginaryPart | Lean.Syntax | null | false |
SSet.Truncated.FundamentalGroupoid.desc._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.FundamentalGroupoid.Basic | ∀ {X : SSet.Truncated 2} {D : Type u_2} [inst : CategoryTheory.Groupoid D]
(obj : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.FundamentalGroupoid._proof_1 }) → D)
(map :
{x y : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.FundamentalGroupoid._proof_1 })} →
... | null | false |
_private.Init.Data.Array.Bootstrap.0.Array.foldlM.loop.match_1.eq_1 | Init.Data.Array.Bootstrap | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (i' : ℕ) → motive i'.succ),
(match 0 with
| 0 => h_1 ()
| i'.succ => h_2 i') =
h_1 () | null | true |
_private.Lean.Server.References.0.Lean.Server.getModuleContainingDecl?.match_1 | Lean.Server.References | (motive : Option Lean.ModuleIdx → Sort u_1) →
(x : Option Lean.ModuleIdx) →
((modIdx : Lean.ModuleIdx) → motive (some modIdx)) → ((x : Option Lean.ModuleIdx) → motive x) → motive x | null | false |
ULift.isLeftRegular_up | Mathlib.Algebra.Regular.ULift | ∀ {R : Type v} [inst : Mul R] {a : R}, IsLeftRegular { down := a } ↔ IsLeftRegular a | null | true |
_private.Mathlib.Order.OrderIsoNat.0.exists_increasing_or_nonincreasing_subseq'._proof_1_4 | Mathlib.Order.OrderIsoNat | ∀ (m n n' : ℕ), n + m < n' → n < n + n' - n - m | null | false |
Filter.hasBasis_pi | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {ι' : ι → Type u_3} {s : (i : ι) → ι' i → Set (α i)}
{p : (i : ι) → ι' i → Prop},
(∀ (i : ι), (f i).HasBasis (p i) (s i)) →
(Filter.pi f).HasBasis (fun If => If.1.Finite ∧ ∀ i ∈ If.1, p i (If.2 i)) fun If => If.1.pi fun i => s i (If.2 i) | null | true |
Meromorphic.meromorphic_fun_comp_add_const_iff_meromorphic._simp_1 | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {c : 𝕜}, (Meromorphic fun z => f (z + c)) = Meromorphic f | null | false |
_private.Init.Data.Iterators.Basic.0.Std.Shrink.eq_1 | Init.Data.Iterators.Basic | ∀ (α : Type u), Std.Shrink α = ↑Std.Internal.idOpaque✝ α | null | true |
CategoryTheory.Triangulated.TStructure.instIsIsoFunctorETruncGEπBotEInt | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {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 |
MeasureTheory.Measure.IsMulRightInvariant.mk._flat_ctor | Mathlib.MeasureTheory.Group.Defs | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Mul G] {μ : MeasureTheory.Measure G},
(∀ (g : G), MeasureTheory.Measure.map (fun x => x * g) μ = μ) → μ.IsMulRightInvariant | null | false |
Std.Time.instInhabitedValidDate | Std.Time.Date.ValidDate | {l : Bool} → Inhabited (Std.Time.ValidDate l) | null | true |
Finsupp.lsubtypeDomain_apply | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(s : Set α) (f : α →₀ M), (Finsupp.lsubtypeDomain s) f = Finsupp.subtypeDomain (fun x => x ∈ s) f | null | true |
instRingWithIdealFilter._aux_1 | Mathlib.RingTheory.IdealFilter.Topology | {A : Type u_1} → [inst : Ring A] → (x : IdealFilter A) → Zero (WithIdealFilter x) | null | false |
Module.Relations.instAddCommGroupQuotient._proof_10 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u_3} [inst : Ring A] (relations : Module.Relations A),
autoParam (∀ (x : relations.Quotient), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
isProperLinearSet_iff | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M},
IsProperLinearSet s ↔ ∃ a t, LinearIndepOn ℕ id ↑t ∧ s = a +ᵥ ↑(AddSubmonoid.closure ↑t) | An equivalent expression of `IsProperLinearSet` in terms of `Finset` instead of `Set.Finite`. | true |
LocallyConstant.mapAddMonoidHom._proof_2 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] {Z : Type u_2} [inst_1 : AddZeroClass Y]
[inst_2 : AddZeroClass Z] (f : Y →+ Z), LocallyConstant.map (⇑f) 0 = 0 | null | false |
RingHom.LocalizationPreserves._proof_1 | Mathlib.RingTheory.LocalProperties.Basic | ∀ ⦃R S : Type u_1⦄ [inst : CommRing R] [inst_1 : CommRing S], MonoidHomClass (R →+* S) R S | null | false |
UniformSpace.Core.mkOfBasis._proof_2 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} (B : FilterBasis (α × α)),
(∀ r ∈ B, ∃ t ∈ B, t ⊆ Prod.swap ⁻¹' r) → Filter.Tendsto Prod.swap B.filter B.filter | null | false |
CategoryTheory.PreOneHypercover.Hom.w₁₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} (self : E.Hom F) {i j : E.I₀} (k : E.I₁ i j),
CategoryTheory.CategoryStruct.comp (self.h₁ k) (F.p₁ (self.s₁ k)) =
CategoryTheory.CategoryStruct.comp (E.p₁ k) (self.h₀ ... | null | true |
ISize.toBitVec32_toInt16 | Init.Data.SInt.IntToBitVec | ∀ (n : ISize) (h : System.Platform.numBits = 32), n.toInt16.toBitVec = BitVec.signExtend 16 (n.toBitVec32 h) | null | true |
ContinuousOpenMap.id_apply | Mathlib.Topology.Hom.Open | ∀ {α : Type u_2} [inst : TopologicalSpace α] (a : α), (ContinuousOpenMap.id α) a = a | null | true |
CategoryTheory.Quiv.isoOfEquiv._proof_5 | Mathlib.CategoryTheory.Category.Quiv | ∀ {V W : Type u_1} [inst : Quiver V] [inst_1 : Quiver W] (e : V ≃ W) (he : (X Y : V) → (X ⟶ Y) ≃ (e X ⟶ e Y)),
CategoryTheory.CategoryStruct.comp
{ obj := ⇑e.symm, map := fun {X Y} f => (he (e.symm X) (e.symm Y)).symm (Quiver.homOfEq f ⋯ ⋯) }
{ obj := ⇑e, map := fun {X Y} => ⇑(he X Y) } =
CategoryTheo... | null | false |
CategoryTheory.Functor.opMapTriangleCompTriangleOpEquivalenceInverse | Mathlib.CategoryTheory.Triangulated.Opposite.Functor | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.HasShift D ℤ] →
(F : CategoryTheory.Functor C D) →
[inst_4 : F.Com... | If `F : C ⥤ D` commutes with shifts, this expresses the compatibility of `F.mapTriangle`
with the equivalences `Pretriangulated.triangleOpEquivalence` on `C` and `D`.
| true |
_private.Std.Sync.Semaphore.0.Std.Semaphore.release.match_3 | Std.Sync.Semaphore | (motive : Option (IO.Promise Unit) → Sort u_1) →
(waiter? : Option (IO.Promise Unit)) →
((waiter : IO.Promise Unit) → motive (some waiter)) → ((x : Option (IO.Promise Unit)) → motive x) → motive waiter? | null | false |
Std.DHashMap.Const.get?_filterMap' | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.DHashMap α fun x => β} [LawfulBEq α]
{f : α → β → Option γ} {k : α},
Std.DHashMap.Const.get? (Std.DHashMap.filterMap f m) k = (Std.DHashMap.Const.get? m k).bind fun x => f k x | Simpler variant of `get?_filterMap` when `LawfulBEq` is available. | true |
MulOpposite.instMulActionWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Opposite | ∀ {M : Type u_2} {α : Type u_1} [inst : MonoidWithZero M] [inst_1 : AddMonoid α] [inst_2 : MulActionWithZero M α]
(x : M), x • 0 = 0 | null | false |
Nat.Primrec.below.rec | Mathlib.Computability.Primrec.Basic | ∀ {motive : (a : ℕ → ℕ) → Nat.Primrec a → Prop}
{motive_1 : {a : ℕ → ℕ} → (t : Nat.Primrec a) → Nat.Primrec.below t → Prop},
motive_1 Nat.Primrec.zero ⋯ →
motive_1 Nat.Primrec.succ ⋯ →
motive_1 Nat.Primrec.left ⋯ →
motive_1 Nat.Primrec.right ⋯ →
(∀ {f g : ℕ → ℕ} (a : Nat.Primrec f) (a_1 ... | null | false |
Nat.pairEquiv.match_1 | Mathlib.Data.Nat.Pairing | ∀ (motive : ℕ × ℕ → Prop) (x : ℕ × ℕ), (∀ (a b : ℕ), motive (a, b)) → motive x | null | false |
_private.Mathlib.GroupTheory.IsSubnormal.0.AddSubgroup.IsSubnormal.isSubnormal_iff.match_1_1.congr_eq_1 | Mathlib.GroupTheory.IsSubnormal | ∀ (motive : ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
x = 0 →
(match x with
| 0 => h_1 ()
| n.succ => h_2 n) ≍
h_1 () | null | true |
CategoryTheory.PreZeroHypercover.pullback₂.congr_simp | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T : C} (f f_1 : S ⟶ T) (e_f : f = f_1)
(E E_1 : CategoryTheory.PreZeroHypercover T) (e_E : E = E_1)
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) f],
CategoryTheory.PreZeroHypercover.pullback₂ f E = CategoryTheory.PreZeroHypercover.pu... | null | true |
RootPairing.GeckConstruction.basis._proof_2 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {K : Type u_1} [inst : Field K], IsDomain K | null | false |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.all_dual.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {P : α → Prop} (size : ℕ) (_l : Ordnode α) (_x : α) (_r : Ordnode α)
(motive : Ordnode.All P (Ordnode.node size _l _x _r).dual → Prop)
(x : Ordnode.All P (Ordnode.node size _l _x _r).dual),
(∀ (hr : Ordnode.All P _r.dual) (hx : P _x) (hl : Ordnode.All P _l.dual), motive ⋯) → motive x | null | false |
Std.LawfulLTCmp.eq_lt_iff_lt | Batteries.Classes.Order | ∀ {α : Type u_1} {inst : LT α} {cmp : α → α → Ordering} [self : Std.LawfulLTCmp cmp] {x y : α},
cmp x y = Ordering.lt ↔ x < y | `cmp x y = .lt` holds iff `x < y` is true. | true |
Qq.SortLocalDecls.Context._sizeOf_1 | Qq.SortLocalDecls | Qq.SortLocalDecls.Context → ℕ | null | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₂._proof_5 | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{u_1}} [inst_1 : Fact κ.IsRegular] {ι : Type u_1}
(D : ι → CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ)
(hι : HasCardinalLT ι κ) {m : J},
(CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.... | null | false |
AlgebraicGeometry.Proj.awayToSection | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | {σ : Type u_1} →
{A : Type u} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
(f : A) →
↧(HomogeneousLocalization.Away 𝒜 f) ⟶
(AlgebraicGeometry.Proj 𝒜... | The canonical map `(A_f)₀ ⟶ Γ(Proj A, D₊(f))`.
This is an isomorphism when `f` is homogeneous of positive degree. See `basicOpenIsoAway` below. | true |
Set.infinite_of_forall_exists_lt | Mathlib.Order.Preorder.Finite | ∀ {α : Type u_2} [inst : Preorder α] {s : Set α} [Nonempty α], (∀ (a : α), ∃ b ∈ s, b < a) → s.Infinite | null | true |
Finpartition.ofSubset._proof_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (P : Finpartition a) {parts : Finset α},
parts ⊆ P.parts → parts.SupIndep id | null | false |
HomogeneousLocalization.awayMap.congr_simp | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι] (𝒜 : ι → σ)
[inst_5 : GradedRing 𝒜] {e e_1 : ι} (e_e : e = e_1) {f g g_1 : A} (e_g : g = g_1) (hg : g ∈ 𝒜 e) {x : A}
(hx : x = f * g), Ho... | null | true |
_private.Mathlib.RingTheory.RegularLocalRing.Polynomial.0.Polynomial.isRegularLocalRing_localization_atPrime_of_comap_eq_maximalIdeal._simp_1_4 | Mathlib.RingTheory.RegularLocalRing.Polynomial | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[RingHomClass F R S] (s : Set R), Ideal.span (⇑f '' s) = Ideal.map f (Ideal.span s) | null | false |
DerivedCategory.Plus.instIsVerdierRightLocalizingHomotopyCategoryIntUpPlusSubcategoryAcyclic | Mathlib.Algebra.Homology.DerivedCategory.Plus | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C],
(HomotopyCategory.plus C).IsVerdierRightLocalizing (HomotopyCategory.subcategoryAcyclic C) | null | true |
CategoryTheory.conj_eqToHom_iff_heq._to_dual_1 | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W X Y Z : C} (f : X ⟶ W) (g : Z ⟶ Y) (h : W = Y)
(h' : X = Z),
f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) g)
(CategoryTheory.eqToHom ⋯) ↔
f ≍ g | null | false |
CategoryTheory.HasSubobjectClassifier.isPullback_χ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasSubobjectClassifier C] {U X : C}
(m : U ⟶ X) [inst_2 : CategoryTheory.Mono m],
CategoryTheory.IsPullback m (⋯.some.χ₀ U) (CategoryTheory.HasSubobjectClassifier.χ m)
(CategoryTheory.HasSubobjectClassifier.truth C) | The diagram
```
U ---------m----------> X
| |
χ₀ U χ m
| |
v v
Ω₀ ------truth--------> Ω
```
is a pullback square.
| true |
SemiconjBy.smul_right_iff._simp_2 | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_3} {H : Type u_4} [inst : Group G] [inst_1 : Mul H] [inst_2 : MulAction G H] [SMulCommClass G H H]
[IsScalarTower G H H] {a b x : H} {r : G}, SemiconjBy x (r • a) (r • b) = SemiconjBy x a b | null | false |
Nat.decidableLoHiLe._proof_1 | Mathlib.Data.Nat.Init | ∀ (lo hi : ℕ) (P : ℕ → Prop), (∀ (a : ℕ), lo ≤ a → a < hi + 1 → P a) ↔ ∀ (a : ℕ), lo ≤ a → a ≤ hi → P a | null | false |
_private.Mathlib.Data.Finset.Disjoint.0.Finset.disjoint_coe._simp_1_1 | Mathlib.Data.Finset.Disjoint | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | null | false |
Nat.Internal.Linear.Poly.toExpr.go | Init.Data.Nat.Internal.Linear | Nat.Internal.Linear.Expr → Nat.Internal.Linear.Poly → Nat.Internal.Linear.Expr | null | true |
_private.Lean.Compiler.LCNF.FixedParams.0.Lean.Compiler.LCNF.mkFixedParamsMap.match_1 | Lean.Compiler.LCNF.FixedParams | (motive : EStateM.Result Unit Lean.Compiler.LCNF.FixedParams.State Unit → Sort u_1) →
(x : EStateM.Result Unit Lean.Compiler.LCNF.FixedParams.State Unit) →
((a : Unit) → (s : Lean.Compiler.LCNF.FixedParams.State) → motive (EStateM.Result.ok a s)) →
((a : Unit) → (s : Lean.Compiler.LCNF.FixedParams.State) → ... | null | false |
IsPrimitiveRoot.card_primitiveRoots | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {ζ : R} {k : ℕ},
IsPrimitiveRoot ζ k → (primitiveRoots k R).card = k.totient | If an integral domain has a primitive `k`-th root of unity, then it has `φ k` of them. | true |
CategoryTheory.CostructuredArrow.functor | Mathlib.CategoryTheory.Comma.StructuredArrow.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
CategoryTheory.Functor C D → CategoryTheory.Functor D CategoryTheory.Cat | The costructured arrow category `CostructuredArrow T d` depends on the chosen codomain `d : D`
in a functorial way, inducing a functor `D ⥤ Cat`. | true |
Lean.Syntax.node5 | Init.Prelude | Lean.SourceInfo →
Lean.SyntaxNodeKind → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax | Create syntax node with 5 children | true |
SSet.StrictSegal.isPointwiseRightKanExtensionAt._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.Coskeletal | ∀ {X : SSet} (sx : X.StrictSegal) (n : ℕ)
(s :
CategoryTheory.Limits.Cone
((CategoryTheory.StructuredArrow.proj (Opposite.op { len := n }) (SimplexCategory.Truncated.inclusion 2).op).comp
((SimplexCategory.Truncated.inclusion 2).op.comp X)))
(m : s.pt ⟶ ((SSet.Truncated.rightExtensionInclusion X 2... | null | false |
Std.ExtTreeMap.getKey!_eq_of_contains | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst_2 : Inhabited α] {k : α}, t.contains k = true → t.getKey! k = k | null | true |
_private.Mathlib.Algebra.Homology.ShortComplex.Homology.0.CategoryTheory.ShortComplex.HomologyMapData.instSubsingleton._simp_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
Mathlib.Tactic.BicategoryLike.Mor₁._sizeOf_1 | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Mor₁ → ℕ | null | false |
HomogeneousIdeal.toIdeal_sup | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), (I ⊔ J).toIdeal = I.toIdeal ⊔ J.toIdeal | null | true |
Rat.mk'.sizeOf_spec | Init.Data.Rat.Basic | ∀ (num : ℤ) (den : ℕ) (den_nz : autoParam (den ≠ 0) Rat.den_nz._autoParam)
(reduced : autoParam (num.natAbs.Coprime den) Rat.reduced._autoParam),
sizeOf { num := num, den := den, den_nz := den_nz, reduced := reduced } = 1 + sizeOf num + sizeOf den + sizeOf reduced | null | true |
CategoryTheory.Functor.mapCommMonNatIso._proof_4 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_2} [inst_3 : CategoryTheory.Category.{u_1, u_2} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F F' : Ca... | null | false |
CategoryTheory.Limits.prod.rightUnitor_hom_naturality_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasInitial C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] (f : Y ⟶ X) {Z : C} (h : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp h (CategoryTheory.Limits.coprod.rightU... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Counting.0.SimpleGraph.coe_finsetWalkLength_eq._proof_1_15 | Mathlib.Combinatorics.SimpleGraph.Walk.Counting | ∀ (q : Prop), q → q | null | false |
LinearMap.BilinForm.mem_orthogonal_iff._simp_1 | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{B : LinearMap.BilinForm R M} {N : Submodule R M} {m : M}, (m ∈ B.orthogonal N) = ∀ n ∈ N, (B n) m = 0 | null | false |
AlgHom.ker_kerSquareLift | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u} [inst : CommRing R] {A : Type u_1} {B : Type u_2} [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B),
RingHom.ker f.kerSquareLift.toRingHom = (RingHom.ker f.toRingHom).cotangentIdeal | null | true |
Multiset.prod | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | {M : Type u_2} → [CommMonoid M] → Multiset M → M | Product of a multiset given a commutative monoid structure on `M`.
`prod {a, b, c} = a * b * c` | true |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions.0.SimpleGraph.cycleGraph.tricoloring._proof_9 | Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions | ∀ (n : ℕ) (u v : Fin (n + 2)), ¬↑v = n + 2 - 1 → ↑2 ≤ ↑(n + 2) → ¬↑(↑v + 1) < ↑(n + 2) → False | null | false |
_private.Mathlib.Algebra.Category.ModuleCat.Kernels.0.ModuleCat.kernelIsLimit._simp_1 | Mathlib.Algebra.Category.ModuleCat.Kernels | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {FC : outParam (C → C → Type u_1)} {CC : outParam (C → Type w)}
{inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))} [self : CategoryTheory.ConcreteCategory C FC]
{X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (x : CC X),
(CategoryTheory.ConcreteCategory.h... | null | false |
Lean.Grind.ConfigInteractive._sizeOf_1 | Init.Grind.Config | Lean.Grind.ConfigInteractive → ℕ | null | false |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.init_update_castSucc._simp_1_2 | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} {a b : Fin n}, (a.castSucc = b.castSucc) = (a = b) | null | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.ext_cochain_to_iff._proof_1_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ (i j : ℤ), i + 1 = j → ∀ (p q : ℤ), p + i = q → p + j = q + 1 | null | false |
BorelSpace.measurable_eq | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_6} {inst : TopologicalSpace α} {inst_1 : MeasurableSpace α} [self : BorelSpace α], inst_1 = borel α | The measurable sets are exactly the Borel-measurable sets. | true |
Mathlib.Ineq.relImpRelData | Mathlib.Tactic.LinearCombination.Lemmas | Mathlib.Ineq → Mathlib.Ineq → Option (Lean.Name × Mathlib.Ineq) | Given two (in)equalities `P` and `Q`, look up the lemma to deduce `Q` from `P`, and the relation
appearing in the side condition produced by this lemma. | true |
CategoryTheory.ShortComplex.homologyι_comp_asIsoHomologyι_inv | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hg : S.g = 0) [inst_2 : S.HasHomology],
CategoryTheory.CategoryStruct.comp S.homologyι (S.asIsoHomologyι hg).inv = CategoryTheory.CategoryStruct.id S.homology | null | true |
CategoryTheory.ObjectProperty.IsTriangulatedClosed₁.casesOn | Mathlib.CategoryTheory.Triangulated.Subcategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.Preadditive C] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | null | false |
Partrec.to₂ | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable σ]
{f : α × β →. σ}, Partrec f → Partrec₂ fun a b => f (a, b) | null | true |
CategoryTheory.Adjunction.leftAdjointCompNatTrans_app | Mathlib.CategoryTheory.Adjunction.CompositionIso | ∀ {C₀ : Type u_1} {C₁ : Type u_2} {C₂ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₀]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₁] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₂]
{F₀₁ : CategoryTheory.Functor C₀ C₁} {F₁₂ : CategoryTheory.Functor C₁ C₂} {F₀₂ : CategoryTheory.Functor C₀ C₂}
{G₁₀ : C... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.