order.iterate | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

2258b40d

(last sync)

ac5a7cec

refactor(data/set/intervals/monotone): split (#17893)

Also generalize&golf monotone_on.exists_monotone_extension and rename order.monotone to order.monotone.basic.

Lean 4 version is leanprover-community/mathlib4#947

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
 import logic.function.iterate
-import order.monotone
+import order.monotone.basic
 
 /-!
 # Inequalities on iterates

d6aae1bc

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

448144f7

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
-import Mathbin.Logic.Function.Iterate
-import Mathbin.Order.Monotone.Basic
+import Logic.Function.Iterate
+import Order.Monotone.Basic
 
 #align_import order.iterate from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module order.iterate
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Logic.Function.Iterate
 import Mathbin.Order.Monotone.Basic
 
+#align_import order.iterate from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Inequalities on iterates

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -107,15 +107,19 @@ variable {g : β → β} {h : β → α}
 
 open Function
 
+#print Monotone.le_iterate_comp_of_le /-
 theorem le_iterate_comp_of_le (hf : Monotone f) (H : h ∘ g ≤ f ∘ h) (n : ℕ) :
     h ∘ g^[n] ≤ f^[n] ∘ h := fun x => by
   refine' hf.seq_le_seq n _ (fun k hk => _) fun k hk => _ <;> simp [iterate_succ', H _]
 #align monotone.le_iterate_comp_of_le Monotone.le_iterate_comp_of_le
+-/
 
+#print Monotone.iterate_comp_le_of_le /-
 theorem iterate_comp_le_of_le (hf : Monotone f) (H : f ∘ h ≤ h ∘ g) (n : ℕ) :
     f^[n] ∘ h ≤ h ∘ g^[n] :=
   hf.dual.le_iterate_comp_of_le H n
 #align monotone.iterate_comp_le_of_le Monotone.iterate_comp_le_of_le
+-/
 
 #print Monotone.iterate_le_of_le /-
 /-- If `f ≤ g` and `f` is monotone, then `f^[n] ≤ g^[n]`. -/

