From 110b734ba43cfbbb1f1d84e4bb1602f15091d1f2 Mon Sep 17 00:00:00 2001 From: leanprover-community-bot Date: Sun, 21 May 2023 16:58:10 +0000 Subject: [PATCH] bump to nightly-2023-05-21-16 mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952 --- Mathbin/Algebra/Category/Group/Limits.lean | 94 +++- Mathbin/Algebra/CharP/MixedCharZero.lean | 194 +++++++-- Mathbin/Algebra/Group/Units.lean | 2 +- .../Constructions/BorelSpace/Complex.lean | 12 + Mathbin/MeasureTheory/Function/EssSup.lean | 232 ++++++++++ .../GradedAlgebra/HomogeneousIdeal.lean | 412 +++++++++++++++++- lake-manifest.json | 8 +- lakefile.lean | 4 +- 8 files changed, 886 insertions(+), 72 deletions(-) diff --git a/Mathbin/Algebra/Category/Group/Limits.lean b/Mathbin/Algebra/Category/Group/Limits.lean index 79882b3c27..f263fc5bd7 100644 --- a/Mathbin/Algebra/Category/Group/Limits.lean +++ b/Mathbin/Algebra/Category/Group/Limits.lean @@ -35,6 +35,12 @@ variable {J : Type v} [SmallCategory J] namespace GroupCat +/- warning: Group.group_obj -> GroupCat.groupObj is a dubious translation: +lean 3 declaration is + forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2}) (j : J), Group.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} GroupCat.concreteCategory.{max u1 u2})) j) +but is expected to have type + forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 GroupCatMax.{u1, u2} instGroupCatLargeCategory.{max u2 u1}) (j : J), Group.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 GroupCatMax.{u1, u2} instGroupCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{succ (max u2 u1), max u2 u1, max u2 u1} GroupCat.{max u2 u1} instGroupCatLargeCategory.{max u2 u1} GroupCat.concreteCategory.{max u2 u1}))) j) +Case conversion may be inaccurate. Consider using '#align Group.group_obj GroupCat.groupObjₓ'. -/ @[to_additive] instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget GroupCat).obj j) := by @@ -43,6 +49,12 @@ instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget Grou #align Group.group_obj GroupCat.groupObj #align AddGroup.add_group_obj AddGroupCat.addGroupObj +/- warning: Group.sections_subgroup -> GroupCat.sectionsSubgroup is a dubious translation: +lean 3 declaration is + forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2}), Subgroup.{max u1 u2} (forall (j : J), coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} GroupCat.{max u1 u2} Type.{max u1 u2} GroupCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F j)) (Pi.group.{u1, max u1 u2} J (fun (j : J) => coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} GroupCat.{max u1 u2} Type.{max u1 u2} GroupCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F j)) (fun (i : J) => GroupCat.group.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F i))) +but is expected to have type + forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2}), Subgroup.{max u1 u2} (forall (j : J), CategoryTheory.Bundled.α.{max u1 u2, max u1 u2} Group.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) j)) (Pi.group.{u1, max u1 u2} J (fun (j : J) => CategoryTheory.Bundled.α.{max u1 u2, max u1 u2} Group.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) j)) (fun (i : J) => GroupCat.instGroupα.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) i))) +Case conversion may be inaccurate. Consider using '#align Group.sections_subgroup GroupCat.sectionsSubgroupₓ'. -/ /-- The flat sections of a functor into `Group` form a subgroup of all sections. -/ @[to_additive @@ -61,6 +73,7 @@ def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) := #align Group.sections_subgroup GroupCat.sectionsSubgroup #align AddGroup.sections_add_subgroup AddGroupCat.sectionsAddSubgroup +#print GroupCat.limitGroup /- @[to_additive] instance limitGroup (F : J ⥤ GroupCat.{max v u}) : Group (Types.limitCone (F ⋙ forget GroupCat)).pt := @@ -69,7 +82,9 @@ instance limitGroup (F : J ⥤ GroupCat.{max v u}) : infer_instance #align Group.limit_group GroupCat.limitGroup #align AddGroup.limit_add_group AddGroupCat.limitAddGroup +-/ +#print GroupCat.Forget₂.createsLimit /- /-- We show that the forgetful functor `Group ⥤ Mon` creates limits. All we need to do is notice that the limit point has a `group` instance available, and then reuse @@ -92,7 +107,9 @@ instance Forget₂.createsLimit (F : J ⥤ GroupCat.{max v u}) : (fun s => _) fun s => rfl } #align Group.forget₂.creates_limit GroupCat.Forget₂.createsLimit #align AddGroup.forget₂.creates_limit AddGroupCat.Forget₂.createsLimit +-/ +#print GroupCat.limitCone /- /-- A choice of limit cone for a functor into `Group`. (Generally, you'll just want to use `limit F`.) -/ @@ -102,7 +119,9 @@ def limitCone (F : J ⥤ GroupCat.{max v u}) : Cone F := liftLimit (limit.isLimit (F ⋙ forget₂ GroupCat MonCat.{max v u})) #align Group.limit_cone GroupCat.limitCone #align AddGroup.limit_cone AddGroupCat.limitCone +-/ +#print GroupCat.limitConeIsLimit /- /-- The chosen cone is a limit cone. (Generally, you'll just want to use `limit.cone F`.) -/ @@ -112,7 +131,9 @@ def limitConeIsLimit (F : J ⥤ GroupCat.{max v u}) : IsLimit (limitCone F) := liftedLimitIsLimit _ #align Group.limit_cone_is_limit GroupCat.limitConeIsLimit #align AddGroup.limit_cone_is_limit AddGroupCat.limitConeIsLimit +-/ +#print GroupCat.hasLimitsOfSize /- /-- The category of groups has all limits. -/ @[to_additive "The category of additive groups has all limits."] instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCat.{max v u} @@ -120,13 +141,17 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCat.{max v u} { HasLimit := fun F => has_limit_of_created F (forget₂ GroupCat MonCat.{max v u}) } #align Group.has_limits_of_size GroupCat.hasLimitsOfSize #align AddGroup.has_limits_of_size AddGroupCat.hasLimitsOfSize +-/ +#print GroupCat.hasLimits /- @[to_additive] instance hasLimits : HasLimits GroupCat.{u} := GroupCat.hasLimitsOfSize.{u, u} #align Group.has_limits GroupCat.hasLimits #align AddGroup.has_limits AddGroupCat.hasLimits +-/ +#print GroupCat.forget₂MonPreservesLimitsOfSize /- /-- The forgetful functor from groups to monoids preserves all limits. This means the underlying monoid of a limit can be computed as a limit in the category of monoids. @@ -138,13 +163,17 @@ instance forget₂MonPreservesLimitsOfSize : where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance } #align Group.forget₂_Mon_preserves_limits_of_size GroupCat.forget₂MonPreservesLimitsOfSize #align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂AddMonPreservesLimits +-/ +#print GroupCat.forget₂MonPreservesLimits /- @[to_additive] instance forget₂MonPreservesLimits : PreservesLimits (forget₂ GroupCat MonCat.{u}) := GroupCat.forget₂MonPreservesLimitsOfSize.{u, u} #align Group.forget₂_Mon_preserves_limits GroupCat.forget₂MonPreservesLimits #align AddGroup.forget₂_Mon_preserves_limits AddGroupCat.forget₂MonPreservesLimits +-/ +#print GroupCat.forgetPreservesLimitsOfSize /- /-- The forgetful functor from groups to types preserves all limits. This means the underlying type of a limit can be computed as a limit in the category of types. -/ @@ -157,17 +186,26 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Grou limits.comp_preserves_limit (forget₂ GroupCat MonCat) (forget MonCat) } #align Group.forget_preserves_limits_of_size GroupCat.forgetPreservesLimitsOfSize #align AddGroup.forget_preserves_limits_of_size AddGroupCat.forgetPreservesLimitsOfSize +-/ +#print GroupCat.forgetPreservesLimits /- @[to_additive] instance forgetPreservesLimits : PreservesLimits (forget GroupCat.{u}) := GroupCat.forgetPreservesLimitsOfSize.{u, u} #align Group.forget_preserves_limits GroupCat.forgetPreservesLimits #align AddGroup.forget_preserves_limits AddGroupCat.forgetPreservesLimits +-/ end GroupCat namespace CommGroupCat +/- warning: CommGroup.comm_group_obj -> CommGroupCat.commGroupObj is a dubious translation: +lean 3 declaration is + forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2}) (j : J), CommGroup.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2})) j) +but is expected to have type + forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1}) (j : J), CommGroup.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1}))) j) +Case conversion may be inaccurate. Consider using '#align CommGroup.comm_group_obj CommGroupCat.commGroupObjₓ'. -/ @[to_additive] instance commGroupObj (F : J ⥤ CommGroupCat.{max v u}) (j) : CommGroup ((F ⋙ forget CommGroupCat).obj j) := @@ -177,6 +215,7 @@ instance commGroupObj (F : J ⥤ CommGroupCat.{max v u}) (j) : #align CommGroup.comm_group_obj CommGroupCat.commGroupObj #align AddCommGroup.add_comm_group_obj AddCommGroupCat.addCommGroupObj +#print CommGroupCat.limitCommGroup /- @[to_additive] instance limitCommGroup (F : J ⥤ CommGroupCat.{max v u}) : CommGroup (Types.limitCone (F ⋙ forget CommGroupCat.{max v u})).pt := @@ -184,7 +223,9 @@ instance limitCommGroup (F : J ⥤ CommGroupCat.{max v u}) : (GroupCat.sectionsSubgroup (F ⋙ forget₂ CommGroupCat GroupCat.{max v u})) #align CommGroup.limit_comm_group CommGroupCat.limitCommGroup #align AddCommGroup.limit_add_comm_group AddCommGroupCat.limitAddCommGroup +-/ +#print CommGroupCat.Forget₂.createsLimit /- /-- We show that the forgetful functor `CommGroup ⥤ Group` creates limits. All we need to do is notice that the limit point has a `comm_group` instance available, @@ -208,7 +249,9 @@ instance Forget₂.createsLimit (F : J ⥤ CommGroupCat.{max v u}) : (by apply MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl } #align CommGroup.forget₂.creates_limit CommGroupCat.Forget₂.createsLimit #align AddCommGroup.forget₂.creates_limit AddCommGroupCat.Forget₂.createsLimit +-/ +#print CommGroupCat.limitCone /- /-- A choice of limit cone for a functor into `CommGroup`. (Generally, you'll just want to use `limit F`.) -/ @@ -218,7 +261,9 @@ def limitCone (F : J ⥤ CommGroupCat.{max v u}) : Cone F := liftLimit (limit.isLimit (F ⋙ forget₂ CommGroupCat GroupCat.{max v u})) #align CommGroup.limit_cone CommGroupCat.limitCone #align AddCommGroup.limit_cone AddCommGroupCat.limitCone +-/ +#print CommGroupCat.limitConeIsLimit /- /-- The chosen cone is a limit cone. (Generally, you'll just want to use `limit.cone F`.) -/ @@ -228,7 +273,9 @@ def limitConeIsLimit (F : J ⥤ CommGroupCat.{max v u}) : IsLimit (limitCone F) liftedLimitIsLimit _ #align CommGroup.limit_cone_is_limit CommGroupCat.limitConeIsLimit #align AddCommGroup.limit_cone_is_limit AddCommGroupCat.limitConeIsLimit +-/ +#print CommGroupCat.hasLimitsOfSize /- /-- The category of commutative groups has all limits. -/ @[to_additive "The category of additive commutative groups has all limits."] instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommGroupCat.{max v u} @@ -236,31 +283,44 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommGroupCat.{max v u} { HasLimit := fun F => has_limit_of_created F (forget₂ CommGroupCat GroupCat.{max v u}) } #align CommGroup.has_limits_of_size CommGroupCat.hasLimitsOfSize #align AddCommGroup.has_limits_of_size AddCommGroupCat.hasLimitsOfSize +-/ +#print CommGroupCat.hasLimits /- @[to_additive] instance hasLimits : HasLimits CommGroupCat.{u} := CommGroupCat.hasLimitsOfSize.{u, u} #align CommGroup.has_limits CommGroupCat.hasLimits #align AddCommGroup.has_limits AddCommGroupCat.hasLimits +-/ +#print CommGroupCat.forget₂GroupPreservesLimitsOfSize /- /-- The forgetful functor from commutative groups to groups preserves all limits. (That is, the underlying group could have been computed instead as limits in the category of groups.) -/ -@[to_additive AddCommGroupCat.forget₂AddGroupPreservesLimits +@[to_additive AddCommGroupCat.forget₂AddGroupPreservesLimitsOfSize "The forgetful functor from additive commutative groups to groups preserves all limits.\n(That is, the underlying group could have been computed instead as limits in the category\nof additive groups.)"] instance forget₂GroupPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat GroupCat.{max v u}) where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance } #align CommGroup.forget₂_Group_preserves_limits_of_size CommGroupCat.forget₂GroupPreservesLimitsOfSize -#align AddCommGroup.forget₂_AddGroup_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimits +#align AddCommGroup.forget₂_AddGroup_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimitsOfSize +-/ +#print CommGroupCat.forget₂GroupPreservesLimits /- @[to_additive] instance forget₂GroupPreservesLimits : PreservesLimits (forget₂ CommGroupCat GroupCat.{u}) := CommGroupCat.forget₂GroupPreservesLimitsOfSize.{u, u} #align CommGroup.forget₂_Group_preserves_limits CommGroupCat.forget₂GroupPreservesLimits -#align AddCommGroup.forget₂_Group_preserves_limits AddCommGroupCat.forget₂GroupPreservesLimits +#align AddCommGroup.forget₂_Group_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimits +-/ +/- warning: CommGroup.forget₂_CommMon_preserves_limits_aux -> CommGroupCat.forget₂CommMonPreservesLimitsAux is a dubious translation: +lean 3 declaration is + forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2}), CategoryTheory.Limits.IsLimit.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} F (CategoryTheory.forget₂.{succ (max u1 u2), succ (max u1 u2), max u1 u2, max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommMonCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} CommMonCat.concreteCategory.{max u1 u2} CommGroupCat.hasForgetToCommMonCat.{max u1 u2})) (CategoryTheory.Functor.mapCone.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} F (CategoryTheory.forget₂.{succ (max u1 u2), succ (max u1 u2), max u1 u2, max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommMonCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} CommMonCat.concreteCategory.{max u1 u2} CommGroupCat.hasForgetToCommMonCat.{max u1 u2}) (CommGroupCat.limitCone.{u1, u2} J _inst_1 F)) +but is expected to have type + forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1}), CategoryTheory.Limits.IsLimit.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} F (CategoryTheory.forget₂.{max (succ u2) (succ u1), succ (max u2 u1), max u2 u1, max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} CommMonCat.{max u2 u1} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} CommMonCat.concreteCategory.{max u2 u1} CommGroupCat.hasForgetToCommMonCat.{max u2 u1})) (CategoryTheory.Functor.mapCone.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} (CategoryTheory.forget₂.{max (succ u2) (succ u1), succ (max u2 u1), max u2 u1, max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} CommMonCat.{max u2 u1} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} CommMonCat.concreteCategory.{max u2 u1} CommGroupCat.hasForgetToCommMonCat.{max u2 u1}) F (CommGroupCat.limitCone.{u1, u2} J _inst_1 F)) +Case conversion may be inaccurate. Consider using '#align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAuxₓ'. -/ /-- An auxiliary declaration to speed up typechecking. -/ @[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux @@ -271,6 +331,7 @@ def forget₂CommMonPreservesLimitsAux (F : J ⥤ CommGroupCat.{max v u}) : #align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAux #align AddCommGroup.forget₂_AddCommMon_preserves_limits_aux AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux +#print CommGroupCat.forget₂CommMonPreservesLimitsOfSize /- /-- The forgetful functor from commutative groups to commutative monoids preserves all limits. (That is, the underlying commutative monoids could have been computed instead as limits in the category of commutative monoids.) @@ -286,7 +347,9 @@ instance forget₂CommMonPreservesLimitsOfSize : (forget₂_CommMon_preserves_limits_aux F) } #align CommGroup.forget₂_CommMon_preserves_limits_of_size CommGroupCat.forget₂CommMonPreservesLimitsOfSize #align AddCommGroup.forget₂_AddCommMon_preserves_limits AddCommGroupCat.forget₂AddCommMonPreservesLimits +-/ +#print CommGroupCat.forgetPreservesLimitsOfSize /- /-- The forgetful functor from commutative groups to types preserves all limits. (That is, the underlying types could have been computed instead as limits in the category of types.) -/ @@ -299,6 +362,7 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Comm limits.comp_preserves_limit (forget₂ CommGroupCat GroupCat) (forget GroupCat) } #align CommGroup.forget_preserves_limits_of_size CommGroupCat.forgetPreservesLimitsOfSize #align AddCommGroup.forget_preserves_limits AddCommGroupCat.forgetPreservesLimits +-/ -- Verify we can form limits indexed over smaller categories. example (f : ℕ → AddCommGroupCat) : HasProduct f := by infer_instance @@ -307,6 +371,12 @@ end CommGroupCat namespace AddCommGroupCat +/- warning: AddCommGroup.kernel_iso_ker -> AddCommGroupCat.kernelIsoKer is a dubious translation: +lean 3 declaration is + forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1})) G H), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) +but is expected to have type + forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1})) G H), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) +Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKerₓ'. -/ /-- The categorical kernel of a morphism in `AddCommGroup` agrees with the usual group-theoretical kernel. -/ @@ -337,11 +407,23 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) : kernel f ≅ AddCom simp #align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKer +/- warning: AddCommGroup.kernel_iso_ker_hom_comp_subtype -> AddCommGroupCat.kernelIsoKer_hom_comp_subtype is a dubious translation: +lean 3 declaration is + forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1})) G H), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1})) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1}) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G (CategoryTheory.Iso.hom.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) +but is expected to have type + forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1})) G H), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1})) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G (CategoryTheory.Iso.hom.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) +Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtypeₓ'. -/ @[simp] theorem kernelIsoKer_hom_comp_subtype {G H : AddCommGroupCat} (f : G ⟶ H) : (kernelIsoKer f).Hom ≫ AddSubgroup.subtype f.ker = kernel.ι f := by ext <;> rfl #align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtype +/- warning: AddCommGroup.kernel_iso_ker_inv_comp_ι -> AddCommGroupCat.kernelIsoKer_inv_comp_ι is a dubious translation: +lean 3 declaration is + forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1})) G H), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1})) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1}) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) G (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f))) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) +but is expected to have type + forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1})) G H), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1})) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1}) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) G (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f))) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) +Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ιₓ'. -/ @[simp] theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) : (kernelIsoKer f).inv ≫ kernel.ι f = AddSubgroup.subtype f.ker := @@ -350,6 +432,12 @@ theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) : simp [kernel_iso_ker] #align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ι +/- warning: AddCommGroup.kernel_iso_ker_over -> AddCommGroupCat.kernelIsoKerOver is a dubious translation: +lean 3 declaration is + forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1})) G H), CategoryTheory.Iso.{u1, succ u1} (CategoryTheory.Over.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G) (CategoryTheory.Over.category.{succ u1, u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKerOver._proof_1.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H f (AddCommGroupCat.kernelIsoKerOver._proof_2.{u1} G H f))) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) +but is expected to have type + forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1})) G H), CategoryTheory.Iso.{u1, succ u1} (CategoryTheory.Over.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G) (CategoryTheory.instCategoryOver.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f))) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) +Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOverₓ'. -/ /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`, agrees with the `subtype` map. -/ diff --git a/Mathbin/Algebra/CharP/MixedCharZero.lean b/Mathbin/Algebra/CharP/MixedCharZero.lean index d654f3572e..9c82af7c41 100644 --- a/Mathbin/Algebra/CharP/MixedCharZero.lean +++ b/Mathbin/Algebra/CharP/MixedCharZero.lean @@ -61,6 +61,7 @@ variable (R : Type _) [CommRing R] -/ +#print MixedCharZero /- /-- A ring of characteristic zero is of "mixed characteristic `(0, p)`" if there exists an ideal such that the quotient `R ⧸ I` has caracteristic `p`. @@ -74,9 +75,11 @@ class MixedCharZero (p : ℕ) : Prop where [to_charZero : CharZero R] charP_quotient : ∃ I : Ideal R, I ≠ ⊤ ∧ CharP (R ⧸ I) p #align mixed_char_zero MixedCharZero +-/ namespace MixedCharZero +#print MixedCharZero.reduce_to_p_prime /- /-- Reduction to `p` prime: When proving any statement `P` about mixed characteristic rings we can always assume that `p` is prime. -/ @@ -105,7 +108,14 @@ theorem reduce_to_p_prime {P : Prop} : haveI : CharZero R := q_mixed_char.to_char_zero exact ⟨⟨M, hM_max.ne_top, ringChar.of_eq rfl⟩⟩ #align mixed_char_zero.reduce_to_p_prime MixedCharZero.reduce_to_p_prime +-/ +/- warning: mixed_char_zero.reduce_to_maximal_ideal -> MixedCharZero.reduce_to_maximal_ideal is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {p : Nat}, (Nat.Prime p) -> (Iff (Exists.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (fun (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) => And (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) (CharP.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))) p))) (Exists.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (fun (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) => And (Ideal.IsMaximal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) I) (CharP.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))) p)))) +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {p : Nat}, (Nat.Prime p) -> (Iff (Exists.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (fun (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) => And (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) (CharP.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))) p))) (Exists.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (fun (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) => And (Ideal.IsMaximal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) I) (CharP.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))) p)))) +Case conversion may be inaccurate. Consider using '#align mixed_char_zero.reduce_to_maximal_ideal MixedCharZero.reduce_to_maximal_idealₓ'. -/ /-- Reduction to `I` prime ideal: When proving statements about mixed characteristic rings, after we reduced to `p` prime, we can assume that the ideal `I` in the definition is maximal. -/ @@ -157,11 +167,17 @@ Note: Property `(2)` is denoted as `equal_char_zero` in the statement names belo section EqualCharZero +/- warning: Q_algebra_to_equal_char_zero -> EqualCharZero.of_algebraRat is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : Nontrivial.{u1} R] [_inst_3 : Algebra.{0, u1} Rat R Rat.commSemiring (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))] (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))) +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : Algebra.{0, u1} Rat R Rat.commSemiring (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))] (_inst_3 : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) _inst_3 (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) _inst_3) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) _inst_3) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) _inst_3) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) _inst_3) (Ideal.Quotient.commRing.{u1} R _inst_1 _inst_3))))) +Case conversion may be inaccurate. Consider using '#align Q_algebra_to_equal_char_zero EqualCharZero.of_algebraRatₓ'. -/ -- argument `[nontrivial R]` is used in the first line of the proof. /-- `ℚ`-algebra implies equal characteristic. -/ @[nolint unused_arguments] -theorem Q_algebra_to_equal_charZero [Nontrivial R] [Algebra ℚ R] : +theorem EqualCharZero.of_algebraRat [Nontrivial R] [Algebra ℚ R] : ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I) := by haveI : CharZero R := algebraRat.charZero R @@ -173,12 +189,18 @@ theorem Q_algebra_to_equal_charZero [Nontrivial R] [Algebra ℚ R] : refine' I.eq_top_of_is_unit_mem _ (IsUnit.map (algebraMap ℚ R) (IsUnit.mk0 (a - b : ℚ) _)) · simpa only [← Ideal.Quotient.eq_zero_iff_mem, map_sub, sub_eq_zero, map_natCast] simpa only [Ne.def, sub_eq_zero] using (@Nat.cast_injective ℚ _ _).Ne hI -#align Q_algebra_to_equal_char_zero Q_algebra_to_equal_charZero +#align Q_algebra_to_equal_char_zero EqualCharZero.of_algebraRat section ConstructionOfQAlgebra +/- warning: equal_char_zero.pnat_coe_is_unit -> EqualCharZero.PNat.isUnit_natCast is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [h : Fact (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))))] (n : PNat), IsUnit.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1)) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) PNat R (HasLiftT.mk.{1, succ u1} PNat R (CoeTCₓ.coe.{1, succ u1} PNat R (coeTrans.{1, 1, succ u1} PNat Nat R (Nat.castCoe.{u1} R (AddMonoidWithOne.toNatCast.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) coePNatNat))) n) +but is expected to have type + forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R] [h : Fact (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))] (n : PNat), IsUnit.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))) (Nat.cast.{u1} R (Semiring.toNatCast.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (PNat.val n)) +Case conversion may be inaccurate. Consider using '#align equal_char_zero.pnat_coe_is_unit EqualCharZero.PNat.isUnit_natCastₓ'. -/ /-- Internal: Not intended to be used outside this local construction. -/ -theorem EqualCharZero.pNat_coe_isUnit [h : Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I))] +theorem EqualCharZero.PNat.isUnit_natCast [h : Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I))] (n : ℕ+) : IsUnit (n : R) := by -- `n : R` is a unit iff `(n)` is not a proper ideal in `R`. @@ -191,45 +213,69 @@ theorem EqualCharZero.pNat_coe_isUnit [h : Fact (∀ I : Ideal R, I ≠ ⊤ → -- But `n` generates the ideal, so its image is clearly zero. rw [← map_natCast (Ideal.Quotient.mk _), Nat.cast_zero, Ideal.Quotient.eq_zero_iff_mem] exact Ideal.subset_span (Set.mem_singleton _) -#align equal_char_zero.pnat_coe_is_unit EqualCharZero.pNat_coe_isUnit - +#align equal_char_zero.pnat_coe_is_unit EqualCharZero.PNat.isUnit_natCast + +/- warning: equal_char_zero.pnat_has_coe_units -> EqualCharZero.coePNatUnits is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : Fact (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))))], CoeTCₓ.{1, succ u1} PNat (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) +but is expected to have type + forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R] [_inst_2 : Fact (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))], Coe.{1, succ u1} PNat (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) +Case conversion may be inaccurate. Consider using '#align equal_char_zero.pnat_has_coe_units EqualCharZero.coePNatUnitsₓ'. -/ /-- Internal: Not intended to be used outside this local construction. -/ -noncomputable instance EqualCharZero.pnatHasCoeUnits - [Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I))] : CoeTC ℕ+ Rˣ := - ⟨fun n => (EqualCharZero.pNat_coe_isUnit R n).Unit⟩ -#align equal_char_zero.pnat_has_coe_units EqualCharZero.pnatHasCoeUnits - +noncomputable instance EqualCharZero.coePNatUnits [Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I))] : + CoeTC ℕ+ Rˣ := + ⟨fun n => (EqualCharZero.PNat.isUnit_natCast R n).Unit⟩ +#align equal_char_zero.pnat_has_coe_units EqualCharZero.coePNatUnits + +/- warning: equal_char_zero.pnat_coe_units_eq_one -> EqualCharZero.pnatCast_one is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : Fact (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))))], Eq.{succ u1} (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) PNat (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) (HasLiftT.mk.{1, succ u1} PNat (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) (CoeTCₓ.coe.{1, succ u1} PNat (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) (EqualCharZero.coePNatUnits.{u1} R _inst_1 _inst_2))) (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne)))) (OfNat.ofNat.{u1} (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) 1 (OfNat.mk.{u1} (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) 1 (One.one.{u1} (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) (MulOneClass.toHasOne.{u1} (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Units.mulOneClass.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))))))) +but is expected to have type + forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R] [_inst_2 : Fact (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))], Eq.{succ u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (EqualCharZero.pnatCast.{u1} R _inst_1 _inst_2 (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (OfNat.ofNat.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) 1 (One.toOfNat1.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (InvOneClass.toOne.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (DivInvOneMonoid.toInvOneClass.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (DivisionMonoid.toDivInvOneMonoid.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (DivisionCommMonoid.toDivisionMonoid.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (CommGroup.toDivisionCommMonoid.{u1} (Units.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Units.instCommGroupUnitsToMonoid.{u1} R (CommRing.toCommMonoid.{u1} R _inst_1))))))))) +Case conversion may be inaccurate. Consider using '#align equal_char_zero.pnat_coe_units_eq_one EqualCharZero.pnatCast_oneₓ'. -/ /-- Internal: Not intended to be used outside this local construction. -/ -theorem EqualCharZero.pNat_coe_units_eq_one [Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I))] : +theorem EqualCharZero.pnatCast_one [Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I))] : ((1 : ℕ+) : Rˣ) = 1 := by apply Units.ext rw [Units.val_one] - change ((EqualCharZero.pNat_coe_isUnit R 1).Unit : R) = 1 - rw [IsUnit.unit_spec (EqualCharZero.pNat_coe_isUnit R 1)] + change ((EqualCharZero.PNat.isUnit_natCast R 1).Unit : R) = 1 + rw [IsUnit.unit_spec (EqualCharZero.PNat.isUnit_natCast R 1)] rw [coe_coe, PNat.one_coe, Nat.cast_one] -#align equal_char_zero.pnat_coe_units_eq_one EqualCharZero.pNat_coe_units_eq_one - +#align equal_char_zero.pnat_coe_units_eq_one EqualCharZero.pnatCast_one + +/- warning: equal_char_zero.pnat_coe_units_coe_eq_coe -> EqualCharZero.pnatCast_eq_natCast is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : Fact (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))))] (n : PNat), Eq.{succ u1} R ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) R (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) R (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) R (coeBase.{succ u1, succ u1} (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) R (Units.hasCoe.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) PNat (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) (HasLiftT.mk.{1, succ u1} PNat (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) (CoeTCₓ.coe.{1, succ u1} PNat (Units.{u1} R (Ring.toMonoid.{u1} R (CommRing.toRing.{u1} R _inst_1))) (EqualCharZero.coePNatUnits.{u1} R _inst_1 _inst_2))) n)) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) PNat R (HasLiftT.mk.{1, succ u1} PNat R (CoeTCₓ.coe.{1, succ u1} PNat R (coeTrans.{1, 1, succ u1} PNat Nat R (Nat.castCoe.{u1} R (AddMonoidWithOne.toNatCast.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) coePNatNat))) n) +but is expected to have type + forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R] [_inst_2 : Fact (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))] (n : PNat), Eq.{succ u1} R (Units.val.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))) (EqualCharZero.pnatCast.{u1} R _inst_1 _inst_2 n)) (Nat.cast.{u1} R (Semiring.toNatCast.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (PNat.val n)) +Case conversion may be inaccurate. Consider using '#align equal_char_zero.pnat_coe_units_coe_eq_coe EqualCharZero.pnatCast_eq_natCastₓ'. -/ /-- Internal: Not intended to be used outside this local construction. -/ -theorem EqualCharZero.pNat_coe_units_coe_eq_coe [Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I))] +theorem EqualCharZero.pnatCast_eq_natCast [Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I))] (n : ℕ+) : ((n : Rˣ) : R) = ↑n := by - change ((EqualCharZero.pNat_coe_isUnit R n).Unit : R) = ↑n + change ((EqualCharZero.PNat.isUnit_natCast R n).Unit : R) = ↑n simp only [IsUnit.unit_spec] -#align equal_char_zero.pnat_coe_units_coe_eq_coe EqualCharZero.pNat_coe_units_coe_eq_coe - +#align equal_char_zero.pnat_coe_units_coe_eq_coe EqualCharZero.pnatCast_eq_natCast + +/- warning: equal_char_zero_to_Q_algebra -> EqualCharZero.algebraRat is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R], (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))) -> (Algebra.{0, u1} Rat R Rat.commSemiring (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) +but is expected to have type + forall {R : Type.{u1}} [_inst_1 : CommRing.{u1} R], (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))) -> (Algebra.{0, u1} Rat R Rat.commSemiring (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) +Case conversion may be inaccurate. Consider using '#align equal_char_zero_to_Q_algebra EqualCharZero.algebraRatₓ'. -/ /-- Equal characteristic implies `ℚ`-algebra. -/ -noncomputable def equalCharZeroToQAlgebra (h : ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I)) : +noncomputable def EqualCharZero.algebraRat (h : ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I)) : Algebra ℚ R := haveI : Fact (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I)) := ⟨h⟩ RingHom.toAlgebra { toFun := fun x => x.num /ₚ ↑x.pnatDen map_zero' := by simp [divp] - map_one' := by simp [EqualCharZero.pNat_coe_units_eq_one] + map_one' := by simp [EqualCharZero.pnatCast_one] map_mul' := by intro a b field_simp - repeat' rw [EqualCharZero.pNat_coe_units_coe_eq_coe R] + repeat' rw [EqualCharZero.pnatCast_eq_natCast R] trans (↑((a * b).num * a.denom * b.denom) : R) · simp_rw [Int.cast_mul, Int.cast_ofNat, coe_coe, Rat.coe_pnatDen] ring @@ -238,21 +284,27 @@ noncomputable def equalCharZeroToQAlgebra (h : ∀ I : Ideal R, I ≠ ⊤ → Ch map_add' := by intro a b field_simp - repeat' rw [EqualCharZero.pNat_coe_units_coe_eq_coe R] + repeat' rw [EqualCharZero.pnatCast_eq_natCast R] trans (↑((a + b).num * a.denom * b.denom) : R) · simp_rw [Int.cast_mul, Int.cast_ofNat, coe_coe, Rat.coe_pnatDen] ring rw [Rat.add_num_den' a b] simp } -#align equal_char_zero_to_Q_algebra equalCharZeroToQAlgebra +#align equal_char_zero_to_Q_algebra EqualCharZero.algebraRat end ConstructionOfQAlgebra end EqualCharZero +/- warning: not_mixed_char_to_equal_char_zero -> EqualCharZero.of_not_mixedCharZero is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : CharZero.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1))))], (forall (p : Nat), (GT.gt.{0} Nat Nat.hasLt p (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Not (MixedCharZero.{u1} R _inst_1 p))) -> (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))) +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : CharZero.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))], (forall (p : Nat), (GT.gt.{0} Nat instLTNat p (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Not (MixedCharZero.{u1} R _inst_1 p))) -> (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))) +Case conversion may be inaccurate. Consider using '#align not_mixed_char_to_equal_char_zero EqualCharZero.of_not_mixedCharZeroₓ'. -/ /-- Not mixed characteristic implies equal characteristic. -/ -theorem not_mixed_char_to_equal_charZero [CharZero R] (h : ∀ p > 0, ¬MixedCharZero R p) : +theorem EqualCharZero.of_not_mixedCharZero [CharZero R] (h : ∀ p > 0, ¬MixedCharZero R p) : ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I) := by intro I hI_ne_top @@ -262,51 +314,75 @@ theorem not_mixed_char_to_equal_charZero [CharZero R] (h : ∀ p > 0, ¬MixedCha · exact hp · have h_mixed : MixedCharZero R p.succ := ⟨⟨I, ⟨hI_ne_top, hp⟩⟩⟩ exact absurd h_mixed (h p.succ p.succ_pos) -#align not_mixed_char_to_equal_char_zero not_mixed_char_to_equal_charZero - +#align not_mixed_char_to_equal_char_zero EqualCharZero.of_not_mixedCharZero + +/- warning: equal_char_zero_to_not_mixed_char -> EqualCharZero.to_not_mixedCharZero is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R], (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))) -> (forall (p : Nat), (GT.gt.{0} Nat Nat.hasLt p (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Not (MixedCharZero.{u1} R _inst_1 p))) +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R], (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))) -> (forall (p : Nat), (GT.gt.{0} Nat instLTNat p (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Not (MixedCharZero.{u1} R _inst_1 p))) +Case conversion may be inaccurate. Consider using '#align equal_char_zero_to_not_mixed_char EqualCharZero.to_not_mixedCharZeroₓ'. -/ /-- Equal characteristic implies not mixed characteristic. -/ -theorem equal_charZero_to_not_mixed_char (h : ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I)) : +theorem EqualCharZero.to_not_mixedCharZero (h : ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I)) : ∀ p > 0, ¬MixedCharZero R p := by intro p p_pos by_contra hp_mixed_char rcases hp_mixed_char.char_p_quotient with ⟨I, hI_ne_top, hI_p⟩ replace hI_zero : CharP (R ⧸ I) 0 := @CharP.ofCharZero _ _ (h I hI_ne_top) exact absurd (CharP.eq (R ⧸ I) hI_p hI_zero) (ne_of_gt p_pos) -#align equal_char_zero_to_not_mixed_char equal_charZero_to_not_mixed_char - +#align equal_char_zero_to_not_mixed_char EqualCharZero.to_not_mixedCharZero + +/- warning: equal_char_zero_iff_not_mixed_char -> EqualCharZero.iff_not_mixedCharZero is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : CharZero.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1))))], Iff (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))) (forall (p : Nat), (GT.gt.{0} Nat Nat.hasLt p (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Not (MixedCharZero.{u1} R _inst_1 p))) +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : CharZero.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))], Iff (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))) (forall (p : Nat), (GT.gt.{0} Nat instLTNat p (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Not (MixedCharZero.{u1} R _inst_1 p))) +Case conversion may be inaccurate. Consider using '#align equal_char_zero_iff_not_mixed_char EqualCharZero.iff_not_mixedCharZeroₓ'. -/ /-- A ring of characteristic zero has equal characteristic iff it does not have mixed characteristic for any `p`. -/ -theorem equal_charZero_iff_not_mixed_char [CharZero R] : +theorem EqualCharZero.iff_not_mixedCharZero [CharZero R] : (∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I)) ↔ ∀ p > 0, ¬MixedCharZero R p := - ⟨equal_charZero_to_not_mixed_char R, not_mixed_char_to_equal_charZero R⟩ -#align equal_char_zero_iff_not_mixed_char equal_charZero_iff_not_mixed_char - + ⟨EqualCharZero.to_not_mixedCharZero R, EqualCharZero.of_not_mixedCharZero R⟩ +#align equal_char_zero_iff_not_mixed_char EqualCharZero.iff_not_mixedCharZero + +/- warning: Q_algebra_iff_equal_char_zero -> EqualCharZero.nonempty_algebraRat_iff is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : Nontrivial.{u1} R], Iff (Nonempty.{succ u1} (Algebra.{0, u1} Rat R Rat.commSemiring (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))) (forall (I : Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Submodule.hasTop.{u1, u1} R R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (AddCommGroupWithOne.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ring.toAddCommGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) (Ideal.hasQuotient.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I))))))) +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R], Iff (Nonempty.{succ u1} (Algebra.{0, u1} Rat R Rat.commSemiring (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))) (forall (I : Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))), (Ne.{succ u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) I (Top.top.{u1} (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Submodule.instTopSubmodule.{u1, u1} R R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))))) (Semiring.toModule.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))))) -> (CharZero.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (AddGroupWithOne.toAddMonoidWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ring.toAddGroupWithOne.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (CommRing.toRing.{u1} (HasQuotient.Quotient.{u1, u1} R (Ideal.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) (Ideal.instHasQuotientIdealToSemiringToCommSemiring.{u1} R _inst_1) I) (Ideal.Quotient.commRing.{u1} R _inst_1 I)))))) +Case conversion may be inaccurate. Consider using '#align Q_algebra_iff_equal_char_zero EqualCharZero.nonempty_algebraRat_iffₓ'. -/ /-- A ring is a `ℚ`-algebra iff it has equal characteristic zero. -/ -theorem Q_algebra_iff_equal_charZero [Nontrivial R] : +theorem EqualCharZero.nonempty_algebraRat_iff [Nontrivial R] : Nonempty (Algebra ℚ R) ↔ ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I) := by constructor · intro h_alg haveI h_alg' : Algebra ℚ R := h_alg.some - apply Q_algebra_to_equal_charZero + apply EqualCharZero.of_algebraRat · intro h apply Nonempty.intro - exact equalCharZeroToQAlgebra R h -#align Q_algebra_iff_equal_char_zero Q_algebra_iff_equal_charZero - + exact EqualCharZero.algebraRat R h +#align Q_algebra_iff_equal_char_zero EqualCharZero.nonempty_algebraRat_iff + +/- warning: not_Q_algebra_iff_not_equal_char_zero -> isEmpty_algebraRat_iff_mixedCharZero is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : CharZero.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1))))], Iff (IsEmpty.{succ u1} (Algebra.{0, u1} Rat R Rat.commSemiring (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1)))) (Exists.{1} Nat (fun (p : Nat) => Exists.{0} (GT.gt.{0} Nat Nat.hasLt p (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (fun (H : GT.gt.{0} Nat Nat.hasLt p (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) => MixedCharZero.{u1} R _inst_1 p))) +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] [_inst_2 : CharZero.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))], Iff (IsEmpty.{succ u1} (Algebra.{0, u1} Rat R Rat.commSemiring (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1)))) (Exists.{1} Nat (fun (p : Nat) => And (GT.gt.{0} Nat instLTNat p (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (MixedCharZero.{u1} R _inst_1 p))) +Case conversion may be inaccurate. Consider using '#align not_Q_algebra_iff_not_equal_char_zero isEmpty_algebraRat_iff_mixedCharZeroₓ'. -/ /-- A ring of characteristic zero is not a `ℚ`-algebra iff it has mixed characteristic for some `p`. -/ -theorem not_Q_algebra_iff_not_equal_charZero [CharZero R] : +theorem isEmpty_algebraRat_iff_mixedCharZero [CharZero R] : IsEmpty (Algebra ℚ R) ↔ ∃ p > 0, MixedCharZero R p := by rw [← not_iff_not] push_neg - rw [not_isEmpty_iff, ← equal_charZero_iff_not_mixed_char] - apply Q_algebra_iff_equal_charZero -#align not_Q_algebra_iff_not_equal_char_zero not_Q_algebra_iff_not_equal_charZero + rw [not_isEmpty_iff, ← EqualCharZero.iff_not_mixedCharZero] + apply EqualCharZero.nonempty_algebraRat_iff +#align not_Q_algebra_iff_not_equal_char_zero isEmpty_algebraRat_iff_mixedCharZero /-! # Splitting statements into different characteristic @@ -323,9 +399,15 @@ section MainStatements variable {P : Prop} +/- warning: split_equal_mixed_char -> split_equalCharZero_mixedCharZero is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {P : Prop} [_inst_2 : CharZero.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1))))], ((Algebra.{0, u1} Rat R Rat.commSemiring (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) -> P) -> (forall (p : Nat), (Nat.Prime p) -> (MixedCharZero.{u1} R _inst_1 p) -> P) -> P +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {P : Prop} [_inst_2 : CharZero.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))], ((Algebra.{0, u1} Rat R Rat.commSemiring (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) -> P) -> (forall (p : Nat), (Nat.Prime p) -> (MixedCharZero.{u1} R _inst_1 p) -> P) -> P +Case conversion may be inaccurate. Consider using '#align split_equal_mixed_char split_equalCharZero_mixedCharZeroₓ'. -/ /-- Split a `Prop` in characteristic zero into equal and mixed characteristic. -/ -theorem split_equal_mixed_char [CharZero R] (h_equal : Algebra ℚ R → P) +theorem split_equalCharZero_mixedCharZero [CharZero R] (h_equal : Algebra ℚ R → P) (h_mixed : ∀ p : ℕ, Nat.Prime p → MixedCharZero R p → P) : P := by by_cases h : ∃ p > 0, MixedCharZero R p @@ -333,13 +415,19 @@ theorem split_equal_mixed_char [CharZero R] (h_equal : Algebra ℚ R → P) rw [← MixedCharZero.reduce_to_p_prime] at h_mixed exact h_mixed p H hp · apply h_equal - rw [← not_Q_algebra_iff_not_equal_charZero, not_isEmpty_iff] at h + rw [← isEmpty_algebraRat_iff_mixedCharZero, not_isEmpty_iff] at h exact h.some -#align split_equal_mixed_char split_equal_mixed_char +#align split_equal_mixed_char split_equalCharZero_mixedCharZero example (n : ℕ) (h : n ≠ 0) : 0 < n := zero_lt_iff.mpr h +/- warning: split_by_characteristic -> split_by_characteristic is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {P : Prop}, (forall (p : Nat), (Ne.{1} Nat p (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (CharP.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))) p) -> P) -> ((Algebra.{0, u1} Rat R Rat.commSemiring (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) -> P) -> (forall (p : Nat), (Nat.Prime p) -> (MixedCharZero.{u1} R _inst_1 p) -> P) -> P +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {P : Prop}, (forall (p : Nat), (Ne.{1} Nat p (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (CharP.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1))) p) -> P) -> ((Algebra.{0, u1} Rat R Rat.commSemiring (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) -> P) -> (forall (p : Nat), (Nat.Prime p) -> (MixedCharZero.{u1} R _inst_1 p) -> P) -> P +Case conversion may be inaccurate. Consider using '#align split_by_characteristic split_by_characteristicₓ'. -/ /-- Split any `Prop` over `R` into the three cases: - positive characteristic. - equal characteristic zero. @@ -354,10 +442,16 @@ theorem split_by_characteristic (h_pos : ∀ p : ℕ, p ≠ 0 → CharP R p → skip -- make `p_char : char_p R 0` an instance. haveI h0 : CharZero R := CharP.charP_to_charZero R - exact split_equal_mixed_char R h_equal h_mixed + exact split_equalCharZero_mixedCharZero R h_equal h_mixed exact h_pos p h p_char #align split_by_characteristic split_by_characteristic +/- warning: split_by_characteristic_domain -> split_by_characteristic_domain is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {P : Prop} [_inst_2 : IsDomain.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))], (forall (p : Nat), (Nat.Prime p) -> (CharP.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))) p) -> P) -> ((Algebra.{0, u1} Rat R Rat.commSemiring (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) -> P) -> (forall (p : Nat), (Nat.Prime p) -> (MixedCharZero.{u1} R _inst_1 p) -> P) -> P +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {P : Prop} [_inst_2 : IsDomain.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))], (forall (p : Nat), (Nat.Prime p) -> (CharP.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1))) p) -> P) -> ((Algebra.{0, u1} Rat R Rat.commSemiring (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) -> P) -> (forall (p : Nat), (Nat.Prime p) -> (MixedCharZero.{u1} R _inst_1 p) -> P) -> P +Case conversion may be inaccurate. Consider using '#align split_by_characteristic_domain split_by_characteristic_domainₓ'. -/ /-- In a `is_domain R`, split any `Prop` over `R` into the three cases: - *prime* characteristic. - equal characteristic zero. @@ -372,6 +466,12 @@ theorem split_by_characteristic_domain [IsDomain R] (h_pos : ∀ p : ℕ, Nat.Pr exact h_pos p p_prime p_char #align split_by_characteristic_domain split_by_characteristic_domain +/- warning: split_by_characteristic_local_ring -> split_by_characteristic_localRing is a dubious translation: +lean 3 declaration is + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {P : Prop} [_inst_2 : LocalRing.{u1} R (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))], (forall (p : Nat), (IsPrimePow.{0} Nat (LinearOrderedCommMonoidWithZero.toCommMonoidWithZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) p) -> (CharP.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1)))) p) -> P) -> ((Algebra.{0, u1} Rat R Rat.commSemiring (Ring.toSemiring.{u1} R (CommRing.toRing.{u1} R _inst_1))) -> P) -> (forall (p : Nat), (Nat.Prime p) -> (MixedCharZero.{u1} R _inst_1 p) -> P) -> P +but is expected to have type + forall (R : Type.{u1}) [_inst_1 : CommRing.{u1} R] {P : Prop} [_inst_2 : LocalRing.{u1} R (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))], (forall (p : Nat), (IsPrimePow.{0} Nat (LinearOrderedCommMonoidWithZero.toCommMonoidWithZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) p) -> (CharP.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (Ring.toAddGroupWithOne.{u1} R (CommRing.toRing.{u1} R _inst_1))) p) -> P) -> ((Algebra.{0, u1} Rat R Rat.commSemiring (CommSemiring.toSemiring.{u1} R (CommRing.toCommSemiring.{u1} R _inst_1))) -> P) -> (forall (p : Nat), (Nat.Prime p) -> (MixedCharZero.{u1} R _inst_1 p) -> P) -> P +Case conversion may be inaccurate. Consider using '#align split_by_characteristic_local_ring split_by_characteristic_localRingₓ'. -/ /-- In a `local_ring R`, split any `Prop` over `R` into the three cases: - *prime power* characteristic. - equal characteristic zero. diff --git a/Mathbin/Algebra/Group/Units.lean b/Mathbin/Algebra/Group/Units.lean index 54dfd96041..6acc85afb3 100644 --- a/Mathbin/Algebra/Group/Units.lean +++ b/Mathbin/Algebra/Group/Units.lean @@ -1230,7 +1230,7 @@ protected theorem mul_right_cancel (h : IsUnit b) : a * b = c * b → a = c := lean 3 declaration is forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a)) but is expected to have type - forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.7119 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.7121 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.7119 x._@.Mathlib.Algebra.Group.Units._hyg.7121) a)) + forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, (IsUnit.{u1} M _inst_1 a) -> (Function.Injective.{succ u1, succ u1} M M ((fun (x._@.Mathlib.Algebra.Group.Units._hyg.7116 : M) (x._@.Mathlib.Algebra.Group.Units._hyg.7118 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Group.Units._hyg.7116 x._@.Mathlib.Algebra.Group.Units._hyg.7118) a)) Case conversion may be inaccurate. Consider using '#align is_unit.mul_right_injective IsUnit.mul_right_injectiveₓ'. -/ @[to_additive] protected theorem mul_right_injective (h : IsUnit a) : Injective ((· * ·) a) := fun _ _ => diff --git a/Mathbin/MeasureTheory/Constructions/BorelSpace/Complex.lean b/Mathbin/MeasureTheory/Constructions/BorelSpace/Complex.lean index b3c21fbcbe..2c46d92c45 100644 --- a/Mathbin/MeasureTheory/Constructions/BorelSpace/Complex.lean +++ b/Mathbin/MeasureTheory/Constructions/BorelSpace/Complex.lean @@ -16,18 +16,30 @@ import Mathbin.MeasureTheory.Constructions.BorelSpace.Basic noncomputable section +#print IsROrC.measurableSpace /- instance (priority := 900) IsROrC.measurableSpace {𝕜 : Type _} [IsROrC 𝕜] : MeasurableSpace 𝕜 := borel 𝕜 #align is_R_or_C.measurable_space IsROrC.measurableSpace +-/ +#print IsROrC.borelSpace /- instance (priority := 900) IsROrC.borelSpace {𝕜 : Type _} [IsROrC 𝕜] : BorelSpace 𝕜 := ⟨rfl⟩ #align is_R_or_C.borel_space IsROrC.borelSpace +-/ +#print Complex.measurableSpace /- instance Complex.measurableSpace : MeasurableSpace ℂ := borel ℂ #align complex.measurable_space Complex.measurableSpace +-/ +/- warning: complex.borel_space -> Complex.borelSpace is a dubious translation: +lean 3 declaration is + BorelSpace.{0} Complex (UniformSpace.toTopologicalSpace.{0} Complex (PseudoMetricSpace.toUniformSpace.{0} Complex (SeminormedRing.toPseudoMetricSpace.{0} Complex (SeminormedCommRing.toSemiNormedRing.{0} Complex (NormedCommRing.toSeminormedCommRing.{0} Complex (NormedField.toNormedCommRing.{0} Complex Complex.normedField)))))) Complex.measurableSpace +but is expected to have type + BorelSpace.{0} Complex (UniformSpace.toTopologicalSpace.{0} Complex (PseudoMetricSpace.toUniformSpace.{0} Complex (SeminormedRing.toPseudoMetricSpace.{0} Complex (SeminormedCommRing.toSeminormedRing.{0} Complex (NormedCommRing.toSeminormedCommRing.{0} Complex (NormedField.toNormedCommRing.{0} Complex Complex.instNormedFieldComplex)))))) Complex.measurableSpace +Case conversion may be inaccurate. Consider using '#align complex.borel_space Complex.borelSpaceₓ'. -/ instance Complex.borelSpace : BorelSpace ℂ := ⟨rfl⟩ #align complex.borel_space Complex.borelSpace diff --git a/Mathbin/MeasureTheory/Function/EssSup.lean b/Mathbin/MeasureTheory/Function/EssSup.lean index 5a55feaf2d..55e241de6c 100644 --- a/Mathbin/MeasureTheory/Function/EssSup.lean +++ b/Mathbin/MeasureTheory/Function/EssSup.lean @@ -42,42 +42,82 @@ section ConditionallyCompleteLattice variable [ConditionallyCompleteLattice β] +#print essSup /- /-- Essential supremum of `f` with respect to measure `μ`: the smallest `c : β` such that `f x ≤ c` a.e. -/ def essSup {m : MeasurableSpace α} (f : α → β) (μ : Measure α) := μ.ae.limsup f #align ess_sup essSup +-/ +#print essInf /- /-- Essential infimum of `f` with respect to measure `μ`: the greatest `c : β` such that `c ≤ f x` a.e. -/ def essInf {m : MeasurableSpace α} (f : α → β) (μ : Measure α) := μ.ae.liminf f #align ess_inf essInf +-/ +/- warning: ess_sup_congr_ae -> essSup_congr_ae is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLattice.{u2} β] {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β (MeasureTheory.Measure.ae.{u1} α m μ) f g) -> (Eq.{succ u2} β (essSup.{u1, u2} α β _inst_1 m f μ) (essSup.{u1, u2} α β _inst_1 m g μ)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : ConditionallyCompleteLattice.{u1} β] {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u2, u1} α β (MeasureTheory.Measure.ae.{u2} α m μ) f g) -> (Eq.{succ u1} β (essSup.{u2, u1} α β _inst_1 m f μ) (essSup.{u2, u1} α β _inst_1 m g μ)) +Case conversion may be inaccurate. Consider using '#align ess_sup_congr_ae essSup_congr_aeₓ'. -/ theorem essSup_congr_ae {f g : α → β} (hfg : f =ᵐ[μ] g) : essSup f μ = essSup g μ := limsup_congr hfg #align ess_sup_congr_ae essSup_congr_ae +/- warning: ess_inf_congr_ae -> essInf_congr_ae is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLattice.{u2} β] {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β (MeasureTheory.Measure.ae.{u1} α m μ) f g) -> (Eq.{succ u2} β (essInf.{u1, u2} α β _inst_1 m f μ) (essInf.{u1, u2} α β _inst_1 m g μ)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : ConditionallyCompleteLattice.{u1} β] {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u2, u1} α β (MeasureTheory.Measure.ae.{u2} α m μ) f g) -> (Eq.{succ u1} β (essInf.{u2, u1} α β _inst_1 m f μ) (essInf.{u2, u1} α β _inst_1 m g μ)) +Case conversion may be inaccurate. Consider using '#align ess_inf_congr_ae essInf_congr_aeₓ'. -/ theorem essInf_congr_ae {f g : α → β} (hfg : f =ᵐ[μ] g) : essInf f μ = essInf g μ := @essSup_congr_ae α βᵒᵈ _ _ _ _ _ hfg #align ess_inf_congr_ae essInf_congr_ae +/- warning: ess_sup_const' -> essSup_const' is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLattice.{u2} β] [_inst_2 : Filter.NeBot.{u1} α (MeasureTheory.Measure.ae.{u1} α m μ)] (c : β), Eq.{succ u2} β (essSup.{u1, u2} α β _inst_1 m (fun (x : α) => c) μ) c +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : ConditionallyCompleteLattice.{u1} β] [_inst_2 : Filter.NeBot.{u2} α (MeasureTheory.Measure.ae.{u2} α m μ)] (c : β), Eq.{succ u1} β (essSup.{u2, u1} α β _inst_1 m (fun (x : α) => c) μ) c +Case conversion may be inaccurate. Consider using '#align ess_sup_const' essSup_const'ₓ'. -/ @[simp] theorem essSup_const' [μ.ae.ne_bot] (c : β) : essSup (fun x : α => c) μ = c := limsup_const _ #align ess_sup_const' essSup_const' +/- warning: ess_inf_const' -> essInf_const' is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLattice.{u2} β] [_inst_2 : Filter.NeBot.{u1} α (MeasureTheory.Measure.ae.{u1} α m μ)] (c : β), Eq.{succ u2} β (essInf.{u1, u2} α β _inst_1 m (fun (x : α) => c) μ) c +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : ConditionallyCompleteLattice.{u1} β] [_inst_2 : Filter.NeBot.{u2} α (MeasureTheory.Measure.ae.{u2} α m μ)] (c : β), Eq.{succ u1} β (essInf.{u2, u1} α β _inst_1 m (fun (x : α) => c) μ) c +Case conversion may be inaccurate. Consider using '#align ess_inf_const' essInf_const'ₓ'. -/ @[simp] theorem essInf_const' [μ.ae.ne_bot] (c : β) : essInf (fun x : α => c) μ = c := liminf_const _ #align ess_inf_const' essInf_const' +/- warning: ess_sup_const -> essSup_const is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (c : β), (Ne.{succ u1} (MeasureTheory.Measure.{u1} α m) μ (OfNat.ofNat.{u1} (MeasureTheory.Measure.{u1} α m) 0 (OfNat.mk.{u1} (MeasureTheory.Measure.{u1} α m) 0 (Zero.zero.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instZero.{u1} α m))))) -> (Eq.{succ u2} β (essSup.{u1, u2} α β _inst_1 m (fun (x : α) => c) μ) c) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : ConditionallyCompleteLattice.{u1} β] (c : β), (Ne.{succ u2} (MeasureTheory.Measure.{u2} α m) μ (OfNat.ofNat.{u2} (MeasureTheory.Measure.{u2} α m) 0 (Zero.toOfNat0.{u2} (MeasureTheory.Measure.{u2} α m) (MeasureTheory.Measure.instZero.{u2} α m)))) -> (Eq.{succ u1} β (essSup.{u2, u1} α β _inst_1 m (fun (x : α) => c) μ) c) +Case conversion may be inaccurate. Consider using '#align ess_sup_const essSup_constₓ'. -/ theorem essSup_const (c : β) (hμ : μ ≠ 0) : essSup (fun x : α => c) μ = c := by rw [← ae_ne_bot] at hμ exact essSup_const' _ #align ess_sup_const essSup_const +/- warning: ess_inf_const -> essInf_const is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (c : β), (Ne.{succ u1} (MeasureTheory.Measure.{u1} α m) μ (OfNat.ofNat.{u1} (MeasureTheory.Measure.{u1} α m) 0 (OfNat.mk.{u1} (MeasureTheory.Measure.{u1} α m) 0 (Zero.zero.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instZero.{u1} α m))))) -> (Eq.{succ u2} β (essInf.{u1, u2} α β _inst_1 m (fun (x : α) => c) μ) c) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : ConditionallyCompleteLattice.{u1} β] (c : β), (Ne.{succ u2} (MeasureTheory.Measure.{u2} α m) μ (OfNat.ofNat.{u2} (MeasureTheory.Measure.{u2} α m) 0 (Zero.toOfNat0.{u2} (MeasureTheory.Measure.{u2} α m) (MeasureTheory.Measure.instZero.{u2} α m)))) -> (Eq.{succ u1} β (essInf.{u2, u1} α β _inst_1 m (fun (x : α) => c) μ) c) +Case conversion may be inaccurate. Consider using '#align ess_inf_const essInf_constₓ'. -/ theorem essInf_const (c : β) (hμ : μ ≠ 0) : essInf (fun x : α => c) μ = c := by rw [← ae_ne_bot] at hμ @@ -90,6 +130,12 @@ section ConditionallyCompleteLinearOrder variable [ConditionallyCompleteLinearOrder β] {x : β} {f : α → β} +/- warning: ess_sup_eq_Inf -> essSup_eq_sInf is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {m : MeasurableSpace.{u1} α} (μ : MeasureTheory.Measure.{u1} α m) (f : α -> β), Eq.{succ u2} β (essSup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) (InfSet.sInf.{u2} β (ConditionallyCompleteLattice.toHasInf.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)) (setOf.{u2} β (fun (a : β) => Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ (setOf.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) a (f x)))) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))))) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} β] {m : MeasurableSpace.{u2} α} (μ : MeasureTheory.Measure.{u2} α m) (f : α -> β), Eq.{succ u1} β (essSup.{u2, u1} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ) (InfSet.sInf.{u1} β (ConditionallyCompleteLattice.toInfSet.{u1} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} β _inst_1)) (setOf.{u1} β (fun (a : β) => Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u2} α (MeasureTheory.Measure.toOuterMeasure.{u2} α m μ) (setOf.{u2} α (fun (x : α) => LT.lt.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (ConditionallyCompleteLattice.toLattice.{u1} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} β _inst_1)))))) a (f x)))) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))))) +Case conversion may be inaccurate. Consider using '#align ess_sup_eq_Inf essSup_eq_sInfₓ'. -/ theorem essSup_eq_sInf {m : MeasurableSpace α} (μ : Measure α) (f : α → β) : essSup f μ = sInf { a | μ { x | a < f x } = 0 } := by @@ -97,6 +143,12 @@ theorem essSup_eq_sInf {m : MeasurableSpace α} (μ : Measure α) (f : α → β simp only [ae_iff, not_le] #align ess_sup_eq_Inf essSup_eq_sInf +/- warning: ess_inf_eq_Sup -> essInf_eq_sSup is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {m : MeasurableSpace.{u1} α} (μ : MeasureTheory.Measure.{u1} α m) (f : α -> β), Eq.{succ u2} β (essInf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) (SupSet.sSup.{u2} β (ConditionallyCompleteLattice.toHasSup.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)) (setOf.{u2} β (fun (a : β) => Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ (setOf.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (f x) a))) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))))) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} β] {m : MeasurableSpace.{u2} α} (μ : MeasureTheory.Measure.{u2} α m) (f : α -> β), Eq.{succ u1} β (essInf.{u2, u1} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ) (SupSet.sSup.{u1} β (ConditionallyCompleteLattice.toSupSet.{u1} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} β _inst_1)) (setOf.{u1} β (fun (a : β) => Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u2} α (MeasureTheory.Measure.toOuterMeasure.{u2} α m μ) (setOf.{u2} α (fun (x : α) => LT.lt.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (ConditionallyCompleteLattice.toLattice.{u1} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} β _inst_1)))))) (f x) a))) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))))) +Case conversion may be inaccurate. Consider using '#align ess_inf_eq_Sup essInf_eq_sSupₓ'. -/ theorem essInf_eq_sSup {m : MeasurableSpace α} (μ : Measure α) (f : α → β) : essInf f μ = sSup { a | μ { x | f x < a } = 0 } := by @@ -104,6 +156,12 @@ theorem essInf_eq_sSup {m : MeasurableSpace α} (μ : Measure α) (f : α → β simp only [ae_iff, not_le] #align ess_inf_eq_Sup essInf_eq_sSup +/- warning: ae_lt_of_ess_sup_lt -> ae_lt_of_essSup_lt is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {x : β} {f : α -> β}, (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (essSup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) x) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u2, u1} β α (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1))))))) (MeasureTheory.Measure.ae.{u1} α m μ) f) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Eventually.{u1} α (fun (y : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (f y) x) (MeasureTheory.Measure.ae.{u1} α m μ)) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {x : β} {f : α -> β}, (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (essSup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) x) -> (autoParam.{0} (Filter.IsBoundedUnder.{u2, u1} β α (fun (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.634 : β) (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.636 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.634 x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.636) (MeasureTheory.Measure.ae.{u1} α m μ) f) _auto._@.Mathlib.MeasureTheory.Function.EssSup._hyg.600) -> (Filter.Eventually.{u1} α (fun (y : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (f y) x) (MeasureTheory.Measure.ae.{u1} α m μ)) +Case conversion may be inaccurate. Consider using '#align ae_lt_of_ess_sup_lt ae_lt_of_essSup_ltₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/ theorem ae_lt_of_essSup_lt (hx : essSup f μ < x) (hf : IsBoundedUnder (· ≤ ·) μ.ae f := by @@ -113,6 +171,12 @@ theorem ae_lt_of_essSup_lt (hx : essSup f μ < x) eventually_lt_of_limsup_lt hx hf #align ae_lt_of_ess_sup_lt ae_lt_of_essSup_lt +/- warning: ae_lt_of_lt_ess_inf -> ae_lt_of_lt_essInf is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {x : β} {f : α -> β}, (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x (essInf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u2, u1} β α (GE.ge.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1))))))) (MeasureTheory.Measure.ae.{u1} α m μ) f) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Eventually.{u1} α (fun (y : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x (f y)) (MeasureTheory.Measure.ae.{u1} α m μ)) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {x : β} {f : α -> β}, (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x (essInf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) -> (autoParam.{0} (Filter.IsBoundedUnder.{u2, u1} β α (fun (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.734 : β) (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.736 : β) => GE.ge.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.734 x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.736) (MeasureTheory.Measure.ae.{u1} α m μ) f) _auto._@.Mathlib.MeasureTheory.Function.EssSup._hyg.706) -> (Filter.Eventually.{u1} α (fun (y : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x (f y)) (MeasureTheory.Measure.ae.{u1} α m μ)) +Case conversion may be inaccurate. Consider using '#align ae_lt_of_lt_ess_inf ae_lt_of_lt_essInfₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/ theorem ae_lt_of_lt_essInf (hx : x < essInf f μ) (hf : IsBoundedUnder (· ≥ ·) μ.ae f := by @@ -124,6 +188,12 @@ theorem ae_lt_of_lt_essInf (hx : x < essInf f μ) variable [TopologicalSpace β] [FirstCountableTopology β] [OrderTopology β] +/- warning: ae_le_ess_sup -> ae_le_essSup is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {f : α -> β} [_inst_2 : TopologicalSpace.{u2} β] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u2} β _inst_2] [_inst_4 : OrderTopology.{u2} β _inst_2 (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))], (autoParamₓ.{0} (Filter.IsBoundedUnder.{u2, u1} β α (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1))))))) (MeasureTheory.Measure.ae.{u1} α m μ) f) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Eventually.{u1} α (fun (y : α) => LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (f y) (essSup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) (MeasureTheory.Measure.ae.{u1} α m μ)) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {f : α -> β} [_inst_2 : TopologicalSpace.{u2} β] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u2} β _inst_2] [_inst_4 : OrderTopology.{u2} β _inst_2 (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))], (autoParam.{0} (Filter.IsBoundedUnder.{u2, u1} β α (fun (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.868 : β) (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.870 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.868 x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.870) (MeasureTheory.Measure.ae.{u1} α m μ) f) _auto._@.Mathlib.MeasureTheory.Function.EssSup._hyg.840) -> (Filter.Eventually.{u1} α (fun (y : α) => LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (f y) (essSup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) (MeasureTheory.Measure.ae.{u1} α m μ)) +Case conversion may be inaccurate. Consider using '#align ae_le_ess_sup ae_le_essSupₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/ theorem ae_le_essSup (hf : IsBoundedUnder (· ≤ ·) μ.ae f := by @@ -133,6 +203,12 @@ theorem ae_le_essSup eventually_le_limsup hf #align ae_le_ess_sup ae_le_essSup +/- warning: ae_ess_inf_le -> ae_essInf_le is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {f : α -> β} [_inst_2 : TopologicalSpace.{u2} β] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u2} β _inst_2] [_inst_4 : OrderTopology.{u2} β _inst_2 (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))], (autoParamₓ.{0} (Filter.IsBoundedUnder.{u2, u1} β α (GE.ge.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1))))))) (MeasureTheory.Measure.ae.{u1} α m μ) f) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Eventually.{u1} α (fun (y : α) => LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (essInf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) (f y)) (MeasureTheory.Measure.ae.{u1} α m μ)) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {f : α -> β} [_inst_2 : TopologicalSpace.{u2} β] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u2} β _inst_2] [_inst_4 : OrderTopology.{u2} β _inst_2 (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))], (autoParam.{0} (Filter.IsBoundedUnder.{u2, u1} β α (fun (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.973 : β) (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.975 : β) => GE.ge.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.973 x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.975) (MeasureTheory.Measure.ae.{u1} α m μ) f) _auto._@.Mathlib.MeasureTheory.Function.EssSup._hyg.945) -> (Filter.Eventually.{u1} α (fun (y : α) => LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (essInf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) (f y)) (MeasureTheory.Measure.ae.{u1} α m μ)) +Case conversion may be inaccurate. Consider using '#align ae_ess_inf_le ae_essInf_leₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/ theorem ae_essInf_le (hf : IsBoundedUnder (· ≥ ·) μ.ae f := by @@ -142,6 +218,12 @@ theorem ae_essInf_le eventually_liminf_le hf #align ae_ess_inf_le ae_essInf_le +/- warning: meas_ess_sup_lt -> meas_essSup_lt is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {f : α -> β} [_inst_2 : TopologicalSpace.{u2} β] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u2} β _inst_2] [_inst_4 : OrderTopology.{u2} β _inst_2 (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))], (autoParamₓ.{0} (Filter.IsBoundedUnder.{u2, u1} β α (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1))))))) (MeasureTheory.Measure.ae.{u1} α m μ) f) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ (setOf.{u1} α (fun (y : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (essSup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) (f y)))) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {f : α -> β} [_inst_2 : TopologicalSpace.{u2} β] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u2} β _inst_2] [_inst_4 : OrderTopology.{u2} β _inst_2 (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))], (autoParam.{0} (Filter.IsBoundedUnder.{u2, u1} β α (fun (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1076 : β) (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1078 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1076 x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1078) (MeasureTheory.Measure.ae.{u1} α m μ) f) _auto._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1048) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m μ) (setOf.{u1} α (fun (y : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (essSup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) (f y)))) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))) +Case conversion may be inaccurate. Consider using '#align meas_ess_sup_lt meas_essSup_ltₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/ theorem meas_essSup_lt (hf : IsBoundedUnder (· ≤ ·) μ.ae f := by @@ -152,6 +234,12 @@ theorem meas_essSup_lt exact ae_le_essSup hf #align meas_ess_sup_lt meas_essSup_lt +/- warning: meas_lt_ess_inf -> meas_lt_essInf is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {f : α -> β} [_inst_2 : TopologicalSpace.{u2} β] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u2} β _inst_2] [_inst_4 : OrderTopology.{u2} β _inst_2 (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))], (autoParamₓ.{0} (Filter.IsBoundedUnder.{u2, u1} β α (GE.ge.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1))))))) (MeasureTheory.Measure.ae.{u1} α m μ) f) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ (setOf.{u1} α (fun (y : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (f y) (essInf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)))) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : ConditionallyCompleteLinearOrder.{u2} β] {f : α -> β} [_inst_2 : TopologicalSpace.{u2} β] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u2} β _inst_2] [_inst_4 : OrderTopology.{u2} β _inst_2 (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))], (autoParam.{0} (Filter.IsBoundedUnder.{u2, u1} β α (fun (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1178 : β) (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1180 : β) => GE.ge.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1178 x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1180) (MeasureTheory.Measure.ae.{u1} α m μ) f) _auto._@.Mathlib.MeasureTheory.Function.EssSup._hyg.1150) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m μ) (setOf.{u1} α (fun (y : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1)))))) (f y) (essInf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)))) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))) +Case conversion may be inaccurate. Consider using '#align meas_lt_ess_inf meas_lt_essInfₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/ theorem meas_lt_essInf (hf : IsBoundedUnder (· ≥ ·) μ.ae f := by @@ -168,24 +256,54 @@ section CompleteLattice variable [CompleteLattice β] +/- warning: ess_sup_measure_zero -> essSup_measure_zero is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLattice.{u2} β] {m : MeasurableSpace.{u1} α} {f : α -> β}, Eq.{succ u2} β (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f (OfNat.ofNat.{u1} (MeasureTheory.Measure.{u1} α m) 0 (OfNat.mk.{u1} (MeasureTheory.Measure.{u1} α m) 0 (Zero.zero.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instZero.{u1} α m))))) (Bot.bot.{u2} β (CompleteLattice.toHasBot.{u2} β _inst_1)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : CompleteLattice.{u1} β] {m : MeasurableSpace.{u2} α} {f : α -> β}, Eq.{succ u1} β (essSup.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f (OfNat.ofNat.{u2} (MeasureTheory.Measure.{u2} α m) 0 (Zero.toOfNat0.{u2} (MeasureTheory.Measure.{u2} α m) (MeasureTheory.Measure.instZero.{u2} α m)))) (Bot.bot.{u1} β (CompleteLattice.toBot.{u1} β _inst_1)) +Case conversion may be inaccurate. Consider using '#align ess_sup_measure_zero essSup_measure_zeroₓ'. -/ @[simp] theorem essSup_measure_zero {m : MeasurableSpace α} {f : α → β} : essSup f (0 : Measure α) = ⊥ := le_bot_iff.mp (sInf_le (by simp [Set.mem_setOf_eq, eventually_le, ae_iff])) #align ess_sup_measure_zero essSup_measure_zero +/- warning: ess_inf_measure_zero -> essInf_measure_zero is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLattice.{u2} β] {m : MeasurableSpace.{u1} α} {f : α -> β}, Eq.{succ u2} β (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f (OfNat.ofNat.{u1} (MeasureTheory.Measure.{u1} α m) 0 (OfNat.mk.{u1} (MeasureTheory.Measure.{u1} α m) 0 (Zero.zero.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instZero.{u1} α m))))) (Top.top.{u2} β (CompleteLattice.toHasTop.{u2} β _inst_1)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : CompleteLattice.{u1} β] {m : MeasurableSpace.{u2} α} {f : α -> β}, Eq.{succ u1} β (essInf.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f (OfNat.ofNat.{u2} (MeasureTheory.Measure.{u2} α m) 0 (Zero.toOfNat0.{u2} (MeasureTheory.Measure.{u2} α m) (MeasureTheory.Measure.instZero.{u2} α m)))) (Top.top.{u1} β (CompleteLattice.toTop.{u1} β _inst_1)) +Case conversion may be inaccurate. Consider using '#align ess_inf_measure_zero essInf_measure_zeroₓ'. -/ @[simp] theorem essInf_measure_zero {m : MeasurableSpace α} {f : α → β} : essInf f (0 : Measure α) = ⊤ := @essSup_measure_zero α βᵒᵈ _ _ _ #align ess_inf_measure_zero essInf_measure_zero +/- warning: ess_sup_mono_ae -> essSup_mono_ae is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (MeasureTheory.Measure.ae.{u1} α m μ) f g) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m g μ)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : CompleteLattice.{u1} β] {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (MeasureTheory.Measure.ae.{u2} α m μ) f g) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (essSup.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ) (essSup.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m g μ)) +Case conversion may be inaccurate. Consider using '#align ess_sup_mono_ae essSup_mono_aeₓ'. -/ theorem essSup_mono_ae {f g : α → β} (hfg : f ≤ᵐ[μ] g) : essSup f μ ≤ essSup g μ := limsup_le_limsup hfg #align ess_sup_mono_ae essSup_mono_ae +/- warning: ess_inf_mono_ae -> essInf_mono_ae is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (MeasureTheory.Measure.ae.{u1} α m μ) f g) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m g μ)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : CompleteLattice.{u1} β] {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (MeasureTheory.Measure.ae.{u2} α m μ) f g) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (essInf.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ) (essInf.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m g μ)) +Case conversion may be inaccurate. Consider using '#align ess_inf_mono_ae essInf_mono_aeₓ'. -/ theorem essInf_mono_ae {f g : α → β} (hfg : f ≤ᵐ[μ] g) : essInf f μ ≤ essInf g μ := liminf_le_liminf hfg #align ess_inf_mono_ae essInf_mono_ae +/- warning: ess_sup_le_of_ae_le -> essSup_le_of_ae_le is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {f : α -> β} (c : β), (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (MeasureTheory.Measure.ae.{u1} α m μ) f (fun (_x : α) => c)) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ) c) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : CompleteLattice.{u1} β] {f : α -> β} (c : β), (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (MeasureTheory.Measure.ae.{u2} α m μ) f (fun (_x : α) => c)) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (essSup.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ) c) +Case conversion may be inaccurate. Consider using '#align ess_sup_le_of_ae_le essSup_le_of_ae_leₓ'. -/ theorem essSup_le_of_ae_le {f : α → β} (c : β) (hf : f ≤ᵐ[μ] fun _ => c) : essSup f μ ≤ c := by refine' (essSup_mono_ae hf).trans _ @@ -194,18 +312,42 @@ theorem essSup_le_of_ae_le {f : α → β} (c : β) (hf : f ≤ᵐ[μ] fun _ => · rwa [essSup_const] #align ess_sup_le_of_ae_le essSup_le_of_ae_le +/- warning: le_ess_inf_of_ae_le -> le_essInf_of_ae_le is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {f : α -> β} (c : β), (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (MeasureTheory.Measure.ae.{u1} α m μ) (fun (_x : α) => c) f) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) c (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} [_inst_1 : CompleteLattice.{u1} β] {f : α -> β} (c : β), (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (MeasureTheory.Measure.ae.{u2} α m μ) (fun (_x : α) => c) f) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) c (essInf.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ)) +Case conversion may be inaccurate. Consider using '#align le_ess_inf_of_ae_le le_essInf_of_ae_leₓ'. -/ theorem le_essInf_of_ae_le {f : α → β} (c : β) (hf : (fun _ => c) ≤ᵐ[μ] f) : c ≤ essInf f μ := @essSup_le_of_ae_le α βᵒᵈ _ _ _ _ c hf #align le_ess_inf_of_ae_le le_essInf_of_ae_le +/- warning: ess_sup_const_bot -> essSup_const_bot is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β], Eq.{succ u2} β (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m (fun (x : α) => Bot.bot.{u2} β (CompleteLattice.toHasBot.{u2} β _inst_1)) μ) (Bot.bot.{u2} β (CompleteLattice.toHasBot.{u2} β _inst_1)) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β], Eq.{succ u2} β (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m (fun (x : α) => Bot.bot.{u2} β (CompleteLattice.toBot.{u2} β _inst_1)) μ) (Bot.bot.{u2} β (CompleteLattice.toBot.{u2} β _inst_1)) +Case conversion may be inaccurate. Consider using '#align ess_sup_const_bot essSup_const_botₓ'. -/ theorem essSup_const_bot : essSup (fun x : α => (⊥ : β)) μ = (⊥ : β) := limsup_const_bot #align ess_sup_const_bot essSup_const_bot +/- warning: ess_inf_const_top -> essInf_const_top is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β], Eq.{succ u2} β (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m (fun (x : α) => Top.top.{u2} β (CompleteLattice.toHasTop.{u2} β _inst_1)) μ) (Top.top.{u2} β (CompleteLattice.toHasTop.{u2} β _inst_1)) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β], Eq.{succ u2} β (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m (fun (x : α) => Top.top.{u2} β (CompleteLattice.toTop.{u2} β _inst_1)) μ) (Top.top.{u2} β (CompleteLattice.toTop.{u2} β _inst_1)) +Case conversion may be inaccurate. Consider using '#align ess_inf_const_top essInf_const_topₓ'. -/ theorem essInf_const_top : essInf (fun x : α => (⊤ : β)) μ = (⊤ : β) := liminf_const_top #align ess_inf_const_top essInf_const_top +/- warning: order_iso.ess_sup_apply -> OrderIso.essSup_apply is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLattice.{u2} β] {m : MeasurableSpace.{u1} α} {γ : Type.{u3}} [_inst_2 : CompleteLattice.{u3} γ] (f : α -> β) (μ : MeasureTheory.Measure.{u1} α m) (g : OrderIso.{u2, u3} β γ (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2))))), Eq.{succ u3} γ (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (OrderIso.{u2, u3} β γ (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2))))) (fun (_x : RelIso.{u2, u3} β γ (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1))))) (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2)))))) => β -> γ) (RelIso.hasCoeToFun.{u2, u3} β γ (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1))))) (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2)))))) g (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) (essSup.{u1, u3} α γ (CompleteLattice.toConditionallyCompleteLattice.{u3} γ _inst_2) m (fun (x : α) => coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (OrderIso.{u2, u3} β γ (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2))))) (fun (_x : RelIso.{u2, u3} β γ (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1))))) (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2)))))) => β -> γ) (RelIso.hasCoeToFun.{u2, u3} β γ (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1))))) (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2)))))) g (f x)) μ) +but is expected to have type + forall {α : Type.{u3}} {β : Type.{u1}} [_inst_1 : CompleteLattice.{u1} β] {m : MeasurableSpace.{u3} α} {γ : Type.{u2}} [_inst_2 : CompleteLattice.{u2} γ] (f : α -> β) (μ : MeasureTheory.Measure.{u3} α m) (g : OrderIso.{u1, u2} β γ (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2))))), Eq.{succ u2} γ (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) β (fun (_x : β) => γ) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) g (essSup.{u3, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ)) (essSup.{u3, u2} α γ (CompleteLattice.toConditionallyCompleteLattice.{u2} γ _inst_2) m (fun (x : α) => FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) β (fun (_x : β) => γ) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) g (f x)) μ) +Case conversion may be inaccurate. Consider using '#align order_iso.ess_sup_apply OrderIso.essSup_applyₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ theorem OrderIso.essSup_apply {m : MeasurableSpace α} {γ} [CompleteLattice γ] (f : α → β) (μ : Measure α) (g : β ≃o γ) : g (essSup f μ) = essSup (fun x => g (f x)) μ := @@ -216,11 +358,23 @@ theorem OrderIso.essSup_apply {m : MeasurableSpace α} {γ} [CompleteLattice γ] is_bounded_default #align order_iso.ess_sup_apply OrderIso.essSup_apply +/- warning: order_iso.ess_inf_apply -> OrderIso.essInf_apply is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLattice.{u2} β] {m : MeasurableSpace.{u1} α} {γ : Type.{u3}} [_inst_2 : CompleteLattice.{u3} γ] (f : α -> β) (μ : MeasureTheory.Measure.{u1} α m) (g : OrderIso.{u2, u3} β γ (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2))))), Eq.{succ u3} γ (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (OrderIso.{u2, u3} β γ (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2))))) (fun (_x : RelIso.{u2, u3} β γ (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1))))) (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2)))))) => β -> γ) (RelIso.hasCoeToFun.{u2, u3} β γ (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1))))) (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2)))))) g (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) (essInf.{u1, u3} α γ (CompleteLattice.toConditionallyCompleteLattice.{u3} γ _inst_2) m (fun (x : α) => coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (OrderIso.{u2, u3} β γ (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2))))) (fun (_x : RelIso.{u2, u3} β γ (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1))))) (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2)))))) => β -> γ) (RelIso.hasCoeToFun.{u2, u3} β γ (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1))))) (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ (PartialOrder.toPreorder.{u3} γ (CompleteSemilatticeInf.toPartialOrder.{u3} γ (CompleteLattice.toCompleteSemilatticeInf.{u3} γ _inst_2)))))) g (f x)) μ) +but is expected to have type + forall {α : Type.{u3}} {β : Type.{u1}} [_inst_1 : CompleteLattice.{u1} β] {m : MeasurableSpace.{u3} α} {γ : Type.{u2}} [_inst_2 : CompleteLattice.{u2} γ] (f : α -> β) (μ : MeasureTheory.Measure.{u3} α m) (g : OrderIso.{u1, u2} β γ (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2))))), Eq.{succ u2} γ (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) β (fun (_x : β) => γ) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) g (essInf.{u3, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ)) (essInf.{u3, u2} α γ (CompleteLattice.toConditionallyCompleteLattice.{u2} γ _inst_2) m (fun (x : α) => FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) β (fun (_x : β) => γ) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u2} β γ (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : β) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : β) => LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : γ) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : γ) => LE.le.{u2} γ (Preorder.toLE.{u2} γ (PartialOrder.toPreorder.{u2} γ (OmegaCompletePartialOrder.toPartialOrder.{u2} γ (CompleteLattice.instOmegaCompletePartialOrder.{u2} γ _inst_2)))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) g (f x)) μ) +Case conversion may be inaccurate. Consider using '#align order_iso.ess_inf_apply OrderIso.essInf_applyₓ'. -/ theorem OrderIso.essInf_apply {m : MeasurableSpace α} {γ} [CompleteLattice γ] (f : α → β) (μ : Measure α) (g : β ≃o γ) : g (essInf f μ) = essInf (fun x => g (f x)) μ := @OrderIso.essSup_apply α βᵒᵈ _ _ γᵒᵈ _ _ _ g.dual #align order_iso.ess_inf_apply OrderIso.essInf_apply +/- warning: ess_sup_mono_measure -> essSup_mono_measure is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {f : α -> β}, (MeasureTheory.Measure.AbsolutelyContinuous.{u1} α m ν μ) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f ν) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} {ν : MeasureTheory.Measure.{u2} α m} [_inst_1 : CompleteLattice.{u1} β] {f : α -> β}, (MeasureTheory.Measure.AbsolutelyContinuous.{u2} α m ν μ) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (essSup.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f ν) (essSup.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ)) +Case conversion may be inaccurate. Consider using '#align ess_sup_mono_measure essSup_mono_measureₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ theorem essSup_mono_measure {f : α → β} (hμν : ν ≪ μ) : essSup f ν ≤ essSup f μ := by @@ -230,12 +384,24 @@ theorem essSup_mono_measure {f : α → β} (hμν : ν ≪ μ) : essSup f ν is_bounded_default #align ess_sup_mono_measure essSup_mono_measure +/- warning: ess_sup_mono_measure' -> essSup_mono_measure' is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} [_inst_2 : CompleteLattice.{u2} β] {f : α -> β}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_2)))) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_2) m f ν) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_2) m f μ)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} {ν : MeasureTheory.Measure.{u2} α m} [_inst_2 : CompleteLattice.{u1} β] {f : α -> β}, (LE.le.{u2} (MeasureTheory.Measure.{u2} α m) (Preorder.toLE.{u2} (MeasureTheory.Measure.{u2} α m) (PartialOrder.toPreorder.{u2} (MeasureTheory.Measure.{u2} α m) (MeasureTheory.Measure.instPartialOrder.{u2} α m))) ν μ) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_2)))) (essSup.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_2) m f ν) (essSup.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_2) m f μ)) +Case conversion may be inaccurate. Consider using '#align ess_sup_mono_measure' essSup_mono_measure'ₓ'. -/ theorem essSup_mono_measure' {α : Type _} {β : Type _} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [CompleteLattice β] {f : α → β} (hμν : ν ≤ μ) : essSup f ν ≤ essSup f μ := essSup_mono_measure (Measure.absolutelyContinuous_of_le hμν) #align ess_sup_mono_measure' essSup_mono_measure' +/- warning: ess_inf_antitone_measure -> essInf_antitone_measure is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {f : α -> β}, (MeasureTheory.Measure.AbsolutelyContinuous.{u1} α m μ ν) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f ν) (essInf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) +but is expected to have type + forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {μ : MeasureTheory.Measure.{u2} α m} {ν : MeasureTheory.Measure.{u2} α m} [_inst_1 : CompleteLattice.{u1} β] {f : α -> β}, (MeasureTheory.Measure.AbsolutelyContinuous.{u2} α m μ ν) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (essInf.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f ν) (essInf.{u2, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m f μ)) +Case conversion may be inaccurate. Consider using '#align ess_inf_antitone_measure essInf_antitone_measureₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ theorem essInf_antitone_measure {f : α → β} (hμν : μ ≪ ν) : essInf f ν ≤ essInf f μ := by @@ -245,6 +411,12 @@ theorem essInf_antitone_measure {f : α → β} (hμν : μ ≪ ν) : essInf f is_bounded_default #align ess_inf_antitone_measure essInf_antitone_measure +/- warning: ess_sup_smul_measure -> essSup_smul_measure is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {f : α -> β} {c : ENNReal}, (Ne.{1} ENNReal c (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))) -> (Eq.{succ u2} β (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f (SMul.smul.{0, u1} ENNReal (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSMul.{u1, 0} α ENNReal (SMulZeroClass.toHasSmul.{0, 0} ENNReal ENNReal (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (SMulWithZero.toSmulZeroClass.{0, 0} ENNReal ENNReal (MulZeroClass.toHasZero.{0} ENNReal (MulZeroOneClass.toMulZeroClass.{0} ENNReal (MonoidWithZero.toMulZeroOneClass.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (MulActionWithZero.toSMulWithZero.{0, 0} ENNReal ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (Module.toMulActionWithZero.{0, 0} ENNReal ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (Algebra.toModule.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) m) c μ)) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) +but is expected to have type + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {f : α -> β} {c : ENNReal}, (Ne.{1} ENNReal c (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))) -> (Eq.{succ u2} β (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f (HSMul.hSMul.{0, u1, u1} ENNReal (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSMul.{0, u1} ENNReal (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSMul.{u1, 0} α ENNReal (Algebra.toSMul.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) m)) c μ)) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m f μ)) +Case conversion may be inaccurate. Consider using '#align ess_sup_smul_measure essSup_smul_measureₓ'. -/ theorem essSup_smul_measure {f : α → β} {c : ℝ≥0∞} (hc : c ≠ 0) : essSup f (c • μ) = essSup f μ := by simp_rw [essSup] @@ -260,6 +432,12 @@ variable {γ : Type _} {mγ : MeasurableSpace γ} {f : α → γ} {g : γ → β include mγ +/- warning: ess_sup_comp_le_ess_sup_map_measure -> essSup_comp_le_essSup_map_measure is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {γ : Type.{u3}} {mγ : MeasurableSpace.{u3} γ} {f : α -> γ} {g : γ -> β}, (AEMeasurable.{u1, u3} α γ mγ m f μ) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (CompleteSemilatticeInf.toPartialOrder.{u2} β (CompleteLattice.toCompleteSemilatticeInf.{u2} β _inst_1)))) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m (Function.comp.{succ u1, succ u3, succ u2} α γ β g f) μ) (essSup.{u3, u2} γ β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) mγ g (MeasureTheory.Measure.map.{u1, u3} α γ mγ m f μ))) +but is expected to have type + forall {α : Type.{u3}} {β : Type.{u1}} {m : MeasurableSpace.{u3} α} {μ : MeasureTheory.Measure.{u3} α m} [_inst_1 : CompleteLattice.{u1} β] {γ : Type.{u2}} {mγ : MeasurableSpace.{u2} γ} {f : α -> γ} {g : γ -> β}, (AEMeasurable.{u3, u2} α γ mγ m f μ) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (OmegaCompletePartialOrder.toPartialOrder.{u1} β (CompleteLattice.instOmegaCompletePartialOrder.{u1} β _inst_1)))) (essSup.{u3, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m (Function.comp.{succ u3, succ u2, succ u1} α γ β g f) μ) (essSup.{u2, u1} γ β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) mγ g (MeasureTheory.Measure.map.{u3, u2} α γ mγ m f μ))) +Case conversion may be inaccurate. Consider using '#align ess_sup_comp_le_ess_sup_map_measure essSup_comp_le_essSup_map_measureₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ theorem essSup_comp_le_essSup_map_measure (hf : AEMeasurable f μ) : @@ -281,6 +459,12 @@ theorem essSup_comp_le_essSup_map_measure (hf : AEMeasurable f μ) : exact fun h => mem_ae_of_mem_ae_map hf h #align ess_sup_comp_le_ess_sup_map_measure essSup_comp_le_essSup_map_measure +/- warning: measurable_embedding.ess_sup_map_measure -> MeasurableEmbedding.essSup_map_measure is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} [_inst_1 : CompleteLattice.{u2} β] {γ : Type.{u3}} {mγ : MeasurableSpace.{u3} γ} {f : α -> γ} {g : γ -> β}, (MeasurableEmbedding.{u1, u3} α γ m mγ f) -> (Eq.{succ u2} β (essSup.{u3, u2} γ β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) mγ g (MeasureTheory.Measure.map.{u1, u3} α γ mγ m f μ)) (essSup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u2} β _inst_1) m (Function.comp.{succ u1, succ u3, succ u2} α γ β g f) μ)) +but is expected to have type + forall {α : Type.{u3}} {β : Type.{u1}} {m : MeasurableSpace.{u3} α} {μ : MeasureTheory.Measure.{u3} α m} [_inst_1 : CompleteLattice.{u1} β] {γ : Type.{u2}} {mγ : MeasurableSpace.{u2} γ} {f : α -> γ} {g : γ -> β}, (MeasurableEmbedding.{u3, u2} α γ m mγ f) -> (Eq.{succ u1} β (essSup.{u2, u1} γ β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) mγ g (MeasureTheory.Measure.map.{u3, u2} α γ mγ m f μ)) (essSup.{u3, u1} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} β _inst_1) m (Function.comp.{succ u3, succ u2, succ u1} α γ β g f) μ)) +Case conversion may be inaccurate. Consider using '#align measurable_embedding.ess_sup_map_measure MeasurableEmbedding.essSup_map_measureₓ'. -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ theorem MeasurableEmbedding.essSup_map_measure (hf : MeasurableEmbedding f) : @@ -305,6 +489,7 @@ variable [MeasurableSpace β] [TopologicalSpace β] [SecondCountableTopology β] /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ +#print essSup_map_measure_of_measurable /- theorem essSup_map_measure_of_measurable (hg : Measurable g) (hf : AEMeasurable f μ) : essSup g (Measure.map f μ) = essSup (g ∘ f) μ := by @@ -322,7 +507,9 @@ theorem essSup_map_measure_of_measurable (hg : Measurable g) (hf : AEMeasurable rw [ae_map_iff hf (measurableSet_le hg measurable_const)] exact h_le #align ess_sup_map_measure_of_measurable essSup_map_measure_of_measurable +-/ +#print essSup_map_measure /- theorem essSup_map_measure (hg : AEMeasurable g (Measure.map f μ)) (hf : AEMeasurable f μ) : essSup g (Measure.map f μ) = essSup (g ∘ f) μ := by @@ -332,6 +519,7 @@ theorem essSup_map_measure (hg : AEMeasurable g (Measure.map f μ)) (hf : AEMeas rw [← eventually_eq] at h_eq exact h_eq.symm #align ess_sup_map_measure essSup_map_measure +-/ omit mγ @@ -347,6 +535,7 @@ variable [CompleteLinearOrder β] /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/ +#print essSup_indicator_eq_essSup_restrict /- theorem essSup_indicator_eq_essSup_restrict [Zero β] {s : Set α} {f : α → β} (hf : 0 ≤ᵐ[μ.restrict s] f) (hs : MeasurableSet s) (hs_not_null : μ s ≠ 0) : essSup (s.indicator f) μ = essSup f (μ.restrict s) := @@ -390,6 +579,7 @@ theorem essSup_indicator_eq_essSup_restrict [Zero β] {s : Set α} {f : α → · simpa [hxs] using hxc hxs · simpa [hxs] using hc #align ess_sup_indicator_eq_ess_sup_restrict essSup_indicator_eq_essSup_restrict +-/ end CompleteLinearOrder @@ -397,27 +587,63 @@ namespace ENNReal variable {f : α → ℝ≥0∞} +/- warning: ennreal.ae_le_ess_sup -> ENNReal.ae_le_essSup is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} (f : α -> ENNReal), Filter.Eventually.{u1} α (fun (y : α) => LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (f y) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m f μ)) (MeasureTheory.Measure.ae.{u1} α m μ) +but is expected to have type + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} (f : α -> ENNReal), Filter.Eventually.{u1} α (fun (y : α) => LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (f y) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m f μ)) (MeasureTheory.Measure.ae.{u1} α m μ) +Case conversion may be inaccurate. Consider using '#align ennreal.ae_le_ess_sup ENNReal.ae_le_essSupₓ'. -/ theorem ae_le_essSup (f : α → ℝ≥0∞) : ∀ᵐ y ∂μ, f y ≤ essSup f μ := eventually_le_limsup f #align ennreal.ae_le_ess_sup ENNReal.ae_le_essSup +/- warning: ennreal.ess_sup_eq_zero_iff -> ENNReal.essSup_eq_zero_iff is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {f : α -> ENNReal}, Iff (Eq.{1} ENNReal (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m f μ) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))) (Filter.EventuallyEq.{u1, 0} α ENNReal (MeasureTheory.Measure.ae.{u1} α m μ) f (OfNat.ofNat.{u1} (α -> ENNReal) 0 (OfNat.mk.{u1} (α -> ENNReal) 0 (Zero.zero.{u1} (α -> ENNReal) (Pi.instZero.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => ENNReal.hasZero)))))) +but is expected to have type + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {f : α -> ENNReal}, Iff (Eq.{1} ENNReal (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m f μ) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))) (Filter.EventuallyEq.{u1, 0} α ENNReal (MeasureTheory.Measure.ae.{u1} α m μ) f (OfNat.ofNat.{u1} (α -> ENNReal) 0 (Zero.toOfNat0.{u1} (α -> ENNReal) (Pi.instZero.{u1, 0} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => ENNReal) (fun (i : α) => instENNRealZero))))) +Case conversion may be inaccurate. Consider using '#align ennreal.ess_sup_eq_zero_iff ENNReal.essSup_eq_zero_iffₓ'. -/ @[simp] theorem essSup_eq_zero_iff : essSup f μ = 0 ↔ f =ᵐ[μ] 0 := limsup_eq_zero_iff #align ennreal.ess_sup_eq_zero_iff ENNReal.essSup_eq_zero_iff +/- warning: ennreal.ess_sup_const_mul -> ENNReal.essSup_const_mul is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {f : α -> ENNReal} {a : ENNReal}, Eq.{1} ENNReal (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m (fun (x : α) => HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (Distrib.toHasMul.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) a (f x)) μ) (HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (Distrib.toHasMul.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) a (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m f μ)) +but is expected to have type + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {f : α -> ENNReal} {a : ENNReal}, Eq.{1} ENNReal (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m (fun (x : α) => HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (CanonicallyOrderedCommSemiring.toMul.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) a (f x)) μ) (HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (CanonicallyOrderedCommSemiring.toMul.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) a (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m f μ)) +Case conversion may be inaccurate. Consider using '#align ennreal.ess_sup_const_mul ENNReal.essSup_const_mulₓ'. -/ theorem essSup_const_mul {a : ℝ≥0∞} : essSup (fun x : α => a * f x) μ = a * essSup f μ := limsup_const_mul #align ennreal.ess_sup_const_mul ENNReal.essSup_const_mul +/- warning: ennreal.ess_sup_mul_le -> ENNReal.essSup_mul_le is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} (f : α -> ENNReal) (g : α -> ENNReal), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m (HMul.hMul.{u1, u1, u1} (α -> ENNReal) (α -> ENNReal) (α -> ENNReal) (instHMul.{u1} (α -> ENNReal) (Pi.instMul.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Distrib.toHasMul.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) f g) μ) (HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (Distrib.toHasMul.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m f μ) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m g μ)) +but is expected to have type + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} (f : α -> ENNReal) (g : α -> ENNReal), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m (HMul.hMul.{u1, u1, u1} (α -> ENNReal) (α -> ENNReal) (α -> ENNReal) (instHMul.{u1} (α -> ENNReal) (Pi.instMul.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => CanonicallyOrderedCommSemiring.toMul.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) f g) μ) (HMul.hMul.{0, 0, 0} ENNReal ENNReal ENNReal (instHMul.{0} ENNReal (CanonicallyOrderedCommSemiring.toMul.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m f μ) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m g μ)) +Case conversion may be inaccurate. Consider using '#align ennreal.ess_sup_mul_le ENNReal.essSup_mul_leₓ'. -/ theorem essSup_mul_le (f g : α → ℝ≥0∞) : essSup (f * g) μ ≤ essSup f μ * essSup g μ := limsup_mul_le f g #align ennreal.ess_sup_mul_le ENNReal.essSup_mul_le +/- warning: ennreal.ess_sup_add_le -> ENNReal.essSup_add_le is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} (f : α -> ENNReal) (g : α -> ENNReal), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m (HAdd.hAdd.{u1, u1, u1} (α -> ENNReal) (α -> ENNReal) (α -> ENNReal) (instHAdd.{u1} (α -> ENNReal) (Pi.instAdd.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) f g) μ) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m f μ) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m g μ)) +but is expected to have type + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} (f : α -> ENNReal) (g : α -> ENNReal), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m (HAdd.hAdd.{u1, u1, u1} (α -> ENNReal) (α -> ENNReal) (α -> ENNReal) (instHAdd.{u1} (α -> ENNReal) (Pi.instAdd.{u1, 0} α (fun (ᾰ : α) => ENNReal) (fun (i : α) => Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))))))))) f g) μ) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))))) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m f μ) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m g μ)) +Case conversion may be inaccurate. Consider using '#align ennreal.ess_sup_add_le ENNReal.essSup_add_leₓ'. -/ theorem essSup_add_le (f g : α → ℝ≥0∞) : essSup (f + g) μ ≤ essSup f μ + essSup g μ := limsup_add_le f g #align ennreal.ess_sup_add_le ENNReal.essSup_add_le +/- warning: ennreal.ess_sup_liminf_le -> ENNReal.essSup_liminf_le is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ι : Type.{u2}} [_inst_1 : Countable.{succ u2} ι] [_inst_2 : LinearOrder.{u2} ι] (f : ι -> α -> ENNReal), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m (fun (x : α) => Filter.liminf.{0, u2} ENNReal ι (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) (fun (n : ι) => f n x) (Filter.atTop.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (LinearOrder.toLattice.{u2} ι _inst_2)))))) μ) (Filter.liminf.{0, u2} ENNReal ι (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) (fun (n : ι) => essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m (fun (x : α) => f n x) μ) (Filter.atTop.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (LinearOrder.toLattice.{u2} ι _inst_2)))))) +but is expected to have type + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ι : Type.{u2}} [_inst_1 : Countable.{succ u2} ι] [_inst_2 : LinearOrder.{u2} ι] (f : ι -> α -> ENNReal), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (OmegaCompletePartialOrder.toPartialOrder.{0} ENNReal (CompleteLattice.instOmegaCompletePartialOrder.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m (fun (x : α) => Filter.liminf.{0, u2} ENNReal ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) (fun (n : ι) => f n x) (Filter.atTop.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_2))))))) μ) (Filter.liminf.{0, u2} ENNReal ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) (fun (n : ι) => essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m (fun (x : α) => f n x) μ) (Filter.atTop.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_2))))))) +Case conversion may be inaccurate. Consider using '#align ennreal.ess_sup_liminf_le ENNReal.essSup_liminf_leₓ'. -/ theorem essSup_liminf_le {ι} [Countable ι] [LinearOrder ι] (f : ι → α → ℝ≥0∞) : essSup (fun x => atTop.liminf fun n => f n x) μ ≤ atTop.liminf fun n => essSup (fun x => f n x) μ := @@ -426,6 +652,12 @@ theorem essSup_liminf_le {ι} [Countable ι] [LinearOrder ι] (f : ι → α → exact ENNReal.limsup_liminf_le_liminf_limsup fun a b => f b a #align ennreal.ess_sup_liminf_le ENNReal.essSup_liminf_le +/- warning: ennreal.coe_ess_sup -> ENNReal.coe_essSup is a dubious translation: +lean 3 declaration is + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {f : α -> NNReal}, (Filter.IsBoundedUnder.{0, u1} NNReal α (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring))))) (MeasureTheory.Measure.ae.{u1} α m μ) f) -> (Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (essSup.{u1, 0} α NNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} NNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} NNReal NNReal.conditionallyCompleteLinearOrderBot)) m f μ)) (essSup.{u1, 0} α ENNReal (CompleteLattice.toConditionallyCompleteLattice.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder)) m (fun (x : α) => (fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (f x)) μ)) +but is expected to have type + forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {f : α -> NNReal}, (Filter.IsBoundedUnder.{0, u1} NNReal α (fun (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.3950 : NNReal) (x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.3952 : NNReal) => LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.3950 x._@.Mathlib.MeasureTheory.Function.EssSup._hyg.3952) (MeasureTheory.Measure.ae.{u1} α m μ) f) -> (Eq.{1} ENNReal (ENNReal.some (essSup.{u1, 0} α NNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} NNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} NNReal NNReal.instConditionallyCompleteLinearOrderBotNNReal)) m f μ)) (essSup.{u1, 0} α ENNReal (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} ENNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} ENNReal (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))) m (fun (x : α) => ENNReal.some (f x)) μ)) +Case conversion may be inaccurate. Consider using '#align ennreal.coe_ess_sup ENNReal.coe_essSupₓ'. -/ theorem coe_essSup {f : α → ℝ≥0} (hf : IsBoundedUnder (· ≤ ·) μ.ae f) : (↑(essSup f μ) : ℝ≥0∞) = essSup (fun x => f x) μ := (ENNReal.coe_sInf <| hf).trans <| diff --git a/Mathbin/RingTheory/GradedAlgebra/HomogeneousIdeal.lean b/Mathbin/RingTheory/GradedAlgebra/HomogeneousIdeal.lean index 68f827053e..886cd55d82 100644 --- a/Mathbin/RingTheory/GradedAlgebra/HomogeneousIdeal.lean +++ b/Mathbin/RingTheory/GradedAlgebra/HomogeneousIdeal.lean @@ -63,44 +63,76 @@ variable (I : Ideal A) include A +#print Ideal.IsHomogeneous /- /-- An `I : ideal A` is homogeneous if for every `r ∈ I`, all homogeneous components of `r` are in `I`.-/ def Ideal.IsHomogeneous : Prop := ∀ (i : ι) ⦃r : A⦄, r ∈ I → (DirectSum.decompose 𝒜 r i : A) ∈ I #align ideal.is_homogeneous Ideal.IsHomogeneous +-/ +#print HomogeneousIdeal /- /-- For any `semiring A`, we collect the homogeneous ideals of `A` into a type. -/ structure HomogeneousIdeal extends Submodule A A where is_homogeneous' : Ideal.IsHomogeneous 𝒜 to_submodule #align homogeneous_ideal HomogeneousIdeal +-/ variable {𝒜} +#print HomogeneousIdeal.toIdeal /- /-- Converting a homogeneous ideal to an ideal-/ def HomogeneousIdeal.toIdeal (I : HomogeneousIdeal 𝒜) : Ideal A := I.toSubmodule #align homogeneous_ideal.to_ideal HomogeneousIdeal.toIdeal +-/ +/- warning: homogeneous_ideal.is_homogeneous -> HomogeneousIdeal.isHomogeneous is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6), Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6), Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.is_homogeneous HomogeneousIdeal.isHomogeneousₓ'. -/ theorem HomogeneousIdeal.isHomogeneous (I : HomogeneousIdeal 𝒜) : I.toIdeal.Homogeneous 𝒜 := I.is_homogeneous' #align homogeneous_ideal.is_homogeneous HomogeneousIdeal.isHomogeneous +/- warning: homogeneous_ideal.to_ideal_injective -> HomogeneousIdeal.toIdeal_injective is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜], Function.Injective.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u1, u3} σ A] [_inst_3 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u2} ι] [_inst_5 : AddMonoid.{u2} ι] [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜], Function.Injective.{succ u3, succ u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_injective HomogeneousIdeal.toIdeal_injectiveₓ'. -/ theorem HomogeneousIdeal.toIdeal_injective : Function.Injective (HomogeneousIdeal.toIdeal : HomogeneousIdeal 𝒜 → Ideal A) := fun ⟨x, hx⟩ ⟨y, hy⟩ (h : x = y) => by simp [h] #align homogeneous_ideal.to_ideal_injective HomogeneousIdeal.toIdeal_injective +#print HomogeneousIdeal.setLike /- instance HomogeneousIdeal.setLike : SetLike (HomogeneousIdeal 𝒜) A where coe I := I.toIdeal coe_injective' I J h := HomogeneousIdeal.toIdeal_injective <| SetLike.coe_injective h #align homogeneous_ideal.set_like HomogeneousIdeal.setLike +-/ +/- warning: homogeneous_ideal.ext -> HomogeneousIdeal.ext is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6} {J : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6}, (Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 J)) -> (Eq.{succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) I J) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6} {J : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6}, (Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 J)) -> (Eq.{succ u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) I J) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.ext HomogeneousIdeal.extₓ'. -/ @[ext] theorem HomogeneousIdeal.ext {I J : HomogeneousIdeal 𝒜} (h : I.toIdeal = J.toIdeal) : I = J := HomogeneousIdeal.toIdeal_injective h #align homogeneous_ideal.ext HomogeneousIdeal.ext +/- warning: homogeneous_ideal.mem_iff -> HomogeneousIdeal.mem_iff is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6} {x : A}, Iff (Membership.Mem.{u3, u3} A (Ideal.{u3} A _inst_1) (SetLike.hasMem.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) x (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) (Membership.Mem.{u3, u3} A (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (SetLike.hasMem.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6)) x I) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6} {x : A}, Iff (Membership.mem.{u1, u1} A (Ideal.{u1} A _inst_1) (SetLike.instMembership.{u1, u1} (Ideal.{u1} A _inst_1) A (Submodule.setLike.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1))) x (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) (Membership.mem.{u1, u1} A (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (SetLike.instMembership.{u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) A (HomogeneousIdeal.setLike.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6)) x I) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.mem_iff HomogeneousIdeal.mem_iffₓ'. -/ @[simp] theorem HomogeneousIdeal.mem_iff {I : HomogeneousIdeal 𝒜} {x : A} : x ∈ I.toIdeal ↔ x ∈ I := Iff.rfl @@ -118,16 +150,30 @@ variable (I : Ideal A) include A +#print Ideal.homogeneousCore' /- /-- For any `I : ideal A`, not necessarily homogeneous, `I.homogeneous_core' 𝒜` is the largest homogeneous ideal of `A` contained in `I`, as an ideal. -/ def Ideal.homogeneousCore' (I : Ideal A) : Ideal A := Ideal.span (coe '' ((coe : Subtype (Homogeneous 𝒜) → A) ⁻¹' I)) #align ideal.homogeneous_core' Ideal.homogeneousCore' +-/ +/- warning: ideal.homogeneous_core'_mono -> Ideal.homogeneousCore'_mono is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] (𝒜 : ι -> σ), Monotone.{u3, u3} (Ideal.{u3} A _inst_1) (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (Ideal.homogeneousCore'.{u1, u2, u3} ι σ A _inst_1 _inst_2 𝒜) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u1, u3} σ A] (𝒜 : ι -> σ), Monotone.{u3, u3} (Ideal.{u3} A _inst_1) (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (Ideal.homogeneousCore'.{u2, u1, u3} ι σ A _inst_1 _inst_2 𝒜) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_core'_mono Ideal.homogeneousCore'_monoₓ'. -/ theorem Ideal.homogeneousCore'_mono : Monotone (Ideal.homogeneousCore' 𝒜) := fun I J I_le_J => Ideal.span_mono <| Set.image_subset _ fun x => @I_le_J _ #align ideal.homogeneous_core'_mono Ideal.homogeneousCore'_mono +/- warning: ideal.homogeneous_core'_le -> Ideal.homogeneousCore'_le is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] (𝒜 : ι -> σ) (I : Ideal.{u3} A _inst_1), LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toHasLe.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (Ideal.homogeneousCore'.{u1, u2, u3} ι σ A _inst_1 _inst_2 𝒜 I) I +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u1, u3} σ A] (𝒜 : ι -> σ) (I : Ideal.{u3} A _inst_1), LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toLE.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) (Ideal.homogeneousCore'.{u2, u1, u3} ι σ A _inst_1 _inst_2 𝒜 I) I +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_core'_le Ideal.homogeneousCore'_leₓ'. -/ theorem Ideal.homogeneousCore'_le : I.homogeneousCore' 𝒜 ≤ I := Ideal.span_le.2 <| image_preimage_subset _ _ #align ideal.homogeneous_core'_le Ideal.homogeneousCore'_le @@ -146,16 +192,34 @@ variable (I : Ideal A) include A +/- warning: ideal.is_homogeneous_iff_forall_subset -> Ideal.isHomogeneous_iff_forall_subset is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u3} A _inst_1), Iff (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (forall (i : ι), HasSubset.Subset.{u3} (Set.{u3} A) (Set.hasSubset.{u3} A) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I) (Set.preimage.{u3, u3} A A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6 i)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u1} A _inst_1), Iff (Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (forall (i : ι), HasSubset.Subset.{u1} (Set.{u1} A) (Set.instHasSubsetSet.{u1} A) (SetLike.coe.{u1, u1} (Ideal.{u1} A _inst_1) A (Submodule.setLike.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)) I) (Set.preimage.{u1, u1} A A (FunLike.coe.{succ u1, succ u1, succ u1} (AddMonoidHom.{u1, u1} A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u1, u1, u1} (AddMonoidHom.{u1, u1} A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) A A (AddZeroClass.toAdd.{u1} A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) (AddZeroClass.toAdd.{u1} A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} (AddMonoidHom.{u1, u1} A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))))) (GradedRing.proj.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6 i)) (SetLike.coe.{u1, u1} (Ideal.{u1} A _inst_1) A (Submodule.setLike.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)) I))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous_iff_forall_subset Ideal.isHomogeneous_iff_forall_subsetₓ'. -/ theorem Ideal.isHomogeneous_iff_forall_subset : I.Homogeneous 𝒜 ↔ ∀ i, (I : Set A) ⊆ GradedRing.proj 𝒜 i ⁻¹' I := Iff.rfl #align ideal.is_homogeneous_iff_forall_subset Ideal.isHomogeneous_iff_forall_subset +/- warning: ideal.is_homogeneous_iff_subset_Inter -> Ideal.isHomogeneous_iff_subset_iInter is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u3} A _inst_1), Iff (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (HasSubset.Subset.{u3} (Set.{u3} A) (Set.hasSubset.{u3} A) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I) (Set.iInter.{u3, succ u1} A ι (fun (i : ι) => Set.preimage.{u3, u3} A A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6 i)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I)))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u1} A _inst_1), Iff (Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (HasSubset.Subset.{u1} (Set.{u1} A) (Set.instHasSubsetSet.{u1} A) (SetLike.coe.{u1, u1} (Ideal.{u1} A _inst_1) A (Submodule.setLike.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)) I) (Set.iInter.{u1, succ u3} A ι (fun (i : ι) => Set.preimage.{u1, u1} A A (FunLike.coe.{succ u1, succ u1, succ u1} (AddMonoidHom.{u1, u1} A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u1, u1, u1} (AddMonoidHom.{u1, u1} A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) A A (AddZeroClass.toAdd.{u1} A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) (AddZeroClass.toAdd.{u1} A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u1, u1, u1} (AddMonoidHom.{u1, u1} A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u1, u1} A A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))))) (GradedRing.proj.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6 i)) (SetLike.coe.{u1, u1} (Ideal.{u1} A _inst_1) A (Submodule.setLike.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)) I)))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous_iff_subset_Inter Ideal.isHomogeneous_iff_subset_iInterₓ'. -/ theorem Ideal.isHomogeneous_iff_subset_iInter : I.Homogeneous 𝒜 ↔ (I : Set A) ⊆ ⋂ i, GradedRing.proj 𝒜 i ⁻¹' ↑I := subset_iInter_iff.symm #align ideal.is_homogeneous_iff_subset_Inter Ideal.isHomogeneous_iff_subset_iInter +/- warning: ideal.mul_homogeneous_element_mem_of_mem -> Ideal.mul_homogeneous_element_mem_of_mem is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : Ideal.{u3} A _inst_1} (r : A) (x : A), (SetLike.Homogeneous.{u1, u3, u2} ι A σ _inst_2 𝒜 x) -> (Membership.Mem.{u3, u3} A (Ideal.{u3} A _inst_1) (SetLike.hasMem.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) x I) -> (forall (j : ι), Membership.Mem.{u3, u3} A (Ideal.{u3} A _inst_1) (SetLike.hasMem.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6 j) (HMul.hMul.{u3, u3, u3} A A A (instHMul.{u3} A (Distrib.toHasMul.{u3} A (NonUnitalNonAssocSemiring.toDistrib.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) r x)) I) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u1, u3} σ A] [_inst_3 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u2} ι] [_inst_5 : AddMonoid.{u2} ι] [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : Ideal.{u3} A _inst_1} (r : A) (x : A), (SetLike.Homogeneous.{u2, u3, u1} ι A σ _inst_2 𝒜 x) -> (Membership.mem.{u3, u3} A (Ideal.{u3} A _inst_1) (SetLike.instMembership.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) x I) -> (forall (j : ι), Membership.mem.{u3, u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) (HMul.hMul.{u3, u3, u3} A A A (instHMul.{u3} A (NonUnitalNonAssocSemiring.toMul.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))) r x)) (Ideal.{u3} A _inst_1) (SetLike.instMembership.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6 j) (HMul.hMul.{u3, u3, u3} A A A (instHMul.{u3} A (NonUnitalNonAssocSemiring.toMul.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))) r x)) I) +Case conversion may be inaccurate. Consider using '#align ideal.mul_homogeneous_element_mem_of_mem Ideal.mul_homogeneous_element_mem_of_memₓ'. -/ theorem Ideal.mul_homogeneous_element_mem_of_mem {I : Ideal A} (r x : A) (hx₁ : Homogeneous 𝒜 x) (hx₂ : x ∈ I) (j : ι) : GradedRing.proj 𝒜 j (r * x) ∈ I := by classical @@ -171,6 +235,12 @@ theorem Ideal.mul_homogeneous_element_mem_of_mem {I : Ideal A} (r x : A) (hx₁ · exact I.zero_mem #align ideal.mul_homogeneous_element_mem_of_mem Ideal.mul_homogeneous_element_mem_of_mem +/- warning: ideal.is_homogeneous_span -> Ideal.homogeneous_span is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (s : Set.{u3} A), (forall (x : A), (Membership.Mem.{u3, u3} A (Set.{u3} A) (Set.hasMem.{u3} A) x s) -> (SetLike.Homogeneous.{u1, u3, u2} ι A σ _inst_2 𝒜 x)) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (Ideal.span.{u3} A _inst_1 s)) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u1, u3} σ A] [_inst_3 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u2} ι] [_inst_5 : AddMonoid.{u2} ι] [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (s : Set.{u3} A), (forall (x : A), (Membership.mem.{u3, u3} A (Set.{u3} A) (Set.instMembershipSet.{u3} A) x s) -> (SetLike.Homogeneous.{u2, u3, u1} ι A σ _inst_2 𝒜 x)) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (Ideal.span.{u3} A _inst_1 s)) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous_span Ideal.homogeneous_spanₓ'. -/ theorem Ideal.homogeneous_span (s : Set A) (h : ∀ x ∈ s, Homogeneous 𝒜 x) : (Ideal.span s).Homogeneous 𝒜 := by rintro i r hr @@ -188,6 +258,7 @@ theorem Ideal.homogeneous_span (s : Set A) (h : ∀ x ∈ s, Homogeneous 𝒜 x) · exact Ideal.subset_span z.2 #align ideal.is_homogeneous_span Ideal.homogeneous_span +#print Ideal.homogeneousCore /- /-- For any `I : ideal A`, not necessarily homogeneous, `I.homogeneous_core' 𝒜` is the largest homogeneous ideal of `A` contained in `I`.-/ def Ideal.homogeneousCore : HomogeneousIdeal 𝒜 := @@ -197,22 +268,47 @@ def Ideal.homogeneousCore : HomogeneousIdeal 𝒜 := rw [Subtype.image_preimage_coe] at h exact h.2⟩ #align ideal.homogeneous_core Ideal.homogeneousCore +-/ +/- warning: ideal.homogeneous_core_mono -> Ideal.homogeneousCore_mono is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜], Monotone.{u3, u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (SetLike.partialOrder.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6))) (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u1, u3} σ A] [_inst_3 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u2} ι] [_inst_5 : AddMonoid.{u2} ι] [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜], Monotone.{u3, u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (SetLike.instPartialOrder.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) A (HomogeneousIdeal.setLike.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6))) (Ideal.homogeneousCore.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_core_mono Ideal.homogeneousCore_monoₓ'. -/ theorem Ideal.homogeneousCore_mono : Monotone (Ideal.homogeneousCore 𝒜) := Ideal.homogeneousCore'_mono 𝒜 #align ideal.homogeneous_core_mono Ideal.homogeneousCore_mono +/- warning: ideal.to_ideal_homogeneous_core_le -> Ideal.toIdeal_homogeneousCore_le is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u3} A _inst_1), LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toHasLe.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) I +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u1, u3} σ A] [_inst_3 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u2} ι] [_inst_5 : AddMonoid.{u2} ι] [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u3} A _inst_1), LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toLE.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (Ideal.homogeneousCore.{u2, u1, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) I +Case conversion may be inaccurate. Consider using '#align ideal.to_ideal_homogeneous_core_le Ideal.toIdeal_homogeneousCore_leₓ'. -/ theorem Ideal.toIdeal_homogeneousCore_le : (I.homogeneousCore 𝒜).toIdeal ≤ I := Ideal.homogeneousCore'_le 𝒜 I #align ideal.to_ideal_homogeneous_core_le Ideal.toIdeal_homogeneousCore_le variable {𝒜 I} +/- warning: ideal.mem_homogeneous_core_of_is_homogeneous_of_mem -> Ideal.mem_homogeneousCore_of_homogeneous_of_mem is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : Ideal.{u3} A _inst_1} {x : A}, (SetLike.Homogeneous.{u1, u3, u2} ι A σ _inst_2 𝒜 x) -> (Membership.Mem.{u3, u3} A (Ideal.{u3} A _inst_1) (SetLike.hasMem.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) x I) -> (Membership.Mem.{u3, u3} A (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (SetLike.hasMem.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6)) x (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u1}} {A : Type.{u2}} [_inst_1 : Semiring.{u2} A] [_inst_2 : SetLike.{u1, u2} σ A] [_inst_3 : AddSubmonoidClass.{u1, u2} σ A (AddMonoid.toAddZeroClass.{u2} A (AddMonoidWithOne.toAddMonoid.{u2} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u2} A (NonAssocSemiring.toAddCommMonoidWithOne.{u2} A (Semiring.toNonAssocSemiring.{u2} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u2, u1} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : Ideal.{u2} A _inst_1} {x : A}, (SetLike.Homogeneous.{u3, u2, u1} ι A σ _inst_2 𝒜 x) -> (Membership.mem.{u2, u2} A (Ideal.{u2} A _inst_1) (SetLike.instMembership.{u2, u2} (Ideal.{u2} A _inst_1) A (Submodule.setLike.{u2, u2} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} A (Semiring.toNonAssocSemiring.{u2} A _inst_1))) (Semiring.toModule.{u2} A _inst_1))) x I) -> (Membership.mem.{u2, u2} A (HomogeneousIdeal.{u3, u1, u2} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (SetLike.instMembership.{u2, u2} (HomogeneousIdeal.{u3, u1, u2} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) A (HomogeneousIdeal.setLike.{u3, u1, u2} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6)) x (Ideal.homogeneousCore.{u3, u1, u2} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) +Case conversion may be inaccurate. Consider using '#align ideal.mem_homogeneous_core_of_is_homogeneous_of_mem Ideal.mem_homogeneousCore_of_homogeneous_of_memₓ'. -/ theorem Ideal.mem_homogeneousCore_of_homogeneous_of_mem {x : A} (h : SetLike.Homogeneous 𝒜 x) (hmem : x ∈ I) : x ∈ I.homogeneousCore 𝒜 := Ideal.subset_span ⟨⟨x, h⟩, hmem, rfl⟩ #align ideal.mem_homogeneous_core_of_is_homogeneous_of_mem Ideal.mem_homogeneousCore_of_homogeneous_of_mem +/- warning: ideal.is_homogeneous.to_ideal_homogeneous_core_eq_self -> Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_self is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : Ideal.{u3} A _inst_1}, (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) -> (Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) I) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] {I : Ideal.{u1} A _inst_1}, (Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) -> (Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (Ideal.homogeneousCore.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) I) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.to_ideal_homogeneous_core_eq_self Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_selfₓ'. -/ theorem Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_self (h : I.Homogeneous 𝒜) : (I.homogeneousCore 𝒜).toIdeal = I := by @@ -223,6 +319,12 @@ theorem Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_self (h : I.Homogeneous exact Ideal.sum_mem _ fun j hj => Ideal.subset_span ⟨⟨_, is_homogeneous_coe _⟩, h _ hx, rfl⟩ #align ideal.is_homogeneous.to_ideal_homogeneous_core_eq_self Ideal.IsHomogeneous.toIdeal_homogeneousCore_eq_self +/- warning: homogeneous_ideal.to_ideal_homogeneous_core_eq_self -> HomogeneousIdeal.toIdeal_homogeneousCore_eq_self is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6), Eq.{succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) I +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] {𝒜 : ι -> σ} [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6), Eq.{succ u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6) (Ideal.homogeneousCore.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) I +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_homogeneous_core_eq_self HomogeneousIdeal.toIdeal_homogeneousCore_eq_selfₓ'. -/ @[simp] theorem HomogeneousIdeal.toIdeal_homogeneousCore_eq_self (I : HomogeneousIdeal 𝒜) : I.toIdeal.homogeneousCore 𝒜 = I := by @@ -231,10 +333,22 @@ theorem HomogeneousIdeal.toIdeal_homogeneousCore_eq_self (I : HomogeneousIdeal variable (𝒜 I) +/- warning: ideal.is_homogeneous.iff_eq -> Ideal.IsHomogeneous.iff_eq is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u3} A _inst_1), Iff (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) I) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u1} A _inst_1), Iff (Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 (Ideal.homogeneousCore.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I)) I) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.iff_eq Ideal.IsHomogeneous.iff_eqₓ'. -/ theorem Ideal.IsHomogeneous.iff_eq : I.Homogeneous 𝒜 ↔ (I.homogeneousCore 𝒜).toIdeal = I := ⟨fun hI => hI.toIdeal_homogeneousCore_eq_self, fun hI => hI ▸ (Ideal.homogeneousCore 𝒜 I).2⟩ #align ideal.is_homogeneous.iff_eq Ideal.IsHomogeneous.iff_eq +/- warning: ideal.is_homogeneous.iff_exists -> Ideal.IsHomogeneous.iff_exists is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : SetLike.{u2, u3} σ A] [_inst_3 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u1} ι] [_inst_5 : AddMonoid.{u1} ι] [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u3} A _inst_1), Iff (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (Exists.{succ u3} (Set.{u3} (coeSort.{succ u3, succ (succ u3)} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) Type.{u3} (SetLike.hasCoeToSort.{u3, u3} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) A (Submonoid.setLike.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) (SetLike.homogeneousSubmonoid.{u1, u3, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)) 𝒜 (GradedRing.to_gradedMonoid.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6)))) (fun (S : Set.{u3} (coeSort.{succ u3, succ (succ u3)} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) Type.{u3} (SetLike.hasCoeToSort.{u3, u3} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) A (Submonoid.setLike.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) (SetLike.homogeneousSubmonoid.{u1, u3, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)) 𝒜 (GradedRing.to_gradedMonoid.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6)))) => Eq.{succ u3} (Ideal.{u3} A _inst_1) I (Ideal.span.{u3} A _inst_1 (Set.image.{u3, u3} (coeSort.{succ u3, succ (succ u3)} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) Type.{u3} (SetLike.hasCoeToSort.{u3, u3} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) A (Submonoid.setLike.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) (SetLike.homogeneousSubmonoid.{u1, u3, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)) 𝒜 (GradedRing.to_gradedMonoid.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6))) A ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (coeSort.{succ u3, succ (succ u3)} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) Type.{u3} (SetLike.hasCoeToSort.{u3, u3} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) A (Submonoid.setLike.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) (SetLike.homogeneousSubmonoid.{u1, u3, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)) 𝒜 (GradedRing.to_gradedMonoid.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6))) A (HasLiftT.mk.{succ u3, succ u3} (coeSort.{succ u3, succ (succ u3)} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) Type.{u3} (SetLike.hasCoeToSort.{u3, u3} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) A (Submonoid.setLike.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) (SetLike.homogeneousSubmonoid.{u1, u3, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)) 𝒜 (GradedRing.to_gradedMonoid.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6))) A (CoeTCₓ.coe.{succ u3, succ u3} (coeSort.{succ u3, succ (succ u3)} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) Type.{u3} (SetLike.hasCoeToSort.{u3, u3} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) A (Submonoid.setLike.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) (SetLike.homogeneousSubmonoid.{u1, u3, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)) 𝒜 (GradedRing.to_gradedMonoid.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6))) A (coeBase.{succ u3, succ u3} (coeSort.{succ u3, succ (succ u3)} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) Type.{u3} (SetLike.hasCoeToSort.{u3, u3} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) A (Submonoid.setLike.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) (SetLike.homogeneousSubmonoid.{u1, u3, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)) 𝒜 (GradedRing.to_gradedMonoid.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6))) A (coeSubtype.{succ u3} A (fun (x : A) => Membership.Mem.{u3, u3} A (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) (SetLike.hasMem.{u3, u3} (Submonoid.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)))) A (Submonoid.setLike.{u3} A (Monoid.toMulOneClass.{u3} A (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) x (SetLike.homogeneousSubmonoid.{u1, u3, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1)) 𝒜 (GradedRing.to_gradedMonoid.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6)))))))) S)))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : SetLike.{u2, u1} σ A] [_inst_3 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_2] (𝒜 : ι -> σ) [_inst_4 : DecidableEq.{succ u3} ι] [_inst_5 : AddMonoid.{u3} ι] [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜] (I : Ideal.{u1} A _inst_1), Iff (Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_2 _inst_3 𝒜 (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_6 I) (Exists.{succ u1} (Set.{u1} (Subtype.{succ u1} A (fun (x : A) => Membership.mem.{u1, u1} A (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)))) A (Submonoid.instSetLikeSubmonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1))))) x (SetLike.homogeneousSubmonoid.{u3, u1, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)) 𝒜 (GradedRing.toGradedMonoid.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6))))) (fun (S : Set.{u1} (Subtype.{succ u1} A (fun (x : A) => Membership.mem.{u1, u1} A (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)))) A (Submonoid.instSetLikeSubmonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1))))) x (SetLike.homogeneousSubmonoid.{u3, u1, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)) 𝒜 (GradedRing.toGradedMonoid.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6))))) => Eq.{succ u1} (Ideal.{u1} A _inst_1) I (Ideal.span.{u1} A _inst_1 (Set.image.{u1, u1} (Subtype.{succ u1} A (fun (x : A) => Membership.mem.{u1, u1} A (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)))) A (Submonoid.instSetLikeSubmonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1))))) x (SetLike.homogeneousSubmonoid.{u3, u1, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)) 𝒜 (GradedRing.toGradedMonoid.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6)))) A (Subtype.val.{succ u1} A (fun (x : A) => Membership.mem.{u1, u1} A (Set.{u1} A) (Set.instMembershipSet.{u1} A) x (SetLike.coe.{u1, u1} (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)))) A (Submonoid.instSetLikeSubmonoid.{u1} A (Monoid.toMulOneClass.{u1} A (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)))) (SetLike.homogeneousSubmonoid.{u3, u1, u2} ι A σ _inst_2 _inst_5 (MonoidWithZero.toMonoid.{u1} A (Semiring.toMonoidWithZero.{u1} A _inst_1)) 𝒜 (GradedRing.toGradedMonoid.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_4 a b) _inst_5 _inst_1 _inst_2 _inst_3 𝒜 _inst_6))))) S)))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.iff_exists Ideal.IsHomogeneous.iff_existsₓ'. -/ theorem Ideal.IsHomogeneous.iff_exists : I.Homogeneous 𝒜 ↔ ∃ S : Set (homogeneousSubmonoid 𝒜), I = Ideal.span (coe '' S) := by @@ -262,6 +376,12 @@ include A namespace Ideal.IsHomogeneous +/- warning: ideal.is_homogeneous.bot -> Ideal.IsHomogeneous.bot is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Bot.bot.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasBot.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Bot.bot.{u1} (Ideal.{u1} A _inst_1) (Submodule.instBotSubmodule.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.bot Ideal.IsHomogeneous.botₓ'. -/ theorem bot : Ideal.IsHomogeneous 𝒜 ⊥ := fun i r hr => by simp only [Ideal.mem_bot] at hr @@ -269,15 +389,33 @@ theorem bot : Ideal.IsHomogeneous 𝒜 ⊥ := fun i r hr => apply Ideal.zero_mem #align ideal.is_homogeneous.bot Ideal.IsHomogeneous.bot +/- warning: ideal.is_homogeneous.top -> Ideal.IsHomogeneous.top is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Top.top.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasTop.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Top.top.{u1} (Ideal.{u1} A _inst_1) (Submodule.instTopSubmodule.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.top Ideal.IsHomogeneous.topₓ'. -/ theorem top : Ideal.IsHomogeneous 𝒜 ⊤ := fun i r hr => by simp only [Submodule.mem_top] #align ideal.is_homogeneous.top Ideal.IsHomogeneous.top variable {𝒜} +/- warning: ideal.is_homogeneous.inf -> Ideal.IsHomogeneous.inf is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {I : Ideal.{u3} A _inst_1} {J : Ideal.{u3} A _inst_1}, (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Inf.inf.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I J)) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {I : Ideal.{u3} A _inst_1} {J : Ideal.{u3} A _inst_1}, (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Inf.inf.{u3} (Ideal.{u3} A _inst_1) (Submodule.instInfSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I J)) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.inf Ideal.IsHomogeneous.infₓ'. -/ theorem inf {I J : Ideal A} (HI : I.Homogeneous 𝒜) (HJ : J.Homogeneous 𝒜) : (I ⊓ J).Homogeneous 𝒜 := fun i r hr => ⟨HI _ hr.1, HJ _ hr.2⟩ #align ideal.is_homogeneous.inf Ideal.IsHomogeneous.inf +/- warning: ideal.is_homogeneous.sup -> Ideal.IsHomogeneous.sup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {I : Ideal.{u3} A _inst_1} {J : Ideal.{u3} A _inst_1}, (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Sup.sup.{u3} (Ideal.{u3} A _inst_1) (SemilatticeSup.toHasSup.{u3} (Ideal.{u3} A _inst_1) (Lattice.toSemilatticeSup.{u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toLattice.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) I J)) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {I : Ideal.{u3} A _inst_1} {J : Ideal.{u3} A _inst_1}, (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Sup.sup.{u3} (Ideal.{u3} A _inst_1) (SemilatticeSup.toSup.{u3} (Ideal.{u3} A _inst_1) (Lattice.toSemilatticeSup.{u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toLattice.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) I J)) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.sup Ideal.IsHomogeneous.supₓ'. -/ theorem sup {I J : Ideal A} (HI : I.Homogeneous 𝒜) (HJ : J.Homogeneous 𝒜) : (I ⊔ J).Homogeneous 𝒜 := by rw [iff_exists] at HI HJ⊢ @@ -287,6 +425,12 @@ theorem sup {I J : Ideal A} (HI : I.Homogeneous 𝒜) (HJ : J.Homogeneous 𝒜) exact (Submodule.span_union _ _).symm #align ideal.is_homogeneous.sup Ideal.IsHomogeneous.sup +/- warning: ideal.is_homogeneous.supr -> Ideal.IsHomogeneous.iSup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} {f : κ -> (Ideal.{u3} A _inst_1)}, (forall (i : κ), Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (f i)) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iSup.{u3, u4} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) κ (fun (i : κ) => f i))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} {f : κ -> (Ideal.{u3} A _inst_1)}, (forall (i : κ), Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (f i)) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iSup.{u3, u4} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) κ (fun (i : κ) => f i))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.supr Ideal.IsHomogeneous.iSupₓ'. -/ protected theorem iSup {κ : Sort _} {f : κ → Ideal A} (h : ∀ i, (f i).Homogeneous 𝒜) : (⨆ i, f i).Homogeneous 𝒜 := by simp_rw [iff_exists] at h⊢ @@ -297,6 +441,12 @@ protected theorem iSup {κ : Sort _} {f : κ → Ideal A} (h : ∀ i, (f i).Homo exact funext hs #align ideal.is_homogeneous.supr Ideal.IsHomogeneous.iSup +/- warning: ideal.is_homogeneous.infi -> Ideal.IsHomogeneous.iInf is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} {f : κ -> (Ideal.{u3} A _inst_1)}, (forall (i : κ), Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (f i)) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iInf.{u3, u4} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) κ (fun (i : κ) => f i))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} {f : κ -> (Ideal.{u3} A _inst_1)}, (forall (i : κ), Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (f i)) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iInf.{u3, u4} (Ideal.{u3} A _inst_1) (Submodule.instInfSetSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) κ (fun (i : κ) => f i))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.infi Ideal.IsHomogeneous.iInfₓ'. -/ protected theorem iInf {κ : Sort _} {f : κ → Ideal A} (h : ∀ i, (f i).Homogeneous 𝒜) : (⨅ i, f i).Homogeneous 𝒜 := by intro i x hx @@ -304,24 +454,48 @@ protected theorem iInf {κ : Sort _} {f : κ → Ideal A} (h : ∀ i, (f i).Homo exact fun j => h _ _ (hx j) #align ideal.is_homogeneous.infi Ideal.IsHomogeneous.iInf +/- warning: ideal.is_homogeneous.supr₂ -> Ideal.IsHomogeneous.iSup₂ is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} {κ' : κ -> Sort.{u5}} {f : forall (i : κ), (κ' i) -> (Ideal.{u3} A _inst_1)}, (forall (i : κ) (j : κ' i), Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (f i j)) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iSup.{u3, u4} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) κ (fun (i : κ) => iSup.{u3, u5} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (κ' i) (fun (j : κ' i) => f i j)))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u5}} {κ' : κ -> Sort.{u4}} {f : forall (i : κ), (κ' i) -> (Ideal.{u3} A _inst_1)}, (forall (i : κ) (j : κ' i), Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (f i j)) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iSup.{u3, u5} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) κ (fun (i : κ) => iSup.{u3, u4} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (κ' i) (fun (j : κ' i) => f i j)))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.supr₂ Ideal.IsHomogeneous.iSup₂ₓ'. -/ /- ./././Mathport/Syntax/Translate/Expr.lean:107:6: warning: expanding binder group (i j) -/ -theorem supr₂ {κ : Sort _} {κ' : κ → Sort _} {f : ∀ i, κ' i → Ideal A} +theorem iSup₂ {κ : Sort _} {κ' : κ → Sort _} {f : ∀ i, κ' i → Ideal A} (h : ∀ i j, (f i j).Homogeneous 𝒜) : (⨆ (i) (j), f i j).Homogeneous 𝒜 := IsHomogeneous.iSup fun i => IsHomogeneous.iSup <| h i -#align ideal.is_homogeneous.supr₂ Ideal.IsHomogeneous.supr₂ - +#align ideal.is_homogeneous.supr₂ Ideal.IsHomogeneous.iSup₂ + +/- warning: ideal.is_homogeneous.infi₂ -> Ideal.IsHomogeneous.iInf₂ is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} {κ' : κ -> Sort.{u5}} {f : forall (i : κ), (κ' i) -> (Ideal.{u3} A _inst_1)}, (forall (i : κ) (j : κ' i), Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (f i j)) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iInf.{u3, u4} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) κ (fun (i : κ) => iInf.{u3, u5} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) (κ' i) (fun (j : κ' i) => f i j)))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u5}} {κ' : κ -> Sort.{u4}} {f : forall (i : κ), (κ' i) -> (Ideal.{u3} A _inst_1)}, (forall (i : κ) (j : κ' i), Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (f i j)) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iInf.{u3, u5} (Ideal.{u3} A _inst_1) (Submodule.instInfSetSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) κ (fun (i : κ) => iInf.{u3, u4} (Ideal.{u3} A _inst_1) (Submodule.instInfSetSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) (κ' i) (fun (j : κ' i) => f i j)))) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.infi₂ Ideal.IsHomogeneous.iInf₂ₓ'. -/ /- ./././Mathport/Syntax/Translate/Expr.lean:107:6: warning: expanding binder group (i j) -/ -theorem infi₂ {κ : Sort _} {κ' : κ → Sort _} {f : ∀ i, κ' i → Ideal A} +theorem iInf₂ {κ : Sort _} {κ' : κ → Sort _} {f : ∀ i, κ' i → Ideal A} (h : ∀ i j, (f i j).Homogeneous 𝒜) : (⨅ (i) (j), f i j).Homogeneous 𝒜 := IsHomogeneous.iInf fun i => IsHomogeneous.iInf <| h i -#align ideal.is_homogeneous.infi₂ Ideal.IsHomogeneous.infi₂ - +#align ideal.is_homogeneous.infi₂ Ideal.IsHomogeneous.iInf₂ + +/- warning: ideal.is_homogeneous.Sup -> Ideal.IsHomogeneous.sSup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {ℐ : Set.{u3} (Ideal.{u3} A _inst_1)}, (forall (I : Ideal.{u3} A _inst_1), (Membership.Mem.{u3, u3} (Ideal.{u3} A _inst_1) (Set.{u3} (Ideal.{u3} A _inst_1)) (Set.hasMem.{u3} (Ideal.{u3} A _inst_1)) I ℐ) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I)) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (SupSet.sSup.{u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) ℐ)) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {ℐ : Set.{u3} (Ideal.{u3} A _inst_1)}, (forall (I : Ideal.{u3} A _inst_1), (Membership.mem.{u3, u3} (Ideal.{u3} A _inst_1) (Set.{u3} (Ideal.{u3} A _inst_1)) (Set.instMembershipSet.{u3} (Ideal.{u3} A _inst_1)) I ℐ) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I)) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (SupSet.sSup.{u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) ℐ)) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.Sup Ideal.IsHomogeneous.sSupₓ'. -/ theorem sSup {ℐ : Set (Ideal A)} (h : ∀ I ∈ ℐ, Ideal.IsHomogeneous 𝒜 I) : (sSup ℐ).Homogeneous 𝒜 := by rw [sSup_eq_iSup] exact supr₂ h #align ideal.is_homogeneous.Sup Ideal.IsHomogeneous.sSup +/- warning: ideal.is_homogeneous.Inf -> Ideal.IsHomogeneous.sInf is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {ℐ : Set.{u3} (Ideal.{u3} A _inst_1)}, (forall (I : Ideal.{u3} A _inst_1), (Membership.Mem.{u3, u3} (Ideal.{u3} A _inst_1) (Set.{u3} (Ideal.{u3} A _inst_1)) (Set.hasMem.{u3} (Ideal.{u3} A _inst_1)) I ℐ) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I)) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (InfSet.sInf.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) ℐ)) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {ℐ : Set.{u3} (Ideal.{u3} A _inst_1)}, (forall (I : Ideal.{u3} A _inst_1), (Membership.mem.{u3, u3} (Ideal.{u3} A _inst_1) (Set.{u3} (Ideal.{u3} A _inst_1)) (Set.instMembershipSet.{u3} (Ideal.{u3} A _inst_1)) I ℐ) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I)) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (InfSet.sInf.{u3} (Ideal.{u3} A _inst_1) (Submodule.instInfSetSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) ℐ)) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.Inf Ideal.IsHomogeneous.sInfₓ'. -/ theorem sInf {ℐ : Set (Ideal A)} (h : ∀ I ∈ ℐ, Ideal.IsHomogeneous 𝒜 I) : (sInf ℐ).Homogeneous 𝒜 := by rw [sInf_eq_iInf] @@ -350,90 +524,186 @@ instance : Inf (HomogeneousIdeal 𝒜) := ⟨fun I J => ⟨_, I.Homogeneous.inf J.Homogeneous⟩⟩ instance : SupSet (HomogeneousIdeal 𝒜) := - ⟨fun S => ⟨⨆ s ∈ S, toIdeal s, Ideal.IsHomogeneous.supr₂ fun s _ => s.Homogeneous⟩⟩ + ⟨fun S => ⟨⨆ s ∈ S, toIdeal s, Ideal.IsHomogeneous.iSup₂ fun s _ => s.Homogeneous⟩⟩ instance : InfSet (HomogeneousIdeal 𝒜) := - ⟨fun S => ⟨⨅ s ∈ S, toIdeal s, Ideal.IsHomogeneous.infi₂ fun s _ => s.Homogeneous⟩⟩ - + ⟨fun S => ⟨⨅ s ∈ S, toIdeal s, Ideal.IsHomogeneous.iInf₂ fun s _ => s.Homogeneous⟩⟩ + +/- warning: homogeneous_ideal.coe_top -> HomogeneousIdeal.coe_top is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Set.{u3} A) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)))) (Top.top.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasTop.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Set.univ.{u3} A) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Set.{u3} A) (SetLike.coe.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Top.top.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instTopHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Set.univ.{u3} A) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.coe_top HomogeneousIdeal.coe_topₓ'. -/ @[simp] theorem coe_top : ((⊤ : HomogeneousIdeal 𝒜) : Set A) = univ := rfl #align homogeneous_ideal.coe_top HomogeneousIdeal.coe_top +/- warning: homogeneous_ideal.coe_bot -> HomogeneousIdeal.coe_bot is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Set.{u3} A) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)))) (Bot.bot.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasBot.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (OfNat.ofNat.{u3} (Set.{u3} A) 0 (OfNat.mk.{u3} (Set.{u3} A) 0 (Zero.zero.{u3} (Set.{u3} A) (Set.zero.{u3} A (MulZeroClass.toHasZero.{u3} A (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Set.{u3} A) (SetLike.coe.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Bot.bot.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instBotHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (OfNat.ofNat.{u3} (Set.{u3} A) 0 (Zero.toOfNat0.{u3} (Set.{u3} A) (Set.zero.{u3} A (MonoidWithZero.toZero.{u3} A (Semiring.toMonoidWithZero.{u3} A _inst_1))))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.coe_bot HomogeneousIdeal.coe_botₓ'. -/ @[simp] theorem coe_bot : ((⊥ : HomogeneousIdeal 𝒜) : Set A) = 0 := rfl #align homogeneous_ideal.coe_bot HomogeneousIdeal.coe_bot +/- warning: homogeneous_ideal.coe_sup -> HomogeneousIdeal.coe_sup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u3} (Set.{u3} A) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)))) (Sup.sup.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasSup.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) I J)) (HAdd.hAdd.{u3, u3, u3} (Set.{u3} A) (Set.{u3} A) (Set.{u3} A) (instHAdd.{u3} (Set.{u3} A) (Set.add.{u3} A (Distrib.toHasAdd.{u3} A (NonUnitalNonAssocSemiring.toDistrib.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)))) I) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)))) J)) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u1} (Set.{u1} A) (SetLike.coe.{u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Sup.sup.{u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instSupHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) I J)) (HAdd.hAdd.{u1, u1, u1} (Set.{u1} A) (Set.{u1} A) (Set.{u1} A) (instHAdd.{u1} (Set.{u1} A) (Set.add.{u1} A (Distrib.toAdd.{u1} A (NonUnitalNonAssocSemiring.toDistrib.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1)))))) (SetLike.coe.{u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) I) (SetLike.coe.{u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) J)) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.coe_sup HomogeneousIdeal.coe_supₓ'. -/ @[simp] theorem coe_sup (I J : HomogeneousIdeal 𝒜) : ↑(I ⊔ J) = (I + J : Set A) := Submodule.coe_sup _ _ #align homogeneous_ideal.coe_sup HomogeneousIdeal.coe_sup +/- warning: homogeneous_ideal.coe_inf -> HomogeneousIdeal.coe_inf is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u3} (Set.{u3} A) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)))) (Inf.inf.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasInf.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) I J)) (Inter.inter.{u3} (Set.{u3} A) (Set.hasInter.{u3} A) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)))) I) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)))) J)) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u1} (Set.{u1} A) (SetLike.coe.{u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Inf.inf.{u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instInfHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) I J)) (Inter.inter.{u1} (Set.{u1} A) (Set.instInterSet.{u1} A) (SetLike.coe.{u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) I) (SetLike.coe.{u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) A (HomogeneousIdeal.setLike.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) J)) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.coe_inf HomogeneousIdeal.coe_infₓ'. -/ @[simp] theorem coe_inf (I J : HomogeneousIdeal 𝒜) : (↑(I ⊓ J) : Set A) = I ∩ J := rfl #align homogeneous_ideal.coe_inf HomogeneousIdeal.coe_inf +/- warning: homogeneous_ideal.to_ideal_top -> HomogeneousIdeal.toIdeal_top is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Top.top.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasTop.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Top.top.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasTop.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Top.top.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instTopHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Top.top.{u3} (Ideal.{u3} A _inst_1) (Submodule.instTopSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_top HomogeneousIdeal.toIdeal_topₓ'. -/ @[simp] theorem toIdeal_top : (⊤ : HomogeneousIdeal 𝒜).toIdeal = (⊤ : Ideal A) := rfl #align homogeneous_ideal.to_ideal_top HomogeneousIdeal.toIdeal_top +/- warning: homogeneous_ideal.to_ideal_bot -> HomogeneousIdeal.toIdeal_bot is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Bot.bot.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasBot.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Bot.bot.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasBot.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Bot.bot.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instBotHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Bot.bot.{u3} (Ideal.{u3} A _inst_1) (Submodule.instBotSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_bot HomogeneousIdeal.toIdeal_botₓ'. -/ @[simp] theorem toIdeal_bot : (⊥ : HomogeneousIdeal 𝒜).toIdeal = (⊥ : Ideal A) := rfl #align homogeneous_ideal.to_ideal_bot HomogeneousIdeal.toIdeal_bot +/- warning: homogeneous_ideal.to_ideal_sup -> HomogeneousIdeal.toIdeal_sup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Sup.sup.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasSup.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) I J)) (Sup.sup.{u3} (Ideal.{u3} A _inst_1) (SemilatticeSup.toHasSup.{u3} (Ideal.{u3} A _inst_1) (Lattice.toSemilatticeSup.{u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toLattice.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Sup.sup.{u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instSupHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) I J)) (Sup.sup.{u1} (Ideal.{u1} A _inst_1) (SemilatticeSup.toSup.{u1} (Ideal.{u1} A _inst_1) (Lattice.toSemilatticeSup.{u1} (Ideal.{u1} A _inst_1) (ConditionallyCompleteLattice.toLattice.{u1} (Ideal.{u1} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Ideal.{u1} A _inst_1) (Submodule.completeLattice.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)))))) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_sup HomogeneousIdeal.toIdeal_supₓ'. -/ @[simp] theorem toIdeal_sup (I J : HomogeneousIdeal 𝒜) : (I ⊔ J).toIdeal = I.toIdeal ⊔ J.toIdeal := rfl #align homogeneous_ideal.to_ideal_sup HomogeneousIdeal.toIdeal_sup +/- warning: homogeneous_ideal.to_ideal_inf -> HomogeneousIdeal.toIdeal_inf is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Inf.inf.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasInf.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) I J)) (Inf.inf.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Inf.inf.{u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instInfHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) I J)) (Inf.inf.{u1} (Ideal.{u1} A _inst_1) (Submodule.instInfSubmodule.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_inf HomogeneousIdeal.toIdeal_infₓ'. -/ @[simp] theorem toIdeal_inf (I J : HomogeneousIdeal 𝒜) : (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal := rfl #align homogeneous_ideal.to_ideal_inf HomogeneousIdeal.toIdeal_inf +/- warning: homogeneous_ideal.to_ideal_Sup -> HomogeneousIdeal.toIdeal_sSup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (ℐ : Set.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (SupSet.sSup.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasSup.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) ℐ)) (iSup.{u3, succ u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (fun (s : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) => iSup.{u3, 0} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (Membership.Mem.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) (Set.hasMem.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) s ℐ) (fun (H : Membership.Mem.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) (Set.hasMem.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) s ℐ) => HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 s))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (ℐ : Set.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (SupSet.sSup.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instSupSetHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) ℐ)) (iSup.{u3, succ u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (fun (s : HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) => iSup.{u3, 0} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (Membership.mem.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) (Set.instMembershipSet.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) s ℐ) (fun (H : Membership.mem.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) (Set.instMembershipSet.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) s ℐ) => HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 s))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_Sup HomogeneousIdeal.toIdeal_sSupₓ'. -/ @[simp] theorem toIdeal_sSup (ℐ : Set (HomogeneousIdeal 𝒜)) : (sSup ℐ).toIdeal = ⨆ s ∈ ℐ, toIdeal s := rfl #align homogeneous_ideal.to_ideal_Sup HomogeneousIdeal.toIdeal_sSup +/- warning: homogeneous_ideal.to_ideal_Inf -> HomogeneousIdeal.toIdeal_sInf is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (ℐ : Set.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (InfSet.sInf.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasInf.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) ℐ)) (iInf.{u3, succ u3} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (fun (s : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) => iInf.{u3, 0} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) (Membership.Mem.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) (Set.hasMem.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) s ℐ) (fun (H : Membership.Mem.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) (Set.hasMem.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) s ℐ) => HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 s))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (ℐ : Set.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (InfSet.sInf.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instInfSetHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) ℐ)) (iInf.{u3, succ u3} (Ideal.{u3} A _inst_1) (Submodule.instInfSetSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (fun (s : HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) => iInf.{u3, 0} (Ideal.{u3} A _inst_1) (Submodule.instInfSetSubmodule.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) (Membership.mem.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) (Set.instMembershipSet.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) s ℐ) (fun (H : Membership.mem.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Set.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) (Set.instMembershipSet.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)) s ℐ) => HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 s))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_Inf HomogeneousIdeal.toIdeal_sInfₓ'. -/ @[simp] theorem toIdeal_sInf (ℐ : Set (HomogeneousIdeal 𝒜)) : (sInf ℐ).toIdeal = ⨅ s ∈ ℐ, toIdeal s := rfl #align homogeneous_ideal.to_ideal_Inf HomogeneousIdeal.toIdeal_sInf +/- warning: homogeneous_ideal.to_ideal_supr -> HomogeneousIdeal.toIdeal_iSup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} (s : κ -> (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iSup.{u3, u4} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasSup.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) κ (fun (i : κ) => s i))) (iSup.{u3, u4} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) κ (fun (i : κ) => HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (s i))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} (s : κ -> (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iSup.{u1, u4} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instSupSetHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) κ (fun (i : κ) => s i))) (iSup.{u1, u4} (Ideal.{u1} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u1} (Ideal.{u1} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Ideal.{u1} A _inst_1) (Submodule.completeLattice.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)))) κ (fun (i : κ) => HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (s i))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_supr HomogeneousIdeal.toIdeal_iSupₓ'. -/ @[simp] theorem toIdeal_iSup {κ : Sort _} (s : κ → HomogeneousIdeal 𝒜) : (⨆ i, s i).toIdeal = ⨆ i, (s i).toIdeal := by rw [iSup, to_ideal_Sup, iSup_range] #align homogeneous_ideal.to_ideal_supr HomogeneousIdeal.toIdeal_iSup +/- warning: homogeneous_ideal.to_ideal_infi -> HomogeneousIdeal.toIdeal_iInf is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} (s : κ -> (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iInf.{u3, u4} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasInf.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) κ (fun (i : κ) => s i))) (iInf.{u3, u4} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) κ (fun (i : κ) => HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (s i))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} (s : κ -> (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iInf.{u1, u4} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instInfSetHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) κ (fun (i : κ) => s i))) (iInf.{u1, u4} (Ideal.{u1} A _inst_1) (Submodule.instInfSetSubmodule.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)) κ (fun (i : κ) => HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (s i))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_infi HomogeneousIdeal.toIdeal_iInfₓ'. -/ @[simp] theorem toIdeal_iInf {κ : Sort _} (s : κ → HomogeneousIdeal 𝒜) : (⨅ i, s i).toIdeal = ⨅ i, (s i).toIdeal := by rw [iInf, to_ideal_Inf, iInf_range] #align homogeneous_ideal.to_ideal_infi HomogeneousIdeal.toIdeal_iInf +/- warning: homogeneous_ideal.to_ideal_supr₂ -> HomogeneousIdeal.toIdeal_iSup₂ is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} {κ' : κ -> Sort.{u5}} (s : forall (i : κ), (κ' i) -> (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iSup.{u3, u4} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasSup.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) κ (fun (i : κ) => iSup.{u3, u5} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasSup.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (κ' i) (fun (j : κ' i) => s i j)))) (iSup.{u3, u4} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) κ (fun (i : κ) => iSup.{u3, u5} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (κ' i) (fun (j : κ' i) => HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (s i j)))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u5}} {κ' : κ -> Sort.{u4}} (s : forall (i : κ), (κ' i) -> (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iSup.{u1, u5} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instSupSetHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) κ (fun (i : κ) => iSup.{u1, u4} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instSupSetHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (κ' i) (fun (j : κ' i) => s i j)))) (iSup.{u1, u5} (Ideal.{u1} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u1} (Ideal.{u1} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Ideal.{u1} A _inst_1) (Submodule.completeLattice.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)))) κ (fun (i : κ) => iSup.{u1, u4} (Ideal.{u1} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u1} (Ideal.{u1} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Ideal.{u1} A _inst_1) (Submodule.completeLattice.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)))) (κ' i) (fun (j : κ' i) => HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (s i j)))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_supr₂ HomogeneousIdeal.toIdeal_iSup₂ₓ'. -/ /- ./././Mathport/Syntax/Translate/Expr.lean:107:6: warning: expanding binder group (i j) -/ /- ./././Mathport/Syntax/Translate/Expr.lean:107:6: warning: expanding binder group (i j) -/ @[simp] -theorem toIdeal_supr₂ {κ : Sort _} {κ' : κ → Sort _} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) : +theorem toIdeal_iSup₂ {κ : Sort _} {κ' : κ → Sort _} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) : (⨆ (i) (j), s i j).toIdeal = ⨆ (i) (j), (s i j).toIdeal := by simp_rw [to_ideal_supr] -#align homogeneous_ideal.to_ideal_supr₂ HomogeneousIdeal.toIdeal_supr₂ - +#align homogeneous_ideal.to_ideal_supr₂ HomogeneousIdeal.toIdeal_iSup₂ + +/- warning: homogeneous_ideal.to_ideal_infi₂ -> HomogeneousIdeal.toIdeal_iInf₂ is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u4}} {κ' : κ -> Sort.{u5}} (s : forall (i : κ), (κ' i) -> (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iInf.{u3, u4} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasInf.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) κ (fun (i : κ) => iInf.{u3, u5} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasInf.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (κ' i) (fun (j : κ' i) => s i j)))) (iInf.{u3, u4} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) κ (fun (i : κ) => iInf.{u3, u5} (Ideal.{u3} A _inst_1) (Submodule.hasInf.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) (κ' i) (fun (j : κ' i) => HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (s i j)))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {κ : Sort.{u5}} {κ' : κ -> Sort.{u4}} (s : forall (i : κ), (κ' i) -> (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6)), Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (iInf.{u1, u5} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instInfSetHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) κ (fun (i : κ) => iInf.{u1, u4} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instInfSetHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (κ' i) (fun (j : κ' i) => s i j)))) (iInf.{u1, u5} (Ideal.{u1} A _inst_1) (Submodule.instInfSetSubmodule.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)) κ (fun (i : κ) => iInf.{u1, u4} (Ideal.{u1} A _inst_1) (Submodule.instInfSetSubmodule.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)) (κ' i) (fun (j : κ' i) => HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (s i j)))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_infi₂ HomogeneousIdeal.toIdeal_iInf₂ₓ'. -/ /- ./././Mathport/Syntax/Translate/Expr.lean:107:6: warning: expanding binder group (i j) -/ /- ./././Mathport/Syntax/Translate/Expr.lean:107:6: warning: expanding binder group (i j) -/ @[simp] -theorem toIdeal_infi₂ {κ : Sort _} {κ' : κ → Sort _} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) : +theorem toIdeal_iInf₂ {κ : Sort _} {κ' : κ → Sort _} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) : (⨅ (i) (j), s i j).toIdeal = ⨅ (i) (j), (s i j).toIdeal := by simp_rw [to_ideal_infi] -#align homogeneous_ideal.to_ideal_infi₂ HomogeneousIdeal.toIdeal_infi₂ - +#align homogeneous_ideal.to_ideal_infi₂ HomogeneousIdeal.toIdeal_iInf₂ + +/- warning: homogeneous_ideal.eq_top_iff -> HomogeneousIdeal.eq_top_iff is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Iff (Eq.{succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) I (Top.top.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasTop.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (Top.top.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasTop.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Iff (Eq.{succ u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) I (Top.top.{u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instTopHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (Top.top.{u1} (Ideal.{u1} A _inst_1) (Submodule.instTopSubmodule.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.eq_top_iff HomogeneousIdeal.eq_top_iffₓ'. -/ @[simp] theorem eq_top_iff (I : HomogeneousIdeal 𝒜) : I = ⊤ ↔ I.toIdeal = ⊤ := toIdeal_injective.eq_iff.symm #align homogeneous_ideal.eq_top_iff HomogeneousIdeal.eq_top_iff +/- warning: homogeneous_ideal.eq_bot_iff -> HomogeneousIdeal.eq_bot_iff is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Iff (Eq.{succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) I (Bot.bot.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasBot.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (Bot.bot.{u3} (Ideal.{u3} A _inst_1) (Submodule.hasBot.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Iff (Eq.{succ u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) I (Bot.bot.{u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instBotHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6))) (Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (Bot.bot.{u1} (Ideal.{u1} A _inst_1) (Submodule.instBotSubmodule.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.eq_bot_iff HomogeneousIdeal.eq_bot_iffₓ'. -/ @[simp] theorem eq_bot_iff (I : HomogeneousIdeal 𝒜) : I = ⊥ ↔ I.toIdeal = ⊥ := toIdeal_injective.eq_iff.symm @@ -446,6 +716,12 @@ instance : CompleteLattice (HomogeneousIdeal 𝒜) := instance : Add (HomogeneousIdeal 𝒜) := ⟨(· ⊔ ·)⟩ +/- warning: homogeneous_ideal.to_ideal_add -> HomogeneousIdeal.toIdeal_add is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (HAdd.hAdd.{u3, u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (instHAdd.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasAdd.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) I J)) (HAdd.hAdd.{u3, u3, u3} (Ideal.{u3} A _inst_1) (Ideal.{u3} A _inst_1) (Ideal.{u3} A _inst_1) (instHAdd.{u3} (Ideal.{u3} A _inst_1) (AddZeroClass.toHasAdd.{u3} (Ideal.{u3} A _inst_1) (AddMonoid.toAddZeroClass.{u3} (Ideal.{u3} A _inst_1) (AddCommMonoid.toAddMonoid.{u3} (Ideal.{u3} A _inst_1) (Submodule.pointwiseAddCommMonoid.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (HAdd.hAdd.{u1, u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (instHAdd.{u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instAddHomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) I J)) (HAdd.hAdd.{u1, u1, u1} (Ideal.{u1} A _inst_1) (Ideal.{u1} A _inst_1) (Ideal.{u1} A _inst_1) (instHAdd.{u1} (Ideal.{u1} A _inst_1) (AddZeroClass.toAdd.{u1} (Ideal.{u1} A _inst_1) (AddMonoid.toAddZeroClass.{u1} (Ideal.{u1} A _inst_1) (AddCommMonoid.toAddMonoid.{u1} (Ideal.{u1} A _inst_1) (Submodule.pointwiseAddCommMonoid.{u1, u1} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))) (Semiring.toModule.{u1} A _inst_1)))))) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_add HomogeneousIdeal.toIdeal_addₓ'. -/ @[simp] theorem toIdeal_add (I J : HomogeneousIdeal 𝒜) : (I + J).toIdeal = I.toIdeal + J.toIdeal := rfl @@ -469,6 +745,12 @@ variable (I : Ideal A) include A +/- warning: ideal.is_homogeneous.mul -> Ideal.IsHomogeneous.mul is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : CommSemiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜] {I : Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)} {J : Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)}, (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) -> (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (HMul.hMul.{u3, u3, u3} (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (instHMul.{u3} (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.hasMul.{u3} A _inst_1)) I J)) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : CommSemiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜] {I : Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)} {J : Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)}, (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) -> (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (HMul.hMul.{u3, u3, u3} (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (instHMul.{u3} (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.instMulIdealToSemiring.{u3} A _inst_1)) I J)) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.mul Ideal.IsHomogeneous.mulₓ'. -/ theorem Ideal.IsHomogeneous.mul {I J : Ideal A} (HI : I.Homogeneous 𝒜) (HJ : J.Homogeneous 𝒜) : (I * J).Homogeneous 𝒜 := by @@ -483,6 +765,12 @@ variable {𝒜} instance : Mul (HomogeneousIdeal 𝒜) where mul I J := ⟨I.toIdeal * J.toIdeal, I.Homogeneous.mul J.Homogeneous⟩ +/- warning: homogeneous_ideal.to_ideal_mul -> HomogeneousIdeal.toIdeal_mul is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : CommSemiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u3} (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (HMul.hMul.{u3, u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (instHMul.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasMul.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) I J)) (HMul.hMul.{u3, u3, u3} (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (instHMul.{u3} (Ideal.{u3} A (CommSemiring.toSemiring.{u3} A _inst_1)) (Ideal.hasMul.{u3} A _inst_1)) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A (CommSemiring.toSemiring.{u3} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : CommSemiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A (CommSemiring.toSemiring.{u1} A _inst_1)))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (J : HomogeneousIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u1} (Ideal.{u1} A (CommSemiring.toSemiring.{u1} A _inst_1)) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (HMul.hMul.{u1, u1, u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (instHMul.{u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (instMulHomogeneousIdealToSemiring.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) I J)) (HMul.hMul.{u1, u1, u1} (Ideal.{u1} A (CommSemiring.toSemiring.{u1} A _inst_1)) (Ideal.{u1} A (CommSemiring.toSemiring.{u1} A _inst_1)) (Ideal.{u1} A (CommSemiring.toSemiring.{u1} A _inst_1)) (instHMul.{u1} (Ideal.{u1} A (CommSemiring.toSemiring.{u1} A _inst_1)) (Ideal.instMulIdealToSemiring.{u1} A _inst_1)) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A (CommSemiring.toSemiring.{u1} A _inst_1) _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_mul HomogeneousIdeal.toIdeal_mulₓ'. -/ @[simp] theorem HomogeneousIdeal.toIdeal_mul (I J : HomogeneousIdeal 𝒜) : (I * J).toIdeal = I.toIdeal * J.toIdeal := @@ -511,11 +799,23 @@ variable (I : Ideal A) include A +/- warning: ideal.homogeneous_core.gc -> Ideal.homogeneousCore.gc is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], GaloisConnection.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.partialOrder.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], GaloisConnection.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instPartialOrderHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousCore.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_core.gc Ideal.homogeneousCore.gcₓ'. -/ theorem Ideal.homogeneousCore.gc : GaloisConnection toIdeal (Ideal.homogeneousCore 𝒜) := fun I J => ⟨fun H => I.toIdeal_homogeneousCore_eq_self ▸ Ideal.homogeneousCore_mono 𝒜 H, fun H => le_trans H (Ideal.homogeneousCore'_le _ _)⟩ #align ideal.homogeneous_core.gc Ideal.homogeneousCore.gc +/- warning: ideal.homogeneous_core.gi -> Ideal.homogeneousCore.gi is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], GaloisCoinsertion.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.partialOrder.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) +but is expected to have type + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], GaloisCoinsertion.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instPartialOrderHomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_core.gi Ideal.homogeneousCore.giₓ'. -/ /-- `to_ideal : homogeneous_ideal 𝒜 → ideal A` and `ideal.homogeneous_core 𝒜` forms a galois coinsertion-/ def Ideal.homogeneousCore.gi : GaloisCoinsertion toIdeal (Ideal.homogeneousCore 𝒜) @@ -527,11 +827,23 @@ def Ideal.homogeneousCore.gi : GaloisCoinsertion toIdeal (Ideal.homogeneousCore choice_eq I H := le_antisymm H (I.toIdeal_homogeneousCore_le _) #align ideal.homogeneous_core.gi Ideal.homogeneousCore.gi +/- warning: ideal.homogeneous_core_eq_Sup -> Ideal.homogeneousCore_eq_sSup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousCore.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (SupSet.sSup.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasSup.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (setOf.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (fun (J : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) => LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toHasLe.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) I))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousCore.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) (SupSet.sSup.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instSupSetHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (setOf.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (fun (J : HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) => LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toLE.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) I))) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_core_eq_Sup Ideal.homogeneousCore_eq_sSupₓ'. -/ theorem Ideal.homogeneousCore_eq_sSup : I.homogeneousCore 𝒜 = sSup { J : HomogeneousIdeal 𝒜 | J.toIdeal ≤ I } := Eq.symm <| IsLUB.sSup_eq <| (Ideal.homogeneousCore.gc 𝒜).isGreatest_u.IsLUB #align ideal.homogeneous_core_eq_Sup Ideal.homogeneousCore_eq_sSup +/- warning: ideal.homogeneous_core'_eq_Sup -> Ideal.homogeneousCore'_eq_sSup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (Ideal.{u3} A _inst_1) (Ideal.homogeneousCore'.{u1, u2, u3} ι σ A _inst_1 _inst_4 𝒜 I) (SupSet.sSup.{u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (setOf.{u3} (Ideal.{u3} A _inst_1) (fun (J : Ideal.{u3} A _inst_1) => And (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) (LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toHasLe.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) J I)))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (Ideal.{u3} A _inst_1) (Ideal.homogeneousCore'.{u2, u1, u3} ι σ A _inst_1 _inst_4 𝒜 I) (SupSet.sSup.{u3} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (setOf.{u3} (Ideal.{u3} A _inst_1) (fun (J : Ideal.{u3} A _inst_1) => And (Ideal.IsHomogeneous.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J) (LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toLE.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) J I)))) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_core'_eq_Sup Ideal.homogeneousCore'_eq_sSupₓ'. -/ theorem Ideal.homogeneousCore'_eq_sSup : I.homogeneousCore' 𝒜 = sSup { J : Ideal A | J.Homogeneous 𝒜 ∧ J ≤ I } := by @@ -562,6 +874,7 @@ variable (I : Ideal A) include A +#print Ideal.homogeneousHull /- /-- For any `I : ideal A`, not necessarily homogeneous, `I.homogeneous_hull 𝒜` is the smallest homogeneous ideal containing `I`. -/ def Ideal.homogeneousHull : HomogeneousIdeal 𝒜 := @@ -571,7 +884,14 @@ def Ideal.homogeneousHull : HomogeneousIdeal 𝒜 := obtain ⟨i, x, rfl⟩ := hx apply SetLike.homogeneous_coe⟩ #align ideal.homogeneous_hull Ideal.homogeneousHull +-/ +/- warning: ideal.le_to_ideal_homogeneous_hull -> Ideal.le_toIdeal_homogeneousHull is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toHasLe.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I)) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toLE.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) I (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Ideal.homogeneousHull.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I)) +Case conversion may be inaccurate. Consider using '#align ideal.le_to_ideal_homogeneous_hull Ideal.le_toIdeal_homogeneousHullₓ'. -/ theorem Ideal.le_toIdeal_homogeneousHull : I ≤ (Ideal.homogeneousHull 𝒜 I).toIdeal := by intro r hr @@ -585,6 +905,12 @@ theorem Ideal.le_toIdeal_homogeneousHull : I ≤ (Ideal.homogeneousHull 𝒜 I). rfl #align ideal.le_to_ideal_homogeneous_hull Ideal.le_toIdeal_homogeneousHull +/- warning: ideal.homogeneous_hull_mono -> Ideal.homogeneousHull_mono is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Monotone.{u3, u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.partialOrder.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], Monotone.{u3, u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instPartialOrderHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (Ideal.homogeneousHull.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_hull_mono Ideal.homogeneousHull_monoₓ'. -/ theorem Ideal.homogeneousHull_mono : Monotone (Ideal.homogeneousHull 𝒜) := fun I J I_le_J => by apply Ideal.span_mono @@ -594,6 +920,12 @@ theorem Ideal.homogeneousHull_mono : Monotone (Ideal.homogeneousHull 𝒜) := fu variable {I 𝒜} +/- warning: ideal.is_homogeneous.to_ideal_homogeneous_hull_eq_self -> Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {I : Ideal.{u3} A _inst_1}, (Ideal.IsHomogeneous.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) -> (Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I)) I) +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] {I : Ideal.{u1} A _inst_1}, (Ideal.IsHomogeneous.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I) -> (Eq.{succ u1} (Ideal.{u1} A _inst_1) (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Ideal.homogeneousHull.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I)) I) +Case conversion may be inaccurate. Consider using '#align ideal.is_homogeneous.to_ideal_homogeneous_hull_eq_self Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_selfₓ'. -/ theorem Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self (h : I.Homogeneous 𝒜) : (Ideal.homogeneousHull 𝒜 I).toIdeal = I := by @@ -603,6 +935,12 @@ theorem Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self (h : I.Homogeneous exact h _ x.prop #align ideal.is_homogeneous.to_ideal_homogeneous_hull_eq_self Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self +/- warning: homogeneous_ideal.homogeneous_hull_to_ideal_eq_self -> HomogeneousIdeal.homogeneousHull_toIdeal_eq_self is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I)) I +but is expected to have type + forall {ι : Type.{u3}} {σ : Type.{u2}} {A : Type.{u1}} [_inst_1 : Semiring.{u1} A] [_inst_2 : DecidableEq.{succ u3} ι] [_inst_3 : AddMonoid.{u3} ι] [_inst_4 : SetLike.{u2, u1} σ A] [_inst_5 : AddSubmonoidClass.{u2, u1} σ A (AddMonoid.toAddZeroClass.{u1} A (AddMonoidWithOne.toAddMonoid.{u1} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} A (NonAssocSemiring.toAddCommMonoidWithOne.{u1} A (Semiring.toNonAssocSemiring.{u1} A _inst_1))))) _inst_4] {𝒜 : ι -> σ} [_inst_6 : GradedRing.{u3, u1, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6), Eq.{succ u1} (HomogeneousIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousHull.{u3, u2, u1} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 (HomogeneousIdeal.toIdeal.{u3, u2, u1} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 I)) I +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.homogeneous_hull_to_ideal_eq_self HomogeneousIdeal.homogeneousHull_toIdeal_eq_selfₓ'. -/ @[simp] theorem HomogeneousIdeal.homogeneousHull_toIdeal_eq_self (I : HomogeneousIdeal 𝒜) : I.toIdeal.homogeneousHull 𝒜 = I := @@ -611,6 +949,12 @@ theorem HomogeneousIdeal.homogeneousHull_toIdeal_eq_self (I : HomogeneousIdeal variable (I 𝒜) +/- warning: ideal.to_ideal_homogeneous_hull_eq_supr -> Ideal.toIdeal_homogeneousHull_eq_iSup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I)) (iSup.{u3, succ u1} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toHasSup.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) ι (fun (i : ι) => Ideal.span.{u3} A _inst_1 (Set.image.{u3, u3} A A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I)))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Ideal.homogeneousHull.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I)) (iSup.{u3, succ u2} (Ideal.{u3} A _inst_1) (ConditionallyCompleteLattice.toSupSet.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.toConditionallyCompleteLattice.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) ι (fun (i : ι) => Ideal.span.{u3} A _inst_1 (Set.image.{u3, u3} A A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I)))) +Case conversion may be inaccurate. Consider using '#align ideal.to_ideal_homogeneous_hull_eq_supr Ideal.toIdeal_homogeneousHull_eq_iSupₓ'. -/ theorem Ideal.toIdeal_homogeneousHull_eq_iSup : (I.homogeneousHull 𝒜).toIdeal = ⨆ i, Ideal.span (GradedRing.proj 𝒜 i '' I) := by @@ -621,6 +965,12 @@ theorem Ideal.toIdeal_homogeneousHull_eq_iSup : exists_prop, Subtype.coe_mk, SetLike.mem_coe] #align ideal.to_ideal_homogeneous_hull_eq_supr Ideal.toIdeal_homogeneousHull_eq_iSup +/- warning: ideal.homogeneous_hull_eq_supr -> Ideal.homogeneousHull_eq_iSup is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I) (iSup.{u3, succ u1} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasSup.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) ι (fun (i : ι) => HomogeneousIdeal.mk.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Ideal.span.{u3} A _inst_1 (Set.image.{u3, u3} A A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I))) (Ideal.homogeneous_span.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Set.image.{u3, u3} A A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I)) (fun (x : A) (H : Membership.Mem.{u3, u3} A (Set.{u3} A) (Set.hasMem.{u3} A) x (Set.image.{u3, u3} A A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I))) => Exists.dcases_on.{succ u3} A (fun (x_1 : A) => And (Membership.Mem.{u3, u3} A (Set.{u3} A) (Set.hasMem.{u3} A) x_1 ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I)) (Eq.{succ u3} A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x)) (fun (H : Membership.Mem.{u3, u3} A (Set.{u3} A) (Set.hasMem.{u3} A) x (Set.image.{u3, u3} A A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I))) => SetLike.Homogeneous.{u1, u3, u2} ι A σ _inst_4 𝒜 x) H (fun (x_1 : A) (H_h : And (Membership.Mem.{u3, u3} A (Set.{u3} A) (Set.hasMem.{u3} A) x_1 ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I)) (Eq.{succ u3} A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x)) => And.dcasesOn.{0} (Membership.Mem.{u3, u3} A (Set.{u3} A) (Set.hasMem.{u3} A) x_1 ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I)) (Eq.{succ u3} A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x) (fun (H_h : And (Membership.Mem.{u3, u3} A (Set.{u3} A) (Set.hasMem.{u3} A) x_1 ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I)) (Eq.{succ u3} A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x)) => SetLike.Homogeneous.{u1, u3, u2} ι A σ _inst_4 𝒜 x) H_h (fun (H_h_left : Membership.Mem.{u3, u3} A (Set.{u3} A) (Set.hasMem.{u3} A) x_1 ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (Ideal.{u3} A _inst_1) (Set.{u3} A) (HasLiftT.mk.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (CoeTCₓ.coe.{succ u3, succ u3} (Ideal.{u3} A _inst_1) (Set.{u3} A) (SetLike.Set.hasCoeT.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I)) (H_h_right : Eq.{succ u3} A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x) => Eq.ndrec.{0, succ u3} A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) (fun (x : A) => SetLike.Homogeneous.{u1, u3, u2} ι A σ _inst_4 𝒜 x) (SetLike.homogeneous_coe.{u1, u3, u2} ι A σ _inst_4 𝒜 i (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A (coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddSubmonoidClass.toAddZeroClass.{u3, u2} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i))) (fun (_x : AddMonoidHom.{u3, u3} A (coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddSubmonoidClass.toAddZeroClass.{u3, u2} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i))) => A -> (coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i))) (AddMonoidHom.hasCoeToFun.{u3, u3} A (coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddSubmonoidClass.toAddZeroClass.{u3, u2} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i))) (AddMonoidHom.comp.{u3, max u1 u3, u3} A (Dfinsupp.{u1, u3} ι (fun (i : ι) => (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (fun (i : ι) => AddZeroClass.toHasZero.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (AddMonoid.toAddZeroClass.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (AddCommMonoid.toAddMonoid.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) ((fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i) i))))) ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (Dfinsupp.addZeroClass.{u1, u3} ι (fun (i : ι) => (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (fun (i : ι) => AddMonoid.toAddZeroClass.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (AddCommMonoid.toAddMonoid.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) ((fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i) i)))) (AddMonoid.toAddZeroClass.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (AddCommMonoid.toAddMonoid.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) ((fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i) i))) (Dfinsupp.evalAddMonoidHom.{u1, u3} ι (fun (i : ι) => (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (fun (i : ι) => AddMonoid.toAddZeroClass.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) (AddCommMonoid.toAddMonoid.{u3} ((fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) i) ((fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i) i))) i) (RingHom.toAddMonoidHom.{u3, max u1 u3} A (DirectSum.{u1, u3} ι (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)) (Semiring.toNonAssocSemiring.{u3} A _inst_1) (Semiring.toNonAssocSemiring.{max u1 u3} (DirectSum.{u1, u3} ι (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)) (DirectSum.semiring.{u1, u3} ι (fun (a : ι) (b : ι) => (fun (a : ι) (b : ι) => _inst_2 a b) a b) (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i) _inst_3 (SetLike.gsemiring.{u1, u2, u3} ι σ A (fun (a : ι) (b : ι) => (fun (a : ι) (b : ι) => _inst_2 a b) a b) _inst_3 _inst_1 _inst_4 _inst_5 (fun (i : ι) => 𝒜 i) (GradedRing.proj._proof_1.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6)))) (RingEquiv.toRingHom.{u3, max u1 u3} A (DirectSum.{u1, u3} ι (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)) (Semiring.toNonAssocSemiring.{u3} A _inst_1) (Semiring.toNonAssocSemiring.{max u1 u3} (DirectSum.{u1, u3} ι (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)) (DirectSum.semiring.{u1, u3} ι (fun (a : ι) (b : ι) => (fun (a : ι) (b : ι) => _inst_2 a b) a b) (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} σ Type.{u3} (SetLike.hasCoeToSort.{u2, u3} σ A _inst_4) (𝒜 i)) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i) _inst_3 (SetLike.gsemiring.{u1, u2, u3} ι σ A (fun (a : ι) (b : ι) => (fun (a : ι) (b : ι) => _inst_2 a b) a b) _inst_3 _inst_1 _inst_4 _inst_5 (fun (i : ι) => 𝒜 i) (GradedRing.proj._proof_1.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6)))) (DirectSum.decomposeRingEquiv.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => (fun (a : ι) (b : ι) => _inst_2 a b) a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6)))) x_1)) x H_h_right)))))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousHull.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I) (iSup.{u3, succ u2} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instSupSetHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) ι (fun (i : ι) => HomogeneousIdeal.mk.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Ideal.span.{u3} A _inst_1 (Set.image.{u3, u3} A A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I))) (Ideal.homogeneous_span.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 (Set.image.{u3, u3} A A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I)) (fun (x : A) (H : Membership.mem.{u3, u3} A (Set.{u3} A) (Set.instMembershipSet.{u3} A) x (Set.image.{u3, u3} A A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I))) => Exists.casesOn.{succ u3} A (fun (x_1 : A) => And (Membership.mem.{u3, u3} A (Set.{u3} A) (Set.instMembershipSet.{u3} A) x_1 (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I)) (Eq.{succ u3} A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x)) (fun (H : Membership.mem.{u3, u3} A (Set.{u3} A) (Set.instMembershipSet.{u3} A) x (Set.image.{u3, u3} A A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i)) (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I))) => SetLike.Homogeneous.{u2, u3, u1} ι A σ _inst_4 𝒜 x) H (fun (x_1 : A) (H_h : And (Membership.mem.{u3, u3} A (Set.{u3} A) (Set.instMembershipSet.{u3} A) x_1 (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I)) (Eq.{succ u3} A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x)) => And.casesOn.{0} (Membership.mem.{u3, u3} A (Set.{u3} A) (Set.instMembershipSet.{u3} A) x_1 (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I)) (Eq.{succ u3} A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x) (fun (H_h : And (Membership.mem.{u3, u3} A (Set.{u3} A) (Set.instMembershipSet.{u3} A) x_1 (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I)) (Eq.{succ u3} A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x)) => SetLike.Homogeneous.{u2, u3, u1} ι A σ _inst_4 𝒜 x) H_h (fun (H_h_left : Membership.mem.{u3, u3} A (Set.{u3} A) (Set.instMembershipSet.{u3} A) x_1 (SetLike.coe.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)) I)) (H_h_right : Eq.{succ u3} A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) x) => Eq.ndrec.{0, succ u3} A (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6 i) x_1) (fun (x : A) => SetLike.Homogeneous.{u2, u3, u1} ι A σ _inst_4 𝒜 x) (SetLike.homogeneous_coe.{u2, u1, u3} ι A σ _inst_4 𝒜 i (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A (Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddSubmonoidClass.toAddZeroClass.{u3, u1} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : A) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A (Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddSubmonoidClass.toAddZeroClass.{u3, u1} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i))) A (Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} (Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (AddSubmonoidClass.toAddZeroClass.{u3, u1} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A (Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddSubmonoidClass.toAddZeroClass.{u3, u1} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i))) A (Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddSubmonoidClass.toAddZeroClass.{u3, u1} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i)) (AddMonoidHom.addMonoidHomClass.{u3, u3} A (Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddSubmonoidClass.toAddZeroClass.{u3, u1} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) σ _inst_4 _inst_5 (𝒜 i))))) (AddMonoidHom.comp.{u3, max u2 u3, u3} A (Dfinsupp.{u2, u3} ι (fun (i : ι) => (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (fun (i : ι) => AddZeroClass.toZero.{u3} ((fun (i : ι) => (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) i) (AddMonoid.toAddZeroClass.{u3} ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddCommMonoid.toAddMonoid.{u3} ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i))))) ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (Dfinsupp.addZeroClass.{u2, u3} ι (fun (i : ι) => (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (fun (i : ι) => AddMonoid.toAddZeroClass.{u3} ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddCommMonoid.toAddMonoid.{u3} ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)))) (AddMonoid.toAddZeroClass.{u3} ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddCommMonoid.toAddMonoid.{u3} ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i))) (Dfinsupp.evalAddMonoidHom.{u2, u3} ι (fun (i : ι) => (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (fun (i : ι) => AddMonoid.toAddZeroClass.{u3} ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddCommMonoid.toAddMonoid.{u3} ((fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) i) (AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i))) i) (RingHom.toAddMonoidHom.{u3, max u2 u3} A (DirectSum.{u2, u3} ι (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)) (Semiring.toNonAssocSemiring.{u3} A _inst_1) (Semiring.toNonAssocSemiring.{max u2 u3} (DirectSum.{u2, u3} ι (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)) (DirectSum.semiring.{u2, u3} ι (fun (a : ι) (b : ι) => (fun (a : ι) (b : ι) => _inst_2 a b) a b) (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i) _inst_3 (SetLike.gsemiring.{u2, u1, u3} ι σ A _inst_3 _inst_1 _inst_4 _inst_5 (fun (i : ι) => 𝒜 i) (GradedRing.proj.proof_1.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6)))) (RingEquiv.toRingHom.{u3, max u2 u3} A (DirectSum.{u2, u3} ι (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)) (Semiring.toNonAssocSemiring.{u3} A _inst_1) (Semiring.toNonAssocSemiring.{max u2 u3} (DirectSum.{u2, u3} ι (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i)) (DirectSum.semiring.{u2, u3} ι (fun (a : ι) (b : ι) => (fun (a : ι) (b : ι) => _inst_2 a b) a b) (fun (i : ι) => Subtype.{succ u3} A (fun (x : A) => Membership.mem.{u3, u1} A σ (SetLike.instMembership.{u1, u3} σ A _inst_4) x (𝒜 i))) (fun (i : ι) => AddCommMonoid.ofSubmonoidOnSemiring.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 i) _inst_3 (SetLike.gsemiring.{u2, u1, u3} ι σ A _inst_3 _inst_1 _inst_4 _inst_5 (fun (i : ι) => 𝒜 i) (GradedRing.proj.proof_1.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6)))) (DirectSum.decomposeRingEquiv.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => (fun (a : ι) (b : ι) => _inst_2 a b) a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜 _inst_6)))) x_1)) x H_h_right)))))) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_hull_eq_supr Ideal.homogeneousHull_eq_iSupₓ'. -/ theorem Ideal.homogeneousHull_eq_iSup : I.homogeneousHull 𝒜 = ⨆ i, @@ -647,11 +997,23 @@ variable [SetLike σ A] [AddSubmonoidClass σ A] (𝒜 : ι → σ) [GradedRing include A +/- warning: ideal.homogeneous_hull.gc -> Ideal.homogeneousHull.gc is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], GaloisConnection.{u3, u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.partialOrder.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], GaloisConnection.{u3, u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instPartialOrderHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (Ideal.homogeneousHull.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_hull.gc Ideal.homogeneousHull.gcₓ'. -/ theorem Ideal.homogeneousHull.gc : GaloisConnection (Ideal.homogeneousHull 𝒜) toIdeal := fun I J => ⟨le_trans (Ideal.le_toIdeal_homogeneousHull _ _), fun H => J.homogeneousHull_toIdeal_eq_self ▸ Ideal.homogeneousHull_mono 𝒜 H⟩ #align ideal.homogeneous_hull.gc Ideal.homogeneousHull.gc +/- warning: ideal.homogeneous_hull.gi -> Ideal.homogeneousHull.gi is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], GaloisInsertion.{u3, u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.partialOrder.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) +but is expected to have type + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜], GaloisInsertion.{u3, u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) (PartialOrder.toPreorder.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instPartialOrderHomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_hull.gi Ideal.homogeneousHull.giₓ'. -/ /-- `ideal.homogeneous_hull 𝒜` and `to_ideal : homogeneous_ideal 𝒜 → ideal A` form a galois insertion-/ def Ideal.homogeneousHull.gi : GaloisInsertion (Ideal.homogeneousHull 𝒜) toIdeal @@ -662,6 +1024,12 @@ def Ideal.homogeneousHull.gi : GaloisInsertion (Ideal.homogeneousHull 𝒜) toId choice_eq I H := le_antisymm (I.le_toIdeal_homogeneousHull 𝒜) H #align ideal.homogeneous_hull.gi Ideal.homogeneousHull.gi +/- warning: ideal.homogeneous_hull_eq_Inf -> Ideal.homogeneousHull_eq_sInf is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : AddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousHull.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I) (InfSet.sInf.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.hasInf.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (setOf.{u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (fun (J : HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) => LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toHasLe.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (SetLike.partialOrder.{u3, u3} (Ideal.{u3} A _inst_1) A (Submodule.setLike.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1))))) I (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : AddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_1 _inst_4 _inst_5 𝒜] (I : Ideal.{u3} A _inst_1), Eq.{succ u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (Ideal.homogeneousHull.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6 I) (InfSet.sInf.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (HomogeneousIdeal.instInfSetHomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6) (setOf.{u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) (fun (J : HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6) => LE.le.{u3} (Ideal.{u3} A _inst_1) (Preorder.toLE.{u3} (Ideal.{u3} A _inst_1) (PartialOrder.toPreorder.{u3} (Ideal.{u3} A _inst_1) (OmegaCompletePartialOrder.toPartialOrder.{u3} (Ideal.{u3} A _inst_1) (CompleteLattice.instOmegaCompletePartialOrder.{u3} (Ideal.{u3} A _inst_1) (Submodule.completeLattice.{u3, u3} A A _inst_1 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))) (Semiring.toModule.{u3} A _inst_1)))))) I (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_6 J)))) +Case conversion may be inaccurate. Consider using '#align ideal.homogeneous_hull_eq_Inf Ideal.homogeneousHull_eq_sInfₓ'. -/ theorem Ideal.homogeneousHull_eq_sInf (I : Ideal A) : Ideal.homogeneousHull 𝒜 I = sInf { J : HomogeneousIdeal 𝒜 | I ≤ J.toIdeal } := Eq.symm <| IsGLB.sInf_eq <| (Ideal.homogeneousHull.gc 𝒜).isLeast_l.IsGLB @@ -683,6 +1051,7 @@ include A open GradedRing SetLike.GradedMonoid DirectSum +#print HomogeneousIdeal.irrelevant /- /-- For a graded ring `⨁ᵢ 𝒜ᵢ` graded by a `canonically_ordered_add_monoid ι`, the irrelevant ideal refers to `⨁_{i>0} 𝒜ᵢ`, or equivalently `{a | a₀ = 0}`. This definition is used in `Proj` construction where `ι` is always `ℕ` so the irrelevant ideal is simply elements with `0` as @@ -701,13 +1070,26 @@ def HomogeneousIdeal.irrelevant : HomogeneousIdeal 𝒜 := · rw [h, hr, decompose_zero, zero_apply, ZeroMemClass.coe_zero] · rw [decompose_of_mem_ne 𝒜 (SetLike.coe_mem _) h]⟩ #align homogeneous_ideal.irrelevant HomogeneousIdeal.irrelevant +-/ +/- warning: homogeneous_ideal.mem_irrelevant_iff -> HomogeneousIdeal.mem_irrelevant_iff is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : CanonicallyOrderedAddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u1} ι (OrderedAddCommMonoid.toAddCommMonoid.{u1} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u1} ι _inst_3))) _inst_1 _inst_4 _inst_5 𝒜] (a : A), Iff (Membership.Mem.{u3, u3} A (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u1} ι (OrderedAddCommMonoid.toAddCommMonoid.{u1} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u1} ι _inst_3))) _inst_6) (SetLike.hasMem.{u3, u3} (HomogeneousIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u1} ι (OrderedAddCommMonoid.toAddCommMonoid.{u1} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u1} ι _inst_3))) _inst_6) A (HomogeneousIdeal.setLike.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u1} ι (OrderedAddCommMonoid.toAddCommMonoid.{u1} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u1} ι _inst_3))) _inst_6)) a (HomogeneousIdeal.irrelevant.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (Eq.{succ u3} A (coeFn.{succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (fun (_x : AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) => A -> A) (AddMonoidHom.hasCoeToFun.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (GradedRing.proj.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u1} ι (OrderedAddCommMonoid.toAddCommMonoid.{u1} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u1} ι _inst_3))) _inst_1 _inst_4 _inst_5 𝒜 _inst_6 (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι (AddCommMonoid.toAddMonoid.{u1} ι (OrderedAddCommMonoid.toAddCommMonoid.{u1} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u1} ι _inst_3))))))))) a) (OfNat.ofNat.{u3} A 0 (OfNat.mk.{u3} A 0 (Zero.zero.{u3} A (MulZeroClass.toHasZero.{u3} A (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} A (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u2} ι (OrderedAddCommMonoid.toAddCommMonoid.{u2} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ι _inst_3))) _inst_1 _inst_4 _inst_5 𝒜] (a : A), Iff (Membership.mem.{u3, u3} A (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u2} ι (OrderedAddCommMonoid.toAddCommMonoid.{u2} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ι _inst_3))) _inst_6) (SetLike.instMembership.{u3, u3} (HomogeneousIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u2} ι (OrderedAddCommMonoid.toAddCommMonoid.{u2} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ι _inst_3))) _inst_6) A (HomogeneousIdeal.setLike.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u2} ι (OrderedAddCommMonoid.toAddCommMonoid.{u2} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ι _inst_3))) _inst_6)) a (HomogeneousIdeal.irrelevant.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (Eq.{succ u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) a) (FunLike.coe.{succ u3, succ u3, succ u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A (fun (_x : A) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) _x) (AddHomClass.toFunLike.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddZeroClass.toAdd.{u3} A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) (AddMonoidHomClass.toAddHomClass.{u3, u3, u3} (AddMonoidHom.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))) A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoidHom.addMonoidHomClass.{u3, u3} A A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1)))))))) (GradedRing.proj.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u2} ι (OrderedAddCommMonoid.toAddCommMonoid.{u2} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ι _inst_3))) _inst_1 _inst_4 _inst_5 𝒜 _inst_6 (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddMonoid.toZero.{u2} ι (AddCommMonoid.toAddMonoid.{u2} ι (OrderedAddCommMonoid.toAddCommMonoid.{u2} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ι _inst_3))))))) a) (OfNat.ofNat.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) a) 0 (Zero.toOfNat0.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) a) (MonoidWithZero.toZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) a) (Semiring.toMonoidWithZero.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : A) => A) a) _inst_1))))) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.mem_irrelevant_iff HomogeneousIdeal.mem_irrelevant_iffₓ'. -/ @[simp] theorem HomogeneousIdeal.mem_irrelevant_iff (a : A) : a ∈ HomogeneousIdeal.irrelevant 𝒜 ↔ proj 𝒜 0 a = 0 := Iff.rfl #align homogeneous_ideal.mem_irrelevant_iff HomogeneousIdeal.mem_irrelevant_iff +/- warning: homogeneous_ideal.to_ideal_irrelevant -> HomogeneousIdeal.toIdeal_irrelevant is a dubious translation: +lean 3 declaration is + forall {ι : Type.{u1}} {σ : Type.{u2}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : CanonicallyOrderedAddMonoid.{u1} ι] [_inst_4 : SetLike.{u2, u3} σ A] [_inst_5 : AddSubmonoidClass.{u2, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u1, u3, u2} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u1} ι (OrderedAddCommMonoid.toAddCommMonoid.{u1} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u1} ι _inst_3))) _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u1, u2, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u1} ι (OrderedAddCommMonoid.toAddCommMonoid.{u1} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u1} ι _inst_3))) _inst_6 (HomogeneousIdeal.irrelevant.{u1, u2, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (RingHom.ker.{u3, u3, u3} A A (RingHom.{u3, u3} A A (Semiring.toNonAssocSemiring.{u3} A _inst_1) (Semiring.toNonAssocSemiring.{u3} A _inst_1)) _inst_1 _inst_1 (RingHom.ringHomClass.{u3, u3} A A (Semiring.toNonAssocSemiring.{u3} A _inst_1) (Semiring.toNonAssocSemiring.{u3} A _inst_1)) (GradedRing.projZeroRingHom.{u1, u3, u2} ι A σ _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) +but is expected to have type + forall {ι : Type.{u2}} {σ : Type.{u1}} {A : Type.{u3}} [_inst_1 : Semiring.{u3} A] [_inst_2 : DecidableEq.{succ u2} ι] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} ι] [_inst_4 : SetLike.{u1, u3} σ A] [_inst_5 : AddSubmonoidClass.{u1, u3} σ A (AddMonoid.toAddZeroClass.{u3} A (AddMonoidWithOne.toAddMonoid.{u3} A (AddCommMonoidWithOne.toAddMonoidWithOne.{u3} A (NonAssocSemiring.toAddCommMonoidWithOne.{u3} A (Semiring.toNonAssocSemiring.{u3} A _inst_1))))) _inst_4] (𝒜 : ι -> σ) [_inst_6 : GradedRing.{u2, u3, u1} ι A σ (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u2} ι (OrderedAddCommMonoid.toAddCommMonoid.{u2} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ι _inst_3))) _inst_1 _inst_4 _inst_5 𝒜], Eq.{succ u3} (Ideal.{u3} A _inst_1) (HomogeneousIdeal.toIdeal.{u2, u1, u3} ι σ A _inst_1 _inst_4 _inst_5 𝒜 (fun (a : ι) (b : ι) => _inst_2 a b) (AddCommMonoid.toAddMonoid.{u2} ι (OrderedAddCommMonoid.toAddCommMonoid.{u2} ι (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ι _inst_3))) _inst_6 (HomogeneousIdeal.irrelevant.{u2, u1, u3} ι σ A _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) (RingHom.ker.{u3, u3, u3} A A (RingHom.{u3, u3} A A (Semiring.toNonAssocSemiring.{u3} A _inst_1) (Semiring.toNonAssocSemiring.{u3} A _inst_1)) _inst_1 _inst_1 (RingHom.instRingHomClassRingHom.{u3, u3} A A (Semiring.toNonAssocSemiring.{u3} A _inst_1) (Semiring.toNonAssocSemiring.{u3} A _inst_1)) (GradedRing.projZeroRingHom.{u2, u3, u1} ι A σ _inst_1 (fun (a : ι) (b : ι) => _inst_2 a b) _inst_3 _inst_4 _inst_5 𝒜 _inst_6)) +Case conversion may be inaccurate. Consider using '#align homogeneous_ideal.to_ideal_irrelevant HomogeneousIdeal.toIdeal_irrelevantₓ'. -/ @[simp] theorem HomogeneousIdeal.toIdeal_irrelevant : (HomogeneousIdeal.irrelevant 𝒜).toIdeal = (GradedRing.projZeroRingHom 𝒜).ker := diff --git a/lake-manifest.json b/lake-manifest.json index 0e7ac9e8f1..2c60ea6b37 100644 --- a/lake-manifest.json +++ b/lake-manifest.json @@ -4,15 +4,15 @@ [{"git": {"url": "https://github.com/leanprover-community/lean3port.git", "subDir?": null, - "rev": "66e8913c4e7ecfb6485692941d195e9b96b2616b", + "rev": "882a5a2b0b8f43ca4dc9b89a5447565e6c9e9196", "name": "lean3port", - "inputRev?": "66e8913c4e7ecfb6485692941d195e9b96b2616b"}}, + "inputRev?": "882a5a2b0b8f43ca4dc9b89a5447565e6c9e9196"}}, {"git": {"url": "https://github.com/leanprover-community/mathlib4.git", "subDir?": null, - "rev": "542f2e564670085b3b5ee475637efdb052dc9c08", + "rev": "54991d4b205a7765d2f9107dd410f3c7b793da2b", "name": "mathlib", - "inputRev?": "542f2e564670085b3b5ee475637efdb052dc9c08"}}, + "inputRev?": "54991d4b205a7765d2f9107dd410f3c7b793da2b"}}, {"git": {"url": "https://github.com/gebner/quote4", "subDir?": null, diff --git a/lakefile.lean b/lakefile.lean index 864db6b68d..3f74430117 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -4,7 +4,7 @@ open Lake DSL System -- Usually the `tag` will be of the form `nightly-2021-11-22`. -- If you would like to use an artifact from a PR build, -- it will be of the form `pr-branchname-sha`. -def tag : String := "nightly-2023-05-21-14" +def tag : String := "nightly-2023-05-21-16" def releaseRepo : String := "leanprover-community/mathport" def oleanTarName : String := "mathlib3-binport.tar.gz" @@ -38,7 +38,7 @@ target fetchOleans (_pkg : Package) : Unit := do untarReleaseArtifact releaseRepo tag oleanTarName libDir return .nil -require lean3port from git "https://github.com/leanprover-community/lean3port.git"@"66e8913c4e7ecfb6485692941d195e9b96b2616b" +require lean3port from git "https://github.com/leanprover-community/lean3port.git"@"882a5a2b0b8f43ca4dc9b89a5447565e6c9e9196" @[default_target] lean_lib Mathbin where