algebra.periodic ⟷ Mathlib.Algebra.Periodic

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -560,7 +560,7 @@ theorem Antiperiodic.nat_mul_eq_of_eq_zero [Ring α] [NegZeroClass β] (h : Anti
 #print Function.Antiperiodic.int_mul_eq_of_eq_zero /-
 theorem Antiperiodic.int_mul_eq_of_eq_zero [Ring α] [SubtractionMonoid β] (h : Antiperiodic f c)
     (hi : f 0 = 0) : ∀ n : ℤ, f (n * c) = 0
-  | (n : ℕ) => by rwa [Int.cast_ofNat, h.nat_mul_eq_of_eq_zero]
+  | (n : ℕ) => by rwa [Int.cast_natCast, h.nat_mul_eq_of_eq_zero]
   | -[n+1] => by rw [Int.cast_negSucc, neg_mul, ← mul_neg, h.neg.nat_mul_eq_of_eq_zero hi]
 #align function.antiperiodic.int_mul_eq_of_eq_zero Function.Antiperiodic.int_mul_eq_of_eq_zero
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -9,7 +9,7 @@ import Algebra.Module.Basic
 import Algebra.Order.Archimedean
 import Data.Int.Parity
 import GroupTheory.Coset
-import GroupTheory.Subgroup.Zpowers
+import GroupTheory.Subgroup.ZPowers
 import GroupTheory.Submonoid.Membership
 
 #align_import algebra.periodic from "leanprover-community/mathlib"@"30413fc89f202a090a54d78e540963ed3de0056e"
@@ -306,7 +306,7 @@ theorem Periodic.nat_mul_sub_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (n *
 protected theorem Periodic.zsmul [AddGroup α] (h : Periodic f c) (n : ℤ) : Periodic f (n • c) :=
   by
   cases n
-  · simpa only [Int.ofNat_eq_coe, coe_nat_zsmul] using h.nsmul n
+  · simpa only [Int.ofNat_eq_coe, natCast_zsmul] using h.nsmul n
   · simpa only [negSucc_zsmul] using (h.nsmul n.succ).neg
 #align function.periodic.zsmul Function.Periodic.zsmul
 -/
@@ -483,12 +483,12 @@ protected theorem Antiperiodic.funext' [Add α] [InvolutiveNeg β] (h : Antiperi
 #align function.antiperiodic.funext' Function.Antiperiodic.funext'
 -/
 
-#print Function.Antiperiodic.periodic /-
+#print Function.Antiperiodic.periodic_two_mul /-
 /-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
   `2 * c`. -/
-protected theorem Antiperiodic.periodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c) :
-    Periodic f (2 * c) := by simp [two_mul, ← add_assoc, h _]
-#align function.antiperiodic.periodic Function.Antiperiodic.periodic
+protected theorem Antiperiodic.periodic_two_mul [Semiring α] [InvolutiveNeg β]
+    (h : Antiperiodic f c) : Periodic f (2 * c) := by simp [two_mul, ← add_assoc, h _]
+#align function.antiperiodic.periodic Function.Antiperiodic.periodic_two_mul
 -/
 
 #print Function.Antiperiodic.eq /-

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -96,7 +96,7 @@ theorem List.periodic_prod [Add α] [Monoid β] (l : List (α → β)) (hl : ∀
     Periodic l.Prod c := by
   induction' l with g l ih hl
   · simp
-  · rw [List.forall_mem_cons] at hl 
+  · rw [List.forall_mem_cons] at hl
     simpa only [List.prod_cons] using hl.1.mul (ih hl.2)
 #align list.periodic_prod List.periodic_prod
 #align list.periodic_sum List.periodic_sum
@@ -443,7 +443,7 @@ theorem Periodic.map_vadd_multiples [AddCommMonoid α] (hf : Periodic f c)
 def Periodic.lift [AddGroup α] (h : Periodic f c) (x : α ⧸ AddSubgroup.zmultiples c) : β :=
   Quotient.liftOn' x f fun a b h' =>
     by
-    rw [QuotientAddGroup.leftRel_apply] at h' 
+    rw [QuotientAddGroup.leftRel_apply] at h'
     obtain ⟨k, hk⟩ := h'
     exact (h.zsmul k _).symm.trans (congr_arg f (add_eq_of_eq_neg_add hk))
 #align function.periodic.lift Function.Periodic.lift

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,14 +3,14 @@ Copyright (c) 2021 Benjamin Davidson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Benjamin Davidson
 -/
-import Mathbin.Algebra.BigOperators.Basic
-import Mathbin.Algebra.Field.Opposite
-import Mathbin.Algebra.Module.Basic
-import Mathbin.Algebra.Order.Archimedean
-import Mathbin.Data.Int.Parity
-import Mathbin.GroupTheory.Coset
-import Mathbin.GroupTheory.Subgroup.Zpowers
-import Mathbin.GroupTheory.Submonoid.Membership
+import Algebra.BigOperators.Basic
+import Algebra.Field.Opposite
+import Algebra.Module.Basic
+import Algebra.Order.Archimedean
+import Data.Int.Parity
+import GroupTheory.Coset
+import GroupTheory.Subgroup.Zpowers
+import GroupTheory.Submonoid.Membership
 
 #align_import algebra.periodic from "leanprover-community/mathlib"@"30413fc89f202a090a54d78e540963ed3de0056e"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Benjamin Davidson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Benjamin Davidson
-
-! This file was ported from Lean 3 source module algebra.periodic
-! leanprover-community/mathlib commit 30413fc89f202a090a54d78e540963ed3de0056e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.BigOperators.Basic
 import Mathbin.Algebra.Field.Opposite
@@ -17,6 +12,8 @@ import Mathbin.GroupTheory.Coset
 import Mathbin.GroupTheory.Subgroup.Zpowers
 import Mathbin.GroupTheory.Submonoid.Membership
 
+#align_import algebra.periodic from "leanprover-community/mathlib"@"30413fc89f202a090a54d78e540963ed3de0056e"
+
 /-!
 # Periodicity
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -58,31 +58,42 @@ def Periodic [Add α] (f : α → β) (c : α) : Prop :=
 #align function.periodic Function.Periodic
 -/
 
+#print Function.Periodic.funext /-
 protected theorem Periodic.funext [Add α] (h : Periodic f c) : (fun x => f (x + c)) = f :=
   funext h
 #align function.periodic.funext Function.Periodic.funext
+-/
 
+#print Function.Periodic.comp /-
 protected theorem Periodic.comp [Add α] (h : Periodic f c) (g : β → γ) : Periodic (g ∘ f) c := by
   simp_all
 #align function.periodic.comp Function.Periodic.comp
+-/
 
+#print Function.Periodic.comp_addHom /-
 theorem Periodic.comp_addHom [Add α] [Add γ] (h : Periodic f c) (g : AddHom γ α) (g_inv : α → γ)
     (hg : RightInverse g_inv g) : Periodic (f ∘ g) (g_inv c) := fun x => by
   simp only [hg c, h (g x), AddHom.map_add, comp_app]
 #align function.periodic.comp_add_hom Function.Periodic.comp_addHom
+-/
 
+#print Function.Periodic.mul /-
 @[to_additive]
 protected theorem Periodic.mul [Add α] [Mul β] (hf : Periodic f c) (hg : Periodic g c) :
     Periodic (f * g) c := by simp_all
 #align function.periodic.mul Function.Periodic.mul
 #align function.periodic.add Function.Periodic.add
+-/
 
+#print Function.Periodic.div /-
 @[to_additive]
 protected theorem Periodic.div [Add α] [Div β] (hf : Periodic f c) (hg : Periodic g c) :
     Periodic (f / g) c := by simp_all
 #align function.periodic.div Function.Periodic.div
 #align function.periodic.sub Function.Periodic.sub
+-/
 
+#print List.periodic_prod /-
 @[to_additive]
 theorem List.periodic_prod [Add α] [Monoid β] (l : List (α → β)) (hl : ∀ f ∈ l, Periodic f c) :
     Periodic l.Prod c := by
@@ -92,32 +103,42 @@ theorem List.periodic_prod [Add α] [Monoid β] (l : List (α → β)) (hl : ∀
     simpa only [List.prod_cons] using hl.1.mul (ih hl.2)
 #align list.periodic_prod List.periodic_prod
 #align list.periodic_sum List.periodic_sum
+-/
 
+#print Multiset.periodic_prod /-
 @[to_additive]
 theorem Multiset.periodic_prod [Add α] [CommMonoid β] (s : Multiset (α → β))
     (hs : ∀ f ∈ s, Periodic f c) : Periodic s.Prod c :=
   (s.prod_toList ▸ s.toList.periodic_prod) fun f hf => hs f <| Multiset.mem_toList.mp hf
 #align multiset.periodic_prod Multiset.periodic_prod
 #align multiset.periodic_sum Multiset.periodic_sum
+-/
 
+#print Finset.periodic_prod /-
 @[to_additive]
 theorem Finset.periodic_prod [Add α] [CommMonoid β] {ι : Type _} {f : ι → α → β} (s : Finset ι)
     (hs : ∀ i ∈ s, Periodic (f i) c) : Periodic (∏ i in s, f i) c :=
   s.prod_toList f ▸ (s.toList.map f).periodic_prod (by simpa [-periodic])
 #align finset.periodic_prod Finset.periodic_prod
 #align finset.periodic_sum Finset.periodic_sum
+-/
 
+#print Function.Periodic.smul /-
 @[to_additive]
 protected theorem Periodic.smul [Add α] [SMul γ β] (h : Periodic f c) (a : γ) :
     Periodic (a • f) c := by simp_all
 #align function.periodic.smul Function.Periodic.smul
 #align function.periodic.vadd Function.Periodic.vadd
+-/
 
+#print Function.Periodic.const_smul /-
 protected theorem Periodic.const_smul [AddMonoid α] [Group γ] [DistribMulAction γ α]
     (h : Periodic f c) (a : γ) : Periodic (fun x => f (a • x)) (a⁻¹ • c) := fun x => by
   simpa only [smul_add, smul_inv_smul] using h (a • x)
 #align function.periodic.const_smul Function.Periodic.const_smul
+-/
 
+#print Function.Periodic.const_smul₀ /-
 theorem Periodic.const_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module γ α] (h : Periodic f c)
     (a : γ) : Periodic (fun x => f (a • x)) (a⁻¹ • c) :=
   by
@@ -125,166 +146,242 @@ theorem Periodic.const_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module
   by_cases ha : a = 0; · simp only [ha, zero_smul]
   simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
 #align function.periodic.const_smul₀ Function.Periodic.const_smul₀
+-/
 
+#print Function.Periodic.const_mul /-
 protected theorem Periodic.const_mul [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a * x)) (a⁻¹ * c) :=
   h.const_smul₀ a
 #align function.periodic.const_mul Function.Periodic.const_mul
+-/
 
+#print Function.Periodic.const_inv_smul /-
 theorem Periodic.const_inv_smul [AddMonoid α] [Group γ] [DistribMulAction γ α] (h : Periodic f c)
     (a : γ) : Periodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul a⁻¹
 #align function.periodic.const_inv_smul Function.Periodic.const_inv_smul
+-/
 
+#print Function.Periodic.const_inv_smul₀ /-
 theorem Periodic.const_inv_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module γ α]
     (h : Periodic f c) (a : γ) : Periodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul₀ a⁻¹
 #align function.periodic.const_inv_smul₀ Function.Periodic.const_inv_smul₀
+-/
 
+#print Function.Periodic.const_inv_mul /-
 theorem Periodic.const_inv_mul [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a⁻¹ * x)) (a * c) :=
   h.const_inv_smul₀ a
 #align function.periodic.const_inv_mul Function.Periodic.const_inv_mul
+-/
 
+#print Function.Periodic.mul_const /-
 theorem Periodic.mul_const [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a)) (c * a⁻¹) :=
   h.const_smul₀ <| MulOpposite.op a
 #align function.periodic.mul_const Function.Periodic.mul_const
+-/
 
+#print Function.Periodic.mul_const' /-
 theorem Periodic.mul_const' [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a)) (c / a) := by simpa only [div_eq_mul_inv] using h.mul_const a
 #align function.periodic.mul_const' Function.Periodic.mul_const'
+-/
 
+#print Function.Periodic.mul_const_inv /-
 theorem Periodic.mul_const_inv [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a⁻¹)) (c * a) :=
   h.const_inv_smul₀ <| MulOpposite.op a
 #align function.periodic.mul_const_inv Function.Periodic.mul_const_inv
+-/
 
+#print Function.Periodic.div_const /-
 theorem Periodic.div_const [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x / a)) (c * a) := by simpa only [div_eq_mul_inv] using h.mul_const_inv a
 #align function.periodic.div_const Function.Periodic.div_const
+-/
 
+#print Function.Periodic.add_period /-
 theorem Periodic.add_period [AddSemigroup α] (h1 : Periodic f c₁) (h2 : Periodic f c₂) :
     Periodic f (c₁ + c₂) := by simp_all [← add_assoc]
 #align function.periodic.add_period Function.Periodic.add_period
+-/
 
+#print Function.Periodic.sub_eq /-
 theorem Periodic.sub_eq [AddGroup α] (h : Periodic f c) (x : α) : f (x - c) = f x := by
   simpa only [sub_add_cancel] using (h (x - c)).symm
 #align function.periodic.sub_eq Function.Periodic.sub_eq
+-/
 
+#print Function.Periodic.sub_eq' /-
 theorem Periodic.sub_eq' [AddCommGroup α] (h : Periodic f c) : f (c - x) = f (-x) := by
   simpa only [sub_eq_neg_add] using h (-x)
 #align function.periodic.sub_eq' Function.Periodic.sub_eq'
+-/
 
+#print Function.Periodic.neg /-
 protected theorem Periodic.neg [AddGroup α] (h : Periodic f c) : Periodic f (-c) := by
   simpa only [sub_eq_add_neg, periodic] using h.sub_eq
 #align function.periodic.neg Function.Periodic.neg
+-/
 
+#print Function.Periodic.sub_period /-
 theorem Periodic.sub_period [AddGroup α] (h1 : Periodic f c₁) (h2 : Periodic f c₂) :
     Periodic f (c₁ - c₂) := by simpa only [sub_eq_add_neg] using h1.add_period h2.neg
 #align function.periodic.sub_period Function.Periodic.sub_period
+-/
 
+#print Function.Periodic.const_add /-
 theorem Periodic.const_add [AddSemigroup α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a + x)) c := fun x => by simpa [add_assoc] using h (a + x)
 #align function.periodic.const_add Function.Periodic.const_add
+-/
 
+#print Function.Periodic.add_const /-
 theorem Periodic.add_const [AddCommSemigroup α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x + a)) c := by simpa only [add_comm] using h.const_add a
 #align function.periodic.add_const Function.Periodic.add_const
+-/
 
+#print Function.Periodic.const_sub /-
 theorem Periodic.const_sub [AddCommGroup α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a - x)) c := fun x => by simp only [← sub_sub, h.sub_eq]
 #align function.periodic.const_sub Function.Periodic.const_sub
+-/
 
+#print Function.Periodic.sub_const /-
 theorem Periodic.sub_const [AddCommGroup α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x - a)) c := by simpa only [sub_eq_add_neg] using h.add_const (-a)
 #align function.periodic.sub_const Function.Periodic.sub_const
+-/
 
+#print Function.Periodic.nsmul /-
 theorem Periodic.nsmul [AddMonoid α] (h : Periodic f c) (n : ℕ) : Periodic f (n • c) := by
   induction n <;> simp_all [Nat.succ_eq_add_one, add_nsmul, ← add_assoc, zero_nsmul]
 #align function.periodic.nsmul Function.Periodic.nsmul
+-/
 
+#print Function.Periodic.nat_mul /-
 theorem Periodic.nat_mul [Semiring α] (h : Periodic f c) (n : ℕ) : Periodic f (n * c) := by
   simpa only [nsmul_eq_mul] using h.nsmul n
 #align function.periodic.nat_mul Function.Periodic.nat_mul
+-/
 
+#print Function.Periodic.neg_nsmul /-
 theorem Periodic.neg_nsmul [AddGroup α] (h : Periodic f c) (n : ℕ) : Periodic f (-(n • c)) :=
   (h.nsmul n).neg
 #align function.periodic.neg_nsmul Function.Periodic.neg_nsmul
+-/
 
+#print Function.Periodic.neg_nat_mul /-
 theorem Periodic.neg_nat_mul [Ring α] (h : Periodic f c) (n : ℕ) : Periodic f (-(n * c)) :=
   (h.nat_mul n).neg
 #align function.periodic.neg_nat_mul Function.Periodic.neg_nat_mul
+-/
 
+#print Function.Periodic.sub_nsmul_eq /-
 theorem Periodic.sub_nsmul_eq [AddGroup α] (h : Periodic f c) (n : ℕ) : f (x - n • c) = f x := by
   simpa only [sub_eq_add_neg] using h.neg_nsmul n x
 #align function.periodic.sub_nsmul_eq Function.Periodic.sub_nsmul_eq
+-/
 
+#print Function.Periodic.sub_nat_mul_eq /-
 theorem Periodic.sub_nat_mul_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (x - n * c) = f x := by
   simpa only [nsmul_eq_mul] using h.sub_nsmul_eq n
 #align function.periodic.sub_nat_mul_eq Function.Periodic.sub_nat_mul_eq
+-/
 
+#print Function.Periodic.nsmul_sub_eq /-
 theorem Periodic.nsmul_sub_eq [AddCommGroup α] (h : Periodic f c) (n : ℕ) :
     f (n • c - x) = f (-x) :=
   (h.nsmul n).sub_eq'
 #align function.periodic.nsmul_sub_eq Function.Periodic.nsmul_sub_eq
+-/
 
+#print Function.Periodic.nat_mul_sub_eq /-
 theorem Periodic.nat_mul_sub_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (n * c - x) = f (-x) := by
   simpa only [sub_eq_neg_add] using h.nat_mul n (-x)
 #align function.periodic.nat_mul_sub_eq Function.Periodic.nat_mul_sub_eq
+-/
 
+#print Function.Periodic.zsmul /-
 protected theorem Periodic.zsmul [AddGroup α] (h : Periodic f c) (n : ℤ) : Periodic f (n • c) :=
   by
   cases n
   · simpa only [Int.ofNat_eq_coe, coe_nat_zsmul] using h.nsmul n
   · simpa only [negSucc_zsmul] using (h.nsmul n.succ).neg
 #align function.periodic.zsmul Function.Periodic.zsmul
+-/
 
+#print Function.Periodic.int_mul /-
 protected theorem Periodic.int_mul [Ring α] (h : Periodic f c) (n : ℤ) : Periodic f (n * c) := by
   simpa only [zsmul_eq_mul] using h.zsmul n
 #align function.periodic.int_mul Function.Periodic.int_mul
+-/
 
+#print Function.Periodic.sub_zsmul_eq /-
 theorem Periodic.sub_zsmul_eq [AddGroup α] (h : Periodic f c) (n : ℤ) : f (x - n • c) = f x :=
   (h.zsmul n).sub_eq x
 #align function.periodic.sub_zsmul_eq Function.Periodic.sub_zsmul_eq
+-/
 
+#print Function.Periodic.sub_int_mul_eq /-
 theorem Periodic.sub_int_mul_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (x - n * c) = f x :=
   (h.int_mul n).sub_eq x
 #align function.periodic.sub_int_mul_eq Function.Periodic.sub_int_mul_eq
+-/
 
+#print Function.Periodic.zsmul_sub_eq /-
 theorem Periodic.zsmul_sub_eq [AddCommGroup α] (h : Periodic f c) (n : ℤ) :
     f (n • c - x) = f (-x) :=
   (h.zsmul _).sub_eq'
 #align function.periodic.zsmul_sub_eq Function.Periodic.zsmul_sub_eq
+-/
 
+#print Function.Periodic.int_mul_sub_eq /-
 theorem Periodic.int_mul_sub_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (n * c - x) = f (-x) :=
   (h.int_mul _).sub_eq'
 #align function.periodic.int_mul_sub_eq Function.Periodic.int_mul_sub_eq
+-/
 
+#print Function.Periodic.eq /-
 protected theorem Periodic.eq [AddZeroClass α] (h : Periodic f c) : f c = f 0 := by
   simpa only [zero_add] using h 0
 #align function.periodic.eq Function.Periodic.eq
+-/
 
+#print Function.Periodic.neg_eq /-
 protected theorem Periodic.neg_eq [AddGroup α] (h : Periodic f c) : f (-c) = f 0 :=
   h.neg.Eq
 #align function.periodic.neg_eq Function.Periodic.neg_eq
+-/
 
+#print Function.Periodic.nsmul_eq /-
 protected theorem Periodic.nsmul_eq [AddMonoid α] (h : Periodic f c) (n : ℕ) : f (n • c) = f 0 :=
   (h.nsmul n).Eq
 #align function.periodic.nsmul_eq Function.Periodic.nsmul_eq
+-/
 
+#print Function.Periodic.nat_mul_eq /-
 theorem Periodic.nat_mul_eq [Semiring α] (h : Periodic f c) (n : ℕ) : f (n * c) = f 0 :=
   (h.nat_mul n).Eq
 #align function.periodic.nat_mul_eq Function.Periodic.nat_mul_eq
+-/
 
+#print Function.Periodic.zsmul_eq /-
 theorem Periodic.zsmul_eq [AddGroup α] (h : Periodic f c) (n : ℤ) : f (n • c) = f 0 :=
   (h.zsmul n).Eq
 #align function.periodic.zsmul_eq Function.Periodic.zsmul_eq
+-/
 
+#print Function.Periodic.int_mul_eq /-
 theorem Periodic.int_mul_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (n * c) = f 0 :=
   (h.int_mul n).Eq
 #align function.periodic.int_mul_eq Function.Periodic.int_mul_eq
+-/
 
+#print Function.Periodic.exists_mem_Ico₀ /-
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ico 0 c` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
@@ -292,7 +389,9 @@ theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean 
   let ⟨n, H, _⟩ := existsUnique_zsmul_near_of_pos' hc x
   ⟨x - n • c, H, (h.sub_zsmul_eq n).symm⟩
 #align function.periodic.exists_mem_Ico₀ Function.Periodic.exists_mem_Ico₀
+-/
 
+#print Function.Periodic.exists_mem_Ico /-
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ico a (a + c)` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
@@ -300,7 +399,9 @@ theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α]
   let ⟨n, H, _⟩ := existsUnique_add_zsmul_mem_Ico hc x a
   ⟨x + n • c, H, (h.zsmul n x).symm⟩
 #align function.periodic.exists_mem_Ico Function.Periodic.exists_mem_Ico
+-/
 