448144f7

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -81,7 +81,7 @@ theorem seq_pos_lt_seq_of_le_of_lt (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h
 #print Monotone.seq_lt_seq_of_lt_of_le /-
 theorem seq_lt_seq_of_lt_of_le (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n := by
-  cases n; exacts[h₀, hf.seq_pos_lt_seq_of_lt_of_le n.zero_lt_succ h₀.le hx hy]
+  cases n; exacts [h₀, hf.seq_pos_lt_seq_of_lt_of_le n.zero_lt_succ h₀.le hx hy]
 #align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_le
 -/

448144f7

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -46,6 +46,7 @@ lemmas in this section formalize this fact for different inequalities made stric
 -/
 
 
+#print Monotone.seq_le_seq /-
 theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k < n, x (k + 1) ≤ f (x k))
     (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n ≤ y n :=
   by
@@ -55,7 +56,9 @@ theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k
     exact fun k hk => hx _ (hk.trans n.lt_succ_self)
     exact fun k hk => hy _ (hk.trans n.lt_succ_self)
 #align monotone.seq_le_seq Monotone.seq_le_seq
+-/
 
+#print Monotone.seq_pos_lt_seq_of_lt_of_le /-
 theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n :=
   by
@@ -66,21 +69,28 @@ theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h
   refine' (ihn n.zero_lt_succ (fun k hk => hx _ _) fun k hk => hy _ _).le <;>
     exact hk.trans n.succ.lt_succ_self
 #align monotone.seq_pos_lt_seq_of_lt_of_le Monotone.seq_pos_lt_seq_of_lt_of_le
+-/
 
+#print Monotone.seq_pos_lt_seq_of_le_of_lt /-
 theorem seq_pos_lt_seq_of_le_of_lt (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
     (hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n :=
   hf.dual.seq_pos_lt_seq_of_lt_of_le hn h₀ hy hx
 #align monotone.seq_pos_lt_seq_of_le_of_lt Monotone.seq_pos_lt_seq_of_le_of_lt
+-/
 
+#print Monotone.seq_lt_seq_of_lt_of_le /-
 theorem seq_lt_seq_of_lt_of_le (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n := by
   cases n; exacts[h₀, hf.seq_pos_lt_seq_of_lt_of_le n.zero_lt_succ h₀.le hx hy]
 #align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_le
+-/
 
+#print Monotone.seq_lt_seq_of_le_of_lt /-
 theorem seq_lt_seq_of_le_of_lt (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
     (hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n :=
   hf.dual.seq_lt_seq_of_lt_of_le n h₀ hy hx
 #align monotone.seq_lt_seq_of_le_of_lt Monotone.seq_lt_seq_of_le_of_lt
+-/
 
 /-!
 ### Iterates of two functions
@@ -107,15 +117,19 @@ theorem iterate_comp_le_of_le (hf : Monotone f) (H : f ∘ h ≤ h ∘ g) (n : 
   hf.dual.le_iterate_comp_of_le H n
 #align monotone.iterate_comp_le_of_le Monotone.iterate_comp_le_of_le
 
+#print Monotone.iterate_le_of_le /-
 /-- If `f ≤ g` and `f` is monotone, then `f^[n] ≤ g^[n]`. -/
 theorem iterate_le_of_le {g : α → α} (hf : Monotone f) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] :=
   hf.iterate_comp_le_of_le h n
 #align monotone.iterate_le_of_le Monotone.iterate_le_of_le
+-/
 
+#print Monotone.le_iterate_of_le /-
 /-- If `f ≤ g` and `g` is monotone, then `f^[n] ≤ g^[n]`. -/
 theorem le_iterate_of_le {g : α → α} (hg : Monotone g) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] :=
   hg.dual.iterate_le_of_le h n
 #align monotone.le_iterate_of_le Monotone.le_iterate_of_le
+-/
 
 end Monotone
 
@@ -133,23 +147,31 @@ section Preorder
 
 variable [Preorder α] {f : α → α}
 
+#print Function.id_le_iterate_of_id_le /-
 /-- If $x ≤ f x$ for all $x$ (we write this as `id ≤ f`), then the same is true for any iterate
 `f^[n]` of `f`. -/
 theorem id_le_iterate_of_id_le (h : id ≤ f) (n : ℕ) : id ≤ f^[n] := by
   simpa only [iterate_id] using monotone_id.iterate_le_of_le h n
 #align function.id_le_iterate_of_id_le Function.id_le_iterate_of_id_le
+-/
 
+#print Function.iterate_le_id_of_le_id /-
 theorem iterate_le_id_of_le_id (h : f ≤ id) (n : ℕ) : f^[n] ≤ id :=
   @id_le_iterate_of_id_le αᵒᵈ _ f h n
 #align function.iterate_le_id_of_le_id Function.iterate_le_id_of_le_id
+-/
 
+#print Function.monotone_iterate_of_id_le /-
 theorem monotone_iterate_of_id_le (h : id ≤ f) : Monotone fun m => f^[m] :=
   monotone_nat_of_le_succ fun n x => by rw [iterate_succ_apply']; exact h _
 #align function.monotone_iterate_of_id_le Function.monotone_iterate_of_id_le
+-/
 
+#print Function.antitone_iterate_of_le_id /-
 theorem antitone_iterate_of_le_id (h : f ≤ id) : Antitone fun m => f^[m] := fun m n hmn =>
   @monotone_iterate_of_id_le αᵒᵈ _ f h m n hmn
 #align function.antitone_iterate_of_le_id Function.antitone_iterate_of_le_id
+-/
 
 end Preorder
 
@@ -168,27 +190,34 @@ section Preorder
 
 variable [Preorder α] {f g : α → α}
 
+#print Function.Commute.iterate_le_of_map_le /-
 theorem iterate_le_of_map_le (h : Commute f g) (hf : Monotone f) (hg : Monotone g) {x}
     (hx : f x ≤ g x) (n : ℕ) : (f^[n]) x ≤ (g^[n]) x := by
   refine' hf.seq_le_seq n _ (fun k hk => _) fun k hk => _ <;>
     simp [iterate_succ' f, h.iterate_right _ _, hg.iterate _ hx]
 #align function.commute.iterate_le_of_map_le Function.Commute.iterate_le_of_map_le
+-/
 
+#print Function.Commute.iterate_pos_lt_of_map_lt /-
 theorem iterate_pos_lt_of_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x}
     (hx : f x < g x) {n} (hn : 0 < n) : (f^[n]) x < (g^[n]) x := by
   refine' hf.seq_pos_lt_seq_of_le_of_lt hn _ (fun k hk => _) fun k hk => _ <;>
     simp [iterate_succ' f, h.iterate_right _ _, hg.iterate _ hx]
 #align function.commute.iterate_pos_lt_of_map_lt Function.Commute.iterate_pos_lt_of_map_lt
+-/
 
+#print Function.Commute.iterate_pos_lt_of_map_lt' /-
 theorem iterate_pos_lt_of_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x}
     (hx : f x < g x) {n} (hn : 0 < n) : (f^[n]) x < (g^[n]) x :=
   @iterate_pos_lt_of_map_lt αᵒᵈ _ g f h.symm hg.dual hf.dual x hx n hn
 #align function.commute.iterate_pos_lt_of_map_lt' Function.Commute.iterate_pos_lt_of_map_lt'
+-/
 
 end Preorder
 
 variable [LinearOrder α] {f g : α → α}
 
+#print Function.Commute.iterate_pos_lt_iff_map_lt /-
 theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
     (hn : 0 < n) : (f^[n]) x < (g^[n]) x ↔ f x < g x :=
   by
@@ -197,21 +226,28 @@ theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : Stri
   · simp only [*, h.iterate_eq_of_map_eq, lt_irrefl]
   · simp only [lt_asymm H, lt_asymm (h.symm.iterate_pos_lt_of_map_lt' hg hf H hn)]
 #align function.commute.iterate_pos_lt_iff_map_lt Function.Commute.iterate_pos_lt_iff_map_lt
+-/
 
+#print Function.Commute.iterate_pos_lt_iff_map_lt' /-
 theorem iterate_pos_lt_iff_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
     (hn : 0 < n) : (f^[n]) x < (g^[n]) x ↔ f x < g x :=
   @iterate_pos_lt_iff_map_lt αᵒᵈ _ _ _ h.symm hg.dual hf.dual x n hn
 #align function.commute.iterate_pos_lt_iff_map_lt' Function.Commute.iterate_pos_lt_iff_map_lt'
+-/
 
+#print Function.Commute.iterate_pos_le_iff_map_le /-
 theorem iterate_pos_le_iff_map_le (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
     (hn : 0 < n) : (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x := by
   simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt' hg hf hn)
 #align function.commute.iterate_pos_le_iff_map_le Function.Commute.iterate_pos_le_iff_map_le
+-/
 
+#print Function.Commute.iterate_pos_le_iff_map_le' /-
 theorem iterate_pos_le_iff_map_le' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
     (hn : 0 < n) : (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x := by
   simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt hg hf hn)
 #align function.commute.iterate_pos_le_iff_map_le' Function.Commute.iterate_pos_le_iff_map_le'
+-/
 
 #print Function.Commute.iterate_pos_eq_iff_map_eq /-
 theorem iterate_pos_eq_iff_map_eq (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
@@ -229,17 +265,21 @@ namespace Monotone
 
 variable [Preorder α] {f : α → α} {x : α}
 
+#print Monotone.monotone_iterate_of_le_map /-
 /-- If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
 a monotone sequence. -/
 theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone fun n => (f^[n]) x :=
   monotone_nat_of_le_succ fun n => by rw [iterate_succ_apply]; exact hf.iterate n hx
 #align monotone.monotone_iterate_of_le_map Monotone.monotone_iterate_of_le_map
+-/
 
+#print Monotone.antitone_iterate_of_map_le /-
 /-- If `f` is a monotone map and `f x ≤ x` at some point `x`, then the iterates `f^[n] x` form
 a antitone sequence. -/
 theorem antitone_iterate_of_map_le (hf : Monotone f) (hx : f x ≤ x) : Antitone fun n => (f^[n]) x :=
   hf.dual.monotone_iterate_of_le_map hx
 #align monotone.antitone_iterate_of_map_le Monotone.antitone_iterate_of_map_le
+-/
 
 end Monotone
 
@@ -247,19 +287,23 @@ namespace StrictMono
 
 variable [Preorder α] {f : α → α} {x : α}
 
+#print StrictMono.strictMono_iterate_of_lt_map /-
 /-- If `f` is a strictly monotone map and `x < f x` at some point `x`, then the iterates `f^[n] x`
 form a strictly monotone sequence. -/
 theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
     StrictMono fun n => (f^[n]) x :=
   strictMono_nat_of_lt_succ fun n => by rw [iterate_succ_apply]; exact hf.iterate n hx
 #align strict_mono.strict_mono_iterate_of_lt_map StrictMono.strictMono_iterate_of_lt_map
+-/
 
+#print StrictMono.strictAnti_iterate_of_map_lt /-
 /-- If `f` is a strictly antitone map and `f x < x` at some point `x`, then the iterates `f^[n] x`
 form a strictly antitone sequence. -/
 theorem strictAnti_iterate_of_map_lt (hf : StrictMono f) (hx : f x < x) :
     StrictAnti fun n => (f^[n]) x :=
   hf.dual.strictMono_iterate_of_lt_map hx
 #align strict_mono.strict_anti_iterate_of_map_lt StrictMono.strictAnti_iterate_of_map_lt
+-/
 
 end StrictMono

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -46,12 +46,6 @@ lemmas in this section formalize this fact for different inequalities made stric
 -/
 
 
-/- warning: monotone.seq_le_seq -> Monotone.seq_le_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x n) (y n)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x n) (y n)))
-Case conversion may be inaccurate. Consider using '#align monotone.seq_le_seq Monotone.seq_le_seqₓ'. -/
 theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k < n, x (k + 1) ≤ f (x k))
     (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n ≤ y n :=
   by
@@ -62,12 +56,6 @@ theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k
     exact fun k hk => hy _ (hk.trans n.lt_succ_self)
 #align monotone.seq_le_seq Monotone.seq_le_seq
 
-/- warning: monotone.seq_pos_lt_seq_of_lt_of_le -> Monotone.seq_pos_lt_seq_of_lt_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x n) (y n)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
-Case conversion may be inaccurate. Consider using '#align monotone.seq_pos_lt_seq_of_lt_of_le Monotone.seq_pos_lt_seq_of_lt_of_leₓ'. -/
 theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n :=
   by
@@ -79,34 +67,16 @@ theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h
     exact hk.trans n.succ.lt_succ_self
 #align monotone.seq_pos_lt_seq_of_lt_of_le Monotone.seq_pos_lt_seq_of_lt_of_le
 
-/- warning: monotone.seq_pos_lt_seq_of_le_of_lt -> Monotone.seq_pos_lt_seq_of_le_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x n) (y n)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
-Case conversion may be inaccurate. Consider using '#align monotone.seq_pos_lt_seq_of_le_of_lt Monotone.seq_pos_lt_seq_of_le_of_ltₓ'. -/
 theorem seq_pos_lt_seq_of_le_of_lt (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
     (hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n :=
   hf.dual.seq_pos_lt_seq_of_lt_of_le hn h₀ hy hx
 #align monotone.seq_pos_lt_seq_of_le_of_lt Monotone.seq_pos_lt_seq_of_le_of_lt
 
-/- warning: monotone.seq_lt_seq_of_lt_of_le -> Monotone.seq_lt_seq_of_lt_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x n) (y n)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
-Case conversion may be inaccurate. Consider using '#align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_leₓ'. -/
 theorem seq_lt_seq_of_lt_of_le (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n := by
   cases n; exacts[h₀, hf.seq_pos_lt_seq_of_lt_of_le n.zero_lt_succ h₀.le hx hy]
 #align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_le
 
-/- warning: monotone.seq_lt_seq_of_le_of_lt -> Monotone.seq_lt_seq_of_le_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x n) (y n)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
-Case conversion may be inaccurate. Consider using '#align monotone.seq_lt_seq_of_le_of_lt Monotone.seq_lt_seq_of_le_of_ltₓ'. -/
 theorem seq_lt_seq_of_le_of_lt (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
     (hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n :=
   hf.dual.seq_lt_seq_of_lt_of_le n h₀ hy hx
@@ -127,45 +97,21 @@ variable {g : β → β} {h : β → α}
 
 open Function
 
-/- warning: monotone.le_iterate_comp_of_le -> Monotone.le_iterate_comp_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u2, succ u2, succ u1} β β α h g) (Function.comp.{succ u2, succ u1, succ u1} β α α f h)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u2, succ u2, succ u1} β β α h (Nat.iterate.{succ u2} β g n)) (Function.comp.{succ u2, succ u1, succ u1} β α α (Nat.iterate.{succ u1} α f n) h))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u2, u2} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u1, u2} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u2} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} β β α h g) (Function.comp.{succ u1, succ u2, succ u2} β α α f h)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u1, u2} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u2} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} β β α h (Nat.iterate.{succ u1} β g n)) (Function.comp.{succ u1, succ u2, succ u2} β α α (Nat.iterate.{succ u2} α f n) h))
-Case conversion may be inaccurate. Consider using '#align monotone.le_iterate_comp_of_le Monotone.le_iterate_comp_of_leₓ'. -/
 theorem le_iterate_comp_of_le (hf : Monotone f) (H : h ∘ g ≤ f ∘ h) (n : ℕ) :
     h ∘ g^[n] ≤ f^[n] ∘ h := fun x => by
   refine' hf.seq_le_seq n _ (fun k hk => _) fun k hk => _ <;> simp [iterate_succ', H _]
 #align monotone.le_iterate_comp_of_le Monotone.le_iterate_comp_of_le
 
-/- warning: monotone.iterate_comp_le_of_le -> Monotone.iterate_comp_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u2, succ u1, succ u1} β α α f h) (Function.comp.{succ u2, succ u2, succ u1} β β α h g)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u2, succ u1, succ u1} β α α (Nat.iterate.{succ u1} α f n) h) (Function.comp.{succ u2, succ u2, succ u1} β β α h (Nat.iterate.{succ u2} β g n)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u2, u2} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u1, u2} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u2} α _inst_1)) (Function.comp.{succ u1, succ u2, succ u2} β α α f h) (Function.comp.{succ u1, succ u1, succ u2} β β α h g)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u1, u2} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u2} α _inst_1)) (Function.comp.{succ u1, succ u2, succ u2} β α α (Nat.iterate.{succ u2} α f n) h) (Function.comp.{succ u1, succ u1, succ u2} β β α h (Nat.iterate.{succ u1} β g n)))
-Case conversion may be inaccurate. Consider using '#align monotone.iterate_comp_le_of_le Monotone.iterate_comp_le_of_leₓ'. -/
 theorem iterate_comp_le_of_le (hf : Monotone f) (H : f ∘ h ≤ h ∘ g) (n : ℕ) :
     f^[n] ∘ h ≤ h ∘ g^[n] :=
   hf.dual.le_iterate_comp_of_le H n
 #align monotone.iterate_comp_le_of_le Monotone.iterate_comp_le_of_le
 
