name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Polynomial.card_roots_le_map | Mathlib.Algebra.Polynomial.Roots | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : IsDomain A] [inst_3 : IsDomain B]
{p : Polynomial A} {f : A →+* B}, Polynomial.map f p ≠ 0 → p.roots.card ≤ (Polynomial.map f p).roots.card | true |
Lean.Compiler.LCNF.CacheAuxDeclResult.ctorElim | Lean.Compiler.LCNF.AuxDeclCache | {motive : Lean.Compiler.LCNF.CacheAuxDeclResult → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Compiler.LCNF.CacheAuxDeclResult) →
ctorIdx = t.ctorIdx → Lean.Compiler.LCNF.CacheAuxDeclResult.ctorElimType ctorIdx → motive t | false |
mul_invOf_cancel_right | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] (a b : α) [inst_1 : Invertible b], a * b * ⅟b = a | true |
CategoryTheory.Limits.pullbackPullbackRightIsPullback._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X₁ X₂ X₃ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₁)
(f₃ : X₂ ⟶ Y₂) (f₄ : X₃ ⟶ Y₂) [inst_1 : CategoryTheory.Limits.HasPullback f₁ f₂]
[inst_2 : CategoryTheory.Limits.HasPullback f₃ f₄]
[inst_3 :
CategoryTheory.Limits.HasPullback f₁
(CategoryTh... | false |
MonoidHom.coe_mrangeRestrict | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {N : Type u_5} [inst_1 : MulOneClass N] (f : M →* N) (x : M),
↑(f.mrangeRestrict x) = f x | true |
Std.DTreeMap.Internal.Impl.ExplorationStep.casesOn | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{k : α → Ordering} →
{motive : Std.DTreeMap.Internal.Impl.ExplorationStep α β k → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl.ExplorationStep α β k) →
((a : α) →
(a_1 : k a = Ordering.lt) →
(a_... | false |
FreeAlgebra.instNoZeroDivisors | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] [NoZeroDivisors R], NoZeroDivisors (FreeAlgebra R X) | true |
CategoryTheory.Comma.mapLeftId | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
... | true |
Batteries.RBNode.balLeft.match_4.congr_eq_1 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (motive : Batteries.RBNode α → Sort u_2) (l : Batteries.RBNode α)
(h_1 :
(a : Batteries.RBNode α) →
(x : α) → (b : Batteries.RBNode α) → motive (Batteries.RBNode.node Batteries.RBColor.red a x b))
(h_2 : (l : Batteries.RBNode α) → motive l) (a : Batteries.RBNode α) (x : α) (b : Batteries.... | true |
_private.Mathlib.Combinatorics.Enumerative.Catalan.0.gosperCatalan | Mathlib.Combinatorics.Enumerative.Catalan | ℕ → ℕ → ℚ | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementFun.visitLambda | Mathlib.Tactic.Translate.Core | Mathlib.Tactic.Translate.TranslateData →
Lean.Expr →
optParam (Array Lean.Expr) #[] → optParam Lean.LocalContext { } → Mathlib.Tactic.Translate.ReplacementM Lean.Expr | true |
Lean.Lsp.TextDocumentClientCapabilities.completion? | Lean.Data.Lsp.Capabilities | Lean.Lsp.TextDocumentClientCapabilities → Option Lean.Lsp.CompletionClientCapabilities | true |
List.replaceIf | Mathlib.Data.List.Defs | {α : Type u_1} → List α → List Bool → List α → List α | true |
MonCat.FilteredColimits.colimitCocone._proof_2 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J] ⦃X Y : J⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (MonCat.FilteredColimits.coconeMorphism F Y) =
CategoryTheory.CategoryStruct.comp (MonCat.FilteredColimits.coc... | false |
LieEquiv.left_inv | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {L' : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (self : L ≃ₗ⁅R⁆ L'),
Function.LeftInverse self.invFun (↑self.toLieHom).toFun | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.recOn | Lean.Elab.Tactic.Do.Attr | {motive : Lean.Elab.Tactic.Do.SpecAttr.SpecProof → Sort u} →
(t : Lean.Elab.Tactic.Do.SpecAttr.SpecProof) →
((declName : Lean.Name) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecProof.global declName)) →
((fvarId : Lean.FVarId) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local fvarId)) →
((id : Le... | false |
CategoryTheory.SingleFunctors.postcompIsoOfIso_hom_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E] {A : Type u_5}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_22 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (j k : ℕ),
k + 1 ≤ (head :: tail).length → (head :: tail).length + 1 ≤ tail.length → k < tail.length | false |
IsometryEquiv.subRight_apply | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricVAdd Gᵃᵒᵖ G] (c b : G),
(IsometryEquiv.subRight c) b = b - c | true |
PresheafOfModules.Derivation.d_one | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor Dᵒᵖ CommRingCat}
{M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat Ring... | true |
MonoidHom.submonoidComap_surjective_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (N' : Submonoid N),
Function.Surjective ⇑f → Function.Surjective ⇑(f.submonoidComap N') | true |
AddSubmonoidClass.subtype | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_1} →
{A : Type u_3} → [inst : AddZeroClass M] → [inst_1 : SetLike A M] → [hA : AddSubmonoidClass A M] → (S' : A) → ↥S' →+ M | true |
UInt8.add_right_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt8), a + -a = 0 | true |
Lean.Meta.getIntrosSize._unsafe_rec | Lean.Meta.Tactic.Intro | Lean.Expr → ℕ | false |
CategoryTheory.Functor.instMonoidalMonMapAddMon | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
[inst_4 :... | true |
InnerProductSpace.laplacianWithin.congr_simp | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] (f f_1 : E → F),
f = f_1 →
∀ (s s_1 : Set E),
s = s_1 →
∀ (a a_1 : E), a = a_1 → InnerProductSpace.laplacianWit... | true |
Finsupp.lsingle_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]
(a : α) (b : M), (Finsupp.lsingle a) b = fun₀ | a => b | true |
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... | true |
Homeomorph.piSplitAt | Mathlib.Topology.Homeomorph.Lemmas | {ι : Type u_7} →
[DecidableEq ι] →
(i : ι) →
(Y : ι → Type u_8) →
[inst : (j : ι) → TopologicalSpace (Y j)] → ((j : ι) → Y j) ≃ₜ Y i × ((j : { j // j ≠ i }) → Y ↑j) | true |
QuotientAddGroup.preimage_mk_zero | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (N : AddSubgroup α), QuotientAddGroup.mk ⁻¹' {↑0} = ↑N | true |
_private.Lean.Meta.GeneralizeVars.0.Lean.Meta.getFVarSetToGeneralize.match_1 | Lean.Meta.GeneralizeVars | (motive : MProd Lean.FVarIdSet Lean.FVarIdSet → Sort u_1) →
(r : MProd Lean.FVarIdSet Lean.FVarIdSet) → ((r s : Lean.FVarIdSet) → motive ⟨r, s⟩) → motive r | false |
DihedralGroup.Product | Mathlib.GroupTheory.CommutingProbability | List ℕ → Type | 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⟩ | 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... | 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 | false |
Array.append_ne_empty_of_left_ne_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, xs ≠ #[] → xs ++ ys ≠ #[] | 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' | 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₁') (... | true |
Nat.factorial_eq_one._simp_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ {n : ℕ}, (n.factorial = 1) = (n ≤ 1) | false |
Lean.Lsp.SymbolKind.key.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.key = 1 | 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) | 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) | 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) | 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... | true |
GeneralizedBooleanAlgebra.toNonUnitalCommRing._proof_7 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (a : α), symmDiff ⊥ a = a | 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 | 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_11) (fvarId_1 : Lean.FVarId)
(n_1 : ℕ) (check_1 persistent_1 : Bool) (k_1 : Lean.Compiler.LCNF.Code pu)
... | 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 | 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)
... | 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
... | 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, ⋯⟩,
... | 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... | 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) | false |
rightAddCoset_mem_rightAddCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] (s : AddSubgroup α) {a : α}, a ∈ s → AddOpposite.op a +ᵥ ↑s = ↑s | true |
Lean.Order.FlatOrder.rel.refl | Init.Internal.Order.Basic | ∀ {α : Sort u} {b : α} {x : Lean.Order.FlatOrder b}, x.rel x | 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_5} [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 | 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... | 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 | 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 | true |
NonUnitalStarAlgHomClass.map_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | Lean.Syntax | false |
AddSubgroup.isComplement'_top_right._simp_1 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.IsComplement' ⊤ = (H = ⊥) | 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 ⋯ | 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]
{g : CategoryTheory.Over X}, CategoryTheory.Mono (CategoryTheory.Limits.image.ι g.hom) | 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... | true |
Int.Linear.eq_def_cert.eq_1 | Init.Data.Int.Linear | ∀ (x : Int.Linear.Var) (xPoly p : Int.Linear.Poly),
Int.Linear.eq_def_cert x xPoly p = p.beq' (Int.Linear.Poly.add (-1) x xPoly) | true |
NNRatCast.noConfusionType | Mathlib.Data.Rat.Init | Sort u → {K : Type u_1} → NNRatCast K → {K' : Type u_1} → NNRatCast K' → Sort u | 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) | false |
Aesop.StatsExtensionEntry._sizeOf_inst | Aesop.Stats.Extension | SizeOf Aesop.StatsExtensionEntry | false |
pi_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {β : Type v} {X : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (X b)]
[h : ∀ (b : β), ProperSpace (X b)], ProperSpace ((b : β) → X b) | 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 | 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 | 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) | 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⁻¹ | 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 | false |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.Environment.mk.noConfusion | Std.Internal.Async.System | {P : Sort u} →
{toHashMap toHashMap' : Std.HashMap String String} →
{ toHashMap := toHashMap } = { toHashMap := toHashMap' } → (toHashMap = toHashMap' → P) → P | false |
_private.Mathlib.Tactic.Explode.0.Mathlib.Explode.explodeCore.match_11 | Mathlib.Tactic.Explode | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((varName : Lean.Name) →
... | 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 | 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 | 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) | false |
Nat.ne_zero_iff_zero_lt | Init.Data.Nat.Basic | ∀ {n : ℕ}, n ≠ 0 ↔ 0 < n | 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 | 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) | 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.π | true |
System.Platform.numBits_pos._simp_1 | Init.System.Platform | (0 < System.Platform.numBits) = True | 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]
... | 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 = f.right | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.saveState | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.StructInstM✝ Lean.Elab.Term.StructInst.SavedState✝ | true |
_aux_Mathlib_Algebra_Group_Equiv_Defs___unexpand_AddEquiv_1 | Mathlib.Algebra.Group.Equiv.Defs | Lean.PrettyPrinter.Unexpander | 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 | 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 | 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) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((xs : Array Lean.Expr) → (fst : Array Lean.BinderInfo) → (targetTy : Lean.Expr) → motive (xs, fst, targetTy)) →
motive __discr | false |
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) | true |
AlgebraicGeometry.AffineSpace.isOpenMap_over | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {n : Type v} (S : AlgebraicGeometry.Scheme), IsOpenMap ⇑(AlgebraicGeometry.AffineSpace n S ↘ S) | 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 | true |
CategoryTheory.Preadditive.instSemiringEnd._proof_9 | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (n : ℕ) (x : CategoryTheory.End X),
Monoid.npow (n + 1) x = Monoid.npow n x * x | 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... | 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... | 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... | false |
Finset.strongInduction_eq | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {p : Finset α → Sort u_4} (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 | true |
Std.Internal.IO.Async.Signal.sigtstp | Std.Internal.Async.Signal | Std.Internal.IO.Async.Signal | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.