+#print Function.Periodic.exists_mem_Ioc /-
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ioc a (a + c)` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
@@ -308,7 +409,9 @@ theorem Periodic.exists_mem_Ioc [LinearOrderedAddCommGroup α] [Archimedean α]
   let ⟨n, H, _⟩ := existsUnique_add_zsmul_mem_Ioc hc x a
   ⟨x + n • c, H, (h.zsmul n x).symm⟩
 #align function.periodic.exists_mem_Ioc Function.Periodic.exists_mem_Ioc
+-/
 
+#print Function.Periodic.image_Ioc /-
 theorem Periodic.image_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
     (hc : 0 < c) (a : α) : f '' Set.Ioc a (a + c) = Set.range f :=
   (Set.image_subset_range _ _).antisymm <|
@@ -316,21 +419,29 @@ theorem Periodic.image_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h :
       let ⟨y, hy, hyx⟩ := h.exists_mem_Ioc hc x a
       ⟨y, hy, hyx.symm⟩
 #align function.periodic.image_Ioc Function.Periodic.image_Ioc
+-/
 
+#print Function.periodic_with_period_zero /-
 theorem periodic_with_period_zero [AddZeroClass α] (f : α → β) : Periodic f 0 := fun x => by
   rw [add_zero]
 #align function.periodic_with_period_zero Function.periodic_with_period_zero
+-/
 
+#print Function.Periodic.map_vadd_zmultiples /-
 theorem Periodic.map_vadd_zmultiples [AddCommGroup α] (hf : Periodic f c)
     (a : AddSubgroup.zmultiples c) (x : α) : f (a +ᵥ x) = f x := by rcases a with ⟨_, m, rfl⟩;
   simp [AddSubgroup.vadd_def, add_comm _ x, hf.zsmul m x]
 #align function.periodic.map_vadd_zmultiples Function.Periodic.map_vadd_zmultiples
+-/
 
+#print Function.Periodic.map_vadd_multiples /-
 theorem Periodic.map_vadd_multiples [AddCommMonoid α] (hf : Periodic f c)
     (a : AddSubmonoid.multiples c) (x : α) : f (a +ᵥ x) = f x := by rcases a with ⟨_, m, rfl⟩;
   simp [AddSubmonoid.vadd_def, add_comm _ x, hf.nsmul m x]
 #align function.periodic.map_vadd_multiples Function.Periodic.map_vadd_multiples
+-/
 
+#print Function.Periodic.lift /-
 /-- Lift a periodic function to a function from the quotient group. -/
 def Periodic.lift [AddGroup α] (h : Periodic f c) (x : α ⧸ AddSubgroup.zmultiples c) : β :=
   Quotient.liftOn' x f fun a b h' =>
@@ -339,12 +450,15 @@ def Periodic.lift [AddGroup α] (h : Periodic f c) (x : α ⧸ AddSubgroup.zmult
     obtain ⟨k, hk⟩ := h'
     exact (h.zsmul k _).symm.trans (congr_arg f (add_eq_of_eq_neg_add hk))
 #align function.periodic.lift Function.Periodic.lift
+-/
 
+#print Function.Periodic.lift_coe /-
 @[simp]
 theorem Periodic.lift_coe [AddGroup α] (h : Periodic f c) (a : α) :
     h.lift (a : α ⧸ AddSubgroup.zmultiples c) = f a :=
   rfl
 #align function.periodic.lift_coe Function.Periodic.lift_coe
+-/
 
 /-! ### Antiperiodicity -/
 
@@ -358,184 +472,260 @@ def Antiperiodic [Add α] [Neg β] (f : α → β) (c : α) : Prop :=
 #align function.antiperiodic Function.Antiperiodic
 -/
 
+#print Function.Antiperiodic.funext /-
 protected theorem Antiperiodic.funext [Add α] [Neg β] (h : Antiperiodic f c) :
     (fun x => f (x + c)) = -f :=
   funext h
 #align function.antiperiodic.funext Function.Antiperiodic.funext
+-/
 
+#print Function.Antiperiodic.funext' /-
 protected theorem Antiperiodic.funext' [Add α] [InvolutiveNeg β] (h : Antiperiodic f c) :
     (fun x => -f (x + c)) = f :=
   neg_eq_iff_eq_neg.mpr h.funext
 #align function.antiperiodic.funext' Function.Antiperiodic.funext'
+-/
 
+#print Function.Antiperiodic.periodic /-
 /-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
   `2 * c`. -/
 protected theorem Antiperiodic.periodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c) :
     Periodic f (2 * c) := by simp [two_mul, ← add_assoc, h _]
 #align function.antiperiodic.periodic Function.Antiperiodic.periodic
+-/
 
+#print Function.Antiperiodic.eq /-
 protected theorem Antiperiodic.eq [AddZeroClass α] [Neg β] (h : Antiperiodic f c) : f c = -f 0 := by
   simpa only [zero_add] using h 0
 #align function.antiperiodic.eq Function.Antiperiodic.eq
+-/
 
+#print Function.Antiperiodic.nat_even_mul_periodic /-
 theorem Antiperiodic.nat_even_mul_periodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℕ) : Periodic f (n * (2 * c)) :=
   h.Periodic.nat_mul n
 #align function.antiperiodic.nat_even_mul_periodic Function.Antiperiodic.nat_even_mul_periodic
+-/
 
+#print Function.Antiperiodic.nat_odd_mul_antiperiodic /-
 theorem Antiperiodic.nat_odd_mul_antiperiodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℕ) : Antiperiodic f (n * (2 * c) + c) := fun x => by
   rw [← add_assoc, h, h.periodic.nat_mul]
 #align function.antiperiodic.nat_odd_mul_antiperiodic Function.Antiperiodic.nat_odd_mul_antiperiodic
+-/
 
+#print Function.Antiperiodic.int_even_mul_periodic /-
 theorem Antiperiodic.int_even_mul_periodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℤ) : Periodic f (n * (2 * c)) :=
   h.Periodic.int_mul n
 #align function.antiperiodic.int_even_mul_periodic Function.Antiperiodic.int_even_mul_periodic
+-/
 
+#print Function.Antiperiodic.int_odd_mul_antiperiodic /-
 theorem Antiperiodic.int_odd_mul_antiperiodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℤ) : Antiperiodic f (n * (2 * c) + c) := fun x => by
   rw [← add_assoc, h, h.periodic.int_mul]
 #align function.antiperiodic.int_odd_mul_antiperiodic Function.Antiperiodic.int_odd_mul_antiperiodic
+-/
 
+#print Function.Antiperiodic.sub_eq /-
 theorem Antiperiodic.sub_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) (x : α) :
     f (x - c) = -f x := by rw [← neg_eq_iff_eq_neg, ← h (x - c), sub_add_cancel]
 #align function.antiperiodic.sub_eq Function.Antiperiodic.sub_eq
+-/
 
+#print Function.Antiperiodic.sub_eq' /-
 theorem Antiperiodic.sub_eq' [AddCommGroup α] [Neg β] (h : Antiperiodic f c) :
     f (c - x) = -f (-x) := by simpa only [sub_eq_neg_add] using h (-x)
 #align function.antiperiodic.sub_eq' Function.Antiperiodic.sub_eq'
+-/
 
+#print Function.Antiperiodic.neg /-
 protected theorem Antiperiodic.neg [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) :
     Antiperiodic f (-c) := by simpa only [sub_eq_add_neg, antiperiodic] using h.sub_eq
 #align function.antiperiodic.neg Function.Antiperiodic.neg
+-/
 
+#print Function.Antiperiodic.neg_eq /-
 theorem Antiperiodic.neg_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) : f (-c) = -f 0 :=
   by simpa only [zero_add] using h.neg 0
 #align function.antiperiodic.neg_eq Function.Antiperiodic.neg_eq
+-/
 
+#print Function.Antiperiodic.nat_mul_eq_of_eq_zero /-
 theorem Antiperiodic.nat_mul_eq_of_eq_zero [Ring α] [NegZeroClass β] (h : Antiperiodic f c)
     (hi : f 0 = 0) : ∀ n : ℕ, f (n * c) = 0
   | 0 => by rwa [Nat.cast_zero, MulZeroClass.zero_mul]
   | n + 1 => by simp [add_mul, antiperiodic.nat_mul_eq_of_eq_zero n, h _]
 #align function.antiperiodic.nat_mul_eq_of_eq_zero Function.Antiperiodic.nat_mul_eq_of_eq_zero
+-/
 
+#print Function.Antiperiodic.int_mul_eq_of_eq_zero /-
 theorem Antiperiodic.int_mul_eq_of_eq_zero [Ring α] [SubtractionMonoid β] (h : Antiperiodic f c)
     (hi : f 0 = 0) : ∀ n : ℤ, f (n * c) = 0
   | (n : ℕ) => by rwa [Int.cast_ofNat, h.nat_mul_eq_of_eq_zero]
   | -[n+1] => by rw [Int.cast_negSucc, neg_mul, ← mul_neg, h.neg.nat_mul_eq_of_eq_zero hi]
 #align function.antiperiodic.int_mul_eq_of_eq_zero Function.Antiperiodic.int_mul_eq_of_eq_zero
+-/
 
+#print Function.Antiperiodic.const_add /-
 theorem Antiperiodic.const_add [AddSemigroup α] [Neg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (a + x)) c := fun x => by simpa [add_assoc] using h (a + x)
 #align function.antiperiodic.const_add Function.Antiperiodic.const_add
+-/
 
+#print Function.Antiperiodic.add_const /-
 theorem Antiperiodic.add_const [AddCommSemigroup α] [Neg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (x + a)) c := fun x => by simpa only [add_right_comm] using h (x + a)
 #align function.antiperiodic.add_const Function.Antiperiodic.add_const
+-/
 
+#print Function.Antiperiodic.const_sub /-
 theorem Antiperiodic.const_sub [AddCommGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (a - x)) c := fun x => by simp only [← sub_sub, h.sub_eq]
 #align function.antiperiodic.const_sub Function.Antiperiodic.const_sub
+-/
 
+#print Function.Antiperiodic.sub_const /-
 theorem Antiperiodic.sub_const [AddCommGroup α] [Neg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (x - a)) c := by simpa only [sub_eq_add_neg] using h.add_const (-a)
 #align function.antiperiodic.sub_const Function.Antiperiodic.sub_const
+-/
 
+#print Function.Antiperiodic.smul /-
 protected theorem Antiperiodic.smul [Add α] [Monoid γ] [AddGroup β] [DistribMulAction γ β]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (a • f) c := by simp_all
 #align function.antiperiodic.smul Function.Antiperiodic.smul
+-/
 
+#print Function.Antiperiodic.const_smul /-
 theorem Antiperiodic.const_smul [AddMonoid α] [Neg β] [Group γ] [DistribMulAction γ α]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (fun x => f (a • x)) (a⁻¹ • c) := fun x => by
   simpa only [smul_add, smul_inv_smul] using h (a • x)
 #align function.antiperiodic.const_smul Function.Antiperiodic.const_smul
+-/
 
+#print Function.Antiperiodic.const_smul₀ /-
 theorem Antiperiodic.const_smul₀ [AddCommMonoid α] [Neg β] [DivisionSemiring γ] [Module γ α]
     (h : Antiperiodic f c) {a : γ} (ha : a ≠ 0) : Antiperiodic (fun x => f (a • x)) (a⁻¹ • c) :=
   fun x => by simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
 #align function.antiperiodic.const_smul₀ Function.Antiperiodic.const_smul₀
+-/
 
+#print Function.Antiperiodic.const_mul /-
 theorem Antiperiodic.const_mul [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (a * x)) (a⁻¹ * c) :=
   h.const_smul₀ ha
 #align function.antiperiodic.const_mul Function.Antiperiodic.const_mul
+-/
 
+#print Function.Antiperiodic.const_inv_smul /-
 theorem Antiperiodic.const_inv_smul [AddMonoid α] [Neg β] [Group γ] [DistribMulAction γ α]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul a⁻¹
 #align function.antiperiodic.const_inv_smul Function.Antiperiodic.const_inv_smul
+-/
 
+#print Function.Antiperiodic.const_inv_smul₀ /-
 theorem Antiperiodic.const_inv_smul₀ [AddCommMonoid α] [Neg β] [DivisionSemiring γ] [Module γ α]
     (h : Antiperiodic f c) {a : γ} (ha : a ≠ 0) : Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul₀ (inv_ne_zero ha)
 #align function.antiperiodic.const_inv_smul₀ Function.Antiperiodic.const_inv_smul₀
+-/
 
+#print Function.Antiperiodic.const_inv_mul /-
 theorem Antiperiodic.const_inv_mul [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (a⁻¹ * x)) (a * c) :=
   h.const_inv_smul₀ ha
 #align function.antiperiodic.const_inv_mul Function.Antiperiodic.const_inv_mul
+-/
 
+#print Function.Antiperiodic.mul_const /-
 theorem Antiperiodic.mul_const [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a)) (c * a⁻¹) :=
   h.const_smul₀ <| (MulOpposite.op_ne_zero_iff a).mpr ha
 #align function.antiperiodic.mul_const Function.Antiperiodic.mul_const
+-/
 
+#print Function.Antiperiodic.mul_const' /-
 theorem Antiperiodic.mul_const' [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a)) (c / a) := by
   simpa only [div_eq_mul_inv] using h.mul_const ha
 #align function.antiperiodic.mul_const' Function.Antiperiodic.mul_const'
+-/
 
+#print Function.Antiperiodic.mul_const_inv /-
 theorem Antiperiodic.mul_const_inv [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a⁻¹)) (c * a) :=
   h.const_inv_smul₀ <| (MulOpposite.op_ne_zero_iff a).mpr ha
 #align function.antiperiodic.mul_const_inv Function.Antiperiodic.mul_const_inv
+-/
 
+#print Function.Antiperiodic.div_inv /-
 protected theorem Antiperiodic.div_inv [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x / a)) (c * a) := by
   simpa only [div_eq_mul_inv] using h.mul_const_inv ha
 #align function.antiperiodic.div_inv Function.Antiperiodic.div_inv
+-/
 
+#print Function.Antiperiodic.add /-
 protected theorem Antiperiodic.add [AddGroup α] [InvolutiveNeg β] (h1 : Antiperiodic f c₁)
     (h2 : Antiperiodic f c₂) : Periodic f (c₁ + c₂) := by simp_all [← add_assoc]
 #align function.antiperiodic.add Function.Antiperiodic.add
+-/
 
+#print Function.Antiperiodic.sub /-
 protected theorem Antiperiodic.sub [AddGroup α] [InvolutiveNeg β] (h1 : Antiperiodic f c₁)
     (h2 : Antiperiodic f c₂) : Periodic f (c₁ - c₂) := by
   simpa only [sub_eq_add_neg] using h1.add h2.neg
 #align function.antiperiodic.sub Function.Antiperiodic.sub
+-/
 
+#print Function.Periodic.add_antiperiod /-
 theorem Periodic.add_antiperiod [AddGroup α] [Neg β] (h1 : Periodic f c₁) (h2 : Antiperiodic f c₂) :
     Antiperiodic f (c₁ + c₂) := by simp_all [← add_assoc]
 #align function.periodic.add_antiperiod Function.Periodic.add_antiperiod
+-/
 
+#print Function.Periodic.sub_antiperiod /-
 theorem Periodic.sub_antiperiod [AddGroup α] [InvolutiveNeg β] (h1 : Periodic f c₁)
     (h2 : Antiperiodic f c₂) : Antiperiodic f (c₁ - c₂) := by
   simpa only [sub_eq_add_neg] using h1.add_antiperiod h2.neg
 #align function.periodic.sub_antiperiod Function.Periodic.sub_antiperiod
+-/
 
+#print Function.Periodic.add_antiperiod_eq /-
 theorem Periodic.add_antiperiod_eq [AddGroup α] [Neg β] (h1 : Periodic f c₁)
     (h2 : Antiperiodic f c₂) : f (c₁ + c₂) = -f 0 :=
   (h1.add_antiperiod h2).Eq
 #align function.periodic.add_antiperiod_eq Function.Periodic.add_antiperiod_eq
+-/
 
+#print Function.Periodic.sub_antiperiod_eq /-
 theorem Periodic.sub_antiperiod_eq [AddGroup α] [InvolutiveNeg β] (h1 : Periodic f c₁)
     (h2 : Antiperiodic f c₂) : f (c₁ - c₂) = -f 0 :=
   (h1.sub_antiperiod h2).Eq
 #align function.periodic.sub_antiperiod_eq Function.Periodic.sub_antiperiod_eq
+-/
 
+#print Function.Antiperiodic.mul /-
 protected theorem Antiperiodic.mul [Add α] [Mul β] [HasDistribNeg β] (hf : Antiperiodic f c)
     (hg : Antiperiodic g c) : Periodic (f * g) c := by simp_all
 #align function.antiperiodic.mul Function.Antiperiodic.mul
+-/
 
+#print Function.Antiperiodic.div /-
 protected theorem Antiperiodic.div [Add α] [DivisionMonoid β] [HasDistribNeg β]
     (hf : Antiperiodic f c) (hg : Antiperiodic g c) : Periodic (f / g) c := by
   simp_all [neg_div_neg_eq]
 #align function.antiperiodic.div Function.Antiperiodic.div
+-/
 
 end Function
 
+#print Int.fract_periodic /-
 theorem Int.fract_periodic (α) [LinearOrderedRing α] [FloorRing α] :
     Function.Periodic Int.fract (1 : α) := by exact_mod_cast fun a => Int.fract_add_int a 1
 #align int.fract_periodic Int.fract_periodic
+-/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -88,7 +88,7 @@ theorem List.periodic_prod [Add α] [Monoid β] (l : List (α → β)) (hl : ∀
     Periodic l.Prod c := by
   induction' l with g l ih hl
   · simp
-  · rw [List.forall_mem_cons] at hl
+  · rw [List.forall_mem_cons] at hl 
     simpa only [List.prod_cons] using hl.1.mul (ih hl.2)
 #align list.periodic_prod List.periodic_prod
 #align list.periodic_sum List.periodic_sum
@@ -103,7 +103,7 @@ theorem Multiset.periodic_prod [Add α] [CommMonoid β] (s : Multiset (α → β
 @[to_additive]
 theorem Finset.periodic_prod [Add α] [CommMonoid β] {ι : Type _} {f : ι → α → β} (s : Finset ι)
     (hs : ∀ i ∈ s, Periodic (f i) c) : Periodic (∏ i in s, f i) c :=
-  s.prod_toList f ▸ (s.toList.map f).periodic_prod (by simpa [-periodic] )
+  s.prod_toList f ▸ (s.toList.map f).periodic_prod (by simpa [-periodic])
 #align finset.periodic_prod Finset.periodic_prod
 #align finset.periodic_sum Finset.periodic_sum
 
@@ -335,7 +335,7 @@ theorem Periodic.map_vadd_multiples [AddCommMonoid α] (hf : Periodic f c)
 def Periodic.lift [AddGroup α] (h : Periodic f c) (x : α ⧸ AddSubgroup.zmultiples c) : β :=
   Quotient.liftOn' x f fun a b h' =>
     by
-    rw [QuotientAddGroup.leftRel_apply] at h'
+    rw [QuotientAddGroup.leftRel_apply] at h' 
     obtain ⟨k, hk⟩ := h'
     exact (h.zsmul k _).symm.trans (congr_arg f (add_eq_of_eq_neg_add hk))
 #align function.periodic.lift Function.Periodic.lift

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -43,7 +43,7 @@ period, periodic, periodicity, antiperiodic
 
 variable {α β γ : Type _} {f g : α → β} {c c₁ c₂ x : α}
 
-open BigOperators
+open scoped BigOperators
 
 namespace Function
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -58,67 +58,31 @@ def Periodic [Add α] (f : α → β) (c : α) : Prop :=
 #align function.periodic Function.Periodic
 -/
 
-/- warning: function.periodic.funext -> Function.Periodic.funext is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α], (Function.Periodic.{u1, u2} α β _inst_1 f c) -> (Eq.{max (succ u1) (succ u2)} (α -> β) (fun (x : α) => f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x c)) f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Add.{u2} α], (Function.Periodic.{u2, u1} α β _inst_1 f c) -> (Eq.{max (succ u2) (succ u1)} (α -> β) (fun (x : α) => f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α _inst_1) x c)) f)
-Case conversion may be inaccurate. Consider using '#align function.periodic.funext Function.Periodic.funextₓ'. -/
 protected theorem Periodic.funext [Add α] (h : Periodic f c) : (fun x => f (x + c)) = f :=
   funext h
 #align function.periodic.funext Function.Periodic.funext
 
-/- warning: function.periodic.comp -> Function.Periodic.comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α], (Function.Periodic.{u1, u2} α β _inst_1 f c) -> (forall (g : β -> γ), Function.Periodic.{u1, u3} α γ _inst_1 (Function.comp.{succ u1, succ u2, succ u3} α β γ g f) c)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α], (Function.Periodic.{u3, u2} α β _inst_1 f c) -> (forall (g : β -> γ), Function.Periodic.{u3, u1} α γ _inst_1 (Function.comp.{succ u3, succ u2, succ u1} α β γ g f) c)
-Case conversion may be inaccurate. Consider using '#align function.periodic.comp Function.Periodic.compₓ'. -/
 protected theorem Periodic.comp [Add α] (h : Periodic f c) (g : β → γ) : Periodic (g ∘ f) c := by
   simp_all
 #align function.periodic.comp Function.Periodic.comp
 
-/- warning: function.periodic.comp_add_hom -> Function.Periodic.comp_addHom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Add.{u3} γ], (Function.Periodic.{u1, u2} α β _inst_1 f c) -> (forall (g : AddHom.{u3, u1} γ α _inst_2 _inst_1) (g_inv : α -> γ), (Function.RightInverse.{succ u3, succ u1} γ α g_inv (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (AddHom.{u3, u1} γ α _inst_2 _inst_1) (fun (_x : AddHom.{u3, u1} γ α _inst_2 _inst_1) => γ -> α) (AddHom.hasCoeToFun.{u3, u1} γ α _inst_2 _inst_1) g)) -> (Function.Periodic.{u3, u2} γ β _inst_2 (Function.comp.{succ u3, succ u1, succ u2} γ α β f (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (AddHom.{u3, u1} γ α _inst_2 _inst_1) (fun (_x : AddHom.{u3, u1} γ α _inst_2 _inst_1) => γ -> α) (AddHom.hasCoeToFun.{u3, u1} γ α _inst_2 _inst_1) g)) (g_inv c)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Add.{u2} γ], (Function.Periodic.{u3, u1} α β _inst_1 f c) -> (forall (g : AddHom.{u2, u3} γ α _inst_2 _inst_1) (g_inv : α -> γ), (Function.RightInverse.{succ u2, succ u3} γ α g_inv (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : γ) => α) _x) (AddHomClass.toFunLike.{max u3 u2, u2, u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ α _inst_2 _inst_1 (AddHom.addHomClass.{u2, u3} γ α _inst_2 _inst_1)) g)) -> (Function.Periodic.{u2, u1} γ β _inst_2 (Function.comp.{succ u2, succ u3, succ u1} γ α β f (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : γ) => α) _x) (AddHomClass.toFunLike.{max u3 u2, u2, u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ α _inst_2 _inst_1 (AddHom.addHomClass.{u2, u3} γ α _inst_2 _inst_1)) g)) (g_inv c)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.comp_add_hom Function.Periodic.comp_addHomₓ'. -/
 theorem Periodic.comp_addHom [Add α] [Add γ] (h : Periodic f c) (g : AddHom γ α) (g_inv : α → γ)
     (hg : RightInverse g_inv g) : Periodic (f ∘ g) (g_inv c) := fun x => by
   simp only [hg c, h (g x), AddHom.map_add, comp_app]
 #align function.periodic.comp_add_hom Function.Periodic.comp_addHom
 
-/- warning: function.periodic.mul -> Function.Periodic.mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {g : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Mul.{u2} β], (Function.Periodic.{u1, u2} α β _inst_1 f c) -> (Function.Periodic.{u1, u2} α β _inst_1 g c) -> (Function.Periodic.{u1, u2} α β _inst_1 (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2))) f g) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {g : α -> β} {c : α} [_inst_1 : Add.{u2} α] [_inst_2 : Mul.{u1} β], (Function.Periodic.{u2, u1} α β _inst_1 f c) -> (Function.Periodic.{u2, u1} α β _inst_1 g c) -> (Function.Periodic.{u2, u1} α β _inst_1 (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2))) f g) c)
-Case conversion may be inaccurate. Consider using '#align function.periodic.mul Function.Periodic.mulₓ'. -/
 @[to_additive]
 protected theorem Periodic.mul [Add α] [Mul β] (hf : Periodic f c) (hg : Periodic g c) :
     Periodic (f * g) c := by simp_all
 #align function.periodic.mul Function.Periodic.mul
 #align function.periodic.add Function.Periodic.add
 
-/- warning: function.periodic.div -> Function.Periodic.div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {g : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Div.{u2} β], (Function.Periodic.{u1, u2} α β _inst_1 f c) -> (Function.Periodic.{u1, u2} α β _inst_1 g c) -> (Function.Periodic.{u1, u2} α β _inst_1 (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2))) f g) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {g : α -> β} {c : α} [_inst_1 : Add.{u2} α] [_inst_2 : Div.{u1} β], (Function.Periodic.{u2, u1} α β _inst_1 f c) -> (Function.Periodic.{u2, u1} α β _inst_1 g c) -> (Function.Periodic.{u2, u1} α β _inst_1 (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2))) f g) c)
-Case conversion may be inaccurate. Consider using '#align function.periodic.div Function.Periodic.divₓ'. -/
 @[to_additive]
 protected theorem Periodic.div [Add α] [Div β] (hf : Periodic f c) (hg : Periodic g c) :
     Periodic (f / g) c := by simp_all
 #align function.periodic.div Function.Periodic.div
 #align function.periodic.sub Function.Periodic.sub
 
-/- warning: list.periodic_prod -> List.periodic_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Monoid.{u2} β] (l : List.{max u1 u2} (α -> β)), (forall (f : α -> β), (Membership.Mem.{max u1 u2, max u1 u2} (α -> β) (List.{max u1 u2} (α -> β)) (List.hasMem.{max u1 u2} (α -> β)) f l) -> (Function.Periodic.{u1, u2} α β _inst_1 f c)) -> (Function.Periodic.{u1, u2} α β _inst_1 (List.prod.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2))) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulOneClass.toHasOne.{u2} β (Monoid.toMulOneClass.{u2} β _inst_2))) l) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {c : α} [_inst_1 : Add.{u2} α] [_inst_2 : Monoid.{u1} β] (l : List.{max u2 u1} (α -> β)), (forall (f : α -> β), (Membership.mem.{max u2 u1, max u2 u1} (α -> β) (List.{max u2 u1} (α -> β)) (List.instMembershipList.{max u2 u1} (α -> β)) f l) -> (Function.Periodic.{u2, u1} α β _inst_1 f c)) -> (Function.Periodic.{u2, u1} α β _inst_1 (List.prod.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_2))) (Pi.instOne.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Monoid.toOne.{u1} β _inst_2)) l) c)
-Case conversion may be inaccurate. Consider using '#align list.periodic_prod List.periodic_prodₓ'. -/
 @[to_additive]
 theorem List.periodic_prod [Add α] [Monoid β] (l : List (α → β)) (hl : ∀ f ∈ l, Periodic f c) :
     Periodic l.Prod c := by
@@ -129,12 +93,6 @@ theorem List.periodic_prod [Add α] [Monoid β] (l : List (α → β)) (hl : ∀
 #align list.periodic_prod List.periodic_prod
 #align list.periodic_sum List.periodic_sum
 
-/- warning: multiset.periodic_prod -> Multiset.periodic_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : CommMonoid.{u2} β] (s : Multiset.{max u1 u2} (α -> β)), (forall (f : α -> β), (Membership.Mem.{max u1 u2, max u1 u2} (α -> β) (Multiset.{max u1 u2} (α -> β)) (Multiset.hasMem.{max u1 u2} (α -> β)) f s) -> (Function.Periodic.{u1, u2} α β _inst_1 f c)) -> (Function.Periodic.{u1, u2} α β _inst_1 (Multiset.prod.{max u1 u2} (α -> β) (Pi.commMonoid.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2)) s) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {c : α} [_inst_1 : Add.{u2} α] [_inst_2 : CommMonoid.{u1} β] (s : Multiset.{max u2 u1} (α -> β)), (forall (f : α -> β), (Membership.mem.{max u2 u1, max u2 u1} (α -> β) (Multiset.{max u2 u1} (α -> β)) (Multiset.instMembershipMultiset.{max u2 u1} (α -> β)) f s) -> (Function.Periodic.{u2, u1} α β _inst_1 f c)) -> (Function.Periodic.{u2, u1} α β _inst_1 (Multiset.prod.{max u2 u1} (α -> β) (Pi.commMonoid.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2)) s) c)
-Case conversion may be inaccurate. Consider using '#align multiset.periodic_prod Multiset.periodic_prodₓ'. -/
 @[to_additive]
 theorem Multiset.periodic_prod [Add α] [CommMonoid β] (s : Multiset (α → β))
     (hs : ∀ f ∈ s, Periodic f c) : Periodic s.Prod c :=
@@ -142,12 +100,6 @@ theorem Multiset.periodic_prod [Add α] [CommMonoid β] (s : Multiset (α → β
 #align multiset.periodic_prod Multiset.periodic_prod
 #align multiset.periodic_sum Multiset.periodic_sum
 
-/- warning: finset.periodic_prod -> Finset.periodic_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : CommMonoid.{u2} β] {ι : Type.{u3}} {f : ι -> α -> β} (s : Finset.{u3} ι), (forall (i : ι), (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) i s) -> (Function.Periodic.{u1, u2} α β _inst_1 (f i) c)) -> (Function.Periodic.{u1, u2} α β _inst_1 (Finset.prod.{max u1 u2, u3} (α -> β) ι (Pi.commMonoid.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2)) s (fun (i : ι) => f i)) c)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : CommMonoid.{u2} β] {ι : Type.{u1}} {f : ι -> α -> β} (s : Finset.{u1} ι), (forall (i : ι), (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i s) -> (Function.Periodic.{u3, u2} α β _inst_1 (f i) c)) -> (Function.Periodic.{u3, u2} α β _inst_1 (Finset.prod.{max u2 u3, u1} (α -> β) ι (Pi.commMonoid.{u3, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2)) s (fun (i : ι) => f i)) c)
-Case conversion may be inaccurate. Consider using '#align finset.periodic_prod Finset.periodic_prodₓ'. -/
 @[to_additive]
 theorem Finset.periodic_prod [Add α] [CommMonoid β] {ι : Type _} {f : ι → α → β} (s : Finset ι)
     (hs : ∀ i ∈ s, Periodic (f i) c) : Periodic (∏ i in s, f i) c :=
@@ -155,35 +107,17 @@ theorem Finset.periodic_prod [Add α] [CommMonoid β] {ι : Type _} {f : ι →
 #align finset.periodic_prod Finset.periodic_prod
 #align finset.periodic_sum Finset.periodic_sum
 
-/- warning: function.periodic.smul -> Function.Periodic.smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : SMul.{u3, u2} γ β], (Function.Periodic.{u1, u2} α β _inst_1 f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β _inst_1 (SMul.smul.{u3, max u1 u2} γ (α -> β) (Function.hasSMul.{u1, u3, u2} α γ β _inst_2) a f) c)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : SMul.{u2, u1} γ β], (Function.Periodic.{u3, u1} α β _inst_1 f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β _inst_1 (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.565 : α) => β) (fun (i : α) => _inst_2))) a f) c)
-Case conversion may be inaccurate. Consider using '#align function.periodic.smul Function.Periodic.smulₓ'. -/
 @[to_additive]
 protected theorem Periodic.smul [Add α] [SMul γ β] (h : Periodic f c) (a : γ) :
     Periodic (a • f) c := by simp_all
 #align function.periodic.smul Function.Periodic.smul
 #align function.periodic.vadd Function.Periodic.vadd
 
-/- warning: function.periodic.const_smul -> Function.Periodic.const_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u1} α] [_inst_2 : Group.{u3} γ] [_inst_3 : DistribMulAction.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_2)) _inst_1], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (DistribSMul.toSmulZeroClass.{u3, u1} γ α (AddMonoid.toAddZeroClass.{u1} α _inst_1) (DistribMulAction.toDistribSMul.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_2)) _inst_1 _inst_3))) a x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (DistribSMul.toSmulZeroClass.{u3, u1} γ α (AddMonoid.toAddZeroClass.{u1} α _inst_1) (DistribMulAction.toDistribSMul.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_2)) _inst_1 _inst_3))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_2)) a) c))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u3} α] [_inst_2 : Group.{u2} γ] [_inst_3 : DistribMulAction.{u2, u3} γ α (DivInvMonoid.toMonoid.{u2} γ (Group.toDivInvMonoid.{u2} γ _inst_2)) _inst_1], (Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α _inst_1)) f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α _inst_1)) (fun (x : α) => f (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α _inst_1) (DistribSMul.toSMulZeroClass.{u2, u3} γ α (AddMonoid.toAddZeroClass.{u3} α _inst_1) (DistribMulAction.toDistribSMul.{u2, u3} γ α (DivInvMonoid.toMonoid.{u2} γ (Group.toDivInvMonoid.{u2} γ _inst_2)) _inst_1 _inst_3)))) a x)) (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α _inst_1) (DistribSMul.toSMulZeroClass.{u2, u3} γ α (AddMonoid.toAddZeroClass.{u3} α _inst_1) (DistribMulAction.toDistribSMul.{u2, u3} γ α (DivInvMonoid.toMonoid.{u2} γ (Group.toDivInvMonoid.{u2} γ _inst_2)) _inst_1 _inst_3)))) (Inv.inv.{u2} γ (InvOneClass.toInv.{u2} γ (DivInvOneMonoid.toInvOneClass.{u2} γ (DivisionMonoid.toDivInvOneMonoid.{u2} γ (Group.toDivisionMonoid.{u2} γ _inst_2)))) a) c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.const_smul Function.Periodic.const_smulₓ'. -/
 protected theorem Periodic.const_smul [AddMonoid α] [Group γ] [DistribMulAction γ α]
     (h : Periodic f c) (a : γ) : Periodic (fun x => f (a • x)) (a⁻¹ • c) := fun x => by
   simpa only [smul_add, smul_inv_smul] using h (a • x)
 #align function.periodic.const_smul Function.Periodic.const_smul
 
-/- warning: function.periodic.const_smul₀ -> Function.Periodic.const_smul₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : DivisionSemiring.{u3} γ] [_inst_3 : Module.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1 _inst_3)))) a x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1 _inst_3)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (GroupWithZero.toDivInvMonoid.{u3} γ (DivisionSemiring.toGroupWithZero.{u3} γ _inst_2))) a) c))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u3} α] [_inst_2 : DivisionSemiring.{u2} γ] [_inst_3 : Module.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1], (Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) (fun (x : α) => f (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u3} γ α (MonoidWithZero.toZero.{u2} γ (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u2, u3} γ α (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1 _inst_3))))) a x)) (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u3} γ α (MonoidWithZero.toZero.{u2} γ (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u2, u3} γ α (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1 _inst_3))))) (Inv.inv.{u2} γ (DivisionSemiring.toInv.{u2} γ _inst_2) a) c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.const_smul₀ Function.Periodic.const_smul₀ₓ'. -/
 theorem Periodic.const_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module γ α] (h : Periodic f c)
     (a : γ) : Periodic (fun x => f (a • x)) (a⁻¹ • c) :=
   by
@@ -192,269 +126,113 @@ theorem Periodic.const_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module
   simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
 #align function.periodic.const_smul₀ Function.Periodic.const_smul₀
 
-/- warning: function.periodic.const_mul -> Function.Periodic.const_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) a x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) a x)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a) c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.const_mul Function.Periodic.const_mulₓ'. -/
 protected theorem Periodic.const_mul [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a * x)) (a⁻¹ * c) :=
   h.const_smul₀ a
 #align function.periodic.const_mul Function.Periodic.const_mul
 
-/- warning: function.periodic.const_inv_smul -> Function.Periodic.const_inv_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u1} α] [_inst_2 : Group.{u3} γ] [_inst_3 : DistribMulAction.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_2)) _inst_1], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (DistribSMul.toSmulZeroClass.{u3, u1} γ α (AddMonoid.toAddZeroClass.{u1} α _inst_1) (DistribMulAction.toDistribSMul.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_2)) _inst_1 _inst_3))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_2)) a) x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (DistribSMul.toSmulZeroClass.{u3, u1} γ α (AddMonoid.toAddZeroClass.{u1} α _inst_1) (DistribMulAction.toDistribSMul.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_2)) _inst_1 _inst_3))) a c))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u3} α] [_inst_2 : Group.{u2} γ] [_inst_3 : DistribMulAction.{u2, u3} γ α (DivInvMonoid.toMonoid.{u2} γ (Group.toDivInvMonoid.{u2} γ _inst_2)) _inst_1], (Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α _inst_1)) f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α _inst_1)) (fun (x : α) => f (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α _inst_1) (DistribSMul.toSMulZeroClass.{u2, u3} γ α (AddMonoid.toAddZeroClass.{u3} α _inst_1) (DistribMulAction.toDistribSMul.{u2, u3} γ α (DivInvMonoid.toMonoid.{u2} γ (Group.toDivInvMonoid.{u2} γ _inst_2)) _inst_1 _inst_3)))) (Inv.inv.{u2} γ (InvOneClass.toInv.{u2} γ (DivInvOneMonoid.toInvOneClass.{u2} γ (DivisionMonoid.toDivInvOneMonoid.{u2} γ (Group.toDivisionMonoid.{u2} γ _inst_2)))) a) x)) (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α _inst_1) (DistribSMul.toSMulZeroClass.{u2, u3} γ α (AddMonoid.toAddZeroClass.{u3} α _inst_1) (DistribMulAction.toDistribSMul.{u2, u3} γ α (DivInvMonoid.toMonoid.{u2} γ (Group.toDivInvMonoid.{u2} γ _inst_2)) _inst_1 _inst_3)))) a c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.const_inv_smul Function.Periodic.const_inv_smulₓ'. -/
 theorem Periodic.const_inv_smul [AddMonoid α] [Group γ] [DistribMulAction γ α] (h : Periodic f c)
     (a : γ) : Periodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul a⁻¹
 #align function.periodic.const_inv_smul Function.Periodic.const_inv_smul
 
-/- warning: function.periodic.const_inv_smul₀ -> Function.Periodic.const_inv_smul₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : DivisionSemiring.{u3} γ] [_inst_3 : Module.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1 _inst_3)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (GroupWithZero.toDivInvMonoid.{u3} γ (DivisionSemiring.toGroupWithZero.{u3} γ _inst_2))) a) x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1 _inst_3)))) a c))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u3} α] [_inst_2 : DivisionSemiring.{u2} γ] [_inst_3 : Module.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1], (Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) (fun (x : α) => f (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u3} γ α (MonoidWithZero.toZero.{u2} γ (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u2, u3} γ α (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1 _inst_3))))) (Inv.inv.{u2} γ (DivisionSemiring.toInv.{u2} γ _inst_2) a) x)) (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u3} γ α (MonoidWithZero.toZero.{u2} γ (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u2, u3} γ α (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1 _inst_3))))) a c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.const_inv_smul₀ Function.Periodic.const_inv_smul₀ₓ'. -/
 theorem Periodic.const_inv_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module γ α]
     (h : Periodic f c) (a : γ) : Periodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul₀ a⁻¹
 #align function.periodic.const_inv_smul₀ Function.Periodic.const_inv_smul₀
 
-/- warning: function.periodic.const_inv_mul -> Function.Periodic.const_inv_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a) x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) a c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a) x)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) a c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.const_inv_mul Function.Periodic.const_inv_mulₓ'. -/
 theorem Periodic.const_inv_mul [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a⁻¹ * x)) (a * c) :=
   h.const_inv_smul₀ a
 #align function.periodic.const_inv_mul Function.Periodic.const_inv_mul
 
-/- warning: function.periodic.mul_const -> Function.Periodic.mul_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x a)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.mul_const Function.Periodic.mul_constₓ'. -/
 theorem Periodic.mul_const [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a)) (c * a⁻¹) :=
   h.const_smul₀ <| MulOpposite.op a
 #align function.periodic.mul_const Function.Periodic.mul_const
 
-/- warning: function.periodic.mul_const' -> Function.Periodic.mul_const' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x a)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1)))) c a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x a)) (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivisionSemiring.toDiv.{u2} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align function.periodic.mul_const' Function.Periodic.mul_const'ₓ'. -/
 theorem Periodic.mul_const' [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a)) (c / a) := by simpa only [div_eq_mul_inv] using h.mul_const a
 #align function.periodic.mul_const' Function.Periodic.mul_const'
 
-/- warning: function.periodic.mul_const_inv -> Function.Periodic.mul_const_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c a))
-Case conversion may be inaccurate. Consider using '#align function.periodic.mul_const_inv Function.Periodic.mul_const_invₓ'. -/
 theorem Periodic.mul_const_inv [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a⁻¹)) (c * a) :=
   h.const_inv_smul₀ <| MulOpposite.op a
 #align function.periodic.mul_const_inv Function.Periodic.mul_const_inv
 
-/- warning: function.periodic.div_const -> Function.Periodic.div_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1)))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivisionSemiring.toDiv.{u2} α _inst_1)) x a)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c a))
-Case conversion may be inaccurate. Consider using '#align function.periodic.div_const Function.Periodic.div_constₓ'. -/
 theorem Periodic.div_const [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x / a)) (c * a) := by simpa only [div_eq_mul_inv] using h.mul_const_inv a
 #align function.periodic.div_const Function.Periodic.div_const
 
-/- warning: function.periodic.add_period -> Function.Periodic.add_period is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddSemigroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α _inst_1) f c₁) -> (Function.Periodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α _inst_1) f c₂) -> (Function.Periodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α _inst_1) f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α _inst_1)) c₁ c₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddSemigroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α _inst_1) f c₁) -> (Function.Periodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α _inst_1) f c₂) -> (Function.Periodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α _inst_1) f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddSemigroup.toAdd.{u2} α _inst_1)) c₁ c₂))
-Case conversion may be inaccurate. Consider using '#align function.periodic.add_period Function.Periodic.add_periodₓ'. -/
 theorem Periodic.add_period [AddSemigroup α] (h1 : Periodic f c₁) (h2 : Periodic f c₂) :
     Periodic f (c₁ + c₂) := by simp_all [← add_assoc]
 #align function.periodic.add_period Function.Periodic.add_period
 
-/- warning: function.periodic.sub_eq -> Function.Periodic.sub_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (forall (x : α), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) x c)) (f x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) -> (forall (x : α), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) x c)) (f x))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_eq Function.Periodic.sub_eqₓ'. -/
 theorem Periodic.sub_eq [AddGroup α] (h : Periodic f c) (x : α) : f (x - c) = f x := by
   simpa only [sub_add_cancel] using (h (x - c)).symm
 #align function.periodic.sub_eq Function.Periodic.sub_eq
 
-/- warning: function.periodic.sub_eq' -> Function.Periodic.sub_eq' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddCommGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) f c) -> (Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddCommGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) f c) -> (Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) c x)) (f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α _inst_1))))) x)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_eq' Function.Periodic.sub_eq'ₓ'. -/
 theorem Periodic.sub_eq' [AddCommGroup α] (h : Periodic f c) : f (c - x) = f (-x) := by
   simpa only [sub_eq_neg_add] using h (-x)
 #align function.periodic.sub_eq' Function.Periodic.sub_eq'
 
-/- warning: function.periodic.neg -> Function.Periodic.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) -> (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1)))) c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.neg Function.Periodic.negₓ'. -/
 protected theorem Periodic.neg [AddGroup α] (h : Periodic f c) : Periodic f (-c) := by
   simpa only [sub_eq_add_neg, periodic] using h.sub_eq
 #align function.periodic.neg Function.Periodic.neg
 
-/- warning: function.periodic.sub_period -> Function.Periodic.sub_period is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c₁) -> (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c₂) -> (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c₁ c₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c₁) -> (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c₂) -> (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) c₁ c₂))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_period Function.Periodic.sub_periodₓ'. -/
 theorem Periodic.sub_period [AddGroup α] (h1 : Periodic f c₁) (h2 : Periodic f c₂) :
     Periodic f (c₁ - c₂) := by simpa only [sub_eq_add_neg] using h1.add_period h2.neg
 #align function.periodic.sub_period Function.Periodic.sub_period
 
-/- warning: function.periodic.const_add -> Function.Periodic.const_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddSemigroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α _inst_1) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α _inst_1) (fun (x : α) => f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α _inst_1)) a x)) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddSemigroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α _inst_1) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α _inst_1) (fun (x : α) => f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddSemigroup.toAdd.{u2} α _inst_1)) a x)) c)
-Case conversion may be inaccurate. Consider using '#align function.periodic.const_add Function.Periodic.const_addₓ'. -/
 theorem Periodic.const_add [AddSemigroup α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a + x)) c := fun x => by simpa [add_assoc] using h (a + x)
 #align function.periodic.const_add Function.Periodic.const_add
 
-/- warning: function.periodic.add_const -> Function.Periodic.add_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommSemigroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_1)) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_1)) (fun (x : α) => f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_1))) x a)) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommSemigroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α (AddCommSemigroup.toAddSemigroup.{u2} α _inst_1)) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α (AddCommSemigroup.toAddSemigroup.{u2} α _inst_1)) (fun (x : α) => f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddSemigroup.toAdd.{u2} α (AddCommSemigroup.toAddSemigroup.{u2} α _inst_1))) x a)) c)
-Case conversion may be inaccurate. Consider using '#align function.periodic.add_const Function.Periodic.add_constₓ'. -/
 theorem Periodic.add_const [AddCommSemigroup α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x + a)) c := by simpa only [add_comm] using h.const_add a
 #align function.periodic.add_const Function.Periodic.add_const
 
-/- warning: function.periodic.const_sub -> Function.Periodic.const_sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (fun (x : α) => f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a x)) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) (fun (x : α) => f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) a x)) c)
-Case conversion may be inaccurate. Consider using '#align function.periodic.const_sub Function.Periodic.const_subₓ'. -/
 theorem Periodic.const_sub [AddCommGroup α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a - x)) c := fun x => by simp only [← sub_sub, h.sub_eq]
 #align function.periodic.const_sub Function.Periodic.const_sub
 
-/- warning: function.periodic.sub_const -> Function.Periodic.sub_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (fun (x : α) => f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) x a)) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) (fun (x : α) => f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) x a)) c)
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_const Function.Periodic.sub_constₓ'. -/
 theorem Periodic.sub_const [AddCommGroup α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x - a)) c := by simpa only [sub_eq_add_neg] using h.add_const (-a)
 #align function.periodic.sub_const Function.Periodic.sub_const
 
-/- warning: function.periodic.nsmul -> Function.Periodic.nsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) f c) -> (forall (n : Nat), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) f (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α _inst_1) n c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α _inst_1)) f c) -> (forall (n : Nat), Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α _inst_1)) f (HSMul.hSMul.{0, u2, u2} Nat α α (instHSMul.{0, u2} Nat α (AddMonoid.SMul.{u2} α _inst_1)) n c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.nsmul Function.Periodic.nsmulₓ'. -/
 theorem Periodic.nsmul [AddMonoid α] (h : Periodic f c) (n : ℕ) : Periodic f (n • c) := by
   induction n <;> simp_all [Nat.succ_eq_add_one, add_nsmul, ← add_assoc, zero_nsmul]
 #align function.periodic.nsmul Function.Periodic.nsmul
 
-/- warning: function.periodic.nat_mul -> Function.Periodic.nat_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) f c) -> (forall (n : Nat), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))))) n) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) f c) -> (forall (n : Nat), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α _inst_1) n) c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.nat_mul Function.Periodic.nat_mulₓ'. -/
 theorem Periodic.nat_mul [Semiring α] (h : Periodic f c) (n : ℕ) : Periodic f (n * c) := by
   simpa only [nsmul_eq_mul] using h.nsmul n
 #align function.periodic.nat_mul Function.Periodic.nat_mul
 
-/- warning: function.periodic.neg_nsmul -> Function.Periodic.neg_nsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (forall (n : Nat), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) n c)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) -> (forall (n : Nat), Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1)))) (HSMul.hSMul.{0, u2, u2} Nat α α (instHSMul.{0, u2} Nat α (AddMonoid.SMul.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) n c)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.neg_nsmul Function.Periodic.neg_nsmulₓ'. -/
 theorem Periodic.neg_nsmul [AddGroup α] (h : Periodic f c) (n : ℕ) : Periodic f (-(n • c)) :=
   (h.nsmul n).neg
 #align function.periodic.neg_nsmul Function.Periodic.neg_nsmul
 
-/- warning: function.periodic.neg_nat_mul -> Function.Periodic.neg_nat_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) n) c)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.neg_nat_mul Function.Periodic.neg_nat_mulₓ'. -/
 theorem Periodic.neg_nat_mul [Ring α] (h : Periodic f c) (n : ℕ) : Periodic f (-(n * c)) :=
   (h.nat_mul n).neg
 #align function.periodic.neg_nat_mul Function.Periodic.neg_nat_mul
 
-/- warning: function.periodic.sub_nsmul_eq -> Function.Periodic.sub_nsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) x (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) n c))) (f x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) x (HSMul.hSMul.{0, u2, u2} Nat α α (instHSMul.{0, u2} Nat α (AddMonoid.SMul.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) n c))) (f x))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_nsmul_eq Function.Periodic.sub_nsmul_eqₓ'. -/
 theorem Periodic.sub_nsmul_eq [AddGroup α] (h : Periodic f c) (n : ℕ) : f (x - n • c) = f x := by
   simpa only [sub_eq_add_neg] using h.neg_nsmul n x
 #align function.periodic.sub_nsmul_eq Function.Periodic.sub_nsmul_eq
 
-/- warning: function.periodic.sub_nat_mul_eq -> Function.Periodic.sub_nat_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c))) (f x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) x (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) n) c))) (f x))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_nat_mul_eq Function.Periodic.sub_nat_mul_eqₓ'. -/
 theorem Periodic.sub_nat_mul_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (x - n * c) = f x := by
   simpa only [nsmul_eq_mul] using h.sub_nsmul_eq n
 #align function.periodic.sub_nat_mul_eq Function.Periodic.sub_nat_mul_eq
 
-/- warning: function.periodic.nsmul_sub_eq -> Function.Periodic.nsmul_sub_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddCommGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddCommGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) (HSMul.hSMul.{0, u2, u2} Nat α α (instHSMul.{0, u2} Nat α (AddMonoid.SMul.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) n c) x)) (f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α _inst_1))))) x)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.nsmul_sub_eq Function.Periodic.nsmul_sub_eqₓ'. -/
 theorem Periodic.nsmul_sub_eq [AddCommGroup α] (h : Periodic f c) (n : ℕ) :
     f (n • c - x) = f (-x) :=
   (h.nsmul n).sub_eq'
 #align function.periodic.nsmul_sub_eq Function.Periodic.nsmul_sub_eq
 
-/- warning: function.periodic.nat_mul_sub_eq -> Function.Periodic.nat_mul_sub_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))) x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) n) c) x)) (f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) x)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.nat_mul_sub_eq Function.Periodic.nat_mul_sub_eqₓ'. -/
 theorem Periodic.nat_mul_sub_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (n * c - x) = f (-x) := by
   simpa only [sub_eq_neg_add] using h.nat_mul n (-x)
 #align function.periodic.nat_mul_sub_eq Function.Periodic.nat_mul_sub_eq
 
-/- warning: function.periodic.zsmul -> Function.Periodic.zsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (forall (n : Int), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) n c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) -> (forall (n : Int), Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f (HSMul.hSMul.{0, u2, u2} Int α α (instHSMul.{0, u2} Int α (SubNegMonoid.SMulInt.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) n c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.zsmul Function.Periodic.zsmulₓ'. -/
 protected theorem Periodic.zsmul [AddGroup α] (h : Periodic f c) (n : ℤ) : Periodic f (n • c) :=
   by
   cases n
@@ -462,123 +240,51 @@ protected theorem Periodic.zsmul [AddGroup α] (h : Periodic f c) (n : ℤ) : Pe
   · simpa only [negSucc_zsmul] using (h.nsmul n.succ).neg
 #align function.periodic.zsmul Function.Periodic.zsmul
 
-/- warning: function.periodic.int_mul -> Function.Periodic.int_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Int), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c))
-Case conversion may be inaccurate. Consider using '#align function.periodic.int_mul Function.Periodic.int_mulₓ'. -/
 protected theorem Periodic.int_mul [Ring α] (h : Periodic f c) (n : ℤ) : Periodic f (n * c) := by
   simpa only [zsmul_eq_mul] using h.zsmul n
 #align function.periodic.int_mul Function.Periodic.int_mul
 
-/- warning: function.periodic.sub_zsmul_eq -> Function.Periodic.sub_zsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) x (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) n c))) (f x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) x (HSMul.hSMul.{0, u2, u2} Int α α (instHSMul.{0, u2} Int α (SubNegMonoid.SMulInt.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) n c))) (f x))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_zsmul_eq Function.Periodic.sub_zsmul_eqₓ'. -/
 theorem Periodic.sub_zsmul_eq [AddGroup α] (h : Periodic f c) (n : ℤ) : f (x - n • c) = f x :=
   (h.zsmul n).sub_eq x
 #align function.periodic.sub_zsmul_eq Function.Periodic.sub_zsmul_eq
 
-/- warning: function.periodic.sub_int_mul_eq -> Function.Periodic.sub_int_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c))) (f x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) x (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c))) (f x))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_int_mul_eq Function.Periodic.sub_int_mul_eqₓ'. -/
 theorem Periodic.sub_int_mul_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (x - n * c) = f x :=
   (h.int_mul n).sub_eq x
 #align function.periodic.sub_int_mul_eq Function.Periodic.sub_int_mul_eq
 
-/- warning: function.periodic.zsmul_sub_eq -> Function.Periodic.zsmul_sub_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddCommGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) n c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddCommGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) (HSMul.hSMul.{0, u2, u2} Int α α (instHSMul.{0, u2} Int α (SubNegMonoid.SMulInt.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) n c) x)) (f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α _inst_1))))) x)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.zsmul_sub_eq Function.Periodic.zsmul_sub_eqₓ'. -/
 theorem Periodic.zsmul_sub_eq [AddCommGroup α] (h : Periodic f c) (n : ℤ) :
     f (n • c - x) = f (-x) :=
   (h.zsmul _).sub_eq'
 #align function.periodic.zsmul_sub_eq Function.Periodic.zsmul_sub_eq
 
-/- warning: function.periodic.int_mul_sub_eq -> Function.Periodic.int_mul_sub_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))) x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c) x)) (f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) x)))
-Case conversion may be inaccurate. Consider using '#align function.periodic.int_mul_sub_eq Function.Periodic.int_mul_sub_eqₓ'. -/
 theorem Periodic.int_mul_sub_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (n * c - x) = f (-x) :=
   (h.int_mul _).sub_eq'
 #align function.periodic.int_mul_sub_eq Function.Periodic.int_mul_sub_eq
 
-/- warning: function.periodic.eq -> Function.Periodic.eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddZeroClass.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α _inst_1) f c) -> (Eq.{succ u2} β (f c) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddZeroClass.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α _inst_1) f c) -> (Eq.{succ u1} β (f c) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (AddZeroClass.toZero.{u2} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.eq Function.Periodic.eqₓ'. -/
 protected theorem Periodic.eq [AddZeroClass α] (h : Periodic f c) : f c = f 0 := by
   simpa only [zero_add] using h 0
 #align function.periodic.eq Function.Periodic.eq
 
-/- warning: function.periodic.neg_eq -> Function.Periodic.neg_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (Eq.{succ u2} β (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) c)) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) -> (Eq.{succ u1} β (f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1)))) c)) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.neg_eq Function.Periodic.neg_eqₓ'. -/
 protected theorem Periodic.neg_eq [AddGroup α] (h : Periodic f c) : f (-c) = f 0 :=
   h.neg.Eq
 #align function.periodic.neg_eq Function.Periodic.neg_eq
 
-/- warning: function.periodic.nsmul_eq -> Function.Periodic.nsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α _inst_1) n c)) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSMul.hSMul.{0, u2, u2} Nat α α (instHSMul.{0, u2} Nat α (AddMonoid.SMul.{u2} α _inst_1)) n c)) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (AddMonoid.toZero.{u2} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.nsmul_eq Function.Periodic.nsmul_eqₓ'. -/
 protected theorem Periodic.nsmul_eq [AddMonoid α] (h : Periodic f c) (n : ℕ) : f (n • c) = f 0 :=
   (h.nsmul n).Eq
 #align function.periodic.nsmul_eq Function.Periodic.nsmul_eq
 
-/- warning: function.periodic.nat_mul_eq -> Function.Periodic.nat_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))))) n) c)) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α _inst_1) n) c)) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.nat_mul_eq Function.Periodic.nat_mul_eqₓ'. -/
 theorem Periodic.nat_mul_eq [Semiring α] (h : Periodic f c) (n : ℕ) : f (n * c) = f 0 :=
   (h.nat_mul n).Eq
 #align function.periodic.nat_mul_eq Function.Periodic.nat_mul_eq
 
-/- warning: function.periodic.zsmul_eq -> Function.Periodic.zsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (forall (n : Int), Eq.{succ u2} β (f (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) n c)) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HSMul.hSMul.{0, u2, u2} Int α α (instHSMul.{0, u2} Int α (SubNegMonoid.SMulInt.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) n c)) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.zsmul_eq Function.Periodic.zsmul_eqₓ'. -/
 theorem Periodic.zsmul_eq [AddGroup α] (h : Periodic f c) (n : ℤ) : f (n • c) = f 0 :=
   (h.zsmul n).Eq
 #align function.periodic.zsmul_eq Function.Periodic.zsmul_eq
 
-/- warning: function.periodic.int_mul_eq -> Function.Periodic.int_mul_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c)) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c)) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (Ring.toSemiring.{u2} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.int_mul_eq Function.Periodic.int_mul_eqₓ'. -/
 theorem Periodic.int_mul_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (n * c) = f 0 :=
   (h.int_mul n).Eq
 #align function.periodic.int_mul_eq Function.Periodic.int_mul_eq
 
-/- warning: function.periodic.exists_mem_Ico₀ -> Function.Periodic.exists_mem_Ico₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c)) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c)) => Eq.{succ u2} β (f x) (f y))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u2} α] [_inst_2 : Archimedean.{u2} α (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u2} α (LinearOrderedCancelAddCommMonoid.toLinearOrderedAddCommMonoid.{u2} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u2} α _inst_1)))], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))) f c) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c) -> (forall (x : α), Exists.{succ u2} α (fun (y : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) y (Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c)) (Eq.{succ u1} β (f x) (f y))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.exists_mem_Ico₀ Function.Periodic.exists_mem_Ico₀ₓ'. -/
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ico 0 c` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
@@ -587,12 +293,6 @@ theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean 
   ⟨x - n • c, H, (h.sub_zsmul_eq n).symm⟩
 #align function.periodic.exists_mem_Ico₀ Function.Periodic.exists_mem_Ico₀
 