-/- warning: monotone.iterate_le_of_le -> Monotone.iterate_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) f g) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (Nat.iterate.{succ u1} α g n))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) f g) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (Nat.iterate.{succ u1} α g n))
-Case conversion may be inaccurate. Consider using '#align monotone.iterate_le_of_le Monotone.iterate_le_of_leₓ'. -/
 /-- If `f ≤ g` and `f` is monotone, then `f^[n] ≤ g^[n]`. -/
 theorem iterate_le_of_le {g : α → α} (hf : Monotone f) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] :=
   hf.iterate_comp_le_of_le h n
 #align monotone.iterate_le_of_le Monotone.iterate_le_of_le
 
-/- warning: monotone.le_iterate_of_le -> Monotone.le_iterate_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) f g) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (Nat.iterate.{succ u1} α g n))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) f g) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (Nat.iterate.{succ u1} α g n))
-Case conversion may be inaccurate. Consider using '#align monotone.le_iterate_of_le Monotone.le_iterate_of_leₓ'. -/
 /-- If `f ≤ g` and `g` is monotone, then `f^[n] ≤ g^[n]`. -/
 theorem le_iterate_of_le {g : α → α} (hg : Monotone g) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] :=
   hg.dual.iterate_le_of_le h n
@@ -187,44 +133,20 @@ section Preorder
 
 variable [Preorder α] {f : α → α}
 
-/- warning: function.id_le_iterate_of_id_le -> Function.id_le_iterate_of_id_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (id.{succ u1} α) f) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (id.{succ u1} α) (Nat.iterate.{succ u1} α f n))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (id.{succ u1} α) f) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (id.{succ u1} α) (Nat.iterate.{succ u1} α f n))
-Case conversion may be inaccurate. Consider using '#align function.id_le_iterate_of_id_le Function.id_le_iterate_of_id_leₓ'. -/
 /-- If $x ≤ f x$ for all $x$ (we write this as `id ≤ f`), then the same is true for any iterate
 `f^[n]` of `f`. -/
 theorem id_le_iterate_of_id_le (h : id ≤ f) (n : ℕ) : id ≤ f^[n] := by
   simpa only [iterate_id] using monotone_id.iterate_le_of_le h n
 #align function.id_le_iterate_of_id_le Function.id_le_iterate_of_id_le
 
-/- warning: function.iterate_le_id_of_le_id -> Function.iterate_le_id_of_le_id is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) f (id.{succ u1} α)) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (id.{succ u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) f (id.{succ u1} α)) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (id.{succ u1} α))
-Case conversion may be inaccurate. Consider using '#align function.iterate_le_id_of_le_id Function.iterate_le_id_of_le_idₓ'. -/
 theorem iterate_le_id_of_le_id (h : f ≤ id) (n : ℕ) : f^[n] ≤ id :=
   @id_le_iterate_of_id_le αᵒᵈ _ f h n
 #align function.iterate_le_id_of_le_id Function.iterate_le_id_of_le_id
 
-/- warning: function.monotone_iterate_of_id_le -> Function.monotone_iterate_of_id_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (id.{succ u1} α) f) -> (Monotone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (id.{succ u1} α) f) -> (Monotone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
-Case conversion may be inaccurate. Consider using '#align function.monotone_iterate_of_id_le Function.monotone_iterate_of_id_leₓ'. -/
 theorem monotone_iterate_of_id_le (h : id ≤ f) : Monotone fun m => f^[m] :=
   monotone_nat_of_le_succ fun n x => by rw [iterate_succ_apply']; exact h _
 #align function.monotone_iterate_of_id_le Function.monotone_iterate_of_id_le
 
-/- warning: function.antitone_iterate_of_le_id -> Function.antitone_iterate_of_le_id is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) f (id.{succ u1} α)) -> (Antitone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) f (id.{succ u1} α)) -> (Antitone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
-Case conversion may be inaccurate. Consider using '#align function.antitone_iterate_of_le_id Function.antitone_iterate_of_le_idₓ'. -/
 theorem antitone_iterate_of_le_id (h : f ≤ id) : Antitone fun m => f^[m] := fun m n hmn =>
   @monotone_iterate_of_id_le αᵒᵈ _ f h m n hmn
 #align function.antitone_iterate_of_le_id Function.antitone_iterate_of_le_id
@@ -246,36 +168,18 @@ section Preorder
 
 variable [Preorder α] {f g : α → α}
 
-/- warning: function.commute.iterate_le_of_map_le -> Function.Commute.iterate_le_of_map_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f x) (g x)) -> (forall (n : Nat), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f x) (g x)) -> (forall (n : Nat), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)))
-Case conversion may be inaccurate. Consider using '#align function.commute.iterate_le_of_map_le Function.Commute.iterate_le_of_map_leₓ'. -/
 theorem iterate_le_of_map_le (h : Commute f g) (hf : Monotone f) (hg : Monotone g) {x}
     (hx : f x ≤ g x) (n : ℕ) : (f^[n]) x ≤ (g^[n]) x := by
   refine' hf.seq_le_seq n _ (fun k hk => _) fun k hk => _ <;>
     simp [iterate_succ' f, h.iterate_right _ _, hg.iterate _ hx]
 #align function.commute.iterate_le_of_map_le Function.Commute.iterate_le_of_map_le
 
-/- warning: function.commute.iterate_pos_lt_of_map_lt -> Function.Commute.iterate_pos_lt_of_map_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (StrictMono.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f x) (g x)) -> (forall {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (StrictMono.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f x) (g x)) -> (forall {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x))))
-Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_lt_of_map_lt Function.Commute.iterate_pos_lt_of_map_ltₓ'. -/
 theorem iterate_pos_lt_of_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x}
     (hx : f x < g x) {n} (hn : 0 < n) : (f^[n]) x < (g^[n]) x := by
   refine' hf.seq_pos_lt_seq_of_le_of_lt hn _ (fun k hk => _) fun k hk => _ <;>
     simp [iterate_succ' f, h.iterate_right _ _, hg.iterate _ hx]
 #align function.commute.iterate_pos_lt_of_map_lt Function.Commute.iterate_pos_lt_of_map_lt
 
-/- warning: function.commute.iterate_pos_lt_of_map_lt' -> Function.Commute.iterate_pos_lt_of_map_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f x) (g x)) -> (forall {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f x) (g x)) -> (forall {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x))))
-Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_lt_of_map_lt' Function.Commute.iterate_pos_lt_of_map_lt'ₓ'. -/
 theorem iterate_pos_lt_of_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x}
     (hx : f x < g x) {n} (hn : 0 < n) : (f^[n]) x < (g^[n]) x :=
   @iterate_pos_lt_of_map_lt αᵒᵈ _ g f h.symm hg.dual hf.dual x hx n hn
@@ -285,12 +189,6 @@ end Preorder
 
 variable [LinearOrder α] {f g : α → α}
 
-/- warning: function.commute.iterate_pos_lt_iff_map_lt -> Function.Commute.iterate_pos_lt_iff_map_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
-Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_lt_iff_map_lt Function.Commute.iterate_pos_lt_iff_map_ltₓ'. -/
 theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
     (hn : 0 < n) : (f^[n]) x < (g^[n]) x ↔ f x < g x :=
   by
