data.list.nodup_equiv_fin ⟷ Mathlib.Data.List.NodupEquivFin

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

@@ -143,7 +143,7 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
   induction' l with hd tl IH generalizing l' f
   · simp
   have : some hd = _ := hf 0
-  rw [eq_comm, List.get?_eq_some'] at this 
+  rw [eq_comm, List.get?_eq_some'] at this
   obtain ⟨w, h⟩ := this
   let f' : ℕ ↪o ℕ :=
     OrderEmbedding.ofMapLEIff (fun i => f (i + 1) - (f 0 + 1)) fun a b => by
@@ -203,7 +203,7 @@ theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
       by
       intro i hi
       specialize hf i
-      rw [nth_le_nth hi, eq_comm, nth_eq_some] at hf 
+      rw [nth_le_nth hi, eq_comm, nth_eq_some] at hf
       obtain ⟨h, -⟩ := hf
       exact h
     refine' ⟨OrderEmbedding.ofMapLEIff (fun ix => ⟨f ix, h ix.is_lt⟩) _, _⟩
@@ -259,7 +259,7 @@ theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
       · simp [hnm]
       · simp
       · simp only [Nat.lt_succ_iff, Nat.succ_le_succ_iff, replicate, length, nonpos_iff_eq_zero] at
-          hi hj 
+          hi hj
         simp [hi, hj]
     · rintro ⟨⟨_ | i⟩, hi⟩
       · simpa using h

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

@@ -243,7 +243,27 @@ theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
     l.Duplicate x ↔
       ∃ (n : ℕ) (hn : n < l.length) (m : ℕ) (hm : m < l.length) (h : n < m),
         x = l.nthLe n hn ∧ x = l.nthLe m hm :=
-  by classical
+  by
+  classical
+  rw [duplicate_iff_two_le_count, le_count_iff_replicate_sublist,
+    sublist_iff_exists_fin_order_embedding_nth_le_eq]
+  constructor
+  · rintro ⟨f, hf⟩
+    refine' ⟨f ⟨0, by simp⟩, Fin.is_lt _, f ⟨1, by simp⟩, Fin.is_lt _, by simp, _, _⟩
+    · simpa using hf ⟨0, by simp⟩
+    · simpa using hf ⟨1, by simp⟩
+  · rintro ⟨n, hn, m, hm, hnm, h, h'⟩
+    refine' ⟨OrderEmbedding.ofStrictMono (fun i => if (i : ℕ) = 0 then ⟨n, hn⟩ else ⟨m, hm⟩) _, _⟩
+    · rintro ⟨⟨_ | i⟩, hi⟩ ⟨⟨_ | j⟩, hj⟩
+      · simp
+      · simp [hnm]
+      · simp
+      · simp only [Nat.lt_succ_iff, Nat.succ_le_succ_iff, replicate, length, nonpos_iff_eq_zero] at
+          hi hj 
+        simp [hi, hj]
+    · rintro ⟨⟨_ | i⟩, hi⟩
+      · simpa using h
+      · simpa using h'
 #align list.duplicate_iff_exists_distinct_nth_le List.duplicate_iff_exists_distinct_nthLe
 -/
 

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

@@ -243,27 +243,7 @@ theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
     l.Duplicate x ↔
       ∃ (n : ℕ) (hn : n < l.length) (m : ℕ) (hm : m < l.length) (h : n < m),
         x = l.nthLe n hn ∧ x = l.nthLe m hm :=
-  by
-  classical
-  rw [duplicate_iff_two_le_count, le_count_iff_replicate_sublist,
-    sublist_iff_exists_fin_order_embedding_nth_le_eq]
-  constructor
-  · rintro ⟨f, hf⟩
-    refine' ⟨f ⟨0, by simp⟩, Fin.is_lt _, f ⟨1, by simp⟩, Fin.is_lt _, by simp, _, _⟩
-    · simpa using hf ⟨0, by simp⟩
-    · simpa using hf ⟨1, by simp⟩
-  · rintro ⟨n, hn, m, hm, hnm, h, h'⟩
-    refine' ⟨OrderEmbedding.ofStrictMono (fun i => if (i : ℕ) = 0 then ⟨n, hn⟩ else ⟨m, hm⟩) _, _⟩
-    · rintro ⟨⟨_ | i⟩, hi⟩ ⟨⟨_ | j⟩, hj⟩
-      · simp
-      · simp [hnm]
-      · simp
-      · simp only [Nat.lt_succ_iff, Nat.succ_le_succ_iff, replicate, length, nonpos_iff_eq_zero] at
-          hi hj 
-        simp [hi, hj]
-    · rintro ⟨⟨_ | i⟩, hi⟩
-      · simpa using h
-      · simpa using h'
+  by classical
 #align list.duplicate_iff_exists_distinct_nth_le List.duplicate_iff_exists_distinct_nthLe
 -/
 

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

@@ -3,9 +3,9 @@ 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.Data.Fin.Basic
-import Mathbin.Data.List.Sort
-import Mathbin.Data.List.Duplicate
+import Data.Fin.Basic
+import Data.List.Sort
+import Data.List.Duplicate
 
 #align_import data.list.nodup_equiv_fin from "leanprover-community/mathlib"@"327c3c0d9232d80e250dc8f65e7835b82b266ea5"
 

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

@@ -2,16 +2,13 @@
 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 data.list.nodup_equiv_fin
-! leanprover-community/mathlib commit 327c3c0d9232d80e250dc8f65e7835b82b266ea5
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fin.Basic
 import Mathbin.Data.List.Sort
 import Mathbin.Data.List.Duplicate
 
+#align_import data.list.nodup_equiv_fin from "leanprover-community/mathlib"@"327c3c0d9232d80e250dc8f65e7835b82b266ea5"
+
 /-!
 # Equivalence between `fin (length l)` and elements of a list
 

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

@@ -91,13 +91,17 @@ namespace Sorted
 
 variable [Preorder α] {l : List α}
 
+#print List.Sorted.get_mono /-
 theorem get_mono (h : l.Sorted (· ≤ ·)) : Monotone fun i : Fin l.length => l.nthLe i i.2 :=
   fun i j => h.rel_nthLe_of_le _ _
 #align list.sorted.nth_le_mono List.Sorted.get_mono
+-/
 
+#print List.Sorted.get_strictMono /-
 theorem get_strictMono (h : l.Sorted (· < ·)) : StrictMono fun i : Fin l.length => l.nthLe i i.2 :=
   fun i j => h.rel_nthLe_of_lt _ _
 #align list.sorted.nth_le_strict_mono List.Sorted.get_strictMono
+-/
 
 variable [DecidableEq α]
 
@@ -113,20 +117,25 @@ def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x
 
 variable (H : Sorted (· < ·) l) {x : { x // x ∈ l }} {i : Fin l.length}
 
+#print List.Sorted.coe_getIso_apply /-
 @[simp]
 theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
   rfl
 #align list.sorted.coe_nth_le_iso_apply List.Sorted.coe_getIso_apply
+-/
 
+#print List.Sorted.coe_getIso_symm_apply /-
 @[simp]
 theorem coe_getIso_symm_apply : ((H.getIso l).symm x : ℕ) = indexOf (↑x) l :=
   rfl
 #align list.sorted.coe_nth_le_iso_symm_apply List.Sorted.coe_getIso_symm_apply
+-/
 
 end Sorted
 
 section Sublist
 
+#print List.sublist_of_orderEmbedding_get?_eq /-
 /-- If there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
 any element of `l` found at index `ix` can be found at index `f ix` in `l'`,
 then `sublist l l'`.
@@ -151,7 +160,9 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
   rw [List.singleton_sublist, ← h, l'.nth_le_take _ (Nat.lt_succ_self _)]
   apply List.nthLe_mem
 #align list.sublist_of_order_embedding_nth_eq List.sublist_of_orderEmbedding_get?_eq
+-/
 
+#print List.sublist_iff_exists_orderEmbedding_get?_eq /-
 /-- A `l : list α` is `sublist l l'` for `l' : list α` iff
 there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
 any element of `l` found at index `ix` can be found at index `f ix` in `l'`.
@@ -176,7 +187,9 @@ theorem sublist_iff_exists_orderEmbedding_get?_eq {l l' : List α} :
   · rintro ⟨f, hf⟩
     exact sublist_of_order_embedding_nth_eq f hf
 #align list.sublist_iff_exists_order_embedding_nth_eq List.sublist_iff_exists_orderEmbedding_get?_eq
+-/
 
+#print List.sublist_iff_exists_fin_orderEmbedding_get_eq /-
 /-- A `l : list α` is `sublist l l'` for `l' : list α` iff
 there is `f`, an order-preserving embedding of `fin l.length` into `fin l'.length` such that
 any element of `l` found at index `ix` can be found at index `f ix` in `l'`.
@@ -223,6 +236,7 @@ theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
         · simp
         · simpa using hi
 #align list.sublist_iff_exists_fin_order_embedding_nth_le_eq List.sublist_iff_exists_fin_orderEmbedding_get_eq
+-/
 
 #print List.duplicate_iff_exists_distinct_nthLe /-
 /-- An element `x : α` of `l : list α` is a duplicate iff it can be found

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -234,25 +234,25 @@ theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
         x = l.nthLe n hn ∧ x = l.nthLe m hm :=
   by
   classical
-    rw [duplicate_iff_two_le_count, le_count_iff_replicate_sublist,
-      sublist_iff_exists_fin_order_embedding_nth_le_eq]
-    constructor
-    · rintro ⟨f, hf⟩
-      refine' ⟨f ⟨0, by simp⟩, Fin.is_lt _, f ⟨1, by simp⟩, Fin.is_lt _, by simp, _, _⟩
-      · simpa using hf ⟨0, by simp⟩
-      · simpa using hf ⟨1, by simp⟩
-    · rintro ⟨n, hn, m, hm, hnm, h, h'⟩
-      refine' ⟨OrderEmbedding.ofStrictMono (fun i => if (i : ℕ) = 0 then ⟨n, hn⟩ else ⟨m, hm⟩) _, _⟩
-      · rintro ⟨⟨_ | i⟩, hi⟩ ⟨⟨_ | j⟩, hj⟩
-        · simp
-        · simp [hnm]
-        · simp
-        · simp only [Nat.lt_succ_iff, Nat.succ_le_succ_iff, replicate, length,
-            nonpos_iff_eq_zero] at hi hj 
-          simp [hi, hj]
-      · rintro ⟨⟨_ | i⟩, hi⟩
-        · simpa using h
-        · simpa using h'
+  rw [duplicate_iff_two_le_count, le_count_iff_replicate_sublist,
+    sublist_iff_exists_fin_order_embedding_nth_le_eq]
+  constructor
+  · rintro ⟨f, hf⟩
+    refine' ⟨f ⟨0, by simp⟩, Fin.is_lt _, f ⟨1, by simp⟩, Fin.is_lt _, by simp, _, _⟩
+    · simpa using hf ⟨0, by simp⟩
+    · simpa using hf ⟨1, by simp⟩
+  · rintro ⟨n, hn, m, hm, hnm, h, h'⟩
+    refine' ⟨OrderEmbedding.ofStrictMono (fun i => if (i : ℕ) = 0 then ⟨n, hn⟩ else ⟨m, hm⟩) _, _⟩
+    · rintro ⟨⟨_ | i⟩, hi⟩ ⟨⟨_ | j⟩, hj⟩
+      · simp
+      · simp [hnm]
+      · simp
+      · simp only [Nat.lt_succ_iff, Nat.succ_le_succ_iff, replicate, length, nonpos_iff_eq_zero] at
+          hi hj 
+        simp [hi, hj]
+    · rintro ⟨⟨_ | i⟩, hi⟩
+      · simpa using h
+      · simpa using h'
 #align list.duplicate_iff_exists_distinct_nth_le List.duplicate_iff_exists_distinct_nthLe
 -/
 

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

@@ -137,7 +137,7 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
   induction' l with hd tl IH generalizing l' f
   · simp
   have : some hd = _ := hf 0
-  rw [eq_comm, List.get?_eq_some'] at this
+  rw [eq_comm, List.get?_eq_some'] at this 
   obtain ⟨w, h⟩ := this
   let f' : ℕ ↪o ℕ :=
     OrderEmbedding.ofMapLEIff (fun i => f (i + 1) - (f 0 + 1)) fun a b => by
@@ -193,7 +193,7 @@ theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
       by
       intro i hi
       specialize hf i
-      rw [nth_le_nth hi, eq_comm, nth_eq_some] at hf
+      rw [nth_le_nth hi, eq_comm, nth_eq_some] at hf 
       obtain ⟨h, -⟩ := hf
       exact h
     refine' ⟨OrderEmbedding.ofMapLEIff (fun ix => ⟨f ix, h ix.is_lt⟩) _, _⟩
@@ -230,7 +230,7 @@ at two distinct indices `n m : ℕ` inside the list `l`.
 -/
 theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
     l.Duplicate x ↔
-      ∃ (n : ℕ)(hn : n < l.length)(m : ℕ)(hm : m < l.length)(h : n < m),
+      ∃ (n : ℕ) (hn : n < l.length) (m : ℕ) (hm : m < l.length) (h : n < m),
         x = l.nthLe n hn ∧ x = l.nthLe m hm :=
   by
   classical
@@ -248,7 +248,7 @@ theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
         · simp [hnm]
         · simp
         · simp only [Nat.lt_succ_iff, Nat.succ_le_succ_iff, replicate, length,
-            nonpos_iff_eq_zero] at hi hj
+            nonpos_iff_eq_zero] at hi hj 
           simp [hi, hj]
       · rintro ⟨⟨_ | i⟩, hi⟩
         · simpa using h

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

@@ -101,6 +101,7 @@ theorem get_strictMono (h : l.Sorted (· < ·)) : StrictMono fun i : Fin l.lengt
 
 variable [DecidableEq α]
 
+#print List.Sorted.getIso /-
 /-- If `l` is a list sorted w.r.t. `(<)`, then `list.nth_le` defines an order isomorphism between
 `fin (length l)` and the set of elements of `l`. -/
 def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x ∈ l }
@@ -108,6 +109,7 @@ def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x
   toEquiv := H.Nodup.getEquiv l
   map_rel_iff' i j := H.get_strictMono.le_iff_le
 #align list.sorted.nth_le_iso List.Sorted.getIso
+-/
 
 variable (H : Sorted (· < ·) l) {x : { x // x ∈ l }} {i : Fin l.length}
 

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

@@ -91,34 +91,16 @@ namespace Sorted
 
 variable [Preorder α] {l : List α}
 
-/- warning: list.sorted.nth_le_mono -> List.Sorted.get_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1)) l) -> (Monotone.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.partialOrder (List.length.{u1} α l))) _inst_1 (fun (i : Fin (List.length.{u1} α l)) => List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.263 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.265 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.263 x._@.Mathlib.Data.List.NodupEquivFin._hyg.265) l) -> (Monotone.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.instPartialOrderFin (List.length.{u1} α l))) _inst_1 (List.get.{u1} α l))
-Case conversion may be inaccurate. Consider using '#align list.sorted.nth_le_mono List.Sorted.get_monoₓ'. -/
 theorem get_mono (h : l.Sorted (· ≤ ·)) : Monotone fun i : Fin l.length => l.nthLe i i.2 :=
   fun i j => h.rel_nthLe_of_le _ _
 #align list.sorted.nth_le_mono List.Sorted.get_mono
 
-/- warning: list.sorted.nth_le_strict_mono -> List.Sorted.get_strictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) -> (StrictMono.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.partialOrder (List.length.{u1} α l))) _inst_1 (fun (i : Fin (List.length.{u1} α l)) => List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.296 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.298 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.296 x._@.Mathlib.Data.List.NodupEquivFin._hyg.298) l) -> (StrictMono.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.instPartialOrderFin (List.length.{u1} α l))) _inst_1 (List.get.{u1} α l))
-Case conversion may be inaccurate. Consider using '#align list.sorted.nth_le_strict_mono List.Sorted.get_strictMonoₓ'. -/
 theorem get_strictMono (h : l.Sorted (· < ·)) : StrictMono fun i : Fin l.length => l.nthLe i i.2 :=
   fun i j => h.rel_nthLe_of_lt _ _
 #align list.sorted.nth_le_strict_mono List.Sorted.get_strictMono
 
 variable [DecidableEq α]
 