-/- warning: function.periodic.exists_mem_Ico -> Function.Periodic.exists_mem_Ico is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) => Eq.{succ u2} β (f x) (f y))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u2} α] [_inst_2 : Archimedean.{u2} α (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u2} α (LinearOrderedCancelAddCommMonoid.toLinearOrderedAddCommMonoid.{u2} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u2} α _inst_1)))], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))) f c) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u2} α (fun (y : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) y (Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))) a (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))))))) a c))) (Eq.{succ u1} β (f x) (f y))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.exists_mem_Ico Function.Periodic.exists_mem_Icoₓ'. -/
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ico a (a + c)` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
@@ -601,12 +301,6 @@ theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α]
   ⟨x + n • c, H, (h.zsmul n x).symm⟩
 #align function.periodic.exists_mem_Ico Function.Periodic.exists_mem_Ico
 
-/- warning: function.periodic.exists_mem_Ioc -> Function.Periodic.exists_mem_Ioc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) => Eq.{succ u2} β (f x) (f y))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u2} α] [_inst_2 : Archimedean.{u2} α (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u2} α (LinearOrderedCancelAddCommMonoid.toLinearOrderedAddCommMonoid.{u2} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u2} α _inst_1)))], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))) f c) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u2} α (fun (y : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) y (Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))) a (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))))))) a c))) (Eq.{succ u1} β (f x) (f y))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.exists_mem_Ioc Function.Periodic.exists_mem_Iocₓ'. -/
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ioc a (a + c)` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
@@ -615,12 +309,6 @@ theorem Periodic.exists_mem_Ioc [LinearOrderedAddCommGroup α] [Archimedean α]
   ⟨x + n • c, H, (h.zsmul n x).symm⟩
 #align function.periodic.exists_mem_Ioc Function.Periodic.exists_mem_Ioc
 