@@ -300,34 +198,16 @@ theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : Stri
   · simp only [lt_asymm H, lt_asymm (h.symm.iterate_pos_lt_of_map_lt' hg hf H hn)]
 #align function.commute.iterate_pos_lt_iff_map_lt Function.Commute.iterate_pos_lt_iff_map_lt
 
-/- warning: function.commute.iterate_pos_lt_iff_map_lt' -> Function.Commute.iterate_pos_lt_iff_map_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
-Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_lt_iff_map_lt' Function.Commute.iterate_pos_lt_iff_map_lt'ₓ'. -/
 theorem iterate_pos_lt_iff_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
     (hn : 0 < n) : (f^[n]) x < (g^[n]) x ↔ f x < g x :=
   @iterate_pos_lt_iff_map_lt αᵒᵈ _ _ _ h.symm hg.dual hf.dual x n hn
 #align function.commute.iterate_pos_lt_iff_map_lt' Function.Commute.iterate_pos_lt_iff_map_lt'
 
-/- warning: function.commute.iterate_pos_le_iff_map_le -> Function.Commute.iterate_pos_le_iff_map_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
-Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_le_iff_map_le Function.Commute.iterate_pos_le_iff_map_leₓ'. -/
 theorem iterate_pos_le_iff_map_le (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
     (hn : 0 < n) : (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x := by
   simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt' hg hf hn)
 #align function.commute.iterate_pos_le_iff_map_le Function.Commute.iterate_pos_le_iff_map_le
 
-/- warning: function.commute.iterate_pos_le_iff_map_le' -> Function.Commute.iterate_pos_le_iff_map_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
-Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_le_iff_map_le' Function.Commute.iterate_pos_le_iff_map_le'ₓ'. -/
 theorem iterate_pos_le_iff_map_le' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
     (hn : 0 < n) : (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x := by
   simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt hg hf hn)
@@ -349,24 +229,12 @@ namespace Monotone
 
 variable [Preorder α] {f : α → α} {x : α}
 
-/- warning: monotone.monotone_iterate_of_le_map -> Monotone.monotone_iterate_of_le_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) x (f x)) -> (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x (f x)) -> (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
-Case conversion may be inaccurate. Consider using '#align monotone.monotone_iterate_of_le_map Monotone.monotone_iterate_of_le_mapₓ'. -/
 /-- If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
 a monotone sequence. -/
 theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone fun n => (f^[n]) x :=
   monotone_nat_of_le_succ fun n => by rw [iterate_succ_apply]; exact hf.iterate n hx
 #align monotone.monotone_iterate_of_le_map Monotone.monotone_iterate_of_le_map
 
-/- warning: monotone.antitone_iterate_of_map_le -> Monotone.antitone_iterate_of_map_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f x) x) -> (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f x) x) -> (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
-Case conversion may be inaccurate. Consider using '#align monotone.antitone_iterate_of_map_le Monotone.antitone_iterate_of_map_leₓ'. -/
 /-- If `f` is a monotone map and `f x ≤ x` at some point `x`, then the iterates `f^[n] x` form
 a antitone sequence. -/
 theorem antitone_iterate_of_map_le (hf : Monotone f) (hx : f x ≤ x) : Antitone fun n => (f^[n]) x :=
@@ -379,12 +247,6 @@ namespace StrictMono
 
 variable [Preorder α] {f : α → α} {x : α}
 
-/- warning: strict_mono.strict_mono_iterate_of_lt_map -> StrictMono.strictMono_iterate_of_lt_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f x)) -> (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f x)) -> (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
-Case conversion may be inaccurate. Consider using '#align strict_mono.strict_mono_iterate_of_lt_map StrictMono.strictMono_iterate_of_lt_mapₓ'. -/
 /-- If `f` is a strictly monotone map and `x < f x` at some point `x`, then the iterates `f^[n] x`
 form a strictly monotone sequence. -/
 theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
@@ -392,12 +254,6 @@ theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
   strictMono_nat_of_lt_succ fun n => by rw [iterate_succ_apply]; exact hf.iterate n hx
 #align strict_mono.strict_mono_iterate_of_lt_map StrictMono.strictMono_iterate_of_lt_map
 
-/- warning: strict_mono.strict_anti_iterate_of_map_lt -> StrictMono.strictAnti_iterate_of_map_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f x) x) -> (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f x) x) -> (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
-Case conversion may be inaccurate. Consider using '#align strict_mono.strict_anti_iterate_of_map_lt StrictMono.strictAnti_iterate_of_map_ltₓ'. -/
 /-- If `f` is a strictly antitone map and `f x < x` at some point `x`, then the iterates `f^[n] x`
 form a strictly antitone sequence. -/
 theorem strictAnti_iterate_of_map_lt (hf : StrictMono f) (hx : f x < x) :

448144f7

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -97,10 +97,8 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
 Case conversion may be inaccurate. Consider using '#align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_leₓ'. -/
 theorem seq_lt_seq_of_lt_of_le (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
-    (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n :=
-  by
-  cases n
-  exacts[h₀, hf.seq_pos_lt_seq_of_lt_of_le n.zero_lt_succ h₀.le hx hy]
+    (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n := by
+  cases n; exacts[h₀, hf.seq_pos_lt_seq_of_lt_of_le n.zero_lt_succ h₀.le hx hy]
 #align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_le
 
 /- warning: monotone.seq_lt_seq_of_le_of_lt -> Monotone.seq_lt_seq_of_le_of_lt is a dubious translation:
@@ -218,9 +216,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (id.{succ u1} α) f) -> (Monotone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
 Case conversion may be inaccurate. Consider using '#align function.monotone_iterate_of_id_le Function.monotone_iterate_of_id_leₓ'. -/
 theorem monotone_iterate_of_id_le (h : id ≤ f) : Monotone fun m => f^[m] :=
-  monotone_nat_of_le_succ fun n x => by
-    rw [iterate_succ_apply']
-    exact h _
+  monotone_nat_of_le_succ fun n x => by rw [iterate_succ_apply']; exact h _
 #align function.monotone_iterate_of_id_le Function.monotone_iterate_of_id_le
 
 /- warning: function.antitone_iterate_of_le_id -> Function.antitone_iterate_of_le_id is a dubious translation:
@@ -362,9 +358,7 @@ Case conversion may be inaccurate. Consider using '#align monotone.monotone_iter
 /-- If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
 a monotone sequence. -/
 theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone fun n => (f^[n]) x :=
-  monotone_nat_of_le_succ fun n => by
-    rw [iterate_succ_apply]
-    exact hf.iterate n hx
+  monotone_nat_of_le_succ fun n => by rw [iterate_succ_apply]; exact hf.iterate n hx
 #align monotone.monotone_iterate_of_le_map Monotone.monotone_iterate_of_le_map
 
 /- warning: monotone.antitone_iterate_of_map_le -> Monotone.antitone_iterate_of_map_le is a dubious translation:
@@ -395,9 +389,7 @@ Case conversion may be inaccurate. Consider using '#align strict_mono.strict_mon
 form a strictly monotone sequence. -/
 theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
     StrictMono fun n => (f^[n]) x :=
-  strictMono_nat_of_lt_succ fun n => by
-    rw [iterate_succ_apply]
-    exact hf.iterate n hx
+  strictMono_nat_of_lt_succ fun n => by rw [iterate_succ_apply]; exact hf.iterate n hx
 #align strict_mono.strict_mono_iterate_of_lt_map StrictMono.strictMono_iterate_of_lt_map
 
 /- warning: strict_mono.strict_anti_iterate_of_map_lt -> StrictMono.strictAnti_iterate_of_map_lt is a dubious translation:

448144f7

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -46,7 +46,12 @@ lemmas in this section formalize this fact for different inequalities made stric
 -/
 
 
-#print Monotone.seq_le_seq /-
+/- warning: monotone.seq_le_seq -> Monotone.seq_le_seq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x n) (y n)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x n) (y n)))
+Case conversion may be inaccurate. Consider using '#align monotone.seq_le_seq Monotone.seq_le_seqₓ'. -/
 theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k < n, x (k + 1) ≤ f (x k))
     (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n ≤ y n :=
   by
@@ -56,9 +61,13 @@ theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k
     exact fun k hk => hx _ (hk.trans n.lt_succ_self)
     exact fun k hk => hy _ (hk.trans n.lt_succ_self)
 #align monotone.seq_le_seq Monotone.seq_le_seq
--/
 
-#print Monotone.seq_pos_lt_seq_of_lt_of_le /-
+/- warning: monotone.seq_pos_lt_seq_of_lt_of_le -> Monotone.seq_pos_lt_seq_of_lt_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x n) (y n)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
+Case conversion may be inaccurate. Consider using '#align monotone.seq_pos_lt_seq_of_lt_of_le Monotone.seq_pos_lt_seq_of_lt_of_leₓ'. -/
 theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n :=
   by
@@ -69,30 +78,41 @@ theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h
   refine' (ihn n.zero_lt_succ (fun k hk => hx _ _) fun k hk => hy _ _).le <;>
     exact hk.trans n.succ.lt_succ_self
 #align monotone.seq_pos_lt_seq_of_lt_of_le Monotone.seq_pos_lt_seq_of_lt_of_le
--/
 
-#print Monotone.seq_pos_lt_seq_of_le_of_lt /-
+/- warning: monotone.seq_pos_lt_seq_of_le_of_lt -> Monotone.seq_pos_lt_seq_of_le_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x n) (y n)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
+Case conversion may be inaccurate. Consider using '#align monotone.seq_pos_lt_seq_of_le_of_lt Monotone.seq_pos_lt_seq_of_le_of_ltₓ'. -/
 theorem seq_pos_lt_seq_of_le_of_lt (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
     (hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n :=
   hf.dual.seq_pos_lt_seq_of_lt_of_le hn h₀ hy hx
 #align monotone.seq_pos_lt_seq_of_le_of_lt Monotone.seq_pos_lt_seq_of_le_of_lt
--/
 
-#print Monotone.seq_lt_seq_of_lt_of_le /-
+/- warning: monotone.seq_lt_seq_of_lt_of_le -> Monotone.seq_lt_seq_of_lt_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x n) (y n)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
+Case conversion may be inaccurate. Consider using '#align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_leₓ'. -/
 theorem seq_lt_seq_of_lt_of_le (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n :=
   by
   cases n
   exacts[h₀, hf.seq_pos_lt_seq_of_lt_of_le n.zero_lt_succ h₀.le hx hy]
 #align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_le
--/
 
-#print Monotone.seq_lt_seq_of_le_of_lt /-
+/- warning: monotone.seq_lt_seq_of_le_of_lt -> Monotone.seq_lt_seq_of_le_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (y (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat Nat.hasLt k n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (x n) (y n)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : Nat -> α} {y : Nat -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (forall (n : Nat), (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (y (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (x (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f (x k)))) -> (forall (k : Nat), (LT.lt.{0} Nat instLTNat k n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (y k)) (y (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (x n) (y n)))
+Case conversion may be inaccurate. Consider using '#align monotone.seq_lt_seq_of_le_of_lt Monotone.seq_lt_seq_of_le_of_ltₓ'. -/
 theorem seq_lt_seq_of_le_of_lt (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
     (hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n :=
   hf.dual.seq_lt_seq_of_lt_of_le n h₀ hy hx
 #align monotone.seq_lt_seq_of_le_of_lt Monotone.seq_lt_seq_of_le_of_lt
--/
 
 /-!
 ### Iterates of two functions
@@ -111,7 +131,7 @@ open Function
 
 /- warning: monotone.le_iterate_comp_of_le -> Monotone.le_iterate_comp_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u1} α _inst_1)) (Function.comp.{succ u2, succ u2, succ u1} β β α h g) (Function.comp.{succ u2, succ u1, succ u1} β α α f h)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u1} α _inst_1)) (Function.comp.{succ u2, succ u2, succ u1} β β α h (Nat.iterate.{succ u2} β g n)) (Function.comp.{succ u2, succ u1, succ u1} β α α (Nat.iterate.{succ u1} α f n) h))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u2, succ u2, succ u1} β β α h g) (Function.comp.{succ u2, succ u1, succ u1} β α α f h)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u2, succ u2, succ u1} β β α h (Nat.iterate.{succ u2} β g n)) (Function.comp.{succ u2, succ u1, succ u1} β α α (Nat.iterate.{succ u1} α f n) h))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u2, u2} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u1, u2} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u2} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} β β α h g) (Function.comp.{succ u1, succ u2, succ u2} β α α f h)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u1, u2} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u2} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u2} β β α h (Nat.iterate.{succ u1} β g n)) (Function.comp.{succ u1, succ u2, succ u2} β α α (Nat.iterate.{succ u2} α f n) h))
 Case conversion may be inaccurate. Consider using '#align monotone.le_iterate_comp_of_le Monotone.le_iterate_comp_of_leₓ'. -/
