name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.CostructuredArrow.toOverCompYoneda._proof_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
(T : CategoryTheory.Over A) {X Y : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.CostructuredArrow.toOver CategoryTheory.yoneda A).op.comp (CategoryTheory.yoneda.obj T)).map f)
((fun X =>
(CategoryTheory.overEquivPresheafCostructuredArrow A).fullyFaithfulFunctor.homEquiv.toIso ≪≫
(((CategoryTheory.CostructuredArrow.toOverCompOverEquivPresheafCostructuredArrow A).app
(Opposite.unop X)).homCongr
(CategoryTheory.Iso.refl
((CategoryTheory.overEquivPresheafCostructuredArrow A).functor.obj T))).toIso)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X =>
(CategoryTheory.overEquivPresheafCostructuredArrow A).fullyFaithfulFunctor.homEquiv.toIso ≪≫
(((CategoryTheory.CostructuredArrow.toOverCompOverEquivPresheafCostructuredArrow A).app
(Opposite.unop X)).homCongr
(CategoryTheory.Iso.refl
((CategoryTheory.overEquivPresheafCostructuredArrow A).functor.obj T))).toIso)
X).hom
((CategoryTheory.yoneda.op.comp
(CategoryTheory.yoneda.obj ((CategoryTheory.overEquivPresheafCostructuredArrow A).functor.obj T))).map
f) |
Lean.IR.LogEntry | Lean.Compiler.IR.CompilerM | Type |
Differentiable.continuous | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} [ContinuousAdd E] [ContinuousSMul 𝕜 E] [ContinuousAdd F]
[ContinuousSMul 𝕜 F], Differentiable 𝕜 f → Continuous f |
Int64.sub_mul | Init.Data.SInt.Lemmas | ∀ {a b c : Int64}, (a - b) * c = a * c - b * c |
OrderHom.gfp_le | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, (∀ b ≤ f b, b ≤ a) → OrderHom.gfp f ≤ a |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic.0.Algebra.finite_iff_isIntegral_and_finiteType.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(motive : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A → Prop)
(x : Algebra.IsIntegral R A ∧ Algebra.FiniteType R A),
(∀ (h : Algebra.IsIntegral R A) (right : Algebra.FiniteType R A), motive ⋯) → motive x |
Lean.Compiler.LCNF.instInhabitedLetDecl | Lean.Compiler.LCNF.Basic | {a : Lean.Compiler.LCNF.Purity} → Inhabited (Lean.Compiler.LCNF.LetDecl a) |
ContinuousLinearEquiv.continuousAlternatingMapCongr._proof_4 | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F' : Type u_2} [inst_1 : NormedAddCommGroup F']
[inst_2 : NormedSpace 𝕜 F'], SMulCommClass 𝕜 𝕜 F' |
Lean.Parser.Tactic.mcasesPatAlts | Std.Tactic.Do.Syntax | Lean.ParserDescr |
Nucleus.mem_toSublocale | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {n : Nucleus X} {x : X}, x ∈ n.toSublocale ↔ ∃ y, n y = x |
ULift.div | Mathlib.Algebra.Group.ULift | {α : Type u} → [Div α] → Div (ULift.{u_1, u} α) |
CategoryTheory.LaxFunctor.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{P : Sort u} →
{toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C} →
{mapId :
(a : B) →
CategoryTheory.CategoryStruct.id (toPrelaxFunctor.obj a) ⟶
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.id a)} →
{mapComp :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
CategoryTheory.CategoryStruct.comp (toPrelaxFunctor.map f) (toPrelaxFunctor.map g) ⟶
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.comp f g)} →
{mapComp_naturality_left :
autoParam
(∀ {a b c : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (mapComp f g)
(toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.whiskerRight η g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (toPrelaxFunctor.map₂ η) (toPrelaxFunctor.map g))
(mapComp f' g))
CategoryTheory.LaxFunctor.mapComp_naturality_left._autoParam} →
{mapComp_naturality_right :
autoParam
(∀ {a b c : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g'),
CategoryTheory.CategoryStruct.comp (mapComp f g)
(toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.whiskerLeft f η)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (toPrelaxFunctor.map₂ η))
(mapComp f g'))
CategoryTheory.LaxFunctor.mapComp_naturality_right._autoParam} →
{map₂_associator :
autoParam
(∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapComp f g) (toPrelaxFunctor.map h))
(CategoryTheory.CategoryStruct.comp (mapComp (CategoryTheory.CategoryStruct.comp f g) h)
(toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.associator f g h).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (toPrelaxFunctor.map f) (toPrelaxFunctor.map g)
(toPrelaxFunctor.map h)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (mapComp g h))
(mapComp f (CategoryTheory.CategoryStruct.comp g h))))
CategoryTheory.LaxFunctor.map₂_associator._autoParam} →
{map₂_leftUnitor :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.leftUnitor f).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.leftUnitor (toPrelaxFunctor.map f)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapId a) (toPrelaxFunctor.map f))
(mapComp (CategoryTheory.CategoryStruct.id a) f)))
CategoryTheory.LaxFunctor.map₂_leftUnitor._autoParam} →
{map₂_rightUnitor :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.rightUnitor f).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.rightUnitor (toPrelaxFunctor.map f)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (mapId b))
(mapComp f (CategoryTheory.CategoryStruct.id b))))
CategoryTheory.LaxFunctor.map₂_rightUnitor._autoParam} →
{toPrelaxFunctor' : CategoryTheory.PrelaxFunctor B C} →
{mapId' :
(a : B) →
CategoryTheory.CategoryStruct.id (toPrelaxFunctor'.obj a) ⟶
toPrelaxFunctor'.map (CategoryTheory.CategoryStruct.id a)} →
{mapComp' :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
CategoryTheory.CategoryStruct.comp (toPrelaxFunctor'.map f)
(toPrelaxFunctor'.map g) ⟶
toPrelaxFunctor'.map (CategoryTheory.CategoryStruct.comp f g)} →
{mapComp_naturality_left' :
autoParam
(∀ {a b c : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (mapComp' f g)
(toPrelaxFunctor'.map₂ (CategoryTheory.Bicategory.whiskerRight η g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (toPrelaxFunctor'.map₂ η)
(toPrelaxFunctor'.map g))
(mapComp' f' g))
CategoryTheory.LaxFunctor.mapComp_naturality_left._autoParam} →
{mapComp_naturality_right' :
autoParam
(∀ {a b c : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g'),
CategoryTheory.CategoryStruct.comp (mapComp' f g)
(toPrelaxFunctor'.map₂ (CategoryTheory.Bicategory.whiskerLeft f η)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor'.map f)
(toPrelaxFunctor'.map₂ η))
(mapComp' f g'))
CategoryTheory.LaxFunctor.mapComp_naturality_right._autoParam} →
{map₂_associator' :
autoParam
(∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapComp' f g)
(toPrelaxFunctor'.map h))
(CategoryTheory.CategoryStruct.comp
(mapComp' (CategoryTheory.CategoryStruct.comp f g) h)
(toPrelaxFunctor'.map₂
(CategoryTheory.Bicategory.associator f g h).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (toPrelaxFunctor'.map f)
(toPrelaxFunctor'.map g) (toPrelaxFunctor'.map h)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor'.map f)
(mapComp' g h))
(mapComp' f (CategoryTheory.CategoryStruct.comp g h))))
CategoryTheory.LaxFunctor.map₂_associator._autoParam} →
{map₂_leftUnitor' :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor'.map₂ (CategoryTheory.Bicategory.leftUnitor f).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.leftUnitor (toPrelaxFunctor'.map f)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapId' a)
(toPrelaxFunctor'.map f))
(mapComp' (CategoryTheory.CategoryStruct.id a) f)))
CategoryTheory.LaxFunctor.map₂_leftUnitor._autoParam} →
{map₂_rightUnitor' :
autoParam
(∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor'.map₂ (CategoryTheory.Bicategory.rightUnitor f).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.rightUnitor (toPrelaxFunctor'.map f)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor'.map f)
(mapId' b))
(mapComp' f (CategoryTheory.CategoryStruct.id b))))
CategoryTheory.LaxFunctor.map₂_rightUnitor._autoParam} →
{ toPrelaxFunctor := toPrelaxFunctor, mapId := mapId, mapComp := mapComp,
mapComp_naturality_left := mapComp_naturality_left,
mapComp_naturality_right := mapComp_naturality_right,
map₂_associator := map₂_associator, map₂_leftUnitor := map₂_leftUnitor,
map₂_rightUnitor := map₂_rightUnitor } =
{ toPrelaxFunctor := toPrelaxFunctor', mapId := mapId',
mapComp := mapComp',
mapComp_naturality_left := mapComp_naturality_left',
mapComp_naturality_right := mapComp_naturality_right',
map₂_associator := map₂_associator',
map₂_leftUnitor := map₂_leftUnitor',
map₂_rightUnitor := map₂_rightUnitor' } →
(toPrelaxFunctor ≍ toPrelaxFunctor' →
mapId ≍ mapId' → mapComp ≍ mapComp' → P) →
P |
LinearIsometryEquiv.symm_conjStarAlgEquiv | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (e : H ≃ₗᵢ[𝕜] K), e.conjStarAlgEquiv.symm = e.symm.conjStarAlgEquiv |
CategoryTheory.Functor.prod._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{u_7, u_1} A] {B : Type u_5}
[inst_1 : CategoryTheory.Category.{u_3, u_5} B] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_8, u_2} C]
{D : Type u_6} [inst_3 : CategoryTheory.Category.{u_4, u_6} D] (F : CategoryTheory.Functor A B)
(G : CategoryTheory.Functor C D) (X : A × C),
CategoryTheory.Prod.mkHom (F.map (CategoryTheory.CategoryStruct.id X).1)
(G.map (CategoryTheory.CategoryStruct.id X).2) =
CategoryTheory.CategoryStruct.id (F.obj X.1, G.obj X.2) |
MeasureTheory.lintegral_lintegral_symm | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] ⦃f : α → β → ENNReal⦄,
AEMeasurable (Function.uncurry f) (μ.prod ν) →
∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (z : β × α), f z.2 z.1 ∂ν.prod μ |
CompactlySupportedContinuousMap._sizeOf_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_5} →
{β : Type u_6} →
{inst : TopologicalSpace α} →
{inst_1 : Zero β} →
{inst_2 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → CompactlySupportedContinuousMap α β → ℕ |
Mathlib.Tactic.BicategoryCoherence.LiftHom.recOn | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom f → Sort u_1} →
(t : Mathlib.Tactic.BicategoryCoherence.LiftHom f) →
((lift : CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicategory.of.obj b) →
motive { lift := lift }) →
motive t |
StarMemClass.rec | Mathlib.Algebra.Star.Basic | {S : Type u_1} →
{R : Type u_2} →
[inst : Star R] →
[inst_1 : SetLike S R] →
{motive : StarMemClass S R → Sort u} →
((star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s) → motive ⋯) → (t : StarMemClass S R) → motive t |
Std.IterM.stepSize | Std.Data.Iterators.Combinators.Monadic.StepSize | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] → [Std.IteratorAccess α m] → [Monad m] → Std.IterM m β → ℕ → Std.IterM m β |
_private.Init.Data.BitVec.Bitblast.0.BitVec.ult_eq_not_carry._proof_1_6 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (y : BitVec w), ¬2 ^ w - 1 - y.toNat < 2 ^ w → False |
ContinuousMap.Homotopy.extend_one | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(F : f₀.Homotopy f₁), F.extend 1 = f₁ |
MeasureTheory.exists_subordinate_pairwise_disjoint | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {ι : Type u_1} {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Countable ι] {s : ι → Set α},
(∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) →
Pairwise (Function.onFun (MeasureTheory.AEDisjoint μ) s) →
∃ t,
(∀ (i : ι), t i ⊆ s i) ∧
(∀ (i : ι), s i =ᵐ[μ] t i) ∧ (∀ (i : ι), MeasurableSet (t i)) ∧ Pairwise (Function.onFun Disjoint t) |
RightCancelMonoid.Nat.card_submonoidPowers | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : RightCancelMonoid G] {a : G}, Nat.card ↥(Submonoid.powers a) = orderOf a |
_private.Mathlib.Algebra.Lie.Ideal.0.LieIdeal.comap._simp_2 | Mathlib.Algebra.Lie.Ideal | ∀ {M : Type u_1} [inst : AddZeroClass M] {s : AddSubmonoid M} {x : M}, (x ∈ s.toAddSubsemigroup) = (x ∈ s) |
Mul.recOn | Init.Prelude | {α : Type u} → {motive : Mul α → Sort u_1} → (t : Mul α) → ((mul : α → α → α) → motive { mul := mul }) → motive t |
SubmoduleClass.module'._proof_2 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_4} {M : Type u_1} {T : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Semiring S] [inst_3 : Module R M] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M]
[inst_7 : SetLike T M] [inst_8 : SMulMemClass T R M] (t : T) (x : ↥t), 1 • x = x |
_private.Mathlib.NumberTheory.Divisors.0.Nat.pairwise_divisorsAntidiagonalList_snd._simp_1_4 | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) |
_private.Lean.Compiler.LCNF.DeclHash.0.Lean.Compiler.LCNF.instHashableSignature.hash.match_1 | Lean.Compiler.LCNF.DeclHash | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Signature pu → Sort u_1) →
(x : Lean.Compiler.LCNF.Signature pu) →
((a : Lean.Name) →
(a_1 : List Lean.Name) →
(a_2 : Lean.Expr) →
(a_3 : Array (Lean.Compiler.LCNF.Param pu)) →
(a_4 : Bool) → motive { name := a, levelParams := a_1, type := a_2, params := a_3, safe := a_4 }) →
motive x |
USize.lt_of_le_of_lt | Init.Data.UInt.Lemmas | ∀ {a b c : USize}, a ≤ b → b < c → a < c |
Lean.Elab.Term.StructInst.SourcesView.noConfusionType | Lean.Elab.StructInst | Sort u → Lean.Elab.Term.StructInst.SourcesView → Lean.Elab.Term.StructInst.SourcesView → Sort u |
CategoryTheory.monoidalCategoryMop._proof_11 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(W X Y Z : Cᴹᵒᵖ),
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z.unmop
(CategoryTheory.MonoidalCategoryStruct.associator Y.unmop X.unmop W.unmop).symm.mop.hom.unmop).mop
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator Z.unmop
{ unmop := CategoryTheory.MonoidalCategoryStruct.tensorObj Y.unmop X.unmop }.unmop
W.unmop).symm.mop.hom
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.MonoidalCategoryStruct.associator Z.unmop Y.unmop X.unmop).symm.mop.hom.unmop
W.unmop).mop)).unmop =
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator Z.unmop Y.unmop
{ unmop := CategoryTheory.MonoidalCategoryStruct.tensorObj X.unmop W.unmop }.unmop).symm.mop.hom
(CategoryTheory.MonoidalCategoryStruct.associator
{ unmop := CategoryTheory.MonoidalCategoryStruct.tensorObj Z.unmop Y.unmop }.unmop X.unmop
W.unmop).symm.mop.hom).unmop |
ZSpan.fract_eq_self | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] {b : Module.Basis ι K E} [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] {x : E}, ZSpan.fract b x = x ↔ x ∈ ZSpan.fundamentalDomain b |
groupHomology.inhomogeneousChains.d._proof_4 | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ (n : ℕ), NeZero (n + 1) |
instDecidableIsValidUTF8 | Init.Data.String.Basic | {b : ByteArray} → Decidable b.IsValidUTF8 |
Matroid.IsBasis'.eRk_eq_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis' I X → M.eRk X = I.encard |
AddOpposite.coe_symm_opAddEquiv | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} [inst : AddCommMonoid M], ⇑AddOpposite.opAddEquiv.symm = AddOpposite.unop |
LocalSubring.exists_le_valuationSubring | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_3} [inst : Field K] (A : LocalSubring K), ∃ B, A ≤ B.toLocalSubring |
AddMonCat.forget_createsLimit._proof_6 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
(this : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections)
(s : CategoryTheory.Limits.Cone F) (x y : ↑s.1),
(CategoryTheory.Limits.Types.Small.limitConeIsLimit (F.comp (CategoryTheory.forget AddMonCat))).lift
((CategoryTheory.forget AddMonCat).mapCone s) (x + y) =
(CategoryTheory.Limits.Types.Small.limitConeIsLimit (F.comp (CategoryTheory.forget AddMonCat))).lift
((CategoryTheory.forget AddMonCat).mapCone s) x +
(CategoryTheory.Limits.Types.Small.limitConeIsLimit (F.comp (CategoryTheory.forget AddMonCat))).lift
((CategoryTheory.forget AddMonCat).mapCone s) y |
Complex.tan | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ |
Finset.sup_eq_bot_of_isEmpty | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] [IsEmpty β] (f : β → α) (S : Finset β),
S.sup f = ⊥ |
QuasiconcaveOn.convex_gt | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconcaveOn 𝕜 s f → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ r < f x} |
Nat.prod_divisors_prime_pow | Mathlib.NumberTheory.Divisors | ∀ {α : Type u_1} [inst : CommMonoid α] {k p : ℕ} {f : ℕ → α},
Nat.Prime p → ∏ x ∈ (p ^ k).divisors, f x = ∏ x ∈ Finset.range (k + 1), f (p ^ x) |
StrictMonoOn.add | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f g : β → α} {s : Set β}
[AddLeftStrictMono α] [AddRightStrictMono α],
StrictMonoOn f s → StrictMonoOn g s → StrictMonoOn (fun x => f x + g x) s |
Submodule.mem_span_set | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : M}
{s : Set M}, m ∈ Submodule.span R s ↔ ∃ c, ↑c.support ⊆ s ∧ (c.sum fun mi r => r • mi) = m |
_private.Init.Data.Int.Gcd.0.Int.lcm_mul_right_dvd_mul_lcm._simp_1_1 | Init.Data.Int.Gcd | ∀ (k m n : ℕ), (k.lcm (m * n) ∣ k.lcm m * k.lcm n) = True |
MulOpposite.instCancelCommMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CancelCommMonoid α],
MulOpposite.instCancelCommMonoid = { toCommMonoid := MulOpposite.instCommMonoid, toIsLeftCancelMul := ⋯ } |
AdicCompletion.AdicCauchySequence.instAddCommGroup._proof_4 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : AdicCompletion.AdicCauchySequence I M), ↑(-x) = ↑(-x) |
TrivSqZeroExt.isNilpotent_inr | Mathlib.RingTheory.DualNumber | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] (x : M), IsNilpotent (TrivSqZeroExt.inr x) |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.recOn | Lean.Server.Logging | {motive : Lean.Server.Logging.LogEntry✝ → Sort u} →
(t : Lean.Server.Logging.LogEntry✝¹) →
((time : Std.Time.ZonedDateTime) →
(direction : Lean.JsonRpc.MessageDirection) →
(kind : Lean.JsonRpc.MessageKind) →
(msg : Lean.JsonRpc.Message) → motive { time := time, direction := direction, kind := kind, msg := msg }) →
motive t |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset._sparseCasesOn_1 | Lean.Meta.Sym.Offset | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Summable.tsum_of_nat_of_neg | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{f : ℤ → G},
(Summable fun n => f ↑n) →
(Summable fun n => f (-↑n)) → ∑' (n : ℤ), f n = ∑' (n : ℕ), f ↑n + ∑' (n : ℕ), f (-↑n) - f 0 |
Lean.Elab.Command.CtorView.modifiers | Lean.Elab.MutualInductive | Lean.Elab.Command.CtorView → Lean.Elab.Modifiers |
Algebra.IsAlgebraic.mk._flat_ctor | Mathlib.RingTheory.Algebraic.Defs | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
(∀ (x : A), IsAlgebraic R x) → Algebra.IsAlgebraic R A |
CategoryTheory.Functor.LaxMonoidal.ofBifunctor.bottomMapᵣ | Mathlib.CategoryTheory.Monoidal.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u_2} →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).comp
F ⟶
F |
Subarray.mkSlice_roi_eq_mkSlice_rco | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs lo<...* = Std.Rco.Sliceable.mkSlice xs (lo + 1)...Std.Slice.size xs |
LinearEquiv.cast_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_14} {M : ι → Type u_15} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] {i j : ι} (h : i = j) (a : M j), (LinearEquiv.cast h).symm a = cast ⋯ a |
MeasureTheory.MemLp.integrable_enorm_pow | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε} {p : ℕ},
MeasureTheory.MemLp f (↑p) μ → p ≠ 0 → MeasureTheory.Integrable (fun x => ‖f x‖ₑ ^ p) μ |
SkewMonoidAlgebra.liftNCRingHom._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} [inst : Semiring k] {R : Type u_2} [inst_1 : Semiring R], AddMonoidHomClass (k →+* R) k R |
Nat.recOnPrimePow._proof_5 | Mathlib.Data.Nat.Factorization.Induction | ∀ (k : ℕ), (k + 2) / (k + 2).minFac ^ (k + 2).factorization (k + 2).minFac < k + 2 |
CategoryTheory.LocalizerMorphism.RightResolution.mk_surjective | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
(R : Φ.RightResolution X₂), ∃ X₁ w, ∃ (hw : W₂ w), R = { X₁ := X₁, w := w, hw := hw } |
AffineMap.map_midpoint | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ {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 : Invertible 2]
[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'] (f : P →ᵃ[R] P') (a b : P),
f (midpoint R a b) = midpoint R (f a) (f b) |
Std.DHashMap.getKey?_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₂ → (m₁ ∪ m₂).getKey? k = m₁.getKey? k |
_private.Mathlib.Computability.TuringMachine.0.Turing.TM2.stmts₁.match_1.eq_6 | Mathlib.Computability.TuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (motive : Turing.TM2.Stmt Γ Λ σ → Sort u_5)
(a : σ → Λ)
(h_1 :
(Q : Turing.TM2.Stmt Γ Λ σ) →
(k : K) →
(a : σ → Γ k) →
(q : Turing.TM2.Stmt Γ Λ σ) → Q = Turing.TM2.Stmt.push k a q → motive (Turing.TM2.Stmt.push k a q))
(h_2 :
(Q : Turing.TM2.Stmt Γ Λ σ) →
(k : K) →
(a : σ → Option (Γ k) → σ) →
(q : Turing.TM2.Stmt Γ Λ σ) → Q = Turing.TM2.Stmt.peek k a q → motive (Turing.TM2.Stmt.peek k a q))
(h_3 :
(Q : Turing.TM2.Stmt Γ Λ σ) →
(k : K) →
(a : σ → Option (Γ k) → σ) →
(q : Turing.TM2.Stmt Γ Λ σ) → Q = Turing.TM2.Stmt.pop k a q → motive (Turing.TM2.Stmt.pop k a q))
(h_4 :
(Q : Turing.TM2.Stmt Γ Λ σ) →
(a : σ → σ) → (q : Turing.TM2.Stmt Γ Λ σ) → Q = Turing.TM2.Stmt.load a q → motive (Turing.TM2.Stmt.load a q))
(h_5 :
(Q : Turing.TM2.Stmt Γ Λ σ) →
(a : σ → Bool) →
(q₁ q₂ : Turing.TM2.Stmt Γ Λ σ) → Q = Turing.TM2.Stmt.branch a q₁ q₂ → motive (Turing.TM2.Stmt.branch a q₁ q₂))
(h_6 : (Q : Turing.TM2.Stmt Γ Λ σ) → (a : σ → Λ) → Q = Turing.TM2.Stmt.goto a → motive (Turing.TM2.Stmt.goto a))
(h_7 : (Q : Turing.TM2.Stmt Γ Λ σ) → Q = Turing.TM2.Stmt.halt → motive Turing.TM2.Stmt.halt),
(match Turing.TM2.Stmt.goto a with
| Q@h:(Turing.TM2.Stmt.push k a q) => h_1 Q k a q h
| Q@h:(Turing.TM2.Stmt.peek k a q) => h_2 Q k a q h
| Q@h:(Turing.TM2.Stmt.pop k a q) => h_3 Q k a q h
| Q@h:(Turing.TM2.Stmt.load a q) => h_4 Q a q h
| Q@h:(Turing.TM2.Stmt.branch a q₁ q₂) => h_5 Q a q₁ q₂ h
| Q@h:(Turing.TM2.Stmt.goto a) => h_6 Q a h
| Q@h:Turing.TM2.Stmt.halt => h_7 Q h) =
h_6 (Turing.TM2.Stmt.goto a) a ⋯ |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.IsLocal.mem_jacobson_or_exists_inv.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} (x : R) (motive : (∃ y ∈ I, ∃ z ∈ Ideal.span {x}, y + z = 1) → Prop)
(x_1 : ∃ y ∈ I, ∃ z ∈ Ideal.span {x}, y + z = 1),
(∀ (p : R) (hpi : p ∈ I) (q : R) (hq : q ∈ Ideal.span {x}) (hpq : p + q = 1), motive ⋯) → motive x_1 |
Std.ExtDHashMap.Const.insertManyIfNewUnit_list_eq_empty_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α}, (Std.ExtDHashMap.Const.insertManyIfNewUnit m l = ∅) = (m = ∅ ∧ l = []) |
Lean.Meta.DiagSummary.data._default | Lean.Meta.Diagnostics | Array Lean.MessageData |
Bundle.TotalSpace.recOn | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_4} →
{E : B → Type u_5} →
{motive : Bundle.TotalSpace F E → Sort u} →
(t : Bundle.TotalSpace F E) → ((proj : B) → (snd : E proj) → motive { proj := proj, snd := snd }) → motive t |
ENNReal.finsetSum_iSup | Mathlib.Data.ENNReal.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} {s : Finset α} {f : α → ι → ENNReal},
(∀ (i j : ι), ∃ k, ∀ (a : α), f a i ≤ f a k ∧ f a j ≤ f a k) → ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i |
Lean.SubExpr.Pos.pushAppArg | Lean.SubExpr | Lean.SubExpr.Pos → Lean.SubExpr.Pos |
_private.Batteries.Data.Fin.Lemmas.0.Fin.findSome?_eq_some_iff._simp_1_1 | Batteries.Data.Fin.Lemmas | ∀ {p : Fin 0 → Prop}, (∀ (i : Fin 0), p i) = True |
PUnit.instLinearOrderedAddCommMonoidWithTop._proof_3 | Mathlib.Algebra.Order.PUnit | ∀ (x : PUnit.{1}), x ≤ x |
Lean.Meta.DiscrTree.getSubexpressionMatches._unsafe_rec | Mathlib.Lean.Meta.DiscrTree | {α : Type} → Lean.Meta.DiscrTree α → Lean.Expr → Lean.MetaM (Array α) |
_aux_Mathlib_Algebra_Group_Units_Defs___unexpand_Units_1 | Mathlib.Algebra.Group.Units.Defs | Lean.PrettyPrinter.Unexpander |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processImplicitArg._unsafe_rec | Lean.Elab.PatternVar | Bool →
Lean.Elab.Term.CollectPatternVars.Context →
Lean.Elab.Term.CollectPatternVars.M Lean.Elab.Term.CollectPatternVars.Context |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_nat._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ} {x : M}, (x ∈ (f.genEigenspace μ) ↑k) = (x ∈ ((f - μ • 1) ^ k).ker) |
IsAddUnit.of_add_eq_zero_right | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] [IsDedekindFiniteAddMonoid M] {b : M} (a : M), a + b = 0 → IsAddUnit b |
MeasureTheory.VectorMeasure.dirac._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {β : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : MeasurableSpace β] (x : β) (v : M) ⦃i : Set β⦄,
¬MeasurableSet i → (if MeasurableSet i ∧ x ∈ i then v else 0) = 0 |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.induction_aux._simp_1_9 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {ι : Sort u_5} (a : α) (f : ι → β),
(Set.range fun i => a • f i) = a • Set.range f |
UniqueFactorizationMonoid.radical_ne_zero._simp_1 | Mathlib.RingTheory.Radical | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M} [Nontrivial M], (UniqueFactorizationMonoid.radical a = 0) = False |
DirectSum.IsInternal.exists_subordinateOrthonormalBasisIndex_eq | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : FiniteDimensional 𝕜 E] {n : ℕ}
(hn : Module.finrank 𝕜 E = n) [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
(hV' : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) {i : ι},
V i ≠ ⊥ → ∃ a, DirectSum.IsInternal.subordinateOrthonormalBasisIndex hn hV a hV' = i |
LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_3} → [self : LinearOrderedCommGroupWithZero α] → LinearOrderedCommMonoidWithZero α |
_private.Mathlib.Tactic.CongrExclamation.0.Congr!.plausiblyEqualTypes.match_5 | Mathlib.Tactic.CongrExclamation | (motive : ℕ → Sort u_1) → (maxDepth : ℕ) → (Unit → motive 0) → ((maxDepth : ℕ) → motive maxDepth.succ) → motive maxDepth |
CochainComplex.isKProjective_shift_iff | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(K : CochainComplex C ℤ) (n : ℤ),
((CategoryTheory.shiftFunctor (CochainComplex C ℤ) n).obj K).IsKProjective ↔ K.IsKProjective |
Hyperreal.coe_add | Mathlib.Analysis.Real.Hyperreal | ∀ (x y : ℝ), ↑(x + y) = ↑x + ↑y |
Bundle.Prod.contMDiffVectorBundle | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} [inst : NontriviallyNormedField 𝕜] {EB : Type u_7}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_8} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB B] (F₁ : Type u_11)
[inst_6 : NormedAddCommGroup F₁] [inst_7 : NormedSpace 𝕜 F₁] (E₁ : B → Type u_12)
[inst_8 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] [inst_9 : (x : B) → AddCommMonoid (E₁ x)]
[inst_10 : (x : B) → Module 𝕜 (E₁ x)] (F₂ : Type u_13) [inst_11 : NormedAddCommGroup F₂] [inst_12 : NormedSpace 𝕜 F₂]
(E₂ : B → Type u_14) [inst_13 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)] [inst_14 : (x : B) → AddCommMonoid (E₂ x)]
[inst_15 : (x : B) → Module 𝕜 (E₂ x)] [inst_16 : (x : B) → TopologicalSpace (E₁ x)]
[inst_17 : (x : B) → TopologicalSpace (E₂ x)] [inst_18 : FiberBundle F₁ E₁] [inst_19 : FiberBundle F₂ E₂]
[inst_20 : VectorBundle 𝕜 F₁ E₁] [inst_21 : VectorBundle 𝕜 F₂ E₂] [ContMDiffVectorBundle n F₁ E₁ IB]
[ContMDiffVectorBundle n F₂ E₂ IB], ContMDiffVectorBundle n (F₁ × F₂) (fun x => E₁ x × E₂ x) IB |
CategoryTheory.ProjectiveResolution.liftFOne._proof_3 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Y : C}
(P : CategoryTheory.ProjectiveResolution Y), CategoryTheory.Projective (P.complex.X 1) |
Std.DTreeMap.Raw.Equiv.of_toList_perm | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp},
t₁.toList.Perm t₂.toList → t₁.Equiv t₂ |
PEquiv.ofSet_eq_refl._simp_1 | Mathlib.Data.PEquiv | ∀ {α : Type u} {s : Set α} [inst : DecidablePred fun x => x ∈ s], (PEquiv.ofSet s = PEquiv.refl α) = (s = Set.univ) |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_aux._proof_1 | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]} (k : ℕ) (x : Nat.below k.succ), ih_gen✝ k ↑x.1 |
ContDiffMapSupportedIn.seminorm._proof_3 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) (F : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F |
JordanHolderLattice.rec | Mathlib.Order.JordanHolder | {X : Type u} →
[inst : Lattice X] →
{motive : JordanHolderLattice X → Sort u_1} →
((IsMaximal : X → X → Prop) →
(lt_of_isMaximal : ∀ {x y : X}, IsMaximal x y → x < y) →
(sup_eq_of_isMaximal : ∀ {x y z : X}, IsMaximal x z → IsMaximal y z → x ≠ y → x ⊔ y = z) →
(isMaximal_inf_left_of_isMaximal_sup :
∀ {x y : X}, IsMaximal x (x ⊔ y) → IsMaximal y (x ⊔ y) → IsMaximal (x ⊓ y) x) →
(Iso : X × X → X × X → Prop) →
(iso_symm : ∀ {x y : X × X}, Iso x y → Iso y x) →
(iso_trans : ∀ {x y z : X × X}, Iso x y → Iso y z → Iso x z) →
(second_iso : ∀ {x y : X}, IsMaximal x (x ⊔ y) → Iso (x, x ⊔ y) (x ⊓ y, y)) →
motive
{ IsMaximal := IsMaximal, lt_of_isMaximal := lt_of_isMaximal,
sup_eq_of_isMaximal := sup_eq_of_isMaximal,
isMaximal_inf_left_of_isMaximal_sup := isMaximal_inf_left_of_isMaximal_sup, Iso := Iso,
iso_symm := iso_symm, iso_trans := iso_trans, second_iso := second_iso }) →
(t : JordanHolderLattice X) → motive t |
descPochhammer | Mathlib.RingTheory.Polynomial.Pochhammer | (R : Type u) → [inst : Ring R] → ℕ → Polynomial R |
Lean.Parser.Tactic.Grind.«grind_filterGen≤_» | Init.Grind.Interactive | Lean.ParserDescr |
CategoryTheory.Comonad.Coalgebra.isoMk | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{G : CategoryTheory.Comonad C} →
{A B : G.Coalgebra} →
(h : A.A ≅ B.A) →
autoParam
(CategoryTheory.CategoryStruct.comp A.a (G.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom B.a)
CategoryTheory.Comonad.Coalgebra.isoMk._auto_1 →
(A ≅ B) |
Matrix.mul_right_inj_of_invertible | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
(A : Matrix n n α) [Invertible A] {x y : Matrix n m α}, A * x = A * y ↔ x = y |
Std.ExtHashSet.size_diff_le_size_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ \ m₂).size ≤ m₁.size |
ProperConstVAdd.mk._flat_ctor | Mathlib.Topology.Algebra.ProperConstSMul | ∀ {M : Type u_1} {X : Type u_2} [inst : VAdd M X] [inst_1 : TopologicalSpace X],
(∀ (c : M), IsProperMap fun x => c +ᵥ x) → ProperConstVAdd M X |
Bundle.Trivialization.coe_linearMapAt | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : AddCommMonoid F]
[inst_5 : Module R F] [inst_6 : (x : B) → AddCommMonoid (E x)] [inst_7 : (x : B) → Module R (E x)]
(e : Bundle.Trivialization F Bundle.TotalSpace.proj) [inst_8 : Bundle.Trivialization.IsLinear R e] (b : B),
⇑(Bundle.Trivialization.linearMapAt R e b) = fun y => if b ∈ e.baseSet then (↑e { proj := b, snd := y }).2 else 0 |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Traversal.0.SimpleGraph.Walk.head_darts_eq_firstDart._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}, 1 ≤ p.darts.length → 0 < p.darts.length |
Std.Roo.mk.inj | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} {lower upper lower_1 upper_1 : α},
((lower<...upper) = lower_1<...upper_1) → lower = lower_1 ∧ upper = upper_1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.