-/- warning: list.sorted.nth_le_iso -> List.Sorted.getIso is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableEq.{succ u1} α] (l : List.{u1} α), (List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) -> (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableEq.{succ u1} α] (l : List.{u1} α), (List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.345 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.347 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.345 x._@.Mathlib.Data.List.NodupEquivFin._hyg.347) l) -> (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)))
-Case conversion may be inaccurate. Consider using '#align list.sorted.nth_le_iso List.Sorted.getIsoₓ'. -/
 /-- If `l` is a list sorted w.r.t. `(<)`, then `list.nth_le` defines an order isomorphism between
 `fin (length l)` and the set of elements of `l`. -/
 def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x ∈ l }
@@ -129,17 +111,11 @@ def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x
 
 variable (H : Sorted (· < ·) l) {x : { x // x ∈ l }} {i : Fin l.length}
 
-/- warning: list.sorted.coe_nth_le_iso_apply -> List.Sorted.coe_getIso_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_apply List.Sorted.coe_getIso_applyₓ'. -/
 @[simp]
 theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
   rfl
 #align list.sorted.coe_nth_le_iso_apply List.Sorted.coe_getIso_apply
 
-/- warning: list.sorted.coe_nth_le_iso_symm_apply -> List.Sorted.coe_getIso_symm_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_symm_apply List.Sorted.coe_getIso_symm_applyₓ'. -/
 @[simp]
 theorem coe_getIso_symm_apply : ((H.getIso l).symm x : ℕ) = indexOf (↑x) l :=
   rfl
@@ -149,12 +125,6 @@ end Sorted
 
 section Sublist
 
-/- warning: list.sublist_of_order_embedding_nth_eq -> List.sublist_of_orderEmbedding_get?_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α} (f : OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe), (forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (coeFn.{1, 1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (_x : RelEmbedding.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) => Nat -> Nat) (RelEmbedding.hasCoeToFun.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) f ix))) -> (List.Sublist.{u1} α l l')
-but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α} (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat), (forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Nat) => Nat) _x) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) f ix))) -> (List.Sublist.{u1} α l l')
-Case conversion may be inaccurate. Consider using '#align list.sublist_of_order_embedding_nth_eq List.sublist_of_orderEmbedding_get?_eqₓ'. -/
 /-- If there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
 any element of `l` found at index `ix` can be found at index `f ix` in `l'`,
 then `sublist l l'`.
@@ -180,12 +150,6 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
   apply List.nthLe_mem
 #align list.sublist_of_order_embedding_nth_eq List.sublist_of_orderEmbedding_get?_eq
 
-/- warning: list.sublist_iff_exists_order_embedding_nth_eq -> List.sublist_iff_exists_orderEmbedding_get?_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (f : OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) => forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (coeFn.{1, 1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (_x : RelEmbedding.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) => Nat -> Nat) (RelEmbedding.hasCoeToFun.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) f ix))))
-but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) (fun (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) => forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Nat) => Nat) _x) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) f ix))))
-Case conversion may be inaccurate. Consider using '#align list.sublist_iff_exists_order_embedding_nth_eq List.sublist_iff_exists_orderEmbedding_get?_eqₓ'. -/
 /-- A `l : list α` is `sublist l l'` for `l' : list α` iff
 there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
 any element of `l` found at index `ix` can be found at index `f ix` in `l'`.
