name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
instPartialOrderGroupCone | Mathlib.Algebra.Order.Group.Cone | (G : Type u_1) → [inst : CommGroup G] → PartialOrder (GroupCone G) |
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 : Preorder 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.Monotonicity | ∀ {α : Type u_1} {m : MeasurableSpace α} {𝕜 : Type u_5} [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.AlgebraicTopology.SimplicialSet.NerveAdjunction.0.SSet.Truncated.liftOfStrictSegal.f₂._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | 2 ≤ 1 + 1 |
_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) |
Std.DTreeMap.Raw.min?_keys | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Min α] [inst_1 : LE α] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α]
[Std.LawfulEqCmp cmp], t.WF → t.keys.min? = t.minKey? |
UpperSet.instAddCommMonoid._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (a b : UpperSet α),
a + b = b + a |
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) |
Subgroup.transferFocal.quotientKerMulEquivQuotientFocalSubroupOf._proof_1 | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] {p : ℕ} (P : Sylow p G), (↑P).focalSubgroupOf.Normal |
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)) |
Algebra.QuasiFinite.iff_finite_primesOver | Mathlib.RingTheory.QuasiFinite.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.FiniteType R S], Algebra.QuasiFinite R S ↔ ∀ (I : Ideal R), I.IsPrime → (I.primesOver S).Finite |
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) (h : ∀ (x : α), p x → q x) (x y : { x // p x }),
(fun x => ⟨↑x, ⋯⟩) x = (fun x => ⟨↑x, ⋯⟩) y → x = y |
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 |
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], ↑0 = ↑0 |
_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 |
Squarefree.moebius_eq | Mathlib.RingTheory.UniqueFactorizationDomain.Moebius | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α},
Squarefree a → UniqueFactorizationMonoid.moebius a = (-1) ^ (UniqueFactorizationMonoid.factors a).card |
Semiquot.mem_pure._simp_1 | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {a b : α}, (a ∈ pure b) = (a = b) |
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 [] → (Nat.hasNotBit 1 t.ctorIdx → 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 : ↑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 : CommMonoidWithZero α] (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) →+ γ |
CategoryTheory.Limits.isTerminalEquivUnique._proof_8 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete PEmpty.{1}) C) (Y : C),
Function.LeftInverse (fun u => { lift := fun s => default, fac := ⋯, uniq := ⋯ }) fun t X =>
{
default :=
t.lift
{ pt := X,
π := { app := fun X_1 => id (CategoryTheory.Discrete.casesOn X_1 fun as => ⋯.elim), naturality := ⋯ } },
uniq := ⋯ } |
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⟩ |
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₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {x : M₂}, (x ∈ f.range) = ∃ 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.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, 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) |
CategoryTheory.InjectiveResolution.extMk_hom | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y)
[inst_3 : HasDerivedCategory C] {n : ℕ} (f : X ⟶ R.cocomplex.X n) (m : ℕ) (hm : n + 1 = m)
(hf : CategoryTheory.CategoryStruct.comp f (R.cocomplex.d n m) = 0),
(R.extMk f m hm hf).hom =
(CategoryTheory.ShiftedHom.mk₀ 0 ⋯ ((DerivedCategory.singleFunctorIsoCompQ C 0).hom.app X)).comp
((CategoryTheory.ShiftedHom.map
(CochainComplex.HomComplex.Cocycle.equivHomShift.symm
(CochainComplex.HomComplex.Cocycle.fromSingleMk
(CategoryTheory.CategoryStruct.comp f (R.cochainComplexXIso (↑n) n ⋯).inv) ⋯ ↑m ⋯ ⋯))
DerivedCategory.Q).comp
(CategoryTheory.ShiftedHom.mk₀ 0 ⋯
(CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (DerivedCategory.Q.map R.ι'))
((DerivedCategory.singleFunctorIsoCompQ C 0).inv.app Y)))
⋯)
⋯ |
Action.diagonalOneIsoLeftRegular | Mathlib.CategoryTheory.Action.Concrete | (G : Type u_1) → [inst : Monoid G] → Action.diagonal G 1 ≅ Action.leftRegular G |
Int.le_iff_lt_or_eq | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b ↔ a < b ∨ a = b |
CategoryTheory.Idempotents.instIsIdempotentCompleteCosimplicialObject | Mathlib.CategoryTheory.Idempotents.SimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.IsIdempotentComplete C],
CategoryTheory.IsIdempotentComplete (CategoryTheory.CosimplicialObject C) |
LieHom._sizeOf_1 | Mathlib.Algebra.Lie.Basic | {R : Type u_1} →
{L : Type u_2} →
{L' : Type u_3} →
{inst : CommRing R} →
{inst_1 : LieRing L} →
{inst_2 : LieAlgebra R L} →
{inst_3 : LieRing L'} →
{inst_4 : LieAlgebra R L'} → [SizeOf R] → [SizeOf L] → [SizeOf L'] → (L →ₗ⁅R⁆ L') → ℕ |
Lean.Elab.AutoBoundImplicitContext.mk | Lean.Elab.AutoBound | Bool → Lean.PArray Lean.Expr → Lean.Elab.AutoBoundImplicitContext |
Vector.zipWith_replicate | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {α_1 : Type u_3} {f : α → β → α_1} {a : α} {b : β} {n : ℕ},
Vector.zipWith f (Vector.replicate n a) (Vector.replicate n b) = Vector.replicate n (f a b) |
IsSelfAdjoint.conjugate' | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Semigroup R] [inst_1 : StarMul R] {x : R},
IsSelfAdjoint x → ∀ (z : R), IsSelfAdjoint (star z * x * z) |
Int.reduceNe._regBuiltin.Int.reduceNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.625502844._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.Key.noConfusionType | Lean.Meta.Tactic.Grind.MBTC | Sort u → Lean.Meta.Grind.Key✝ → Lean.Meta.Grind.Key✝ → Sort u |
_private.Mathlib.RingTheory.Unramified.Locus.0.Algebra.unramifiedLocus_eq_compl_support._simp_1_2 | Mathlib.RingTheory.Unramified.Locus | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R}, (p ∉ Module.support R M) = Subsingleton (LocalizedModule p.asIdeal.primeCompl M) |
String.Pos.Raw.instLinearOrderPackage._proof_1 | Init.Data.String.OrderInstances | let this := inferInstance;
let this_1 :=
let this := inferInstance;
inferInstance;
∀ (a b : String.Pos.Raw), a < b ↔ a ≤ b ∧ ¬b ≤ a |
ZNum.decidableLT | Mathlib.Data.Num.Basic | DecidableLT ZNum |
CompHausLike.LocallyConstant.sigmaComparison_comp_sigmaIso | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{Q : CompHausLike P} {Z : Type (max u w)} (r : LocallyConstant (↑Q.toTop) Z) (a : Function.Fiber ⇑r)
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P]
(X : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))),
CategoryTheory.CategoryStruct.comp (X.mapIso (CompHausLike.LocallyConstant.sigmaIso r).op).hom
(CategoryTheory.CategoryStruct.comp
(CompHausLike.sigmaComparison X fun a => ↑(CompHausLike.LocallyConstant.fiber r a).toTop) fun g => g a) =
X.map (CompHausLike.LocallyConstant.sigmaIncl r a).op |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM.0.Lean.Meta.Grind.Arith.CommRing.setTermSemiringId.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((semiringId' : ℕ) → motive (some semiringId')) → ((x : Option ℕ) → motive x) → motive __do_lift |
Array.range'_append_1 | Init.Data.Array.Range | ∀ {s m n : ℕ}, Array.range' s m ++ Array.range' (s + m) n = Array.range' s (m + n) |
Finset.prod_prod_Ioi_mul_eq_prod_prod_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : LinearOrder α] [inst_2 : Fintype α]
[inst_3 : LocallyFiniteOrderTop α] [LocallyFiniteOrderBot α] (f : α → α → M),
∏ i, ∏ j ∈ Finset.Ioi i, f j i * f i j = ∏ i, ∏ j ∈ {i}ᶜ, f j i |
NonUnitalNonAssocRing.toHasDistribNeg._proof_3 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a : α), - -a = a |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.