@@ -122,7 +142,7 @@ theorem le_iterate_comp_of_le (hf : Monotone f) (H : h ∘ g ≤ f ∘ h) (n : 
 
 /- warning: monotone.iterate_comp_le_of_le -> Monotone.iterate_comp_le_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u1} α _inst_1)) (Function.comp.{succ u2, succ u1, succ u1} β α α f h) (Function.comp.{succ u2, succ u2, succ u1} β β α h g)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u1} α _inst_1)) (Function.comp.{succ u2, succ u1, succ u1} β α α (Nat.iterate.{succ u1} α f n) h) (Function.comp.{succ u2, succ u2, succ u1} β β α h (Nat.iterate.{succ u2} β g n)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u2, succ u1, succ u1} β α α f h) (Function.comp.{succ u2, succ u2, succ u1} β β α h g)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u2, succ u1, succ u1} β α α (Nat.iterate.{succ u1} α f n) h) (Function.comp.{succ u2, succ u2, succ u1} β β α h (Nat.iterate.{succ u2} β g n)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] {f : α -> α} {g : β -> β} {h : β -> α}, (Monotone.{u2, u2} α α _inst_1 _inst_1 f) -> (LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u1, u2} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u2} α _inst_1)) (Function.comp.{succ u1, succ u2, succ u2} β α α f h) (Function.comp.{succ u1, succ u1, succ u2} β β α h g)) -> (forall (n : Nat), LE.le.{max u2 u1} (β -> α) (Pi.hasLe.{u1, u2} β (fun (ᾰ : β) => α) (fun (i : β) => Preorder.toLE.{u2} α _inst_1)) (Function.comp.{succ u1, succ u2, succ u2} β α α (Nat.iterate.{succ u2} α f n) h) (Function.comp.{succ u1, succ u1, succ u2} β β α h (Nat.iterate.{succ u1} β g n)))
 Case conversion may be inaccurate. Consider using '#align monotone.iterate_comp_le_of_le Monotone.iterate_comp_le_of_leₓ'. -/
@@ -131,19 +151,27 @@ theorem iterate_comp_le_of_le (hf : Monotone f) (H : f ∘ h ≤ h ∘ g) (n : 
   hf.dual.le_iterate_comp_of_le H n
 #align monotone.iterate_comp_le_of_le Monotone.iterate_comp_le_of_le
 
-#print Monotone.iterate_le_of_le /-
+/- warning: monotone.iterate_le_of_le -> Monotone.iterate_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) f g) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (Nat.iterate.{succ u1} α g n))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) f g) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (Nat.iterate.{succ u1} α g n))
+Case conversion may be inaccurate. Consider using '#align monotone.iterate_le_of_le Monotone.iterate_le_of_leₓ'. -/
 /-- If `f ≤ g` and `f` is monotone, then `f^[n] ≤ g^[n]`. -/
 theorem iterate_le_of_le {g : α → α} (hf : Monotone f) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] :=
   hf.iterate_comp_le_of_le h n
 #align monotone.iterate_le_of_le Monotone.iterate_le_of_le
--/
 
-#print Monotone.le_iterate_of_le /-
+/- warning: monotone.le_iterate_of_le -> Monotone.le_iterate_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) f g) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (Nat.iterate.{succ u1} α g n))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) f g) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (Nat.iterate.{succ u1} α g n))
+Case conversion may be inaccurate. Consider using '#align monotone.le_iterate_of_le Monotone.le_iterate_of_leₓ'. -/
 /-- If `f ≤ g` and `g` is monotone, then `f^[n] ≤ g^[n]`. -/
 theorem le_iterate_of_le {g : α → α} (hg : Monotone g) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] :=
   hg.dual.iterate_le_of_le h n
 #align monotone.le_iterate_of_le Monotone.le_iterate_of_le
--/
 
 end Monotone
 
@@ -161,33 +189,49 @@ section Preorder
 
 variable [Preorder α] {f : α → α}
 
-#print Function.id_le_iterate_of_id_le /-
+/- warning: function.id_le_iterate_of_id_le -> Function.id_le_iterate_of_id_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (id.{succ u1} α) f) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (id.{succ u1} α) (Nat.iterate.{succ u1} α f n))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (id.{succ u1} α) f) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (id.{succ u1} α) (Nat.iterate.{succ u1} α f n))
+Case conversion may be inaccurate. Consider using '#align function.id_le_iterate_of_id_le Function.id_le_iterate_of_id_leₓ'. -/
 /-- If $x ≤ f x$ for all $x$ (we write this as `id ≤ f`), then the same is true for any iterate
 `f^[n]` of `f`. -/
 theorem id_le_iterate_of_id_le (h : id ≤ f) (n : ℕ) : id ≤ f^[n] := by
   simpa only [iterate_id] using monotone_id.iterate_le_of_le h n
 #align function.id_le_iterate_of_id_le Function.id_le_iterate_of_id_le
--/
 
-#print Function.iterate_le_id_of_le_id /-
+/- warning: function.iterate_le_id_of_le_id -> Function.iterate_le_id_of_le_id is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) f (id.{succ u1} α)) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (id.{succ u1} α))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) f (id.{succ u1} α)) -> (forall (n : Nat), LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (Nat.iterate.{succ u1} α f n) (id.{succ u1} α))
+Case conversion may be inaccurate. Consider using '#align function.iterate_le_id_of_le_id Function.iterate_le_id_of_le_idₓ'. -/
 theorem iterate_le_id_of_le_id (h : f ≤ id) (n : ℕ) : f^[n] ≤ id :=
   @id_le_iterate_of_id_le αᵒᵈ _ f h n
 #align function.iterate_le_id_of_le_id Function.iterate_le_id_of_le_id
--/
 
-#print Function.monotone_iterate_of_id_le /-
+/- warning: function.monotone_iterate_of_id_le -> Function.monotone_iterate_of_id_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) (id.{succ u1} α) f) -> (Monotone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (a : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) (id.{succ u1} α) f) -> (Monotone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
+Case conversion may be inaccurate. Consider using '#align function.monotone_iterate_of_id_le Function.monotone_iterate_of_id_leₓ'. -/
 theorem monotone_iterate_of_id_le (h : id ≤ f) : Monotone fun m => f^[m] :=
   monotone_nat_of_le_succ fun n x => by
     rw [iterate_succ_apply']
     exact h _
 #align function.monotone_iterate_of_id_le Function.monotone_iterate_of_id_le
--/
 
-#print Function.antitone_iterate_of_le_id /-
+/- warning: function.antitone_iterate_of_le_id -> Function.antitone_iterate_of_le_id is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toHasLe.{u1} α _inst_1)) f (id.{succ u1} α)) -> (Antitone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α}, (LE.le.{u1} (α -> α) (Pi.hasLe.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => Preorder.toLE.{u1} α _inst_1)) f (id.{succ u1} α)) -> (Antitone.{0, u1} Nat (α -> α) (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) (Pi.preorder.{u1, u1} α (fun (ᾰ : α) => α) (fun (i : α) => _inst_1)) (fun (m : Nat) => Nat.iterate.{succ u1} α f m))
+Case conversion may be inaccurate. Consider using '#align function.antitone_iterate_of_le_id Function.antitone_iterate_of_le_idₓ'. -/
 theorem antitone_iterate_of_le_id (h : f ≤ id) : Antitone fun m => f^[m] := fun m n hmn =>
   @monotone_iterate_of_id_le αᵒᵈ _ f h m n hmn
 #align function.antitone_iterate_of_le_id Function.antitone_iterate_of_le_id
--/
 
 end Preorder
 
@@ -206,34 +250,51 @@ section Preorder
 
 variable [Preorder α] {f g : α → α}
 