@@ -211,12 +175,6 @@ theorem sublist_iff_exists_orderEmbedding_get?_eq {l l' : List α} :
     exact sublist_of_order_embedding_nth_eq f hf
 #align list.sublist_iff_exists_order_embedding_nth_eq List.sublist_iff_exists_orderEmbedding_get?_eq
 
-/- warning: list.sublist_iff_exists_fin_order_embedding_nth_le_eq -> List.sublist_iff_exists_fin_orderEmbedding_get_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (f : OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) => forall (ix : Fin (List.length.{u1} α l)), Eq.{succ u1} α (List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) ix) (Fin.is_lt (List.length.{u1} α l) ix)) (List.nthLe.{u1} α l' ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l')) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l')) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l')) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l')) Nat (Fin.coeToNat (List.length.{u1} α l'))))) (coeFn.{1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (_x : RelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) => (Fin (List.length.{u1} α l)) -> (Fin (List.length.{u1} α l'))) (RelEmbedding.hasCoeToFun.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) f ix)) (Fin.is_lt (List.length.{u1} α l') (coeFn.{1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (_x : RelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) => (Fin (List.length.{u1} α l)) -> (Fin (List.length.{u1} α l'))) (RelEmbedding.hasCoeToFun.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) f ix)))))
-but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (fun (f : OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) => forall (ix : Fin (List.length.{u1} α l)), Eq.{succ u1} α (List.get.{u1} α l ix) (List.get.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (fun (a : Fin (List.length.{u1} α l)) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Fin (List.length.{u1} α l)) => Fin (List.length.{u1} α l')) a) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) f ix))))
-Case conversion may be inaccurate. Consider using '#align list.sublist_iff_exists_fin_order_embedding_nth_le_eq List.sublist_iff_exists_fin_orderEmbedding_get_eqₓ'. -/
 /-- A `l : list α` is `sublist l l'` for `l' : list α` iff
 there is `f`, an order-preserving embedding of `fin l.length` into `fin l'.length` such that
 any element of `l` found at index `ix` can be found at index `f ix` in `l'`.

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

@@ -130,10 +130,7 @@ def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x
 variable (H : Sorted (· < ·) l) {x : { x // x ∈ l }} {i : Fin l.length}
 
 /- warning: list.sorted.coe_nth_le_iso_apply -> List.Sorted.coe_getIso_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) (coeFn.{succ u1, succ u1} (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (fun (_x : RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) => (Fin (List.length.{u1} α l)) -> (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (RelIso.hasCoeToFun.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.450 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 x._@.Mathlib.Data.List.NodupEquivFin._hyg.450) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) (FunLike.coe.{succ u1, 1, succ u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Fin (List.length.{u1} α l)) (fun (_x : Fin (List.length.{u1} α l)) => Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (RelHomClass.toFunLike.{u1, 0, u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.get.{u1} α l i)
+<too large>
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_apply List.Sorted.coe_getIso_applyₓ'. -/
 @[simp]
 theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
@@ -141,10 +138,7 @@ theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
 #align list.sorted.coe_nth_le_iso_apply List.Sorted.coe_getIso_apply
 
 /- warning: list.sorted.coe_nth_le_iso_symm_apply -> List.Sorted.coe_getIso_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)}, Eq.{1} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l))) (fun (_x : RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) => (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) -> (Fin (List.length.{u1} α l))) (RelIso.hasCoeToFun.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOfₓ.{u1} α (fun (a : α) (b : α) => _inst_2 a b) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) x) l)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.508 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 x._@.Mathlib.Data.List.NodupEquivFin._hyg.508) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)}, Eq.{1} Nat (Fin.val (List.length.{u1} α l) (FunLike.coe.{succ u1, succ u1, 1} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => Fin (List.length.{u1} α l)) (RelHomClass.toFunLike.{u1, u1, 0} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOf.{u1} α (instBEq.{u1} α (fun (a : α) (b : α) => _inst_2 a b)) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) x) l)
+<too large>
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_symm_apply List.Sorted.coe_getIso_symm_applyₓ'. -/
 @[simp]
 theorem coe_getIso_symm_apply : ((H.getIso l).symm x : ℕ) = indexOf (↑x) l :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -133,7 +133,7 @@ variable (H : Sorted (· < ·) l) {x : { x // x ∈ l }} {i : Fin l.length}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) (coeFn.{succ u1, succ u1} (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (fun (_x : RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) => (Fin (List.length.{u1} α l)) -> (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (RelIso.hasCoeToFun.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.450 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 x._@.Mathlib.Data.List.NodupEquivFin._hyg.450) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) (FunLike.coe.{succ u1, 1, succ u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Fin (List.length.{u1} α l)) (fun (_x : Fin (List.length.{u1} α l)) => Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (RelHomClass.toFunLike.{u1, 0, u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.get.{u1} α l i)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.450 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 x._@.Mathlib.Data.List.NodupEquivFin._hyg.450) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) (FunLike.coe.{succ u1, 1, succ u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Fin (List.length.{u1} α l)) (fun (_x : Fin (List.length.{u1} α l)) => Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (RelHomClass.toFunLike.{u1, 0, u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.get.{u1} α l i)
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_apply List.Sorted.coe_getIso_applyₓ'. -/
 @[simp]
 theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
@@ -144,7 +144,7 @@ theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)}, Eq.{1} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l))) (fun (_x : RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) => (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) -> (Fin (List.length.{u1} α l))) (RelIso.hasCoeToFun.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOfₓ.{u1} α (fun (a : α) (b : α) => _inst_2 a b) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) x) l)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.508 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 x._@.Mathlib.Data.List.NodupEquivFin._hyg.508) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)}, Eq.{1} Nat (Fin.val (List.length.{u1} α l) (FunLike.coe.{succ u1, succ u1, 1} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => Fin (List.length.{u1} α l)) (RelHomClass.toFunLike.{u1, u1, 0} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOf.{u1} α (instBEq.{u1} α (fun (a : α) (b : α) => _inst_2 a b)) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) x) l)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.508 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 x._@.Mathlib.Data.List.NodupEquivFin._hyg.508) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)}, Eq.{1} Nat (Fin.val (List.length.{u1} α l) (FunLike.coe.{succ u1, succ u1, 1} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => Fin (List.length.{u1} α l)) (RelHomClass.toFunLike.{u1, u1, 0} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOf.{u1} α (instBEq.{u1} α (fun (a : α) (b : α) => _inst_2 a b)) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) x) l)
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_symm_apply List.Sorted.coe_getIso_symm_applyₓ'. -/
 @[simp]
 theorem coe_getIso_symm_apply : ((H.getIso l).symm x : ℕ) = indexOf (↑x) l :=