-/- warning: function.periodic.image_Ioc -> Function.Periodic.image_Ioc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (a : α), Eq.{succ u2} (Set.{u2} β) (Set.image.{u1, u2} α β f (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (Set.range.{u2, succ u1} β α f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u2} α] [_inst_2 : Archimedean.{u2} α (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u2} α (LinearOrderedCancelAddCommMonoid.toLinearOrderedAddCommMonoid.{u2} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u2} α _inst_1)))], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))) f c) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c) -> (forall (a : α), Eq.{succ u1} (Set.{u1} β) (Set.image.{u2, u1} α β f (Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))) a (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))))))) a c))) (Set.range.{u1, succ u2} β α f))
-Case conversion may be inaccurate. Consider using '#align function.periodic.image_Ioc Function.Periodic.image_Iocₓ'. -/
 theorem Periodic.image_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
     (hc : 0 < c) (a : α) : f '' Set.Ioc a (a + c) = Set.range f :=
   (Set.image_subset_range _ _).antisymm <|
@@ -629,44 +317,20 @@ theorem Periodic.image_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h :
       ⟨y, hy, hyx.symm⟩
 #align function.periodic.image_Ioc Function.Periodic.image_Ioc
 
-/- warning: function.periodic_with_period_zero -> Function.periodic_with_period_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddZeroClass.{u1} α] (f : α -> β), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α _inst_1) f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : AddZeroClass.{u2} α] (f : α -> β), Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α _inst_1) f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (AddZeroClass.toZero.{u2} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align function.periodic_with_period_zero Function.periodic_with_period_zeroₓ'. -/
 theorem periodic_with_period_zero [AddZeroClass α] (f : α → β) : Periodic f 0 := fun x => by
   rw [add_zero]
 #align function.periodic_with_period_zero Function.periodic_with_period_zero
 
-/- warning: function.periodic.map_vadd_zmultiples -> Function.Periodic.map_vadd_zmultiples is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) f c) -> (forall (a : coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) α (AddSubgroup.setLike.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) (AddSubgroup.zmultiples.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) c)) (x : α), Eq.{succ u2} β (f (VAdd.vadd.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) α (AddSubgroup.setLike.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) (AddSubgroup.zmultiples.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) c)) α (AddAction.toHasVadd.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) α (AddSubgroup.setLike.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) (AddSubgroup.zmultiples.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) c)) α (SubNegMonoid.toAddMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) α (AddSubgroup.setLike.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) (AddSubgroup.zmultiples.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) c)) (AddGroup.toSubNegMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)) α (AddSubgroup.setLike.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) (AddSubgroup.zmultiples.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) c)) (AddSubgroup.toAddGroup.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) (AddSubgroup.zmultiples.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) c)))) (AddSubgroup.addAction.{u1, u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) α (AddMonoid.toAddAction.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) (AddSubgroup.zmultiples.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1) c))) a x)) (f x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) f c) -> (forall (a : Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) (SetLike.instMembership.{u2, u2} (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) α (AddSubgroup.instSetLikeAddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))) x (AddSubgroup.zmultiples.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) c))) (x : α), Eq.{succ u1} β (f (HVAdd.hVAdd.{u2, u2, u2} (Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) (SetLike.instMembership.{u2, u2} (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) α (AddSubgroup.instSetLikeAddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))) x (AddSubgroup.zmultiples.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) c))) α α (instHVAdd.{u2, u2} (Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) (SetLike.instMembership.{u2, u2} (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) α (AddSubgroup.instSetLikeAddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))) x (AddSubgroup.zmultiples.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) c))) α (AddSubmonoid.vadd.{u2, u2} α α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) (AddAction.toVAdd.{u2, u2} α α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))) (AddMonoid.toAddAction.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) (AddSubgroup.toAddSubmonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) (AddSubgroup.zmultiples.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) c)))) a x)) (f x))
-Case conversion may be inaccurate. Consider using '#align function.periodic.map_vadd_zmultiples Function.Periodic.map_vadd_zmultiplesₓ'. -/
 theorem Periodic.map_vadd_zmultiples [AddCommGroup α] (hf : Periodic f c)
     (a : AddSubgroup.zmultiples c) (x : α) : f (a +ᵥ x) = f x := by rcases a with ⟨_, m, rfl⟩;
   simp [AddSubgroup.vadd_def, add_comm _ x, hf.zsmul m x]
 #align function.periodic.map_vadd_zmultiples Function.Periodic.map_vadd_zmultiples
 
-/- warning: function.periodic.map_vadd_multiples -> Function.Periodic.map_vadd_multiples is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) f c) -> (forall (a : coeSort.{succ u1, succ (succ u1)} (AddSubmonoid.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubmonoid.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) α (AddSubmonoid.setLike.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1)))) (AddSubmonoid.multiples.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1) c)) (x : α), Eq.{succ u2} β (f (VAdd.vadd.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (AddSubmonoid.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubmonoid.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) α (AddSubmonoid.setLike.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1)))) (AddSubmonoid.multiples.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1) c)) α (AddSubmonoid.hasVadd.{u1, u1} α α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1)) (Add.toVAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1)))) (AddSubmonoid.multiples.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1) c)) a x)) (f x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) f c) -> (forall (a : Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) α (AddSubmonoid.instSetLikeAddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1)))) x (AddSubmonoid.multiples.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) c))) (x : α), Eq.{succ u1} β (f (HVAdd.hVAdd.{u2, u2, u2} (Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) α (AddSubmonoid.instSetLikeAddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1)))) x (AddSubmonoid.multiples.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) c))) α α (instHVAdd.{u2, u2} (Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) α (AddSubmonoid.instSetLikeAddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1)))) x (AddSubmonoid.multiples.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) c))) α (AddSubmonoid.vadd.{u2, u2} α α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1)) (AddAction.toVAdd.{u2, u2} α α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) (AddMonoid.toAddAction.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) (AddSubmonoid.multiples.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) c))) a x)) (f x))
-Case conversion may be inaccurate. Consider using '#align function.periodic.map_vadd_multiples Function.Periodic.map_vadd_multiplesₓ'. -/
 theorem Periodic.map_vadd_multiples [AddCommMonoid α] (hf : Periodic f c)
     (a : AddSubmonoid.multiples c) (x : α) : f (a +ᵥ x) = f x := by rcases a with ⟨_, m, rfl⟩;
   simp [AddSubmonoid.vadd_def, add_comm _ x, hf.nsmul m x]
 #align function.periodic.map_vadd_multiples Function.Periodic.map_vadd_multiples
 
-/- warning: function.periodic.lift -> Function.Periodic.lift is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (HasQuotient.Quotient.{u1, u1} α (AddSubgroup.{u1} α _inst_1) (quotientAddGroup.Subgroup.hasQuotient.{u1} α _inst_1) (AddSubgroup.zmultiples.{u1} α _inst_1 c)) -> β
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α], (Function.Periodic.{u1, u2} α β (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) -> (HasQuotient.Quotient.{u1, u1} α (AddSubgroup.{u1} α _inst_1) (QuotientAddGroup.instHasQuotientAddSubgroup.{u1} α _inst_1) (AddSubgroup.zmultiples.{u1} α _inst_1 c)) -> β
-Case conversion may be inaccurate. Consider using '#align function.periodic.lift Function.Periodic.liftₓ'. -/
 /-- Lift a periodic function to a function from the quotient group. -/
 def Periodic.lift [AddGroup α] (h : Periodic f c) (x : α ⧸ AddSubgroup.zmultiples c) : β :=
   Quotient.liftOn' x f fun a b h' =>
@@ -676,12 +340,6 @@ def Periodic.lift [AddGroup α] (h : Periodic f c) (x : α ⧸ AddSubgroup.zmult
     exact (h.zsmul k _).symm.trans (congr_arg f (add_eq_of_eq_neg_add hk))
 #align function.periodic.lift Function.Periodic.lift
 
-/- warning: function.periodic.lift_coe -> Function.Periodic.lift_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α] (h : Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c) (a : α), Eq.{succ u2} β (Function.Periodic.lift.{u1, u2} α β f c _inst_1 h ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (HasQuotient.Quotient.{u1, u1} α (AddSubgroup.{u1} α _inst_1) (quotientAddGroup.Subgroup.hasQuotient.{u1} α _inst_1) (AddSubgroup.zmultiples.{u1} α _inst_1 c)) (HasLiftT.mk.{succ u1, succ u1} α (HasQuotient.Quotient.{u1, u1} α (AddSubgroup.{u1} α _inst_1) (quotientAddGroup.Subgroup.hasQuotient.{u1} α _inst_1) (AddSubgroup.zmultiples.{u1} α _inst_1 c)) (CoeTCₓ.coe.{succ u1, succ u1} α (HasQuotient.Quotient.{u1, u1} α (AddSubgroup.{u1} α _inst_1) (quotientAddGroup.Subgroup.hasQuotient.{u1} α _inst_1) (AddSubgroup.zmultiples.{u1} α _inst_1 c)) (quotientAddGroup.HasQuotient.Quotient.hasCoeT.{u1} α _inst_1 (AddSubgroup.zmultiples.{u1} α _inst_1 c)))) a)) (f a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α] (h : Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c) (a : α), Eq.{succ u1} β (Function.Periodic.lift.{u2, u1} α β f c _inst_1 h (QuotientAddGroup.mk.{u2} α _inst_1 (AddSubgroup.zmultiples.{u2} α _inst_1 c) a)) (f a)
-Case conversion may be inaccurate. Consider using '#align function.periodic.lift_coe Function.Periodic.lift_coeₓ'. -/
 @[simp]
 theorem Periodic.lift_coe [AddGroup α] (h : Periodic f c) (a : α) :
     h.lift (a : α ⧸ AddSubgroup.zmultiples c) = f a :=
@@ -700,398 +358,176 @@ def Antiperiodic [Add α] [Neg β] (f : α → β) (c : α) : Prop :=
 #align function.antiperiodic Function.Antiperiodic
 -/
 
-/- warning: function.antiperiodic.funext -> Function.Antiperiodic.funext is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β _inst_1 _inst_2 f c) -> (Eq.{max (succ u1) (succ u2)} (α -> β) (fun (x : α) => f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x c)) (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (x : α) => β) (fun (i : α) => _inst_2)) f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Add.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β _inst_1 _inst_2 f c) -> (Eq.{max (succ u2) (succ u1)} (α -> β) (fun (x : α) => f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α _inst_1) x c)) (Neg.neg.{max u2 u1} (α -> β) (Pi.instNeg.{u2, u1} α (fun (x : α) => β) (fun (i : α) => _inst_2)) f))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.funext Function.Antiperiodic.funextₓ'. -/
 protected theorem Antiperiodic.funext [Add α] [Neg β] (h : Antiperiodic f c) :
     (fun x => f (x + c)) = -f :=
   funext h
 #align function.antiperiodic.funext Function.Antiperiodic.funext
 
-/- warning: function.antiperiodic.funext' -> Function.Antiperiodic.funext' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β _inst_1 (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (Eq.{max (succ u1) (succ u2)} (α -> β) (fun (x : α) => Neg.neg.{u2} β (InvolutiveNeg.toHasNeg.{u2} β _inst_2) (f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x c))) f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Add.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β _inst_1 (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (Eq.{max (succ u2) (succ u1)} (α -> β) (fun (x : α) => Neg.neg.{u1} β (InvolutiveNeg.toNeg.{u1} β _inst_2) (f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α _inst_1) x c))) f)
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.funext' Function.Antiperiodic.funext'ₓ'. -/
 protected theorem Antiperiodic.funext' [Add α] [InvolutiveNeg β] (h : Antiperiodic f c) :
     (fun x => -f (x + c)) = f :=
   neg_eq_iff_eq_neg.mpr h.funext
 #align function.antiperiodic.funext' Function.Antiperiodic.funext'
 
-/- warning: function.antiperiodic.periodic -> Function.Antiperiodic.periodic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))))))) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (Semiring.toNatCast.{u2} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.periodic Function.Antiperiodic.periodicₓ'. -/
 /-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
   `2 * c`. -/
 protected theorem Antiperiodic.periodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c) :
     Periodic f (2 * c) := by simp [two_mul, ← add_assoc, h _]
 #align function.antiperiodic.periodic Function.Antiperiodic.periodic
 
-/- warning: function.antiperiodic.eq -> Function.Antiperiodic.eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddZeroClass.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α _inst_1) _inst_2 f c) -> (Eq.{succ u2} β (f c) (Neg.neg.{u2} β _inst_2 (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddZeroClass.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α _inst_1) _inst_2 f c) -> (Eq.{succ u1} β (f c) (Neg.neg.{u1} β _inst_2 (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (AddZeroClass.toZero.{u2} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.eq Function.Antiperiodic.eqₓ'. -/
 protected theorem Antiperiodic.eq [AddZeroClass α] [Neg β] (h : Antiperiodic f c) : f c = -f 0 := by
   simpa only [zero_add] using h 0
 #align function.antiperiodic.eq Function.Antiperiodic.eq
 
-/- warning: function.antiperiodic.nat_even_mul_periodic -> Function.Antiperiodic.nat_even_mul_periodic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Nat), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))))))) c)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Nat), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (Semiring.toNatCast.{u2} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.nat_even_mul_periodic Function.Antiperiodic.nat_even_mul_periodicₓ'. -/
 theorem Antiperiodic.nat_even_mul_periodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℕ) : Periodic f (n * (2 * c)) :=
   h.Periodic.nat_mul n
 #align function.antiperiodic.nat_even_mul_periodic Function.Antiperiodic.nat_even_mul_periodic
 
-/- warning: function.antiperiodic.nat_odd_mul_antiperiodic -> Function.Antiperiodic.nat_odd_mul_antiperiodic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Nat), Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))))))) c)) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Nat), Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (Semiring.toNatCast.{u2} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)) c))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.nat_odd_mul_antiperiodic Function.Antiperiodic.nat_odd_mul_antiperiodicₓ'. -/
 theorem Antiperiodic.nat_odd_mul_antiperiodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℕ) : Antiperiodic f (n * (2 * c) + c) := fun x => by
   rw [← add_assoc, h, h.periodic.nat_mul]
 #align function.antiperiodic.nat_odd_mul_antiperiodic Function.Antiperiodic.nat_odd_mul_antiperiodic
 
-/- warning: function.antiperiodic.int_even_mul_periodic -> Function.Antiperiodic.int_even_mul_periodic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Int), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) c)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Int), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.int_even_mul_periodic Function.Antiperiodic.int_even_mul_periodicₓ'. -/
 theorem Antiperiodic.int_even_mul_periodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℤ) : Periodic f (n * (2 * c)) :=
   h.Periodic.int_mul n
 #align function.antiperiodic.int_even_mul_periodic Function.Antiperiodic.int_even_mul_periodic
 
-/- warning: function.antiperiodic.int_odd_mul_antiperiodic -> Function.Antiperiodic.int_odd_mul_antiperiodic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Int), Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) c)) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Int), Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)) c))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.int_odd_mul_antiperiodic Function.Antiperiodic.int_odd_mul_antiperiodicₓ'. -/
 theorem Antiperiodic.int_odd_mul_antiperiodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℤ) : Antiperiodic f (n * (2 * c) + c) := fun x => by
   rw [← add_assoc, h, h.periodic.int_mul]
 #align function.antiperiodic.int_odd_mul_antiperiodic Function.Antiperiodic.int_odd_mul_antiperiodic
 
-/- warning: function.antiperiodic.sub_eq -> Function.Antiperiodic.sub_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (x : α), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) x c)) (Neg.neg.{u2} β (InvolutiveNeg.toHasNeg.{u2} β _inst_2) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (x : α), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) x c)) (Neg.neg.{u1} β (InvolutiveNeg.toNeg.{u1} β _inst_2) (f x)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.sub_eq Function.Antiperiodic.sub_eqₓ'. -/
 theorem Antiperiodic.sub_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) (x : α) :
     f (x - c) = -f x := by rw [← neg_eq_iff_eq_neg, ← h (x - c), sub_add_cancel]
 #align function.antiperiodic.sub_eq Function.Antiperiodic.sub_eq
 
-/- warning: function.antiperiodic.sub_eq' -> Function.Antiperiodic.sub_eq' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) _inst_2 f c) -> (Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c x)) (Neg.neg.{u2} β _inst_2 (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) x))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : AddCommGroup.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) _inst_2 f c) -> (Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) c x)) (Neg.neg.{u1} β _inst_2 (f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α _inst_1))))) x))))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.sub_eq' Function.Antiperiodic.sub_eq'ₓ'. -/
 theorem Antiperiodic.sub_eq' [AddCommGroup α] [Neg β] (h : Antiperiodic f c) :
     f (c - x) = -f (-x) := by simpa only [sub_eq_neg_add] using h (-x)
 #align function.antiperiodic.sub_eq' Function.Antiperiodic.sub_eq'
 
-/- warning: function.antiperiodic.neg -> Function.Antiperiodic.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1)))) c))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.neg Function.Antiperiodic.negₓ'. -/
 protected theorem Antiperiodic.neg [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) :
     Antiperiodic f (-c) := by simpa only [sub_eq_add_neg, antiperiodic] using h.sub_eq
 #align function.antiperiodic.neg Function.Antiperiodic.neg
 
-/- warning: function.antiperiodic.neg_eq -> Function.Antiperiodic.neg_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (Eq.{succ u2} β (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) c)) (Neg.neg.{u2} β (InvolutiveNeg.toHasNeg.{u2} β _inst_2) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (Eq.{succ u1} β (f (Neg.neg.{u2} α (NegZeroClass.toNeg.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1)))) c)) (Neg.neg.{u1} β (InvolutiveNeg.toNeg.{u1} β _inst_2) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.neg_eq Function.Antiperiodic.neg_eqₓ'. -/
 theorem Antiperiodic.neg_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) : f (-c) = -f 0 :=
   by simpa only [zero_add] using h.neg 0
 #align function.antiperiodic.neg_eq Function.Antiperiodic.neg_eq
 
-/- warning: function.antiperiodic.nat_mul_eq_of_eq_zero -> Function.Antiperiodic.nat_mul_eq_of_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : NegZeroClass.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (NegZeroClass.toHasNeg.{u2} β _inst_2) f c) -> (Eq.{succ u2} β (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (NegZeroClass.toHasZero.{u2} β _inst_2))))) -> (forall (n : Nat), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c)) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (NegZeroClass.toHasZero.{u2} β _inst_2)))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u2} α] [_inst_2 : NegZeroClass.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (NegZeroClass.toNeg.{u1} β _inst_2) f c) -> (Eq.{succ u1} β (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1))))) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (NegZeroClass.toZero.{u1} β _inst_2)))) -> (forall (n : Nat), Eq.{succ u1} β (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α _inst_1) n) c)) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (NegZeroClass.toZero.{u1} β _inst_2))))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.nat_mul_eq_of_eq_zero Function.Antiperiodic.nat_mul_eq_of_eq_zeroₓ'. -/
 theorem Antiperiodic.nat_mul_eq_of_eq_zero [Ring α] [NegZeroClass β] (h : Antiperiodic f c)
     (hi : f 0 = 0) : ∀ n : ℕ, f (n * c) = 0
   | 0 => by rwa [Nat.cast_zero, MulZeroClass.zero_mul]
   | n + 1 => by simp [add_mul, antiperiodic.nat_mul_eq_of_eq_zero n, h _]
 #align function.antiperiodic.nat_mul_eq_of_eq_zero Function.Antiperiodic.nat_mul_eq_of_eq_zero
 
-/- warning: function.antiperiodic.int_mul_eq_of_eq_zero -> Function.Antiperiodic.int_mul_eq_of_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : SubtractionMonoid.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (SubNegMonoid.toHasNeg.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2)) f c) -> (Eq.{succ u2} β (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2)))))))) -> (forall (n : Int), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c)) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : SubtractionMonoid.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β _inst_2))) f c) -> (Eq.{succ u1} β (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (Ring.toSemiring.{u2} α _inst_1)))))) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β _inst_2)))))) -> (forall (n : Int), Eq.{succ u1} β (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c)) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β _inst_2))))))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.int_mul_eq_of_eq_zero Function.Antiperiodic.int_mul_eq_of_eq_zeroₓ'. -/
 theorem Antiperiodic.int_mul_eq_of_eq_zero [Ring α] [SubtractionMonoid β] (h : Antiperiodic f c)
     (hi : f 0 = 0) : ∀ n : ℤ, f (n * c) = 0
   | (n : ℕ) => by rwa [Int.cast_ofNat, h.nat_mul_eq_of_eq_zero]
   | -[n+1] => by rw [Int.cast_negSucc, neg_mul, ← mul_neg, h.neg.nat_mul_eq_of_eq_zero hi]
 #align function.antiperiodic.int_mul_eq_of_eq_zero Function.Antiperiodic.int_mul_eq_of_eq_zero
 
-/- warning: function.antiperiodic.const_add -> Function.Antiperiodic.const_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddSemigroup.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α _inst_1) _inst_2 f c) -> (forall (a : α), Function.Antiperiodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α _inst_1) _inst_2 (fun (x : α) => f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α _inst_1)) a x)) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddSemigroup.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α _inst_1) _inst_2 f c) -> (forall (a : α), Function.Antiperiodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α _inst_1) _inst_2 (fun (x : α) => f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddSemigroup.toAdd.{u2} α _inst_1)) a x)) c)
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_add Function.Antiperiodic.const_addₓ'. -/
 theorem Antiperiodic.const_add [AddSemigroup α] [Neg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (a + x)) c := fun x => by simpa [add_assoc] using h (a + x)
 #align function.antiperiodic.const_add Function.Antiperiodic.const_add
 
-/- warning: function.antiperiodic.add_const -> Function.Antiperiodic.add_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommSemigroup.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_1)) _inst_2 f c) -> (forall (a : α), Function.Antiperiodic.{u1, u2} α β (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_1)) _inst_2 (fun (x : α) => f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_1))) x a)) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommSemigroup.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α (AddCommSemigroup.toAddSemigroup.{u2} α _inst_1)) _inst_2 f c) -> (forall (a : α), Function.Antiperiodic.{u2, u1} α β (AddSemigroup.toAdd.{u2} α (AddCommSemigroup.toAddSemigroup.{u2} α _inst_1)) _inst_2 (fun (x : α) => f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddSemigroup.toAdd.{u2} α (AddCommSemigroup.toAddSemigroup.{u2} α _inst_1))) x a)) c)
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.add_const Function.Antiperiodic.add_constₓ'. -/
 theorem Antiperiodic.add_const [AddCommSemigroup α] [Neg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (x + a)) c := fun x => by simpa only [add_right_comm] using h (x + a)
 #align function.antiperiodic.add_const Function.Antiperiodic.add_const
 
-/- warning: function.antiperiodic.const_sub -> Function.Antiperiodic.const_sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (a : α), Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) (fun (x : α) => f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a x)) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (a : α), Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) (fun (x : α) => f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) a x)) c)
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_sub Function.Antiperiodic.const_subₓ'. -/
 theorem Antiperiodic.const_sub [AddCommGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (a - x)) c := fun x => by simp only [← sub_sub, h.sub_eq]
 #align function.antiperiodic.const_sub Function.Antiperiodic.const_sub
 
-/- warning: function.antiperiodic.sub_const -> Function.Antiperiodic.sub_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) _inst_2 f c) -> (forall (a : α), Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) x a)) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) _inst_2 f c) -> (forall (a : α), Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) x a)) c)
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.sub_const Function.Antiperiodic.sub_constₓ'. -/
 theorem Antiperiodic.sub_const [AddCommGroup α] [Neg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (x - a)) c := by simpa only [sub_eq_add_neg] using h.add_const (-a)
 #align function.antiperiodic.sub_const Function.Antiperiodic.sub_const
 
