name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Function.Injective.cancelMonoid.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : Pow M₁ ℕ] [inst_3 : CancelMonoid M₂]
(f : M₁ → M₂) (hf : Function.Injective f) (one : f 1 = 1) (mul : ∀ (x y : M₁), f (x * y) = f x * f y)
(npow : ∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n),
Function.Injective.cancelMonoid f hf one mul np... | null | true |
Homeomorph.piSplitAt | Mathlib.Topology.Homeomorph.Lemmas | {ι : Type u_5} →
[DecidableEq ι] →
(i : ι) →
(Y : ι → Type u_6) →
[inst : (j : ι) → TopologicalSpace (Y j)] → ((j : ι) → Y j) ≃ₜ Y i × ((j : { j // j ≠ i }) → Y ↑j) | A product of topological spaces can be split as the binary product of one of the spaces and
the product of all the remaining spaces. | true |
QuotientAddGroup.preimage_mk_zero | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (N : AddSubgroup α), QuotientAddGroup.mk ⁻¹' {↑0} = ↑N | null | true |
CommGrpCat.commGroupObj._aux_3 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J CommGrpCat) → (j : J) → Mul ((F.comp (CategoryTheory.forget CommGrpCat)).obj j) | null | false |
DihedralGroup.Product | Mathlib.GroupTheory.CommutingProbability | List ℕ → Type | A finite product of Dihedral groups. | true |
_private.Mathlib.Analysis.InnerProductSpace.LinearPMap.0.LinearPMap.graph_adjoint_toLinearPMap_eq_adjoint._simp_1_2 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
Lean.MetavarContext.UnivMVarParamResult.recOn | Lean.MetavarContext | {motive : Lean.MetavarContext.UnivMVarParamResult → Sort u} →
(t : Lean.MetavarContext.UnivMVarParamResult) →
((mctx : Lean.MetavarContext) →
(newParamNames : Array Lean.Name) →
(nextParamIdx : ℕ) →
(expr : Lean.Expr) →
motive { mctx := mctx, newParamNames := newParamNa... | null | false |
Std.TreeMap.recOn | Std.Data.TreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive : Std.TreeMap α β cmp → Sort u_1} →
(t : Std.TreeMap α β cmp) → ((inner : Std.DTreeMap α (fun x => β) cmp) → motive { inner := inner }) → motive t | null | false |
Array.append_ne_empty_of_left_ne_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, xs ≠ #[] → xs ++ ys ≠ #[] | null | true |
Set.image2_union_inter_subset_union | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s s' : Set α} {t t' : Set β},
Set.image2 f (s ∪ s') (t ∩ t') ⊆ Set.image2 f s t ∪ Set.image2 f s' t' | null | true |
CategoryTheory.Abelian.SpectralObject.cyclesIso_inv_cyclesMap | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
{i₀' i₁' i₂' i₃' : ι} (f₁' : i₀' ⟶ i₁') (... | null | true |
Nat.factorial_eq_one._simp_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ {n : ℕ}, (n.factorial = 1) = (n ≤ 1) | null | false |
_private.Init.Data.Nat.Internal.SOM.0.Nat.Internal.SOM.Poly.mul_denote.match_1_1 | Init.Data.Nat.Internal.SOM | ∀ (motive : Nat.Internal.SOM.Poly → Prop) (p₁ : Nat.Internal.SOM.Poly),
(∀ (_ : Unit), motive []) →
(∀ (k : ℕ) (m : Nat.Internal.SOM.Mon) (p₁ : List (ℕ × Nat.Internal.SOM.Mon)), motive ((k, m) :: p₁)) → motive p₁ | null | false |
Lean.Lsp.SymbolKind.key.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.key = 1 | null | true |
CommGrpCat.coyoneda_obj_obj_coe | Mathlib.Algebra.Category.Grp.Yoneda | ∀ (M : CommGrpCatᵒᵖ) (N : CommGrpCat), ↑((CommGrpCat.coyoneda.obj M).obj N) = (↑(Opposite.unop M) →* ↑N) | null | true |
CompleteLat.instConcreteCategoryCompleteLatticeHomCarrier._proof_4 | Mathlib.Order.Category.CompleteLat | ∀ {X Y Z : CompleteLat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X), (CategoryTheory.CategoryStruct.comp f g) x = g (f x) | null | false |
TopologicalSpace.Opens.comap_comp | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (g : C(β, γ)) (f : C(α, β)),
TopologicalSpace.Opens.comap (g.comp f) = (TopologicalSpace.Opens.comap f).comp (TopologicalSpace.Opens.comap g) | null | true |
CategoryTheory.NatTrans.Equifibered.whiskerLeft | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equifibered | ∀ {J : Type u_1} {K : Type u_2} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_3} C] [inst_2 : CategoryTheory.Category.{v_3, u_2} K]
{F G : CategoryTheory.Functor J C} {α : F ⟶ G},
CategoryTheory.NatTrans.Equifibered α →
∀ (H : CategoryTheory.Functor K J... | null | true |
GeneralizedBooleanAlgebra.toNonUnitalCommRing._proof_7 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (a : α), symmDiff ⊥ a = a | null | false |
_private.Mathlib.Algebra.Group.WithOne.Defs.0.WithZero.unzero.match_1.splitter | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u_1} →
(motive : (x : WithZero α) → x ≠ 0 → Sort u_2) →
(x : WithZero α) → (x_1 : x ≠ 0) → ((x : α) → (x_2 : ↑x ≠ 0) → motive (some x) x_2) → motive x x_1 | null | true |
Lean.Compiler.LCNF.Code.inc.injEq | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (fvarId : Lean.FVarId) (n : ℕ) (check persistent : Bool)
(k : Lean.Compiler.LCNF.Code pu)
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_15) (fvarId_1 : Lean.FVarId)
(n_1 : ℕ) (check_1 persistent_1 : Bool) (k_1 : Lean.Compiler.LCNF.Code pu)
... | null | true |
AddMonoidAlgebra.mapDomainAddEquiv._proof_3 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_1) {M : Type u_3} {N : Type u_2} [inst : Semiring R] [inst_1 : Add M] [inst_2 : Add N] (e : M ≃ N)
(x y : AddMonoidAlgebra R M),
AddMonoidAlgebra.mapDomain (⇑e) (x + y) = AddMonoidAlgebra.mapDomain (⇑e) x + AddMonoidAlgebra.mapDomain (⇑e) y | null | false |
CategoryTheory.MorphismProperty.Over.homMk | Mathlib.CategoryTheory.MorphismProperty.Comma | {T : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} T] →
{P Q : CategoryTheory.MorphismProperty T} →
{X : T} →
[inst_1 : Q.IsMultiplicative] →
{A B : P.Over Q X} →
(f : A.left ⟶ B.left) →
autoParam (CategoryTheory.CategoryStruct.comp f B.hom = A.hom)
... | Make a morphism in `P.Over Q X` from a morphism in `T` with compatibilities. | true |
CategoryTheory.FreeBicategory.bicategory._proof_7 | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u_1} [inst : Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g')
(h : c ⟶ d),
Quot.map (CategoryTheory.FreeBicategory.Hom₂.whisker_right h) ⋯
(Quot.map (CategoryTheory.FreeBicategory.Hom₂.whisker_left f) ⋯ η) =
CategoryTheory.CategoryStruct.comp
... | null | false |
MeasurableEquiv.IicProdIoc._proof_5 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] [inst_2 : DecidableLE ι] {X : ι → Type u_2}
[inst_3 : LocallyFiniteOrderBot ι] [inst_4 : (i : ι) → MeasurableSpace (X i)] {a b : ι} (hab : a ≤ b),
Measurable
⇑{ toFun := fun x i => if h : ↑i ≤ a then x.1 ⟨↑i, ⋯⟩ else x.2 ⟨↑i, ⋯⟩,
... | null | false |
Std.Internal.List.getValueCastD_filter_not_contains_of_containsKey_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α} {k : α}
{fallback : β k},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.getValueCastD k (List.filter (fun p => !l₂.contains p.fst) l₁) fallba... | null | true |
_private.Init.Data.List.MapIdx.0.List.mapIdx_eq_replicate_iff._simp_1_1 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {a : α} {n : ℕ} {l : List α}, (l = List.replicate n a) = (l.length = n ∧ ∀ b ∈ l, b = a) | null | false |
rightAddCoset_mem_rightAddCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] (s : AddSubgroup α) {a : α}, a ∈ s → AddOpposite.op a +ᵥ ↑s = ↑s | null | true |
Lean.Order.FlatOrder.rel.refl | Init.Internal.Order.Basic | ∀ {α : Sort u} {b : α} {x : Lean.Order.FlatOrder b}, x.rel x | null | true |
HasFDerivAt.const_mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {𝔸 : Type u_4} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸] {a : E → 𝔸}
{a' : E →L[𝕜] 𝔸}, HasFDerivAt a a' x → ∀ (b : 𝔸), HasFDerivAt (fun y => b * a y) (b • a') x | null | true |
Lean.Elab.InfoTree.node.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} →
{i : Lean.Elab.Info} →
{children : Lean.PersistentArray Lean.Elab.InfoTree} →
{i' : Lean.Elab.Info} →
{children' : Lean.PersistentArray Lean.Elab.InfoTree} →
Lean.Elab.InfoTree.node i children = Lean.Elab.InfoTree.node i' children' →
(i = i' → children = children... | null | false |
MvPowerSeries.isWeightedHomogeneous_weightedHomogeneousComponent | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) (f : MvPowerSeries σ R) (p : ℕ),
MvPowerSeries.IsWeightedHomogeneous w ((MvPowerSeries.weightedHomogeneousComponent w p) f) p | null | true |
exists_pos_rat_lt | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {K : Type u_4} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [Archimedean K] {x : K},
0 < x → ∃ q, 0 < q ∧ ↑q < x | null | true |
PadicInt.instMetricSpace._proof_24 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] {x y : ℤ_[p]}, dist x y = 0 → x = y | null | false |
NonUnitalStarAlgHomClass.map_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | Lean.Syntax | null | false |
AddSubgroup.isComplement'_top_right._simp_1 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.IsComplement' ⊤ = (H = ⊥) | null | false |
CategoryTheory.Limits.Cocone.equivStructuredArrow_unitIso | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor J C),
(CategoryTheory.Limits.Cocone.equivStructuredArrow F).unitIso =
CategoryTheory.NatIso.ofComponents CategoryTheory.Limits.Cocone.eta ⋯ | null | true |
CategoryTheory.MonoOver.image._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} [inst_1 : CategoryTheory.Limits.HasImages C]
{f g : CategoryTheory.Over X} (k : f ⟶ g),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.image.lift
{ I := CategoryTheory.Limits.image g.hom, m := CategoryTheory.Limits.image... | null | false |
Lean.JsonRpc.MessageMetaData.responseError.inj | Lean.Data.JsonRpc | ∀ {id : Lean.JsonRpc.RequestID} {code : Lean.JsonRpc.ErrorCode} {message : String} {data? : Option Lean.Json}
{id_1 : Lean.JsonRpc.RequestID} {code_1 : Lean.JsonRpc.ErrorCode} {message_1 : String} {data?_1 : Option Lean.Json},
Lean.JsonRpc.MessageMetaData.responseError id code message data? =
Lean.JsonRpc.Mes... | null | true |
Valuation.exists_extension_eq_map | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {K : Type u_2} {Γ₀ : Type u_3} [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K]
[inst_3 : IsValuativeTopology K] [inst_4 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation K Γ₀)
[inst_5 : v.Compatible] [inst_6 : IsUniformAddGroup K] (x : UniformSpace.Completion K), ∃ r, v.extension x = v r | null | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.d₂₁_single_self_inv_ρ_sub_inv_self._abel_1_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u_1, u_1, u_1} k G} (g : G) (a : ↑A),
(((fun₀ | g⁻¹ => a) - fun₀ | 1 => (A.ρ g) a) + fun₀ | g => (A.ρ g) a) -
(((fun₀ | g => (A.ρ g) a) - fun₀ | 1 => a) + fun₀ | g⁻¹ => a) =
(fun₀ | 1 => a) - fun₀ | 1 => (A.ρ g) a | null | false |
NNRatCast.noConfusionType | Mathlib.Data.Rat.Init | Sort u → {K : Type u_1} → NNRatCast K → {K' : Type u_1} → NNRatCast K' → Sort u | null | false |
_private.Mathlib.RingTheory.LaurentSeries.0.LaurentSeries.Cauchy.exists_lb_eventual_support._simp_1_1 | Mathlib.RingTheory.LaurentSeries | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
{x : R}, (v x < 1) = (v.restrict x < 1) | null | false |
Aesop.StatsExtensionEntry._sizeOf_inst | Aesop.Stats.Extension | SizeOf Aesop.StatsExtensionEntry | null | false |
CategoryTheory.RingObjCat.forget_map | Mathlib.CategoryTheory.Monoidal.Ring | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.RingObjCat C} (f : X ⟶ Y),
(CategoryTheory.RingObjCat.forget C).map f = f.hom | null | true |
pi_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {β : Type v} {X : β → Type u_2} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (X b)]
[h : ∀ (b : β), ProperSpace (X b)], ProperSpace ((b : β) → X b) | A finite product of proper spaces is proper. | true |
Order.pred_eq_iff_covBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] {a b : α} [NoMinOrder α], Order.pred a = b ↔ b ⋖ a | null | true |
Real.pow_arith_mean_le_arith_mean_pow_of_even | Mathlib.Analysis.MeanInequalitiesPow | ∀ {ι : Type u} (s : Finset ι) (w z : ι → ℝ),
(∀ i ∈ s, 0 ≤ w i) → ∑ i ∈ s, w i = 1 → ∀ {n : ℕ}, Even n → (∑ i ∈ s, w i * z i) ^ n ≤ ∑ i ∈ s, w i * z i ^ n | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.pow_self_pos._simp_1_1 | Init.Data.Nat.Lemmas | ∀ {a n : ℕ}, (0 < a ^ n) = (0 < a ∨ n = 0) | null | false |
Finset.inf_inv | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq α] [inst_1 : Inv α] [inst_2 : SemilatticeInf β]
[inst_3 : OrderTop β] (s : Finset α) (f : α → β), s⁻¹.inf f = s.inf fun x => f x⁻¹ | null | true |
Submodule.module'._proof_5 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p : Submodule R M) [inst_2 : Semiring S] [inst_3 : SMul S R] [inst_4 : Module S M] [inst_5 : IsScalarTower S R M]
(x y : S) (b : ↥p), (x * y) • b = x • y • b | null | false |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.mkPathAux.match_1 | Lean.Meta.Sym.Simp.DiscrTree | (motive : Lean.Meta.DiscrTree.Key × Array Lean.Expr → Sort u_1) →
(x : Lean.Meta.DiscrTree.Key × Array Lean.Expr) →
((k : Lean.Meta.DiscrTree.Key) → (todo : Array Lean.Expr) → motive (k, todo)) → motive x | null | false |
MonoidHom.map_pow | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (a : M) (n : ℕ), f (a ^ n) = f a ^ n | null | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.Basis.toCentralizer_equivariant._simp_1_1 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a * b⁻¹ = c) = (a = c * b) | null | false |
Nat.ne_zero_iff_zero_lt | Init.Data.Nat.Basic | ∀ {n : ℕ}, n ≠ 0 ↔ 0 < n | null | true |
CategoryTheory.Limits.preservesColimits_unop | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) [CategoryTheory.Limits.PreservesLimits F],
CategoryTheory.Limits.PreservesColimits F.unop | If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits, then `F.unop : C ⥤ D` preserves colimits. | true |
Set.image_neg_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b : α),
Neg.neg '' Set.uIcc a b = Set.uIcc (-a) (-b) | null | true |
CategoryTheory.Limits.coconeOfConeUnop_ι | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F.unop),
(CategoryTheory.Limits.coconeOfConeUnop c).ι = CategoryTheory.NatTrans.removeUnop c.π | null | true |
System.Platform.numBits_pos._simp_1 | Init.System.Platform | (0 < System.Platform.numBits) = True | null | false |
CategoryTheory.Functor.mapDifferentialObject._proof_3 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddMonoidWithOne S] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S] (D : Type u_5)
[inst_4 : CategoryTheory.Category.{u_4, u_5} D] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms D]
... | null | false |
CategoryTheory.Limits.Cocone.fromStructuredArrow_map_hom | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor J C) {X Y : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)}
(f : X ⟶ Y),
((CategoryTheory.Limits.Cocone.fromStructuredArrow F).map f).hom = Categor... | null | true |
_aux_Mathlib_Algebra_Group_Equiv_Defs___unexpand_AddEquiv_1 | Mathlib.Algebra.Group.Equiv.Defs | Lean.PrettyPrinter.Unexpander | null | false |
WithLp.prod_nndist_eq_of_L1 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddCommGroup α] [inst_1 : SeminormedAddCommGroup β]
(x y : WithLp 1 (α × β)), nndist x y = nndist x.fst y.fst + nndist x.snd y.snd | null | true |
CategoryTheory.Equivalence.powNat.match_1 | Mathlib.CategoryTheory.Equivalence | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → motive n.succ.succ) → motive x | null | false |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.initFn.match_1._@.Lean.Elab.Tactic.Monotonicity.1250514167._hygCtx._hyg.2 | Lean.Elab.Tactic.Monotonicity | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((xs : Array Lean.Expr) → (fst : Array Lean.BinderInfo) → (targetTy : Lean.Expr) → motive (xs, fst, targetTy)) →
motive x | null | false |
Tactic.ComputeAsymptotics.MultiseriesExpansion.zero.eq_2 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic | ∀ (basis_hd : ℝ → ℝ) (basis_tl : List (ℝ → ℝ)),
Tactic.ComputeAsymptotics.MultiseriesExpansion.zero =
Tactic.ComputeAsymptotics.MultiseriesExpansion.mk Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.nil
fun x => 0 | null | true |
Subsemigroup.unop_sInf | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] (S : Set (Subsemigroup Mᵐᵒᵖ)), (sInf S).unop = sInf (Subsemigroup.op ⁻¹' S) | null | true |
AlgebraicGeometry.AffineSpace.isOpenMap_over | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {n : Type u} (S : AlgebraicGeometry.Scheme), IsOpenMap ⇑(AlgebraicGeometry.AffineSpace n S ↘ S) | null | true |
_private.Mathlib.Combinatorics.Additive.PluenneckeRuzsa.0.Finset.mul_aux | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : CommGroup G] {A B C : Finset G},
A.Nonempty →
A ⊆ B →
(∀ A' ∈ B.powerset.erase ∅, ↑(A * C).card / ↑A.card ≤ ↑(A' * C).card / ↑A'.card) →
∀ A' ⊆ A, (A * C).card * A'.card ≤ (A' * C).card * A.card | null | true |
CategoryTheory.Preadditive.instSemiringEnd._proof_9 | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C},
Nat.unaryCast 0 = 0 | null | false |
Bundle.Trivialization.linearMapAt_symmₗ | 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 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : AddCommMonoid F]
[inst_5 : Module R F] [inst_6 : (x : B) → AddCommMonoid (E x)] [inst_7 : (x : B) → Module R... | null | true |
LieModuleHom.restrictLie._proof_1 | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {M : Type u_4}
[inst_3 : AddCommGroup M] [inst_4 : LieRingModule L M] {N : Type u_3} [inst_5 : AddCommGroup N]
[inst_6 : LieRingModule L N] [inst_7 : Module R N] [inst_8 : Module R M] (f : M →ₗ⁅R,L⁆ N) (L' : LieSubalg... | null | false |
CategoryTheory.linearYoneda._proof_2 | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type u_3) [inst : Ring R] (C : Type u_1) [inst_1 : CategoryTheory.Category.{u_2, u_1} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] (X : C) (X_1 : Cᵒᵖ),
ModuleCat.ofHom (CategoryTheory.Linear.leftComp R X (CategoryTheory.CategoryStruct.id X_1).unop) =
CategoryTheory.Cate... | null | false |
Finset.strongInduction_eq | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {p : Finset α → Sort u_3} (H : (s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) (s : Finset α),
Finset.strongInduction H s = H s fun t x => Finset.strongInduction H t | null | true |
_private.Lean.Meta.Tactic.TryThis.0.Lean.Meta.Tactic.TryThis.mkExactSuggestionSyntax | Lean.Meta.Tactic.TryThis | Lean.Expr → Bool → Lean.MetaM (Lean.TSyntax `tactic × Lean.MessageData) | Returns the syntax for an `exact` or `refine` (as indicated by `useRefine`) tactic corresponding to
`e` as well as a `MessageData` representation with hover information.
If `exposeNames` is `true`, prepends the tactic with `expose_names.` Note that the tactic is
always generated within `withExposedNames` to avoid gener... | true |
DirectedSystem | Mathlib.Order.DirectedInverseSystem | {ι : Type u_1} → [inst : Preorder ι] → (F : ι → Type u_4) → (⦃i j : ι⦄ → i ≤ j → F i → F j) → Prop | A directed system is a functor from a category (directed poset) to another category. | true |
AlgEquiv.toLinearEquiv_refl | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁],
↑AlgEquiv.refl = LinearEquiv.refl R A₁ | null | true |
CommAlgCat.tensorHom_hom | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] {A B C D : CommAlgCat R} (f : A ⟶ C) (g : B ⟶ D),
CommAlgCat.Hom.hom (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
Algebra.TensorProduct.map (CommAlgCat.Hom.hom f) (CommAlgCat.Hom.hom g) | null | true |
Lean.Elab.Structural.IndGroupInst.levels | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInst → List Lean.Level | null | true |
Std.Http.Response.Builder.mk.injEq | Std.Http.Data.Response | ∀ (line : Std.Http.Response.Head) (extensions : Std.Http.Extensions) (line_1 : Std.Http.Response.Head)
(extensions_1 : Std.Http.Extensions),
({ line := line, extensions := extensions } = { line := line_1, extensions := extensions_1 }) =
(line = line_1 ∧ extensions = extensions_1) | null | true |
AlgebraicGeometry.instQuasiSeparatedOfMonoScheme | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [CategoryTheory.Mono f], AlgebraicGeometry.QuasiSeparated f | null | true |
_private.Lean.Compiler.LCNF.SpecInfo.0.Lean.Compiler.LCNF.isNoSpecType | Lean.Compiler.LCNF.SpecInfo | Lean.Environment → Lean.Expr → Bool | Return `true` if `type` is a type tagged with `@[nospecialize]` or an arrow that produces this kind of type.
For example, this function returns true for `Inhabited Nat`, and `Nat → Inhabited Nat`.
| true |
Lean.Parser.ParserContext.suppressInsideQuot._inherited_default | Lean.Parser.Types | Bool | null | false |
EuclideanSpace.nndist_eq | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_7} [inst : RCLike 𝕜] {n : Type u_8} [inst_1 : Fintype n] (x y : EuclideanSpace 𝕜 n),
nndist x y = NNReal.sqrt (∑ i, nndist (x.ofLp i) (y.ofLp i) ^ 2) | null | true |
CategoryTheory.Grp.mk | Mathlib.CategoryTheory.Monoidal.Grp | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
(X : C) → [grp : CategoryTheory.GrpObj X] → CategoryTheory.Grp C | null | true |
Finset.emultiplicity_prod | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [IsCancelMulZero α] {β : Type u_3} {p : α},
Prime p → ∀ (s : Finset β) (f : β → α), emultiplicity p (∏ x ∈ s, f x) = ∑ x ∈ s, emultiplicity p (f x) | null | true |
Lean.Linter.MissingDocs.handleMutual | Lean.Linter.MissingDocs | Lean.Linter.MissingDocs.Handler | null | true |
RCLike.conjAe_coe | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], ⇑RCLike.conjAe = ⇑(starRingEnd K) | null | true |
LinearEquiv.ofEq.congr_simp | Mathlib.LinearAlgebra.Basis.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p q : Submodule R M) (h : p = q), LinearEquiv.ofEq p q h = LinearEquiv.ofEq p q h | null | true |
RCLike.im_eq_zero | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.I = 0 → ∀ (z : K), RCLike.im z = 0 | null | true |
CategoryTheory.Limits.BinaryBicone.isBilimitOfCokernelFst._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(b : CategoryTheory.Limits.BinaryBicone X Y) {T : C} (f : X ⟶ T) (g : Y ⟶ T),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryCofan.inl b.toCocone)
(CategoryTheory.CategoryStruct.co... | null | false |
_private.Mathlib.NumberTheory.FLT.Polynomial.0.Polynomial.flt_catalan_aux._simp_1_5 | Mathlib.NumberTheory.FLT.Polynomial | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f x + f y = f (x + y) | null | false |
Std.Format.tag.sizeOf_spec | Init.Data.Format.Basic | ∀ (a : ℕ) (a_1 : Std.Format), sizeOf (Std.Format.tag a a_1) = 1 + sizeOf a + sizeOf a_1 | null | true |
Filter.EventuallyEq.nhdsNE_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜}, f₁ =ᶠ[nhdsWithin x {x}ᶜ] f → deriv f₁ =ᶠ[nhdsWithin x {x}ᶜ] deriv f | null | true |
CategoryTheory.EquivalenceRelation.casesOn | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{R X : C} →
{p₁ p₂ : R ⟶ X} →
{motive : CategoryTheory.EquivalenceRelation p₁ p₂ → Sort u} →
(t : CategoryTheory.EquivalenceRelation p₁ p₂) →
((toReflexiveRelation : CategoryTheory.ReflexiveRelation p₁ p₂) →
... | null | false |
Coalgebra.isSkewPrimitiveElem_map_equiv | Mathlib.RingTheory.Coalgebra.Primitive | ∀ {F : Type u_1} {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : Module R A] [inst_3 : Coalgebra R A] [inst_4 : AddCommMonoid B] [inst_5 : Module R B]
[inst_6 : Coalgebra R B] {g h a : A} [inst_7 : EquivLike F A B] [CoalgEquivClass F R A B] (f : F),
Coalge... | A coalgebra isomorphism preserves skew-primitivity. | true |
List.le_nil._simp_1 | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : LT α] {l : List α}, (l ≤ []) = (l = []) | null | false |
_private.Lean.Meta.RecursorInfo.0.Lean.Meta.getMotiveLevel._sparseCasesOn_1 | Lean.Meta.RecursorInfo | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
_private.Aesop.Tree.Data.0.Aesop.GoalId.succ.match_1 | Aesop.Tree.Data | (motive : Aesop.GoalId → Sort u_1) → (x : Aesop.GoalId) → ((n : ℕ) → motive { toNat := n }) → motive x | null | false |
Std.HashMap.Equiv.getElem!_eq | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α} [inst : Inhabited β], m₁.Equiv m₂ → m₁[k]! = m₂[k]! | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.