@@ -159,7 +159,7 @@ section Sublist
 lean 3 declaration is
   forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α} (f : OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe), (forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (coeFn.{1, 1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (_x : RelEmbedding.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) => Nat -> Nat) (RelEmbedding.hasCoeToFun.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) f ix))) -> (List.Sublist.{u1} α l l')
 but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α} (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat), (forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Nat) => Nat) _x) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697))) f ix))) -> (List.Sublist.{u1} α l l')
+  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α} (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat), (forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Nat) => Nat) _x) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) f ix))) -> (List.Sublist.{u1} α l l')
 Case conversion may be inaccurate. Consider using '#align list.sublist_of_order_embedding_nth_eq List.sublist_of_orderEmbedding_get?_eqₓ'. -/
 /-- If there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
 any element of `l` found at index `ix` can be found at index `f ix` in `l'`,
@@ -190,7 +190,7 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
 lean 3 declaration is
   forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (f : OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) => forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (coeFn.{1, 1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (_x : RelEmbedding.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) => Nat -> Nat) (RelEmbedding.hasCoeToFun.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) f ix))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) (fun (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) => forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Nat) => Nat) _x) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697))) f ix))))
+  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) (fun (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) => forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Nat) => Nat) _x) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) f ix))))
 Case conversion may be inaccurate. Consider using '#align list.sublist_iff_exists_order_embedding_nth_eq List.sublist_iff_exists_orderEmbedding_get?_eqₓ'. -/
 /-- A `l : list α` is `sublist l l'` for `l' : list α` iff
 there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
@@ -221,7 +221,7 @@ theorem sublist_iff_exists_orderEmbedding_get?_eq {l l' : List α} :
 lean 3 declaration is
   forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (f : OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) => forall (ix : Fin (List.length.{u1} α l)), Eq.{succ u1} α (List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) ix) (Fin.is_lt (List.length.{u1} α l) ix)) (List.nthLe.{u1} α l' ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l')) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l')) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l')) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l')) Nat (Fin.coeToNat (List.length.{u1} α l'))))) (coeFn.{1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (_x : RelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) => (Fin (List.length.{u1} α l)) -> (Fin (List.length.{u1} α l'))) (RelEmbedding.hasCoeToFun.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) f ix)) (Fin.is_lt (List.length.{u1} α l') (coeFn.{1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (_x : RelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) => (Fin (List.length.{u1} α l)) -> (Fin (List.length.{u1} α l'))) (RelEmbedding.hasCoeToFun.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) f ix)))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (fun (f : OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) => forall (ix : Fin (List.length.{u1} α l)), Eq.{succ u1} α (List.get.{u1} α l ix) (List.get.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (fun (a : Fin (List.length.{u1} α l)) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Fin (List.length.{u1} α l)) => Fin (List.length.{u1} α l')) a) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697))) f ix))))
+  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (fun (f : OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) => forall (ix : Fin (List.length.{u1} α l)), Eq.{succ u1} α (List.get.{u1} α l ix) (List.get.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (fun (a : Fin (List.length.{u1} α l)) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Fin (List.length.{u1} α l)) => Fin (List.length.{u1} α l')) a) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) f ix))))
 Case conversion may be inaccurate. Consider using '#align list.sublist_iff_exists_fin_order_embedding_nth_le_eq List.sublist_iff_exists_fin_orderEmbedding_get_eqₓ'. -/
 /-- A `l : list α` is `sublist l l'` for `l' : list α` iff
 there is `f`, an order-preserving embedding of `fin l.length` into `fin l'.length` such that

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

@@ -93,7 +93,7 @@ variable [Preorder α] {l : List α}
 
 /- warning: list.sorted.nth_le_mono -> List.Sorted.get_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1)) l) -> (Monotone.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.partialOrder (List.length.{u1} α l))) _inst_1 (fun (i : Fin (List.length.{u1} α l)) => List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i)))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1)) l) -> (Monotone.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.partialOrder (List.length.{u1} α l))) _inst_1 (fun (i : Fin (List.length.{u1} α l)) => List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.263 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.265 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.263 x._@.Mathlib.Data.List.NodupEquivFin._hyg.265) l) -> (Monotone.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.instPartialOrderFin (List.length.{u1} α l))) _inst_1 (List.get.{u1} α l))
 Case conversion may be inaccurate. Consider using '#align list.sorted.nth_le_mono List.Sorted.get_monoₓ'. -/
@@ -103,7 +103,7 @@ theorem get_mono (h : l.Sorted (· ≤ ·)) : Monotone fun i : Fin l.length => l
 
 /- warning: list.sorted.nth_le_strict_mono -> List.Sorted.get_strictMono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1)) l) -> (StrictMono.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.partialOrder (List.length.{u1} α l))) _inst_1 (fun (i : Fin (List.length.{u1} α l)) => List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i)))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) -> (StrictMono.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.partialOrder (List.length.{u1} α l))) _inst_1 (fun (i : Fin (List.length.{u1} α l)) => List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α}, (List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.296 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.298 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.296 x._@.Mathlib.Data.List.NodupEquivFin._hyg.298) l) -> (StrictMono.{0, u1} (Fin (List.length.{u1} α l)) α (PartialOrder.toPreorder.{0} (Fin (List.length.{u1} α l)) (Fin.instPartialOrderFin (List.length.{u1} α l))) _inst_1 (List.get.{u1} α l))
 Case conversion may be inaccurate. Consider using '#align list.sorted.nth_le_strict_mono List.Sorted.get_strictMonoₓ'. -/
