name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₁ | Mathlib.CategoryTheory.MorphismProperty.Representable | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
[inst_2 : F.Full] →
{A₁ A₂ A₃ : C} →
{X : D} →
{f₁ : F.obj A₁ ⟶ X} →
... | true |
AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.carrier.smul_mem | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] {f : A} {m : ℕ} (f_deg : f ∈ 𝒜 m),
0 < m →
∀
(q :
↑↑(AlgebraicGeometry.Spec.locallyRingedSpaceObj
(CommRingCat.of (HomogeneousLocalizati... | true |
CategoryTheory.Functor.final_of_isFiltered_of_pUnit | Mathlib.CategoryTheory.Filtered.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.IsFiltered C]
(F : CategoryTheory.Functor C (CategoryTheory.Discrete PUnit.{u_1 + 1})), F.Final | true |
Ordinal.opow_right_inj | Mathlib.SetTheory.Ordinal.Exponential | ∀ {a b c : Ordinal.{u_1}}, 1 < a → (a ^ b = a ^ c ↔ b = c) | true |
CategoryTheory.orderDualEquivalence._proof_5 | Mathlib.CategoryTheory.Category.Preorder | ∀ (X : Type u_1) [inst : Preorder X] (X_1 : Xᵒᵈ),
CategoryTheory.CategoryStruct.comp
({ obj := fun x => Opposite.op (OrderDual.ofDual x), map := fun {X_2 Y} f => (CategoryTheory.homOfLE ⋯).op,
map_id := ⋯, map_comp := ⋯ }.map
((CategoryTheory.Iso.refl (CategoryTheory.Functor.id Xᵒᵈ)).hom.app... | false |
LinearMap.IsNonneg.casesOn | Mathlib.LinearAlgebra.SesquilinearForm.Basic | {R : Type u_1} →
{M : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{I₁ I₂ : R →+* R} →
[inst_3 : LE R] →
{B : M →ₛₗ[I₁] M →ₛₗ[I₂] R} →
{motive : B.IsNonneg → Sort u} →
(t : B.IsNonneg)... | false |
CategoryTheory.CommShift₂Setup.z_zero₂._autoParam | Mathlib.CategoryTheory.Shift.CommShiftTwo | Lean.Syntax | false |
CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct.ι_map_associator_hom_eq_associator_hom | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (V : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u₃)
[inst_4 : CategoryTheory.Category.{v₃, u₃} D] [inst_5 : CategoryTheory.MonoidalCategoryStruc... | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._unary._proof_9 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ),
table.size ≤ pat.utf8ByteSize → ∀ guess < table.size, { byteIdx := guess } < pat.rawEndPos | false |
Lean.Elab.HeaderProcessedSnapshot.bodyStx | Lean.Elab.DefView | Lean.Elab.HeaderProcessedSnapshot → Lean.Syntax | true |
CategoryTheory.CostructuredArrow.ιCompGrothendieckProj | Mathlib.CategoryTheory.Comma.StructuredArrow.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(L : CategoryTheory.Functor C D) →
(X : D) →
(CategoryTheory.Grothendieck.ι (CategoryTheory.CostructuredArrow.functor L) X).comp
(Catego... | true |
MonoidHom.transfer._proof_1 | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_2} [inst : Group G] {H : Subgroup G} {A : Type u_1} [inst_1 : CommGroup A] (ϕ : ↥H →* A)
[inst_2 : H.FiniteIndex], Subgroup.leftTransversals.diff ϕ default (1 • default) = 1 | false |
_private.Std.Data.Internal.List.Associative.0.Option.getD.match_1.eq_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (x : α) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match some x with
| some x => h_1 x
| none => h_2 ()) =
h_1 x | true |
AdicCompletion.liftRingHom._proof_6 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_2} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : CommRing S] (I : Ideal S)
(f : (n : ℕ) → R →+* S ⧸ I ^ n) (hf : ∀ {m n : ℕ} (hle : m ≤ n), (Ideal.Quotient.factorPow I hle).comp (f n) = f m)
(x y : R),
⟨fun n => (Submodule.factor ⋯) ((f n) (x + y)), ⋯⟩ =
⟨fun n => (Submodule.factor ⋯) ((f... | false |
_private.Mathlib.Algebra.MonoidAlgebra.Module.0.MonoidAlgebra.submoduleOfSMulMem._simp_1 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : MulOneClass M] (m : M) (r : R),
MonoidAlgebra.single m r = r • (MonoidAlgebra.of R M) m | false |
ProofWidgets.instHtmlEvalHtml | ProofWidgets.Component.HtmlDisplay | ProofWidgets.HtmlEval ProofWidgets.Html | true |
Lean.ppConstNameWithInfos | Lean.Util.PPExt | Lean.PPContext → Lean.Name → BaseIO Lean.FormatWithInfos | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance.eq_def | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (patByte : UInt8) (table : Array ℕ) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (guess : ℕ) (hg : guess < table.size),
String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance✝ pat patByte table ht h guess hg =
if pat.getUTF8Byte { ... | true |
Lean.Server.FileWorker.AbsoluteLspSemanticToken.rec | Lean.Server.FileWorker.SemanticHighlighting | {motive : Lean.Server.FileWorker.AbsoluteLspSemanticToken → Sort u} →
((pos tailPos : Lean.Lsp.Position) →
(type : Lean.Lsp.SemanticTokenType) →
(priority : ℕ) → motive { pos := pos, tailPos := tailPos, type := type, priority := priority }) →
(t : Lean.Server.FileWorker.AbsoluteLspSemanticToken) → m... | false |
_private.Mathlib.Data.Nat.Cast.SetInterval.0.Nat.image_cast_int_Ico._simp_1_1 | Mathlib.Data.Nat.Cast.SetInterval | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (Set.Ici a).OrdConnected = True | false |
Std.DTreeMap.Raw.Const.get!_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : BEq α] [Std.LawfulBEqCmp cmp] [inst_2 : Inhabited β],
t.WF →
∀ {l : List (α × β)} {k : α},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Raw.Const.get! (Std.DTreeMap.... | true |
Matroid.mapEquiv | Mathlib.Combinatorics.Matroid.Map | {α : Type u_1} → {β : Type u_2} → Matroid α → α ≃ β → Matroid β | true |
CategoryTheory.Discrete.addMonoidalFunctorComp.eq_1 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ {M : Type u} [inst : AddMonoid M] {N : Type u'} [inst_1 : AddMonoid N] {K : Type u} [inst_2 : AddMonoid K]
(F : M →+ N) (G : N →+ K),
CategoryTheory.Discrete.addMonoidalFunctorComp F G =
CategoryTheory.Iso.refl
((CategoryTheory.Discrete.addMonoidalFunctor F).comp (CategoryTheory.Discrete.addMonoidalFunc... | true |
Mathlib.Tactic.Algebra.BaseType.mk.injEq | Mathlib.Tactic.Algebra.Basic | ∀ {u v : Lean.Level} {R : Q(Type u)} {A : Q(Type v)} {sR : Q(CommSemiring «$R»)} {sA : Q(CommSemiring «$A»)}
{sAlg : Q(Algebra «$R» «$A»)} (r : Q(«$R»)) (x x_1 : Mathlib.Tactic.Ring.ExSum q(«$sR») r),
(Mathlib.Tactic.Algebra.BaseType.mk r x = Mathlib.Tactic.Algebra.BaseType.mk r x_1) = (x = x_1) | true |
ProbabilityTheory.IsRatCondKernelCDF.mk | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α × β → ℚ → ℝ}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β},
Measurable f →
(∀ (a : α), ∀ᵐ (b : β) ∂ν a, ProbabilityTheory.IsRatStieltjesPoint f (a, b)) →
(∀ (a : α) (q : ℚ), MeasureTheory... | true |
Nat.SOM.Expr.ctorElim | Init.Data.Nat.SOM | {motive : Nat.SOM.Expr → Sort u} →
(ctorIdx : ℕ) → (t : Nat.SOM.Expr) → ctorIdx = t.ctorIdx → Nat.SOM.Expr.ctorElimType ctorIdx → motive t | false |
_private.Mathlib.Algebra.Order.Group.Unbundled.Int.0.Int.abs_ediv_le_abs.match_1_1 | Mathlib.Algebra.Order.Group.Unbundled.Int | ∀ (motive : (b : ℤ) → (∃ n, b = ↑n ∨ b = -↑n) → Prop) (b : ℤ) (x : ∃ n, b = ↑n ∨ b = -↑n),
(∀ (n : ℕ), motive ↑n ⋯) → (∀ (n : ℕ), motive (-↑n) ⋯) → motive b x | false |
_private.Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries.0.hasFTaylorSeriesUpTo_top_iff'._simp_1_2 | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
CategoryTheory.Pseudofunctor.Grothendieck.map_obj_base | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮]
{F G : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} (α : F ⟶ G)
(a : F.Grothendieck), ((CategoryTheory.Pseudofunctor.Grothendieck.map α).obj a).base = a.base | true |
Lean.Meta.Grind.Arith.Cutsat.resolveCooperDvd | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | Lean.Meta.Grind.Arith.Cutsat.LeCnstr →
Lean.Meta.Grind.Arith.Cutsat.LeCnstr →
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Lean.Meta.Grind.Arith.Cutsat.SearchM Unit | true |
Submodule.restrictScalars.congr_simp | Mathlib.Algebra.Module.Submodule.RestrictScalars | ∀ (S : Type u_1) {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
[inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M]
(V V_1 : Submodule R M), V = V_1 → Submodule.restrictScalars S V = Submodule.restrictScalars S V_1 | true |
CategoryTheory.MorphismProperty.instIsStableUnderTransfiniteCompositionLlp | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C),
W.llp.IsStableUnderTransfiniteComposition | true |
Multiset.Ioo_eq_zero_iff._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α} [DenselyOrdered α],
(Multiset.Ioo a b = 0) = ¬a < b | false |
Monotone.quasiconcaveOn | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : PartialOrder β] [inst_6 : Module 𝕜 E] [PosSMulMono 𝕜 E]
{f : E → β}, Monotone f → QuasiconcaveOn 𝕜 Set.univ f | true |
CategoryTheory.CommSq.cocone_inr | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
{i : Y ⟶ Z} (s : CategoryTheory.CommSq f g h i), s.cocone.inr = i | true |
_private.Mathlib.Topology.Algebra.MulAction.0.Set.univ_smul_nhds_zero._simp_1_4 | Mathlib.Topology.Algebra.MulAction | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
CategoryTheory.MorphismProperty.Under.forget_comp_forget_map | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P Q : CategoryTheory.MorphismProperty T) (X : T)
[inst_1 : Q.IsMultiplicative] {A B : P.Under Q X} (f : A ⟶ B),
((CategoryTheory.MorphismProperty.Under.forget P Q X).comp (CategoryTheory.Under.forget X)).map f = f.right | true |
RelSeries.eraseLast._proof_3 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) (i : Fin (p.length - 1)),
(p.toFun ⟨↑i, ⋯⟩.castSucc, p.toFun ⟨↑i, ⋯⟩.succ) ∈ r | false |
FiniteInter.finiteInterClosure.rec | Mathlib.Data.Set.Constructions | ∀ {α : Type u_1} {S : Set (Set α)} {motive : (a : Set α) → FiniteInter.finiteInterClosure S a → Prop},
(∀ {s : Set α} (a : s ∈ S), motive s ⋯) →
motive Set.univ ⋯ →
(∀ {s t : Set α} (a : FiniteInter.finiteInterClosure S s) (a_1 : FiniteInter.finiteInterClosure S t),
motive s a → motive t a_1 → mot... | false |
GroupCone.mk.noConfusion | Mathlib.Algebra.Order.Group.Cone | {G : Type u_1} →
{inst : CommGroup G} →
{P : Sort u} →
{toSubmonoid : Submonoid G} →
{eq_one_of_mem_of_inv_mem' : ∀ {a : G}, a ∈ toSubmonoid.carrier → a⁻¹ ∈ toSubmonoid.carrier → a = 1} →
{toSubmonoid' : Submonoid G} →
{eq_one_of_mem_of_inv_mem'' : ∀ {a : G}, a ∈ toSubmonoid'.c... | false |
HomologicalComplex.singleObjHomologySelfIso.eq_1 | Mathlib.Algebra.Homology.SingleHomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι) (j : ι)
(A : C),
HomologicalComplex.singleObjHomologySelfIso c j A =
(((HomologicalComplex.... | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_12 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs rls : ℕ) (rll rlr : Std.DTreeMap.Internal.Impl α β) (size : ℕ)
(l r : Std.DTreeMap.Internal.Impl α β),
¬1 + (rll.size + 1 + rlr.size + 1 + (l.size + 1 + r.size)) =
0 + 1 + (rll.size + 1 + rlr.size) + 1 + (l.size + 1 + r.size) →
False | false |
ZeroAtInftyContinuousMap.ctorIdx | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
{inst : TopologicalSpace α} → {inst_1 : Zero β} → {inst_2 : TopologicalSpace β} → ZeroAtInftyContinuousMap α β → ℕ | false |
TestFunction.fderivCLM_apply | Mathlib.Analysis.Distribution.TestFunction | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n k : ℕ∞} [inst_6 : Algebra ℝ 𝕜] [inst_7 : IsScalarTo... | true |
Lean.OpenDecl.ctorElimType | Lean.Data.OpenDecl | {motive : Lean.OpenDecl → Sort u} → ℕ → Sort (max 1 u) | false |
_private.Init.Grind.Ordered.Ring.0.Lean.Grind.OrderedRing.nonneg_intCast_of_nonneg._proof_1_1 | Init.Grind.Ordered.Ring | ∀ (a : ℕ), 0 ≤ Int.negSucc a → False | false |
_private.Lean.Compiler.NameMangling.0.PSigma.casesOn._arg_pusher | Lean.Compiler.NameMangling | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | false |
Module.instQuotientIdealSubmoduleHSMulTop | Mathlib.Algebra.Module.Torsion.Basic | {R : Type u_1} →
(M : Type u_2) →
[inst : Ring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (I : Ideal R) → [inst_3 : I.IsTwoSided] → Module (R ⧸ I) (M ⧸ I • ⊤) | true |
Lean.Grind.Linarith.eq_norm | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} [inst : Lean.Grind.IntModule α] (ctx : Lean.Grind.Linarith.Context α)
(lhs rhs : Lean.Grind.Linarith.Expr) (p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.norm_cert lhs rhs p = true →
Lean.Grind.Linarith.Expr.denote ctx lhs = Lean.Grind.Linarith.Expr.denote ctx rhs →
Lean.Grind.Linari... | true |
CategoryTheory.InducedCategory.homEquiv._proof_2 | Mathlib.CategoryTheory.InducedCategory | ∀ {C : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} D] {F : C → D}
{X Y : CategoryTheory.InducedCategory D F},
Function.RightInverse (fun f => CategoryTheory.InducedCategory.homMk f) fun f => f.hom | false |
Std.Internal.IO.Async.instReprSignal.repr | Std.Internal.Async.Signal | Std.Internal.IO.Async.Signal → ℕ → Std.Format | true |
CategoryTheory.Lax.LaxTrans.app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} → CategoryTheory.Lax.LaxTrans F G → (a : B) → F.obj a ⟶ G.obj a | true |
Cardinal.mk_biUnion_le | Mathlib.SetTheory.Cardinal.Basic | ∀ {ι α : Type u} (A : ι → Set α) (s : Set ι), Cardinal.mk ↑(⋃ x ∈ s, A x) ≤ Cardinal.mk ↑s * ⨆ x, Cardinal.mk ↑(A ↑x) | true |
Lean.JsonRpc.instInhabitedNotification.default | Lean.Data.JsonRpc | {a : Type u_1} → [Inhabited a] → Lean.JsonRpc.Notification a | true |
CategoryTheory.Square.IsPushout.flip | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {sq : CategoryTheory.Square C},
sq.IsPushout → sq.flip.IsPushout | true |
Lean.Compiler.LCNF.compiler.extract_closed | Lean.Compiler.LCNF.ConfigOptions | Lean.Option Bool | true |
Finsupp.embSigma_inj | Mathlib.Data.Finsupp.Sigma | ∀ {κ : Type u_1} {ι : κ → Type u_2} {M : Type u_3} [inst : Zero M] {k : κ} {f g : ι k →₀ M},
f.embSigma = g.embSigma ↔ f = g | true |
_private.Lean.Server.FileWorker.0.Lean.Server.FileWorker.initializeWorker.getImportClosure?.match_1 | Lean.Server.FileWorker | (motive : Option Lean.JsonRpc.Message → Sort u_1) →
(msg? : Option Lean.JsonRpc.Message) →
((params : Lean.Json.Structured) →
motive (some (Lean.JsonRpc.Message.notification "textDocument/publishDiagnostics" (some params)))) →
((params : Lean.Json.Structured) →
motive (some (Lean.JsonRpc.M... | false |
Continuous.mul | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M] {X : Type u_2}
[inst_3 : TopologicalSpace X] {f g : X → M}, Continuous f → Continuous g → Continuous (f * g) | true |
Locale.adjunctionTopToLocalePT._proof_3 | Mathlib.Topology.Order.Category.FrameAdjunction | ∀ ⦃X Y : Locale⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((Locale.pt.comp topToLocale).map f) (Opposite.op (Frm.ofHom Y.counitAppCont)) =
CategoryTheory.CategoryStruct.comp (Opposite.op (Frm.ofHom X.counitAppCont))
((CategoryTheory.Functor.id Locale).map f) | false |
Ordinal.IsPrincipal.eq_1 | Mathlib.SetTheory.Ordinal.Principal | ∀ (op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1}) (o : Ordinal.{u_1}),
Ordinal.IsPrincipal op o = ∀ ⦃a b : Ordinal.{u_1}⦄, a < o → b < o → op a b < o | true |
instLiesOverFiberOfIsPrime | Mathlib.RingTheory.LocalRing.ResidueField.Fiber | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (q : Ideal (p.Fiber S)) [q.IsPrime], q.LiesOver p | true |
Std.ExtDTreeMap.Const.get_filterMap' | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {γ : Type w} {t : Std.ExtDTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] [inst_1 : Std.LawfulEqCmp cmp] {f : α → β → Option γ} {k : α}
{h : k ∈ Std.ExtDTreeMap.filterMap f t},
Std.ExtDTreeMap.Const.get (Std.ExtDTreeMap.filterMap f t) k h = (f k (Std.ExtD... | true |
Matrix.IsAdjMatrix.hadamard_self | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : MulZeroOneClass α] {A : Matrix V V α}, A.IsAdjMatrix → A.hadamard A = A | true |
Matrix.blockDiag' | Mathlib.Data.Matrix.Block | {o : Type u_4} →
{m' : o → Type u_7} →
{n' : o → Type u_8} →
{α : Type u_12} → Matrix ((i : o) × m' i) ((i : o) × n' i) α → (k : o) → Matrix (m' k) (n' k) α | true |
QuotientAddGroup.rangeKerLift._proof_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_2} [inst_1 : AddGroup H] (φ : G →+ H),
∀ g ∈ φ.ker, g ∈ φ.rangeRestrict.ker | false |
frequently_frequently_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {p : X → Prop},
(∃ᶠ (x' : X) in nhds x, ∃ᶠ (x'' : X) in nhds x', p x'') ↔ ∃ᶠ (x : X) in nhds x, p x | true |
DirectSum.IsInternal.subordinateOrthonormalBasis.congr_simp | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_7} {𝕜 : Type u_8} [inst : RCLike 𝕜] {E : Type u_9} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : FiniteDimensional 𝕜 E] {n : ℕ}
(hn : Module.finrank 𝕜 E = n) {inst_5 : DecidableEq ι} [inst_6 : DecidableEq ι] {V V_1 : ι → Submodule 𝕜 E}
(e_V : V... | true |
Nat.EqResult.decide.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ (b b_1 : Bool), (Nat.EqResult.decide b = Nat.EqResult.decide b_1) = (b = b_1) | true |
VectorBundle.mk | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : TopologicalSpace (Bundle.TotalSpace F E... | true |
SimpleGraph.Walk.isPath_iff_eq_nil._simp_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} (p : G.Walk u u), p.IsPath = (p = SimpleGraph.Walk.nil) | false |
Matrix.toLinearEquivRight'OfInv_symm_apply | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : Semiring R] {m : Type u_3} {n : Type u_4} [inst_1 : Fintype m] [inst_2 : DecidableEq m]
[inst_3 : Fintype n] [inst_4 : DecidableEq n] {M : Matrix m n R} {M' : Matrix n m R} (hMM' : M * M' = 1)
(hM'M : M' * M = 1) (a : m → R) (a_1 : n),
(Matrix.toLinearEquivRight'OfInv hMM' hM'M).symm a a_... | true |
String.Slice.Pos.le_endPos._simp_1 | Init.Data.String.Basic | ∀ {s : String.Slice} (p : s.Pos), (p ≤ s.endPos) = True | false |
Function.Injective.hasLeftInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} [Nonempty α] {f : α → β}, Function.Injective f → Function.HasLeftInverse f | true |
CategoryTheory.Comonad.comonadicOfCreatesFSplitEqualizers | Mathlib.CategoryTheory.Monad.Comonadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
(F ⊣ G) → [CategoryTheory.Comonad.CreatesLimitOfIsCosplitPair F] → CategoryTheory.... | true |
ContinuousMap.intCast_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : IntCast β] (n : ℤ)
(x : α), ↑n x = ↑n | true |
Submodule.span_singleton_smul_eq | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {r : R},
IsUnit r → ∀ (x : M), R ∙ r • x = R ∙ x | true |
Lean.Compiler.LCNF.casesThunkToMono | Lean.Compiler.LCNF.ToMono | (c : Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure) →
(c.typeName == `Thunk) = true → Lean.Compiler.LCNF.ToMonoM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) | true |
pointedToBipointedFst._proof_7 | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y Z : Pointed} (f : X ⟶ Y) (g : Y ⟶ Z),
Option.map (CategoryTheory.CategoryStruct.comp f g).toFun
{ X := Option X.X, toProd := (some X.point, none) }.toProd.2 =
Option.map (CategoryTheory.CategoryStruct.comp f g).toFun
{ X := Option X.X, toProd := (some X.point, none) }.toProd.2 | false |
Lean.Meta.LazyDiscrTree.Key.lit.elim | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Key → Sort u} →
(t : Lean.Meta.LazyDiscrTree.Key) →
t.ctorIdx = 2 → ((a : Lean.Literal) → motive (Lean.Meta.LazyDiscrTree.Key.lit a)) → motive t | false |
Std.DTreeMap.Equiv.constGetEntryGED_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{k : α} {fallback : α × β},
t₁.Equiv t₂ → Std.DTreeMap.Const.getEntryGED t₁ k fallback = Std.DTreeMap.Const.getEntryGED t₂ k fallback | true |
FreeAbelianGroup.ring._proof_1 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1) [inst : Monoid α] (x : FreeAbelianGroup α), 1 * x = x | false |
FunLike.commGroup._proof_5 | Mathlib.Data.FunLike.Group | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : Pow F ℕ] [inst_2 : CommGroup β]
[IsPowApply ℕ F α β] (f : F) (n : ℕ), ⇑(f ^ n) = ⇑f ^ n | false |
Lean.Diff.Histogram.Entry.leftWF | Lean.Util.Diff | ∀ {α : Type u} {lsize rsize : ℕ} (self : Lean.Diff.Histogram.Entry α lsize rsize),
self.leftCount = 0 ↔ self.leftIndex = none | true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.split'.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ (motive : ONote × ℕ → Sort u_1) (a' : ONote) (m : ℕ) (h_1 : (a' : ONote) → (m : ℕ) → motive (a', m)),
(match (a', m) with
| (a', m) => h_1 a' m) =
h_1 a' m | true |
CategoryTheory.Equivalence.symm_counitIso | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D), e.symm.counitIso = e.unitIso.symm | true |
metricSpaceOfNormedAddCommGroupOfAddTorsor._proof_5 | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ (V : Type u_2) (P : Type u_1) [inst : NormedAddCommGroup V] [inst_1 : AddTorsor V P],
uniformity P = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | ‖p.1 -ᵥ p.2‖ < ε} | false |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.LSeries_residueClass_eq._simp_1_4 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ (f : ℕ → ℂ) (c s : ℂ), c * LSeries f s = LSeries (c • f) s | false |
_private.Mathlib.RingTheory.LaurentSeries.0.LaurentSeries.powerSeries_ext_subring.match_1_1 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K] (x : LaurentSeries.RatFuncAdicCompl K)
(motive :
x ∈ Subring.map (LaurentSeries.LaurentSeriesRingEquiv K).toRingHom (LaurentSeries.powerSeries_as_subring K) → Prop)
(x_1 : x ∈ Subring.map (LaurentSeries.LaurentSeriesRingEquiv K).toRingHom (LaurentSeries.powerSeries_as_subring K... | false |
_private.Lean.Data.Lsp.Extra.0.Lean.Lsp.instToJsonLeanImportMetaKind.toJson.match_1 | Lean.Data.Lsp.Extra | (motive : Lean.Lsp.LeanImportMetaKind → Sort u_1) →
(x : Lean.Lsp.LeanImportMetaKind) →
(Unit → motive Lean.Lsp.LeanImportMetaKind.nonMeta) →
(Unit → motive Lean.Lsp.LeanImportMetaKind.meta) → (Unit → motive Lean.Lsp.LeanImportMetaKind.full) → motive x | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Countable.0.MeasureTheory.SimpleFunc.exists_lt_lintegral_simpleFunc_of_lt_lintegral._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Countable | ∀ {r : NNReal}, (↑r = 0) = (r = 0) | false |
AddSubmonoid.mem_addUnits_of_val_mem_neg_val_mem | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M) {x : AddUnits M}, ↑x ∈ S → ↑(-x) ∈ S → x ∈ S.addUnits | true |
Real.mk_mul | Mathlib.Data.Real.Basic | ∀ {f g : CauSeq ℚ abs}, Real.mk (f * g) = Real.mk f * Real.mk g | true |
Lean.Elab.Term.forEachExprWithExposedLevelMVars | Lean.Elab.Term.TermElabM | Lean.Expr → (Lean.Expr → Lean.Elab.TermElabM Unit) → Lean.Elab.TermElabM Unit | true |
String.Slice.mk._flat_ctor | Init.Data.String.Defs | (str : String) → (startInclusive endExclusive : str.Pos) → startInclusive ≤ endExclusive → String.Slice | false |
Matrix.transpose_multiset_sum | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_11} [inst : AddCommMonoid α] (s : Multiset (Matrix m n α)),
s.sum.transpose = (Multiset.map Matrix.transpose s).sum | true |
MatrixModCat.unitIso._proof_1 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u_1) {ι : Type u_2} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι] (X : ModuleCat R),
IsScalarTower R (Matrix ι ι R) (ι → ↑X) | false |
Lean.Meta.instInhabitedPostponedEntry.default | Lean.Meta.Basic | Lean.Meta.PostponedEntry | true |
_private.Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries.0.hasFTaylorSeriesUpTo_top_iff._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞} {p : E → FormalMultilinearSeries 𝕜 E F},
HasFTaylorSeriesUpTo n f p = HasFTaylorSeri... | false |
SSet.stdSimplex.homOfLE_faceSingletonComplIso_inv_eq_facePairComplIso_inv_δ_pred_assoc | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (i j : Fin (n + 3)) (h : i < j) {Z : SSet} (h_1 : SSet.stdSimplex.obj { len := n + 1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp (SSet.Subcomplex.homOfLE ⋯)
(CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.faceSingletonComplIso i).inv h_1) =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.f... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.