-/- warning: function.antiperiodic.smul -> Function.Antiperiodic.smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Monoid.{u3} γ] [_inst_3 : AddGroup.{u2} β] [_inst_4 : DistribMulAction.{u3, u2} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3))], (Function.Antiperiodic.{u1, u2} α β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) f c) -> (forall (a : γ), Function.Antiperiodic.{u1, u2} α β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) (SMul.smul.{u3, max u1 u2} γ (α -> β) (Function.hasSMul.{u1, u3, u2} α γ β (SMulZeroClass.toHasSmul.{u3, u2} γ β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)))) (DistribSMul.toSmulZeroClass.{u3, u2} γ β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3))) (DistribMulAction.toDistribSMul.{u3, u2} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) _inst_4)))) a f) c)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Monoid.{u2} γ] [_inst_3 : AddGroup.{u1} β] [_inst_4 : DistribMulAction.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))], (Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.4884 : α) => β) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} γ β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (DistribSMul.toSMulZeroClass.{u2, u1} γ β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))) (DistribMulAction.toDistribSMul.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3)) _inst_4))))) a f) c)
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.smul Function.Antiperiodic.smulₓ'. -/
 protected theorem Antiperiodic.smul [Add α] [Monoid γ] [AddGroup β] [DistribMulAction γ β]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (a • f) c := by simp_all
 #align function.antiperiodic.smul Function.Antiperiodic.smul
 
-/- warning: function.antiperiodic.const_smul -> Function.Antiperiodic.const_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u1} α] [_inst_2 : Neg.{u2} β] [_inst_3 : Group.{u3} γ] [_inst_4 : DistribMulAction.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_3)) _inst_1], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) _inst_2 f c) -> (forall (a : γ), Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) _inst_2 (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (DistribSMul.toSmulZeroClass.{u3, u1} γ α (AddMonoid.toAddZeroClass.{u1} α _inst_1) (DistribMulAction.toDistribSMul.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_3)) _inst_1 _inst_4))) a x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (DistribSMul.toSmulZeroClass.{u3, u1} γ α (AddMonoid.toAddZeroClass.{u1} α _inst_1) (DistribMulAction.toDistribSMul.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_3)) _inst_1 _inst_4))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_3)) a) c))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u3} α] [_inst_2 : Neg.{u2} β] [_inst_3 : Group.{u1} γ] [_inst_4 : DistribMulAction.{u1, u3} γ α (DivInvMonoid.toMonoid.{u1} γ (Group.toDivInvMonoid.{u1} γ _inst_3)) _inst_1], (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α _inst_1)) _inst_2 f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α _inst_1)) _inst_2 (fun (x : α) => f (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α _inst_1) (DistribSMul.toSMulZeroClass.{u1, u3} γ α (AddMonoid.toAddZeroClass.{u3} α _inst_1) (DistribMulAction.toDistribSMul.{u1, u3} γ α (DivInvMonoid.toMonoid.{u1} γ (Group.toDivInvMonoid.{u1} γ _inst_3)) _inst_1 _inst_4)))) a x)) (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α _inst_1) (DistribSMul.toSMulZeroClass.{u1, u3} γ α (AddMonoid.toAddZeroClass.{u3} α _inst_1) (DistribMulAction.toDistribSMul.{u1, u3} γ α (DivInvMonoid.toMonoid.{u1} γ (Group.toDivInvMonoid.{u1} γ _inst_3)) _inst_1 _inst_4)))) (Inv.inv.{u1} γ (InvOneClass.toInv.{u1} γ (DivInvOneMonoid.toInvOneClass.{u1} γ (DivisionMonoid.toDivInvOneMonoid.{u1} γ (Group.toDivisionMonoid.{u1} γ _inst_3)))) a) c))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_smul Function.Antiperiodic.const_smulₓ'. -/
 theorem Antiperiodic.const_smul [AddMonoid α] [Neg β] [Group γ] [DistribMulAction γ α]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (fun x => f (a • x)) (a⁻¹ • c) := fun x => by
   simpa only [smul_add, smul_inv_smul] using h (a • x)
 #align function.antiperiodic.const_smul Function.Antiperiodic.const_smul
 
-/- warning: function.antiperiodic.const_smul₀ -> Function.Antiperiodic.const_smul₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionSemiring.{u3} γ] [_inst_4 : Module.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u3} γ a (OfNat.ofNat.{u3} γ 0 (OfNat.mk.{u3} γ 0 (Zero.zero.{u3} γ (MulZeroClass.toHasZero.{u3} γ (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} γ (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} γ (Semiring.toNonAssocSemiring.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))))))) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1 _inst_4)))) a x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1 _inst_4)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (GroupWithZero.toDivInvMonoid.{u3} γ (DivisionSemiring.toGroupWithZero.{u3} γ _inst_3))) a) c)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u3} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionSemiring.{u1} γ] [_inst_4 : Module.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1], (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u1} γ a (OfNat.ofNat.{u1} γ 0 (Zero.toOfNat0.{u1} γ (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)))))) -> (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) _inst_2 (fun (x : α) => f (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u1, u3} γ α (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u1, u3} γ α (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1 _inst_4))))) a x)) (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u1, u3} γ α (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u1, u3} γ α (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1 _inst_4))))) (Inv.inv.{u1} γ (DivisionSemiring.toInv.{u1} γ _inst_3) a) c)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_smul₀ Function.Antiperiodic.const_smul₀ₓ'. -/
 theorem Antiperiodic.const_smul₀ [AddCommMonoid α] [Neg β] [DivisionSemiring γ] [Module γ α]
     (h : Antiperiodic f c) {a : γ} (ha : a ≠ 0) : Antiperiodic (fun x => f (a • x)) (a⁻¹ • c) :=
   fun x => by simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
 #align function.antiperiodic.const_smul₀ Function.Antiperiodic.const_smul₀
 
-/- warning: function.antiperiodic.const_mul -> Function.Antiperiodic.const_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) a x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a) c)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) a x)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a) c)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_mul Function.Antiperiodic.const_mulₓ'. -/
 theorem Antiperiodic.const_mul [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (a * x)) (a⁻¹ * c) :=
   h.const_smul₀ ha
 #align function.antiperiodic.const_mul Function.Antiperiodic.const_mul
 
-/- warning: function.antiperiodic.const_inv_smul -> Function.Antiperiodic.const_inv_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u1} α] [_inst_2 : Neg.{u2} β] [_inst_3 : Group.{u3} γ] [_inst_4 : DistribMulAction.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_3)) _inst_1], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) _inst_2 f c) -> (forall (a : γ), Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) _inst_2 (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (DistribSMul.toSmulZeroClass.{u3, u1} γ α (AddMonoid.toAddZeroClass.{u1} α _inst_1) (DistribMulAction.toDistribSMul.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_3)) _inst_1 _inst_4))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_3)) a) x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_1)) (DistribSMul.toSmulZeroClass.{u3, u1} γ α (AddMonoid.toAddZeroClass.{u1} α _inst_1) (DistribMulAction.toDistribSMul.{u3, u1} γ α (DivInvMonoid.toMonoid.{u3} γ (Group.toDivInvMonoid.{u3} γ _inst_3)) _inst_1 _inst_4))) a c))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddMonoid.{u3} α] [_inst_2 : Neg.{u2} β] [_inst_3 : Group.{u1} γ] [_inst_4 : DistribMulAction.{u1, u3} γ α (DivInvMonoid.toMonoid.{u1} γ (Group.toDivInvMonoid.{u1} γ _inst_3)) _inst_1], (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α _inst_1)) _inst_2 f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α _inst_1)) _inst_2 (fun (x : α) => f (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α _inst_1) (DistribSMul.toSMulZeroClass.{u1, u3} γ α (AddMonoid.toAddZeroClass.{u3} α _inst_1) (DistribMulAction.toDistribSMul.{u1, u3} γ α (DivInvMonoid.toMonoid.{u1} γ (Group.toDivInvMonoid.{u1} γ _inst_3)) _inst_1 _inst_4)))) (Inv.inv.{u1} γ (InvOneClass.toInv.{u1} γ (DivInvOneMonoid.toInvOneClass.{u1} γ (DivisionMonoid.toDivInvOneMonoid.{u1} γ (Group.toDivisionMonoid.{u1} γ _inst_3)))) a) x)) (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α _inst_1) (DistribSMul.toSMulZeroClass.{u1, u3} γ α (AddMonoid.toAddZeroClass.{u3} α _inst_1) (DistribMulAction.toDistribSMul.{u1, u3} γ α (DivInvMonoid.toMonoid.{u1} γ (Group.toDivInvMonoid.{u1} γ _inst_3)) _inst_1 _inst_4)))) a c))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_inv_smul Function.Antiperiodic.const_inv_smulₓ'. -/
 theorem Antiperiodic.const_inv_smul [AddMonoid α] [Neg β] [Group γ] [DistribMulAction γ α]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul a⁻¹
 #align function.antiperiodic.const_inv_smul Function.Antiperiodic.const_inv_smul
 
-/- warning: function.antiperiodic.const_inv_smul₀ -> Function.Antiperiodic.const_inv_smul₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionSemiring.{u3} γ] [_inst_4 : Module.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u3} γ a (OfNat.ofNat.{u3} γ 0 (OfNat.mk.{u3} γ 0 (Zero.zero.{u3} γ (MulZeroClass.toHasZero.{u3} γ (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} γ (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} γ (Semiring.toNonAssocSemiring.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))))))) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1 _inst_4)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (GroupWithZero.toDivInvMonoid.{u3} γ (DivisionSemiring.toGroupWithZero.{u3} γ _inst_3))) a) x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1 _inst_4)))) a c)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u3} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionSemiring.{u1} γ] [_inst_4 : Module.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1], (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u1} γ a (OfNat.ofNat.{u1} γ 0 (Zero.toOfNat0.{u1} γ (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)))))) -> (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) _inst_2 (fun (x : α) => f (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u1, u3} γ α (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u1, u3} γ α (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1 _inst_4))))) (Inv.inv.{u1} γ (DivisionSemiring.toInv.{u1} γ _inst_3) a) x)) (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u1, u3} γ α (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u1, u3} γ α (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1 _inst_4))))) a c)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_inv_smul₀ Function.Antiperiodic.const_inv_smul₀ₓ'. -/
 theorem Antiperiodic.const_inv_smul₀ [AddCommMonoid α] [Neg β] [DivisionSemiring γ] [Module γ α]
     (h : Antiperiodic f c) {a : γ} (ha : a ≠ 0) : Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul₀ (inv_ne_zero ha)
 #align function.antiperiodic.const_inv_smul₀ Function.Antiperiodic.const_inv_smul₀
 
-/- warning: function.antiperiodic.const_inv_mul -> Function.Antiperiodic.const_inv_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a) x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) a c)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a) x)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) a c)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_inv_mul Function.Antiperiodic.const_inv_mulₓ'. -/
 theorem Antiperiodic.const_inv_mul [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (a⁻¹ * x)) (a * c) :=
   h.const_inv_smul₀ ha
 #align function.antiperiodic.const_inv_mul Function.Antiperiodic.const_inv_mul
 
-/- warning: function.antiperiodic.mul_const -> Function.Antiperiodic.mul_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x a)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a))))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.mul_const Function.Antiperiodic.mul_constₓ'. -/
 theorem Antiperiodic.mul_const [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a)) (c * a⁻¹) :=
   h.const_smul₀ <| (MulOpposite.op_ne_zero_iff a).mpr ha
 #align function.antiperiodic.mul_const Function.Antiperiodic.mul_const
 
-/- warning: function.antiperiodic.mul_const' -> Function.Antiperiodic.mul_const' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x a)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1)))) c a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x a)) (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivisionSemiring.toDiv.{u2} α _inst_1)) c a)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.mul_const' Function.Antiperiodic.mul_const'ₓ'. -/
 theorem Antiperiodic.mul_const' [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a)) (c / a) := by
   simpa only [div_eq_mul_inv] using h.mul_const ha
 #align function.antiperiodic.mul_const' Function.Antiperiodic.mul_const'
 
-/- warning: function.antiperiodic.mul_const_inv -> Function.Antiperiodic.mul_const_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c a)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.mul_const_inv Function.Antiperiodic.mul_const_invₓ'. -/
 theorem Antiperiodic.mul_const_inv [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a⁻¹)) (c * a) :=
   h.const_inv_smul₀ <| (MulOpposite.op_ne_zero_iff a).mpr ha
 #align function.antiperiodic.mul_const_inv Function.Antiperiodic.mul_const_inv
 
-/- warning: function.antiperiodic.div_inv -> Function.Antiperiodic.div_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1)))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivisionSemiring.toDiv.{u2} α _inst_1)) x a)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c a)))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.div_inv Function.Antiperiodic.div_invₓ'. -/
 protected theorem Antiperiodic.div_inv [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x / a)) (c * a) := by
   simpa only [div_eq_mul_inv] using h.mul_const_inv ha
 #align function.antiperiodic.div_inv Function.Antiperiodic.div_inv
 
-/- warning: function.antiperiodic.add -> Function.Antiperiodic.add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c₁) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c₂) -> (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) c₁ c₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c₁) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c₂) -> (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))))) c₁ c₂))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.add Function.Antiperiodic.addₓ'. -/
 protected theorem Antiperiodic.add [AddGroup α] [InvolutiveNeg β] (h1 : Antiperiodic f c₁)
     (h2 : Antiperiodic f c₂) : Periodic f (c₁ + c₂) := by simp_all [← add_assoc]
 #align function.antiperiodic.add Function.Antiperiodic.add
 
-/- warning: function.antiperiodic.sub -> Function.Antiperiodic.sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c₁) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c₂) -> (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c₁ c₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c₁) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c₂) -> (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) c₁ c₂))
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.sub Function.Antiperiodic.subₓ'. -/
 protected theorem Antiperiodic.sub [AddGroup α] [InvolutiveNeg β] (h1 : Antiperiodic f c₁)
     (h2 : Antiperiodic f c₂) : Periodic f (c₁ - c₂) := by
   simpa only [sub_eq_add_neg] using h1.add h2.neg
 #align function.antiperiodic.sub Function.Antiperiodic.sub
 
-/- warning: function.periodic.add_antiperiod -> Function.Periodic.add_antiperiod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c₁) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) _inst_2 f c₂) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) _inst_2 f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) c₁ c₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c₁) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) _inst_2 f c₂) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) _inst_2 f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))))) c₁ c₂))
-Case conversion may be inaccurate. Consider using '#align function.periodic.add_antiperiod Function.Periodic.add_antiperiodₓ'. -/
 theorem Periodic.add_antiperiod [AddGroup α] [Neg β] (h1 : Periodic f c₁) (h2 : Antiperiodic f c₂) :
     Antiperiodic f (c₁ + c₂) := by simp_all [← add_assoc]
 #align function.periodic.add_antiperiod Function.Periodic.add_antiperiod
 
-/- warning: function.periodic.sub_antiperiod -> Function.Periodic.sub_antiperiod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c₁) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c₂) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c₁ c₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c₁) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c₂) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) c₁ c₂))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_antiperiod Function.Periodic.sub_antiperiodₓ'. -/
 theorem Periodic.sub_antiperiod [AddGroup α] [InvolutiveNeg β] (h1 : Periodic f c₁)
     (h2 : Antiperiodic f c₂) : Antiperiodic f (c₁ - c₂) := by
   simpa only [sub_eq_add_neg] using h1.add_antiperiod h2.neg
 #align function.periodic.sub_antiperiod Function.Periodic.sub_antiperiod
 
-/- warning: function.periodic.add_antiperiod_eq -> Function.Periodic.add_antiperiod_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c₁) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) _inst_2 f c₂) -> (Eq.{succ u2} β (f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) c₁ c₂)) (Neg.neg.{u2} β _inst_2 (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c₁) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) _inst_2 f c₂) -> (Eq.{succ u1} β (f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))))) c₁ c₂)) (Neg.neg.{u1} β _inst_2 (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.add_antiperiod_eq Function.Periodic.add_antiperiod_eqₓ'. -/
 theorem Periodic.add_antiperiod_eq [AddGroup α] [Neg β] (h1 : Periodic f c₁)
     (h2 : Antiperiodic f c₂) : f (c₁ + c₂) = -f 0 :=
   (h1.add_antiperiod h2).Eq
 #align function.periodic.add_antiperiod_eq Function.Periodic.add_antiperiod_eq
 
-/- warning: function.periodic.sub_antiperiod_eq -> Function.Periodic.sub_antiperiod_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) f c₁) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c₂) -> (Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c₁ c₂)) (Neg.neg.{u2} β (InvolutiveNeg.toHasNeg.{u2} β _inst_2) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c₁ : α} {c₂ : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) f c₁) -> (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c₂) -> (Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) c₁ c₂)) (Neg.neg.{u1} β (InvolutiveNeg.toNeg.{u1} β _inst_2) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (AddGroup.toSubtractionMonoid.{u2} α _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align function.periodic.sub_antiperiod_eq Function.Periodic.sub_antiperiod_eqₓ'. -/
 theorem Periodic.sub_antiperiod_eq [AddGroup α] [InvolutiveNeg β] (h1 : Periodic f c₁)
     (h2 : Antiperiodic f c₂) : f (c₁ - c₂) = -f 0 :=
   (h1.sub_antiperiod h2).Eq
 #align function.periodic.sub_antiperiod_eq Function.Periodic.sub_antiperiod_eq
 
-/- warning: function.antiperiodic.mul -> Function.Antiperiodic.mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {g : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Mul.{u2} β] [_inst_3 : HasDistribNeg.{u2} β _inst_2], (Function.Antiperiodic.{u1, u2} α β _inst_1 (InvolutiveNeg.toHasNeg.{u2} β (HasDistribNeg.toHasInvolutiveNeg.{u2} β _inst_2 _inst_3)) f c) -> (Function.Antiperiodic.{u1, u2} α β _inst_1 (InvolutiveNeg.toHasNeg.{u2} β (HasDistribNeg.toHasInvolutiveNeg.{u2} β _inst_2 _inst_3)) g c) -> (Function.Periodic.{u1, u2} α β _inst_1 (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2))) f g) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {g : α -> β} {c : α} [_inst_1 : Add.{u2} α] [_inst_2 : Mul.{u1} β] [_inst_3 : HasDistribNeg.{u1} β _inst_2], (Function.Antiperiodic.{u2, u1} α β _inst_1 (InvolutiveNeg.toNeg.{u1} β (HasDistribNeg.toInvolutiveNeg.{u1} β _inst_2 _inst_3)) f c) -> (Function.Antiperiodic.{u2, u1} α β _inst_1 (InvolutiveNeg.toNeg.{u1} β (HasDistribNeg.toInvolutiveNeg.{u1} β _inst_2 _inst_3)) g c) -> (Function.Periodic.{u2, u1} α β _inst_1 (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2))) f g) c)
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.mul Function.Antiperiodic.mulₓ'. -/
 protected theorem Antiperiodic.mul [Add α] [Mul β] [HasDistribNeg β] (hf : Antiperiodic f c)
     (hg : Antiperiodic g c) : Periodic (f * g) c := by simp_all
 #align function.antiperiodic.mul Function.Antiperiodic.mul
 
-/- warning: function.antiperiodic.div -> Function.Antiperiodic.div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {g : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : HasDistribNeg.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))))], (Function.Antiperiodic.{u1, u2} α β _inst_1 (InvolutiveNeg.toHasNeg.{u2} β (HasDistribNeg.toHasInvolutiveNeg.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) _inst_3)) f c) -> (Function.Antiperiodic.{u1, u2} α β _inst_1 (InvolutiveNeg.toHasNeg.{u2} β (HasDistribNeg.toHasInvolutiveNeg.{u2} β (MulOneClass.toHasMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) _inst_3)) g c) -> (Function.Periodic.{u1, u2} α β _inst_1 (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) f g) c)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {g : α -> β} {c : α} [_inst_1 : Add.{u2} α] [_inst_2 : DivisionMonoid.{u1} β] [_inst_3 : HasDistribNeg.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (DivInvMonoid.toMonoid.{u1} β (DivisionMonoid.toDivInvMonoid.{u1} β _inst_2))))], (Function.Antiperiodic.{u2, u1} α β _inst_1 (InvolutiveNeg.toNeg.{u1} β (HasDistribNeg.toInvolutiveNeg.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (DivInvMonoid.toMonoid.{u1} β (DivisionMonoid.toDivInvMonoid.{u1} β _inst_2)))) _inst_3)) f c) -> (Function.Antiperiodic.{u2, u1} α β _inst_1 (InvolutiveNeg.toNeg.{u1} β (HasDistribNeg.toInvolutiveNeg.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β (DivInvMonoid.toMonoid.{u1} β (DivisionMonoid.toDivInvMonoid.{u1} β _inst_2)))) _inst_3)) g c) -> (Function.Periodic.{u2, u1} α β _inst_1 (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toDiv.{u1} β (DivisionMonoid.toDivInvMonoid.{u1} β _inst_2)))) f g) c)
-Case conversion may be inaccurate. Consider using '#align function.antiperiodic.div Function.Antiperiodic.divₓ'. -/
 protected theorem Antiperiodic.div [Add α] [DivisionMonoid β] [HasDistribNeg β]
     (hf : Antiperiodic f c) (hg : Antiperiodic g c) : Periodic (f / g) c := by
   simp_all [neg_div_neg_eq]
@@ -1099,12 +535,6 @@ protected theorem Antiperiodic.div [Add α] [DivisionMonoid β] [HasDistribNeg 
 
 end Function
 
-/- warning: int.fract_periodic -> Int.fract_periodic is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : LinearOrderedRing.{u1} α] [_inst_2 : FloorRing.{u1} α _inst_1], Function.Periodic.{u1, u1} α α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1)))) (Int.fract.{u1} α _inst_1 _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : LinearOrderedRing.{u1} α] [_inst_2 : FloorRing.{u1} α _inst_1], Function.Periodic.{u1, u1} α α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1))))))) (Int.fract.{u1} α _inst_1 _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Semiring.toOne.{u1} α (StrictOrderedSemiring.toSemiring.{u1} α (LinearOrderedSemiring.toStrictOrderedSemiring.{u1} α (LinearOrderedRing.toLinearOrderedSemiring.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align int.fract_periodic Int.fract_periodicₓ'. -/
 theorem Int.fract_periodic (α) [LinearOrderedRing α] [FloorRing α] :
     Function.Periodic Int.fract (1 : α) := by exact_mod_cast fun a => Int.fract_add_int a 1
 #align int.fract_periodic Int.fract_periodic

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -646,9 +646,7 @@ but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommGroup.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) f c) -> (forall (a : Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) (SetLike.instMembership.{u2, u2} (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) α (AddSubgroup.instSetLikeAddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))) x (AddSubgroup.zmultiples.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) c))) (x : α), Eq.{succ u1} β (f (HVAdd.hVAdd.{u2, u2, u2} (Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) (SetLike.instMembership.{u2, u2} (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) α (AddSubgroup.instSetLikeAddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))) x (AddSubgroup.zmultiples.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) c))) α α (instHVAdd.{u2, u2} (Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) (SetLike.instMembership.{u2, u2} (AddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)) α (AddSubgroup.instSetLikeAddSubgroup.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))) x (AddSubgroup.zmultiples.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) c))) α (AddSubmonoid.vadd.{u2, u2} α α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1)))) (AddAction.toVAdd.{u2, u2} α α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))) (AddMonoid.toAddAction.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1))))) (AddSubgroup.toAddSubmonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) (AddSubgroup.zmultiples.{u2} α (AddCommGroup.toAddGroup.{u2} α _inst_1) c)))) a x)) (f x))
 Case conversion may be inaccurate. Consider using '#align function.periodic.map_vadd_zmultiples Function.Periodic.map_vadd_zmultiplesₓ'. -/
 theorem Periodic.map_vadd_zmultiples [AddCommGroup α] (hf : Periodic f c)
-    (a : AddSubgroup.zmultiples c) (x : α) : f (a +ᵥ x) = f x :=
-  by
-  rcases a with ⟨_, m, rfl⟩
+    (a : AddSubgroup.zmultiples c) (x : α) : f (a +ᵥ x) = f x := by rcases a with ⟨_, m, rfl⟩;
   simp [AddSubgroup.vadd_def, add_comm _ x, hf.zsmul m x]
 #align function.periodic.map_vadd_zmultiples Function.Periodic.map_vadd_zmultiples
 
@@ -659,9 +657,7 @@ but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u2} α], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) f c) -> (forall (a : Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) α (AddSubmonoid.instSetLikeAddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1)))) x (AddSubmonoid.multiples.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) c))) (x : α), Eq.{succ u1} β (f (HVAdd.hVAdd.{u2, u2, u2} (Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) α (AddSubmonoid.instSetLikeAddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1)))) x (AddSubmonoid.multiples.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) c))) α α (instHVAdd.{u2, u2} (Subtype.{succ u2} α (fun (x : α) => Membership.mem.{u2, u2} α (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) α (AddSubmonoid.instSetLikeAddSubmonoid.{u2} α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1)))) x (AddSubmonoid.multiples.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) c))) α (AddSubmonoid.vadd.{u2, u2} α α (AddMonoid.toAddZeroClass.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1)) (AddAction.toVAdd.{u2, u2} α α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) (AddMonoid.toAddAction.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1))) (AddSubmonoid.multiples.{u2} α (AddCommMonoid.toAddMonoid.{u2} α _inst_1) c))) a x)) (f x))
 Case conversion may be inaccurate. Consider using '#align function.periodic.map_vadd_multiples Function.Periodic.map_vadd_multiplesₓ'. -/
 theorem Periodic.map_vadd_multiples [AddCommMonoid α] (hf : Periodic f c)
-    (a : AddSubmonoid.multiples c) (x : α) : f (a +ᵥ x) = f x :=
-  by
-  rcases a with ⟨_, m, rfl⟩
+    (a : AddSubmonoid.multiples c) (x : α) : f (a +ᵥ x) = f x := by rcases a with ⟨_, m, rfl⟩;
   simp [AddSubmonoid.vadd_def, add_comm _ x, hf.nsmul m x]
 #align function.periodic.map_vadd_multiples Function.Periodic.map_vadd_multiples
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -575,7 +575,7 @@ theorem Periodic.int_mul_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (n * c) =
 
 /- warning: function.periodic.exists_mem_Ico₀ -> Function.Periodic.exists_mem_Ico₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c)) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c)) => Eq.{succ u2} β (f x) (f y))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c)) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c)) => Eq.{succ u2} β (f x) (f y))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u2} α] [_inst_2 : Archimedean.{u2} α (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u2} α (LinearOrderedCancelAddCommMonoid.toLinearOrderedAddCommMonoid.{u2} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u2} α _inst_1)))], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))) f c) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c) -> (forall (x : α), Exists.{succ u2} α (fun (y : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) y (Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c)) (Eq.{succ u1} β (f x) (f y))))
 Case conversion may be inaccurate. Consider using '#align function.periodic.exists_mem_Ico₀ Function.Periodic.exists_mem_Ico₀ₓ'. -/
