name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.DHashMap.Const.mem_ofList | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} [EquivBEq α] [LawfulHashable α] {l : List (α × β)} {k : α},
k ∈ Std.DHashMap.Const.ofList l ↔ (List.map Prod.fst l).contains k = true |
CategoryTheory.Localization.Preadditive.add.congr_simp | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | ∀ {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] [inst_2 : CategoryTheory.Preadditive C]
{L : CategoryTheory.Functor C D} (W W_1 : CategoryTheory.MorphismProperty C) (e_W : W = W_1)
[inst_3 : L.IsLocalization W] [inst_4 : W.HasLeftCalculusOfFractions] {X Y : C} {X' Y' : D} (eX eX_1 : L.obj X ≅ X'),
eX = eX_1 →
∀ (eY eY_1 : L.obj Y ≅ Y'),
eY = eY_1 →
∀ (f₁ f₁_1 : X' ⟶ Y'),
f₁ = f₁_1 →
∀ (f₂ f₂_1 : X' ⟶ Y'),
f₂ = f₂_1 →
CategoryTheory.Localization.Preadditive.add W eX eY f₁ f₂ =
CategoryTheory.Localization.Preadditive.add W_1 eX_1 eY_1 f₁_1 f₂_1 |
_private.Mathlib.Order.SupIndep.0.iSupIndep.of_coe_Iic_comp._simp_1_1 | Mathlib.Order.SupIndep | ∀ {ι : Sort u_1} {α : Type u_2} [inst : CompleteLattice α] {a : α} (f : ι → ↑(Set.Iic a)), ⨆ i, ↑(f i) = ↑(⨆ i, f i) |
LinearIndepOn.image_of_comp | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {ι : Type u'} {ι' : Type u_1} {R : Type u_2} {s : Set ι} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (f : ι → ι') (g : ι' → M), LinearIndepOn R (g ∘ f) s → LinearIndepOn R g (f '' s) |
CategoryTheory.Presieve.IsSheafFor.functorInclusion_comp_extend | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X}
{P : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (h : CategoryTheory.Presieve.IsSheafFor P S.arrows) (f : S.functor ⟶ P),
CategoryTheory.CategoryStruct.comp S.functorInclusion (h.extend f) = f |
CategoryTheory.MorphismProperty.IsStableUnderCobaseChange.hasOfPrecompProperty_epimorphisms | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
[P.IsStableUnderCobaseChange], P.HasOfPrecompProperty (CategoryTheory.MorphismProperty.epimorphisms C) |
LeanSearchClient.SearchResult.mk.noConfusion | LeanSearchClient.Syntax | {P : Sort u} →
{name : String} →
{type? docString? doc_url? kind? : Option String} →
{name' : String} →
{type?' docString?' doc_url?' kind?' : Option String} →
{ name := name, type? := type?, docString? := docString?, doc_url? := doc_url?, kind? := kind? } =
{ name := name', type? := type?', docString? := docString?', doc_url? := doc_url?', kind? := kind?' } →
(name = name' → type? = type?' → docString? = docString?' → doc_url? = doc_url?' → kind? = kind?' → P) → P |
Lean.Server.FileWorker.WorkerContext.modifyGetPartialHandler | Lean.Server.FileWorker | {α : Type} →
Lean.Server.FileWorker.WorkerContext →
String → (Lean.Server.FileWorker.PartialHandlerInfo → α × Lean.Server.FileWorker.PartialHandlerInfo) → BaseIO α |
ContinuousMap.HomotopyRel.symm_bijective | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)} {S : Set X},
Function.Bijective ContinuousMap.HomotopyRel.symm |
isDedekindRing_iff | Mathlib.RingTheory.DedekindDomain.Basic | ∀ (A : Type u_2) [inst : CommRing A] (K : Type u_4) [inst_1 : CommRing K] [inst_2 : Algebra A K] [IsFractionRing A K],
IsDedekindRing A ↔
IsNoetherianRing A ∧ Ring.DimensionLEOne A ∧ ∀ {x : K}, IsIntegral A x → ∃ y, (algebraMap A K) y = x |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.some_getEntryLE_eq_getEntryLE?._simp_1_9 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {a : α} {o : Option α}, some (o.getD a) = o.or (some a) |
Complex.equivRealProd | Mathlib.Data.Complex.Basic | ℂ ≃ ℝ × ℝ |
IsLocalization.AtPrime.mk'_mem_maximal_iff | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (I : Ideal R)
[hI : I.IsPrime] [inst_3 : IsLocalization.AtPrime S I] (x : R) (y : ↥I.primeCompl) (h : optParam (IsLocalRing S) ⋯),
IsLocalization.mk' S x y ∈ IsLocalRing.maximalIdeal S ↔ x ∈ I |
CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct.recOn | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{D : Type u₃} →
[inst_4 : CategoryTheory.Category.{v₃, u₃} D] →
[inst_5 : CategoryTheory.MonoidalCategoryStruct D] →
{motive : CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct C V D → Sort u} →
(t : CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct C V D) →
((ι : CategoryTheory.Functor D (CategoryTheory.Functor C V)) →
(convolutionExtensionUnit :
(d d' : D) →
CategoryTheory.MonoidalCategory.externalProduct (ι.obj d) (ι.obj d') ⟶
(CategoryTheory.MonoidalCategory.tensor C).comp
(ι.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj d d'))) →
(isPointwiseLeftKanExtensionConvolutionExtensionUnit :
(d d' : D) →
(CategoryTheory.Functor.LeftExtension.mk
(ι.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj d d'))
(convolutionExtensionUnit d d')).IsPointwiseLeftKanExtension) →
(unitUnit :
CategoryTheory.MonoidalCategoryStruct.tensorUnit V ⟶
(ι.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit D)).obj
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) →
(isPointwiseLeftKanExtensionUnitUnit :
(CategoryTheory.Functor.LeftExtension.mk
(ι.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit D))
{ app := fun x => unitUnit, naturality := ⋯ }).IsPointwiseLeftKanExtension) →
(faithful_ι : ι.Faithful) →
(convolutionExtensionUnit_comp_ι_map_tensorHom_app :
∀ {d₁ d₂ d₁' d₂' : D} (f₁ : d₁ ⟶ d₁') (f₂ : d₂ ⟶ d₂') (x y : C),
CategoryTheory.CategoryStruct.comp
((convolutionExtensionUnit d₁ d₂).app (x, y))
((ι.map (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂)).app
(CategoryTheory.MonoidalCategoryStruct.tensorObj x y)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom ((ι.map f₁).app x)
((ι.map f₂).app y))
((convolutionExtensionUnit d₁' d₂').app (x, y))) →
(convolutionExtensionUnit_comp_ι_map_whiskerLeft_app :
∀ (d₁ : D) {d₂ d₂' : D} (f₂ : d₂ ⟶ d₂') (x y : C),
CategoryTheory.CategoryStruct.comp
((convolutionExtensionUnit d₁ d₂).app (x, y))
((ι.map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft d₁ f₂)).app
(CategoryTheory.MonoidalCategoryStruct.tensorObj x y)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((ι.obj d₁).obj x)
((ι.map f₂).app y))
((convolutionExtensionUnit d₁ d₂').app (x, y))) →
(convolutionExtensionUnit_comp_ι_map_whiskerRight_app :
∀ {d₁ d₁' : D} (f₁ : d₁ ⟶ d₁') (d₂ : D) (x y : C),
CategoryTheory.CategoryStruct.comp
((convolutionExtensionUnit d₁ d₂).app (x, y))
((ι.map
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f₁ d₂)).app
(CategoryTheory.MonoidalCategoryStruct.tensorObj x y)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((ι.map f₁).app x)
((ι.obj d₂).obj y))
((convolutionExtensionUnit d₁' d₂).app (x, y))) →
(associator_hom_unit_unit :
∀ (d d' d'' : D) (x y z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
((convolutionExtensionUnit d d').app (x, y)) ((ι.obj d'').obj z))
(CategoryTheory.CategoryStruct.comp
((convolutionExtensionUnit
(CategoryTheory.MonoidalCategoryStruct.tensorObj d d')
d'').app
(CategoryTheory.MonoidalCategoryStruct.tensorObj x y, z))
((ι.map
(CategoryTheory.MonoidalCategoryStruct.associator d d'
d'').hom).app
(CategoryTheory.MonoidalCategoryStruct.tensorObj
(CategoryTheory.MonoidalCategoryStruct.tensorObj x y) z))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator ((ι.obj d).obj x)
((ι.obj d', ι.obj d'').1.obj (y, z).1)
((ι.obj d', ι.obj d'').2.obj (y, z).2)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
((ι.obj d).obj x)
((convolutionExtensionUnit d' d'').app (y, z)))
(CategoryTheory.CategoryStruct.comp
((convolutionExtensionUnit d
(CategoryTheory.MonoidalCategoryStruct.tensorObj d'
d'')).app
(x, CategoryTheory.MonoidalCategoryStruct.tensorObj y z))
((ι.obj
(CategoryTheory.MonoidalCategoryStruct.tensorObj d
(CategoryTheory.MonoidalCategoryStruct.tensorObj d'
d''))).map
(CategoryTheory.MonoidalCategoryStruct.associator
(x, CategoryTheory.MonoidalCategoryStruct.tensorObj y z).1
y z).inv)))) →
(leftUnitor_hom_unit_app :
∀ (d : D) (y : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight unitUnit
((ι.obj d).obj y))
(CategoryTheory.CategoryStruct.comp
((convolutionExtensionUnit
(CategoryTheory.MonoidalCategoryStruct.tensorUnit D)
d).app
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C, y))
((ι.map
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
d).hom).app
(CategoryTheory.MonoidalCategoryStruct.tensorObj
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C) y))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor
((ι.obj d).obj y)).hom
((ι.obj d).map
(CategoryTheory.MonoidalCategoryStruct.leftUnitor y).inv)) →
(rightUnitor_hom_unit_app :
∀ (d : D) (y : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
((ι.obj d).obj y) unitUnit)
(CategoryTheory.CategoryStruct.comp
((convolutionExtensionUnit d
(CategoryTheory.MonoidalCategoryStruct.tensorUnit
D)).app
(y, CategoryTheory.MonoidalCategoryStruct.tensorUnit C))
((ι.map
(CategoryTheory.MonoidalCategoryStruct.rightUnitor
d).hom).app
(CategoryTheory.MonoidalCategoryStruct.tensorObj y
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C)))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.rightUnitor
((ι.obj d).obj y)).hom
((ι.obj d).map
(CategoryTheory.MonoidalCategoryStruct.rightUnitor y).inv)) →
motive
{ ι := ι, convolutionExtensionUnit := convolutionExtensionUnit,
isPointwiseLeftKanExtensionConvolutionExtensionUnit :=
isPointwiseLeftKanExtensionConvolutionExtensionUnit,
unitUnit := unitUnit,
isPointwiseLeftKanExtensionUnitUnit :=
isPointwiseLeftKanExtensionUnitUnit,
faithful_ι := faithful_ι,
convolutionExtensionUnit_comp_ι_map_tensorHom_app :=
convolutionExtensionUnit_comp_ι_map_tensorHom_app,
convolutionExtensionUnit_comp_ι_map_whiskerLeft_app :=
convolutionExtensionUnit_comp_ι_map_whiskerLeft_app,
convolutionExtensionUnit_comp_ι_map_whiskerRight_app :=
convolutionExtensionUnit_comp_ι_map_whiskerRight_app,
associator_hom_unit_unit := associator_hom_unit_unit,
leftUnitor_hom_unit_app := leftUnitor_hom_unit_app,
rightUnitor_hom_unit_app := rightUnitor_hom_unit_app }) →
motive t |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.δ_descCochain._proof_1_6 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ (p : ℤ), p + -1 + 0 = p + -1 |
Lean.PrettyPrinter.parenthesizeTerm | Lean.PrettyPrinter.Parenthesizer | Lean.Syntax → Lean.CoreM Lean.Syntax |
ENNReal.ofReal_rpow_of_pos | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x p : ℝ}, 0 < x → ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p) |
Lean.Parser.suppressInsideQuot | Lean.Parser.Basic | Lean.Parser.Parser → Lean.Parser.Parser |
Path.Homotopic.equivalence | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ : X}, Equivalence Path.Homotopic |
Lean.Elab.Term.LetIdDeclView.recOn | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetIdDeclView → Sort u} →
(t : Lean.Elab.Term.LetIdDeclView) →
((id : Lean.Syntax) →
(binders : Array Lean.Syntax) →
(type value : Lean.Syntax) → motive { id := id, binders := binders, type := type, value := value }) →
motive t |
CategoryTheory.Bicategory.postcomposing₂_obj_app_toFunctor_obj | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (a b : B) (f : a ⟶ b) (x : Bᵒᵖ) (x_1 : Opposite.unop x ⟶ a),
(((CategoryTheory.Bicategory.postcomposing₂ a b).obj f).app x).toFunctor.obj x_1 =
CategoryTheory.CategoryStruct.comp x_1 f |
ContFract.instCoeGenContFract | Mathlib.Algebra.ContinuedFractions.Basic | {α : Type u_1} → [inst : One α] → [inst_1 : Zero α] → [inst_2 : LT α] → Coe (ContFract α) (GenContFract α) |
CategoryTheory.MonoidalCategory.DayConvolutionUnit.noConfusion | Mathlib.CategoryTheory.Monoidal.DayConvolution | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{V : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} V} →
{inst_2 : CategoryTheory.MonoidalCategory C} →
{inst_3 : CategoryTheory.MonoidalCategory V} →
{F : CategoryTheory.Functor C V} →
{t : CategoryTheory.MonoidalCategory.DayConvolutionUnit F} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{V' : Type u₂} →
{inst'_1 : CategoryTheory.Category.{v₂, u₂} V'} →
{inst'_2 : CategoryTheory.MonoidalCategory C'} →
{inst'_3 : CategoryTheory.MonoidalCategory V'} →
{F' : CategoryTheory.Functor C' V'} →
{t' : CategoryTheory.MonoidalCategory.DayConvolutionUnit F'} →
C = C' →
inst ≍ inst' →
V = V' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
F ≍ F' →
t ≍ t' →
CategoryTheory.MonoidalCategory.DayConvolutionUnit.noConfusionType P t
t' |
Nat.range_nth_of_infinite | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop}, (setOf p).Infinite → Set.range (Nat.nth p) = setOf p |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_filter_iff._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (p : α → Bool) (x : Option α), (Option.any p x = true) = ∃ y, x = some y ∧ p y = true |
LinearMap.toMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {M₂ : Type u_2} [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂],
SMulCommClass R R M₂ |
continuous_iff_ultrafilter | Mathlib.Topology.Ultrafilter | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f ↔ ∀ (x : X) (g : Ultrafilter X), ↑g ≤ nhds x → Filter.Tendsto f (↑g) (nhds (f x)) |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Attr.0.Lean.Elab.Tactic.BVDecide.Frontend.elabBVDecideConfig.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.Attr | (motive :
DoResultPR Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig
PUnit.{1} →
Sort u_1) →
(r :
DoResultPR Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig
PUnit.{1}) →
((a : Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) →
motive r |
NumberField.Units.regOfFamily_div_regulator | Mathlib.NumberTheory.NumberField.Units.Regulator | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(u : Fin (NumberField.Units.rank K) → (NumberField.RingOfIntegers K)ˣ),
NumberField.Units.regOfFamily u / NumberField.Units.regulator K =
↑(Subgroup.closure (Set.range u) ⊔ NumberField.Units.torsion K).index |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.comp.match_1.eq_4 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1}
(motive : CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → Sort u_2)
(x : CategoryTheory.WithTerminal C) (_Y : C)
(h_1 :
(_X _Y _Z : C) →
motive (CategoryTheory.WithTerminal.of _X) (CategoryTheory.WithTerminal.of _Y)
(CategoryTheory.WithTerminal.of _Z))
(h_2 :
(_X : C) →
(x : CategoryTheory.WithTerminal C) →
motive (CategoryTheory.WithTerminal.of _X) x CategoryTheory.WithTerminal.star)
(h_3 :
(_X : C) →
(x : CategoryTheory.WithTerminal C) →
motive CategoryTheory.WithTerminal.star (CategoryTheory.WithTerminal.of _X) x)
(h_4 :
(x : CategoryTheory.WithTerminal C) →
(_Y : C) → motive x CategoryTheory.WithTerminal.star (CategoryTheory.WithTerminal.of _Y))
(h_5 :
Unit → motive CategoryTheory.WithTerminal.star CategoryTheory.WithTerminal.star CategoryTheory.WithTerminal.star),
(match x, CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.of _Y with
| CategoryTheory.WithTerminal.of _X, CategoryTheory.WithTerminal.of _Y, CategoryTheory.WithTerminal.of _Z =>
h_1 _X _Y _Z
| CategoryTheory.WithTerminal.of _X, x, CategoryTheory.WithTerminal.star => h_2 _X x
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.of _X, x => h_3 _X x
| x, CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.of _Y => h_4 x _Y
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star => h_5 ()) =
h_4 x _Y |
NNReal.exists_pow_lt_of_lt_one | Mathlib.Data.NNReal.Defs | ∀ {a b : NNReal}, 0 < a → b < 1 → ∃ n, b ^ n < a |
IsFractionRing.isAlgebraic_iff | Mathlib.RingTheory.Localization.Integral | ∀ (A : Type u_3) (K : Type u_4) (C : Type u_5) [inst : CommRing A] [IsDomain A] [inst_2 : Field K]
[inst_3 : Algebra A K] [IsFractionRing A K] [inst_5 : CommRing C] [inst_6 : Algebra A C] [inst_7 : Algebra K C]
[IsScalarTower A K C] {x : C}, IsAlgebraic A x ↔ IsAlgebraic K x |
Quiver.Path.length_eq_zero_iff._simp_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {V : Type u_1} [inst : Quiver V] {a : V} (p : Quiver.Path a a), (p.length = 0) = (p = Quiver.Path.nil) |
Sym2.IsDiag._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x x_1 : α), (x = x_1) = (x_1 = x) |
idRestrGroupoid._proof_3 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H],
∃ s, ∃ (h : IsOpen s), OpenPartialHomeomorph.refl H ≈ OpenPartialHomeomorph.ofSet s h |
BitVec.ushiftRight_eq_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ}, w ≤ n → x >>> n = 0#w |
_private.Mathlib.Tactic.Abel.0.Mathlib.Tactic.Abel.eval._sparseCasesOn_5 | Mathlib.Tactic.Abel | {motive : Lean.Literal → Sort u} →
(t : Lean.Literal) →
((val : ℕ) → motive (Lean.Literal.natVal val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
isSaddlePointOn_value | Mathlib.Order.SaddlePoint | ∀ {E : Type u_1} {F : Type u_2} {β : Type u_3} {X : Set E} {Y : Set F} {f : E → F → β} [inst : CompleteLinearOrder β]
{a : E},
a ∈ X →
∀ {b : F}, b ∈ Y → IsSaddlePointOn X Y f a b → ⨅ x ∈ X, ⨆ y ∈ Y, f x y = f a b ∧ ⨆ y ∈ Y, ⨅ x ∈ X, f x y = f a b |
PrimeSpectrum.BasicConstructibleSetData.mk.sizeOf_spec | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} [inst : SizeOf R] (f : R) (n : ℕ) (g : Fin n → R),
sizeOf { f := f, n := n, g := g } = 1 + sizeOf f + sizeOf n |
Fin.image_succ_Ioc | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.succ '' Set.Ioc i j = Set.Ioc i.succ j.succ |
_private.Mathlib.NumberTheory.ModularForms.Delta.0.ModularForm.logDeriv_eta_comp_eq_logDeriv_csqrt_eta._proof_1_10 | Mathlib.NumberTheory.ModularForms.Delta | (1 + 1).AtLeastTwo |
_private.Init.Data.String.Slice.0.String.Slice.eqIgnoreAsciiCase.go._unary._proof_2 | Init.Data.String.Slice | ∀ (s1 s2 : String.Slice) (s1Curr s2Curr : String.Pos.Raw),
s1Curr < s1.rawEndPos ∧ s2Curr < s2.rawEndPos → s2Curr < s2.rawEndPos |
StieltjesFunction.instModuleNNReal._proof_1 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (c : NNReal) (f : StieltjesFunction R),
Monotone fun x => ↑c * ↑f x |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone.0.NumberField.mixedEmbedding.fundamentalCone.mem_integerSet._simp_1_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) |
AddValuation.map_lt_sum | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{ι : Type u_6} {s : Finset ι} {f : ι → R} {g : Γ₀}, g ≠ ⊤ → (∀ i ∈ s, g < v (f i)) → g < v (∑ i ∈ s, f i) |
UInt16.toUInt8_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ},
UInt16.size ≤ n →
(UInt16.ofNatTruncate n).toUInt8 = UInt8.ofNatLT (UInt8.size - 1) UInt16.toUInt8_ofNatTruncate_of_le._proof_1 |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.adj_incidenceSet_inter._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {α : Type u} {s : Set α} {p : α → Prop} {x : α}, (x ∈ {x | x ∈ s ∧ p x}) = (x ∈ s ∧ p x) |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.isStarProjection_iff_eq_starProjection_range._simp_1_2 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {f g : M₁ →SL[σ₁₂] M₂},
(↑f = ↑g) = (f = g) |
Filter.tendsto_div_const_atBot_iff | Mathlib.Order.Filter.AtTopBot.Field | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {l : Filter β}
{f : β → α} {r : α} [l.NeBot],
Filter.Tendsto (fun x => f x / r) l Filter.atBot ↔
0 < r ∧ Filter.Tendsto f l Filter.atBot ∨ r < 0 ∧ Filter.Tendsto f l Filter.atTop |
Subgroup.ofUnitsEquivType._proof_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Subgroup Mˣ) (x : ↥S.ofUnits), ↑x ∈ S.ofUnits |
Lean.Meta.Grind.SplitStatus.ready | Lean.Meta.Tactic.Grind.Split | ℕ → optParam Bool false → optParam Bool false → Lean.Meta.Grind.SplitStatus |
Lean.Export.Entry.ctorIdx | Mathlib.Util.Export | Lean.Export.Entry → ℕ |
tprod_setProd_singleton_right | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] (s : Set β) (c : γ)
(f : β × γ → α), ∏' (x : ↑(s ×ˢ {c})), f ↑x = ∏' (b : ↑s), f (↑b, c) |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.Data.Atom.mk.injEq | Lean.Elab.DocString.Builtin.Keywords | ∀ (name category name_1 category_1 : Lean.Name),
({ name := name, category := category } = { name := name_1, category := category_1 }) =
(name = name_1 ∧ category = category_1) |
LieSubmodule.normalizer._proof_3 | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [LieModule R L M]
(N : LieSubmodule R L M) (t : R), ∀ m ∈ {m | ∀ (x : L), ⁅x, m⁆ ∈ N}, ∀ (x : L), ⁅x, t • m⁆ ∈ N |
Lean.Meta.Grind.TopSort.State._sizeOf_1 | Lean.Meta.Tactic.Grind.EqResolution | Lean.Meta.Grind.TopSort.State → ℕ |
Equiv.subtypeProdEquivProd._proof_3 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {q : β → Prop} (x : { c // p c.1 ∧ q c.2 }), p (↑x).1 |
LinearMap.toContinuousLinearMap.congr_simp | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : IsTopologicalAddGroup F']
[inst_9 : ContinuousSMul 𝕜 F'] [inst_10 : CompleteSpace 𝕜] [inst_11 : T2Space E] [inst_12 : FiniteDimensional 𝕜 E],
LinearMap.toContinuousLinearMap = LinearMap.toContinuousLinearMap |
Lean.Compiler.LCNF.NormLevelParam.State.noConfusion | Lean.Compiler.LCNF.Level | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.NormLevelParam.State} →
t = t' → Lean.Compiler.LCNF.NormLevelParam.State.noConfusionType P t t' |
List.zipWithLeft'TR.go._unsafe_rec | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (α → Option β → γ) → List α → List β → Array γ → List γ × List β |
IO.FS.realPath | Init.System.IO | System.FilePath → IO System.FilePath |
ShrinkingLemma.PartialRefinement.rec | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
{motive : ShrinkingLemma.PartialRefinement u s p → Sort u} →
((toFun : ι → Set X) →
(carrier : Set ι) →
(isOpen : ∀ (i : ι), IsOpen (toFun i)) →
(subset_iUnion : s ⊆ ⋃ i, toFun i) →
(closure_subset : ∀ {i : ι}, i ∈ carrier → closure (toFun i) ⊆ u i) →
(pred_of_mem : ∀ {i : ι}, i ∈ carrier → p (toFun i)) →
(apply_eq : ∀ {i : ι}, i ∉ carrier → toFun i = u i) →
motive
{ toFun := toFun, carrier := carrier, isOpen := isOpen, subset_iUnion := subset_iUnion,
closure_subset := closure_subset, pred_of_mem := pred_of_mem,
apply_eq := apply_eq }) →
(t : ShrinkingLemma.PartialRefinement u s p) → motive t |
SimpleGraph.IsMatchingFree | Mathlib.Combinatorics.SimpleGraph.Matching | {V : Type u_1} → SimpleGraph V → Prop |
WeierstrassCurve.Jacobian.negY_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} (X Y Z : R),
W'.negY ![X, Y, Z] = -Y - W'.a₁ * X * Z - W'.a₃ * Z ^ 3 |
invertibleSucc | Mathlib.Algebra.CharP.Invertible | {K : Type u_2} → [inst : DivisionSemiring K] → [CharZero K] → (n : ℕ) → Invertible ↑n.succ |
ContinuousMultilinearMap.iteratedFDerivComponent._proof_3 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_5} {ι : Type u_1} {E₁ : ι → Type u_4} {G : Type u_2} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E₁ i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E₁ i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] {α : Type u_3}
[inst_6 : Fintype α] (f : ContinuousMultilinearMap 𝕜 E₁ G) {s : Set ι} (e : α ≃ ↑s)
[inst_7 : DecidablePred fun x => x ∈ s] (m₁ : (i : { a // a ∉ s }) → E₁ ↑i) (m₂ : α → (i : ι) → E₁ i),
‖((f.iteratedFDerivComponent e) m₁) m₂‖ ≤ (‖f‖ * ∏ i, ‖m₁ i‖) * ∏ i, ‖m₂ i‖ |
List.getElem_modifyHead._proof_3 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {l : List α} {f : α → α} {i : ℕ}, i < (List.modifyHead f l).length → i < l.length |
Lean.Doc.instFromDocArgMessageSeverity | Lean.Elab.DocString | Lean.Doc.FromDocArg Lean.MessageSeverity |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_505 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
List.head_attach | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α} (h : xs.attach ≠ []), xs.attach.head h = ⟨xs.head ⋯, ⋯⟩ |
_private.Mathlib.NumberTheory.LSeries.AbstractFuncEq.0.WeakFEPair.f_modif_aux2._simp_1_1 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {α : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : SMulZeroClass R M] (s : Set α) (r : α → R)
(f : α → M), (fun a => r a • s.indicator f a) = s.indicator fun a => r a • f a |
_private.Mathlib.Order.KrullDimension.0.Order.exists_series_of_le_height._proof_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} (m : ℕ) (p : LTSeries α), p.length = m → n < m → m - n < p.length + 1 |
Subalgebra.coe_pi | Mathlib.Algebra.Algebra.Subalgebra.Pi | ∀ {ι : Type u_1} {R : Type u_2} {S : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → Semiring (S i)]
[inst_2 : (i : ι) → Algebra R (S i)] (s : Set ι) (t : (i : ι) → Subalgebra R (S i)),
↑(Subalgebra.pi s t) = (Submodule.pi s fun i => Subalgebra.toSubmodule (t i)).carrier |
FinEnum.PSigma.finEnumPropProp._proof_3 | Mathlib.Data.FinEnum | ∀ {α : Prop} {β : α → Prop}, (∃ (a : α), β a) → α |
RealRMK.le_rieszMeasure_tsupport_subset | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] [inst_2 : MeasurableSpace X] [inst_3 : BorelSpace X]
(Λ : CompactlySupportedContinuousMap X ℝ →ₚ[ℝ] ℝ) [inst_4 : LocallyCompactSpace X]
{f : CompactlySupportedContinuousMap X ℝ},
(∀ (x : X), 0 ≤ f x ∧ f x ≤ 1) → ∀ {V : Set X}, tsupport ⇑f ⊆ V → ENNReal.ofReal (Λ f) ≤ (RealRMK.rieszMeasure Λ) V |
MeasureTheory.AEStronglyMeasurable.mono_set | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} {s t : Set α},
s ⊆ t → MeasureTheory.AEStronglyMeasurable f (μ.restrict t) → MeasureTheory.AEStronglyMeasurable f (μ.restrict s) |
Matrix.discr_fin_two | Mathlib.LinearAlgebra.Matrix.Charpoly.Disc | ∀ {R : Type u_1} [inst : CommRing R] (A : Matrix (Fin 2) (Fin 2) R), A.discr = A.trace ^ 2 - 4 * A.det |
Seminorm.comp_smul | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {𝕜₂ : Type u_4} {E : Type u_7} {E₂ : Type u_8} [inst : SeminormedRing 𝕜]
[inst_1 : SeminormedCommRing 𝕜₂] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_2 : RingHomIsometric σ₁₂] [inst_3 : AddCommGroup E]
[inst_4 : AddCommGroup E₂] [inst_5 : Module 𝕜 E] [inst_6 : Module 𝕜₂ E₂] (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂)
(c : 𝕜₂), p.comp (c • f) = ‖c‖₊ • p.comp f |
Lean.Widget.RpcEncodablePacket.leanTags?._@.Lean.Widget.InteractiveDiagnostic.2989700264._hygCtx._hyg.2 | Lean.Widget.InteractiveDiagnostic | Lean.Widget.RpcEncodablePacket✝ → Option Lean.Json |
AffineEquiv.ofBijective_apply | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] {φ : P₁ →ᵃ[k] P₂} (hφ : Function.Bijective ⇑φ) (a : P₁),
(AffineEquiv.ofBijective hφ) a = φ a |
Polynomial.powAddExpansion | Mathlib.Algebra.Polynomial.Identities | {R : Type u_1} →
[inst : CommSemiring R] → (x y : R) → (n : ℕ) → { k // (x + y) ^ n = x ^ n + ↑n * x ^ (n - 1) * y + k * y ^ 2 } |
Set.mulIndicator_le' | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Type u_2} {M : Type u_3} [inst : LE M] [inst_1 : One M] {s : Set α} {f g : α → M},
(∀ a ∈ s, f a ≤ g a) → (∀ a ∉ s, 1 ≤ g a) → s.mulIndicator f ≤ g |
_private.Mathlib.Dynamics.PeriodicPts.Defs.0.Function.periodicOrbit_eq_nil_iff_not_periodic_pt._simp_1_4 | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {n : ℕ}, (List.range n = []) = (n = 0) |
IsSimpleOrder.eq_bot_or_eq_top | Mathlib.Order.Atoms | ∀ {α : Type u_4} {inst : LE α} {inst_1 : BoundedOrder α} [self : IsSimpleOrder α] (a : α), a = ⊥ ∨ a = ⊤ |
Lean.instNonemptyKeyedDeclsAttribute | Lean.KeyedDeclsAttribute | ∀ {γ : Type}, Nonempty (Lean.KeyedDeclsAttribute γ) |
Lean.Server.Test.Runner.Client.instToJsonHighlightMatchesParams.toJson | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.HighlightMatchesParams → Lean.Json |
_private.Mathlib.Topology.Order.Basic.0.exists_countable_generateFrom_Ioi_Iio._simp_1_2 | Mathlib.Topology.Order.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
(∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.val_step_filterMap.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {γ : Type u_1} (motive : Option γ → Sort u_2) (h_1 : Unit → motive none) (h_2 : (out' : γ) → motive (some out')),
(match none with
| none => h_1 ()
| some out' => h_2 out') =
h_1 () |
instLawfulMonadContOptionT | Mathlib.Control.Monad.Cont | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : MonadCont m] [LawfulMonadCont m], LawfulMonadCont (OptionT m) |
_private.Lean.Meta.Tactic.Grind.Order.StructId.0.Lean.Meta.Grind.Order.getInst? | Lean.Meta.Tactic.Grind.Order.StructId | Lean.Name → Lean.Level → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) |
«term_ᵈᵃᵃ» | Mathlib.GroupTheory.GroupAction.DomAct.Basic | Lean.TrailingParserDescr |
Std.DTreeMap.Internal.Impl.getEntryGE?ₘ'.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.getEntryGE?ₘ' k t =
Std.DTreeMap.Internal.Impl.explore (compare k) none
(fun x x_1 =>
match x, x_1 with
| x, Std.DTreeMap.Internal.Impl.ExplorationStep.lt k' a v a_1 => some ⟨k', v⟩
| base, Std.DTreeMap.Internal.Impl.ExplorationStep.eq a c r => (c.inner.or r.head?).or base
| base, Std.DTreeMap.Internal.Impl.ExplorationStep.gt a a_1 a_2 a_3 => base)
t |
_private.Lean.Elab.PreDefinition.WF.Preprocess.0._regBuiltin.Lean.Elab.WF.paramProj.declare_26._@.Lean.Elab.PreDefinition.WF.Preprocess.184633683._hygCtx._hyg.12 | Lean.Elab.PreDefinition.WF.Preprocess | IO Unit |
Lean.ExternEntry.adhoc.sizeOf_spec | Lean.Compiler.ExternAttr | ∀ (backend : Lean.Name), sizeOf (Lean.ExternEntry.adhoc backend) = 1 + sizeOf backend |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_inter_of_contains_eq_false_left._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
LocallyConstant.mulIndicator_apply | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {R : Type u_5} [inst_1 : One R] {U : Set X} (f : LocallyConstant X R)
(hU : IsClopen U) (x : X), (f.mulIndicator hU) x = U.mulIndicator (⇑f) x |
MeasureTheory.FiniteMeasure.map_prod_map | Mathlib.MeasureTheory.Measure.FiniteMeasureProd | ∀ {α : Type u_1} [inst : MeasurableSpace α] {β : Type u_2} [inst_1 : MeasurableSpace β]
(μ : MeasureTheory.FiniteMeasure α) (ν : MeasureTheory.FiniteMeasure β) {α' : Type u_3} [inst_2 : MeasurableSpace α']
{β' : Type u_4} [inst_3 : MeasurableSpace β'] {f : α → α'} {g : β → β'},
Measurable f → Measurable g → (μ.map f).prod (ν.map g) = (μ.prod ν).map (Prod.map f g) |
_private.Mathlib.Data.Fintype.Sets.0.Set.disjoint_toFinset._simp_1_1 | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = Disjoint ↑s ↑t |
List.length_eraseIdx | Init.Data.List.Erase | ∀ {α : Type u_1} {l : List α} {i : ℕ}, (l.eraseIdx i).length = if i < l.length then l.length - 1 else l.length |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.liftFromUnderComp.match_1.eq_1 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {J : Type u_1} (motive : CategoryTheory.WithInitial J → Sort u_2)
(h_1 : Unit → motive CategoryTheory.WithInitial.star) (h_2 : (a : J) → motive (CategoryTheory.WithInitial.of a)),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.star => h_1 ()
| CategoryTheory.WithInitial.of a => h_2 a) =
h_1 () |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.