name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
HomotopicalAlgebra.Precylinder.LeftHomotopy.trans._proof_1
|
Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {P : HomotopicalAlgebra.Precylinder X} {Y : C}
{f₀ f₁ f₂ : X ⟶ Y} (h : P.LeftHomotopy f₀ f₁) {P' : HomotopicalAlgebra.Precylinder X} (h' : P'.LeftHomotopy f₁ f₂),
CategoryTheory.CategoryStruct.comp P.i₁ h.h = CategoryTheory.CategoryStruct.comp P'.i₀ h'.h
|
_private.Mathlib.Topology.Algebra.Module.LinearMapPiProd.0.ContinuousLinearMap.pi_eq_zero._simp_1_2
|
Mathlib.Topology.Algebra.Module.LinearMapPiProd
|
∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x
|
Lean.Server.GoToKind.toCtorIdx
|
Lean.Server.GoTo
|
Lean.Server.GoToKind → ℕ
|
CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber_comp
|
Mathlib.CategoryTheory.Sites.Point.Category
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] [inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A]
{Φ₁ Φ₂ Φ₃ : J.Point} (f : Φ₁ ⟶ Φ₂) (g : Φ₂ ⟶ Φ₃),
CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber g)
(CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber f)
|
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.casesOn
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.Types
|
{motive_8 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
((p : Int.Linear.Poly) → (h : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof) → motive_8 { p := p, h := h }) → motive_8 t
|
OrderDual.instGroup
|
Mathlib.Algebra.Order.Group.Synonym
|
{α : Type u_1} → [h : Group α] → Group αᵒᵈ
|
AList.mem_lookup_union_middle
|
Mathlib.Data.List.AList
|
∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {b : β a} {s₁ s₂ s₃ : AList β},
b ∈ AList.lookup a (s₁ ∪ s₃) → a ∉ s₂ → b ∈ AList.lookup a (s₁ ∪ s₂ ∪ s₃)
|
PFun.fixInduction'._proof_1
|
Mathlib.Data.PFun
|
∀ {α : Type u_1} {β : Type u_2} {f : α →. β ⊕ α} {b : β} (a' : α) (h : b ∈ f.fix a') (b' : β),
(f a').get ⋯ = Sum.inl b' → ∃ (h : (f a').Dom), (f a').get h = Sum.inl b'
|
Int.gcd_mul_right
|
Init.Data.Int.Gcd
|
∀ (m n k : ℤ), (m * n).gcd (k * n) = m.gcd k * n.natAbs
|
_private.Lean.Environment.0.Lean.importModules.match_4
|
Lean.Environment
|
(motive : Unit × Lean.ImportState → Sort u_1) →
(__discr : Unit × Lean.ImportState) → ((fst : Unit) → (s : Lean.ImportState) → motive (fst, s)) → motive __discr
|
CoxeterSystem.isReflection_simple
|
Mathlib.GroupTheory.Coxeter.Inversion
|
∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (i : B),
cs.IsReflection (cs.simple i)
|
CategoryTheory.BasedNatIso.id_hom
|
Mathlib.CategoryTheory.FiberedCategory.BasedCategory
|
∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴),
(CategoryTheory.BasedNatIso.id F).hom = CategoryTheory.CategoryStruct.id F
|
Primrec.of_eq
|
Mathlib.Computability.Primrec
|
∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {f g : α → σ},
Primrec f → (∀ (n : α), f n = g n) → Primrec g
|
FirstOrder.Language.Symbols
|
Mathlib.ModelTheory.Basic
|
FirstOrder.Language → Type (max u v)
|
ProbabilityTheory.Kernel.comap_map_comm
|
Mathlib.Probability.Kernel.Composition.MapComap
|
∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5}
{mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel β γ) {f : α → β} {g : γ → δ}
(hf : Measurable f), Measurable g → (κ.map g).comap f hf = (κ.comap f hf).map g
|
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.iso_hom_naturality_assoc
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
|
∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} (X : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] (S : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X)
{x x' : X} (f : x ⟶ x') {Z : B} (h : (((CategoryTheory.Functor.whiskeringRight X C B).obj G).obj S.snd).obj x' ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map (S.fst.map f)) (CategoryTheory.CategoryStruct.comp (S.iso.hom.app x') h) =
CategoryTheory.CategoryStruct.comp (S.iso.hom.app x) (CategoryTheory.CategoryStruct.comp (G.map (S.snd.map f)) h)
|
Convex.combo_interior_closure_subset_interior
|
Mathlib.Analysis.Convex.Topology
|
∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E] {s : Set E},
Convex 𝕜 s → ∀ {a b : 𝕜}, 0 < a → 0 ≤ b → a + b = 1 → a • interior s + b • closure s ⊆ interior s
|
Group.ofRightAxioms._proof_4
|
Mathlib.Algebra.Group.MinimalAxioms
|
∀ {G : Type u_1} [inst : Mul G] [inst_1 : Inv G] [inst_2 : One G],
(∀ (a b c : G), a * b * c = a * (b * c)) →
(∀ (a : G), a * 1 = a) → (∀ (a : G), a * a⁻¹ = 1) → (∀ (a : G), a⁻¹ * a = 1) → ∀ (a : G), 1 * a = a
|
_private.Mathlib.Algebra.Group.Semiconj.Basic.0.SemiconjBy.inv_inv_symm_iff._simp_1_2
|
Mathlib.Algebra.Group.Semiconj.Basic
|
∀ {G : Type u_3} [inst : InvolutiveInv G] {a b : G}, (a⁻¹ = b⁻¹) = (a = b)
|
Lean.AssocList.brecOn.go
|
Lean.Data.AssocList
|
{α : Type u} →
{β : Type v} →
{motive : Lean.AssocList α β → Sort u_1} →
(t : Lean.AssocList α β) →
((t : Lean.AssocList α β) → Lean.AssocList.below t → motive t) → motive t ×' Lean.AssocList.below t
|
disjoint_nhds_atBot_iff._simp_1
|
Mathlib.Topology.Order.OrderClosed
|
∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [ClosedIicTopology α] {a : α},
Disjoint (nhds a) Filter.atBot = ¬IsBot a
|
CategoryTheory.FintypeCat.isoQuotientStabilizerOfIsConnected._proof_3
|
Mathlib.CategoryTheory.Galois.Examples
|
∀ {G : Type u_1} [inst : Group G] (X : Action FintypeCat G) (x : X.V.carrier),
MulAction.QuotientAction G (MulAction.stabilizer G x)
|
RingPreordering.instHasIdealSupport
|
Mathlib.Algebra.Order.Ring.Ordering.Basic
|
∀ {F : Type u_2} [inst : Field F] (P : RingPreordering F), P.HasIdealSupport
|
Lean.CollectLevelMVars.State.visitedLevel
|
Lean.Util.CollectLevelMVars
|
Lean.CollectLevelMVars.State → Lean.LevelSet
|
StarSubalgebra.range_le
|
Mathlib.Algebra.Star.Subalgebra
|
∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A),
Set.range ⇑(algebraMap R A) ≤ ↑S
|
CategoryTheory.ShortComplex.SnakeInput.h₃τ₁._proof_1
|
Mathlib.Algebra.Homology.ShortComplex.SnakeLemma
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair S.v₁₂ 0) CategoryTheory.ShortComplex.π₁
|
IsAddTorsionFree.nsmul_eq_zero_iff'
|
Mathlib.Algebra.Group.Torsion
|
∀ {M : Type u_1} [inst : AddMonoid M] [IsAddTorsionFree M] {n : ℕ} {a : M}, a ≠ 0 → (n • a = 0 ↔ n = 0)
|
BitVec.add_right_eq_self
|
Init.Data.BitVec.Lemmas
|
∀ {w : ℕ} {x y : BitVec w}, x + y = x ↔ y = 0#w
|
_private.Mathlib.Order.TypeTags.0.WithTop.instRepr.match_1.splitter
|
Mathlib.Order.TypeTags
|
{α : Type u_1} →
(motive : WithTop α → Sort u_2) → (o : WithTop α) → (Unit → motive none) → ((a : α) → motive (some a)) → motive o
|
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.Const.insertMany.match_1
|
Std.Data.DHashMap.Internal.Defs
|
{α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x
|
_private.Lean.Meta.AbstractMVars.0.Lean.Meta.AbstractMVars.abstractLevelMVars.match_1
|
Lean.Meta.AbstractMVars
|
(motive : Option Lean.Level → Sort u_1) →
(x : Option Lean.Level) → ((u : Lean.Level) → motive (some u)) → (Unit → motive none) → motive x
|
Submonoid.map_comap_eq
|
Mathlib.Algebra.Group.Submonoid.Operations
|
∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid N), Submonoid.map f (Submonoid.comap f S) = S ⊓ MonoidHom.mrange f
|
AlgEquiv.piMulOpposite
|
Mathlib.Algebra.Algebra.Pi
|
(R : Type u_3) →
{ι : Type u_4} →
(A₁ : ι → Type u_5) →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → Semiring (A₁ i)] →
[inst_2 : (i : ι) → Algebra R (A₁ i)] → ((i : ι) → A₁ i)ᵐᵒᵖ ≃ₐ[R] (i : ι) → (A₁ i)ᵐᵒᵖ
|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State.annotations
|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze
|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State → Lean.PrettyPrinter.Delaborator.OptionsPerPos
|
groupCohomology.mapShortComplexH2_id_comp_assoc
|
Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality
|
∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B C : Rep k G} (φ : A ⟶ B) (ψ : B ⟶ C)
{Z : CategoryTheory.ShortComplex (ModuleCat k)} (h : groupCohomology.shortComplexH2 C ⟶ Z),
CategoryTheory.CategoryStruct.comp
(groupCohomology.mapShortComplexH2 (MonoidHom.id G) (CategoryTheory.CategoryStruct.comp φ ψ)) h =
CategoryTheory.CategoryStruct.comp (groupCohomology.mapShortComplexH2 (MonoidHom.id G) φ)
(CategoryTheory.CategoryStruct.comp (groupCohomology.mapShortComplexH2 (MonoidHom.id G) ψ) h)
|
Finsupp.lcomapDomain._proof_1
|
Mathlib.LinearAlgebra.Finsupp.Defs
|
∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] {β : Type u_3} (f : α → β) (hf : Function.Injective f)
(x y : β →₀ M), Finsupp.comapDomain f (x + y) ⋯ = Finsupp.comapDomain f x ⋯ + Finsupp.comapDomain f y ⋯
|
_private.Mathlib.Algebra.Exact.0.LinearEquiv.conj_exact_iff_exact._simp_1_1
|
Mathlib.Algebra.Exact
|
∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {P : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] {f : M →ₗ[R] N} {g : N →ₗ[R] P}, Function.Exact ⇑f ⇑g = (LinearMap.ker g = LinearMap.range f)
|
Polynomial.lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors'
|
Mathlib.Algebra.Polynomial.FieldDivision
|
∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} {t : R} {n : ℕ},
p ≠ 0 →
(∀ m ≤ n, ((⇑Polynomial.derivative)^[m] p).IsRoot t) →
(∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R) → n < Polynomial.rootMultiplicity t p
|
Std.LawfulOrderLeftLeaningMin.of_eq
|
Init.Data.Order.Lemmas
|
∀ {α : Type u} [inst : LE α] [inst_1 : Min α] [inst_2 : DecidableLE α],
(∀ (a b : α), a ⊓ b = if a ≤ b then a else b) → Std.LawfulOrderLeftLeaningMin α
|
ByteSlice.contains
|
Std.Data.ByteSlice
|
ByteSlice → UInt8 → Bool
|
Stream'.Seq1.ret.eq_1
|
Mathlib.Data.Seq.Basic
|
∀ {α : Type u} (a : α), Stream'.Seq1.ret a = (a, Stream'.Seq.nil)
|
SSet.Edge.edge
|
Mathlib.AlgebraicTopology.SimplicialSet.CompStruct
|
{X : SSet} →
{x₀ x₁ : X.obj (Opposite.op (SimplexCategory.mk 0))} → SSet.Edge x₀ x₁ → X.obj (Opposite.op (SimplexCategory.mk 1))
|
CategoryTheory.Adjunction.fullyFaithfulROfCompIsoId
|
Mathlib.CategoryTheory.Monad.Adjunction
|
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{L : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor D C} → (L ⊣ R) → (R.comp L ≅ CategoryTheory.Functor.id D) → R.FullyFaithful
|
Lean.Meta.RefinedDiscrTree.Trie.pending
|
Mathlib.Lean.Meta.RefinedDiscrTree.Basic
|
{α : Type} → Lean.Meta.RefinedDiscrTree.Trie α → Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α)
|
AlgebraicGeometry.QuasiCompact.of_comp
|
Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated
|
∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.QuasiCompact (CategoryTheory.CategoryStruct.comp f g)] [AlgebraicGeometry.QuasiSeparated g],
AlgebraicGeometry.QuasiCompact f
|
CategoryTheory.Monad.beckAlgebraCoequalizer._proof_2
|
Mathlib.CategoryTheory.Monad.Coequalizer
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
(s :
CategoryTheory.Limits.Cofork (CategoryTheory.Monad.FreeCoequalizer.topMap X)
(CategoryTheory.Monad.FreeCoequalizer.bottomMap X)),
CategoryTheory.CategoryStruct.comp (T.map s.π.f)
(((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.one).a =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair (CategoryTheory.Monad.FreeCoequalizer.topMap X)
(CategoryTheory.Monad.FreeCoequalizer.bottomMap X)).obj
CategoryTheory.Limits.WalkingParallelPair.one).a
s.π.f
|
CategoryTheory.Iso.isoCongr
|
Mathlib.CategoryTheory.HomCongr
|
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {X₁ Y₁ X₂ Y₂ : C} → (X₁ ≅ X₂) → (Y₁ ≅ Y₂) → (X₁ ≅ Y₁) ≃ (X₂ ≅ Y₂)
|
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.sum_div_nat_floor_pow_sq_le_div_sq._simp_1_9
|
Mathlib.Analysis.SpecificLimits.FloorPow
|
∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False
|
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Trivial.0.ValuativeRel.eq_trivialRel_of_compatible_one._simp_1_1
|
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial
|
∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] [inst_2 : Nontrivial R]
[inst_3 : NoZeroDivisors R] [inst_4 : DecidablePred fun x => x = 0] (x : R), (1 x ≤ 1) = True
|
Lean.JsonNumber.mk.sizeOf_spec
|
Lean.Data.Json.Basic
|
∀ (mantissa : ℤ) (exponent : ℕ),
sizeOf { mantissa := mantissa, exponent := exponent } = 1 + sizeOf mantissa + sizeOf exponent
|
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse._proof_7
|
Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory
|
∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.Functor C (CategoryTheory.Comon D)} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.IsComonHom
{ app := fun X_1 => ((CategoryTheory.CategoryStruct.comp f g).app X_1).hom, naturality := ⋯ }
|
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_measurableSet._simp_1_5
|
Mathlib.Algebra.Module.ZLattice.Basic
|
∀ {α : Type u} (x : α), (x ∈ Set.univ) = True
|
MeasureTheory.Measure.conv_zero
|
Mathlib.MeasureTheory.Group.Convolution
|
∀ {M : Type u_1} [inst : AddMonoid M] [inst_1 : MeasurableSpace M] (μ : MeasureTheory.Measure M), μ.conv 0 = 0
|
spectrum.subset_circle_of_unitary
|
Mathlib.Analysis.CStarAlgebra.Spectrum
|
∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] {E : Type u_2} [inst_1 : NormedRing E] [inst_2 : StarRing E] [CStarRing E]
[inst_4 : NormedAlgebra 𝕜 E] [CompleteSpace E] {u : E}, u ∈ unitary E → spectrum 𝕜 u ⊆ Metric.sphere 0 1
|
Lean.Server.RequestContext.rec
|
Lean.Server.Requests
|
{motive : Lean.Server.RequestContext → Sort u} →
((rpcSessions : Std.TreeMap UInt64 (IO.Ref Lean.Server.FileWorker.RpcSession) compare) →
(doc : Lean.Server.FileWorker.EditableDocument) →
(hLog : IO.FS.Stream) →
(initParams : Lean.Lsp.InitializeParams) →
(cancelTk : Lean.Server.RequestCancellationToken) →
(serverRequestEmitter : Lean.Server.ServerRequestEmitter) →
motive
{ rpcSessions := rpcSessions, doc := doc, hLog := hLog, initParams := initParams,
cancelTk := cancelTk, serverRequestEmitter := serverRequestEmitter }) →
(t : Lean.Server.RequestContext) → motive t
|
Classical.exists_or_forall_not
|
Init.Classical
|
∀ {α : Sort u_1} (P : α → Prop), (∃ a, P a) ∨ ∀ (a : α), ¬P a
|
Polynomial.UniversalFactorizationRing.factor₁_mul_factor₂
|
Mathlib.RingTheory.Polynomial.UniversalFactorizationRing
|
∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
↑(Polynomial.UniversalFactorizationRing.factor₁ m k hn p) *
↑(Polynomial.UniversalFactorizationRing.factor₂ m k hn p) =
↑(Polynomial.UniversalFactorizationRing.monicDegreeEq m k hn p)
|
LinearMap.BilinForm.toMatrixAux_apply
|
Mathlib.LinearAlgebra.Matrix.BilinearForm
|
∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} (B : LinearMap.BilinForm R₁ M₁) (b : n → M₁) (i j : n),
(BilinForm.toMatrixAux b) B i j = (B (b i)) (b j)
|
affineSpan_eq_top_of_nonempty_interior
|
Mathlib.Analysis.Normed.Affine.AddTorsorBases
|
∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] {s : Set V},
(interior ((convexHull ℝ) s)).Nonempty → affineSpan ℝ s = ⊤
|
_private.Std.Data.HashMap.Lemmas.0.Std.HashMap.mem_toArray_iff_getKey?_eq_some_and_getElem?_eq_some._simp_1_1
|
Std.Data.HashMap.Lemmas
|
∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β}, m.toArray = m.toList.toArray
|
hasDerivAt_tsum
|
Mathlib.Analysis.Calculus.SmoothSeries
|
∀ {α : Type u_1} {𝕜 : Type u_3} {F : Type u_5} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ} [inst_4 : NormedSpace 𝕜 F] {g g' : α → 𝕜 → F} {y₀ : 𝕜},
Summable u →
(∀ (n : α) (y : 𝕜), HasDerivAt (g n) (g' n y) y) →
(∀ (n : α) (y : 𝕜), ‖g' n y‖ ≤ u n) →
(Summable fun n => g n y₀) → ∀ (y : 𝕜), HasDerivAt (fun z => ∑' (n : α), g n z) (∑' (n : α), g' n y) y
|
Lean.Grind.CommRing.Poly.mul_nc.go.eq_def
|
Init.Grind.Ring.CommSolver
|
∀ (p₂ p₁ acc : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.mul_nc.go p₂ p₁ acc =
match p₁ with
| Lean.Grind.CommRing.Poly.num k => acc.combine (Lean.Grind.CommRing.Poly.mulConst k p₂)
| Lean.Grind.CommRing.Poly.add k m p₁ =>
Lean.Grind.CommRing.Poly.mul_nc.go p₂ p₁ (acc.combine (Lean.Grind.CommRing.Poly.mulMon_nc k m p₂))
|
Finset.instGeneralizedBooleanAlgebra._proof_7
|
Mathlib.Data.Finset.SDiff
|
∀ {α : Type u_1} [inst : DecidableEq α] (a b : Finset α), a ⊓ b ⊓ a \ b = ⊥
|
CategoryTheory.Limits.createsLimitsOfShapeOfCreatesEqualizersAndProducts._proof_2
|
Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers
|
∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{D : Type u_5} [inst_2 : CategoryTheory.Category.{u_4, u_5} D]
[CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) D]
(G : CategoryTheory.Functor C D)
[CategoryTheory.CreatesLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) G],
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) C
|
Submonoid.LocalizationMap.mulEquivOfLocalizations_left_inv_apply
|
Mathlib.GroupTheory.MonoidLocalization.Basic
|
∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} (x : N),
(f.mulEquivOfLocalizations (f.ofMulEquivOfLocalizations k)) x = k x
|
Module.FaithfullyFlat.tensorProduct_mk_injective
|
Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra
|
∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Module.FaithfullyFlat A B] (M : Type u_3) [inst_4 : AddCommGroup M] [inst_5 : Module A M],
Function.Injective ⇑((TensorProduct.mk A B M) 1)
|
CategoryTheory.Limits.WalkingPair.right.sizeOf_spec
|
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts
|
sizeOf CategoryTheory.Limits.WalkingPair.right = 1
|
TopologicalSpace.isTopologicalBasis_empty._simp_1
|
Mathlib.Topology.Bases
|
∀ {α : Type u} [t : TopologicalSpace α], TopologicalSpace.IsTopologicalBasis ∅ = IsEmpty α
|
_private.Mathlib.MeasureTheory.PiSystem.0.isPiSystem_piiUnionInter._simp_1_5
|
Mathlib.MeasureTheory.PiSystem
|
∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b)
|
IsometryEquiv.mulLeft._proof_1
|
Mathlib.Topology.MetricSpace.IsometricSMul
|
∀ {G : Type u_1} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [IsIsometricSMul G G] (c b c_1 : G),
edist (c * b) (c * c_1) = edist b c_1
|
FirstOrder.Language.DirectLimit.unify_sigma_mk_self
|
Mathlib.ModelTheory.DirectLimit
|
∀ {L : FirstOrder.Language} {ι : Type v} [inst : Preorder ι] {G : ι → Type w} [inst_1 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [DirectedSystem G fun i j h => ⇑(f i j h)] {α : Type u_1} {i : ι}
{x : α → G i},
FirstOrder.Language.DirectLimit.unify f (fun a => FirstOrder.Language.Structure.Sigma.mk f i (x a)) i ⋯ = x
|
OnePoint.isClosed_image_coe._simp_1
|
Mathlib.Topology.Compactification.OnePoint.Basic
|
∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsClosed (OnePoint.some '' s) = (IsClosed s ∧ IsCompact s)
|
Nat.lt_add_one_of_lt
|
Init.Data.Nat.Basic
|
∀ {a b : ℕ}, a < b → a < b + 1
|
Finset.inv_subset_div_right
|
Mathlib.Algebra.Group.Pointwise.Finset.Basic
|
∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : DivisionMonoid α] {s t : Finset α}, 1 ∈ s → t⁻¹ ⊆ s / t
|
_private.Init.Data.List.Attach.0.List.attach_filterMap._simp_1_3
|
Init.Data.List.Attach
|
∀ {α : Sort u_1}, (∃ _a, False) = False
|
Nat._aux_Mathlib_Data_Nat_Factorial_Basic___macroRules_Nat_term_!_1
|
Mathlib.Data.Nat.Factorial.Basic
|
Lean.Macro
|
AffineIsometry
|
Mathlib.Analysis.Normed.Affine.Isometry
|
(𝕜 : Type u_1) →
{V : Type u_2} →
{V₂ : Type u_5} →
(P : Type u_10) →
(P₂ : Type u_11) →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[NormedAddTorsor V P] →
[inst_5 : SeminormedAddCommGroup V₂] →
[NormedSpace 𝕜 V₂] →
[inst : PseudoMetricSpace P₂] →
[NormedAddTorsor V₂ P₂] → Type (max (max (max u_10 u_11) u_2) u_5)
|
Lean.Compiler.LCNF.UnreachableBranches.Value.merge._unsafe_rec
|
Lean.Compiler.LCNF.ElimDeadBranches
|
Lean.Environment →
Lean.Compiler.LCNF.UnreachableBranches.Value →
Lean.Compiler.LCNF.UnreachableBranches.Value → Lean.Compiler.LCNF.UnreachableBranches.Value
|
_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.throwInvalidPattern
|
Lean.Elab.Match
|
{α : Type} → Lean.Expr → Lean.MetaM α
|
Fin.foldl_zero
|
Init.Data.Fin.Fold
|
∀ {α : Sort u_1} (f : α → Fin 0 → α) (x : α), Fin.foldl 0 f x = x
|
Lean.Meta.zetaDeltaLocalDecl
|
Lean.Meta.Tactic.Unfold
|
Lean.MVarId → Lean.FVarId → Lean.FVarId → Lean.MetaM Lean.MVarId
|
Semiquot.partialOrder
|
Mathlib.Data.Semiquot
|
{α : Type u_1} → PartialOrder (Semiquot α)
|
ISize.minValue_div_neg_one
|
Init.Data.SInt.Lemmas
|
ISize.minValue / -1 = ISize.minValue
|
Fin.finsetImage_natAdd_Ici
|
Mathlib.Order.Interval.Finset.Fin
|
∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.image (Fin.natAdd m) (Finset.Ici i) = Finset.Ici (Fin.natAdd m i)
|
Std.HashMap.Raw.mem_insertMany_of_mem
|
Std.Data.HashMap.RawLemmas
|
∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] {ρ : Type w}
[inst_2 : ForIn Id ρ (α × β)] [EquivBEq α] [LawfulHashable α], m.WF → ∀ {l : ρ} {k : α}, k ∈ m → k ∈ m.insertMany l
|
BoundedContinuousFunction.instCommMonoid
|
Mathlib.Topology.ContinuousMap.Bounded.Basic
|
{α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : CommMonoid R] → [BoundedMul R] → [ContinuousMul R] → CommMonoid (BoundedContinuousFunction α R)
|
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.eapproxDiff.match_1.splitter
|
Mathlib.MeasureTheory.Function.SimpleFunc
|
(motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x
|
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._unary
|
Init.Data.String.Pattern.String
|
(pat : String.Slice) →
UInt8 →
(table : Array ℕ) →
table.size ≤ pat.utf8ByteSize →
(∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) → (guess : ℕ) ×' guess < table.size → { n // n < table.size }
|
Lean.Doc.MarkdownBlock.toMarkdown
|
Lean.DocString.Markdown
|
{i : Type u} →
{b : Type v} →
[self : Lean.Doc.MarkdownBlock i b] →
(Lean.Doc.Inline i → Lean.Doc.MarkdownM Unit) →
(Lean.Doc.Block i b → Lean.Doc.MarkdownM Unit) → b → Array (Lean.Doc.Block i b) → Lean.Doc.MarkdownM Unit
|
Std.HashSet.Raw.erase_emptyWithCapacity
|
Std.Data.HashSet.RawLemmas
|
∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {k : α} {c : ℕ},
(Std.HashSet.Raw.emptyWithCapacity c).erase k = Std.HashSet.Raw.emptyWithCapacity c
|
LeftPreLieRing.casesOn
|
Mathlib.Algebra.NonAssoc.PreLie.Basic
|
{L : Type u_1} →
{motive : LeftPreLieRing L → Sort u} →
(t : LeftPreLieRing L) →
([toNonUnitalNonAssocRing : NonUnitalNonAssocRing L] →
(assoc_symm' : ∀ (x y z : L), associator x y z = associator y x z) →
motive { toNonUnitalNonAssocRing := toNonUnitalNonAssocRing, assoc_symm' := assoc_symm' }) →
motive t
|
Lean.Lsp.instToJsonSemanticTokensParams
|
Lean.Data.Lsp.LanguageFeatures
|
Lean.ToJson Lean.Lsp.SemanticTokensParams
|
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.IsIdempotentElem.comp_eq_right_iff._simp_1_5
|
Mathlib.LinearAlgebra.Projection
|
∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a)
|
Lean.Compiler.LCNF.MonadScope.mk
|
Lean.Compiler.LCNF.MonadScope
|
{m : Type → Type} →
m Lean.Compiler.LCNF.Scope →
({α : Type} → (Lean.Compiler.LCNF.Scope → Lean.Compiler.LCNF.Scope) → m α → m α) → Lean.Compiler.LCNF.MonadScope m
|
Mathlib.Tactic.Push.instBEqHead.beq
|
Mathlib.Tactic.Push.Attr
|
Mathlib.Tactic.Push.Head → Mathlib.Tactic.Push.Head → Bool
|
CategoryTheory.SimplicialObject.cechNerveEquiv._proof_2
|
Mathlib.AlgebraicTopology.CechNerve
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
(X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C) (A : X ⟶ F.augmentedCechNerve),
CategoryTheory.SimplicialObject.equivalenceLeftToRight X F
(CategoryTheory.SimplicialObject.equivalenceRightToLeft X F A) =
A
|
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.withRecApps.loop._unsafe_rec
|
Lean.Elab.PreDefinition.WF.GuessLex
|
{α : Type} →
(recFnName : Lean.Name) →
ℕ → (Lean.Expr → Array Lean.Expr → Lean.MetaM α) → Lean.Expr → Lean.Expr → Lean.Elab.WF.GuessLex.M recFnName α Unit
|
Real.sSup_smul_of_nonneg
|
Mathlib.Data.Real.Pointwise
|
∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : MulActionWithZero α ℝ]
[IsOrderedModule α ℝ] {a : α}, 0 ≤ a → ∀ (s : Set ℝ), sSup (a • s) = a • sSup s
|
cfcₙ_complex_eq_real._auto_1
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances
|
Lean.Syntax
|
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.Complex.cot_eq_exp_ratio._simp_1_2
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent
|
∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.