name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence._proof_14 | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C]
(F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat))
(ι : Type u_1) [inst_1 : Unique ι] {X S : C} (f : X ⟶ S) {D₁ D₂ : F.DescentDataAsCoalgebra fun x => f} (α : D₁ ⟶ D₂),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (F.DescentDataAsCoalgebra fun x => f)).map α)
((fun D => CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.isoMk (fun i => CategoryTheory.eqToIso ⋯) ⋯)
D₂).hom =
CategoryTheory.CategoryStruct.comp
((fun D => CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.isoMk (fun i => CategoryTheory.eqToIso ⋯) ⋯)
D₁).hom
(({ obj := fun D => { A := D.obj default, a := D.hom default default, counit := ⋯, coassoc := ⋯ },
map := fun {X_1 Y} φ => { f := φ.hom default, h := ⋯ }, map_id := ⋯, map_comp := ⋯ }.comp
{ obj := fun A => { obj := fun x => A.A, hom := fun x x_1 => A.a, counit := ⋯, coassoc := ⋯ },
map := fun {X_1 Y} φ => { hom := fun i => φ.f, comm := ⋯ }, map_id := ⋯, map_comp := ⋯ }).map
α) |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeUsingDefaultPrio.synthesizeUsingDefault._unsafe_rec | Lean.Elab.SyntheticMVars | Lean.MVarId → Lean.Elab.TermElabM Bool |
Polynomial.piEquiv | Mathlib.Algebra.Polynomial.Eval.Coeff | {ι : Type u_2} →
[Finite ι] →
(R : ι → Type u_1) → [inst : (i : ι) → Semiring (R i)] → Polynomial ((i : ι) → R i) ≃+* ((i : ι) → Polynomial (R i)) |
SaturatedAddSubmonoid.instCompleteLattice._proof_5 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : AddZeroClass M] (a b : SaturatedAddSubmonoid M), Lattice.inf a b ≤ b |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_20 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : UInt8), 1 * a = a |
_private.Mathlib.Order.Filter.Basic.0.Filter.mem_inf_principal'._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α}, Disjoint (a ⊓ b) c = Disjoint a (b ⊓ c) |
Continuous.strictAnti_of_inj_boundedOrder | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
[inst_7 : BoundedOrder α] {f : α → δ}, Continuous f → f ⊤ ≤ f ⊥ → Function.Injective f → StrictAnti f |
MeasureTheory.Measure.IsCondKernel.disintegrate | Mathlib.Probability.Kernel.Disintegration.Basic | ∀ {α : Type u_1} {Ω : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω} {ρ : MeasureTheory.Measure (α × Ω)}
{ρCond : ProbabilityTheory.Kernel α Ω} [self : ρ.IsCondKernel ρCond], ρ.fst.compProd ρCond = ρ |
CategoryTheory.Functor.OfSequence.map.match_3 | Mathlib.CategoryTheory.Functor.OfSequence | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
(motive : (x : ℕ → C) → ((n : ℕ) → x n ⟶ x (n + 1)) → ℕ → ℕ → Sort u_3) →
(x : ℕ → C) →
(x_1 : (n : ℕ) → x n ⟶ x (n + 1)) →
(x_2 x_3 : ℕ) →
((x : ℕ → C) → (x_4 : (n : ℕ) → x n ⟶ x (n + 1)) → motive x x_4 0 0) →
((x : ℕ → C) → (f : (n : ℕ) → x n ⟶ x (n + 1)) → motive x f 0 1) →
((x : ℕ → C) → (f : (n : ℕ) → x n ⟶ x (n + 1)) → (l : ℕ) → motive x f 0 l.succ) →
((x : ℕ → C) → (x_4 : (n : ℕ) → x n ⟶ x (n + 1)) → (n : ℕ) → motive x x_4 n.succ 0) →
((x : ℕ → C) → (f : (n : ℕ) → x n ⟶ x (n + 1)) → (k l : ℕ) → motive x f k.succ l.succ) →
motive x x_1 x_2 x_3 |
MeasureTheory.Measure.AbsolutelyContinuous.comp | Mathlib.Probability.Kernel.Composition.MeasureComp | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ ν : MeasureTheory.Measure α}
{κ η : ProbabilityTheory.Kernel α β},
μ.AbsolutelyContinuous ν →
(∀ᵐ (a : α) ∂μ, (κ a).AbsolutelyContinuous (η a)) → (μ.bind ⇑κ).AbsolutelyContinuous (ν.bind ⇑η) |
Std.OrientedCmp.rec | Init.Data.Order.Ord | {α : Type u} →
{cmp : α → α → Ordering} →
{motive : Std.OrientedCmp cmp → Sort u_1} →
((eq_swap : ∀ {a b : α}, cmp a b = (cmp b a).swap) → motive ⋯) → (t : Std.OrientedCmp cmp) → motive t |
linearDepOn_iff' | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {s : Set ι} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] {v : ι → M},
¬LinearIndepOn R v s ↔ ∃ f ∈ Finsupp.supported R R s, (Finsupp.linearCombination R v) f = 0 ∧ f ≠ 0 |
Array.foldl_flatten' | Init.Data.Array.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {f : β → α → β} {b : β} {xss : Array (Array α)} {stop : ℕ},
stop = xss.flatten.size → Array.foldl f b xss.flatten 0 stop = Array.foldl (fun b xs => Array.foldl f b xs) b xss |
_private.Std.Time.Format.Basic.0.Std.Time.parseQuarterLong | Std.Time.Format.Basic | Std.Internal.Parsec.String.Parser Std.Time.Month.Quarter |
MeasurableNeg.rec | Mathlib.MeasureTheory.Group.Arithmetic | {G : Type u_2} →
[inst : Neg G] →
[inst_1 : MeasurableSpace G] →
{motive : MeasurableNeg G → Sort u} →
((measurable_neg : Measurable Neg.neg) → motive ⋯) → (t : MeasurableNeg G) → motive t |
Con.comap._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] (f : M → N),
(∀ (x y : M), f (x * y) = f x * f y) →
∀ (c : Con N) (w x y z : M),
(Setoid.comap f c.toSetoid) w x → (Setoid.comap f c.toSetoid) y z → c (f (w * y)) (f (x * z)) |
_private.Mathlib.Algebra.CharP.Two.0.CharTwo.sqAddMonoidHom | Mathlib.Algebra.CharP.Two | {R : Type u_1} → [inst : CommSemiring R] → [CharP R 2] → R →+ R |
Subfield.mem_comap._simp_1 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] {s : Subfield L} {f : K →+* L} {x : K},
(x ∈ Subfield.comap f s) = (f x ∈ s) |
Std.DTreeMap.minKeyD_insertIfNew_le_minKeyD | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.isEmpty = false →
∀ {k : α} {v : β k} {fallback : α}, (cmp ((t.insertIfNew k v).minKeyD fallback) (t.minKeyD fallback)).isLE = true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_5.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(motive :
(l_1 : Std.DTreeMap.Internal.Impl α β) →
l_1.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond l_1.size (Std.DTreeMap.Internal.Impl.inner rs k v l r).size →
Sort u_3)
(ls : ℕ) (lk : α) (lv : β lk) (ll lr : Std.DTreeMap.Internal.Impl α β)
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced)
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size)
(h_1 :
(hlb : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond Std.DTreeMap.Internal.Impl.leaf.size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive Std.DTreeMap.Internal.Impl.leaf hlb hlr)
(h_2 :
(ls : ℕ) →
(lk : α) →
(lv : β lk) →
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr) hlb hlr),
(match Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr, hlb, hlr with
| Std.DTreeMap.Internal.Impl.leaf, hlb, hlr => h_1 hlb hlr
| Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr, hlb, hlr => h_2 ls lk lv ll lr hlb hlr) =
h_2 ls lk lv ll lr hlb hlr |
Std.DTreeMap.Internal.RooSliceData._sizeOf_1 | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} → {inst : Ord α} → [SizeOf α] → [(a : α) → SizeOf (β a)] → Std.DTreeMap.Internal.RooSliceData α β → ℕ |
AddGrpCat.instCategory.eq_1 | Mathlib.Algebra.Category.Grp.Basic | AddGrpCat.instCategory =
{ Hom := fun X Y => X.Hom Y, id := fun X => { hom' := AddMonoidHom.id ↑X },
comp := fun {X Y Z} f g => { hom' := g.hom'.comp f.hom' }, id_comp := @AddGrpCat.instCategory._proof_1,
comp_id := @AddGrpCat.instCategory._proof_2, assoc := @AddGrpCat.instCategory._proof_3 } |
isOfFinAddOrder_iff_zsmul_eq_zero | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : SubtractionMonoid G] {x : G}, IsOfFinAddOrder x ↔ ∃ n, n ≠ 0 ∧ n • x = 0 |
TopHom.symm_dual_comp | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : LE α] [inst_1 : OrderTop α] [inst_2 : LE β] [inst_3 : OrderTop β]
[inst_4 : LE γ] [inst_5 : OrderTop γ] (g : BotHom βᵒᵈ γᵒᵈ) (f : BotHom αᵒᵈ βᵒᵈ),
TopHom.dual.symm (g.comp f) = (TopHom.dual.symm g).comp (TopHom.dual.symm f) |
CompleteSublattice.sInfClosed' | Mathlib.Order.CompleteSublattice | ∀ {α : Type u_1} [inst : CompleteLattice α] (self : CompleteSublattice α) ⦃s : Set α⦄,
s ⊆ self.carrier → sInf s ∈ self.carrier |
NumberField.RingOfIntegers.HeightOneSpectrum.isNonarchimedean_adicAbv | Mathlib.NumberTheory.NumberField.FinitePlaces | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(v : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)),
IsNonarchimedean ⇑(NumberField.RingOfIntegers.HeightOneSpectrum.adicAbv v) |
CategoryTheory.isCofilteredOrEmpty_of_directed_ge | Mathlib.CategoryTheory.Filtered.Basic | ∀ (α : Type u) [inst : Preorder α] [IsCodirectedOrder α], CategoryTheory.IsCofilteredOrEmpty α |
_private.Mathlib.Topology.Order.Bornology.0.Pi.instIsOrderBornology._simp_5 | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} {s : Set α} [inst : Bornology α] [inst_1 : Preorder α] [IsOrderBornology α],
Bornology.IsBounded s = (BddBelow s ∧ BddAbove s) |
NumberField.mixedEmbedding.fundamentalCone.isCompact_compactSet | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
IsCompact (NumberField.mixedEmbedding.fundamentalCone.compactSet K) |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PreProcessM.markUninterestingConst | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | Lean.Name → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PreProcessM Unit |
Lean.Meta.Grind.Order.ToPropagate.eqTrue | Lean.Meta.Tactic.Grind.Order.Types | Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId →
Lean.Expr →
Lean.Meta.Grind.Order.NodeId →
Lean.Meta.Grind.Order.NodeId →
Lean.Meta.Grind.Order.Weight → Lean.Meta.Grind.Order.Weight → Lean.Meta.Grind.Order.ToPropagate |
Lean.Grind.CommRing.Poly.powC_nc.eq_def | Init.Grind.Ring.CommSolver | ∀ (p : Lean.Grind.CommRing.Poly) (k c : ℕ),
p.powC_nc k c =
match k with
| 0 => Lean.Grind.CommRing.Poly.num 1
| 1 => p
| k.succ => (p.powC_nc k c).mulC_nc p c |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functorToMonoOver._proof_5 | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
[CategoryTheory.IsGrothendieckAbelian.{u_1, u_2, u_3} C] (J : Type u_1),
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete J) C |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Embeddings.0.IsCyclotomicExtension.Rat.nrComplexPlaces_eq_totient_div_two._simp_1_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Embeddings | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n |
LinearEquiv.transvection.eq_1 | Mathlib.LinearAlgebra.Transvection | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {f : Module.Dual R V}
{v : V} (h : f v = 0),
LinearEquiv.transvection h =
{ toFun := ⇑(LinearMap.transvection f v), map_add' := ⋯, map_smul' := ⋯, invFun := ⇑(LinearMap.transvection f (-v)),
left_inv := ⋯, right_inv := ⋯ } |
Lean.Meta.NativeEqTrueResult._sizeOf_1 | Lean.Meta.Native | Lean.Meta.NativeEqTrueResult → ℕ |
Algebra.inf_toSubsemiring | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S T : Subalgebra R A),
(S ⊓ T).toSubsemiring = S.toSubsemiring ⊓ T.toSubsemiring |
ISize.toNatClampNeg_ofBitVec | Init.Data.SInt.Lemmas | ∀ (b : BitVec System.Platform.numBits), (ISize.ofBitVec b).toNatClampNeg = b.toInt.toNat |
AddSubgroup.index_eq_one | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.index = 1 ↔ H = ⊤ |
Directed.finset_le | Mathlib.Data.Finset.Order | ∀ {α : Type u} {r : α → α → Prop} [IsTrans α r] {ι : Type u_1} [hι : Nonempty ι] {f : ι → α},
Directed r f → ∀ (s : Finset ι), ∃ z, ∀ i ∈ s, r (f i) (f z) |
_private.Mathlib.Algebra.Lie.LieTheorem.0.LieModule.weightSpaceOfIsLieTower_aux._simp_1_11 | Mathlib.Algebra.Lie.LieTheorem | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) |
CategoryTheory.MorphismProperty.IsCardinalForSmallObjectArgument | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.MorphismProperty C → (κ : Cardinal.{w}) → [Fact κ.IsRegular] → [OrderBot κ.ord.ToType] → Prop |
ProbabilityTheory.Kernel.IsFiniteKernel.comap | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} {g : γ → α} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsFiniteKernel κ]
(hg : Measurable g), ProbabilityTheory.IsFiniteKernel (κ.comap g hg) |
WithTop.untop₀_max | Mathlib.Algebra.Order.WithTop.Untop0 | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] {a b : WithTop α},
a ≠ ⊤ → b ≠ ⊤ → (max a b).untop₀ = max a.untop₀ b.untop₀ |
LinearMap.IsAdjointPair | Mathlib.LinearAlgebra.SesquilinearForm.Basic | {R : Type u_1} →
{M : Type u_5} →
{M₁ : Type u_6} →
{M₃ : Type u_8} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : AddCommMonoid M₁] →
[inst_4 : Module R M₁] →
[inst_5 : AddCommMonoid M₃] →
[inst_6 : Module R M₃] →
{I : R →+* R} → (M →ₗ[R] M →ₛₗ[I] M₃) → (M₁ →ₗ[R] M₁ →ₛₗ[I] M₃) → (M → M₁) → (M₁ → M) → Prop |
_private.Mathlib.Algebra.Order.Nonneg.Ring.0.Nonneg.noZeroDivisors._simp_2 | Mathlib.Algebra.Order.Nonneg.Ring | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.PendingField | Lean.Elab.StructInst | Type |
Lean.IR.Decl.uniqueIds | Lean.Compiler.IR.NormIds | Lean.IR.Decl → Bool |
Lean.Server.Watchdog.RequestData.requestQueues | Lean.Server.Watchdog | Lean.Server.Watchdog.RequestData → Std.TreeMap Lean.Lsp.DocumentUri Lean.Server.Watchdog.RequestQueueMap compare |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.complexMGF_id_gaussianReal._simp_1_3 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {x y : ℝ}, 0 ≤ x → y ≠ 0 → (x ^ y = 0) = (x = 0) |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.get.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
[inst : Ord α] →
(k : α) →
(motive : (t : Std.DTreeMap.Internal.Impl α β) → k ∈ t → Sort u_3) →
(t : Std.DTreeMap.Internal.Impl α β) →
(hlk : k ∈ t) →
((size : ℕ) →
(k' : α) →
(v' : β k') →
(l r : Std.DTreeMap.Internal.Impl α β) →
(hlk : k ∈ Std.DTreeMap.Internal.Impl.inner size k' v' l r) →
motive (Std.DTreeMap.Internal.Impl.inner size k' v' l r) hlk) →
motive t hlk |
TrivSqZeroExt.mul_left_eq_one | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rᵐᵒᵖ M] [inst_3 : Module R M]
(r : R) (x : TrivSqZeroExt R M),
r * x.fst = 1 → (TrivSqZeroExt.inl r + TrivSqZeroExt.inr (-(MulOpposite.op r • r • x.snd))) * x = 1 |
CategoryTheory.Limits.Fan.IsLimit.desc | Mathlib.CategoryTheory.Limits.Shapes.Products | {β : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : β → C} →
{c : CategoryTheory.Limits.Fan F} → CategoryTheory.Limits.IsLimit c → {A : C} → ((i : β) → A ⟶ F i) → (A ⟶ c.pt) |
Erased.mk._proof_1 | Mathlib.Data.Erased | ∀ {α : Sort u_1} (a : α), ∃ a_1, (fun x => a_1 = x) = fun b => a = b |
TendstoLocallyUniformlyOn.fun_mul₀ | Mathlib.Topology.MetricSpace.Algebra | ∀ {X : Type u_3} {M : Type u_4} {ι : Type u_5} [inst : TopologicalSpace X] [inst_1 : PseudoMetricSpace M]
[inst_2 : Zero M] [inst_3 : Mul M] [IsBoundedSMul M M] {s : Set X} {F G : ι → X → M} {f g : X → M} {l : Filter ι},
TendstoLocallyUniformlyOn F f l s →
TendstoLocallyUniformlyOn G g l s →
ContinuousOn f s →
ContinuousOn g s → TendstoLocallyUniformlyOn (fun i i_1 => F i i_1 * G i i_1) (fun i => f i * g i) l s |
Monoid.Coprod.mk_surjective | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], Function.Surjective ⇑Monoid.Coprod.mk |
_private.Mathlib.Tactic.NormNum.BigOperators.0.Mathlib.Meta.Nat.unifyZeroOrSucc.match_1 | Mathlib.Tactic.NormNum.BigOperators | (motive : Option Lean.Expr → Sort u_1) →
(__discr : Option Lean.Expr) →
((n'_val : Q(ℕ)) → motive (some n'_val)) → ((x : Option Lean.Expr) → motive x) → motive __discr |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.Style.header.broadImportsCheck.match_1 | Mathlib.Tactic.Linter.Header | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
(Unit → motive `Mathlib.Tactic) →
(Unit → motive `Mathlib.Tactic.Replace) →
(Unit → motive `Mathlib.Tactic.Have) → ((modName : Lean.Name) → motive modName) → motive x |
monotone_Iic | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} [inst : Preorder α], Monotone Set.Iic |
Mathlib.Tactic.Sat.LRATStep.noConfusionType | Mathlib.Tactic.Sat.FromLRAT | Sort u → Mathlib.Tactic.Sat.LRATStep → Mathlib.Tactic.Sat.LRATStep → Sort u |
Lean.Linter.MissingDocs.addBuiltinHandler | Lean.Linter.MissingDocs | Lean.Name → Lean.Linter.MissingDocs.Handler → IO Unit |
_private.Lean.Elab.Tactic.Do.ProofMode.Cases.0.Lean.Elab.Tactic.Do.ProofMode.synthIsAnd._sparseCasesOn_1 | Lean.Elab.Tactic.Do.ProofMode.Cases | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Multiset.toFinset_range | Mathlib.Data.Finset.Range | ∀ (n : ℕ), (Multiset.range n).toFinset = Finset.range n |
WittVector.mapFun.add | Mathlib.RingTheory.WittVector.Basic | ∀ {p : ℕ} {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Fact (Nat.Prime p)]
(f : R →+* S) (x y : WittVector p R),
WittVector.mapFun (⇑f) (x + y) = WittVector.mapFun (⇑f) x + WittVector.mapFun (⇑f) y |
SimpleGraph.Walk.reverseAux._sunfold | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | {V : Type u} → {G : SimpleGraph V} → {u v w : V} → G.Walk u v → G.Walk u w → G.Walk v w |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.4177755762._hygCtx._hyg.1.casesOn | Lean.Server.FileWorker.WidgetRequests | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
(t : Lean.Widget.RpcEncodablePacket✝) → ((query msg : Lean.Json) → motive { query := query, msg := msg }) → motive t |
_private.Mathlib.Analysis.SpecialFunctions.Log.Basic.0.Mathlib.Meta.Positivity.evalLogNatLit._proof_6 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ (inst : Q(DivisionRing ℝ)), «$inst» =Q Real.instDivisionRing |
SubMulAction.instTop | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} → {M : Type v} → [inst : SMul R M] → Top (SubMulAction R M) |
eq_or_eq_inv_of_mabs_eq | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LinearOrder α] {a b : α}, |a|ₘ = b → a = b ∨ a = b⁻¹ |
Multiset.nat_divisors_prod | Mathlib.Data.Finset.NatDivisors | ∀ (s : Multiset ℕ), s.prod.divisors = (Multiset.map Nat.divisors s).prod |
SimpleGraph.Finsubgraph.instHNot._proof_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V] (G' : G.Finsubgraph), (￢↑G').verts.Finite |
Nat.add_modEq_left_iff._simp_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, (a + b ≡ a [MOD n]) = (n ∣ b) |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_support_isInfix._proof_1_6 | Mathlib.Combinatorics.SimpleGraph.Walks.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {v w v' w' : V} {p₁ : G.Walk v w} {p₂ : G.Walk v' w'} (s t : List V),
s ++ p₁.support ++ t = p₂.support → s.length + p₁.length ≤ p₂.length |
frontier_Ico | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[NoMinOrder α] {a b : α}, a < b → frontier (Set.Ico a b) = {a, b} |
CategoryTheory.colimitCompWhiskeringRightIsoColimitComp | Mathlib.CategoryTheory.Limits.Preserves.FunctorCategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{E : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{J : Type u_4} →
[inst_3 : CategoryTheory.Category.{v_4, u_4} J] →
[inst_4 : CategoryTheory.Limits.HasColimitsOfShape J D] →
(F : CategoryTheory.Functor D E) →
[inst_5 : CategoryTheory.Limits.PreservesColimitsOfShape J F] →
(G : CategoryTheory.Functor J (CategoryTheory.Functor C D)) →
CategoryTheory.Limits.colimit (G.comp ((CategoryTheory.Functor.whiskeringRight C D E).obj F)) ≅
(CategoryTheory.Limits.colimit G).comp F |
Lean.Compiler.LCNF.Renaming | Lean.Compiler.LCNF.Renaming | Type |
CategoryTheory.Precoverage.ZeroHypercover.Small.mk | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S : C}
{E : J.ZeroHypercover S}, (∃ ι f, (E.restrictIndex f).presieve₀ ∈ J.coverings S) → E.Small |
Pi.normedAddGroup._proof_2 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → NormedAddGroup (G i)] (x y : (i : ι) → G i),
dist x y = ‖-x + y‖ |
Bool.coe_sort_true | Mathlib.Data.Bool.Basic | (true = true) = True |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic.0.inhomogeneousCochains.d._simp_2 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | ∀ {α : Type u_5} {M : Type u_9} {N : Type u_10} [inst : SMul M N] [inst_1 : SMul N α] [inst_2 : SMul M α]
[IsScalarTower M N α] (x : M) (y : N) (z : α), x • y • z = (x • y) • z |
PowerBasis.quotientEquivQuotientMinpolyMap.eq_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (pb : PowerBasis R S)
(I : Ideal R),
pb.quotientEquivQuotientMinpolyMap I =
(AlgEquiv.ofRingEquiv ⋯).trans (AdjoinRoot.quotEquivQuotMap (minpoly R pb.gen) I) |
ContDiff.differentiable_one | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : 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},
ContDiff 𝕜 1 f → Differentiable 𝕜 f |
Group.zpow._inherited_default | Mathlib.Algebra.Group.Defs | {G : Type u} → (G → G → G) → G → (G → G) → ℤ → G → G |
Lean.withTraceNode' | Lean.Util.Trace | {α : Type} →
{m : Type → Type} →
[Monad m] →
[Lean.MonadTrace m] →
[Lean.MonadRef m] →
[Lean.AddMessageContext m] →
[Lean.MonadOptions m] →
[Lean.MonadAlwaysExcept Lean.Exception m] →
[MonadLiftT BaseIO m] →
Lean.Name → m (α × Lean.MessageData) → optParam Bool true → optParam String "" → m α |
SimpleGraph.Coloring.color_classes_independent | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u} {G : SimpleGraph V} {α : Type u_2} (C : G.Coloring α) (c : α), IsAntichain G.Adj (C.colorClass c) |
VectorAllP | Mathlib.Data.Vector3 | {α : Type u_1} → {n : ℕ} → (α → Prop) → Vector3 α n → Prop |
MulMemClass.mul_left_mem_add_closure | Mathlib.Algebra.Ring.Submonoid.Basic | ∀ {M : Type u_1} {R : Type u_2} [inst : NonUnitalNonAssocSemiring R] [inst_1 : SetLike M R] [MulMemClass M R] {S : M}
{a b : R}, a ∈ S → b ∈ AddSubmonoid.closure ↑S → a * b ∈ AddSubmonoid.closure ↑S |
MLList.ofList._unsafe_rec | Batteries.Data.MLList.Basic | {α : Type u_1} → {m : Type u_1 → Type u_1} → List α → MLList m α |
IsTopologicalAddGroup.toHSpace._proof_6 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : AddZeroClass M] [inst_1 : TopologicalSpace M] [inst_2 : ContinuousAdd M],
{ toFun := Function.uncurry Add.add, continuous_toFun := ⋯ }.comp
((ContinuousMap.id M).prodMk (ContinuousMap.const M 0)) =
{ toFun := Function.uncurry Add.add, continuous_toFun := ⋯ }.comp
((ContinuousMap.id M).prodMk (ContinuousMap.const M 0)) |
Set.encard_le_encard_diff_add_encard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} (s t : Set α), s.encard ≤ (s \ t).encard + t.encard |
UInt8.ofBitVec_ofFin | Init.Data.UInt.Lemmas | ∀ (n : Fin (2 ^ 8)), { toBitVec := { toFin := n } } = UInt8.ofFin n |
LaurentPolynomial.smeval_T_pow | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid S] [inst_2 : MulActionWithZero R S]
[inst_3 : Monoid S] (n : ℤ) (x : Sˣ), (LaurentPolynomial.T n).smeval x = ↑(x ^ n) |
Lean.Parser.Term.binop_lazy.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer |
ProfiniteGrp.toLimit._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u_1}), CompactSpace ↑P.1.toTop |
CategoryTheory.Limits.IsImage.ofIsoI._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
{F : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) {I' : C} (e : F.I ≅ I')
(F' : CategoryTheory.Limits.MonoFactorisation f),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp e.inv (hF.lift F')) F'.m = (F.ofIsoI e).m |
Finset.sumLexLift_inl_inl | Mathlib.Data.Sum.Interval | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6}
(f₁ : α₁ → β₁ → Finset γ₁) (f₂ : α₂ → β₂ → Finset γ₂) (g₁ : α₁ → β₂ → Finset γ₁) (g₂ : α₁ → β₂ → Finset γ₂) (a : α₁)
(b : β₁), Finset.sumLexLift f₁ f₂ g₁ g₂ (Sum.inl a) (Sum.inl b) = Finset.map Function.Embedding.inl (f₁ a b) |
Std.Iter.foldl_toArray | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} {γ : Type x} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id]
[inst_2 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id] {f : γ → β → γ} {init : γ} {it : Std.Iter β},
Array.foldl f init it.toArray = Std.Iter.fold f init it |
Mathlib.Tactic.Translate.Reorder._sizeOf_inst | Mathlib.Tactic.Translate.Reorder | SizeOf Mathlib.Tactic.Translate.Reorder |
Lean.MetavarContext.addExprMVarDecl | Lean.MetavarContext | Lean.MetavarContext →
Lean.MVarId →
Lean.Name →
Lean.LocalContext →
Lean.LocalInstances →
Lean.Expr → optParam Lean.MetavarKind Lean.MetavarKind.natural → optParam ℕ 0 → Lean.MetavarContext |
dualTensorHomEquivOfBasis._proof_3 | Mathlib.LinearAlgebra.Contraction | ∀ {ι : Type u_4} {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [inst_5 : DecidableEq ι] [inst_6 : Fintype ι]
(b : Module.Basis ι R M),
(∑ i, (TensorProduct.mk R (Module.Dual R M) N) (b.dualBasis i) ∘ₗ LinearMap.applyₗ (b i)) ∘ₗ dualTensorHom R M N =
LinearMap.id |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.