@@ -589,7 +589,7 @@ theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean 
 
 /- warning: function.periodic.exists_mem_Ico -> Function.Periodic.exists_mem_Ico is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) => Eq.{succ u2} β (f x) (f y))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) => Eq.{succ u2} β (f x) (f y))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u2} α] [_inst_2 : Archimedean.{u2} α (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u2} α (LinearOrderedCancelAddCommMonoid.toLinearOrderedAddCommMonoid.{u2} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u2} α _inst_1)))], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))) f c) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u2} α (fun (y : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) y (Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))) a (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))))))) a c))) (Eq.{succ u1} β (f x) (f y))))
 Case conversion may be inaccurate. Consider using '#align function.periodic.exists_mem_Ico Function.Periodic.exists_mem_Icoₓ'. -/
@@ -603,7 +603,7 @@ theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α]
 
 /- warning: function.periodic.exists_mem_Ioc -> Function.Periodic.exists_mem_Ioc is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) => Eq.{succ u2} β (f x) (f y))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u1} α (fun (y : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) => Eq.{succ u2} β (f x) (f y))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u2} α] [_inst_2 : Archimedean.{u2} α (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u2} α (LinearOrderedCancelAddCommMonoid.toLinearOrderedAddCommMonoid.{u2} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u2} α _inst_1)))], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))) f c) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c) -> (forall (x : α) (a : α), Exists.{succ u2} α (fun (y : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) y (Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))) a (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))))))) a c))) (Eq.{succ u1} β (f x) (f y))))
 Case conversion may be inaccurate. Consider using '#align function.periodic.exists_mem_Ioc Function.Periodic.exists_mem_Iocₓ'. -/
@@ -617,7 +617,7 @@ theorem Periodic.exists_mem_Ioc [LinearOrderedAddCommGroup α] [Archimedean α]
 
 /- warning: function.periodic.image_Ioc -> Function.Periodic.image_Ioc is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (a : α), Eq.{succ u2} (Set.{u2} β) (Set.image.{u1, u2} α β f (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (Set.range.{u2, succ u1} β α f))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u1} α] [_inst_2 : Archimedean.{u1} α (OrderedCancelAddCommMonoid.toOrderedAddCommMonoid.{u1} α (OrderedAddCommGroup.toOrderedCancelAddCommMonoid.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))))))) f c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))))) c) -> (forall (a : α), Eq.{succ u2} (Set.{u2} β) (Set.image.{u1, u2} α β f (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1))) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α (OrderedAddCommGroup.toAddCommGroup.{u1} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))))))) a c))) (Set.range.{u2, succ u1} β α f))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : LinearOrderedAddCommGroup.{u2} α] [_inst_2 : Archimedean.{u2} α (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u2} α (LinearOrderedCancelAddCommMonoid.toLinearOrderedAddCommMonoid.{u2} α (LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid.{u2} α _inst_1)))], (Function.Periodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))) f c) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (NegZeroClass.toZero.{u2} α (SubNegZeroMonoid.toNegZeroClass.{u2} α (SubtractionMonoid.toSubNegZeroMonoid.{u2} α (SubtractionCommMonoid.toSubtractionMonoid.{u2} α (AddCommGroup.toDivisionAddCommMonoid.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))))))))) c) -> (forall (a : α), Eq.{succ u1} (Set.{u1} β) (Set.image.{u2, u1} α β f (Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (OrderedAddCommGroup.toPartialOrder.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1))) a (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α (AddCommGroup.toAddGroup.{u2} α (OrderedAddCommGroup.toAddCommGroup.{u2} α (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} α _inst_1)))))))) a c))) (Set.range.{u1, succ u2} β α f))
 Case conversion may be inaccurate. Consider using '#align function.periodic.image_Ioc Function.Periodic.image_Iocₓ'. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

@@ -402,7 +402,7 @@ theorem Periodic.neg_nsmul [AddGroup α] (h : Periodic f c) (n : ℕ) : Periodic
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) n) c)))
+  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) n) c)))
 Case conversion may be inaccurate. Consider using '#align function.periodic.neg_nat_mul Function.Periodic.neg_nat_mulₓ'. -/
 theorem Periodic.neg_nat_mul [Ring α] (h : Periodic f c) (n : ℕ) : Periodic f (-(n * c)) :=
   (h.nat_mul n).neg
@@ -422,7 +422,7 @@ theorem Periodic.sub_nsmul_eq [AddGroup α] (h : Periodic f c) (n : ℕ) : f (x
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c))) (f x))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) x (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) n) c))) (f x))
+  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) x (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) n) c))) (f x))
 Case conversion may be inaccurate. Consider using '#align function.periodic.sub_nat_mul_eq Function.Periodic.sub_nat_mul_eqₓ'. -/
 theorem Periodic.sub_nat_mul_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (x - n * c) = f x := by
   simpa only [nsmul_eq_mul] using h.sub_nsmul_eq n
@@ -443,7 +443,7 @@ theorem Periodic.nsmul_sub_eq [AddCommGroup α] (h : Periodic f c) (n : ℕ) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))) x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) n) c) x)) (f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) n) c) x)) (f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) x)))
 Case conversion may be inaccurate. Consider using '#align function.periodic.nat_mul_sub_eq Function.Periodic.nat_mul_sub_eqₓ'. -/
 theorem Periodic.nat_mul_sub_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (n * c - x) = f (-x) := by
   simpa only [sub_eq_neg_add] using h.nat_mul n (-x)
@@ -774,7 +774,7 @@ theorem Antiperiodic.nat_odd_mul_antiperiodic [Semiring α] [InvolutiveNeg β] (
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Int), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) c)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Int), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)))
+  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Int), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.int_even_mul_periodic Function.Antiperiodic.int_even_mul_periodicₓ'. -/
 theorem Antiperiodic.int_even_mul_periodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℤ) : Periodic f (n * (2 * c)) :=
@@ -785,7 +785,7 @@ theorem Antiperiodic.int_even_mul_periodic [Ring α] [InvolutiveNeg β] (h : Ant
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Int), Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) c)) c))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Int), Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)) c))
+  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Int), Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (Semiring.toNatCast.{u2} α (Ring.toSemiring.{u2} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)) c))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.int_odd_mul_antiperiodic Function.Antiperiodic.int_odd_mul_antiperiodicₓ'. -/
 theorem Antiperiodic.int_odd_mul_antiperiodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℤ) : Antiperiodic f (n * (2 * c) + c) := fun x => by
@@ -1107,7 +1107,7 @@ end Function
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : LinearOrderedRing.{u1} α] [_inst_2 : FloorRing.{u1} α _inst_1], Function.Periodic.{u1, u1} α α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1)))) (Int.fract.{u1} α _inst_1 _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1)))))))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : LinearOrderedRing.{u1} α] [_inst_2 : FloorRing.{u1} α _inst_1], Function.Periodic.{u1, u1} α α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1))))))) (Int.fract.{u1} α _inst_1 _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1))))))
+  forall (α : Type.{u1}) [_inst_1 : LinearOrderedRing.{u1} α] [_inst_2 : FloorRing.{u1} α _inst_1], Function.Periodic.{u1, u1} α α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1))))))) (Int.fract.{u1} α _inst_1 _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Semiring.toOne.{u1} α (StrictOrderedSemiring.toSemiring.{u1} α (LinearOrderedSemiring.toStrictOrderedSemiring.{u1} α (LinearOrderedRing.toLinearOrderedSemiring.{u1} α _inst_1))))))
 Case conversion may be inaccurate. Consider using '#align int.fract_periodic Int.fract_periodicₓ'. -/
 theorem Int.fract_periodic (α) [LinearOrderedRing α] [FloorRing α] :
     Function.Periodic Int.fract (1 : α) := by exact_mod_cast fun a => Int.fract_add_int a 1

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce86f4e05e9a9b8da5e316b22c76ce76440c56a1

@@ -400,7 +400,7 @@ theorem Periodic.neg_nsmul [AddGroup α] (h : Periodic f c) (n : ℕ) : Periodic
 
 /- warning: function.periodic.neg_nat_mul -> Function.Periodic.neg_nat_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))) n) c)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) n) c)))
 Case conversion may be inaccurate. Consider using '#align function.periodic.neg_nat_mul Function.Periodic.neg_nat_mulₓ'. -/
@@ -420,7 +420,7 @@ theorem Periodic.sub_nsmul_eq [AddGroup α] (h : Periodic f c) (n : ℕ) : f (x
 
 /- warning: function.periodic.sub_nat_mul_eq -> Function.Periodic.sub_nat_mul_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))) n) c))) (f x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c))) (f x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) x (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) n) c))) (f x))
 Case conversion may be inaccurate. Consider using '#align function.periodic.sub_nat_mul_eq Function.Periodic.sub_nat_mul_eqₓ'. -/
@@ -441,7 +441,7 @@ theorem Periodic.nsmul_sub_eq [AddCommGroup α] (h : Periodic f c) (n : ℕ) :
 
 /- warning: function.periodic.nat_mul_sub_eq -> Function.Periodic.nat_mul_sub_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))) n) c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))) x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Nat), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))) x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Nat), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Nat.cast.{u2} α (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) n) c) x)) (f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) x)))
 Case conversion may be inaccurate. Consider using '#align function.periodic.nat_mul_sub_eq Function.Periodic.nat_mul_sub_eqₓ'. -/
@@ -464,7 +464,7 @@ protected theorem Periodic.zsmul [AddGroup α] (h : Periodic f c) (n : ℤ) : Pe
 
 /- warning: function.periodic.int_mul -> Function.Periodic.int_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) n) c))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Int), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c))
 Case conversion may be inaccurate. Consider using '#align function.periodic.int_mul Function.Periodic.int_mulₓ'. -/
@@ -484,7 +484,7 @@ theorem Periodic.sub_zsmul_eq [AddGroup α] (h : Periodic f c) (n : ℤ) : f (x
 
 /- warning: function.periodic.sub_int_mul_eq -> Function.Periodic.sub_int_mul_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) n) c))) (f x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) x (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c))) (f x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) x (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c))) (f x))
 Case conversion may be inaccurate. Consider using '#align function.periodic.sub_int_mul_eq Function.Periodic.sub_int_mul_eqₓ'. -/
@@ -505,7 +505,7 @@ theorem Periodic.zsmul_sub_eq [AddCommGroup α] (h : Periodic f c) (n : ℤ) :
 
 /- warning: function.periodic.int_mul_sub_eq -> Function.Periodic.int_mul_sub_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) n) c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))) x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c) x)) (f (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddGroupWithOne.toAddGroup.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))) x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} {x : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (Ring.toSub.{u2} α _inst_1)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c) x)) (f (Neg.neg.{u2} α (Ring.toNeg.{u2} α _inst_1) x)))
 Case conversion may be inaccurate. Consider using '#align function.periodic.int_mul_sub_eq Function.Periodic.int_mul_sub_eqₓ'. -/
@@ -565,7 +565,7 @@ theorem Periodic.zsmul_eq [AddGroup α] (h : Periodic f c) (n : ℤ) : f (n •
 
 /- warning: function.periodic.int_mul_eq -> Function.Periodic.int_mul_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) n) c)) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f c) -> (forall (n : Int), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c)) (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f c) -> (forall (n : Int), Eq.{succ u1} β (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c)) (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (Ring.toSemiring.{u2} α _inst_1)))))))
 Case conversion may be inaccurate. Consider using '#align function.periodic.int_mul_eq Function.Periodic.int_mul_eqₓ'. -/
@@ -772,7 +772,7 @@ theorem Antiperiodic.nat_odd_mul_antiperiodic [Semiring α] [InvolutiveNeg β] (
 
 /- warning: function.antiperiodic.int_even_mul_periodic -> Function.Antiperiodic.int_even_mul_periodic is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Int), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))))) c)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Int), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) c)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Int), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.int_even_mul_periodic Function.Antiperiodic.int_even_mul_periodicₓ'. -/
@@ -783,7 +783,7 @@ theorem Antiperiodic.int_even_mul_periodic [Ring α] [InvolutiveNeg β] (h : Ant
 
 /- warning: function.antiperiodic.int_odd_mul_antiperiodic -> Function.Antiperiodic.int_odd_mul_antiperiodic is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Int), Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))))) c)) c))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : InvolutiveNeg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f c) -> (forall (n : Int), Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (InvolutiveNeg.toHasNeg.{u2} β _inst_2) f (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))))) c)) c))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (n : Int), Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f (HAdd.hAdd.{u2, u2, u2} α α α (instHAdd.{u2} α (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (OfNat.ofNat.{u2} α 2 (instOfNat.{u2} α 2 (NonAssocRing.toNatCast.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) c)) c))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.int_odd_mul_antiperiodic Function.Antiperiodic.int_odd_mul_antiperiodicₓ'. -/
@@ -834,7 +834,7 @@ theorem Antiperiodic.neg_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f
 
 /- warning: function.antiperiodic.nat_mul_eq_of_eq_zero -> Function.Antiperiodic.nat_mul_eq_of_eq_zero is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : NegZeroClass.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (NegZeroClass.toHasNeg.{u2} β _inst_2) f c) -> (Eq.{succ u2} β (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (NegZeroClass.toHasZero.{u2} β _inst_2))))) -> (forall (n : Nat), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))) n) c)) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (NegZeroClass.toHasZero.{u2} β _inst_2)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : NegZeroClass.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (NegZeroClass.toHasNeg.{u2} β _inst_2) f c) -> (Eq.{succ u2} β (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (NegZeroClass.toHasZero.{u2} β _inst_2))))) -> (forall (n : Nat), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat α (HasLiftT.mk.{1, succ u1} Nat α (CoeTCₓ.coe.{1, succ u1} Nat α (Nat.castCoe.{u1} α (AddMonoidWithOne.toNatCast.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1))))))) n) c)) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (NegZeroClass.toHasZero.{u2} β _inst_2)))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Semiring.{u2} α] [_inst_2 : NegZeroClass.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (NegZeroClass.toNeg.{u1} β _inst_2) f c) -> (Eq.{succ u1} β (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1))))) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (NegZeroClass.toZero.{u1} β _inst_2)))) -> (forall (n : Nat), Eq.{succ u1} β (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1)))) (Nat.cast.{u2} α (Semiring.toNatCast.{u2} α _inst_1) n) c)) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (NegZeroClass.toZero.{u1} β _inst_2))))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.nat_mul_eq_of_eq_zero Function.Antiperiodic.nat_mul_eq_of_eq_zeroₓ'. -/
@@ -846,7 +846,7 @@ theorem Antiperiodic.nat_mul_eq_of_eq_zero [Ring α] [NegZeroClass β] (h : Anti
 
 /- warning: function.antiperiodic.int_mul_eq_of_eq_zero -> Function.Antiperiodic.int_mul_eq_of_eq_zero is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : SubtractionMonoid.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (SubNegMonoid.toHasNeg.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2)) f c) -> (Eq.{succ u2} β (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2)))))))) -> (forall (n : Int), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1)))))) n) c)) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2))))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Ring.{u1} α] [_inst_2 : SubtractionMonoid.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α _inst_1)) (SubNegMonoid.toHasNeg.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2)) f c) -> (Eq.{succ u2} β (f (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α _inst_1))))))))) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2)))))))) -> (forall (n : Int), Eq.{succ u2} β (f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α _inst_1))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α _inst_1)))))) n) c)) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (SubtractionMonoid.toSubNegMonoid.{u2} β _inst_2))))))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : Ring.{u2} α] [_inst_2 : SubtractionMonoid.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1))))) (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β _inst_2))) f c) -> (Eq.{succ u1} β (f (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (Ring.toSemiring.{u2} α _inst_1)))))) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β _inst_2)))))) -> (forall (n : Int), Eq.{succ u1} β (f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocRing.toMul.{u2} α (NonAssocRing.toNonUnitalNonAssocRing.{u2} α (Ring.toNonAssocRing.{u2} α _inst_1)))) (Int.cast.{u2} α (Ring.toIntCast.{u2} α _inst_1) n) c)) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β _inst_2))))))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.int_mul_eq_of_eq_zero Function.Antiperiodic.int_mul_eq_of_eq_zeroₓ'. -/
@@ -1105,7 +1105,7 @@ end Function
 
 /- warning: int.fract_periodic -> Int.fract_periodic is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : LinearOrderedRing.{u1} α] [_inst_2 : FloorRing.{u1} α _inst_1], Function.Periodic.{u1, u1} α α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1)))) (Int.fract.{u1} α _inst_1 _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (NonAssocRing.toAddGroupWithOne.{u1} α (Ring.toNonAssocRing.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1)))))))))
+  forall (α : Type.{u1}) [_inst_1 : LinearOrderedRing.{u1} α] [_inst_2 : FloorRing.{u1} α _inst_1], Function.Periodic.{u1, u1} α α (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1)))) (Int.fract.{u1} α _inst_1 _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α (Ring.toAddCommGroupWithOne.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1)))))))))
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : LinearOrderedRing.{u1} α] [_inst_2 : FloorRing.{u1} α _inst_1], Function.Periodic.{u1, u1} α α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1))))))) (Int.fract.{u1} α _inst_1 _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (NonAssocRing.toOne.{u1} α (Ring.toNonAssocRing.{u1} α (StrictOrderedRing.toRing.{u1} α (LinearOrderedRing.toStrictOrderedRing.{u1} α _inst_1))))))
 Case conversion may be inaccurate. Consider using '#align int.fract_periodic Int.fract_periodicₓ'. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/02ba8949f486ebecf93fe7460f1ed0564b5e442c

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Benjamin Davidson
 
 ! This file was ported from Lean 3 source module algebra.periodic
-! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
+! leanprover-community/mathlib commit 30413fc89f202a090a54d78e540963ed3de0056e
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -180,11 +180,11 @@ protected theorem Periodic.const_smul [AddMonoid α] [Group γ] [DistribMulActio
 
 /- warning: function.periodic.const_smul₀ -> Function.Periodic.const_smul₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : DivisionRing.{u3} γ] [_inst_3 : Module.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)) _inst_1], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)) _inst_1 _inst_3)))) a x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)) _inst_1 _inst_3)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (DivisionRing.toDivInvMonoid.{u3} γ _inst_2)) a) c))
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : DivisionSemiring.{u3} γ] [_inst_3 : Module.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1 _inst_3)))) a x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1 _inst_3)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (GroupWithZero.toDivInvMonoid.{u3} γ (DivisionSemiring.toGroupWithZero.{u3} γ _inst_2))) a) c))
 but is expected to have type
   forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u3} α] [_inst_2 : DivisionSemiring.{u2} γ] [_inst_3 : Module.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1], (Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) (fun (x : α) => f (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u3} γ α (MonoidWithZero.toZero.{u2} γ (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u2, u3} γ α (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1 _inst_3))))) a x)) (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u3} γ α (MonoidWithZero.toZero.{u2} γ (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u2, u3} γ α (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1 _inst_3))))) (Inv.inv.{u2} γ (DivisionSemiring.toInv.{u2} γ _inst_2) a) c))
 Case conversion may be inaccurate. Consider using '#align function.periodic.const_smul₀ Function.Periodic.const_smul₀ₓ'. -/
-theorem Periodic.const_smul₀ [AddCommMonoid α] [DivisionRing γ] [Module γ α] (h : Periodic f c)
+theorem Periodic.const_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module γ α] (h : Periodic f c)
     (a : γ) : Periodic (fun x => f (a • x)) (a⁻¹ • c) :=
   by
   intro x
@@ -194,11 +194,11 @@ theorem Periodic.const_smul₀ [AddCommMonoid α] [DivisionRing γ] [Module γ 
 
 /- warning: function.periodic.const_mul -> Function.Periodic.const_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) a x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1)) a) c))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) a x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a) c))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) a x)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a) c))
 Case conversion may be inaccurate. Consider using '#align function.periodic.const_mul Function.Periodic.const_mulₓ'. -/
-protected theorem Periodic.const_mul [DivisionRing α] (h : Periodic f c) (a : α) :
+protected theorem Periodic.const_mul [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a * x)) (a⁻¹ * c) :=
   h.const_smul₀ a
 #align function.periodic.const_mul Function.Periodic.const_mul
@@ -216,65 +216,65 @@ theorem Periodic.const_inv_smul [AddMonoid α] [Group γ] [DistribMulAction γ 
 
 /- warning: function.periodic.const_inv_smul₀ -> Function.Periodic.const_inv_smul₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : DivisionRing.{u3} γ] [_inst_3 : Module.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)) _inst_1], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)) _inst_1 _inst_3)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (DivisionRing.toDivInvMonoid.{u3} γ _inst_2)) a) x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_2)) _inst_1 _inst_3)))) a c))
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : DivisionSemiring.{u3} γ] [_inst_3 : Module.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1], (Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1 _inst_3)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (GroupWithZero.toDivInvMonoid.{u3} γ (DivisionSemiring.toGroupWithZero.{u3} γ _inst_2))) a) x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_2)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_2) _inst_1 _inst_3)))) a c))
 but is expected to have type
   forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u3} α] [_inst_2 : DivisionSemiring.{u2} γ] [_inst_3 : Module.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1], (Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) (fun (x : α) => f (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u3} γ α (MonoidWithZero.toZero.{u2} γ (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u2, u3} γ α (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1 _inst_3))))) (Inv.inv.{u2} γ (DivisionSemiring.toInv.{u2} γ _inst_2) a) x)) (HSMul.hSMul.{u2, u3, u3} γ α α (instHSMul.{u2, u3} γ α (SMulZeroClass.toSMul.{u2, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u2, u3} γ α (MonoidWithZero.toZero.{u2} γ (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u2, u3} γ α (Semiring.toMonoidWithZero.{u2} γ (DivisionSemiring.toSemiring.{u2} γ _inst_2)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u2, u3} γ α (DivisionSemiring.toSemiring.{u2} γ _inst_2) _inst_1 _inst_3))))) a c))
 Case conversion may be inaccurate. Consider using '#align function.periodic.const_inv_smul₀ Function.Periodic.const_inv_smul₀ₓ'. -/
-theorem Periodic.const_inv_smul₀ [AddCommMonoid α] [DivisionRing γ] [Module γ α] (h : Periodic f c)
-    (a : γ) : Periodic (fun x => f (a⁻¹ • x)) (a • c) := by
+theorem Periodic.const_inv_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module γ α]
+    (h : Periodic f c) (a : γ) : Periodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul₀ a⁻¹
 #align function.periodic.const_inv_smul₀ Function.Periodic.const_inv_smul₀
 
 /- warning: function.periodic.const_inv_mul -> Function.Periodic.const_inv_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1)) a) x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) a c))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a) x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) a c))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a) x)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) a c))
 Case conversion may be inaccurate. Consider using '#align function.periodic.const_inv_mul Function.Periodic.const_inv_mulₓ'. -/
-theorem Periodic.const_inv_mul [DivisionRing α] (h : Periodic f c) (a : α) :
+theorem Periodic.const_inv_mul [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (a⁻¹ * x)) (a * c) :=
   h.const_inv_smul₀ a
 #align function.periodic.const_inv_mul Function.Periodic.const_inv_mul
 
 /- warning: function.periodic.mul_const -> Function.Periodic.mul_const is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) c (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1)) a)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x a)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a)))
 Case conversion may be inaccurate. Consider using '#align function.periodic.mul_const Function.Periodic.mul_constₓ'. -/
-theorem Periodic.mul_const [DivisionRing α] (h : Periodic f c) (a : α) :
+theorem Periodic.mul_const [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a)) (c * a⁻¹) :=
   h.const_smul₀ <| MulOpposite.op a
 #align function.periodic.mul_const Function.Periodic.mul_const
 
 /- warning: function.periodic.mul_const' -> Function.Periodic.mul_const' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) x a)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1))) c a))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x a)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1)))) c a))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x a)) (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivisionSemiring.toDiv.{u2} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align function.periodic.mul_const' Function.Periodic.mul_const'ₓ'. -/
-theorem Periodic.mul_const' [DivisionRing α] (h : Periodic f c) (a : α) :
+theorem Periodic.mul_const' [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a)) (c / a) := by simpa only [div_eq_mul_inv] using h.mul_const a
 #align function.periodic.mul_const' Function.Periodic.mul_const'
 
 /- warning: function.periodic.mul_const_inv -> Function.Periodic.mul_const_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) x (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1)) a))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) c a))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c a))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c a))
 Case conversion may be inaccurate. Consider using '#align function.periodic.mul_const_inv Function.Periodic.mul_const_invₓ'. -/
-theorem Periodic.mul_const_inv [DivisionRing α] (h : Periodic f c) (a : α) :
+theorem Periodic.mul_const_inv [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x * a⁻¹)) (c * a) :=
   h.const_inv_smul₀ <| MulOpposite.op a
 #align function.periodic.mul_const_inv Function.Periodic.mul_const_inv
 
 /- warning: function.periodic.div_const -> Function.Periodic.div_const is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) (fun (x : α) => f (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) c a))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α], (Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) (fun (x : α) => f (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1)))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c a))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α], (Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) f c) -> (forall (a : α), Function.Periodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (fun (x : α) => f (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivisionSemiring.toDiv.{u2} α _inst_1)) x a)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c a))
 Case conversion may be inaccurate. Consider using '#align function.periodic.div_const Function.Periodic.div_constₓ'. -/
-theorem Periodic.div_const [DivisionRing α] (h : Periodic f c) (a : α) :
+theorem Periodic.div_const [DivisionSemiring α] (h : Periodic f c) (a : α) :
     Periodic (fun x => f (x / a)) (c * a) := by simpa only [div_eq_mul_inv] using h.mul_const_inv a
 #align function.periodic.div_const Function.Periodic.div_const
 
@@ -919,22 +919,22 @@ theorem Antiperiodic.const_smul [AddMonoid α] [Neg β] [Group γ] [DistribMulAc
 
 /- warning: function.antiperiodic.const_smul₀ -> Function.Antiperiodic.const_smul₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionRing.{u3} γ] [_inst_4 : Module.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)) _inst_1], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u3} γ a (OfNat.ofNat.{u3} γ 0 (OfNat.mk.{u3} γ 0 (Zero.zero.{u3} γ (MulZeroClass.toHasZero.{u3} γ (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} γ (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} γ (NonAssocRing.toNonUnitalNonAssocRing.{u3} γ (Ring.toNonAssocRing.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)))))))))) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)) _inst_1 _inst_4)))) a x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)) _inst_1 _inst_4)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (DivisionRing.toDivInvMonoid.{u3} γ _inst_3)) a) c)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionSemiring.{u3} γ] [_inst_4 : Module.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u3} γ a (OfNat.ofNat.{u3} γ 0 (OfNat.mk.{u3} γ 0 (Zero.zero.{u3} γ (MulZeroClass.toHasZero.{u3} γ (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} γ (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} γ (Semiring.toNonAssocSemiring.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))))))) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1 _inst_4)))) a x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1 _inst_4)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (GroupWithZero.toDivInvMonoid.{u3} γ (DivisionSemiring.toGroupWithZero.{u3} γ _inst_3))) a) c)))
 but is expected to have type
   forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u3} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionSemiring.{u1} γ] [_inst_4 : Module.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1], (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u1} γ a (OfNat.ofNat.{u1} γ 0 (Zero.toOfNat0.{u1} γ (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)))))) -> (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) _inst_2 (fun (x : α) => f (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u1, u3} γ α (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u1, u3} γ α (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1 _inst_4))))) a x)) (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u1, u3} γ α (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u1, u3} γ α (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1 _inst_4))))) (Inv.inv.{u1} γ (DivisionSemiring.toInv.{u1} γ _inst_3) a) c)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_smul₀ Function.Antiperiodic.const_smul₀ₓ'. -/
