name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
EuclideanGeometry.Sphere.mem_tangentSet_of_mem_tangentsFrom | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {as : AffineSubspace ℝ P} {s : EuclideanGeometry.Sphere P} {p : P},
as ∈ s.tangentsFrom p → as ∈ s.tangentSet | true |
Partrec₂ | Mathlib.Computability.Partrec | {α : Type u_1} →
{β : Type u_2} → {σ : Type u_3} → [Primcodable α] → [Primcodable β] → [Primcodable σ] → (α → β →. σ) → Prop | true |
_private.Lean.Structure.0.Lean.StructureState.mk.noConfusion | Lean.Structure | {P : Sort u} →
{map map' : Lean.PersistentHashMap Lean.Name Lean.StructureInfo} →
{ map := map } = { map := map' } → (map = map' → P) → P | false |
ModuleCon.instAddMonoidQuotient._aux_3 | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_1} →
(M : Type u_2) →
[inst : SMul S M] →
[inst_1 : AddMonoid M] → (c : ModuleCon S M) → ℕ → ModuleCon.Quotient M c → ModuleCon.Quotient M c | false |
if_true_right | Init.PropLemmas | ∀ {p q : Prop} [h : Decidable p], (if p then q else True) ↔ p → q | true |
Lean.Meta.Match.Example.ctor.elim | Lean.Meta.Match.Basic | {motive_1 : Lean.Meta.Match.Example → Sort u} →
(t : Lean.Meta.Match.Example) →
t.ctorIdx = 2 →
((a : Lean.Name) → (a_1 : List Lean.Meta.Match.Example) → motive_1 (Lean.Meta.Match.Example.ctor a a_1)) →
motive_1 t | false |
Lean.ToExpr.toTypeExpr | Lean.ToExpr | (α : Type u) → [self : Lean.ToExpr α] → Lean.Expr | true |
AddMagma.FreeAddSemigroup.map | Mathlib.Algebra.Free | {α : Type u} →
[inst : Add α] →
{β : Type v} → [inst_1 : Add β] → (α →ₙ+ β) → AddMagma.FreeAddSemigroup α →ₙ+ AddMagma.FreeAddSemigroup β | true |
AddActionHom.instCoeTCOfAddActionSemiHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : VAdd M X] {Y : Type u_6} [inst_1 : VAdd N Y]
{F : Type u_8} [inst_2 : FunLike F X Y] [inst_3 : AddActionSemiHomClass F φ X Y],
AddActionHom.instCoeTCOfAddActionSemiHomClass = { coe := AddActionSemiHomClass.toAddActionHom } | true |
Matrix.rank_eq_finrank_range_toLin | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {n : Type un} {R : Type uR} [inst : Fintype n] [inst_1 : CommRing R] [inst_2 : Finite m]
[inst_3 : DecidableEq n] {M₁ : Type u_1} {M₂ : Type u_2} [inst_4 : AddCommGroup M₁] [inst_5 : AddCommGroup M₂]
[inst_6 : Module R M₁] [inst_7 : Module R M₂] (A : Matrix m n R) (v₁ : Module.Basis m R M₁)
(v₂ : ... | true |
Std.DHashMap.Internal.Raw₀.containsThenInsertIfNew_fst | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] {k : α}
{v : β k}, (m.containsThenInsertIfNew k v).1 = m.contains k | true |
Batteries.CodeAction.getMatchHeaderRange? | Batteries.CodeAction.Match | Lean.Syntax → Option Lean.Syntax.Range | true |
CommMonCat.rec | Mathlib.Algebra.Category.MonCat.Basic | {motive : CommMonCat → Sort u_1} →
((carrier : Type u) → [str : CommMonoid carrier] → motive { carrier := carrier, str := str }) →
(t : CommMonCat) → motive t | false |
Multiset.card_nsmul | Mathlib.Algebra.Order.Group.Multiset | ∀ {α : Type u_1} (s : Multiset α) (n : ℕ), (n • s).card = n * s.card | true |
IsUltrametricDist.isNonarchimedean_nnnorm | Mathlib.Analysis.Normed.Group.Ultra | ∀ {R : Type u_4} [inst : SeminormedAddCommGroup R] [IsUltrametricDist R], IsNonarchimedean fun x => ↑‖x‖₊ | true |
CategoryTheory.SimplicialThickening.instCategory._proof_1 | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ (J : Type u_1) [inst : LinearOrder J] {X Y : CategoryTheory.SimplicialThickening J} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f | false |
_private.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.collectProps._unsafe_rec | Lean.Meta.Tactic.Cleanup | StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit | false |
Order.Ico_succ_left_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : α}, ¬IsMax a → Set.Ico (Order.succ a) b = Set.Ioo a b | true |
Std.Time.Week.Offset.ofSeconds | Std.Time.Date.Unit.Week | Std.Time.Second.Offset → Std.Time.Week.Offset | true |
_private.Mathlib.GroupTheory.GroupExtension.Basic.0.GroupExtension.Splitting.semidirectProductToGroupExtensionEquiv._simp_15 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a * a ^ n = a ^ (1 + n) | false |
Lean.Meta.instBEqInstanceEntry | Lean.Meta.Instances | BEq Lean.Meta.InstanceEntry | true |
CategoryTheory.MonObj.one_mul._autoParam | Mathlib.CategoryTheory.Monoidal.Mon_ | Lean.Syntax | false |
Std.DHashMap.Const.get!_modify | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k k' : α} [inst : Inhabited β] {f : β → β},
Std.DHashMap.Const.get! (Std.DHashMap.Const.modify m k f) k' =
if (k == k') = true then (Option.map f (Std.DHashMap.Const.get? m k)).get! else S... | true |
unitsCenterToCenterUnits_injective | Mathlib.GroupTheory.Submonoid.Center | ∀ (M : Type u_1) [inst : Monoid M], Function.Injective ⇑(unitsCenterToCenterUnits M) | true |
BddDistLat.dual | Mathlib.Order.Category.BddDistLat | CategoryTheory.Functor BddDistLat BddDistLat | true |
CircleDeg1Lift.translationNumber_eq_of_semiconj | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ {f g₁ g₂ : CircleDeg1Lift}, Function.Semiconj ⇑f ⇑g₁ ⇑g₂ → g₁.translationNumber = g₂.translationNumber | true |
ZFSet.pairSep | Mathlib.SetTheory.ZFC.Basic | (ZFSet.{u} → ZFSet.{u} → Prop) → ZFSet.{u} → ZFSet.{u} → ZFSet.{u} | true |
WeierstrassCurve.Projective.dblZ | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → R | true |
FreeAddMagma.ctorIdx | Mathlib.Algebra.Free | {α : Type u} → FreeAddMagma α → ℕ | false |
Lean.Grind.LinearOrder.lt_of_not_le | Init.Grind.Ordered.Order | ∀ {α : Type u} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [Std.IsLinearOrder α] {a b : α}, ¬a ≤ b → b < a | true |
Homeomorph.uniqueProd_symm_apply_snd | Mathlib.Topology.Homeomorph.Lemmas | ∀ (X : Type u_7) (Y : Type u_8) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : Unique X] (a : Y),
((Homeomorph.uniqueProd X Y).symm a).2 = ((Homeomorph.prodUnique Y X).symm a).1 | true |
Lean.Grind.AC.instBEqExpr.beq._sparseCasesOn_1 | Init.Grind.AC | {motive : Lean.Grind.AC.Expr → Sort u} →
(t : Lean.Grind.AC.Expr) →
((x : Lean.Grind.AC.Var) → motive (Lean.Grind.AC.Expr.var x)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Meta.Tactic.Grind.Propagate.0.Lean.Meta.Grind.applyCongrFun.go._unary._proof_1 | Lean.Meta.Tactic.Grind.Propagate | ∀ (args : Array Lean.Expr) (rhs h : Lean.Expr) (i : ℕ) (_h : i < args.size) (h' : Lean.Expr),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun rhs h => PSigma.casesOn h fun h i => args.size - i)
⟨Lean.mkApp rhs args[i], ⟨h', i + 1⟩⟩ ⟨rhs, ⟨h, i⟩⟩ | false |
Finset.inf'_eq_inf | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {s : Finset β} (H : s.Nonempty)
(f : β → α), s.inf' H f = s.inf f | true |
groupHomology.boundaries₁._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k : Type u_1} [inst : CommRing k], RingHomSurjective (RingHom.id k) | false |
Lean.Meta.NormCast.countHeadCoes._unsafe_rec | Lean.Meta.Tactic.NormCast | Lean.Expr → Lean.MetaM ℕ | false |
MonoidHom.fintypeMrange | Mathlib.Algebra.Group.Subgroup.Finite | {M : Type u_4} →
{N : Type u_5} →
[inst : Monoid M] →
[inst_1 : Monoid N] → [Fintype M] → [DecidableEq N] → (f : M →* N) → Fintype ↥(MonoidHom.mrange f) | true |
Ideal.basisSpanSingleton._proof_1 | Mathlib.RingTheory.Ideal.Basis | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
IsScalarTower R S S | false |
Lean.Lsp.WorkspaceSymbolParams.rec | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.WorkspaceSymbolParams → Sort u} →
((query : String) → motive { query := query }) → (t : Lean.Lsp.WorkspaceSymbolParams) → motive t | false |
AddHomClass.toAddHom | Mathlib.Algebra.Group.Hom.Defs | {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 → M →ₙ+ N | true |
UInt16.toUInt32_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, a.toUInt32 < b.toUInt32 ↔ a < b | true |
GradedEquivLike.toGradedFunLike | Mathlib.Data.FunLike.Graded | ∀ (E : Type u_1) {A : Type u_2} {B : Type u_3} {σ : Type u_4} {τ : Type u_5} {ι : Type u_6} [inst : SetLike σ A]
[inst_1 : SetLike τ B] (𝒜 : ι → σ) (ℬ : ι → τ) [inst_2 : EquivLike E A B] [GradedEquivLike E 𝒜 ℬ], GradedFunLike E 𝒜 ℬ | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_of_length_eq._proof_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] {l₁ l₂ : List ((a : α) × β a)},
l₂.length = l₁.length →
∀ (a : α),
l₁.length ≤ (Std.Internal.List.eraseKey a l₂).length ∧ 1 + (Std.Internal.List.eraseKey a l₂).length = l₂.length →
False | false |
Finset.card_image_of_injOn | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {f : α → β} [inst : DecidableEq β],
Set.InjOn f ↑s → (Finset.image f s).card = s.card | true |
ZNum.cast_zero' | Mathlib.Data.Num.ZNum | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : Add α] [inst_3 : Neg α], ↑ZNum.zero = 0 | true |
Char.any._proof_2 | Batteries.Data.Char.Basic | ∀ c < Char.max - Char.maxSurrogate, 57343 < c + Char.maxSurrogate + 1 ∧ c + Char.maxSurrogate + 1 < 1114112 | false |
_private.Lean.Compiler.IR.ExpandResetReuse.0.Lean.IR.ExpandResetReuse.consumed.match_4 | Lean.Compiler.IR.ExpandResetReuse | (motive : Lean.IR.FnBody → Sort u_1) →
(x : Lean.IR.FnBody) →
((x : Lean.IR.VarId) →
(ty : Lean.IR.IRType) → (v : Lean.IR.Expr) → (b : Lean.IR.FnBody) → motive (Lean.IR.FnBody.vdecl x ty v b)) →
((y : Lean.IR.VarId) →
(n : ℕ) → (c persistent : Bool) → (b : Lean.IR.FnBody) → motive (Lean.IR... | false |
Fin.partialProd_left_inv | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} {G : Type u_3} [inst : Group G] (f : Fin (n + 1) → G),
(f 0 • Fin.partialProd fun i => (f i.castSucc)⁻¹ * f i.succ) = f | true |
CategoryTheory.Limits.Fan.IsLimit.prod._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {ι : Type u_1} {ι' : Type u_2} {X : ι → ι' → C}
(c : (i : ι) → CategoryTheory.Limits.Fan fun j => X i j) (hc : (i : ι) → CategoryTheory.Limits.IsLimit (c i))
(c' : CategoryTheory.Limits.Fan fun i => (c i).pt) (hc' : CategoryTheory.Limits.IsLimit c')
(... | false |
Matrix.ofNat_fin_two | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} [inst : AddMonoidWithOne α] (n : ℕ) [inst_1 : n.AtLeastTwo],
OfNat.ofNat n = !![OfNat.ofNat n, 0; 0, OfNat.ofNat n] | true |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Real.0.Real.finiteSpanningSetsInIooRat._simp_2 | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
_private.Mathlib.Tactic.IrreducibleDef.0.Lean.Elab.Command._aux_Mathlib_Tactic_IrreducibleDef___elabRules_Lean_Elab_Command_command_Irreducible_def_____1.match_11 | Mathlib.Tactic.IrreducibleDef | (motive : Lean.TSyntax `ident × Option (Lean.Syntax.TSepArray `ident ",") → Sort u_1) →
(__discr : Lean.TSyntax `ident × Option (Lean.Syntax.TSepArray `ident ",")) →
((n : Lean.TSyntax `ident) → (us : Option (Lean.Syntax.TSepArray `ident ",")) → motive (n, us)) → motive __discr | false |
CategoryTheory.Grp.mkIso'.eq_1 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G H : C} (e : G ≅ H) [inst_2 : CategoryTheory.GrpObj G] [inst_3 : CategoryTheory.GrpObj H]
[inst_4 : CategoryTheory.IsMonHom e.hom],
CategoryTheory.Grp.mkIso' e = (CategoryTheory.Grp.fullyFaithfulFor... | true |
ModuleCat.FilteredColimits.colimitMulAction._proof_1 | Mathlib.Algebra.Category.ModuleCat.FilteredColimits | ∀ {R : Type u_1} [inst : Ring R] {J : Type u_2} [inst_1 : CategoryTheory.SmallCategory J]
[inst_2 : CategoryTheory.IsFiltered J] (F : CategoryTheory.Functor J (ModuleCat R)) (r s : R)
(x : ↑(ModuleCat.FilteredColimits.M F)), (r * s) • x = r • s • x | false |
Lean.IR.EmitLLVM.emitJmp | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} →
LLVM.Builder llvmctx → Lean.IR.JoinPointId → Array Lean.IR.Arg → Lean.IR.EmitLLVM.M llvmctx Unit | true |
Multiset.covBy_cons._simp_1 | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} (s : Multiset α) (a : α), (s ⋖ a ::ₘ s) = True | false |
Aesop.GoalKind.ctorElim | Aesop.Stats.Basic | {motive : Aesop.GoalKind → Sort u} →
(ctorIdx : ℕ) → (t : Aesop.GoalKind) → ctorIdx = t.ctorIdx → Aesop.GoalKind.ctorElimType ctorIdx → motive t | false |
Bornology.ofBounded' | Mathlib.Topology.Bornology.Basic | {α : Type u_4} →
(B : Set (Set α)) →
∅ ∈ B → (∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B) → (∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B) → ⋃₀ B = Set.univ → Bornology α | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.checkAndAddSplitCandidate.match_4 | Lean.Meta.Tactic.Grind.Internalize | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive x | false |
Nat.succ_le | Init.Data.Nat.Lemmas | ∀ {n m : ℕ}, n.succ ≤ m ↔ n < m | true |
convexHull_exists_dist_ge | Mathlib.Analysis.Normed.Module.Convex | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E} {x : E},
x ∈ (convexHull ℝ) s → ∀ (y : E), ∃ x' ∈ s, dist x y ≤ dist x' y | true |
Equiv.psigmaCongrRight_trans | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_4} {β₁ : α → Sort u_1} {β₂ : α → Sort u_2} {β₃ : α → Sort u_3} (F : (a : α) → β₁ a ≃ β₂ a)
(G : (a : α) → β₂ a ≃ β₃ a),
(Equiv.psigmaCongrRight F).trans (Equiv.psigmaCongrRight G) = Equiv.psigmaCongrRight fun a => (F a).trans (G a) | true |
CategoryTheory.PreGaloisCategory.toAutMulEquiv_isHomeomorph | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.GaloisCategory C] (G : Type u_1) [inst_2 : Group G]
[inst_3 : (X : C) → MulAction G (F.obj X).obj] [inst_4 : CategoryTheory.PreGaloisCategory.FiberFunctor F]
[inst_5 : TopologicalSpace G]... | true |
Std.OrientedCmp.not_lt_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α}, cmp a b = Ordering.lt → cmp b a ≠ Ordering.lt | true |
SimpleGraph.boxProdComm._proof_1 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} (G : SimpleGraph α) (H : SimpleGraph β) {a b : α × β},
H.Adj ((Equiv.prodComm α β) a).1 ((Equiv.prodComm α β) b).1 ∧
((Equiv.prodComm α β) a).2 = ((Equiv.prodComm α β) b).2 ∨
G.Adj ((Equiv.prodComm α β) a).2 ((Equiv.prodComm α β) b).2 ∧
((Equiv.prodComm α β) a).1 ... | false |
Batteries.RBMap.foldr | Batteries.Data.RBMap.Basic | {α : Type u} →
{β : Type v} → {σ : Type w} → {cmp : α → α → Ordering} → (α → β → σ → σ) → σ → Batteries.RBMap α β cmp → σ | true |
_private.Mathlib.Analysis.FunctionalSpaces.SobolevInequality.0._aux_Mathlib_Analysis_FunctionalSpaces_SobolevInequality___unexpand_Fintype_card_1 | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | Lean.PrettyPrinter.Unexpander | false |
CategoryTheory.Functor.CoconeTypes.IsColimitCore.noConfusionType | Mathlib.CategoryTheory.Limits.Types.ColimitType | Sort u_1 →
{J : Type u} →
[inst : CategoryTheory.Category.{v, u} J] →
{F : CategoryTheory.Functor J (Type w₀)} →
{c : F.CoconeTypes} →
c.IsColimitCore →
{J' : Type u} →
[inst' : CategoryTheory.Category.{v, u} J'] →
{F' : CategoryTheory.Functor J' (... | false |
localCohomology.SelfLERadical.castEquivalence | Mathlib.Algebra.Homology.LocalCohomology | {R : Type u} →
[inst : CommRing R] →
{J K : Ideal R} → J.radical = K.radical → (localCohomology.SelfLERadical J ≌ localCohomology.SelfLERadical K) | true |
_private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.tryIntros.match_1 | Lean.Elab.Tactic.Ext | (motive : List (Lean.TSyntax `rcasesPat) → Sort u_1) →
(pats : List (Lean.TSyntax `rcasesPat)) →
(Unit → motive []) →
((p : Lean.TSyntax `rcasesPat) → (ps : List (Lean.TSyntax `rcasesPat)) → motive (p :: ps)) → motive pats | false |
CategoryTheory.Sheaf.instAddCommGroupH | Mathlib.CategoryTheory.Sites.SheafCohomology.Basic | {C : Type u_4} →
[inst : CategoryTheory.Category.{u_3, u_4} C] →
{J : CategoryTheory.GrothendieckTopology C} →
(F : CategoryTheory.Sheaf J AddCommGrpCat) →
[inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat] →
[inst_2 : CategoryTheory.HasExt (CategoryTheory.Sheaf J AddCommGrpCat)] → (n :... | true |
AddCon.comap.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (f : M → N) (H : ∀ (x y : M), f (x + y) = f x + f y)
(c : AddCon N), AddCon.comap f H c = { toSetoid := Setoid.comap f c.toSetoid, add' := ⋯ } | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.uniformity_basis_dist_le_pow.match_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {r : ℝ} (_ε : ℝ) (motive : (∃ n, r ^ n < _ε) → Prop) (x : ∃ n, r ^ n < _ε),
(∀ (n : ℕ) (hn : r ^ n < _ε), motive ⋯) → motive x | false |
QuaternionAlgebra.mk.sizeOf_spec | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {a b c : R} [inst : SizeOf R] (re imI imJ imK : R),
sizeOf { re := re, imI := imI, imJ := imJ, imK := imK } = 1 + sizeOf re + sizeOf imI + sizeOf imJ + sizeOf imK | true |
Lean.Meta.Grind.SplitSource.toMessageData | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SplitSource → Lean.MessageData | true |
Lean.Doc.Context.mk.inj | Lean.Elab.DocString | ∀ {suggestionMode suggestionMode_1 : Lean.Doc.SuggestionMode},
{ suggestionMode := suggestionMode } = { suggestionMode := suggestionMode_1 } → suggestionMode = suggestionMode_1 | true |
Polynomial.roots_expand_pow_image_iterateFrobenius_subset | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] (p n : ℕ) [inst_2 : ExpChar R p] (f : Polynomial R)
[inst_3 : DecidableEq R],
Finset.image (⇑(iterateFrobenius R p n)) ((Polynomial.expand R (p ^ n)) f).roots.toFinset ⊆ f.roots.toFinset | true |
CategoryTheory.Abelian.PullbackToBiproductIsKernel.isLimitPullbackToBiproduct | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.Limits.HasPullbacks C] →
{X Y Z : C} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
CategoryTheory.Limits.IsLimit
(CategoryTheory.Abelian.Pullb... | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.tendsto_nhds_infty._simp_1_2 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | false |
AddMonoidHomClass.toAddHomClass | Mathlib.Algebra.Group.Hom.Defs | ∀ {F : Type u_10} {M : outParam (Type u_11)} {N : outParam (Type u_12)} {inst : AddZero M} {inst_1 : AddZero N}
{inst_2 : FunLike F M N} [self : AddMonoidHomClass F M N], AddHomClass F M N | true |
IsPRadical | Mathlib.FieldTheory.IsPerfectClosure | {K : Type u_1} → {L : Type u_2} → [inst : CommSemiring K] → [inst_1 : CommSemiring L] → (K →+* L) → ℕ → Prop | true |
Lean.Elab.Tactic.elabGrindPattern | Lean.Elab.Tactic.Grind.Main | Lean.Elab.Command.CommandElab | true |
_private.Mathlib.Algebra.MvPolynomial.Degrees.0.MvPolynomial.degreeOf_le_totalDegree._proof_1_1 | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u_2} {σ : Type u_1} [inst : CommSemiring R] (f : MvPolynomial σ R) (i : σ) (d : σ →₀ ℕ),
d i = 0 → d i ≤ f.totalDegree | false |
Mathlib.Tactic.BicategoryLike.NormalExpr.tgtM | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ m] →
Mathlib.Tactic.BicategoryLike.NormalExpr → m Mathlib.Tactic.BicategoryLike.Mor₁ | true |
_private.Mathlib.Tactic.NormNum.NatFactorial.0.Mathlib.Meta.NormNum.evalNatDescFactorial._proof_3 | Mathlib.Tactic.NormNum.NatFactorial | ∀ (x y z : Q(ℕ)), «$y» =Q «$z» + «$x» + 1 | false |
Finsupp.toMultiset_sum | Mathlib.Data.Finsupp.Multiset | ∀ {α : Type u_1} {ι : Type u_3} {f : ι → α →₀ ℕ} (s : Finset ι),
Finsupp.toMultiset (∑ i ∈ s, f i) = ∑ i ∈ s, Finsupp.toMultiset (f i) | true |
Module.AEval.X_smul_of | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_2} {A : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (m : M), Polynomial.X • (Module.AEval.of R M a) m = (Module.AEval.of R M a) (a • m) | true |
_private.Init.Data.List.Attach.0.List.findSome?.match_1.splitter | Init.Data.List.Attach | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → ((b : β) → motive (some b)) → (Unit → motive none) → motive x | true |
ContinuousLinearEquiv.finTwoArrow_symm_apply | Mathlib.Topology.Algebra.Module.Equiv | ∀ (R : Type u_2) (M : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace M], ⇑(ContinuousLinearEquiv.finTwoArrow R M).symm = fun x => ![x.1, x.2] | true |
Aesop.IndexMatchResult.mk | Aesop.Index.Basic | {α : Type} → α → Array Aesop.IndexMatchLocation → Option (Array Aesop.Substitution) → Aesop.IndexMatchResult α | true |
_private.Mathlib.Combinatorics.SimpleGraph.FiveWheelLike.0.SimpleGraph.sum_degree_le_of_le_not_adj._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | ∀ {α : Type u_1} {G : SimpleGraph α} {i : ℕ} [inst : DecidableRel G.Adj] {W X : Finset α},
(∀ x ∈ X, i ≤ {z ∈ W | ¬G.Adj x z}.card) → ∀ i_1 ∈ X, {w ∈ W | G.Adj i_1 w}.card ≤ W.card - i | false |
Holor.instAddMonoid._proof_2 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : AddMonoid α] (a : Holor α ds), a + 0 = a | false |
Lean.Elab.Command.reproveDecl | Lean.Util.Reprove | Lean.Name → Lean.TSyntax `Lean.Parser.Tactic.tacticSeq → Lean.Elab.Command.CommandElabM Unit | true |
AlgebraicGeometry.Proj.basicOpen_pow | 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) (n : ℕ),
0 < n → AlgebraicGeometry.Proj.basicOpen 𝒜 (f ^ n) = AlgebraicGeometry.Proj.basicOpen 𝒜 f | true |
CategoryTheory.ShortComplex.LeftHomologyData.K | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → {S : CategoryTheory.ShortComplex C} → S.LeftHomologyData → C | true |
Subgroup.strictPeriods_eq_zmultiples_strictWidthInfty | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {𝒢 : Subgroup (GL (Fin 2) ℝ)} [DiscreteTopology ↥𝒢.strictPeriods],
𝒢.strictPeriods = AddSubgroup.zmultiples 𝒢.strictWidthInfty | true |
Std.Internal.List.insertList_insertEntry_right_equiv_insertEntry_insertList | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((a : α) × β a)} (p : (a : α) × β a),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.DistinctKeys toInsert →
(Std.Internal.List.insertList l (Std.Internal.List.insertEntry p.fst p.snd toInsert)).Perm
(Std.Internal.L... | true |
_private.Mathlib.Data.Prod.Basic.0.Prod.total_left.match_1 | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} (motive : α × β → Prop) (x : α × β), (∀ (a₂ : α) (snd : β), motive (a₂, snd)) → motive x | false |
instConditionallyCompleteLinearOrder._proof_12 | Mathlib.Data.Int.ConditionallyCompleteOrder | ∀ (s : Set ℤ) (h : s.Nonempty ∧ BddBelow s), Classical.choose ⋯ ∈ lowerBounds s | false |
VectorBundleCore.noConfusion | Mathlib.Topology.VectorBundle.Basic | {P : Sort u} →
{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} →
{t : VectorBund... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.