-#print Function.Commute.iterate_le_of_map_le /-
+/- warning: function.commute.iterate_le_of_map_le -> Function.Commute.iterate_le_of_map_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f x) (g x)) -> (forall (n : Nat), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f x) (g x)) -> (forall (n : Nat), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)))
+Case conversion may be inaccurate. Consider using '#align function.commute.iterate_le_of_map_le Function.Commute.iterate_le_of_map_leₓ'. -/
 theorem iterate_le_of_map_le (h : Commute f g) (hf : Monotone f) (hg : Monotone g) {x}
     (hx : f x ≤ g x) (n : ℕ) : (f^[n]) x ≤ (g^[n]) x := by
   refine' hf.seq_le_seq n _ (fun k hk => _) fun k hk => _ <;>
     simp [iterate_succ' f, h.iterate_right _ _, hg.iterate _ hx]
 #align function.commute.iterate_le_of_map_le Function.Commute.iterate_le_of_map_le
--/
 
-#print Function.Commute.iterate_pos_lt_of_map_lt /-
+/- warning: function.commute.iterate_pos_lt_of_map_lt -> Function.Commute.iterate_pos_lt_of_map_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (StrictMono.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f x) (g x)) -> (forall {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (StrictMono.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f x) (g x)) -> (forall {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x))))
+Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_lt_of_map_lt Function.Commute.iterate_pos_lt_of_map_ltₓ'. -/
 theorem iterate_pos_lt_of_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x}
     (hx : f x < g x) {n} (hn : 0 < n) : (f^[n]) x < (g^[n]) x := by
   refine' hf.seq_pos_lt_seq_of_le_of_lt hn _ (fun k hk => _) fun k hk => _ <;>
     simp [iterate_succ' f, h.iterate_right _ _, hg.iterate _ hx]
 #align function.commute.iterate_pos_lt_of_map_lt Function.Commute.iterate_pos_lt_of_map_lt
--/
 
-#print Function.Commute.iterate_pos_lt_of_map_lt' /-
+/- warning: function.commute.iterate_pos_lt_of_map_lt' -> Function.Commute.iterate_pos_lt_of_map_lt' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f x) (g x)) -> (forall {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (Monotone.{u1, u1} α α _inst_1 _inst_1 g) -> (forall {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f x) (g x)) -> (forall {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x))))
+Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_lt_of_map_lt' Function.Commute.iterate_pos_lt_of_map_lt'ₓ'. -/
 theorem iterate_pos_lt_of_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x}
     (hx : f x < g x) {n} (hn : 0 < n) : (f^[n]) x < (g^[n]) x :=
   @iterate_pos_lt_of_map_lt αᵒᵈ _ g f h.symm hg.dual hf.dual x hx n hn
 #align function.commute.iterate_pos_lt_of_map_lt' Function.Commute.iterate_pos_lt_of_map_lt'
--/
 
 end Preorder
 
 variable [LinearOrder α] {f g : α → α}
 
-#print Function.Commute.iterate_pos_lt_iff_map_lt /-
+/- warning: function.commute.iterate_pos_lt_iff_map_lt -> Function.Commute.iterate_pos_lt_iff_map_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
+Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_lt_iff_map_lt Function.Commute.iterate_pos_lt_iff_map_ltₓ'. -/
 theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
     (hn : 0 < n) : (f^[n]) x < (g^[n]) x ↔ f x < g x :=
   by
@@ -242,28 +303,39 @@ theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : Stri
   · simp only [*, h.iterate_eq_of_map_eq, lt_irrefl]
   · simp only [lt_asymm H, lt_asymm (h.symm.iterate_pos_lt_of_map_lt' hg hf H hn)]
 #align function.commute.iterate_pos_lt_iff_map_lt Function.Commute.iterate_pos_lt_iff_map_lt
--/
 
-#print Function.Commute.iterate_pos_lt_iff_map_lt' /-
+/- warning: function.commute.iterate_pos_lt_iff_map_lt' -> Function.Commute.iterate_pos_lt_iff_map_lt' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
+Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_lt_iff_map_lt' Function.Commute.iterate_pos_lt_iff_map_lt'ₓ'. -/
 theorem iterate_pos_lt_iff_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
     (hn : 0 < n) : (f^[n]) x < (g^[n]) x ↔ f x < g x :=
   @iterate_pos_lt_iff_map_lt αᵒᵈ _ _ _ h.symm hg.dual hf.dual x n hn
 #align function.commute.iterate_pos_lt_iff_map_lt' Function.Commute.iterate_pos_lt_iff_map_lt'
--/
 
-#print Function.Commute.iterate_pos_le_iff_map_le /-
+/- warning: function.commute.iterate_pos_le_iff_map_le -> Function.Commute.iterate_pos_le_iff_map_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
+Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_le_iff_map_le Function.Commute.iterate_pos_le_iff_map_leₓ'. -/
 theorem iterate_pos_le_iff_map_le (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
     (hn : 0 < n) : (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x := by
   simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt' hg hf hn)
 #align function.commute.iterate_pos_le_iff_map_le Function.Commute.iterate_pos_le_iff_map_le
--/
 
-#print Function.Commute.iterate_pos_le_iff_map_le' /-
+/- warning: function.commute.iterate_pos_le_iff_map_le' -> Function.Commute.iterate_pos_le_iff_map_le' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {f : α -> α} {g : α -> α}, (Function.Commute.{u1} α f g) -> (StrictMono.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) f) -> (Monotone.{u1, u1} α α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) g) -> (forall {x : α} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (Nat.iterate.{succ u1} α f n x) (Nat.iterate.{succ u1} α g n x)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (f x) (g x))))
+Case conversion may be inaccurate. Consider using '#align function.commute.iterate_pos_le_iff_map_le' Function.Commute.iterate_pos_le_iff_map_le'ₓ'. -/
 theorem iterate_pos_le_iff_map_le' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
     (hn : 0 < n) : (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x := by
   simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt hg hf hn)
 #align function.commute.iterate_pos_le_iff_map_le' Function.Commute.iterate_pos_le_iff_map_le'
--/
 
 #print Function.Commute.iterate_pos_eq_iff_map_eq /-
 theorem iterate_pos_eq_iff_map_eq (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
@@ -281,7 +353,12 @@ namespace Monotone
 
 variable [Preorder α] {f : α → α} {x : α}
 
-#print Monotone.monotone_iterate_of_le_map /-
+/- warning: monotone.monotone_iterate_of_le_map -> Monotone.monotone_iterate_of_le_map is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) x (f x)) -> (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x (f x)) -> (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
+Case conversion may be inaccurate. Consider using '#align monotone.monotone_iterate_of_le_map Monotone.monotone_iterate_of_le_mapₓ'. -/
 /-- If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
 a monotone sequence. -/
 theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone fun n => (f^[n]) x :=
@@ -289,15 +366,18 @@ theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone
     rw [iterate_succ_apply]
     exact hf.iterate n hx
 #align monotone.monotone_iterate_of_le_map Monotone.monotone_iterate_of_le_map
--/
 
-#print Monotone.antitone_iterate_of_map_le /-
+/- warning: monotone.antitone_iterate_of_map_le -> Monotone.antitone_iterate_of_map_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f x) x) -> (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (Monotone.{u1, u1} α α _inst_1 _inst_1 f) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f x) x) -> (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
+Case conversion may be inaccurate. Consider using '#align monotone.antitone_iterate_of_map_le Monotone.antitone_iterate_of_map_leₓ'. -/
 /-- If `f` is a monotone map and `f x ≤ x` at some point `x`, then the iterates `f^[n] x` form
 a antitone sequence. -/
 theorem antitone_iterate_of_map_le (hf : Monotone f) (hx : f x ≤ x) : Antitone fun n => (f^[n]) x :=
   hf.dual.monotone_iterate_of_le_map hx
 #align monotone.antitone_iterate_of_map_le Monotone.antitone_iterate_of_map_le
--/
 
 end Monotone
 
@@ -305,7 +385,12 @@ namespace StrictMono
 
 variable [Preorder α] {f : α → α} {x : α}
 
-#print StrictMono.strictMono_iterate_of_lt_map /-
+/- warning: strict_mono.strict_mono_iterate_of_lt_map -> StrictMono.strictMono_iterate_of_lt_map is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f x)) -> (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f x)) -> (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
+Case conversion may be inaccurate. Consider using '#align strict_mono.strict_mono_iterate_of_lt_map StrictMono.strictMono_iterate_of_lt_mapₓ'. -/
 /-- If `f` is a strictly monotone map and `x < f x` at some point `x`, then the iterates `f^[n] x`
 form a strictly monotone sequence. -/
 theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
@@ -314,16 +399,19 @@ theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
     rw [iterate_succ_apply]
     exact hf.iterate n hx
 #align strict_mono.strict_mono_iterate_of_lt_map StrictMono.strictMono_iterate_of_lt_map
--/
 
-#print StrictMono.strictAnti_iterate_of_map_lt /-
+/- warning: strict_mono.strict_anti_iterate_of_map_lt -> StrictMono.strictAnti_iterate_of_map_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f x) x) -> (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : α -> α} {x : α}, (StrictMono.{u1, u1} α α _inst_1 _inst_1 f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f x) x) -> (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 (fun (n : Nat) => Nat.iterate.{succ u1} α f n x))
+Case conversion may be inaccurate. Consider using '#align strict_mono.strict_anti_iterate_of_map_lt StrictMono.strictAnti_iterate_of_map_ltₓ'. -/
 /-- If `f` is a strictly antitone map and `f x < x` at some point `x`, then the iterates `f^[n] x`
 form a strictly antitone sequence. -/
 theorem strictAnti_iterate_of_map_lt (hf : StrictMono f) (hx : f x < x) :
     StrictAnti fun n => (f^[n]) x :=
   hf.dual.strictMono_iterate_of_lt_map hx
 #align strict_mono.strict_anti_iterate_of_map_lt StrictMono.strictAnti_iterate_of_map_lt
