name
string | module
string | type
string |
|---|---|---|
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofGoal.match_3
|
Aesop.Tree.ExtractProof
|
(motive : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment) → Sort u_1) →
(__discr : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment)) →
((postNormGoal : Lean.MVarId) →
(children : Array Aesop.RappRef) →
(postNormEnv : Lean.Environment) → motive (some (postNormGoal, children, postNormEnv))) →
((x : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment)) → motive x) → motive __discr
|
QuotientGroup.fintypeQuotientRightRel
|
Mathlib.GroupTheory.Coset.Card
|
{α : Type u_1} → [inst : Group α] → {s : Subgroup α} → [Fintype (α ⧸ s)] → Fintype (Quotient (QuotientGroup.rightRel s))
|
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Reify.0.Lean.Meta.Grind.Arith.Linear.reify?.isOfNatZero
|
Lean.Meta.Tactic.Grind.Arith.Linear.Reify
|
Lean.Expr → Lean.Meta.Grind.Arith.Linear.LinearM Bool
|
Lean.Omega.IntList.mul_get
|
Init.Omega.IntList
|
∀ (xs ys : Lean.Omega.IntList) (i : ℕ), (xs * ys).get i = xs.get i * ys.get i
|
Lean.Elab.MonadAutoImplicits.casesOn
|
Lean.Elab.InfoTree.Types
|
{m : Type → Type} →
{motive : Lean.Elab.MonadAutoImplicits m → Sort u} →
(t : Lean.Elab.MonadAutoImplicits m) →
((getAutoImplicits : m (Array Lean.Expr)) → motive { getAutoImplicits := getAutoImplicits }) → motive t
|
Batteries.RBNode.foldr_reverse
|
Batteries.Data.RBMap.Lemmas
|
∀ {α : Type u_1} {β : Type u_2} {t : Batteries.RBNode α} {f : α → β → β} {init : β},
Batteries.RBNode.foldr f t.reverse init = Batteries.RBNode.foldl (flip f) init t
|
lift_nhds_left
|
Mathlib.Topology.UniformSpace.Defs
|
∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] {x : α} {g : Set α → Filter β},
Monotone g → (nhds x).lift g = (uniformity α).lift fun s => g (UniformSpace.ball x s)
|
Option.get!_none
|
Init.Data.Option.Lemmas
|
∀ {α : Type u_1} [inst : Inhabited α], none.get! = default
|
_private.Lean.Compiler.LCNF.Simp.SimpM.0.Lean.Compiler.LCNF.Simp.withIncRecDepth.throwMaxRecDepth.match_3
|
Lean.Compiler.LCNF.Simp.SimpM
|
(motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) →
(Unit → motive []) → ((declName : Lean.Name) → (stack : List Lean.Name) → motive (declName :: stack)) → motive x
|
_private.Mathlib.Data.Set.Prod.0.Set.pi_inter_distrib._proof_1_1
|
Mathlib.Data.Set.Prod
|
∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t t₁ : (i : ι) → Set (α i)},
(s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁
|
_private.Init.Data.Iterators.Lemmas.Combinators.FlatMap.0.Std.Iterators.Iter.step_filterMapWithPostcondition.match_3.eq_3
|
Init.Data.Iterators.Lemmas.Combinators.FlatMap
|
∀ {α β : Type u_1} [inst : Std.Iterators.Iterator α Id β] {it : Std.Iter β} (motive : it.Step → Sort u_2)
(h : it.IsPlausibleStep Std.Iterators.IterStep.done)
(h_1 :
(it' : Std.Iter β) →
(out : β) →
(h : it.IsPlausibleStep (Std.Iterators.IterStep.yield it' out)) →
motive ⟨Std.Iterators.IterStep.yield it' out, h⟩)
(h_2 :
(it' : Std.Iter β) →
(h : it.IsPlausibleStep (Std.Iterators.IterStep.skip it')) → motive ⟨Std.Iterators.IterStep.skip it', h⟩)
(h_3 : (h : it.IsPlausibleStep Std.Iterators.IterStep.done) → motive ⟨Std.Iterators.IterStep.done, h⟩),
(match ⟨Std.Iterators.IterStep.done, h⟩ with
| ⟨Std.Iterators.IterStep.yield it' out, h⟩ => h_1 it' out h
| ⟨Std.Iterators.IterStep.skip it', h⟩ => h_2 it' h
| ⟨Std.Iterators.IterStep.done, h⟩ => h_3 h) =
h_3 h
|
sub_lt_comm
|
Mathlib.Algebra.Order.Group.Unbundled.Basic
|
∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, a - b < c ↔ a - c < b
|
PadicInt.withValIntegersRingEquiv
|
Mathlib.NumberTheory.Padics.WithVal
|
{p : ℕ} → [inst : Fact (Nat.Prime p)] → ↥(Valued.integer (Rat.padicValuation p).Completion) ≃+* ℤ_[p]
|
CategoryTheory.Limits.Cofork.ext._proof_3
|
Mathlib.CategoryTheory.Limits.Shapes.Equalizers
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y}
{s t : CategoryTheory.Limits.Cofork f g} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.mkHom i.inv ⋯)
(CategoryTheory.Limits.Cofork.mkHom i.hom w) =
CategoryTheory.CategoryStruct.id t
|
Std.PRange.Least?.recOn
|
Init.Data.Range.Polymorphic.UpwardEnumerable
|
{α : Type u} →
{motive : Std.PRange.Least? α → Sort u_1} →
(t : Std.PRange.Least? α) → ((least? : Option α) → motive { least? := least? }) → motive t
|
ContinuousMap.Homotopy.casesOn
|
Mathlib.Topology.Homotopy.Basic
|
{X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} →
{motive : f₀.Homotopy f₁ → Sort u_1} →
(t : f₀.Homotopy f₁) →
((toContinuousMap : C(↑unitInterval × X, Y)) →
(map_zero_left : ∀ (x : X), toContinuousMap.toFun (0, x) = f₀ x) →
(map_one_left : ∀ (x : X), toContinuousMap.toFun (1, x) = f₁ x) →
motive
{ toContinuousMap := toContinuousMap, map_zero_left := map_zero_left,
map_one_left := map_one_left }) →
motive t
|
AddHomClass.toAddHom.eq_1
|
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]
[inst_3 : AddHomClass F M N] (f : F), ↑f = { toFun := ⇑f, map_add' := ⋯ }
|
TopologicalSpace.NonemptyCompacts.coe_map
|
Mathlib.Topology.Sets.Compacts
|
∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β}
(hf : Continuous f) (s : TopologicalSpace.NonemptyCompacts α),
↑(TopologicalSpace.NonemptyCompacts.map f hf s) = f '' ↑s
|
Std.PreorderPackage.ofLE._proof_3
|
Init.Data.Order.PackageFactories
|
∀ (α : Type u_1) (args : Std.Packages.PreorderOfLEArgs α), Std.IsPreorder α
|
_private.Mathlib.Analysis.Convex.Function.0.strictConvexOn_iff_div._simp_1_1
|
Mathlib.Analysis.Convex.Function
|
∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True
|
Subring.mem_mk'._simp_1
|
Mathlib.Algebra.Ring.Subring.Defs
|
∀ {R : Type u} [inst : Ring R] {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubgroup R} (ha : ↑sa = s)
{x : R}, (x ∈ Subring.mk' s sm sa hm ha) = (x ∈ s)
|
IsLowerSet.null_frontier
|
Mathlib.MeasureTheory.Order.UpperLower
|
∀ {ι : Type u_1} [inst : Fintype ι] {s : Set (ι → ℝ)}, IsLowerSet s → MeasureTheory.volume (frontier s) = 0
|
_private.Aesop.RuleSet.0.Aesop.BaseRuleSet.merge.match_1
|
Aesop.RuleSet
|
(motive : Option (Aesop.UnorderedArraySet Aesop.RuleName) → Sort u_1) →
(x : Option (Aesop.UnorderedArraySet Aesop.RuleName)) →
(Unit → motive none) → ((ns : Aesop.UnorderedArraySet Aesop.RuleName) → motive (some ns)) → motive x
|
MulEquiv.symmEquiv_apply_apply
|
Mathlib.Algebra.Group.Equiv.Defs
|
∀ (P : Type u_9) (Q : Type u_10) [inst : Mul P] [inst_1 : Mul Q] (h : P ≃* Q) (a : Q),
((MulEquiv.symmEquiv P Q) h) a = h.symm a
|
CategoryTheory.Oplax.OplaxTrans.naturality_comp_assoc
|
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax
|
∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (self : CategoryTheory.Oplax.OplaxTrans F G) {a b c : B} (f : a ⟶ b)
(g : b ⟶ c) {Z : F.obj a ⟶ G.obj c}
(h : CategoryTheory.CategoryStruct.comp (self.app a) (CategoryTheory.CategoryStruct.comp (G.map f) (G.map g)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.naturality (CategoryTheory.CategoryStruct.comp f g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (self.app a) (G.mapComp f g)) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapComp f g) (self.app c))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (F.map g) (self.app c)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (self.naturality g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (self.app b) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (self.naturality f) (G.map g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (self.app a) (G.map f) (G.map g)).hom h)))))
|
MeasureTheory.measureUnivNNReal
|
Mathlib.MeasureTheory.Measure.Typeclasses.Finite
|
{α : Type u_1} → {m0 : MeasurableSpace α} → MeasureTheory.Measure α → NNReal
|
Lean.Server.Watchdog.handleDidChange
|
Lean.Server.Watchdog
|
Lean.Lsp.DidChangeTextDocumentParams → Lean.Server.Watchdog.ServerM Unit
|
isPRadical_iff
|
Mathlib.FieldTheory.IsPerfectClosure
|
∀ {K : Type u_1} {L : Type u_2} [inst : CommSemiring K] [inst_1 : CommSemiring L] (i : K →+* L) (p : ℕ),
IsPRadical i p ↔ (∀ (x : L), ∃ n y, i y = x ^ p ^ n) ∧ RingHom.ker i ≤ pNilradical K p
|
Filter.Tendsto.nonpos_add_atBot
|
Mathlib.Order.Filter.AtTopBot.Monoid
|
∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [IsOrderedAddMonoid M] {l : Filter α}
{f g : α → M},
(∀ (x : α), f x ≤ 0) → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x + g x) l Filter.atBot
|
MeasureTheory.eLpNorm_conj
|
Mathlib.MeasureTheory.Function.LpSeminorm.Basic
|
∀ {α : Type u_1} {m0 : MeasurableSpace α} {𝕜 : Type u_7} [inst : RCLike 𝕜] (f : α → 𝕜) (p : ENNReal)
(μ : MeasureTheory.Measure α), MeasureTheory.eLpNorm ((starRingEnd (α → 𝕜)) f) p μ = MeasureTheory.eLpNorm f p μ
|
Std.Internal.IO.Process.ResourceUsageStats.casesOn
|
Std.Internal.Async.Process
|
{motive : Std.Internal.IO.Process.ResourceUsageStats → Sort u} →
(t : Std.Internal.IO.Process.ResourceUsageStats) →
((cpuUserTime cpuSystemTime : Std.Time.Millisecond.Offset) →
(peakResidentSetSizeKb sharedMemorySizeKb unsharedDataSizeKb unsharedStackSizeKb minorPageFaults majorPageFaults
swapOperations blockInputOps blockOutputOps messagesSent messagesReceived signalsReceived
voluntaryContextSwitches involuntaryContextSwitches : UInt64) →
motive
{ cpuUserTime := cpuUserTime, cpuSystemTime := cpuSystemTime,
peakResidentSetSizeKb := peakResidentSetSizeKb, sharedMemorySizeKb := sharedMemorySizeKb,
unsharedDataSizeKb := unsharedDataSizeKb, unsharedStackSizeKb := unsharedStackSizeKb,
minorPageFaults := minorPageFaults, majorPageFaults := majorPageFaults, swapOperations := swapOperations,
blockInputOps := blockInputOps, blockOutputOps := blockOutputOps, messagesSent := messagesSent,
messagesReceived := messagesReceived, signalsReceived := signalsReceived,
voluntaryContextSwitches := voluntaryContextSwitches,
involuntaryContextSwitches := involuntaryContextSwitches }) →
motive t
|
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.Submodule.le_linearEquiv_of_sSup_eq_top.match_1_3
|
Mathlib.RingTheory.SimpleModule.Isotypic
|
∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
(s : Set (Submodule R M)) (w : Submodule R M) (compl : IsCompl N w)
(motive : (∃ m ∈ s, N.linearProjOfIsCompl w compl ∘ₗ m.subtype ≠ 0) → Prop)
(x : ∃ m ∈ s, N.linearProjOfIsCompl w compl ∘ₗ m.subtype ≠ 0),
(∀ (m : Submodule R M) (hm : m ∈ s) (ne : N.linearProjOfIsCompl w compl ∘ₗ m.subtype ≠ 0), motive ⋯) → motive x
|
IsNilpotent.charpoly_eq_X_pow_finrank
|
Mathlib.LinearAlgebra.Eigenspace.Zero
|
∀ {R : Type u_1} {M : Type u_3} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inst_4 : Module.Finite R M] [inst_5 : Module.Free R M] {φ : Module.End R M},
IsNilpotent φ → LinearMap.charpoly φ = Polynomial.X ^ Module.finrank R M
|
Lean.Meta.DefEqCacheKind.toCtorIdx
|
Lean.Meta.ExprDefEq
|
Lean.Meta.DefEqCacheKind → ℕ
|
Std.TreeSet.get?_erase
|
Std.Data.TreeSet.Lemmas
|
∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k a : α},
(t.erase k).get? a = if cmp k a = Ordering.eq then none else t.get? a
|
Subsemiring.instCompleteLattice._proof_2
|
Mathlib.Algebra.Ring.Subsemiring.Basic
|
∀ {R : Type u_1} [inst : NonAssocSemiring R] (x x_1 : Subsemiring R) (x_2 : R), x_2 ∈ ↑x ∧ x_2 ∈ ↑x_1 → x_2 ∈ ↑x
|
BitVec.toInt_neg_of_msb_true
|
Init.Data.BitVec.Lemmas
|
∀ {w : ℕ} {x : BitVec w}, x.msb = true → x.toInt < 0
|
CategoryTheory.Limits.HasZeroObject.instMono
|
Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] {X : C}
(f : 0 ⟶ X), CategoryTheory.Mono f
|
Qq.getLevelQ
|
Mathlib.Util.Qq
|
Lean.Expr → Lean.MetaM ((u : Lean.Level) × Q(Sort u))
|
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.jacobson_eq_top_iff.match_1_3
|
Mathlib.RingTheory.Jacobson.Ideal
|
∀ {R : Type u_1} [inst : Ring R] {I : Ideal R} (x : Ideal R) (motive : x ∈ {J | I ≤ J ∧ J.IsMaximal} → Prop)
(x_1 : x ∈ {J | I ≤ J ∧ J.IsMaximal}), (∀ (hij : I ≤ x) (right : x.IsMaximal), motive ⋯) → motive x_1
|
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.NatOffset.ctorElim
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat
|
{motive : Nat.NatOffset✝ → Sort u} →
(ctorIdx : ℕ) →
(t : Nat.NatOffset✝¹) → ctorIdx = Nat.NatOffset.ctorIdx✝ t → Nat.NatOffset.ctorElimType✝ ctorIdx → motive t
|
CategoryTheory.Equivalence.counitInv_app_tensor_comp_functor_map_δ_inverse_assoc
|
Mathlib.CategoryTheory.Monoidal.Functor
|
∀ {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] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal] (X Y : C) {Z : D}
(h :
e.functor.obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj (e.functor.obj X))
(e.inverse.obj (e.functor.obj Y))) ⟶
Z),
CategoryTheory.CategoryStruct.comp
(e.counitInv.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.functor.obj X) (e.functor.obj Y)))
(CategoryTheory.CategoryStruct.comp
(e.functor.map (CategoryTheory.Functor.OplaxMonoidal.δ e.inverse (e.functor.obj X) (e.functor.obj Y))) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ e.functor X Y)
(CategoryTheory.CategoryStruct.comp
(e.functor.map (CategoryTheory.MonoidalCategoryStruct.tensorHom (e.unitIso.hom.app X) (e.unitIso.hom.app Y))) h)
|
UpperSet.instAddCommMonoid._proof_1
|
Mathlib.Algebra.Order.UpperLower
|
∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedAddMonoid α] (s : UpperSet α),
s + 0 = s
|
SupBotHom.cancel_left._simp_1
|
Mathlib.Order.Hom.BoundedLattice
|
∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Max α] [inst_1 : Bot α] [inst_2 : Max β] [inst_3 : Bot β]
[inst_4 : Max γ] [inst_5 : Bot γ] {g : SupBotHom β γ} {f₁ f₂ : SupBotHom α β},
Function.Injective ⇑g → (g.comp f₁ = g.comp f₂) = (f₁ = f₂)
|
IntermediateField.subsingleton_of_rank_adjoin_eq_one
|
Mathlib.FieldTheory.IntermediateField.Adjoin.Basic
|
∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E],
(∀ (x : E), Module.rank F ↥F⟮x⟯ = 1) → Subsingleton (IntermediateField F E)
|
Aesop.GoalWithMVars.ctorIdx
|
Aesop.Script.GoalWithMVars
|
Aesop.GoalWithMVars → ℕ
|
AddUnits.leftOfAdd._proof_2
|
Mathlib.Algebra.Group.Commute.Units
|
∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M), a + b = ↑u → AddCommute a b → b + ↑(-u) + a = 0
|
_private.Mathlib.Algebra.Order.Archimedean.Class.0.MulArchimedeanClass.orderHom_injective._simp_1_1
|
Mathlib.Algebra.Order.Archimedean.Class
|
∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk a = MulArchimedeanClass.mk b) = ((∃ m, |b|ₘ ≤ |a|ₘ ^ m) ∧ ∃ n, |a|ₘ ≤ |b|ₘ ^ n)
|
Sum.Lex.denselyOrdered_of_noMaxOrder
|
Mathlib.Data.Sum.Order
|
∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [DenselyOrdered α] [DenselyOrdered β] [NoMaxOrder α],
DenselyOrdered (Lex (α ⊕ β))
|
Lean.Lsp.FileChangeType._sizeOf_inst
|
Lean.Data.Lsp.Workspace
|
SizeOf Lean.Lsp.FileChangeType
|
OrderAddMonoidHom.addCommute_inl_inr
|
Mathlib.Algebra.Order.Monoid.Lex
|
∀ {α : Type u_1} {β : Type u_2} [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β] (m : α) (n : β), AddCommute ((OrderAddMonoidHom.inl α β) m) ((OrderAddMonoidHom.inr α β) n)
|
Std.DHashMap.Raw.getKey?_insert_self
|
Std.Data.DHashMap.RawLemmas
|
∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (m.insert k v).getKey? k = some k
|
sup_sdiff
|
Mathlib.Order.Heyting.Basic
|
∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a ⊔ b) \ c = a \ c ⊔ b \ c
|
Lean.Lsp.CompletionItemKind.enumMember
|
Lean.Data.Lsp.LanguageFeatures
|
Lean.Lsp.CompletionItemKind
|
Lean.Server.References.removeWorkerRefs
|
Lean.Server.References
|
Lean.Server.References → Lean.Name → Lean.Server.References
|
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.integral_isMulLeftInvariant_isMulRightInvariant_combo._simp_1_6
|
Mathlib.MeasureTheory.Measure.Haar.Unique
|
∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n)
|
AddOpposite.instSubtractionMonoid.eq_1
|
Mathlib.Algebra.Group.Opposite
|
∀ {α : Type u_1} [inst : SubtractionMonoid α],
AddOpposite.instSubtractionMonoid =
{ toSubNegMonoid := AddOpposite.instSubNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯ }
|
CategoryTheory.Functor.OplaxMonoidal.comp_δ
|
Mathlib.CategoryTheory.Monoidal.Functor
|
∀ {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] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [inst_6 : F.OplaxMonoidal]
[inst_7 : G.OplaxMonoidal] (X Y : C),
CategoryTheory.Functor.OplaxMonoidal.δ (F.comp G) X Y =
CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Functor.OplaxMonoidal.δ F X Y))
(CategoryTheory.Functor.OplaxMonoidal.δ G (F.obj X) (F.obj Y))
|
dist_vadd_left
|
Mathlib.Analysis.Normed.Group.AddTorsor
|
∀ {V : Type u_2} {P : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] (v : V) (x : P), dist (v +ᵥ x) x = ‖v‖
|
TopologicalSpace.CompactOpens.map
|
Mathlib.Topology.Sets.Compacts
|
{α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(f : α → β) → Continuous f → IsOpenMap f → TopologicalSpace.CompactOpens α → TopologicalSpace.CompactOpens β
|
InfiniteGalois.isOpen_and_normal_iff_finite_and_isGalois
|
Mathlib.FieldTheory.Galois.Infinite
|
∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] (L : IntermediateField k K)
[IsGalois k K], IsOpen L.fixingSubgroup.carrier ∧ L.fixingSubgroup.Normal ↔ FiniteDimensional k ↥L ∧ IsGalois k ↥L
|
IsPrimitiveRoot.adjoinEquivRingOfIntegers_apply
|
Mathlib.NumberTheory.NumberField.Cyclotomic.Basic
|
∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n) (a : ↥(Algebra.adjoin ℤ {ζ})),
hζ.adjoinEquivRingOfIntegers a = (IsIntegralClosure.lift ℤ (NumberField.RingOfIntegers K) K) a
|
Std.Time.Formats.leanDateTimeWithIdentifierAndNanos
|
Std.Time.Format
|
Std.Time.GenericFormat Std.Time.Awareness.any
|
PartENat.lt_coe_iff
|
Mathlib.Data.Nat.PartENat
|
∀ (x : PartENat) (n : ℕ), x < ↑n ↔ ∃ (h : x.Dom), x.get h < n
|
Std.DHashMap.Raw.size_alter_eq_sub_one
|
Std.Data.DHashMap.RawLemmas
|
∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k : α} {f : Option (β k) → Option (β k)},
m.WF → k ∈ m → (f (m.get? k)).isNone = true → (m.alter k f).size = m.size - 1
|
Subtype.impEmbedding._proof_1
|
Mathlib.Logic.Embedding.Basic
|
∀ {α : Type u_1} (p q : α → Prop), (∀ (x : α), p x → q x) → ∀ (x : { x // p x }), q ↑x
|
EquivLike.pairwise_comp_iff
|
Mathlib.Logic.Equiv.Pairwise
|
∀ {X : Type u_1} {Y : Type u_2} {F : Sort u_3} [inst : EquivLike F Y X] (f : F) (p : X → X → Prop),
Pairwise (Function.onFun p ⇑f) ↔ Pairwise p
|
ModuleCat.Tilde.stalkToFiberLinearMap
|
Mathlib.AlgebraicGeometry.Modules.Tilde
|
{R : Type u} →
[inst : CommRing R] →
(M : ModuleCat R) →
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) →
M.tildeInModuleCat.stalk x ⟶ ModuleCat.of R (LocalizedModule x.asIdeal.primeCompl ↑M)
|
ContinuousMapZero.toContinuousMapHom._proof_3
|
Mathlib.Topology.ContinuousMap.ContinuousMapZero
|
∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : IsTopologicalSemiring R] (x : R) (x_1 : ContinuousMapZero X R),
↑(x • x_1) = ↑(x • x_1)
|
_private.Mathlib.CategoryTheory.Sites.Hypercover.Zero.0.CategoryTheory.PreZeroHypercover.Hom.ext'_iff.match_1_1
|
Mathlib.CategoryTheory.Sites.Hypercover.Zero
|
∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {S : C} {E : CategoryTheory.PreZeroHypercover S}
{F : CategoryTheory.PreZeroHypercover S} {f g : E.Hom F}
(motive :
(∃ (hs : f.s₀ = g.s₀),
∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)) →
Prop)
(x :
∃ (hs : f.s₀ = g.s₀),
∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)),
(∀ (hs : f.s₀ = g.s₀)
(hh : ∀ (i : E.I₀), f.h₀ i = CategoryTheory.CategoryStruct.comp (g.h₀ i) (CategoryTheory.eqToHom ⋯)), motive ⋯) →
motive x
|
Ordinal.pred_le_self
|
Mathlib.SetTheory.Ordinal.Arithmetic
|
∀ (o : Ordinal.{u_4}), o.pred ≤ o
|
Semiquot.mem_pure._simp_1
|
Mathlib.Data.Semiquot
|
∀ {α : Type u_1} {a b : α}, (a ∈ pure b) = (a = b)
|
RingHom.op._proof_17
|
Mathlib.Algebra.Ring.Opposite
|
∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (x : Rᵐᵒᵖ →+* Sᵐᵒᵖ)
(x_1 y : Rᵐᵒᵖ),
(↑(AddMonoidHom.mulOp
{ toFun := (↑(AddMonoidHom.mulUnop x.toAddMonoidHom)).toFun, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ }.toAddMonoidHom)).toFun
(x_1 + y) =
(↑(AddMonoidHom.mulOp
{ toFun := (↑(AddMonoidHom.mulUnop x.toAddMonoidHom)).toFun, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ }.toAddMonoidHom)).toFun
x_1 +
(↑(AddMonoidHom.mulOp
{ toFun := (↑(AddMonoidHom.mulUnop x.toAddMonoidHom)).toFun, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ }.toAddMonoidHom)).toFun
y
|
Ordnode.Valid'.rotateL_lemma₁
|
Mathlib.Data.Ordmap.Ordset
|
∀ {a b c : ℕ}, 3 * a ≤ b + c → c ≤ 3 * b → a ≤ 3 * b
|
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?._sparseCasesOn_5
|
Lean.Meta.Tactic.Grind.PropagateInj
|
{α : Type u} → {motive : List α → Sort u_1} → (t : List α) → motive [] → (t.ctorIdx ≠ 0 → motive t) → motive t
|
PNat.find_eq_one._simp_1
|
Mathlib.Data.PNat.Find
|
∀ {p : ℕ+ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (PNat.find h = 1) = p 1
|
Polynomial.eval₂_homogenize_of_eq_one
|
Mathlib.Algebra.Polynomial.Homogenize
|
∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] {p : Polynomial R} {n : ℕ},
p.natDegree ≤ n →
∀ (f : R →+* S) (g : Fin 2 → S), g 1 = 1 → MvPolynomial.eval₂ f g (p.homogenize n) = Polynomial.eval₂ f (g 0) p
|
groupHomology.H0π_comp_map_apply
|
Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality
|
∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep k G} {B : Rep k H} (f : G →* H)
(φ : A ⟶ (Action.res (ModuleCat k) f).obj B) (x : CategoryTheory.ToType A.V),
(CategoryTheory.ConcreteCategory.hom (groupHomology.map f φ 0))
((CategoryTheory.ConcreteCategory.hom (groupHomology.H0π A)) x) =
(CategoryTheory.ConcreteCategory.hom (groupHomology.H0π B)) ((CategoryTheory.ConcreteCategory.hom φ.hom) x)
|
MessageType.log.elim
|
Lean.Data.Lsp.Window
|
{motive : MessageType → Sort u} → (t : MessageType) → t.ctorIdx = 3 → motive MessageType.log → motive t
|
Std.DHashMap.Internal.Raw₀.getKeyD_insertMany_emptyWithCapacity_list_of_contains_eq_false
|
Std.Data.DHashMap.Internal.RawLemmas
|
∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{l : List ((a : α) × β a)} {k fallback : α},
(List.map Sigma.fst l).contains k = false →
(↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertMany l)).getKeyD k fallback = fallback
|
_private.Mathlib.Algebra.Order.Group.Unbundled.Int.0.Int.ediv_eq_zero_of_lt_abs.match_1_1
|
Mathlib.Algebra.Order.Group.Unbundled.Int
|
∀ {a : ℤ} (motive : (b x : ℤ) → x = ↑b.natAbs → a < x → Prop) (b x : ℤ) (x_1 : x = ↑b.natAbs) (H2 : a < x),
(∀ (n : ℕ) (H2 : a < ↑(↑n).natAbs), motive (Int.ofNat n) ↑(↑n).natAbs ⋯ H2) →
(∀ (n : ℕ) (H2 : a < ↑(Int.negSucc n).natAbs), motive (Int.negSucc n) ↑(Int.negSucc n).natAbs ⋯ H2) →
motive b x x_1 H2
|
AddSubmonoid.coe_multiset_sum
|
Mathlib.Algebra.Group.Submonoid.BigOperators
|
∀ {M : Type u_4} [inst : AddCommMonoid M] (S : AddSubmonoid M) (m : Multiset ↥S),
↑m.sum = (Multiset.map Subtype.val m).sum
|
_private.Mathlib.RingTheory.UniqueFactorizationDomain.Basic.0.irreducible_iff_prime_of_existsUnique_irreducible_factors.match_1_3
|
Mathlib.RingTheory.UniqueFactorizationDomain.Basic
|
∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] (p : α) (fa fb : Multiset α)
(motive : (∃ b ∈ fa + fb, Associated p b) → Prop) (x : ∃ b ∈ fa + fb, Associated p b),
(∀ (q : α) (hqf : q ∈ fa + fb) (hq : Associated p q), motive ⋯) → motive x
|
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser._aux_Aesop_Frontend_Command___elabRules_Aesop_Frontend_Parser_addRules_1.match_1
|
Aesop.Frontend.Command
|
(motive : Aesop.GlobalRuleSetMember × Array Aesop.RuleSetName → Sort u_1) →
(x : Aesop.GlobalRuleSetMember × Array Aesop.RuleSetName) →
((rule : Aesop.GlobalRuleSetMember) → (rsNames : Array Aesop.RuleSetName) → motive (rule, rsNames)) → motive x
|
CategoryTheory.ObjectProperty.IsStrongGenerator.isDense_colimitsCardinalClosure_ι
|
Mathlib.CategoryTheory.Presentable.StrongGenerator
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
[CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, u} C] [CategoryTheory.LocallySmall.{w, v, u} C]
{P : CategoryTheory.ObjectProperty C} [CategoryTheory.ObjectProperty.Small.{w, v, u} P],
P.IsStrongGenerator → P ≤ CategoryTheory.isCardinalPresentable C κ → (P.colimitsCardinalClosure κ).ι.IsDense
|
MvPolynomial.smulCommClass
|
Mathlib.Algebra.MvPolynomial.Basic
|
∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring S₂] [inst_1 : SMulZeroClass R S₂]
[inst_2 : SMulZeroClass S₁ S₂] [SMulCommClass R S₁ S₂], SMulCommClass R S₁ (MvPolynomial σ S₂)
|
DirectSum.toAddMonoid
|
Mathlib.Algebra.DirectSum.Basic
|
{ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
[DecidableEq ι] →
{γ : Type u₁} → [inst_2 : AddCommMonoid γ] → ((i : ι) → β i →+ γ) → (DirectSum ι fun i => β i) →+ γ
|
Sigma.Lex.boundedOrder
|
Mathlib.Data.Sigma.Order
|
{ι : Type u_1} →
{α : ι → Type u_2} →
[inst : PartialOrder ι] →
[inst_1 : BoundedOrder ι] →
[inst_2 : (i : ι) → Preorder (α i)] → [OrderBot (α ⊥)] → [OrderTop (α ⊤)] → BoundedOrder (Σₗ (i : ι), α i)
|
Representation.finsuppLEquivFreeAsModule._proof_4
|
Mathlib.RepresentationTheory.Basic
|
∀ (k : Type u_1) (G : Type u_2) [inst : CommSemiring k] [inst_1 : Monoid G] (α : Type u_3),
Function.LeftInverse (AddEquiv.refl (α →₀ MonoidAlgebra k G)).invFun (AddEquiv.refl (α →₀ MonoidAlgebra k G)).toFun
|
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.ciSup_subtype._simp_1_5
|
Mathlib.Order.ConditionallyCompleteLattice.Indexed
|
∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩
|
_private.Mathlib.Algebra.ModEq.0.AddCommGroup.natCast_modEq_natCast._simp_1_1
|
Mathlib.Algebra.ModEq
|
∀ {a b n : ℕ}, (a ≡ b [MOD n]) = (↑a ≡ ↑b [ZMOD ↑n])
|
Std.DTreeMap.Internal.Cell.ofOption
|
Std.Data.DTreeMap.Internal.Cell
|
{α : Type u} → {β : α → Type v} → [inst : Ord α] → (k : α) → Option (β k) → Std.DTreeMap.Internal.Cell α β (compare k)
|
Order.Ideal.PrimePair.I_isPrime
|
Mathlib.Order.PrimeIdeal
|
∀ {P : Type u_1} [inst : Preorder P] (IF : Order.Ideal.PrimePair P), IF.I.IsPrime
|
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.exists_linearEquiv_eq_graph._simp_1_2
|
Mathlib.LinearAlgebra.Prod
|
∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{F : Type u_10} [inst_6 : FunLike F M M₂] [inst_7 : SemilinearMapClass F τ₁₂ M M₂] [inst_8 : RingHomSurjective τ₁₂]
{f : F} {x : M₂}, (x ∈ LinearMap.range f) = ∃ y, f y = x
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._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)
|
Pi.mulZeroOneClass._proof_2
|
Mathlib.Algebra.GroupWithZero.Pi
|
∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroOneClass (α i)] (a : (i : ι) → α i), a * 1 = a
|
IsStronglyTranscendental.iff_of_isLocalization
|
Mathlib.RingTheory.Algebraic.StronglyTranscendental
|
∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] {M : Submonoid S},
M ≤ nonZeroDivisors S →
∀ [IsLocalization M T] [IsScalarTower R S T] {x : S},
IsStronglyTranscendental R ((algebraMap S T) x) ↔ IsStronglyTranscendental R x
|
CommBialgCat.Hom
|
Mathlib.Algebra.Category.CommBialgCat
|
{R : Type u} → [inst : CommRing R] → CommBialgCat R → CommBialgCat R → Type v
|
CategoryTheory.MonoidalCategory.MonoidalRightAction.hom_inv_actionHomLeft
|
Mathlib.CategoryTheory.Monoidal.Action.Basic
|
∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {x y : D} (f : x ≅ y) (z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f.hom z)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f.inv z) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj x z)
|
Action.diagonalOneIsoLeftRegular
|
Mathlib.CategoryTheory.Action.Concrete
|
(G : Type u_1) → [inst : Monoid G] → Action.diagonal G 1 ≅ Action.leftRegular G
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.