@@ -113,7 +113,12 @@ theorem get_strictMono (h : l.Sorted (· < ·)) : StrictMono fun i : Fin l.lengt
 
 variable [DecidableEq α]
 
-#print List.Sorted.getIso /-
+/- warning: list.sorted.nth_le_iso -> List.Sorted.getIso is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableEq.{succ u1} α] (l : List.{u1} α), (List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) -> (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableEq.{succ u1} α] (l : List.{u1} α), (List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.345 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.347 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.345 x._@.Mathlib.Data.List.NodupEquivFin._hyg.347) l) -> (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)))
+Case conversion may be inaccurate. Consider using '#align list.sorted.nth_le_iso List.Sorted.getIsoₓ'. -/
 /-- If `l` is a list sorted w.r.t. `(<)`, then `list.nth_le` defines an order isomorphism between
 `fin (length l)` and the set of elements of `l`. -/
 def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x ∈ l }
@@ -121,13 +126,12 @@ def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x
   toEquiv := H.Nodup.getEquiv l
   map_rel_iff' i j := H.get_strictMono.le_iff_le
 #align list.sorted.nth_le_iso List.Sorted.getIso
--/
 
 variable (H : Sorted (· < ·) l) {x : { x // x ∈ l }} {i : Fin l.length}
 
 /- warning: list.sorted.coe_nth_le_iso_apply -> List.Sorted.coe_getIso_apply is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1)) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) (coeFn.{succ u1, succ u1} (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (fun (_x : RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) => (Fin (List.length.{u1} α l)) -> (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (RelIso.hasCoeToFun.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) (coeFn.{succ u1, succ u1} (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (fun (_x : RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) => (Fin (List.length.{u1} α l)) -> (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (RelIso.hasCoeToFun.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.450 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 x._@.Mathlib.Data.List.NodupEquivFin._hyg.450) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) (FunLike.coe.{succ u1, 1, succ u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Fin (List.length.{u1} α l)) (fun (_x : Fin (List.length.{u1} α l)) => Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (RelHomClass.toFunLike.{u1, 0, u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.get.{u1} α l i)
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_apply List.Sorted.coe_getIso_applyₓ'. -/
@@ -138,7 +142,7 @@ theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
 
 /- warning: list.sorted.coe_nth_le_iso_symm_apply -> List.Sorted.coe_getIso_symm_apply is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1)) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)}, Eq.{1} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l))) (fun (_x : RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) => (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) -> (Fin (List.length.{u1} α l))) (RelIso.hasCoeToFun.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOfₓ.{u1} α (fun (a : α) (b : α) => _inst_2 a b) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) x) l)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1)) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)}, Eq.{1} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l))) (fun (_x : RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) => (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) -> (Fin (List.length.{u1} α l))) (RelIso.hasCoeToFun.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOfₓ.{u1} α (fun (a : α) (b : α) => _inst_2 a b) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) x) l)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.508 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 x._@.Mathlib.Data.List.NodupEquivFin._hyg.508) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)}, Eq.{1} Nat (Fin.val (List.length.{u1} α l) (FunLike.coe.{succ u1, succ u1, 1} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => Fin (List.length.{u1} α l)) (RelHomClass.toFunLike.{u1, u1, 0} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOf.{u1} α (instBEq.{u1} α (fun (a : α) (b : α) => _inst_2 a b)) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) x) l)
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_symm_apply List.Sorted.coe_getIso_symm_applyₓ'. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/730c6d4cab72b9d84fcfb9e95e8796e9cd8f40ba

@@ -129,7 +129,7 @@ variable (H : Sorted (· < ·) l) {x : { x // x ∈ l }} {i : Fin l.length}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1)) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) (coeFn.{succ u1, succ u1} (OrderIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (fun (_x : RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) => (Fin (List.length.{u1} α l)) -> (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (RelIso.hasCoeToFun.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) i) (Fin.property (List.length.{u1} α l) i))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.450 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 x._@.Mathlib.Data.List.NodupEquivFin._hyg.450) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) (FunLike.coe.{succ u1, 1, succ u1} (Function.Embedding.{1, succ u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l))) (Fin (List.length.{u1} α l)) (fun (_x : Fin (List.length.{u1} α l)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Fin (List.length.{u1} α l)) => Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) _x) (EmbeddingLike.toFunLike.{succ u1, 1, succ u1} (Function.Embedding.{1, succ u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l))) (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Function.instEmbeddingLikeEmbedding.{1, succ u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)))) (RelEmbedding.toEmbedding.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (a : Fin (List.length.{u1} α l)) (b : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) a b) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H))) i)) (List.get.{u1} α l i)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.450 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.448 x._@.Mathlib.Data.List.NodupEquivFin._hyg.450) l) {i : Fin (List.length.{u1} α l)}, Eq.{succ u1} α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) (FunLike.coe.{succ u1, 1, succ u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Fin (List.length.{u1} α l)) (fun (_x : Fin (List.length.{u1} α l)) => Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (RelHomClass.toFunLike.{u1, 0, u1} (RelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H) i)) (List.get.{u1} α l i)
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_apply List.Sorted.coe_getIso_applyₓ'. -/
 @[simp]
 theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
@@ -140,7 +140,7 @@ theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1)) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)}, Eq.{1} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l))) (fun (_x : RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) => (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) -> (Fin (List.length.{u1} α l))) (RelIso.hasCoeToFun.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOfₓ.{u1} α (fun (a : α) (b : α) => _inst_2 a b) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) x) l)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.508 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 x._@.Mathlib.Data.List.NodupEquivFin._hyg.508) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)}, Eq.{1} Nat (Fin.val (List.length.{u1} α l) (FunLike.coe.{succ u1, succ u1, 1} (Function.Embedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => Fin (List.length.{u1} α l)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, 1} (Function.Embedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Function.instEmbeddingLikeEmbedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)))) (RelEmbedding.toEmbedding.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (a : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (b : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) a b) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)))) x)) (List.indexOf.{u1} α (instBEq.{u1} α (fun (a : α) (b : α) => _inst_2 a b)) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) x) l)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.508 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 x._@.Mathlib.Data.List.NodupEquivFin._hyg.508) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)}, Eq.{1} Nat (Fin.val (List.length.{u1} α l) (FunLike.coe.{succ u1, succ u1, 1} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => Fin (List.length.{u1} α l)) (RelHomClass.toFunLike.{u1, u1, 0} (RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOf.{u1} α (instBEq.{u1} α (fun (a : α) (b : α) => _inst_2 a b)) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) x) l)
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_symm_apply List.Sorted.coe_getIso_symm_applyₓ'. -/
 @[simp]
 theorem coe_getIso_symm_apply : ((H.getIso l).symm x : ℕ) = indexOf (↑x) l :=