--/
 
 end StrictMono

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

2258b40d

chore: adapt to multiple goal linter 1 (#12338)

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -44,8 +44,8 @@ theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k
   induction' n with n ihn
   · exact h₀
   · refine' (hx _ n.lt_succ_self).trans ((hf <| ihn _ _).trans (hy _ n.lt_succ_self))
-    exact fun k hk => hx _ (hk.trans n.lt_succ_self)
-    exact fun k hk => hy _ (hk.trans n.lt_succ_self)
+    · exact fun k hk => hx _ (hk.trans n.lt_succ_self)
+    · exact fun k hk => hy _ (hk.trans n.lt_succ_self)
 #align monotone.seq_le_seq Monotone.seq_le_seq
 
 theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)

2258b40d

chore: remove more autoImplicit (#11336)

... or reduce its scope (the full removal is not as obvious).

59f72a90

Diff

@@ -18,16 +18,13 @@ Current selection of inequalities is motivated by formalization of the rotation
 a circle homeomorphism.
 -/
 
-set_option autoImplicit true
-
-
 open Function
 
 open Function (Commute)
 
 namespace Monotone
 
-variable [Preorder α] {f : α → α} {x y : ℕ → α}
+variable {α : Type*} [Preorder α] {f : α → α} {x y : ℕ → α}
 
 /-!
 ### Comparison of two sequences
@@ -90,7 +87,7 @@ Then we specialize these two lemmas to the case `β = α`, `h = id`.
 -/
 
 
-variable {g : β → β} {h : β → α}
+variable {β : Type*} {g : β → β} {h : β → α}
 
 open Function
 
@@ -130,7 +127,7 @@ namespace Function
 
 section Preorder
 
-variable [Preorder α] {f : α → α}
+variable {α : Type*} [Preorder α] {f : α → α}
 
 /-- If $x ≤ f x$ for all $x$ (we write this as `id ≤ f`), then the same is true for any iterate
 `f^[n]` of `f`. -/
@@ -167,7 +164,7 @@ namespace Commute
 
 section Preorder
 
-variable [Preorder α] {f g : α → α}
+variable {α : Type*} [Preorder α] {f g : α → α}
 
 theorem iterate_le_of_map_le (h : Commute f g) (hf : Monotone f) (hg : Monotone g) {x}
     (hx : f x ≤ g x) (n : ℕ) : f^[n] x ≤ g^[n] x := by
@@ -192,7 +189,7 @@ theorem iterate_pos_lt_of_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Mo
 
 end Preorder
 
-variable [LinearOrder α] {f g : α → α}
+variable {α : Type*} [LinearOrder α] {f g : α → α}
 
 theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
     (hn : 0 < n) : f^[n] x < g^[n] x ↔ f x < g x := by
@@ -229,7 +226,7 @@ end Function
 
 namespace Monotone
 
-variable [Preorder α] {f : α → α} {x : α}
+variable {α : Type*} [Preorder α] {f : α → α} {x : α}
 
 /-- If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
 a monotone sequence. -/
@@ -249,7 +246,7 @@ end Monotone
 
 namespace StrictMono
 
-variable [Preorder α] {f : α → α} {x : α}
+variable {α : Type*} [Preorder α] {f : α → α} {x : α}
 
 /-- If `f` is a strictly monotone map and `x < f x` at some point `x`, then the iterates `f^[n] x`
 form a strictly monotone sequence. -/

2258b40d

chore(*): replace $ with <| (#9319)

See Zulip thread for the discussion.

9f6d3388

Diff

@@ -46,7 +46,7 @@ theorem seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k
     (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n ≤ y n := by
   induction' n with n ihn
   · exact h₀
-  · refine' (hx _ n.lt_succ_self).trans ((hf $ ihn _ _).trans (hy _ n.lt_succ_self))
+  · refine' (hx _ n.lt_succ_self).trans ((hf <| ihn _ _).trans (hy _ n.lt_succ_self))
     exact fun k hk => hx _ (hk.trans n.lt_succ_self)
     exact fun k hk => hy _ (hk.trans n.lt_succ_self)
 #align monotone.seq_le_seq Monotone.seq_le_seq
@@ -55,7 +55,7 @@ theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n := by
   induction' n with n ihn
   · exact hn.false.elim
-  suffices x n ≤ y n from (hx n n.lt_succ_self).trans_le ((hf this).trans $ hy n n.lt_succ_self)
+  suffices x n ≤ y n from (hx n n.lt_succ_self).trans_le ((hf this).trans <| hy n n.lt_succ_self)
   cases n with
   | zero => exact h₀
   | succ n =>

2258b40d

chore(*): drop $/<| before fun (#9361)

Subset of #9319

3694e27d

Diff

@@ -143,7 +143,7 @@ theorem iterate_le_id_of_le_id (h : f ≤ id) (n : ℕ) : f^[n] ≤ id :=
 #align function.iterate_le_id_of_le_id Function.iterate_le_id_of_le_id
 
 theorem monotone_iterate_of_id_le (h : id ≤ f) : Monotone fun m => f^[m] :=
-  monotone_nat_of_le_succ $ fun n x => by
+  monotone_nat_of_le_succ fun n x => by
     rw [iterate_succ_apply']
     exact h _
 #align function.monotone_iterate_of_id_le Function.monotone_iterate_of_id_le
@@ -234,7 +234,7 @@ variable [Preorder α] {f : α → α} {x : α}
 /-- If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
 a monotone sequence. -/
 theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone fun n => f^[n] x :=
-  monotone_nat_of_le_succ $ fun n => by
+  monotone_nat_of_le_succ fun n => by
     rw [iterate_succ_apply]
     exact hf.iterate n hx
 #align monotone.monotone_iterate_of_le_map Monotone.monotone_iterate_of_le_map
@@ -255,7 +255,7 @@ variable [Preorder α] {f : α → α} {x : α}
 form a strictly monotone sequence. -/
 theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
     StrictMono fun n => f^[n] x :=
-  strictMono_nat_of_lt_succ $ fun n => by
+  strictMono_nat_of_lt_succ fun n => by
     rw [iterate_succ_apply]
     exact hf.iterate n hx
 #align strict_mono.strict_mono_iterate_of_lt_map StrictMono.strictMono_iterate_of_lt_map

2258b40d

refactor(*): Protect Function.Commute (#6456)

This PR protects Function.Commute, so that it no longer clashes with Commute in the root namespace, as suggested by @j-loreaux in #6290.

abbba041

Diff

@@ -23,6 +23,8 @@ set_option autoImplicit true
 
 open Function
 
+open Function (Commute)
+
 namespace Monotone
 
 variable [Preorder α] {f : α → α} {x y : ℕ → α}

2258b40d

fix: disable autoImplicit globally (#6528)

Autoimplicits are highly controversial and also defeat the performance-improving work in #6474.

The intent of this PR is to make autoImplicit opt-in on a per-file basis, by disabling it in the lakefile and enabling it again with set_option autoImplicit true in the few files that rely on it.

That also keeps this PR small, as opposed to attempting to "fix" files to not need it any more.

I claim that many of the uses of autoImplicit in these files are accidental; situations such as:

Assuming variables are in scope, but pasting the lemma in the wrong section
Pasting in a lemma from a scratch file without checking to see if the variable names are consistent with the rest of the file
Making a copy-paste error between lemmas and forgetting to add an explicit arguments.

Having set_option autoImplicit false as the default prevents these types of mistake being made in the 90% of files where autoImplicits are not used at all, and causes them to be caught by CI during review.

I think there were various points during the port where we encouraged porters to delete the universes u v lines; I think having autoparams for universe variables only would cover a lot of the cases we actually use them, while avoiding any real shortcomings.

A Zulip poll (after combining overlapping votes accordingly) was in favor of this change with 5:5:18 as the no:dontcare:yes vote ratio.

While this PR was being reviewed, a handful of files gained some more likely-accidental autoImplicits. In these places, set_option autoImplicit true has been placed locally within a section, rather than at the top of the file.

0c24f831

Diff

@@ -18,6 +18,8 @@ Current selection of inequalities is motivated by formalization of the rotation
 a circle homeomorphism.
 -/
 
+set_option autoImplicit true
+
 
 open Function

2258b40d

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module order.iterate
-! leanprover-community/mathlib commit 2258b40dacd2942571c8ce136215350c702dc78f
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Logic.Function.Iterate
 import Mathlib.Order.Monotone.Basic
 
+#align_import order.iterate from "leanprover-community/mathlib"@"2258b40dacd2942571c8ce136215350c702dc78f"
+
 /-!
 # Inequalities on iterates

2258b40d

fix precedence of Nat.iterate (#5589)

bd2fff86

Diff

@@ -169,7 +169,7 @@ section Preorder
 variable [Preorder α] {f g : α → α}
 
 theorem iterate_le_of_map_le (h : Commute f g) (hf : Monotone f) (hg : Monotone g) {x}
-    (hx : f x ≤ g x) (n : ℕ) : (f^[n]) x ≤ (g^[n]) x := by
+    (hx : f x ≤ g x) (n : ℕ) : f^[n] x ≤ g^[n] x := by
   apply hf.seq_le_seq n
   · rfl
   · intros; rw [iterate_succ_apply']
@@ -177,7 +177,7 @@ theorem iterate_le_of_map_le (h : Commute f g) (hf : Monotone f) (hg : Monotone
 #align function.commute.iterate_le_of_map_le Function.Commute.iterate_le_of_map_le
 
 theorem iterate_pos_lt_of_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x}
-    (hx : f x < g x) {n} (hn : 0 < n) : (f^[n]) x < (g^[n]) x := by
+    (hx : f x < g x) {n} (hn : 0 < n) : f^[n] x < g^[n] x := by
   apply hf.seq_pos_lt_seq_of_le_of_lt hn
   · rfl
   · intros; rw [iterate_succ_apply']
@@ -185,7 +185,7 @@ theorem iterate_pos_lt_of_map_lt (h : Commute f g) (hf : Monotone f) (hg : Stric
 #align function.commute.iterate_pos_lt_of_map_lt Function.Commute.iterate_pos_lt_of_map_lt
 
 theorem iterate_pos_lt_of_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x}
-    (hx : f x < g x) {n} (hn : 0 < n) : (f^[n]) x < (g^[n]) x :=
+    (hx : f x < g x) {n} (hn : 0 < n) : f^[n] x < g^[n] x :=
   @iterate_pos_lt_of_map_lt αᵒᵈ _ g f h.symm hg.dual hf.dual x hx n hn
 #align function.commute.iterate_pos_lt_of_map_lt' Function.Commute.iterate_pos_lt_of_map_lt'
 
@@ -194,7 +194,7 @@ end Preorder
 variable [LinearOrder α] {f g : α → α}
 
 theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
-    (hn : 0 < n) : (f^[n]) x < (g^[n]) x ↔ f x < g x := by
+    (hn : 0 < n) : f^[n] x < g^[n] x ↔ f x < g x := by
   rcases lt_trichotomy (f x) (g x) with (H | H | H)
   · simp only [*, iterate_pos_lt_of_map_lt]
   · simp only [*, h.iterate_eq_of_map_eq, lt_irrefl]
@@ -202,22 +202,22 @@ theorem iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : Stri
 #align function.commute.iterate_pos_lt_iff_map_lt Function.Commute.iterate_pos_lt_iff_map_lt
 
 theorem iterate_pos_lt_iff_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
-    (hn : 0 < n) : (f^[n]) x < (g^[n]) x ↔ f x < g x :=
+    (hn : 0 < n) : f^[n] x < g^[n] x ↔ f x < g x :=
   @iterate_pos_lt_iff_map_lt αᵒᵈ _ _ _ h.symm hg.dual hf.dual x n hn
 #align function.commute.iterate_pos_lt_iff_map_lt' Function.Commute.iterate_pos_lt_iff_map_lt'
 
 theorem iterate_pos_le_iff_map_le (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
-    (hn : 0 < n) : (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x := by
+    (hn : 0 < n) : f^[n] x ≤ g^[n] x ↔ f x ≤ g x := by
   simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt' hg hf hn)
 #align function.commute.iterate_pos_le_iff_map_le Function.Commute.iterate_pos_le_iff_map_le
 
 theorem iterate_pos_le_iff_map_le' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
-    (hn : 0 < n) : (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x := by
+    (hn : 0 < n) : f^[n] x ≤ g^[n] x ↔ f x ≤ g x := by
   simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt hg hf hn)
 #align function.commute.iterate_pos_le_iff_map_le' Function.Commute.iterate_pos_le_iff_map_le'
 
 theorem iterate_pos_eq_iff_map_eq (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
-    (hn : 0 < n) : (f^[n]) x = (g^[n]) x ↔ f x = g x := by
+    (hn : 0 < n) : f^[n] x = g^[n] x ↔ f x = g x := by
   simp only [le_antisymm_iff, h.iterate_pos_le_iff_map_le hf hg hn,
     h.symm.iterate_pos_le_iff_map_le' hg hf hn]
 #align function.commute.iterate_pos_eq_iff_map_eq Function.Commute.iterate_pos_eq_iff_map_eq
@@ -232,7 +232,7 @@ variable [Preorder α] {f : α → α} {x : α}
 
 /-- If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
 a monotone sequence. -/
-theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone fun n => (f^[n]) x :=
+theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone fun n => f^[n] x :=
   monotone_nat_of_le_succ $ fun n => by
     rw [iterate_succ_apply]
     exact hf.iterate n hx
@@ -240,7 +240,7 @@ theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone
 
 /-- If `f` is a monotone map and `f x ≤ x` at some point `x`, then the iterates `f^[n] x` form
 an antitone sequence. -/
-theorem antitone_iterate_of_map_le (hf : Monotone f) (hx : f x ≤ x) : Antitone fun n => (f^[n]) x :=
+theorem antitone_iterate_of_map_le (hf : Monotone f) (hx : f x ≤ x) : Antitone fun n => f^[n] x :=
   hf.dual.monotone_iterate_of_le_map hx
 #align monotone.antitone_iterate_of_map_le Monotone.antitone_iterate_of_map_le
 
@@ -253,7 +253,7 @@ variable [Preorder α] {f : α → α} {x : α}
 /-- If `f` is a strictly monotone map and `x < f x` at some point `x`, then the iterates `f^[n] x`
 form a strictly monotone sequence. -/
 theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
-    StrictMono fun n => (f^[n]) x :=
+    StrictMono fun n => f^[n] x :=
   strictMono_nat_of_lt_succ $ fun n => by
     rw [iterate_succ_apply]
     exact hf.iterate n hx
@@ -262,7 +262,7 @@ theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
 /-- If `f` is a strictly antitone map and `f x < x` at some point `x`, then the iterates `f^[n] x`
 form a strictly antitone sequence. -/
 theorem strictAnti_iterate_of_map_lt (hf : StrictMono f) (hx : f x < x) :
-    StrictAnti fun n => (f^[n]) x :=
+    StrictAnti fun n => f^[n] x :=
   hf.dual.strictMono_iterate_of_lt_map hx
 #align strict_mono.strict_anti_iterate_of_map_lt StrictMono.strictAnti_iterate_of_map_lt

2258b40d

chore: fix grammar 3/3 (#5003)

Part 3 of #5001

df58f20b

Diff

@@ -239,7 +239,7 @@ theorem monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone
 #align monotone.monotone_iterate_of_le_map Monotone.monotone_iterate_of_le_map
 
 /-- If `f` is a monotone map and `f x ≤ x` at some point `x`, then the iterates `f^[n] x` form
-a antitone sequence. -/
+an antitone sequence. -/
 theorem antitone_iterate_of_map_le (hf : Monotone f) (hx : f x ≤ x) : Antitone fun n => (f^[n]) x :=
   hf.dual.monotone_iterate_of_le_map hx
 #align monotone.antitone_iterate_of_map_le Monotone.antitone_iterate_of_map_le

2258b40d

chore: add space after exacts (#4945)

Too often tempted to change these during other PRs, so doing a mass edit here.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

bf799bb9

Diff

@@ -70,7 +70,7 @@ theorem seq_pos_lt_seq_of_le_of_lt (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h
 theorem seq_lt_seq_of_lt_of_le (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
     (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n := by
   cases n
-  exacts[h₀, hf.seq_pos_lt_seq_of_lt_of_le (Nat.zero_lt_succ _) h₀.le hx hy]
+  exacts [h₀, hf.seq_pos_lt_seq_of_lt_of_le (Nat.zero_lt_succ _) h₀.le hx hy]
 #align monotone.seq_lt_seq_of_lt_of_le Monotone.seq_lt_seq_of_lt_of_le
 
 theorem seq_lt_seq_of_le_of_lt (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)

2258b40d

chore: update SHA in porting header (#1306)

These files correspond to files flagged "The following files have been modified since the commit at which they were verified." by port_status.py but are in sync with mathlib3, so we can update the hash.

I only updated the easy ones, the others need a closer inspection.

Co-authored-by: Reid Barton <rwbarton@gmail.com>

cac405f4

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 
 ! This file was ported from Lean 3 source module order.iterate
-! leanprover-community/mathlib commit d6aae1bcbd04b8de2022b9b83a5b5b10e10c777d
+! leanprover-community/mathlib commit 2258b40dacd2942571c8ce136215350c702dc78f
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

d6aae1bc

chore: update lean4/std4 (#1096)

a9a1f7d7

Diff

@@ -219,7 +219,7 @@ theorem iterate_pos_le_iff_map_le' (h : Commute f g) (hf : StrictMono f) (hg : M
 theorem iterate_pos_eq_iff_map_eq (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
     (hn : 0 < n) : (f^[n]) x = (g^[n]) x ↔ f x = g x := by
   simp only [le_antisymm_iff, h.iterate_pos_le_iff_map_le hf hg hn,
-    h.symm.iterate_pos_le_iff_map_le' hg hf hn]; rfl
+    h.symm.iterate_pos_le_iff_map_le' hg hf hn]
 #align function.commute.iterate_pos_eq_iff_map_eq Function.Commute.iterate_pos_eq_iff_map_eq
 
 end Commute

d6aae1bc

chore: add source headers to ported theory files (#1094)

The script used to do this is included. The yaml file was obtained from https://raw.githubusercontent.com/wiki/leanprover-community/mathlib/mathlib4-port-status.md

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2020 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
+
+! This file was ported from Lean 3 source module order.iterate
+! leanprover-community/mathlib commit d6aae1bcbd04b8de2022b9b83a5b5b10e10c777d
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Logic.Function.Iterate
 import Mathlib.Order.Monotone.Basic

`order.iterate` ⟷ `Mathlib.Order.Iterate`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 22

order.iterate ⟷ Mathlib.Order.Iterate

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 22

`order.iterate` ⟷ `Mathlib.Order.Iterate`