-theorem Antiperiodic.const_smul₀ [AddCommMonoid α] [Neg β] [DivisionRing γ] [Module γ α]
+theorem Antiperiodic.const_smul₀ [AddCommMonoid α] [Neg β] [DivisionSemiring γ] [Module γ α]
     (h : Antiperiodic f c) {a : γ} (ha : a ≠ 0) : Antiperiodic (fun x => f (a • x)) (a⁻¹ • c) :=
   fun x => by simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
 #align function.antiperiodic.const_smul₀ Function.Antiperiodic.const_smul₀
 
 /- warning: function.antiperiodic.const_mul -> Function.Antiperiodic.const_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) a x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1)) a) c)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) a x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a) c)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) a x)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a) c)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_mul Function.Antiperiodic.const_mulₓ'. -/
-theorem Antiperiodic.const_mul [DivisionRing α] [Neg β] (h : Antiperiodic f c) {a : α}
+theorem Antiperiodic.const_mul [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (a * x)) (a⁻¹ * c) :=
   h.const_smul₀ ha
 #align function.antiperiodic.const_mul Function.Antiperiodic.const_mul
@@ -952,66 +952,66 @@ theorem Antiperiodic.const_inv_smul [AddMonoid α] [Neg β] [Group γ] [DistribM
 
 /- warning: function.antiperiodic.const_inv_smul₀ -> Function.Antiperiodic.const_inv_smul₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionRing.{u3} γ] [_inst_4 : Module.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)) _inst_1], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u3} γ a (OfNat.ofNat.{u3} γ 0 (OfNat.mk.{u3} γ 0 (Zero.zero.{u3} γ (MulZeroClass.toHasZero.{u3} γ (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} γ (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u3} γ (NonAssocRing.toNonUnitalNonAssocRing.{u3} γ (Ring.toNonAssocRing.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)))))))))) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)) _inst_1 _inst_4)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (DivisionRing.toDivInvMonoid.{u3} γ _inst_3)) a) x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (Ring.toSemiring.{u3} γ (DivisionRing.toRing.{u3} γ _inst_3)) _inst_1 _inst_4)))) a c)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u1} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionSemiring.{u3} γ] [_inst_4 : Module.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1], (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u3} γ a (OfNat.ofNat.{u3} γ 0 (OfNat.mk.{u3} γ 0 (Zero.zero.{u3} γ (MulZeroClass.toHasZero.{u3} γ (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} γ (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} γ (Semiring.toNonAssocSemiring.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))))))) -> (Function.Antiperiodic.{u1, u2} α β (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1 _inst_4)))) (Inv.inv.{u3} γ (DivInvMonoid.toHasInv.{u3} γ (GroupWithZero.toDivInvMonoid.{u3} γ (DivisionSemiring.toGroupWithZero.{u3} γ _inst_3))) a) x)) (SMul.smul.{u3, u1} γ α (SMulZeroClass.toHasSmul.{u3, u1} γ α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (SMulWithZero.toSmulZeroClass.{u3, u1} γ α (MulZeroClass.toHasZero.{u3} γ (MulZeroOneClass.toMulZeroClass.{u3} γ (MonoidWithZero.toMulZeroOneClass.{u3} γ (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3))))) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (MulActionWithZero.toSMulWithZero.{u3, u1} γ α (Semiring.toMonoidWithZero.{u3} γ (DivisionSemiring.toSemiring.{u3} γ _inst_3)) (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_1))) (Module.toMulActionWithZero.{u3, u1} γ α (DivisionSemiring.toSemiring.{u3} γ _inst_3) _inst_1 _inst_4)))) a c)))
 but is expected to have type
   forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddCommMonoid.{u3} α] [_inst_2 : Neg.{u2} β] [_inst_3 : DivisionSemiring.{u1} γ] [_inst_4 : Module.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1], (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) _inst_2 f c) -> (forall {a : γ}, (Ne.{succ u1} γ a (OfNat.ofNat.{u1} γ 0 (Zero.toOfNat0.{u1} γ (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)))))) -> (Function.Antiperiodic.{u3, u2} α β (AddZeroClass.toAdd.{u3} α (AddMonoid.toAddZeroClass.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1))) _inst_2 (fun (x : α) => f (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u1, u3} γ α (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u1, u3} γ α (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1 _inst_4))))) (Inv.inv.{u1} γ (DivisionSemiring.toInv.{u1} γ _inst_3) a) x)) (HSMul.hSMul.{u1, u3, u3} γ α α (instHSMul.{u1, u3} γ α (SMulZeroClass.toSMul.{u1, u3} γ α (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (SMulWithZero.toSMulZeroClass.{u1, u3} γ α (MonoidWithZero.toZero.{u1} γ (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3))) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (MulActionWithZero.toSMulWithZero.{u1, u3} γ α (Semiring.toMonoidWithZero.{u1} γ (DivisionSemiring.toSemiring.{u1} γ _inst_3)) (AddMonoid.toZero.{u3} α (AddCommMonoid.toAddMonoid.{u3} α _inst_1)) (Module.toMulActionWithZero.{u1, u3} γ α (DivisionSemiring.toSemiring.{u1} γ _inst_3) _inst_1 _inst_4))))) a c)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_inv_smul₀ Function.Antiperiodic.const_inv_smul₀ₓ'. -/
-theorem Antiperiodic.const_inv_smul₀ [AddCommMonoid α] [Neg β] [DivisionRing γ] [Module γ α]
+theorem Antiperiodic.const_inv_smul₀ [AddCommMonoid α] [Neg β] [DivisionSemiring γ] [Module γ α]
     (h : Antiperiodic f c) {a : γ} (ha : a ≠ 0) : Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) := by
   simpa only [inv_inv] using h.const_smul₀ (inv_ne_zero ha)
 #align function.antiperiodic.const_inv_smul₀ Function.Antiperiodic.const_inv_smul₀
 
 /- warning: function.antiperiodic.const_inv_mul -> Function.Antiperiodic.const_inv_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1)) a) x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) a c)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a) x)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) a c)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a) x)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) a c)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.const_inv_mul Function.Antiperiodic.const_inv_mulₓ'. -/
-theorem Antiperiodic.const_inv_mul [DivisionRing α] [Neg β] (h : Antiperiodic f c) {a : α}
+theorem Antiperiodic.const_inv_mul [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (a⁻¹ * x)) (a * c) :=
   h.const_inv_smul₀ ha
 #align function.antiperiodic.const_inv_mul Function.Antiperiodic.const_inv_mul
 
 /- warning: function.antiperiodic.mul_const -> Function.Antiperiodic.mul_const is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) c (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1)) a))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x a)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a))))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.mul_const Function.Antiperiodic.mul_constₓ'. -/
-theorem Antiperiodic.mul_const [DivisionRing α] [Neg β] (h : Antiperiodic f c) {a : α}
+theorem Antiperiodic.mul_const [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a)) (c * a⁻¹) :=
   h.const_smul₀ <| (MulOpposite.op_ne_zero_iff a).mpr ha
 #align function.antiperiodic.mul_const Function.Antiperiodic.mul_const
 
 /- warning: function.antiperiodic.mul_const' -> Function.Antiperiodic.mul_const' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) x a)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1))) c a)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x a)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1)))) c a)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x a)) (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivisionSemiring.toDiv.{u2} α _inst_1)) c a)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.mul_const' Function.Antiperiodic.mul_const'ₓ'. -/
-theorem Antiperiodic.mul_const' [DivisionRing α] [Neg β] (h : Antiperiodic f c) {a : α}
+theorem Antiperiodic.mul_const' [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a)) (c / a) := by
   simpa only [div_eq_mul_inv] using h.mul_const ha
 #align function.antiperiodic.mul_const' Function.Antiperiodic.mul_const'
 
 /- warning: function.antiperiodic.mul_const_inv -> Function.Antiperiodic.mul_const_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) x (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1)) a))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) c a)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) x (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1))) a))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c a)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) x (Inv.inv.{u2} α (DivisionSemiring.toInv.{u2} α _inst_1) a))) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c a)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.mul_const_inv Function.Antiperiodic.mul_const_invₓ'. -/
-theorem Antiperiodic.mul_const_inv [DivisionRing α] [Neg β] (h : Antiperiodic f c) {a : α}
+theorem Antiperiodic.mul_const_inv [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x * a⁻¹)) (c * a) :=
   h.const_inv_smul₀ <| (MulOpposite.op_ne_zero_iff a).mpr ha
 #align function.antiperiodic.mul_const_inv Function.Antiperiodic.mul_const_inv
 
 /- warning: function.antiperiodic.div_inv -> Function.Antiperiodic.div_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionRing.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} α (NonAssocRing.toNonUnitalNonAssocRing.{u1} α (Ring.toNonAssocRing.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1))) _inst_2 (fun (x : α) => f (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (DivisionRing.toDivInvMonoid.{u1} α _inst_1))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (Ring.toDistrib.{u1} α (DivisionRing.toRing.{u1} α _inst_1)))) c a)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u1} α] [_inst_2 : Neg.{u2} β], (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))))))) -> (Function.Antiperiodic.{u1, u2} α β (Distrib.toHasAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1))))) _inst_2 (fun (x : α) => f (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α (DivisionSemiring.toGroupWithZero.{u1} α _inst_1)))) x a)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (DivisionSemiring.toSemiring.{u1} α _inst_1)))))) c a)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : DivisionSemiring.{u2} α] [_inst_2 : Neg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 f c) -> (forall {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1)))))) -> (Function.Antiperiodic.{u2, u1} α β (Distrib.toAdd.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) _inst_2 (fun (x : α) => f (HDiv.hDiv.{u2, u2, u2} α α α (instHDiv.{u2} α (DivisionSemiring.toDiv.{u2} α _inst_1)) x a)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (NonUnitalNonAssocSemiring.toMul.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α (DivisionSemiring.toSemiring.{u2} α _inst_1))))) c a)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.div_inv Function.Antiperiodic.div_invₓ'. -/
-protected theorem Antiperiodic.div_inv [DivisionRing α] [Neg β] (h : Antiperiodic f c) {a : α}
+protected theorem Antiperiodic.div_inv [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
     (ha : a ≠ 0) : Antiperiodic (fun x => f (x / a)) (c * a) := by
   simpa only [div_eq_mul_inv] using h.mul_const_inv ha
 #align function.antiperiodic.div_inv Function.Antiperiodic.div_inv

mathlib commit https://github.com/leanprover-community/mathlib/commit/1a313d8bba1bad05faba71a4a4e9742ab5bd9efd

@@ -900,7 +900,7 @@ theorem Antiperiodic.sub_const [AddCommGroup α] [Neg β] (h : Antiperiodic f c)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Monoid.{u3} γ] [_inst_3 : AddGroup.{u2} β] [_inst_4 : DistribMulAction.{u3, u2} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3))], (Function.Antiperiodic.{u1, u2} α β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) f c) -> (forall (a : γ), Function.Antiperiodic.{u1, u2} α β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) (SMul.smul.{u3, max u1 u2} γ (α -> β) (Function.hasSMul.{u1, u3, u2} α γ β (SMulZeroClass.toHasSmul.{u3, u2} γ β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)))) (DistribSMul.toSmulZeroClass.{u3, u2} γ β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3))) (DistribMulAction.toDistribSMul.{u3, u2} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) _inst_4)))) a f) c)
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Monoid.{u2} γ] [_inst_3 : AddGroup.{u1} β] [_inst_4 : DistribMulAction.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))], (Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.4890 : α) => β) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} γ β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (DistribSMul.toSMulZeroClass.{u2, u1} γ β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))) (DistribMulAction.toDistribSMul.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3)) _inst_4))))) a f) c)
+  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Monoid.{u2} γ] [_inst_3 : AddGroup.{u1} β] [_inst_4 : DistribMulAction.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))], (Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.4884 : α) => β) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} γ β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (DistribSMul.toSMulZeroClass.{u2, u1} γ β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))) (DistribMulAction.toDistribSMul.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3)) _inst_4))))) a f) c)
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.smul Function.Antiperiodic.smulₓ'. -/
 protected theorem Antiperiodic.smul [Add α] [Monoid γ] [AddGroup β] [DistribMulAction γ β]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (a • f) c := by simp_all

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Benjamin Davidson
 
 ! This file was ported from Lean 3 source module algebra.periodic
-! leanprover-community/mathlib commit 50832daea47b195a48b5b33b1c8b2162c48c3afc
+! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -723,7 +723,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.funext' Function.Antiperiodic.funext'ₓ'. -/
 protected theorem Antiperiodic.funext' [Add α] [InvolutiveNeg β] (h : Antiperiodic f c) :
     (fun x => -f (x + c)) = f :=
-  (eq_neg_iff_eq_neg.mp h.funext).symm
+  neg_eq_iff_eq_neg.mpr h.funext
 #align function.antiperiodic.funext' Function.Antiperiodic.funext'
 
 /- warning: function.antiperiodic.periodic -> Function.Antiperiodic.periodic is a dubious translation:
@@ -799,7 +799,7 @@ but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {c : α} [_inst_1 : AddGroup.{u2} α] [_inst_2 : InvolutiveNeg.{u1} β], (Function.Antiperiodic.{u2, u1} α β (AddZeroClass.toAdd.{u2} α (AddMonoid.toAddZeroClass.{u2} α (SubNegMonoid.toAddMonoid.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1)))) (InvolutiveNeg.toNeg.{u1} β _inst_2) f c) -> (forall (x : α), Eq.{succ u1} β (f (HSub.hSub.{u2, u2, u2} α α α (instHSub.{u2} α (SubNegMonoid.toSub.{u2} α (AddGroup.toSubNegMonoid.{u2} α _inst_1))) x c)) (Neg.neg.{u1} β (InvolutiveNeg.toNeg.{u1} β _inst_2) (f x)))
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.sub_eq Function.Antiperiodic.sub_eqₓ'. -/
 theorem Antiperiodic.sub_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) (x : α) :
-    f (x - c) = -f x := by simp only [eq_neg_iff_eq_neg.mp (h (x - c)), sub_add_cancel]
+    f (x - c) = -f x := by rw [← neg_eq_iff_eq_neg, ← h (x - c), sub_add_cancel]
 #align function.antiperiodic.sub_eq Function.Antiperiodic.sub_eq
 
 /- warning: function.antiperiodic.sub_eq' -> Function.Antiperiodic.sub_eq' is a dubious translation:

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

@@ -82,7 +82,7 @@ protected theorem Periodic.comp [Add α] (h : Periodic f c) (g : β → γ) : Pe
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Add.{u3} γ], (Function.Periodic.{u1, u2} α β _inst_1 f c) -> (forall (g : AddHom.{u3, u1} γ α _inst_2 _inst_1) (g_inv : α -> γ), (Function.RightInverse.{succ u3, succ u1} γ α g_inv (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (AddHom.{u3, u1} γ α _inst_2 _inst_1) (fun (_x : AddHom.{u3, u1} γ α _inst_2 _inst_1) => γ -> α) (AddHom.hasCoeToFun.{u3, u1} γ α _inst_2 _inst_1) g)) -> (Function.Periodic.{u3, u2} γ β _inst_2 (Function.comp.{succ u3, succ u1, succ u2} γ α β f (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (AddHom.{u3, u1} γ α _inst_2 _inst_1) (fun (_x : AddHom.{u3, u1} γ α _inst_2 _inst_1) => γ -> α) (AddHom.hasCoeToFun.{u3, u1} γ α _inst_2 _inst_1) g)) (g_inv c)))
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Add.{u2} γ], (Function.Periodic.{u3, u1} α β _inst_1 f c) -> (forall (g : AddHom.{u2, u3} γ α _inst_2 _inst_1) (g_inv : α -> γ), (Function.RightInverse.{succ u2, succ u3} γ α g_inv (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : γ) => α) _x) (AddHomClass.toFunLike.{max u3 u2, u2, u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ α _inst_2 _inst_1 (AddHom.addHomClass.{u2, u3} γ α _inst_2 _inst_1)) g)) -> (Function.Periodic.{u2, u1} γ β _inst_2 (Function.comp.{succ u2, succ u3, succ u1} γ α β f (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : γ) => α) _x) (AddHomClass.toFunLike.{max u3 u2, u2, u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ α _inst_2 _inst_1 (AddHom.addHomClass.{u2, u3} γ α _inst_2 _inst_1)) g)) (g_inv c)))
+  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Add.{u2} γ], (Function.Periodic.{u3, u1} α β _inst_1 f c) -> (forall (g : AddHom.{u2, u3} γ α _inst_2 _inst_1) (g_inv : α -> γ), (Function.RightInverse.{succ u2, succ u3} γ α g_inv (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : γ) => α) _x) (AddHomClass.toFunLike.{max u3 u2, u2, u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ α _inst_2 _inst_1 (AddHom.addHomClass.{u2, u3} γ α _inst_2 _inst_1)) g)) -> (Function.Periodic.{u2, u1} γ β _inst_2 (Function.comp.{succ u2, succ u3, succ u1} γ α β f (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : γ) => α) _x) (AddHomClass.toFunLike.{max u3 u2, u2, u3} (AddHom.{u2, u3} γ α _inst_2 _inst_1) γ α _inst_2 _inst_1 (AddHom.addHomClass.{u2, u3} γ α _inst_2 _inst_1)) g)) (g_inv c)))
 Case conversion may be inaccurate. Consider using '#align function.periodic.comp_add_hom Function.Periodic.comp_addHomₓ'. -/
 theorem Periodic.comp_addHom [Add α] [Add γ] (h : Periodic f c) (g : AddHom γ α) (g_inv : α → γ)
     (hg : RightInverse g_inv g) : Periodic (f ∘ g) (g_inv c) := fun x => by
@@ -159,7 +159,7 @@ theorem Finset.periodic_prod [Add α] [CommMonoid β] {ι : Type _} {f : ι →
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : SMul.{u3, u2} γ β], (Function.Periodic.{u1, u2} α β _inst_1 f c) -> (forall (a : γ), Function.Periodic.{u1, u2} α β _inst_1 (SMul.smul.{u3, max u1 u2} γ (α -> β) (Function.hasSMul.{u1, u3, u2} α γ β _inst_2) a f) c)
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : SMul.{u2, u1} γ β], (Function.Periodic.{u3, u1} α β _inst_1 f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β _inst_1 (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.562 : α) => β) (fun (i : α) => _inst_2))) a f) c)
+  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : SMul.{u2, u1} γ β], (Function.Periodic.{u3, u1} α β _inst_1 f c) -> (forall (a : γ), Function.Periodic.{u3, u1} α β _inst_1 (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.565 : α) => β) (fun (i : α) => _inst_2))) a f) c)
 Case conversion may be inaccurate. Consider using '#align function.periodic.smul Function.Periodic.smulₓ'. -/
 @[to_additive]
 protected theorem Periodic.smul [Add α] [SMul γ β] (h : Periodic f c) (a : γ) :
@@ -900,7 +900,7 @@ theorem Antiperiodic.sub_const [AddCommGroup α] [Neg β] (h : Antiperiodic f c)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Monoid.{u3} γ] [_inst_3 : AddGroup.{u2} β] [_inst_4 : DistribMulAction.{u3, u2} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3))], (Function.Antiperiodic.{u1, u2} α β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) f c) -> (forall (a : γ), Function.Antiperiodic.{u1, u2} α β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) (SMul.smul.{u3, max u1 u2} γ (α -> β) (Function.hasSMul.{u1, u3, u2} α γ β (SMulZeroClass.toHasSmul.{u3, u2} γ β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)))) (DistribSMul.toSmulZeroClass.{u3, u2} γ β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3))) (DistribMulAction.toDistribSMul.{u3, u2} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) _inst_4)))) a f) c)
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Monoid.{u2} γ] [_inst_3 : AddGroup.{u1} β] [_inst_4 : DistribMulAction.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))], (Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.4887 : α) => β) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} γ β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (DistribSMul.toSMulZeroClass.{u2, u1} γ β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))) (DistribMulAction.toDistribSMul.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3)) _inst_4))))) a f) c)
+  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Monoid.{u2} γ] [_inst_3 : AddGroup.{u1} β] [_inst_4 : DistribMulAction.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))], (Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.4890 : α) => β) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} γ β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (DistribSMul.toSMulZeroClass.{u2, u1} γ β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))) (DistribMulAction.toDistribSMul.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3)) _inst_4))))) a f) c)
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.smul Function.Antiperiodic.smulₓ'. -/
 protected theorem Antiperiodic.smul [Add α] [Monoid γ] [AddGroup β] [DistribMulAction γ β]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (a • f) c := by simp_all

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

@@ -840,7 +840,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.nat_mul_eq_of_eq_zero Function.Antiperiodic.nat_mul_eq_of_eq_zeroₓ'. -/
 theorem Antiperiodic.nat_mul_eq_of_eq_zero [Ring α] [NegZeroClass β] (h : Antiperiodic f c)
     (hi : f 0 = 0) : ∀ n : ℕ, f (n * c) = 0
-  | 0 => by rwa [Nat.cast_zero, zero_mul]
+  | 0 => by rwa [Nat.cast_zero, MulZeroClass.zero_mul]
   | n + 1 => by simp [add_mul, antiperiodic.nat_mul_eq_of_eq_zero n, h _]
 #align function.antiperiodic.nat_mul_eq_of_eq_zero Function.Antiperiodic.nat_mul_eq_of_eq_zero
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/3b267e70a936eebb21ab546f49a8df34dd300b25

@@ -900,7 +900,7 @@ theorem Antiperiodic.sub_const [AddCommGroup α] [Neg β] (h : Antiperiodic f c)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {c : α} [_inst_1 : Add.{u1} α] [_inst_2 : Monoid.{u3} γ] [_inst_3 : AddGroup.{u2} β] [_inst_4 : DistribMulAction.{u3, u2} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3))], (Function.Antiperiodic.{u1, u2} α β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) f c) -> (forall (a : γ), Function.Antiperiodic.{u1, u2} α β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) (SMul.smul.{u3, max u1 u2} γ (α -> β) (Function.hasSMul.{u1, u3, u2} α γ β (SMulZeroClass.toHasSmul.{u3, u2} γ β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)))) (DistribSMul.toSmulZeroClass.{u3, u2} γ β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3))) (DistribMulAction.toDistribSMul.{u3, u2} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_3)) _inst_4)))) a f) c)
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Monoid.{u2} γ] [_inst_3 : AddGroup.{u1} β] [_inst_4 : DistribMulAction.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))], (Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.4682 : α) => β) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} γ β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (DistribSMul.toSMulZeroClass.{u2, u1} γ β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))) (DistribMulAction.toDistribSMul.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3)) _inst_4))))) a f) c)
+  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {c : α} [_inst_1 : Add.{u3} α] [_inst_2 : Monoid.{u2} γ] [_inst_3 : AddGroup.{u1} β] [_inst_4 : DistribMulAction.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))], (Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) f c) -> (forall (a : γ), Function.Antiperiodic.{u3, u1} α β _inst_1 (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (HSMul.hSMul.{u2, max u3 u1, max u3 u1} γ (α -> β) (α -> β) (instHSMul.{u2, max u3 u1} γ (α -> β) (Pi.instSMul.{u3, u1, u2} α γ (fun (a._@.Mathlib.Algebra.Periodic._hyg.4887 : α) => β) (fun (i : α) => SMulZeroClass.toSMul.{u2, u1} γ β (NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (AddGroup.toSubtractionMonoid.{u1} β _inst_3)))) (DistribSMul.toSMulZeroClass.{u2, u1} γ β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3))) (DistribMulAction.toDistribSMul.{u2, u1} γ β _inst_2 (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β _inst_3)) _inst_4))))) a f) c)
 Case conversion may be inaccurate. Consider using '#align function.antiperiodic.smul Function.Antiperiodic.smulₓ'. -/
 protected theorem Antiperiodic.smul [Add α] [Monoid γ] [AddGroup β] [DistribMulAction γ β]
     (h : Antiperiodic f c) (a : γ) : Antiperiodic (a • f) c := by simp_all

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

A mix of various changes; generated with a script and manually tweaked.

@@ -42,7 +42,7 @@ namespace Function
 /-! ### Periodicity -/
 
 
-/-- A function `f` is said to be `periodic` with period `c` if for all `x`, `f (x + c) = f x`. -/
+/-- A function `f` is said to be `Periodic` with period `c` if for all `x`, `f (x + c) = f x`. -/
 @[simp]
 def Periodic [Add α] (f : α → β) (c : α) : Prop :=
   ∀ x : α, f (x + c) = f x
@@ -277,7 +277,7 @@ theorem Periodic.int_mul_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (n * c) =
   (h.int_mul n).eq
 #align function.periodic.int_mul_eq Function.Periodic.int_mul_eq
 
-/-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
+/-- If a function `f` is `Periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ico 0 c` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
     (hc : 0 < c) (x) : ∃ y ∈ Ico 0 c, f x = f y :=
@@ -285,7 +285,7 @@ theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean 
   ⟨x - n • c, H, (h.sub_zsmul_eq n).symm⟩
 #align function.periodic.exists_mem_Ico₀ Function.Periodic.exists_mem_Ico₀
 
-/-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
+/-- If a function `f` is `Periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ico a (a + c)` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
     (hc : 0 < c) (x a) : ∃ y ∈ Ico a (a + c), f x = f y :=
@@ -293,7 +293,7 @@ theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α]
   ⟨x + n • c, H, (h.zsmul n x).symm⟩
 #align function.periodic.exists_mem_Ico Function.Periodic.exists_mem_Ico
 
-/-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
+/-- If a function `f` is `Periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ioc a (a + c)` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
     (hc : 0 < c) (x a) : ∃ y ∈ Ioc a (a + c), f x = f y :=
@@ -374,12 +374,12 @@ protected theorem Antiperiodic.funext' [Add α] [InvolutiveNeg β] (h : Antiperi
   neg_eq_iff_eq_neg.mpr h.funext
 #align function.antiperiodic.funext' Function.Antiperiodic.funext'
 
-/-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
+/-- If a function is `antiperiodic` with antiperiod `c`, then it is also `Periodic` with period
 `2 • c`. -/
 protected theorem Antiperiodic.periodic [AddMonoid α] [InvolutiveNeg β]
     (h : Antiperiodic f c) : Periodic f (2 • c) := by simp [two_nsmul, ← add_assoc, h _]
 
-/-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
+/-- If a function is `antiperiodic` with antiperiod `c`, then it is also `Periodic` with period
   `2 * c`. -/
 protected theorem Antiperiodic.periodic_two_mul [Semiring α] [InvolutiveNeg β]
     (h : Antiperiodic f c) : Periodic f (2 * c) := nsmul_eq_mul 2 c ▸ h.periodic

