name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
cfc_mono._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
Set.MapsTo.inter_inter | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β} {f : α → β},
Set.MapsTo f s₁ t₁ → Set.MapsTo f s₂ t₂ → Set.MapsTo f (s₁ ∩ s₂) (t₁ ∩ t₂) |
Fin.succ_eq_last_succ | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {i : Fin n.succ}, i.succ = Fin.last (n + 1) ↔ i = Fin.last n |
R0Space.specializes_symmetric | Mathlib.Topology.Separation.Basic | ∀ {X : Type u} {inst : TopologicalSpace X} [self : R0Space X], Symmetric Specializes |
UpperHalfPlane.verticalStrip | Mathlib.Analysis.Complex.UpperHalfPlane.Topology | ℝ → ℝ → Set UpperHalfPlane |
BoundedContinuousFunction._aux_Mathlib_Topology_ContinuousMap_BoundedCompactlySupported___unexpand_compactlySupported_1 | Mathlib.Topology.ContinuousMap.BoundedCompactlySupported | Lean.PrettyPrinter.Unexpander |
CategoryTheory.Limits.parallelPairHom._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y')
(p : X ⟶ X') (q : Y ⟶ Y'),
CategoryTheory.CategoryStruct.comp g q = CategoryTheory.CategoryStruct.comp p g' →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair f g).map CategoryTheory.Limits.WalkingParallelPairHom.right) q =
CategoryTheory.CategoryStruct.comp p
((CategoryTheory.Limits.parallelPair f' g').map CategoryTheory.Limits.WalkingParallelPairHom.right) |
GenContFract.convs'Aux_stable_step_of_terminated | Mathlib.Algebra.ContinuedFractions.TerminatedStable | ∀ {K : Type u_1} {n : ℕ} [inst : DivisionRing K] {s : Stream'.Seq (GenContFract.Pair K)},
s.TerminatedAt n → GenContFract.convs'Aux s (n + 1) = GenContFract.convs'Aux s n |
Turing.TM0.Stmt.move.inj | Mathlib.Computability.PostTuringMachine | ∀ {Γ : Type u_1} {a a_1 : Turing.Dir}, Turing.TM0.Stmt.move a = Turing.TM0.Stmt.move a_1 → a = a_1 |
CliffordAlgebra.GradedAlgebra.ι | Mathlib.LinearAlgebra.CliffordAlgebra.Grading | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(Q : QuadraticForm R M) → M →ₗ[R] DirectSum (ZMod 2) fun i => ↥(CliffordAlgebra.evenOdd Q i) |
Cardinal.isInaccessible_def | Mathlib.SetTheory.Cardinal.Regular | ∀ {c : Cardinal.{u_1}}, c.IsInaccessible ↔ Cardinal.aleph0 < c ∧ c.IsRegular ∧ c.IsStrongLimit |
Char.ltAsymm | Init.Data.Char.Lemmas | Std.Asymm fun x1 x2 => x1 < x2 |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldlM.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(x : δ) (x_1 : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldlM f x x_1 =
match x, x_1 with
| d, Std.DHashMap.Internal.AssocList.nil => pure d
| d, Std.DHashMap.Internal.AssocList.cons a b es => do
let d ← f d a b
Std.DHashMap.Internal.AssocList.foldlM f d es |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.goWithIncremental._proof_1 | Lean.Elab.Tactic.Induction | ∀ (r : Array Lean.Elab.Tactic.ElimApp.Alt) (i : Fin r.size), ↑i < r.size |
List.min?_cons' | Init.Data.List.MinMax | ∀ {α : Type u_1} {x : α} [inst : Min α] {xs : List α}, (x :: xs).min? = some (List.foldl min x xs) |
UniformSpace.Completion.instNormedSpace._proof_2 | Mathlib.Analysis.Normed.Module.Completion | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E],
UniformContinuousConstSMul 𝕜 E |
CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[inst_1 : CategoryTheory.Limits.HasFiniteCoproducts C]
[CategoryTheory.Limits.HasColimitsOfShape (Finset (CategoryTheory.Discrete α)) C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C),
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetObj F) |
Std.Tactic.BVDecide.LRAT.Internal.Clause.mk.noConfusion | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : outParam (Type u)} →
{β : Type v} →
{P : Sort u_1} →
{toList : β → Std.Sat.CNF.Clause α} →
{not_tautology : ∀ (c : β) (l : Std.Sat.Literal α), l ∉ toList c ∨ l.negate ∉ toList c} →
{ofArray : Array (Std.Sat.Literal α) → Option β} →
{empty : β} →
{empty_eq : toList empty = []} →
{unit : Std.Sat.Literal α → β} →
{unit_eq : ∀ (l : Std.Sat.Literal α), toList (unit l) = [l]} →
{isUnit : β → Option (Std.Sat.Literal α)} →
{isUnit_iff : ∀ (c : β) (l : Std.Sat.Literal α), isUnit c = some l ↔ toList c = [l]} →
{negate : β → Std.Sat.CNF.Clause α} →
{negate_eq : ∀ (c : β), negate c = List.map Std.Sat.Literal.negate (toList c)} →
{delete : β → Std.Sat.Literal α → β} →
{delete_iff :
∀ (c : β) (l l' : Std.Sat.Literal α),
l' ∈ toList (delete c l) ↔ l' ≠ l ∧ l' ∈ toList c} →
{contains : β → Std.Sat.Literal α → Bool} →
{contains_iff :
∀ (c : β) (l : Std.Sat.Literal α), contains c l = true ↔ l ∈ toList c} →
{reduce :
β →
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment →
Std.Tactic.BVDecide.LRAT.Internal.ReduceResult α} →
{toList' : β → Std.Sat.CNF.Clause α} →
{not_tautology' :
∀ (c : β) (l : Std.Sat.Literal α), l ∉ toList' c ∨ l.negate ∉ toList' c} →
{ofArray' : Array (Std.Sat.Literal α) → Option β} →
{empty' : β} →
{empty_eq' : toList' empty' = []} →
{unit' : Std.Sat.Literal α → β} →
{unit_eq' : ∀ (l : Std.Sat.Literal α), toList' (unit' l) = [l]} →
{isUnit' : β → Option (Std.Sat.Literal α)} →
{isUnit_iff' :
∀ (c : β) (l : Std.Sat.Literal α),
isUnit' c = some l ↔ toList' c = [l]} →
{negate' : β → Std.Sat.CNF.Clause α} →
{negate_eq' :
∀ (c : β),
negate' c =
List.map Std.Sat.Literal.negate (toList' c)} →
{delete' : β → Std.Sat.Literal α → β} →
{delete_iff' :
∀ (c : β) (l l' : Std.Sat.Literal α),
l' ∈ toList' (delete' c l) ↔
l' ≠ l ∧ l' ∈ toList' c} →
{contains' : β → Std.Sat.Literal α → Bool} →
{contains_iff' :
∀ (c : β) (l : Std.Sat.Literal α),
contains' c l = true ↔ l ∈ toList' c} →
{reduce' :
β →
Array
Std.Tactic.BVDecide.LRAT.Internal.Assignment →
Std.Tactic.BVDecide.LRAT.Internal.ReduceResult
α} →
{ toList := toList,
not_tautology := not_tautology,
ofArray := ofArray, empty := empty,
empty_eq := empty_eq, unit := unit,
unit_eq := unit_eq, isUnit := isUnit,
isUnit_iff := isUnit_iff, negate := negate,
negate_eq := negate_eq, delete := delete,
delete_iff := delete_iff,
contains := contains,
contains_iff := contains_iff,
reduce := reduce } =
{ toList := toList',
not_tautology := not_tautology',
ofArray := ofArray', empty := empty',
empty_eq := empty_eq', unit := unit',
unit_eq := unit_eq', isUnit := isUnit',
isUnit_iff := isUnit_iff',
negate := negate', negate_eq := negate_eq',
delete := delete',
delete_iff := delete_iff',
contains := contains',
contains_iff := contains_iff',
reduce := reduce' } →
(toList ≍ toList' →
ofArray ≍ ofArray' →
empty ≍ empty' →
unit ≍ unit' →
isUnit ≍ isUnit' →
negate ≍ negate' →
delete ≍ delete' →
contains ≍ contains' →
reduce ≍ reduce' → P) →
P |
Stream'.WSeq.productive_dropn | Mathlib.Data.WSeq.Productive | ∀ {α : Type u} (s : Stream'.WSeq α) [s.Productive] (n : ℕ), (s.drop n).Productive |
Submodule.Quotient.instSMul' | Mathlib.LinearAlgebra.Quotient.Defs | {R : Type u_1} →
{M : Type u_2} →
[inst : Ring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{S : Type u_3} →
[inst_3 : SMul S R] → [inst_4 : SMul S M] → [IsScalarTower S R M] → (P : Submodule R M) → SMul S (M ⧸ P) |
Std.ExtDHashMap.mem_alter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : Option (β k) → Option (β k)},
k' ∈ m.alter k f ↔ if (k == k') = true then (f (m.get? k)).isSome = true else k' ∈ m |
IsCompact.exists_thickening_image_subset | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {β : Type u_2} [inst_1 : PseudoEMetricSpace β] {f : α → β} {K : Set α}
{U : Set β},
IsCompact K →
IsOpen U →
(∀ x ∈ K, ContinuousAt f x) → Set.MapsTo f K U → ∃ ε > 0, ∃ V ∈ nhdsSet K, Metric.thickening ε (f '' V) ⊆ U |
Lean.Lsp.instHashableRpcRef | Lean.Server.Rpc.Basic | Hashable Lean.Lsp.RpcRef |
CategoryTheory.sum.inrCompInverseAssociator_inv_app | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : D ⊕ E),
(CategoryTheory.sum.inrCompInverseAssociator C D E).inv.app X =
CategoryTheory.CategoryStruct.id
((((CategoryTheory.Sum.inr_ C D).comp (CategoryTheory.Sum.inl_ (C ⊕ D) E)).sum'
(CategoryTheory.Sum.inr_ (C ⊕ D) E)).obj
X) |
Std.DTreeMap.Internal.Const.RoiSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Const.RoiSliceData α β → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => β) →
(range : Std.Roi α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.Const.RoiSliceData α β) → motive t |
MvPolynomial.supported.eq_1 | Mathlib.Algebra.MvPolynomial.Supported | ∀ {σ : Type u_1} (R : Type u) [inst : CommSemiring R] (s : Set σ),
MvPolynomial.supported R s = Algebra.adjoin R (MvPolynomial.X '' s) |
MeasureTheory.SimpleFunc.instLattice._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Lattice β] (a b : MeasureTheory.SimpleFunc α β),
SemilatticeInf.inf a b ≤ a |
Subsemigroup.le_comap_map | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup M) {f : M →ₙ* N},
S ≤ Subsemigroup.comap f (Subsemigroup.map f S) |
ProbabilityTheory.Kernel.comap._proof_1 | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_3} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_1}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (g : γ → α), Measurable g → Measurable (⇑κ ∘ g) |
MonoidHom.toLocalizationMap._proof_2 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] (f : M →* N),
(∀ (y : ↥S), IsUnit (f ↑y)) →
(∀ (z : N), ∃ x, z * f ↑x.2 = f x.1) →
(∀ (x y : M), f x = f y → ∃ c, ↑c * x = ↑c * y) → S.IsLocalizationMap (↑f).toFun |
Real.not_DifferentiableAt_log_mul_zero | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ¬DifferentiableAt ℝ (fun x => x * Real.log x) 0 |
Mathlib.Tactic.CancelDenoms.CancelResult.recOn | Mathlib.Tactic.CancelDenoms.Core | {u : Lean.Level} →
{α : Q(Type u)} →
{mα : Q(Mul «$α»)} →
{e v : Q(«$α»)} →
{motive : Mathlib.Tactic.CancelDenoms.CancelResult mα e v → Sort u} →
(t : Mathlib.Tactic.CancelDenoms.CancelResult mα e v) →
((cancelled : Q(«$α»)) →
(pf : Q(«$v» * «$e» = «$cancelled»)) → motive { cancelled := cancelled, pf := pf }) →
motive t |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.destructTuple._proof_2 | Lean.Elab.Do.Legacy | ∀ (uvars : Array Lean.Elab.Term.Do.Var), uvars.size = 1 → 0 < uvars.size |
NormedAddGroupHom.range_comp_incl_top | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_3} {V₂ : Type u_4} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f : NormedAddGroupHom V₁ V₂), (f.comp (NormedAddGroupHom.incl ⊤)).range = f.range |
_private.Init.Data.Slice.Array.Lemmas.0.Std.Internal.List.extract_eq_drop_take'._simp_1_5 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) |
Std.TreeMap.Raw.getKey!_union | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → ∀ {k : α}, (t₁ ∪ t₂).getKey! k = t₂.getKeyD k (t₁.getKey! k) |
MvPFunctor.instMvQPFObj | Mathlib.Data.QPF.Multivariate.Basic | {n : ℕ} → (P : MvPFunctor.{u_1} n) → MvQPF ↑P |
mem_upperBounds_image2_of_mem_lowerBounds | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {f : α → β → γ}
{s : Set α} {t : Set β} {a : α} {b : β},
(∀ (b : β), Antitone (Function.swap f b)) →
(∀ (a : α), Antitone (f a)) → a ∈ lowerBounds s → b ∈ lowerBounds t → f a b ∈ upperBounds (Set.image2 f s t) |
Nat.Partrec.Code.evaln._unary._proof_7 | Mathlib.Computability.PartrecCode | ∀ (k : ℕ) (cf cg : Nat.Partrec.Code),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 ⟨k, cf.prec cg⟩
⟨k.succ, cf.prec cg⟩ |
SMulPosStrictMono.toSMulPosMono | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] [inst_3 : PartialOrder α]
[inst_4 : PartialOrder β] [SMulPosStrictMono α β], SMulPosMono α β |
DependsOn.dependsOn_lmarginalPartialTraj | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {b : ℕ}
{κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))}
[∀ (n : ℕ), ProbabilityTheory.IsSFiniteKernel (κ n)] (a : ℕ) {f : ((n : ℕ) → X n) → ENNReal},
DependsOn f ↑(Finset.Iic b) →
Measurable f → DependsOn (ProbabilityTheory.Kernel.lmarginalPartialTraj κ a b f) ↑(Finset.Iic a) |
CategoryTheory.Limits.Concrete.limit_ext | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type r}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {J : Type w}
[inst_3 : CategoryTheory.Category.{t, w} J] (F : CategoryTheory.Functor J C)
[CategoryTheory.Limits.PreservesLimit F (CategoryTheory.forget C)] [inst_5 : CategoryTheory.Limits.HasLimit F]
(x y : CategoryTheory.ToType (CategoryTheory.Limits.limit F)),
(∀ (j : J),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.limit.π F j)) x =
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.limit.π F j)) y) →
x = y |
Std.ExtDTreeMap.getKey!_inter_of_not_mem_right | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Inhabited α]
[inst_1 : Std.TransCmp cmp] {k : α}, k ∉ t₂ → (t₁ ∩ t₂).getKey! k = default |
List.find?_replicate_eq_some_iff._simp_1 | Init.Data.List.Find | ∀ {α : Type u_1} {n : ℕ} {a b : α} {p : α → Bool},
(List.find? p (List.replicate n a) = some b) = (n ≠ 0 ∧ p a = true ∧ a = b) |
Lean.IR.Expr.ctor | Lean.Compiler.IR.Basic | Lean.IR.CtorInfo → Array Lean.IR.Arg → Lean.IR.Expr |
OpenNormalSubgroup.pathComponentOne.eq_1 | Mathlib.Topology.Connected.PathComponentOne | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G]
[inst_3 : LocPathConnectedSpace G],
OpenNormalSubgroup.pathComponentOne G = { toSubgroup := Subgroup.pathComponentOne G, isOpen' := ⋯, isNormal' := ⋯ } |
Lean.Meta.MVarRenaming.map._default | Lean.Meta.Match.MVarRenaming | Lean.MVarIdMap Lean.MVarId |
UInt16.neg_ne_zero | Init.Data.UInt.Lemmas | ∀ {a : UInt16}, -a ≠ 0 ↔ a ≠ 0 |
Lean.Meta.Simp.instInhabitedContext.default | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Context |
Lean.IR.Decl.noConfusion | Lean.Compiler.IR.Basic | {P : Sort u} → {t t' : Lean.IR.Decl} → t = t' → Lean.IR.Decl.noConfusionType P t t' |
Lean.Server.Watchdog.handleIleanInfoUpdate | Lean.Server.Watchdog | Lean.Server.Watchdog.FileWorker → Lean.Lsp.LeanIleanInfoParams → Lean.Server.Watchdog.ServerM Unit |
LinearIsometryEquiv.toHomeomorph_injective | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
[inst_7 : Module R₂ E₂], Function.Injective LinearIsometryEquiv.toHomeomorph |
IO.FS.Metadata.modified | Init.System.IO | IO.FS.Metadata → IO.FS.SystemTime |
TopologicalSpace.Opens.comap | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → C(α, β) → FrameHom (TopologicalSpace.Opens β) (TopologicalSpace.Opens α) |
Lean.Lsp.ClientCapabilities.casesOn | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.ClientCapabilities → Sort u} →
(t : Lean.Lsp.ClientCapabilities) →
((textDocument? : Option Lean.Lsp.TextDocumentClientCapabilities) →
(window? : Option Lean.Lsp.WindowClientCapabilities) →
(workspace? : Option Lean.Lsp.WorkspaceClientCapabilities) →
(lean? : Option Lean.Lsp.LeanClientCapabilities) →
motive { textDocument? := textDocument?, window? := window?, workspace? := workspace?, lean? := lean? }) →
motive t |
_private.Std.Time.Date.Unit.Day.0.Std.Time.Day.Offset.toMilliseconds._proof_1 | Std.Time.Date.Unit.Day | 86400 / ↑86400000 = 1 / 1000 |
LocallyConstant.comapAddMonoidHom_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Z : Type u_6}
[inst_2 : AddZeroClass Z] (f : C(X, Y)) (g : LocallyConstant Y Z),
(LocallyConstant.comapAddMonoidHom f) g = LocallyConstant.comap f g |
mul_two | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n * 2 = n + n |
_private.Lean.Elab.Print.0.Lean.Elab.Command.printIdCore._sparseCasesOn_1 | Lean.Elab.Print | {motive : Lean.ConstantKind → Sort u} →
(t : Lean.ConstantKind) →
motive Lean.ConstantKind.defn → motive Lean.ConstantKind.thm → (Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t |
Lean.Meta.getUInt16Value? | Lean.Meta.LitValues | Lean.Expr → Lean.MetaM (Option UInt16) |
StrictMonoOn.exists_slope_lt_deriv | Mathlib.Analysis.Convex.Deriv | ∀ {x y : ℝ} {f : ℝ → ℝ},
ContinuousOn f (Set.Icc x y) →
x < y → StrictMonoOn (deriv f) (Set.Ioo x y) → ∃ a ∈ Set.Ioo x y, (f y - f x) / (y - x) < deriv f a |
Algebra.EssFiniteType.isNoetherianRing | Mathlib.RingTheory.Localization.Submodule | ∀ (R : Type u_3) (S : Type u_4) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.EssFiniteType R S] [IsNoetherianRing R], IsNoetherianRing S |
MulAction.stabilizerEquivStabilizer.congr_simp | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {g g_1 : G} (e_g : g = g_1) {a b : α}
(hg : b = g • a), MulAction.stabilizerEquivStabilizer hg = MulAction.stabilizerEquivStabilizer ⋯ |
Algebra.instMulDistribMulActionAlgHomUnits._proof_2 | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u_2} (A : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : Aˣ), 1 • x = x |
_private.Mathlib.Analysis.Normed.Module.FiniteDimension.0.isOpen_setOf_nat_le_rank._simp_1_1 | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {K : Type u} {V : Type v} {V' : Type v'} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V'] [inst_4 : Module K V'] {n : ℕ} {f : V →ₗ[K] V'},
(↑n ≤ f.rank) = ∃ s, s.card = n ∧ LinearIndependent K fun (x : ↑↑s) => f ↑x |
CategoryTheory.Discrete.opposite_inverse_obj | Mathlib.CategoryTheory.Discrete.Basic | ∀ (α : Type u₁) (a : CategoryTheory.Discrete α), (CategoryTheory.Discrete.opposite α).inverse.obj a = Opposite.op a |
CategoryTheory.Functor.Additive.map_add._autoParam | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | Lean.Syntax |
CategoryTheory.PrelaxFunctor.toPrelaxFunctorStruct | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.PrelaxFunctor B C → CategoryTheory.PrelaxFunctorStruct B C |
IsLprojection.Subtype.BooleanAlgebra._proof_12 | Mathlib.Analysis.Normed.Module.MStructure | ∀ {X : Type u_2} [inst : NormedAddCommGroup X] {M : Type u_1} [inst_1 : Ring M] [inst_2 : Module M X]
[inst_3 : FaithfulSMul M X] (P Q : { P // IsLprojection X P }), P \ Q = P ⊓ Qᶜ |
Lean.SimplePersistentEnvExtension | Lean.EnvExtension | Type → Type → Type |
hasFTaylorSeriesUpToOn_succ_iff_right | 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] {s : Set E}
{f : E → F} {n : WithTop ℕ∞} {p : E → FormalMultilinearSeries 𝕜 E F},
HasFTaylorSeriesUpToOn (n + 1) f p s ↔
(∀ x ∈ s, (p x 0).curry0 = f x) ∧
(∀ x ∈ s, HasFDerivWithinAt (fun y => p y 0) (p x 1).curryLeft s x) ∧
HasFTaylorSeriesUpToOn n (fun x => (continuousMultilinearCurryFin1 𝕜 E F) (p x 1)) (fun x => (p x).shift) s |
Lean.Server.FileWorker.Query.noConfusion | Lean.Server.CodeActions.UnknownIdentifier | {P : Sort u} → {t t' : Lean.Server.FileWorker.Query} → t = t' → Lean.Server.FileWorker.Query.noConfusionType P t t' |
MeasureTheory.eLpNorm'_congr_nnnorm_ae | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_5} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] {f g : α → F},
(∀ᵐ (x : α) ∂μ, ‖f x‖₊ = ‖g x‖₊) → MeasureTheory.eLpNorm' f q μ = MeasureTheory.eLpNorm' g q μ |
LinearMap.continuousAt_zero_of_locally_bounded | Mathlib.Analysis.LocallyConvex.ContinuousOfBounded | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} {E : Type u_3} {F : Type u_4} [inst : AddCommGroup E] [inst_1 : TopologicalSpace E]
[IsTopologicalAddGroup E] [inst_3 : AddCommGroup F] [inst_4 : TopologicalSpace F] [inst_5 : NontriviallyNormedField 𝕜]
[inst_6 : Module 𝕜 E] [ContinuousSMul 𝕜 E] [inst_8 : NormedField 𝕜'] [inst_9 : Module 𝕜' F] {σ : 𝕜 →+* 𝕜'}
[RingHomIsometric σ] [FirstCountableTopology E] (f : E →ₛₗ[σ] F),
(∀ (s : Set E), Bornology.IsVonNBounded 𝕜 s → Bornology.IsVonNBounded 𝕜' (⇑f '' s)) → ContinuousAt (⇑f) 0 |
Lean.Elab.Tactic.BVDecide.Frontend.UnsatProver.Result.mk.sizeOf_spec | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide | ∀ (proof : Lean.Expr) (lratCert : Lean.Elab.Tactic.BVDecide.Frontend.LratCert),
sizeOf { proof := proof, lratCert := lratCert } = 1 + sizeOf proof + sizeOf lratCert |
DistribMulActionHom.rec | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
[inst : Monoid M] →
{N : Type u_2} →
[inst_1 : Monoid N] →
{φ : M →* N} →
{A : Type u_4} →
[inst_2 : AddMonoid A] →
[inst_3 : DistribMulAction M A] →
{B : Type u_5} →
[inst_4 : AddMonoid B] →
[inst_5 : DistribMulAction N B] →
{motive : (A →ₑ+[φ] B) → Sort u} →
((toMulActionHom : A →ₑ[⇑φ] B) →
(map_zero' : toMulActionHom.toFun 0 = 0) →
(map_add' :
∀ (x y : A),
toMulActionHom.toFun (x + y) = toMulActionHom.toFun x + toMulActionHom.toFun y) →
motive
{ toMulActionHom := toMulActionHom, map_zero' := map_zero', map_add' := map_add' }) →
(t : A →ₑ+[φ] B) → motive t |
MonadCont.Label.noConfusion | Mathlib.Control.Monad.Cont | {P : Sort u_1} →
{α : Type w} →
{m : Type u → Type v} →
{β : Type u} →
{t : MonadCont.Label α m β} →
{α' : Type w} →
{m' : Type u → Type v} →
{β' : Type u} →
{t' : MonadCont.Label α' m' β'} →
α = α' → m = m' → β = β' → t ≍ t' → MonadCont.Label.noConfusionType P t t' |
RightOrdContinuous.toOrderEmbedding | Mathlib.Order.OrdContinuous | {α : Type u} →
{β : Type v} →
[inst : SemilatticeInf α] →
[inst_1 : SemilatticeInf β] → (f : α → β) → RightOrdContinuous f → Function.Injective f → α ↪o β |
Aesop.GoalData.mk.sizeOf_spec | Aesop.Tree.Data | ∀ {Rapp MVarCluster : Type} [inst : SizeOf Rapp] [inst_1 : SizeOf MVarCluster] (id : Aesop.GoalId)
(parent : IO.Ref MVarCluster) (children : Array (IO.Ref Rapp)) (origin : Aesop.GoalOrigin) (depth : ℕ)
(state : Aesop.GoalState) (isIrrelevant isForcedUnprovable : Bool) (preNormGoal : Lean.MVarId)
(normalizationState : Aesop.NormalizationState) (mvars : Aesop.UnorderedArraySet Lean.MVarId)
(forwardState : Aesop.ForwardState) (forwardRuleMatches : Aesop.ForwardRuleMatches)
(successProbability : Aesop.Percent) (addedInIteration lastExpandedInIteration : Aesop.Iteration)
(unsafeRulesSelected : Bool) (unsafeQueue : Aesop.UnsafeQueue) (failedRapps : Array Aesop.RegularRule),
sizeOf
{ id := id, parent := parent, children := children, origin := origin, depth := depth, state := state,
isIrrelevant := isIrrelevant, isForcedUnprovable := isForcedUnprovable, preNormGoal := preNormGoal,
normalizationState := normalizationState, mvars := mvars, forwardState := forwardState,
forwardRuleMatches := forwardRuleMatches, successProbability := successProbability,
addedInIteration := addedInIteration, lastExpandedInIteration := lastExpandedInIteration,
unsafeRulesSelected := unsafeRulesSelected, unsafeQueue := unsafeQueue, failedRapps := failedRapps } =
1 + sizeOf id + sizeOf parent + sizeOf children + sizeOf origin + sizeOf depth + sizeOf state +
sizeOf isIrrelevant +
sizeOf isForcedUnprovable +
sizeOf preNormGoal +
sizeOf normalizationState +
sizeOf mvars +
sizeOf forwardState +
sizeOf forwardRuleMatches +
sizeOf successProbability +
sizeOf addedInIteration +
sizeOf lastExpandedInIteration +
sizeOf unsafeRulesSelected +
sizeOf unsafeQueue +
sizeOf failedRapps |
Complex.tan_add_int_mul_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℤ), Complex.tan (x + ↑n * ↑Real.pi) = Complex.tan x |
AddQuantale.rec | Mathlib.Algebra.Order.Quantale | {α : Type u_1} →
[inst : AddSemigroup α] →
[inst_1 : CompleteLattice α] →
[inst_2 : IsAddQuantale α] → {motive : AddQuantale α → Sort u} → motive { } → (t : AddQuantale α) → motive t |
MeasurableSpace.GenerateMeasurable.below.compl | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {s : Set (Set α)} {motive : (a : Set α) → MeasurableSpace.GenerateMeasurable s a → Prop} (t : Set α)
(a : MeasurableSpace.GenerateMeasurable s t),
MeasurableSpace.GenerateMeasurable.below a → motive t a → MeasurableSpace.GenerateMeasurable.below ⋯ |
Lean.ParserDescr.recOn | Init.Prelude | {motive : Lean.ParserDescr → Sort u} →
(t : Lean.ParserDescr) →
((name : Lean.Name) → motive (Lean.ParserDescr.const name)) →
((name : Lean.Name) → (p : Lean.ParserDescr) → motive p → motive (Lean.ParserDescr.unary name p)) →
((name : Lean.Name) →
(p₁ p₂ : Lean.ParserDescr) → motive p₁ → motive p₂ → motive (Lean.ParserDescr.binary name p₁ p₂)) →
((kind : Lean.SyntaxNodeKind) →
(prec : ℕ) → (p : Lean.ParserDescr) → motive p → motive (Lean.ParserDescr.node kind prec p)) →
((kind : Lean.SyntaxNodeKind) →
(prec lhsPrec : ℕ) →
(p : Lean.ParserDescr) → motive p → motive (Lean.ParserDescr.trailingNode kind prec lhsPrec p)) →
((val : String) → motive (Lean.ParserDescr.symbol val)) →
((val : String) →
(includeIdent : Bool) → motive (Lean.ParserDescr.nonReservedSymbol val includeIdent)) →
((catName : Lean.Name) → (rbp : ℕ) → motive (Lean.ParserDescr.cat catName rbp)) →
((declName : Lean.Name) → motive (Lean.ParserDescr.parser declName)) →
((name : String) →
(kind : Lean.SyntaxNodeKind) →
(p : Lean.ParserDescr) →
motive p → motive (Lean.ParserDescr.nodeWithAntiquot name kind p)) →
((p : Lean.ParserDescr) →
(sep : String) →
(psep : Lean.ParserDescr) →
(allowTrailingSep : Bool) →
motive p → motive psep → motive (p.sepBy sep psep allowTrailingSep)) →
((p : Lean.ParserDescr) →
(sep : String) →
(psep : Lean.ParserDescr) →
(allowTrailingSep : Bool) →
motive p → motive psep → motive (p.sepBy1 sep psep allowTrailingSep)) →
((val asciiVal : String) →
(preserveForPP : Bool) →
motive (Lean.ParserDescr.unicodeSymbol val asciiVal preserveForPP)) →
motive t |
ISize.reduceToInt._regBuiltin.ISize.reduceToInt.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2118279935._hygCtx._hyg.15 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit |
FormalMultilinearSeries.restrictScalars.congr_simp | Mathlib.Analysis.Analytic.Binomial | ∀ (𝕜 : Type u) {𝕜' : Type u'} {E : Type v} {F : Type w} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E]
[inst_6 : AddCommMonoid F] [inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd F]
[inst_10 : ContinuousConstSMul 𝕜 F] [inst_11 : Semiring 𝕜'] [inst_12 : SMul 𝕜 𝕜'] [inst_13 : Module 𝕜' E]
[inst_14 : ContinuousConstSMul 𝕜' E] [inst_15 : IsScalarTower 𝕜 𝕜' E] [inst_16 : Module 𝕜' F]
[inst_17 : ContinuousConstSMul 𝕜' F] [inst_18 : IsScalarTower 𝕜 𝕜' F] (p p_1 : FormalMultilinearSeries 𝕜' E F),
p = p_1 → ∀ (n : ℕ), FormalMultilinearSeries.restrictScalars 𝕜 p n = FormalMultilinearSeries.restrictScalars 𝕜 p_1 n |
Std.Sat.AIG.RefVec.fold.congr_simp | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} (aig : Std.Sat.AIG α) (vec vec_1 : aig.RefVec len),
vec = vec_1 →
∀ (func func_1 : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α) (e_func : func = func_1)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput func],
Std.Sat.AIG.RefVec.fold aig vec func = Std.Sat.AIG.RefVec.fold aig vec_1 func_1 |
Mathlib.Tactic.LinearCombination'.Expanded.noConfusionType | Mathlib.Tactic.LinearCombination' | Sort u → Mathlib.Tactic.LinearCombination'.Expanded → Mathlib.Tactic.LinearCombination'.Expanded → Sort u |
_private.Mathlib.LinearAlgebra.Eigenspace.Zero.0.LinearMap.hasEigenvalue_zero_tfae.match_1_6 | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {K : Type u_2} {M : Type u_1} [inst : Field K] [inst_1 : AddCommGroup M] [inst_2 : Module K M] (φ : Module.End K M)
(motive : (∃ m, m ≠ 0 ∧ φ m = 0) → Prop) (x : ∃ m, m ≠ 0 ∧ φ m = 0),
(∀ (x : M) (h1 : x ≠ 0) (h2 : φ x = 0), motive ⋯) → motive x |
_private.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.mkCongrThm.match_1 | Lean.Elab.Tactic.Conv.Congr | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr) → ((rhs mvarNew : Lean.Expr) → motive (rhs, mvarNew)) → motive __discr |
Std.Tactic.BVDecide.LRAT.Internal.Formula.readyForRatAdd_insert | Std.Tactic.BVDecide.LRAT.Internal.Formula.Class | ∀ {α : outParam (Type u)} {β : outParam (Type v)} {inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} {σ : Type w}
{inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ} [self : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ]
(f : σ) (c : β),
Std.Tactic.BVDecide.LRAT.Internal.Formula.ReadyForRatAdd f →
Std.Tactic.BVDecide.LRAT.Internal.Formula.ReadyForRatAdd (Std.Tactic.BVDecide.LRAT.Internal.Formula.insert f c) |
ContextFreeGrammar.Generates.eq_1 | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} (g : ContextFreeGrammar T) (s : List (Symbol T g.NT)),
g.Generates s = g.Derives [Symbol.nonterminal g.initial] s |
AlgebraicGeometry.smoothOfRelativeDimension_comp | Mathlib.AlgebraicGeometry.Morphisms.Smooth | ∀ (n m : ℕ) {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {Z : AlgebraicGeometry.Scheme} (g : Y ⟶ Z)
[hf : AlgebraicGeometry.SmoothOfRelativeDimension n f] [hg : AlgebraicGeometry.SmoothOfRelativeDimension m g],
AlgebraicGeometry.SmoothOfRelativeDimension (n + m) (CategoryTheory.CategoryStruct.comp f g) |
TensorProduct.AlgebraTensorModule.ext | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : AddCommMonoid P]
[inst_10 : Module R P] [inst_11 : Module A P] [IsScalarTower R A P] {g h : TensorProduct R M N →ₗ[A] P},
(∀ (x : M) (y : N), g (x ⊗ₜ[R] y) = h (x ⊗ₜ[R] y)) → g = h |
Lean.Lsp.TextDocumentContentChangeEvent.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentContentChangeEvent → Sort u} →
((range : Lean.Lsp.Range) →
(text : String) → motive (Lean.Lsp.TextDocumentContentChangeEvent.rangeChange range text)) →
((text : String) → motive (Lean.Lsp.TextDocumentContentChangeEvent.fullChange text)) →
(t : Lean.Lsp.TextDocumentContentChangeEvent) → motive t |
_private.Mathlib.Data.Nat.Bits.0.Nat.bodd_eq_one_and_ne_zero.match_1_1 | Mathlib.Data.Nat.Bits | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive x |
SimpleGraph.Walk.adj_snd._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}, ¬p.Nil → G.1 v p.snd = True |
AlgebraicGeometry.Scheme.Pullback.Triplet.specTensorTo_base_snd | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (T : AlgebraicGeometry.Scheme.Pullback.Triplet f g)
(p : ↥(AlgebraicGeometry.Spec T.tensor)), (CategoryTheory.Limits.pullback.snd f g) (T.SpecTensorTo p) = T.y |
FloorSemiring.mk | Mathlib.Algebra.Order.Floor.Defs | {α : Type u_4} →
[inst : Semiring α] →
[inst_1 : PartialOrder α] →
(floor ceil : α → ℕ) →
(∀ {a : α}, a < 0 → floor a = 0) →
(∀ {a : α} {n : ℕ}, 0 ≤ a → (n ≤ floor a ↔ ↑n ≤ a)) → GaloisConnection ceil Nat.cast → FloorSemiring α |
SchwartzMap.iteratedLineDerivOp_eq_iteratedFDeriv | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ {E : Type u_5} {F : Type u_8} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ F]
[inst_3 : NormedSpace ℝ E] {n : ℕ} {m : Fin n → E} {f : SchwartzMap E F} {x : E},
(LineDeriv.iteratedLineDerivOp m f) x = (iteratedFDeriv ℝ n (⇑f) x) m |
CategoryTheory.MorphismProperty.IsStableUnderFilteredColimits.mk._flat_ctor | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C},
autoParam
(∀ (J : Type w') [inst_1 : CategoryTheory.Category.{w, w'} J] [CategoryTheory.IsFiltered J],
W.IsStableUnderColimitsOfShape J)
CategoryTheory.MorphismProperty.IsStableUnderFilteredColimits.isStableUnderColimitsOfShape._autoParam →
CategoryTheory.MorphismProperty.IsStableUnderFilteredColimits.{w, w', v, u} W |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.