@@ -155,7 +155,7 @@ section Sublist
 lean 3 declaration is
   forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α} (f : OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe), (forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (coeFn.{1, 1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (_x : RelEmbedding.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) => Nat -> Nat) (RelEmbedding.hasCoeToFun.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) f ix))) -> (List.Sublist.{u1} α l l')
 but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α} (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat), (forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (Function.Embedding.{1, 1} Nat Nat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Nat) => Nat) _x) (EmbeddingLike.toFunLike.{1, 1, 1} (Function.Embedding.{1, 1} Nat Nat) Nat Nat (Function.instEmbeddingLikeEmbedding.{1, 1} Nat Nat)) (RelEmbedding.toEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) f) ix))) -> (List.Sublist.{u1} α l l')
+  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α} (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat), (forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Nat) => Nat) _x) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697))) f ix))) -> (List.Sublist.{u1} α l l')
 Case conversion may be inaccurate. Consider using '#align list.sublist_of_order_embedding_nth_eq List.sublist_of_orderEmbedding_get?_eqₓ'. -/
 /-- If there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
 any element of `l` found at index `ix` can be found at index `f ix` in `l'`,
@@ -186,7 +186,7 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
 lean 3 declaration is
   forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (f : OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) => forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (coeFn.{1, 1} (OrderEmbedding.{0, 0} Nat Nat Nat.hasLe Nat.hasLe) (fun (_x : RelEmbedding.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) => Nat -> Nat) (RelEmbedding.hasCoeToFun.{0, 0} Nat Nat (LE.le.{0} Nat Nat.hasLe) (LE.le.{0} Nat Nat.hasLe)) f ix))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) (fun (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) => forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (Function.Embedding.{1, 1} Nat Nat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Nat) => Nat) _x) (EmbeddingLike.toFunLike.{1, 1, 1} (Function.Embedding.{1, 1} Nat Nat) Nat Nat (Function.instEmbeddingLikeEmbedding.{1, 1} Nat Nat)) (RelEmbedding.toEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) f) ix))))
+  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) (fun (f : OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) => forall (ix : Nat), Eq.{succ u1} (Option.{u1} α) (List.get?.{u1} α l ix) (List.get?.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat (fun (_x : Nat) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Nat) => Nat) _x) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} Nat Nat instLENat instLENat) Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} Nat Nat (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Nat) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Nat) => LE.le.{0} Nat instLENat x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697))) f ix))))
 Case conversion may be inaccurate. Consider using '#align list.sublist_iff_exists_order_embedding_nth_eq List.sublist_iff_exists_orderEmbedding_get?_eqₓ'. -/
 /-- A `l : list α` is `sublist l l'` for `l' : list α` iff
 there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
@@ -217,7 +217,7 @@ theorem sublist_iff_exists_orderEmbedding_get?_eq {l l' : List α} :
 lean 3 declaration is
   forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (f : OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) => forall (ix : Fin (List.length.{u1} α l)), Eq.{succ u1} α (List.nthLe.{u1} α l ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) ix) (Fin.is_lt (List.length.{u1} α l) ix)) (List.nthLe.{u1} α l' ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l')) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l')) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l')) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l')) Nat (Fin.coeToNat (List.length.{u1} α l'))))) (coeFn.{1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (_x : RelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) => (Fin (List.length.{u1} α l)) -> (Fin (List.length.{u1} α l'))) (RelEmbedding.hasCoeToFun.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) f ix)) (Fin.is_lt (List.length.{u1} α l') (coeFn.{1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l'))) (fun (_x : RelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) => (Fin (List.length.{u1} α l)) -> (Fin (List.length.{u1} α l'))) (RelEmbedding.hasCoeToFun.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l))) (LE.le.{0} (Fin (List.length.{u1} α l')) (Fin.hasLe (List.length.{u1} α l')))) f ix)))))
 but is expected to have type
-  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (fun (f : OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) => forall (ix : Fin (List.length.{u1} α l)), Eq.{succ u1} α (List.get.{u1} α l ix) (List.get.{u1} α l' (FunLike.coe.{1, 1, 1} (Function.Embedding.{1, 1} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (fun (a : Fin (List.length.{u1} α l)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Fin (List.length.{u1} α l)) => Fin (List.length.{u1} α l')) a) (EmbeddingLike.toFunLike.{1, 1, 1} (Function.Embedding.{1, 1} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (Function.instEmbeddingLikeEmbedding.{1, 1} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')))) (RelEmbedding.toEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) f) ix))))
+  forall {α : Type.{u1}} {l : List.{u1} α} {l' : List.{u1} α}, Iff (List.Sublist.{u1} α l l') (Exists.{1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (fun (f : OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) => forall (ix : Fin (List.length.{u1} α l)), Eq.{succ u1} α (List.get.{u1} α l ix) (List.get.{u1} α l' (FunLike.coe.{1, 1, 1} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (fun (a : Fin (List.length.{u1} α l)) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Fin (List.length.{u1} α l)) => Fin (List.length.{u1} α l')) a) (RelHomClass.toFunLike.{0, 0, 0} (OrderEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l'))) (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697) (RelEmbedding.instRelHomClassRelEmbedding.{0, 0} (Fin (List.length.{u1} α l)) (Fin (List.length.{u1} α l')) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.680 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.682 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.680 x._@.Mathlib.Order.Hom.Basic._hyg.682) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.695 : Fin (List.length.{u1} α l')) (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Fin (List.length.{u1} α l')) => LE.le.{0} (Fin (List.length.{u1} α l')) (instLEFin (List.length.{u1} α l')) x._@.Mathlib.Order.Hom.Basic._hyg.695 x._@.Mathlib.Order.Hom.Basic._hyg.697))) f ix))))
 Case conversion may be inaccurate. Consider using '#align list.sublist_iff_exists_fin_order_embedding_nth_le_eq List.sublist_iff_exists_fin_orderEmbedding_get_eqₓ'. -/
 /-- A `l : list α` is `sublist l l'` for `l' : list α` iff
 there is `f`, an order-preserving embedding of `fin l.length` into `fin l'.length` such that

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

@@ -140,7 +140,7 @@ theorem coe_getIso_apply : (H.getIso l i : α) = nthLe l i i.2 :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1)) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)}, Eq.{1} Nat ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (List.length.{u1} α l)) Nat (HasLiftT.mk.{1, 1} (Fin (List.length.{u1} α l)) Nat (CoeTCₓ.coe.{1, 1} (Fin (List.length.{u1} α l)) Nat (coeBase.{1, 1} (Fin (List.length.{u1} α l)) Nat (Fin.coeToNat (List.length.{u1} α l))))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l))) (fun (_x : RelIso.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) => (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) -> (Fin (List.length.{u1} α l))) (RelIso.hasCoeToFun.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin (List.length.{u1} α l)) (LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))) (LE.le.{0} (Fin (List.length.{u1} α l)) (Fin.hasLe (List.length.{u1} α l)))) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (Fin.hasLe (List.length.{u1} α l)) (Subtype.hasLe.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)) x)) (List.indexOfₓ.{u1} α (fun (a : α) (b : α) => _inst_2 a b) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l))))) x) l)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.505 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.507 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.505 x._@.Mathlib.Data.List.NodupEquivFin._hyg.507) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)}, Eq.{1} Nat (Fin.val (List.length.{u1} α l) (FunLike.coe.{succ u1, succ u1, 1} (Function.Embedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => Fin (List.length.{u1} α l)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, 1} (Function.Embedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Function.instEmbeddingLikeEmbedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)))) (RelEmbedding.toEmbedding.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (a : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (b : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) a b) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)))) x)) (List.indexOf.{u1} α (instBEq.{u1} α (fun (a : α) (b : α) => _inst_2 a b)) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) x) l)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {l : List.{u1} α} [_inst_2 : DecidableEq.{succ u1} α] (H : List.Sorted.{u1} α (fun (x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 : α) (x._@.Mathlib.Data.List.NodupEquivFin._hyg.508 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Data.List.NodupEquivFin._hyg.506 x._@.Mathlib.Data.List.NodupEquivFin._hyg.508) l) {x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)}, Eq.{1} Nat (Fin.val (List.length.{u1} α l) (FunLike.coe.{succ u1, succ u1, 1} (Function.Embedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => Fin (List.length.{u1} α l)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, 1} (Function.Embedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (Function.instEmbeddingLikeEmbedding.{succ u1, 1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)))) (RelEmbedding.toEmbedding.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, 0} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Fin (List.length.{u1} α l)) (fun (a : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (b : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) => LE.le.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) a b) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Fin (List.length.{u1} α l)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Fin (List.length.{u1} α l)) => LE.le.{0} (Fin (List.length.{u1} α l)) (instLEFin (List.length.{u1} α l)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (OrderIso.symm.{0, u1} (Fin (List.length.{u1} α l)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (instLEFin (List.length.{u1} α l)) (Subtype.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l)) (List.Sorted.getIso.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) l H)))) x)) (List.indexOf.{u1} α (instBEq.{u1} α (fun (a : α) (b : α) => _inst_2 a b)) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) x) l)
 Case conversion may be inaccurate. Consider using '#align list.sorted.coe_nth_le_iso_symm_apply List.Sorted.coe_getIso_symm_applyₓ'. -/
 @[simp]
 theorem coe_getIso_symm_apply : ((H.getIso l).symm x : ℕ) = indexOf (↑x) l :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

