name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
SimpleGraph.CompleteEquipartiteSubgraph.card_verts | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {r t : ℕ} (K : G.CompleteEquipartiteSubgraph r t), K.verts.card = r * t |
CategoryTheory.Functor.commShiftOp_iso_eq | Mathlib.CategoryTheory.Shift.Opposite | ∀ {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] (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] (F : CategoryTheory.Functor C D)
[inst_5 : F.CommShift A] (a : A),
CategoryTheory.Functor.commShiftIso (CategoryTheory.OppositeShift.functor A F) a =
(CategoryTheory.NatIso.op (CategoryTheory.Functor.commShiftIso F a)).symm |
LinearOrder.liftWithOrd._proof_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : LinearOrder β] [inst_1 : Ord α] (f : α → β),
(∀ (a b : α), compare a b = compare (f a) (f b)) → ∀ (x x_1 : α), compare (f x) (f x_1) = compare x x_1 |
Part.inv_mem_inv | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : Inv α] (a : Part α), ∀ ma ∈ a, ma⁻¹ ∈ a⁻¹ |
Std.Time.Timestamp.subWeeks | Std.Time.DateTime.Timestamp | Std.Time.Timestamp → Std.Time.Week.Offset → Std.Time.Timestamp |
Module.fgSystem.equiv_comp_of | Mathlib.Algebra.Colimit.Finiteness | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Submodule R M)] (N : { N // N.FG }),
↑(Module.fgSystem.equiv R M) ∘ₗ Module.DirectLimit.of R { N // N.FG } (fun i => ↥↑i) (Module.fgSystem R M) N =
(↑N).subtype |
Std.IterM.drain_eq_map_toList | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β},
it.drain = (fun x => PUnit.unit) <$> it.toList |
groupHomology.instPreservesZeroMorphismsRepChainComplexModuleCatNatChainsFunctor | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ (k G : Type u) [inst : CommRing k] [inst_1 : Group G], (groupHomology.chainsFunctor k G).PreservesZeroMorphisms |
Quaternion.im_imK | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), a.im.imK = a.imK |
GenContFract.IntFractPair.mapFr.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | ∀ {K : Type u_1} {β : Type u_2} (f : K → β) (gp : GenContFract.IntFractPair K),
GenContFract.IntFractPair.mapFr f gp = { b := gp.b, fr := f gp.fr } |
MeasureTheory.Measure.InnerRegularWRT.eq_of_innerRegularWRT_of_forall_eq | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop}
{ν : MeasureTheory.Measure α},
μ.InnerRegularWRT p q → ν.InnerRegularWRT p q → (∀ (U : Set α), p U → μ U = ν U) → ∀ {U : Set α}, q U → μ U = ν U |
Module.Relations.Solution.congr_var | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution solution' : relations.Solution M},
solution = solution' → ∀ (g : relations.G), solution.var g = solution'.var g |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.mk.inj | Lean.Server.Logging | ∀ {time : Std.Time.ZonedDateTime} {direction : Lean.JsonRpc.MessageDirection} {kind : Lean.JsonRpc.MessageKind}
{msg : Lean.JsonRpc.Message} {time_1 : Std.Time.ZonedDateTime} {direction_1 : Lean.JsonRpc.MessageDirection}
{kind_1 : Lean.JsonRpc.MessageKind} {msg_1 : Lean.JsonRpc.Message},
{ time := time, direction := direction, kind := kind, msg := msg } =
{ time := time_1, direction := direction_1, kind := kind_1, msg := msg_1 } →
time = time_1 ∧ direction = direction_1 ∧ kind = kind_1 ∧ msg = msg_1 |
BoxIntegral.Box.mem_mk._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {l u x : ι → ℝ} {H : ∀ (i : ι), l i < u i},
(x ∈ { lower := l, upper := u, lower_lt_upper := H }) = ∀ (i : ι), x i ∈ Set.Ioc (l i) (u i) |
IO.FS.SystemTime.noConfusion | Init.System.IO | {P : Sort u} → {t t' : IO.FS.SystemTime} → t = t' → IO.FS.SystemTime.noConfusionType P t t' |
CochainComplex.HomComplex.CohomologyClass.mk_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ), CochainComplex.HomComplex.CohomologyClass.mk 0 = 0 |
Finsupp.prod_finset_sum_index | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {ι : Type u_2} {M : Type u_8} {N : Type u_10} [inst : AddCommMonoid M] [inst_1 : CommMonoid N]
{s : Finset ι} {g : ι → α →₀ M} {h : α → M → N},
(∀ (a : α), h a 0 = 1) →
(∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂) → ∏ i ∈ s, (g i).prod h = (∑ i ∈ s, g i).prod h |
CategoryTheory.Limits.WalkingParallelFamily.Hom.line.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{P : Sort u} →
{a a' : J} →
CategoryTheory.Limits.WalkingParallelFamily.Hom.line a = CategoryTheory.Limits.WalkingParallelFamily.Hom.line a' →
(a ≍ a' → P) → P |
Lean.Widget.RpcEncodablePacket._@.Lean.Widget.Types.2243429567._hygCtx._hyg.1 | Lean.Widget.Types | Type |
InformationTheory.klDiv_eq_integral_klFun | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ]
[MeasureTheory.IsFiniteMeasure ν],
InformationTheory.klDiv μ ν =
if μ.AbsolutelyContinuous ν ∧ MeasureTheory.Integrable (MeasureTheory.llr μ ν) μ then
ENNReal.ofReal (∫ (x : α), InformationTheory.klFun (μ.rnDeriv ν x).toReal ∂ν)
else ⊤ |
Fin.reduceCastSucc._regBuiltin.Fin.reduceCastSucc.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.2550739679._hygCtx._hyg.17 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit |
CategoryTheory.Localization.Monoidal.triangle | Mathlib.CategoryTheory.Localization.Monoidal.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] {L : CategoryTheory.Functor C D}
{W : CategoryTheory.MorphismProperty C} [inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : W.IsMonoidal]
[inst_4 : L.IsLocalization W] {unit : D} {ε : L.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ unit}
(X Y : CategoryTheory.LocalizedMonoidal L W ε),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.LocalizedMonoidal L W ε)) Y).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom) =
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom Y |
_private.Mathlib.Order.Atoms.0.bot_covBy_iff._simp_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (⊥ < a) = (a ≠ ⊥) |
Std.Internal.List.getKey!_map | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : BEq α] [EquivBEq α] [inst_2 : Inhabited α]
{f : (a : α) → β a → γ a} {l : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKey! k (List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) l) = Std.Internal.List.getKey! k l |
Lean.Lsp.instToJsonRpcReleaseParams.toJson | Lean.Data.Lsp.Extra | Lean.Lsp.RpcReleaseParams → Lean.Json |
Matrix.trace_fin_one | Mathlib.LinearAlgebra.Matrix.Trace | ∀ {R : Type u_6} [inst : AddCommMonoid R] (A : Matrix (Fin 1) (Fin 1) R), A.trace = A 0 0 |
Complex.norm_ratCast | Mathlib.Analysis.Complex.Norm | ∀ (q : ℚ), ‖↑q‖ = |↑q| |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.interSmallerFn.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l sofar : List ((a : α) × β a)) (k : α),
Std.Internal.List.interSmallerFn l sofar k =
match Std.Internal.List.getEntry? k l with
| some kv' => Std.Internal.List.insertEntry kv'.fst kv'.snd sofar
| none => sofar |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Real.rpow_def_of_nonneg._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {z : ℝ}, (↑z = 0) = (z = 0) |
IsOpenMap.functor._proof_2 | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap ⇑(CategoryTheory.ConcreteCategory.hom f))
{X_1 Y_1 Z : TopologicalSpace.Opens ↑X} (f_1 : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z),
IsOpenMap.functorMap ⋯ ⋯ ⋯ =
CategoryTheory.CategoryStruct.comp (IsOpenMap.functorMap ⋯ ⋯ ⋯) (IsOpenMap.functorMap ⋯ ⋯ ⋯) |
CategoryTheory.Mat_.instAddCommGroupHom | Mathlib.CategoryTheory.Preadditive.Mat | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Preadditive C] → (M N : CategoryTheory.Mat_ C) → AddCommGroup (M ⟶ N) |
Lean.Elab.PartialTermInfo.casesOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.PartialTermInfo → Sort u} →
(t : Lean.Elab.PartialTermInfo) →
((toElabInfo : Lean.Elab.ElabInfo) →
(lctx : Lean.LocalContext) →
(expectedType? : Option Lean.Expr) →
motive { toElabInfo := toElabInfo, lctx := lctx, expectedType? := expectedType? }) →
motive t |
Nat.SOM.Poly.append_denote | Init.Data.Nat.SOM | ∀ (ctx : Nat.Linear.Context) (p₁ p₂ : Nat.SOM.Poly),
Nat.SOM.Poly.denote ctx (p₁ ++ p₂) = Nat.SOM.Poly.denote ctx p₁ + Nat.SOM.Poly.denote ctx p₂ |
_private.Init.Data.List.MinMax.0.List.max?_attach._simp_1_4 | Init.Data.List.MinMax | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
_private.Lean.Compiler.LCNF.Specialize.0.PSigma.casesOn._arg_pusher | Lean.Compiler.LCNF.Specialize | ∀ {α : 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) → rel t y → β_1 y) → motive t) t mk fun y h => f y) =
PSigma.casesOn t fun fst snd => mk fst snd fun y h => f y |
IsDedekindDomain.HeightOneSpectrum.equivPrimesOver | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {A : Type u_4} →
[inst : CommRing A] →
{p : Ideal A} →
[hpm : p.IsMaximal] →
(B : Type u_5) →
[inst_1 : CommRing B] →
[IsDedekindDomain B] →
[inst_3 : Algebra A B] →
[IsDomain A] →
[Module.IsTorsionFree A B] →
p ≠ 0 → { v // v.asIdeal ∣ Ideal.map (algebraMap A B) p } ≃ ↑(p.primesOver B) |
_private.Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas.0.ZMod.sum_Ico_eq_card_lt | Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas | ∀ {p q : ℕ},
∑ a ∈ Finset.Ico 1 (p / 2).succ, a * q / p =
{x ∈ Finset.Ico 1 (p / 2).succ ×ˢ Finset.Ico 1 (q / 2).succ | x.2 * p ≤ x.1 * q}.card |
LawfulMonadStateOf.set_bind_modifyGet_bind | Batteries.Control.LawfulMonadState | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m] [LawfulMonadStateOf σ m]
{α β : Type u_1} (s : σ) (f : σ → α × σ) (mx : α → m β),
(do
set s
let x ← modifyGet f
mx x) =
do
set (f s).2
mx (f s).1 |
TopologicalSpace.Opens.toTopCat_map | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat) {U V : TopologicalSpace.Opens ↑X} {f : U ⟶ V} {x : ↑X} {h : x ∈ U},
(CategoryTheory.ConcreteCategory.hom ((TopologicalSpace.Opens.toTopCat X).map f)) ⟨x, h⟩ = ⟨x, ⋯⟩ |
Mathlib.Tactic.Ring.natCast_mul | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_1} [inst : CommSemiring R] {b₁ b₃ : R} {a₁ a₃ : ℕ} (a₂ : ℕ),
↑a₁ = b₁ → ↑a₃ = b₃ → ↑(a₁ ^ a₂ * a₃) = b₁ ^ a₂ * b₃ |
AlgebraicGeometry.Scheme.Cover.exists_lift_trans_eq | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst : CategoryTheory.Category.{v_1, u_1} 𝒰.I₀] [inst_1 : 𝒰.LocallyDirected] {i j : 𝒰.I₀}
(x : ↥(CategoryTheory.Limits.pullback (𝒰.f i) (𝒰.f j))),
∃ k hki hkj y, (CategoryTheory.Limits.pullback.lift (𝒰.trans hki) (𝒰.trans hkj) ⋯) y = x |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage._proof_3 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preregular C]
[inst_2 : CategoryTheory.FinitaryExtensive C]
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type u_2))},
(∀ (n : ℕ), CategoryTheory.Sheaf.IsLocallySurjective (F.map (CategoryTheory.homOfLE ⋯).op)) →
∀ (n : ℕ) (x : Nat.below n.succ),
∃ X' φ,
∃ (_ : CategoryTheory.EffectiveEpi φ),
∃ x_2,
(F.map (CategoryTheory.homOfLE ⋯).op).hom.app (Opposite.op X') x_2 =
(F.obj (Opposite.op n)).obj.map φ.op x.1.snd |
PointedCone.maxTensorProduct._proof_2 | Mathlib.Geometry.Convex.Cone.TensorProduct | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R |
DivInvMonoid.div._default | Mathlib.Algebra.Group.Defs | {G : Type u} →
(mul : G → G → G) →
(∀ (a b c : G), a * b * c = a * (b * c)) →
(one : G) →
(∀ (a : G), 1 * a = a) →
(∀ (a : G), a * 1 = a) →
(npow : ℕ → G → G) →
(∀ (x : G), npow 0 x = 1) → (∀ (n : ℕ) (x : G), npow (n + 1) x = npow n x * x) → (G → G) → G → G → G |
Subsemigroup.unop_eq_bot._simp_2 | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] {S : Subsemigroup Mᵐᵒᵖ}, (S.unop = ⊥) = (S = ⊥) |
ContinuousCohomology.kerHomogeneousCochainsZeroEquiv._proof_17 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_3) (G : Type u_1) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] (X : Action (TopModuleCat R) G) (n : ℕ) (hn : n = 1)
(x : ↑((ContinuousCohomology.invariants R G).obj X).toModuleCat) (g : G),
(TopModuleCat.Hom.hom (X.ρ g)) (↑↑⟨⟨(ContinuousLinearMap.const R G) ↑x, ⋯⟩, ⋯⟩ 1) =
↑↑⟨⟨(ContinuousLinearMap.const R G) ↑x, ⋯⟩, ⋯⟩ 1 |
LightProfinite.«termℕ∪{∞}» | Mathlib.Topology.Category.LightProfinite.Sequence | Lean.ParserDescr |
CategoryTheory.Functor.sheafPushforwardContinuousIso_hom | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F F' : CategoryTheory.Functor C D} (e : F ≅ F') (A : Type u) [inst_2 : CategoryTheory.Category.{t, u} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [inst_3 : F.IsContinuous J K]
[inst_4 : F'.IsContinuous J K],
(CategoryTheory.Functor.sheafPushforwardContinuousIso e A J K).hom =
CategoryTheory.Functor.sheafPushforwardContinuousNatTrans e.inv A J K |
Std.TreeMap.getKey!_eq_get!_getKey? | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{a : α}, t.getKey! a = (t.getKey? a).get! |
Lean.Meta.CaseValuesSubgoal.mk.injEq | Lean.Meta.Match.CaseValues | ∀ (mvarId : Lean.MVarId) (newHs : Array Lean.FVarId) (subst : Lean.Meta.FVarSubst) (mvarId_1 : Lean.MVarId)
(newHs_1 : Array Lean.FVarId) (subst_1 : Lean.Meta.FVarSubst),
({ mvarId := mvarId, newHs := newHs, subst := subst } = { mvarId := mvarId_1, newHs := newHs_1, subst := subst_1 }) =
(mvarId = mvarId_1 ∧ newHs = newHs_1 ∧ subst = subst_1) |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.minKey?_modifyKey._simp_1_3 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α] {k : α}
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
(Std.Internal.List.minKey? l = some k) =
(Std.Internal.List.getKey? k l = some k ∧
∀ (k' : α), Std.Internal.List.containsKey k' l = true → (compare k k').isLE = true) |
MeasureTheory.Egorov.tendstoUniformlyOn_diff_iUnionNotConvergentSeq | Mathlib.MeasureTheory.Function.Egorov | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace α} [inst : PseudoEMetricSpace β]
{μ : MeasureTheory.Measure α} {s : Set α} {ε : ℝ} {f : ι → α → β} {g : α → β} [inst_1 : SemilatticeSup ι]
[inst_2 : Nonempty ι] [inst_3 : Countable ι] (hε : 0 < ε) (hf : ∀ (n : ι), Measurable fun a => edist (f n a) (g a))
(hsm : MeasurableSet s) (hs : μ s ≠ ⊤)
(hfg : ∀ᵐ (x : α) ∂μ, x ∈ s → Filter.Tendsto (fun n => f n x) Filter.atTop (nhds (g x))),
TendstoUniformlyOn f g Filter.atTop (s \ MeasureTheory.Egorov.iUnionNotConvergentSeq hε hf hsm hs hfg) |
PosNum.cmp_swap | Mathlib.Data.Num.Lemmas | ∀ (m n : PosNum), (m.cmp n).swap = n.cmp m |
AddEquiv.ext_int | Mathlib.Data.Int.Cast.Lemmas | ∀ {A : Type u_5} [inst : AddMonoid A] {f g : ℤ ≃+ A}, f 1 = g 1 → f = g |
Lean.Lsp.DocumentColorOptions.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toWorkDoneProgressOptions toWorkDoneProgressOptions_1 : Lean.Lsp.WorkDoneProgressOptions},
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions } =
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions_1 } →
toWorkDoneProgressOptions = toWorkDoneProgressOptions_1 |
Polygon.HasNondegenerateVertices.hasNondegenerateEdges | Mathlib.Geometry.Polygon.Basic | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} {n : ℕ} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] [inst_4 : NeZero n] [Nontrivial R] {poly : Polygon P n},
Polygon.HasNondegenerateVertices R poly → poly.HasNondegenerateEdges |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.mk.noConfusion | Mathlib.AlgebraicGeometry.AffineTransitionLimit | {I : Type u} →
{inst : CategoryTheory.Category.{u, u} I} →
{S X : AlgebraicGeometry.Scheme} →
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} →
{t : D ⟶ (CategoryTheory.Functor.const I).obj S} →
{f : X ⟶ S} →
{P : Sort u_1} →
{c : CategoryTheory.Limits.Cone D} →
{hc : CategoryTheory.Limits.IsLimit c} →
{i : I} →
{a : D.obj i ⟶ X} →
{ha : t.app i = CategoryTheory.CategoryStruct.comp a f} →
{b : D.obj i ⟶ X} →
{hb : t.app i = CategoryTheory.CategoryStruct.comp b f} →
{hab :
CategoryTheory.CategoryStruct.comp (c.π.app i) a =
CategoryTheory.CategoryStruct.comp (c.π.app i) b} →
{𝒰S : S.OpenCover} →
{h𝒰S : ∀ (i : 𝒰S.I₀), AlgebraicGeometry.IsAffine (𝒰S.X i)} →
{𝒰X :
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).X i).OpenCover} →
{h𝒰X :
∀ (i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).I₀)
(j : (𝒰X i).I₀), AlgebraicGeometry.IsAffine ((𝒰X i).X j)} →
{c' : CategoryTheory.Limits.Cone D} →
{hc' : CategoryTheory.Limits.IsLimit c'} →
{i' : I} →
{a' : D.obj i' ⟶ X} →
{ha' : t.app i' = CategoryTheory.CategoryStruct.comp a' f} →
{b' : D.obj i' ⟶ X} →
{hb' : t.app i' = CategoryTheory.CategoryStruct.comp b' f} →
{hab' :
CategoryTheory.CategoryStruct.comp (c'.π.app i') a' =
CategoryTheory.CategoryStruct.comp (c'.π.app i') b'} →
{𝒰S' : S.OpenCover} →
{h𝒰S' : ∀ (i : 𝒰S'.I₀), AlgebraicGeometry.IsAffine (𝒰S'.X i)} →
{𝒰X' :
(i :
(CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f
𝒰S').I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f
𝒰S').X
i).OpenCover} →
{h𝒰X' :
∀
(i :
(CategoryTheory.Precoverage.ZeroHypercover.pullback₁
f 𝒰S').I₀)
(j : (𝒰X' i).I₀),
AlgebraicGeometry.IsAffine ((𝒰X' i).X j)} →
{ c := c, hc := hc, i := i, a := a, ha := ha, b := b,
hb := hb, hab := hab, 𝒰S := 𝒰S, h𝒰S := h𝒰S,
𝒰X := 𝒰X, h𝒰X := h𝒰X } =
{ c := c', hc := hc', i := i', a := a', ha := ha',
b := b', hb := hb', hab := hab', 𝒰S := 𝒰S',
h𝒰S := h𝒰S', 𝒰X := 𝒰X', h𝒰X := h𝒰X' } →
(c ≍ c' →
hc ≍ hc' →
i ≍ i' →
a ≍ a' → b ≍ b' → 𝒰S ≍ 𝒰S' → 𝒰X ≍ 𝒰X' → P) →
P |
Subarray.foldrM | Init.Data.Array.Subarray | {α : Type u} → {β : Type v} → {m : Type v → Type w} → [Monad m] → (α → β → m β) → β → Subarray α → m β |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.g'_eq | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {cc : CategoryTheory.Limits.CokernelCofork S.f}
(hcc : CategoryTheory.Limits.IsColimit cc),
hcc.desc (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯) =
CategoryTheory.CategoryStruct.comp (S.isoOpcyclesOfIsColimit hcc).hom S.fromOpcycles |
Filter.EventuallyEq.star | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {R : Type u_2} [inst : Star R] {f g : α → R} {l : Filter α}, f =ᶠ[l] g → star f =ᶠ[l] star g |
Nat.primeCounting.eq_1 | Mathlib.NumberTheory.PrimeCounting | ∀ (n : ℕ), n.primeCounting = (n + 1).primeCounting' |
exists_compact_superset | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] [WeaklyLocallyCompactSpace X] {K : Set X},
IsCompact K → ∃ K', IsCompact K' ∧ K ⊆ interior K' |
MulAction.instDecidablePredMemSubmonoidStabilizerSubmonoidOfDecidableEq | Mathlib.GroupTheory.GroupAction.Defs | {M : Type u_1} →
{α : Type u_3} →
[inst : Monoid M] →
[inst_1 : MulAction M α] →
[DecidableEq α] → (a : α) → DecidablePred fun x => x ∈ MulAction.stabilizerSubmonoid M a |
Lean.Elab.Term.Do.Var | Lean.Elab.Do.Legacy | Type |
AffineEquiv.list_sbtw_map_iff | Mathlib.Analysis.Convex.BetweenList | ∀ {R : Type u_1} {V : Type u_2} {V' : Type u_3} {P : Type u_4} {P' : Type u_5} [inst : Ring R] [inst_1 : PartialOrder R]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup V']
[inst_6 : Module R V'] [inst_7 : AddTorsor V' P'] {l : List P} (f : P ≃ᵃ[R] P'),
List.Sbtw R (List.map (⇑f) l) ↔ List.Sbtw R l |
_private.Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization.0.HomogeneousLocalization.Away.isLocalization_mul._simp_1_5 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {x y : M × ↥S},
(Localization.r S) x y = ∃ c, ↑c * (↑y.2 * x.1) = ↑c * (↑x.2 * y.1) |
DirectSum | Mathlib.Algebra.DirectSum.Basic | (ι : Type v) → (β : ι → Type w) → [(i : ι) → AddCommMonoid (β i)] → Type (max w v) |
AddSubgroup.Normal.pathComponentZero | Mathlib.Topology.Connected.PathConnected | ∀ (G : Type u_4) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
(AddSubgroup.pathComponentZero G).Normal |
CompleteLatticeHom.toBoundedLatticeHom._proof_4 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_1} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : CompleteLatticeHom α β)
(a b : α),
{ toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊓ b) =
{ toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊓ { toFun := ⇑f, map_sup' := ⋯, map_inf' := ⋯ }.toFun b |
BitVec.ushiftRight_eq' | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ : ℕ} (x : BitVec w₁) (y : BitVec w₂), x >>> y = x >>> y.toNat |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_14 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (tail : List α),
List.findIdxNth p tail (List.countPBefore p tail (List.findIdxNth p tail 0)) + 1 ≤ tail.length →
List.findIdxNth p tail (List.countPBefore p tail (List.findIdxNth p tail 0)) < tail.length |
LinearEquiv.rTensor_symm_tmul | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} [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 : N ≃ₗ[R] P) (m : M) (p : P), (LinearEquiv.rTensor M f).symm (p ⊗ₜ[R] m) = f.symm p ⊗ₜ[R] m |
DeltaGeneratedSpace.instLocPathConnectedSpace | Mathlib.Topology.Compactness.DeltaGeneratedSpace | ∀ {X : Type u_1} [tX : TopologicalSpace X] [DeltaGeneratedSpace X], LocPathConnectedSpace X |
_private.Mathlib.CategoryTheory.MorphismProperty.Basic.0.CategoryTheory.MorphismProperty.toSet_iSup._simp_1_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C)
(f : CategoryTheory.Arrow C), (f ∈ P.toSet) = P f.hom |
Lean.PrettyPrinter.Delaborator.instMonadReaderOfSubExprDelabM | Lean.PrettyPrinter.Delaborator.Basic | MonadReaderOf Lean.SubExpr Lean.PrettyPrinter.Delaborator.DelabM |
Submonoid.disjoint_def' | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] {p₁ p₂ : Submonoid M},
Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1 |
Turing.ToPartrec.stepNormal.eq_def | Mathlib.Computability.TuringMachine.Config | ∀ (x : Turing.ToPartrec.Code),
Turing.ToPartrec.stepNormal x =
match (motive := Turing.ToPartrec.Code → Turing.ToPartrec.Cont → List ℕ → Turing.ToPartrec.Cfg) x with
| Turing.ToPartrec.Code.zero' => fun k v => Turing.ToPartrec.Cfg.ret k (0 :: v)
| Turing.ToPartrec.Code.succ => fun k v => Turing.ToPartrec.Cfg.ret k [v.headI.succ]
| Turing.ToPartrec.Code.tail => fun k v => Turing.ToPartrec.Cfg.ret k v.tail
| f.cons fs => fun k v => Turing.ToPartrec.stepNormal f (Turing.ToPartrec.Cont.cons₁ fs v k) v
| f.comp g => fun k v => Turing.ToPartrec.stepNormal g (Turing.ToPartrec.Cont.comp f k) v
| f.case g => fun k v =>
Nat.rec (Turing.ToPartrec.stepNormal f k v.tail) (fun y x => Turing.ToPartrec.stepNormal g k (y :: v.tail))
v.headI
| f.fix => fun k v => Turing.ToPartrec.stepNormal f (Turing.ToPartrec.Cont.fix f k) v |
Ordinal.isInitialIso_symm_apply_coe | Mathlib.SetTheory.Cardinal.Aleph | ∀ (x : Cardinal.{u_1}), ↑((RelIso.symm Ordinal.isInitialIso) x) = x.ord |
ClopenUpperSet.instSetLike._proof_1 | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] (s t : ClopenUpperSet α),
(fun s => s.carrier) s = (fun s => s.carrier) t → s = t |
UInt16.toBitVec_toUInt8 | Init.Data.UInt.Lemmas | ∀ (n : UInt16), n.toUInt8.toBitVec = BitVec.setWidth 8 n.toBitVec |
Lean.instReprExpr.repr._unsafe_rec | Lean.Expr | Lean.Expr → ℕ → Std.Format |
LinearMap.isPairSelfAdjointSubmodule._proof_3 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup M₂] [inst_4 : Module R M₂] (B F : M →ₗ[R] M →ₗ[R] M₂) (c : R),
∀ x ∈ {f | B.IsPairSelfAdjoint F ⇑f}, B.IsAdjointPair F (c • ⇑x) (c • ⇑x) |
Matrix.SpecialLinearGroup.instCoeFun | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
{R : Type v} → [inst_2 : CommRing R] → CoeFun (Matrix.SpecialLinearGroup n R) fun x => n → n → R |
SaturatedAddSubmonoid.instCompleteLattice._proof_2 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : AddZeroClass M] (a b : SaturatedAddSubmonoid M), b ≤ SemilatticeSup.sup a b |
birkhoffAverage_neg | Mathlib.Dynamics.BirkhoffSum.Average | ∀ {R : Type u_1} {α : Type u_2} {M : Type u_3} [inst : DivisionSemiring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] {f : α → α} {g : α → M}, birkhoffAverage R f (-g) = -birkhoffAverage R f g |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Real.abs_sin_eq_one_iff._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {x : ℝ} (n : ℤ), Real.pi / 2 + ↑n * (2 * Real.pi) = x → Real.pi / 2 + IntCast.intCast (2 * n) * Real.pi = x |
WithZero.lift'_zero | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} [inst : MulOneClass α] [inst_1 : MulZeroOneClass β] (f : α →* β),
(WithZero.lift' f) 0 = 0 |
_private.Init.Data.Vector.Lemmas.0.Array.mapM.map.eq_def | Init.Data.Vector.Lemmas | ∀ {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (f : α → m β) (as : Array α) (i : ℕ) (bs : Array β),
Array.mapM.map✝ f as i bs =
if hlt : i < as.size then do
let __do_lift ← f as[i]
Array.mapM.map✝¹ f as (i + 1) (bs.push __do_lift)
else pure bs |
MeasureTheory.lpNorm_const_smul | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} [inst : NormedAddCommGroup E] {𝕜 : Type u_3}
[inst_1 : NormedField 𝕜] [inst_2 : Module 𝕜 E] [NormSMulClass 𝕜 E] (c : 𝕜) (f : α → E) (μ : MeasureTheory.Measure α),
MeasureTheory.lpNorm (c • f) p μ = ↑‖c‖₊ * MeasureTheory.lpNorm f p μ |
CategoryTheory.Functor.Monoidal.whiskerRight_δ_μ_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]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X Y : C) (T : D) {Z : D}
(h :
CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)) T ⟶
Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Functor.OplaxMonoidal.δ F X Y) T)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Functor.LaxMonoidal.μ F X Y) T) h) =
h |
_private.Lean.Meta.Tactic.Grind.0.Lean.initFn._@.Lean.Meta.Tactic.Grind.328880924._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind | IO Unit |
IsLocalization.ringEquivOfRingEquiv_symm | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {T : Submonoid P}
{Q : Type u_4} [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T Q] {j : R ≃+* P}
(H : Submonoid.map j M = T),
(IsLocalization.ringEquivOfRingEquiv S Q j H).symm = IsLocalization.ringEquivOfRingEquiv Q S j.symm ⋯ |
compl_strictAnti | Mathlib.Order.Hom.Set | ∀ (α : Type u_1) [inst : BooleanAlgebra α], StrictAnti compl |
CategoryTheory.Sieve.BindStruct | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(S : CategoryTheory.Presieve X) →
(⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Sieve Y) → {Z : C} → (Z ⟶ X) → Type (max u₁ v₁) |
Nat.toArray_ric_eq_toArray_rcc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toArray = (0...=n).toArray |
Int.add_assoc | Init.Data.Int.Lemmas | ∀ (a b c : ℤ), a + b + c = a + (b + c) |
IdealFilter.gabrielComposition | Mathlib.RingTheory.IdealFilter.Basic | {A : Type u_1} → [inst : Ring A] → IdealFilter A → IdealFilter A → IdealFilter A |
CategoryTheory.OplaxFunctor.PseudoCore.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F : CategoryTheory.OplaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C]
(mapIdIso : (a : B) → F.map (CategoryTheory.CategoryStruct.id a) ≅ CategoryTheory.CategoryStruct.id (F.obj a))
(mapCompIso :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
F.map (CategoryTheory.CategoryStruct.comp f g) ≅ CategoryTheory.CategoryStruct.comp (F.map f) (F.map g))
(mapIdIso_hom :
autoParam (∀ {a : B}, (mapIdIso a).hom = F.mapId a) CategoryTheory.OplaxFunctor.PseudoCore.mapIdIso_hom._autoParam)
(mapCompIso_hom :
autoParam (∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), (mapCompIso f g).hom = F.mapComp f g)
CategoryTheory.OplaxFunctor.PseudoCore.mapCompIso_hom._autoParam),
sizeOf
{ mapIdIso := mapIdIso, mapCompIso := mapCompIso, mapIdIso_hom := mapIdIso_hom,
mapCompIso_hom := mapCompIso_hom } =
1 |
YoungDiagram.transpose_transpose | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (μ : YoungDiagram), μ.transpose.transpose = μ |
continuousAt_extChartAt_symm | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] (x : M),
ContinuousAt (↑(extChartAt I x).symm) (↑(extChartAt I x) x) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.