This renames

• Int.cast_ofNat to Int.cast_natCast
• Int.int_cast_ofNat to Int.cast_ofNat

I think the history here is that this lemma was previously about Int.ofNat, before we globally fixed the simp-normal form to be Nat.cast.

Since the Int.cast_ofNat name is repurposed, it can't be deprecated. Int.int_cast_ofNat is such a wonky name that it was probably never used.

@@ -451,7 +451,7 @@ theorem Antiperiodic.nat_mul_eq_of_eq_zero [Semiring α] [NegZeroClass β] (h :
 
 theorem Antiperiodic.int_mul_eq_of_eq_zero [Ring α] [SubtractionMonoid β] (h : Antiperiodic f c)
     (hi : f 0 = 0) : ∀ n : ℤ, f (n * c) = 0
-  | (n : ℕ) => by rw [Int.cast_ofNat, h.nat_mul_eq_of_eq_zero hi n]
+  | (n : ℕ) => by rw [Int.cast_natCast, h.nat_mul_eq_of_eq_zero hi n]
   | .negSucc n => by rw [Int.cast_negSucc, neg_mul, ← mul_neg, h.neg.nat_mul_eq_of_eq_zero hi]
 #align function.antiperiodic.int_mul_eq_of_eq_zero Function.Antiperiodic.int_mul_eq_of_eq_zero
 

Add @[simp] theorem negOnePow_two_mul_add_one to Algebra.GroupPower.NegOnePow, which states that (2 * n + 1).negOnePow = -1.

Add theorems to Algebra.Periodic about the value of f (x + n • c), f (x - n • c), and f (n • c - x), where we have Antiperiodic f c. All these theorems have variants for either n : ℕ or n : ℤ, and they also have variants using * instead of • if the domain and codomain of f are rings.

For all real numbers x and all integers n. deduce the following. All these theorems are in Analysis.SpecialFunctions.Trigonometric.Basic, they are not @[simp], and they have a variation (using the notation (-1) ^ n instead of n.negOnePow) for natural number n.

• sin (x + n * π) = n.negOnePow * sin x
• sin (x - n * π) = n.negOnePow * sin x
• sin (n * π - x) = -(n.negOnePow * sin x)
• cos (x + n * π) = n.negOnePow * cos x
• cos (x - n * π) = n.negOnePow * cos x
• cos (n * π - x) = n.negOnePow * cos x

@@ -8,6 +8,7 @@ import Mathlib.Algebra.Order.Archimedean
 import Mathlib.GroupTheory.Coset
 import Mathlib.GroupTheory.Subgroup.ZPowers
 import Mathlib.GroupTheory.Submonoid.Membership
+import Mathlib.Algebra.GroupPower.NegOnePow
 
 #align_import algebra.periodic from "leanprover-community/mathlib"@"30413fc89f202a090a54d78e540963ed3de0056e"
 
@@ -24,7 +25,7 @@ In this file we define and then prove facts about periodic and antiperiodic func
 * `Function.Antiperiodic`: A function `f` is *antiperiodic* if `∀ x, f (x + c) = -f x`.
   `f` is referred to as antiperiodic with antiperiod `c` or `c`-antiperiodic.
 
-Note that any `c`-antiperiodic function will necessarily also be `2*c`-periodic.
+Note that any `c`-antiperiodic function will necessarily also be `2 • c`-periodic.
 
 ## Tags
 
@@ -373,34 +374,56 @@ protected theorem Antiperiodic.funext' [Add α] [InvolutiveNeg β] (h : Antiperi
   neg_eq_iff_eq_neg.mpr h.funext
 #align function.antiperiodic.funext' Function.Antiperiodic.funext'
 
+/-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
+`2 • c`. -/
+protected theorem Antiperiodic.periodic [AddMonoid α] [InvolutiveNeg β]
+    (h : Antiperiodic f c) : Periodic f (2 • c) := by simp [two_nsmul, ← add_assoc, h _]
+
 /-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
   `2 * c`. -/
-protected theorem Antiperiodic.periodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c) :
-    Periodic f (2 * c) := by simp [two_mul, ← add_assoc, h _]
-#align function.antiperiodic.periodic Function.Antiperiodic.periodic
+protected theorem Antiperiodic.periodic_two_mul [Semiring α] [InvolutiveNeg β]
+    (h : Antiperiodic f c) : Periodic f (2 * c) := nsmul_eq_mul 2 c ▸ h.periodic
+#align function.antiperiodic.periodic Function.Antiperiodic.periodic_two_mul
 
 protected theorem Antiperiodic.eq [AddZeroClass α] [Neg β] (h : Antiperiodic f c) : f c = -f 0 := by
   simpa only [zero_add] using h 0
 #align function.antiperiodic.eq Function.Antiperiodic.eq
 
+theorem Antiperiodic.even_nsmul_periodic [AddMonoid α] [InvolutiveNeg β] (h : Antiperiodic f c)
+    (n : ℕ) : Periodic f ((2 * n) • c) := mul_nsmul c 2 n ▸ h.periodic.nsmul n
+
 theorem Antiperiodic.nat_even_mul_periodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℕ) : Periodic f (n * (2 * c)) :=
-  h.periodic.nat_mul n
+  h.periodic_two_mul.nat_mul n
 #align function.antiperiodic.nat_even_mul_periodic Function.Antiperiodic.nat_even_mul_periodic
 
+theorem Antiperiodic.odd_nsmul_antiperiodic [AddMonoid α] [InvolutiveNeg β] (h : Antiperiodic f c)
+    (n : ℕ) : Antiperiodic f ((2 * n + 1) • c) := fun x => by
+  rw [add_nsmul, one_nsmul, ← add_assoc, h, h.even_nsmul_periodic]
+
 theorem Antiperiodic.nat_odd_mul_antiperiodic [Semiring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℕ) : Antiperiodic f (n * (2 * c) + c) := fun x => by
-  rw [← add_assoc, h, h.periodic.nat_mul]
+  rw [← add_assoc, h, h.nat_even_mul_periodic]
 #align function.antiperiodic.nat_odd_mul_antiperiodic Function.Antiperiodic.nat_odd_mul_antiperiodic
 
+theorem Antiperiodic.even_zsmul_periodic [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c)
+    (n : ℤ) : Periodic f ((2 * n) • c) := by
+  rw [mul_comm, mul_zsmul, two_zsmul, ← two_nsmul]
+  exact h.periodic.zsmul n
+
 theorem Antiperiodic.int_even_mul_periodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℤ) : Periodic f (n * (2 * c)) :=
-  h.periodic.int_mul n
+  h.periodic_two_mul.int_mul n
 #align function.antiperiodic.int_even_mul_periodic Function.Antiperiodic.int_even_mul_periodic
 
+theorem Antiperiodic.odd_zsmul_antiperiodic [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c)
+    (n : ℤ) : Antiperiodic f ((2 * n + 1) • c) := by
+  intro x
+  rw [add_zsmul, one_zsmul, ← add_assoc, h, h.even_zsmul_periodic]
+
 theorem Antiperiodic.int_odd_mul_antiperiodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
     (n : ℤ) : Antiperiodic f (n * (2 * c) + c) := fun x => by
-  rw [← add_assoc, h, h.periodic.int_mul]
+  rw [← add_assoc, h, h.int_even_mul_periodic]
 #align function.antiperiodic.int_odd_mul_antiperiodic Function.Antiperiodic.int_odd_mul_antiperiodic
 
 theorem Antiperiodic.sub_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) (x : α) :
@@ -432,6 +455,62 @@ theorem Antiperiodic.int_mul_eq_of_eq_zero [Ring α] [SubtractionMonoid β] (h :
   | .negSucc n => by rw [Int.cast_negSucc, neg_mul, ← mul_neg, h.neg.nat_mul_eq_of_eq_zero hi]
 #align function.antiperiodic.int_mul_eq_of_eq_zero Function.Antiperiodic.int_mul_eq_of_eq_zero
 
+theorem Antiperiodic.add_zsmul_eq [AddGroup α] [AddGroup β] (h : Antiperiodic f c) (n : ℤ) :
+    f (x + n • c) = (n.negOnePow : ℤ) • f x := by
+  rcases Int.even_or_odd' n with ⟨k, rfl | rfl⟩
+  · rw [h.even_zsmul_periodic, Int.negOnePow_two_mul, Units.val_one, one_zsmul]
+  · rw [h.odd_zsmul_antiperiodic, Int.negOnePow_two_mul_add_one, Units.val_neg,
+      Units.val_one, neg_zsmul, one_zsmul]
+
+theorem Antiperiodic.sub_zsmul_eq [AddGroup α] [AddGroup β] (h : Antiperiodic f c) (n : ℤ) :
+    f (x - n • c) = (n.negOnePow : ℤ) • f x := by
+  simpa only [sub_eq_add_neg, neg_zsmul, Int.negOnePow_neg] using h.add_zsmul_eq (-n)
+
+theorem Antiperiodic.zsmul_sub_eq [AddCommGroup α] [AddGroup β] (h : Antiperiodic f c) (n : ℤ) :
+    f (n • c - x) = (n.negOnePow : ℤ) • f (-x) := by
+  rw [sub_eq_add_neg, add_comm]
+  exact h.add_zsmul_eq n
+
+theorem Antiperiodic.add_int_mul_eq [Ring α] [Ring β] (h : Antiperiodic f c) (n : ℤ) :
+    f (x + n * c) = (n.negOnePow : ℤ) * f x := by simpa only [zsmul_eq_mul] using h.add_zsmul_eq n
+
+theorem Antiperiodic.sub_int_mul_eq [Ring α] [Ring β] (h : Antiperiodic f c) (n : ℤ) :
+    f (x - n * c) = (n.negOnePow : ℤ) * f x := by simpa only [zsmul_eq_mul] using h.sub_zsmul_eq n
+
+theorem Antiperiodic.int_mul_sub_eq [Ring α] [Ring β] (h : Antiperiodic f c) (n : ℤ) :
+    f (n * c - x) = (n.negOnePow : ℤ) * f (-x) := by
+  simpa only [zsmul_eq_mul] using h.zsmul_sub_eq n
+
+theorem Antiperiodic.add_nsmul_eq [AddMonoid α] [AddGroup β] (h : Antiperiodic f c) (n : ℕ) :
+    f (x + n • c) = (-1) ^ n • f x := by
+  rcases Nat.even_or_odd' n with ⟨k, rfl | rfl⟩
+  · rw [h.even_nsmul_periodic, pow_mul, (by norm_num : (-1) ^ 2 = 1), one_pow, one_zsmul]
+  · rw [h.odd_nsmul_antiperiodic, pow_add, pow_mul, (by norm_num : (-1) ^ 2 = 1), one_pow,
+      pow_one, one_mul, neg_zsmul, one_zsmul]
+
+theorem Antiperiodic.sub_nsmul_eq [AddGroup α] [AddGroup β] (h : Antiperiodic f c) (n : ℕ) :
+    f (x - n • c) = (-1) ^ n • f x := by
+  simpa only [Int.reduceNeg, natCast_zsmul] using h.sub_zsmul_eq n
+
+theorem Antiperiodic.nsmul_sub_eq [AddCommGroup α] [AddGroup β] (h : Antiperiodic f c) (n : ℕ) :
+    f (n • c - x) = (-1) ^ n • f (-x) := by
+  simpa only [Int.reduceNeg, natCast_zsmul] using h.zsmul_sub_eq n
+
+theorem Antiperiodic.add_nat_mul_eq [Semiring α] [Ring β] (h : Antiperiodic f c) (n : ℕ) :
+    f (x + n * c) = (-1) ^ n * f x := by
+  simpa only [nsmul_eq_mul, zsmul_eq_mul, Int.cast_pow, Int.cast_neg,
+    Int.cast_one] using h.add_nsmul_eq n
+
+theorem Antiperiodic.sub_nat_mul_eq [Ring α] [Ring β] (h : Antiperiodic f c) (n : ℕ) :
+    f (x - n * c) = (-1) ^ n * f x := by
+  simpa only [nsmul_eq_mul, zsmul_eq_mul, Int.cast_pow, Int.cast_neg,
+    Int.cast_one] using h.sub_nsmul_eq n
+
+theorem Antiperiodic.nat_mul_sub_eq [Ring α] [Ring β] (h : Antiperiodic f c) (n : ℕ) :
+    f (n * c - x) = (-1) ^ n * f (-x) := by
+  simpa only [nsmul_eq_mul, zsmul_eq_mul, Int.cast_pow, Int.cast_neg,
+    Int.cast_one] using h.nsmul_sub_eq n
+
 theorem Antiperiodic.const_add [AddSemigroup α] [Neg β] (h : Antiperiodic f c) (a : α) :
     Antiperiodic (fun x => f (a + x)) c := fun x => by simpa [add_assoc] using h (a + x)
 #align function.antiperiodic.const_add Function.Antiperiodic.const_add

... and add a deprecated alias for the old name. This is mostly just me discovering the power of F2

@@ -227,7 +227,7 @@ theorem Periodic.nat_mul_sub_eq [Ring α] (h : Periodic f c) (n : ℕ) : f (n *
 
 protected theorem Periodic.zsmul [AddGroup α] (h : Periodic f c) (n : ℤ) : Periodic f (n • c) := by
   cases' n with n n
-  · simpa only [Int.ofNat_eq_coe, coe_nat_zsmul] using h.nsmul n
+  · simpa only [Int.ofNat_eq_coe, natCast_zsmul] using h.nsmul n
   · simpa only [negSucc_zsmul] using (h.nsmul (n + 1)).neg
 #align function.periodic.zsmul Function.Periodic.zsmul
 

Integral curves are either injective, constant, or periodic and non-constant.

When we have notions of submanifolds, this'll be useful for showing that the image of an integral curve is a submanifold.

• depends on: #8886

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Michael Rothgang <rothgami@math.hu-berlin.de>

@@ -349,6 +349,11 @@ theorem Periodic.lift_coe [AddGroup α] (h : Periodic f c) (a : α) :
   rfl
 #align function.periodic.lift_coe Function.Periodic.lift_coe
 
+/-- A periodic function `f : R → X` on a semiring (or, more generally, `AddZeroClass`)
+of non-zero period is not injective. -/
+lemma Periodic.not_injective {R X : Type*} [AddZeroClass R] {f : R → X} {c : R}
+    (hf : Periodic f c) (hc : c ≠ 0) : ¬ Injective f := fun h ↦ hc <| h hf.eq
+
 /-! ### Antiperiodicity -/
 
 /-- A function `f` is said to be `antiperiodic` with antiperiod `c` if for all `x`,

Started from Algebra/Periodic.lean with some snowball sampling. Seems to be somewhat disjoint from the tree shaking in #9347.

@@ -3,11 +3,8 @@ Copyright (c) 2021 Benjamin Davidson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Benjamin Davidson
 -/
-import Mathlib.Algebra.BigOperators.Basic
 import Mathlib.Algebra.Field.Opposite
-import Mathlib.Algebra.Module.Basic
 import Mathlib.Algebra.Order.Archimedean
-import Mathlib.Data.Int.Parity
 import Mathlib.GroupTheory.Coset
 import Mathlib.GroupTheory.Subgroup.ZPowers
 import Mathlib.GroupTheory.Submonoid.Membership

We still have the exact_mod_cast tactic, used in a few places, which somehow (?) works a little bit harder to prevent the expected type influencing the elaboration of the term. I would like to get to the bottom of this, and it will be easier once the only usages of exact_mod_cast are the ones that don't work using the term elaborator by itself.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -542,6 +542,5 @@ theorem Antiperiodic.div [Add α] [DivisionMonoid β] [HasDistribNeg β] (hf : A
 end Function
 
 theorem Int.fract_periodic (α) [LinearOrderedRing α] [FloorRing α] :
-    Function.Periodic Int.fract (1 : α) := fun a => by
-  exact_mod_cast Int.fract_add_int a 1
+    Function.Periodic Int.fract (1 : α) := fun a => mod_cast Int.fract_add_int a 1
 #align int.fract_periodic Int.fract_periodic

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -413,8 +413,9 @@ protected theorem Antiperiodic.neg [AddGroup α] [InvolutiveNeg β] (h : Antiper
     Antiperiodic f (-c) := by simpa only [sub_eq_add_neg, Antiperiodic] using h.sub_eq
 #align function.antiperiodic.neg Function.Antiperiodic.neg
 
-theorem Antiperiodic.neg_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) : f (-c) = -f 0 :=
-  by simpa only [zero_add] using h.neg 0
+theorem Antiperiodic.neg_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) :
+    f (-c) = -f 0 := by
+  simpa only [zero_add] using h.neg 0
 #align function.antiperiodic.neg_eq Function.Antiperiodic.neg_eq
 
 theorem Antiperiodic.nat_mul_eq_of_eq_zero [Semiring α] [NegZeroClass β] (h : Antiperiodic f c)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -35,7 +35,7 @@ period, periodic, periodicity, antiperiodic
 -/
 
 
-variable {α β γ : Type _} {f g : α → β} {c c₁ c₂ x : α}
+variable {α β γ : Type*} {f g : α → β} {c c₁ c₂ x : α}
 
 open Set BigOperators
 
@@ -93,7 +93,7 @@ theorem _root_.Multiset.periodic_prod [Add α] [CommMonoid β] (s : Multiset (α
 #align multiset.periodic_sum Multiset.periodic_sum
 
 @[to_additive]
-theorem _root_.Finset.periodic_prod [Add α] [CommMonoid β] {ι : Type _} {f : ι → α → β}
+theorem _root_.Finset.periodic_prod [Add α] [CommMonoid β] {ι : Type*} {f : ι → α → β}
     (s : Finset ι) (hs : ∀ i ∈ s, Periodic (f i) c) : Periodic (∏ i in s, f i) c :=
   s.prod_to_list f ▸ (s.toList.map f).periodic_prod (by simpa [-Periodic] )
 #align finset.periodic_prod Finset.periodic_prod

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Benjamin Davidson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Benjamin Davidson
-
-! This file was ported from Lean 3 source module algebra.periodic
-! leanprover-community/mathlib commit 30413fc89f202a090a54d78e540963ed3de0056e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.BigOperators.Basic
 import Mathlib.Algebra.Field.Opposite
@@ -17,6 +12,8 @@ import Mathlib.GroupTheory.Coset
 import Mathlib.GroupTheory.Subgroup.ZPowers
 import Mathlib.GroupTheory.Submonoid.Membership
 
+#align_import algebra.periodic from "leanprover-community/mathlib"@"30413fc89f202a090a54d78e540963ed3de0056e"
+
 /-!
 # Periodicity
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -194,7 +194,7 @@ theorem Periodic.const_sub [AddCommGroup α] (h : Periodic f c) (a : α) :
 #align function.periodic.const_sub Function.Periodic.const_sub
 
 theorem Periodic.sub_const [AddCommGroup α] (h : Periodic f c) (a : α) :
-    Periodic (fun x => f (x - a)) c :=  by
+    Periodic (fun x => f (x - a)) c := by
   simpa only [sub_eq_add_neg] using h.add_const (-a)
 #align function.periodic.sub_const Function.Periodic.sub_const
 

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -308,7 +308,7 @@ theorem Periodic.exists_mem_Ioc [LinearOrderedAddCommGroup α] [Archimedean α]
 
 theorem Periodic.image_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
     (hc : 0 < c) (a : α) : f '' Ioc a (a + c) = range f :=
-  (image_subset_range _ _).antisymm <|range_subset_iff.2 fun x =>
+  (image_subset_range _ _).antisymm <| range_subset_iff.2 fun x =>
     let ⟨y, hy, hyx⟩ := h.exists_mem_Ioc hc x a
     ⟨y, hy, hyx.symm⟩
 #align function.periodic.image_Ioc Function.Periodic.image_Ioc

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -14,7 +14,7 @@ import Mathlib.Algebra.Module.Basic
 import Mathlib.Algebra.Order.Archimedean
 import Mathlib.Data.Int.Parity
 import Mathlib.GroupTheory.Coset
-import Mathlib.GroupTheory.Subgroup.Zpowers
+import Mathlib.GroupTheory.Subgroup.ZPowers
 import Mathlib.GroupTheory.Submonoid.Membership
 
 /-!

This is a forward-port of https://github.com/leanprover-community/mathlib/pull/18597

Some notes:

• This doesn't forward-port the changes to algebra/star/self_adjoint; I plan to re-port this file from scratch after https://github.com/leanprover-community/mathlib/pull/18565 lands. For now, I just add some hacks to keep it compiling.
• It seems that the changes to algebra/periodic were made during porting, see https://github.com/leanprover-community/mathlib4/pull/1963/files/2a6b385f555c37f3eb5e4dd9c113e0a1b5f6b958..[578a6252](https://github.com/leanprover-community/mathlib/commit/578a6252973bcdbd1a6ce4fc0fe2791295cf80e4)#r1140354814. So there is nothing to do other than update the SHA.

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Benjamin Davidson
 
 ! This file was ported from Lean 3 source module algebra.periodic
-! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
+! leanprover-community/mathlib commit 30413fc89f202a090a54d78e540963ed3de0056e
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

This forward ports the changes introduced by leanprover-community/mathlib#17483

No change is needed to Mathlib.Data.EReal as the proofs have been golfed in a different way.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Benjamin Davidson
 
 ! This file was ported from Lean 3 source module algebra.periodic
-! leanprover-community/mathlib commit 4c19a16e4b705bf135cf9a80ac18fcc99c438514
+! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -371,7 +371,7 @@ protected theorem Antiperiodic.funext [Add α] [Neg β] (h : Antiperiodic f c) :
 
 protected theorem Antiperiodic.funext' [Add α] [InvolutiveNeg β] (h : Antiperiodic f c) :
     (fun x => -f (x + c)) = f :=
-  (eq_neg_iff_eq_neg.mp h.funext).symm
+  neg_eq_iff_eq_neg.mpr h.funext
 #align function.antiperiodic.funext' Function.Antiperiodic.funext'
 
 /-- If a function is `antiperiodic` with antiperiod `c`, then it is also `periodic` with period
@@ -405,7 +405,7 @@ theorem Antiperiodic.int_odd_mul_antiperiodic [Ring α] [InvolutiveNeg β] (h :
 #align function.antiperiodic.int_odd_mul_antiperiodic Function.Antiperiodic.int_odd_mul_antiperiodic
 
 theorem Antiperiodic.sub_eq [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) (x : α) :
-    f (x - c) = -f x := by simp only [eq_neg_iff_eq_neg.mp (h (x - c)), sub_add_cancel]
+    f (x - c) = -f x := by simp only [← neg_eq_iff_eq_neg, ← h (x - c), sub_add_cancel]
 #align function.antiperiodic.sub_eq Function.Antiperiodic.sub_eq
 
 theorem Antiperiodic.sub_eq' [AddCommGroup α] [Neg β] (h : Antiperiodic f c) :

I generalized some lemmas from additive subgroups of the real numbers to additive subgroups of an archimedean additive group.

@@ -40,7 +40,7 @@ period, periodic, periodicity, antiperiodic
 
 variable {α β γ : Type _} {f g : α → β} {c c₁ c₂ x : α}
 
-open BigOperators
+open Set BigOperators
 
 namespace Function
 
@@ -285,7 +285,7 @@ theorem Periodic.int_mul_eq [Ring α] (h : Periodic f c) (n : ℤ) : f (n * c) =
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ico 0 c` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
-    (hc : 0 < c) (x) : ∃ y ∈ Set.Ico 0 c, f x = f y :=
+    (hc : 0 < c) (x) : ∃ y ∈ Ico 0 c, f x = f y :=
   let ⟨n, H, _⟩ := existsUnique_zsmul_near_of_pos' hc x
   ⟨x - n • c, H, (h.sub_zsmul_eq n).symm⟩
 #align function.periodic.exists_mem_Ico₀ Function.Periodic.exists_mem_Ico₀
@@ -293,7 +293,7 @@ theorem Periodic.exists_mem_Ico₀ [LinearOrderedAddCommGroup α] [Archimedean 
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ico a (a + c)` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
-    (hc : 0 < c) (x a) : ∃ y ∈ Set.Ico a (a + c), f x = f y :=
+    (hc : 0 < c) (x a) : ∃ y ∈ Ico a (a + c), f x = f y :=
   let ⟨n, H, _⟩ := existsUnique_add_zsmul_mem_Ico hc x a
   ⟨x + n • c, H, (h.zsmul n x).symm⟩
 #align function.periodic.exists_mem_Ico Function.Periodic.exists_mem_Ico
@@ -301,19 +301,30 @@ theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α]
 /-- If a function `f` is `periodic` with positive period `c`, then for all `x` there exists some
   `y ∈ Ioc a (a + c)` such that `f x = f y`. -/
 theorem Periodic.exists_mem_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
-    (hc : 0 < c) (x a) : ∃ y ∈ Set.Ioc a (a + c), f x = f y :=
+    (hc : 0 < c) (x a) : ∃ y ∈ Ioc a (a + c), f x = f y :=
   let ⟨n, H, _⟩ := existsUnique_add_zsmul_mem_Ioc hc x a
   ⟨x + n • c, H, (h.zsmul n x).symm⟩
 #align function.periodic.exists_mem_Ioc Function.Periodic.exists_mem_Ioc
 
 theorem Periodic.image_Ioc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
-    (hc : 0 < c) (a : α) : f '' Set.Ioc a (a + c) = Set.range f :=
-  (Set.image_subset_range _ _).antisymm <|
-    Set.range_subset_iff.2 fun x =>
-      let ⟨y, hy, hyx⟩ := h.exists_mem_Ioc hc x a
-      ⟨y, hy, hyx.symm⟩
+    (hc : 0 < c) (a : α) : f '' Ioc a (a + c) = range f :=
+  (image_subset_range _ _).antisymm <|range_subset_iff.2 fun x =>
+    let ⟨y, hy, hyx⟩ := h.exists_mem_Ioc hc x a
+    ⟨y, hy, hyx.symm⟩
 #align function.periodic.image_Ioc Function.Periodic.image_Ioc
 
+theorem Periodic.image_Icc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
+    (hc : 0 < c) (a : α) : f '' Icc a (a + c) = range f :=
+  (image_subset_range _ _).antisymm <| h.image_Ioc hc a ▸ image_subset _ Ioc_subset_Icc_self
+
+theorem Periodic.image_uIcc [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
+    (hc : c ≠ 0) (a : α) : f '' uIcc a (a + c) = range f := by
+  cases hc.lt_or_lt with
+  | inl hc =>
+    rw [uIcc_of_ge (add_le_of_nonpos_right hc.le), ← h.neg.image_Icc (neg_pos.2 hc) (a + c),
+      add_neg_cancel_right]
+  | inr hc => rw [uIcc_of_le (le_add_of_nonneg_right hc.le), h.image_Icc hc]
+
 theorem periodic_with_period_zero [AddZeroClass α] (f : α → β) : Periodic f 0 := fun x => by
   rw [add_zero]
 #align function.periodic_with_period_zero Function.periodic_with_period_zero