@@ -170,7 +170,7 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
   rw [eq_comm, List.get?_eq_some'] at this
   obtain ⟨w, h⟩ := this
   let f' : ℕ ↪o ℕ :=
-    OrderEmbedding.ofMapLeIff (fun i => f (i + 1) - (f 0 + 1)) fun a b => by
+    OrderEmbedding.ofMapLEIff (fun i => f (i + 1) - (f 0 + 1)) fun a b => by
       simp [tsub_le_tsub_iff_right, Nat.succ_le_iff, Nat.lt_succ_iff]
   have : ∀ ix, tl.nth ix = (l'.drop (f 0 + 1)).get? (f' ix) :=
     by
@@ -204,7 +204,7 @@ theorem sublist_iff_exists_orderEmbedding_get?_eq {l l' : List α} :
       simpa using hf
     · obtain ⟨f, hf⟩ := IH
       refine'
-        ⟨OrderEmbedding.ofMapLeIff (fun ix : ℕ => if ix = 0 then 0 else (f ix.pred).succ) _, _⟩
+        ⟨OrderEmbedding.ofMapLEIff (fun ix : ℕ => if ix = 0 then 0 else (f ix.pred).succ) _, _⟩
       · rintro ⟨_ | a⟩ ⟨_ | b⟩ <;> simp [Nat.succ_le_succ_iff]
       · rintro ⟨_ | i⟩
         · simp
@@ -238,7 +238,7 @@ theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
       rw [nth_le_nth hi, eq_comm, nth_eq_some] at hf
       obtain ⟨h, -⟩ := hf
       exact h
-    refine' ⟨OrderEmbedding.ofMapLeIff (fun ix => ⟨f ix, h ix.is_lt⟩) _, _⟩
+    refine' ⟨OrderEmbedding.ofMapLEIff (fun ix => ⟨f ix, h ix.is_lt⟩) _, _⟩
     · simp
     · intro i
       apply Option.some_injective

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

These · are scoping when there is a single active goal.

These were found using a modification of the linter at #12339.

@@ -220,7 +220,7 @@ theorem duplicate_iff_exists_distinct_get {l : List α} {x : α} :
     · rintro ⟨f, hf⟩
       refine' ⟨f ⟨0, by simp⟩, f ⟨1, by simp⟩,
         f.lt_iff_lt.2 (show (0 : ℕ) < 1 from zero_lt_one), _⟩
-      · rw [← hf, ← hf]; simp
+      rw [← hf, ← hf]; simp
     · rintro ⟨n, m, hnm, h, h'⟩
       refine' ⟨OrderEmbedding.ofStrictMono (fun i => if (i : ℕ) = 0 then n else m) _, _⟩
       · rintro ⟨⟨_ | i⟩, hi⟩ ⟨⟨_ | j⟩, hj⟩

Most of them go back to the port.

@@ -237,7 +237,7 @@ theorem duplicate_iff_exists_distinct_get {l : List α} {x : α} :
 /-- An element `x : α` of `l : List α` is a duplicate iff it can be found
 at two distinct indices `n m : ℕ` inside the list `l`.
 -/
-@[deprecated duplicate_iff_exists_distinct_get]
+@[deprecated duplicate_iff_exists_distinct_get] -- 2023-01-19
 theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
     l.Duplicate x ↔
       ∃ (n : ℕ) (hn : n < l.length) (m : ℕ) (hm : m < l.length) (_ : n < m),

@@ -19,8 +19,8 @@ Given a list `l`,
   sending `⟨x, hx⟩` to `⟨indexOf x l, _⟩`;
 
 * if `l` has no duplicates and contains every element of a type `α`, then
-  `List.Nodup.getEquivOfForallMemList` defines an equivalence between
-  `Fin (length l)` and `α`;  if `α` does not have decidable equality, then
+  `List.Nodup.getEquivOfForallMemList` defines an equivalence between `Fin (length l)` and `α`;
+  if `α` does not have decidable equality, then
   there is a bijection `List.Nodup.getBijectionOfForallMemList`;
 
 * if `l` is sorted w.r.t. `(<)`, then `List.Sorted.getIso` is the same bijection reinterpreted

This removes the following files from the import closure of Data.Fin.Basic:

Mathlib.Algebra.Group.Equiv.Basic
Mathlib.Algebra.Group.Hom.Basic
Mathlib.Algebra.Group.InjSurj
Mathlib.Algebra.Group.OrderSynonym
Mathlib.Algebra.Group.Units.Equiv
Mathlib.Algebra.Group.Units.Hom
Mathlib.Algebra.GroupWithZero.Basic
Mathlib.Algebra.GroupWithZero.InjSurj
Mathlib.Algebra.GroupWithZero.Units.Basic
Mathlib.Algebra.GroupWithZero.Units.Equiv
Mathlib.Algebra.Order.Group.Units
Mathlib.Algebra.Order.Monoid.Basic
Mathlib.Algebra.Order.Monoid.OrderDual
Mathlib.Algebra.Order.Monoid.TypeTags
Mathlib.Algebra.Order.Monoid.Units
Mathlib.Algebra.Order.WithZero
Mathlib.Data.Int.Cast.Basic

@@ -124,12 +124,12 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
   let f' : ℕ ↪o ℕ :=
     OrderEmbedding.ofMapLEIff (fun i => f (i + 1) - (f 0 + 1)) fun a b => by
       dsimp only
-      rw [tsub_le_tsub_iff_right, OrderEmbedding.le_iff_le, Nat.succ_le_succ_iff]
+      rw [Nat.sub_le_sub_iff_right, OrderEmbedding.le_iff_le, Nat.succ_le_succ_iff]
       rw [Nat.succ_le_iff, OrderEmbedding.lt_iff_lt]
       exact b.succ_pos
   have : ∀ ix, tl.get? ix = (l'.drop (f 0 + 1)).get? (f' ix) := by
     intro ix
-    rw [List.get?_drop, OrderEmbedding.coe_ofMapLEIff, add_tsub_cancel_of_le, ← hf, List.get?]
+    rw [List.get?_drop, OrderEmbedding.coe_ofMapLEIff, Nat.add_sub_cancel', ← hf, List.get?]
     rw [Nat.succ_le_iff, OrderEmbedding.lt_iff_lt]
     exact ix.succ_pos
   rw [← List.take_append_drop (f 0 + 1) l', ← List.singleton_append]

Search for [∀∃].*(_ and manually replace some occurrences with more readable versions. In case of ∀, the new expressions are defeq to the old ones. In case of ∃, they differ by exists_prop.

In some rare cases, golf proofs that needed fixing.

@@ -173,7 +173,7 @@ theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
   rw [sublist_iff_exists_orderEmbedding_get?_eq]
   constructor
   · rintro ⟨f, hf⟩
-    have h : ∀ {i : ℕ} (_ : i < l.length), f i < l'.length := by
+    have h : ∀ {i : ℕ}, i < l.length → f i < l'.length := by
       intro i hi
       specialize hf i
       rw [get?_eq_get hi, eq_comm, get?_eq_some] at hf

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

@@ -129,7 +129,7 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
       exact b.succ_pos
   have : ∀ ix, tl.get? ix = (l'.drop (f 0 + 1)).get? (f' ix) := by
     intro ix
-    rw [List.get?_drop, OrderEmbedding.coe_ofMapLEIff, add_tsub_cancel_of_le, ←hf, List.get?]
+    rw [List.get?_drop, OrderEmbedding.coe_ofMapLEIff, add_tsub_cancel_of_le, ← hf, List.get?]
     rw [Nat.succ_le_iff, OrderEmbedding.lt_iff_lt]
     exact ix.succ_pos
   rw [← List.take_append_drop (f 0 + 1) l', ← List.singleton_append]

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

This has nice performance benefits.

@@ -31,7 +31,7 @@ Given a list `l`,
 
 namespace List
 
-variable {α : Type _}
+variable {α : Type*}
 
 namespace Nodup
 

• depends on: #5966

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

@@ -2,16 +2,13 @@
 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 data.list.nodup_equiv_fin
-! leanprover-community/mathlib commit 008205aa645b3f194c1da47025c5f110c8406eab
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fin.Basic
 import Mathlib.Data.List.Sort
 import Mathlib.Data.List.Duplicate
 
+#align_import data.list.nodup_equiv_fin from "leanprover-community/mathlib"@"008205aa645b3f194c1da47025c5f110c8406eab"
+
 /-!
 # Equivalence between `Fin (length l)` and elements of a list
 

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -176,8 +176,7 @@ theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
   rw [sublist_iff_exists_orderEmbedding_get?_eq]
   constructor
   · rintro ⟨f, hf⟩
-    have h : ∀ {i : ℕ} (_ : i < l.length), f i < l'.length :=
-      by
+    have h : ∀ {i : ℕ} (_ : i < l.length), f i < l'.length := by
       intro i hi
       specialize hf i
       rw [get?_eq_get hi, eq_comm, get?_eq_some] at hf

This PR fixes two things:

• Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
• All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

@@ -208,9 +208,7 @@ theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
       · rw [get?_eq_none.mpr, get?_eq_none.mpr]
         · simp
         · simpa using hi
-#align
-  list.sublist_iff_exists_fin_order_embedding_nth_le_eq
-  List.sublist_iff_exists_fin_orderEmbedding_get_eq
+#align list.sublist_iff_exists_fin_order_embedding_nth_le_eq List.sublist_iff_exists_fin_orderEmbedding_get_eq
 
 /-- An element `x : α` of `l : List α` is a duplicate iff it can be found
 at two distinct indices `n m : ℕ` inside the list `l`.

@@ -125,14 +125,14 @@ theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
   rw [eq_comm, List.get?_eq_some] at this
   obtain ⟨w, h⟩ := this
   let f' : ℕ ↪o ℕ :=
-    OrderEmbedding.ofMapLeIff (fun i => f (i + 1) - (f 0 + 1)) fun a b => by
+    OrderEmbedding.ofMapLEIff (fun i => f (i + 1) - (f 0 + 1)) fun a b => by
       dsimp only
       rw [tsub_le_tsub_iff_right, OrderEmbedding.le_iff_le, Nat.succ_le_succ_iff]
       rw [Nat.succ_le_iff, OrderEmbedding.lt_iff_lt]
       exact b.succ_pos
   have : ∀ ix, tl.get? ix = (l'.drop (f 0 + 1)).get? (f' ix) := by
     intro ix
-    rw [List.get?_drop, OrderEmbedding.coe_ofMapLeIff, add_tsub_cancel_of_le, ←hf, List.get?]
+    rw [List.get?_drop, OrderEmbedding.coe_ofMapLEIff, add_tsub_cancel_of_le, ←hf, List.get?]
     rw [Nat.succ_le_iff, OrderEmbedding.lt_iff_lt]
     exact ix.succ_pos
   rw [← List.take_append_drop (f 0 + 1) l', ← List.singleton_append]
@@ -156,7 +156,7 @@ theorem sublist_iff_exists_orderEmbedding_get?_eq {l l' : List α} :
       simpa using hf
     · obtain ⟨f, hf⟩ := IH
       refine'
-        ⟨OrderEmbedding.ofMapLeIff (fun ix : ℕ => if ix = 0 then 0 else (f ix.pred).succ) _, _⟩
+        ⟨OrderEmbedding.ofMapLEIff (fun ix : ℕ => if ix = 0 then 0 else (f ix.pred).succ) _, _⟩
       · rintro ⟨_ | a⟩ ⟨_ | b⟩ <;> simp [Nat.succ_le_succ_iff]
       · rintro ⟨_ | i⟩
         · simp
@@ -183,7 +183,7 @@ theorem sublist_iff_exists_fin_orderEmbedding_get_eq {l l' : List α} :
       rw [get?_eq_get hi, eq_comm, get?_eq_some] at hf
       obtain ⟨h, -⟩ := hf
       exact h
-    refine' ⟨OrderEmbedding.ofMapLeIff (fun ix => ⟨f ix, h ix.is_lt⟩) _, _⟩
+    refine' ⟨OrderEmbedding.ofMapLEIff (fun ix => ⟨f ix, h ix.is_lt⟩) _, _⟩
     · simp
     · intro i
       apply Option.some_injective

I see no reason for these lemmas to be deprecated.

@@ -55,8 +55,7 @@ variable [DecidableEq α]
 /-- If `l` has no duplicates, then `List.get` defines an equivalence between `Fin (length l)` and
 the set of elements of `l`. -/
 @[simps]
-def getEquiv (l : List α) (H : Nodup l) : Fin (length l) ≃ { x // x ∈ l }
-    where
+def getEquiv (l : List α) (H : Nodup l) : Fin (length l) ≃ { x // x ∈ l } where
   toFun i := ⟨get l i, get_mem l i i.2⟩
   invFun x := ⟨indexOf (↑x) l, indexOf_lt_length.2 x.2⟩
   left_inv i := by simp only [List.get_indexOf, eq_self_iff_true, Fin.eta, Subtype.coe_mk, H]
@@ -83,24 +82,19 @@ namespace Sorted
 
 variable [Preorder α] {l : List α}
 
-@[deprecated]
-theorem get_mono (h : l.Sorted (· ≤ ·)) : Monotone l.get :=
-  fun _ _ => h.rel_nthLe_of_le _ _
+theorem get_mono (h : l.Sorted (· ≤ ·)) : Monotone l.get := fun _ _ => h.rel_get_of_le
 #align list.sorted.nth_le_mono List.Sorted.get_mono
 
-@[deprecated]
-theorem get_strictMono (h : l.Sorted (· < ·)) :
-    StrictMono l.get := fun _ _ => h.rel_nthLe_of_lt _ _
+theorem get_strictMono (h : l.Sorted (· < ·)) : StrictMono l.get := fun _ _ => h.rel_get_of_lt
 #align list.sorted.nth_le_strict_mono List.Sorted.get_strictMono
 
 variable [DecidableEq α]
 
 /-- If `l` is a list sorted w.r.t. `(<)`, then `List.get` defines an order isomorphism between
 `Fin (length l)` and the set of elements of `l`. -/
-def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x ∈ l }
-    where
+def getIso (l : List α) (H : Sorted (· < ·) l) : Fin (length l) ≃o { x // x ∈ l } where
   toEquiv := H.nodup.getEquiv l
-  map_rel_iff' {_ _} := H.get_strictMono.le_iff_le
+  map_rel_iff' := H.get_strictMono.le_iff_le
 #align list.sorted.nth_le_iso List.Sorted.getIso
 
 variable (H : Sorted (· < ·) l) {x : { x // x ∈ l }} {i : Fin l.length}

Co-authored-by: Lukas Miaskiwskyi <lukas.mias@gmail.com> Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com>