algebra.tropical.basic ⟷ Mathlib.Algebra.Tropical.Basic

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

@@ -5,7 +5,7 @@ Authors: Yakov Pechersky
 -/
 import Algebra.GroupPower.Order
 import Algebra.Order.Monoid.WithTop
-import Algebra.SmulWithZero
+import Algebra.SMulWithZero
 import Algebra.Order.Monoid.MinMax
 
 #align_import algebra.tropical.basic from "leanprover-community/mathlib"@"00f4ab49e7d5139216e0b3daad15fffa504897ab"
@@ -600,7 +600,7 @@ instance [AddMonoid R] : Monoid (Tropical R) :=
     Tropical.semigroup with
     npow := fun n x => x ^ n
     npow_zero := fun _ => untrop_injective <| zero_smul _ _
-    npow_succ := fun _ _ => untrop_injective <| succ_nsmul _ _ }
+    npow_succ := fun _ _ => untrop_injective <| succ_nsmul' _ _ }
 
 #print Tropical.trop_nsmul /-
 @[simp]

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

@@ -697,8 +697,8 @@ theorem add_pow [LinearOrder R] [AddMonoid R] [CovariantClass R R (· + ·) (·
     [CovariantClass R R (Function.swap (· + ·)) (· ≤ ·)] (x y : Tropical R) (n : ℕ) :
     (x + y) ^ n = x ^ n + y ^ n := by
   cases' le_total x y with h h
-  · rw [add_eq_left h, add_eq_left (pow_le_pow_of_le_left' h _)]
-  · rw [add_eq_right h, add_eq_right (pow_le_pow_of_le_left' h _)]
+  · rw [add_eq_left h, add_eq_left (pow_le_pow_left' h _)]
+  · rw [add_eq_right h, add_eq_right (pow_le_pow_left' h _)]
 #align tropical.add_pow Tropical.add_pow
 -/
 

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

@@ -3,10 +3,10 @@ Copyright (c) 2021 Yakov Pechersky. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yakov Pechersky
 -/
-import Mathbin.Algebra.GroupPower.Order
-import Mathbin.Algebra.Order.Monoid.WithTop
-import Mathbin.Algebra.SmulWithZero
-import Mathbin.Algebra.Order.Monoid.MinMax
+import Algebra.GroupPower.Order
+import Algebra.Order.Monoid.WithTop
+import Algebra.SmulWithZero
+import Algebra.Order.Monoid.MinMax
 
 #align_import algebra.tropical.basic from "leanprover-community/mathlib"@"00f4ab49e7d5139216e0b3daad15fffa504897ab"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -615,7 +615,7 @@ instance [AddCommMonoid R] : CommMonoid (Tropical R) :=
 instance [AddGroup R] : Group (Tropical R) :=
   { Tropical.monoid with
     inv := Inv.inv
-    mul_left_inv := fun _ => untrop_injective <| add_left_neg _
+    hMul_left_inv := fun _ => untrop_injective <| add_left_neg _
     zpow := fun n x => trop <| n • untrop x
     zpow_zero' := fun _ => untrop_injective <| zero_zsmul _
     zpow_succ' := fun _ _ => untrop_injective <| AddGroup.zsmul_succ' _ _

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

@@ -2,17 +2,14 @@
 Copyright (c) 2021 Yakov Pechersky. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yakov Pechersky
-
-! This file was ported from Lean 3 source module algebra.tropical.basic
-! leanprover-community/mathlib commit 00f4ab49e7d5139216e0b3daad15fffa504897ab
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.GroupPower.Order
 import Mathbin.Algebra.Order.Monoid.WithTop
 import Mathbin.Algebra.SmulWithZero
 import Mathbin.Algebra.Order.Monoid.MinMax
 
+#align_import algebra.tropical.basic from "leanprover-community/mathlib"@"00f4ab49e7d5139216e0b3daad15fffa504897ab"
+
 /-!
 
 # Tropical algebraic structures

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

@@ -376,12 +376,12 @@ instance : LinearOrder (Tropical R) :=
     DecidableEq := Tropical.decidableEq
     max := fun a b => trop (max (untrop a) (untrop b))
     max_def := by
-      ext (x y)
+      ext x y
       rw [maxDefault, max_def, apply_ite trop, trop_untrop, trop_untrop,
         if_congr untrop_le_iff rfl rfl]
     min := (· + ·)
     min_def := by
-      ext (x y)
+      ext x y
       rw [trop_add_def, minDefault, min_def, apply_ite trop, trop_untrop, trop_untrop,
         if_congr untrop_le_iff rfl rfl] }
 

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

@@ -257,21 +257,29 @@ def tropOrderIso [Preorder R] : R ≃o Tropical R :=
 #align tropical.trop_order_iso Tropical.tropOrderIso
 -/
 
+#print Tropical.tropOrderIso_coe_fn /-
 @[simp]
 theorem tropOrderIso_coe_fn [Preorder R] : (tropOrderIso : R → Tropical R) = trop :=
   rfl
 #align tropical.trop_order_iso_coe_fn Tropical.tropOrderIso_coe_fn
+-/
 
+#print Tropical.tropOrderIso_symm_coe_fn /-
 @[simp]
 theorem tropOrderIso_symm_coe_fn [Preorder R] : (tropOrderIso.symm : Tropical R → R) = untrop :=
   rfl
 #align tropical.trop_order_iso_symm_coe_fn Tropical.tropOrderIso_symm_coe_fn
+-/
 
+#print Tropical.trop_monotone /-
 theorem trop_monotone [Preorder R] : Monotone (trop : R → Tropical R) := fun _ _ => id
 #align tropical.trop_monotone Tropical.trop_monotone
+-/
 
+#print Tropical.untrop_monotone /-
 theorem untrop_monotone [Preorder R] : Monotone (untrop : Tropical R → R) := fun _ _ => id
 #align tropical.untrop_monotone Tropical.untrop_monotone
+-/
 
 instance [PartialOrder R] : PartialOrder (Tropical R) :=
   { Tropical.preorder with le_antisymm := fun _ _ h h' => untrop_injective (le_antisymm h h') }
@@ -310,10 +318,12 @@ theorem zero_ne_trop_coe (x : R) : (0 : Tropical (WithTop R)) ≠ trop x :=
 #align tropical.zero_ne_trop_coe Tropical.zero_ne_trop_coe
 -/
 
+#print Tropical.le_zero /-
 @[simp]
 theorem le_zero [LE R] [OrderTop R] (x : Tropical R) : x ≤ 0 :=
   le_top
 #align tropical.le_zero Tropical.le_zero
+-/
 
 instance [LE R] [OrderTop R] : OrderTop (Tropical R) :=
   { Tropical.hasTop with le_top := fun _ => le_top }
@@ -330,24 +340,32 @@ instance : AddCommSemigroup (Tropical R)
   add_assoc _ _ _ := untrop_injective (min_assoc _ _ _)
   add_comm _ _ := untrop_injective (min_comm _ _)
 
+#print Tropical.untrop_add /-
 @[simp]
 theorem untrop_add (x y : Tropical R) : untrop (x + y) = min (untrop x) (untrop y) :=
   rfl
 #align tropical.untrop_add Tropical.untrop_add
+-/
 
+#print Tropical.trop_min /-
 @[simp]
 theorem trop_min (x y : R) : trop (min x y) = trop x + trop y :=
   rfl
 #align tropical.trop_min Tropical.trop_min
+-/
 
+#print Tropical.trop_inf /-
 @[simp]
 theorem trop_inf (x y : R) : trop (x ⊓ y) = trop x + trop y :=
   rfl
 #align tropical.trop_inf Tropical.trop_inf
+-/
 
+#print Tropical.trop_add_def /-
 theorem trop_add_def (x y : Tropical R) : x + y = trop (min (untrop x) (untrop y)) :=
   rfl
 #align tropical.trop_add_def Tropical.trop_add_def
+-/
 
 instance : LinearOrder (Tropical R) :=
   {
@@ -367,66 +385,93 @@ instance : LinearOrder (Tropical R) :=
       rw [trop_add_def, minDefault, min_def, apply_ite trop, trop_untrop, trop_untrop,
         if_congr untrop_le_iff rfl rfl] }
 
+#print Tropical.untrop_sup /-
 @[simp]
 theorem untrop_sup (x y : Tropical R) : untrop (x ⊔ y) = untrop x ⊔ untrop y :=
   rfl
 #align tropical.untrop_sup Tropical.untrop_sup
+-/
 
+#print Tropical.untrop_max /-
 @[simp]
 theorem untrop_max (x y : Tropical R) : untrop (max x y) = max (untrop x) (untrop y) :=
   rfl
 #align tropical.untrop_max Tropical.untrop_max
+-/
 
+#print Tropical.min_eq_add /-
 @[simp]
 theorem min_eq_add : (min : Tropical R → Tropical R → Tropical R) = (· + ·) :=
   rfl
 #align tropical.min_eq_add Tropical.min_eq_add
+-/
 
+#print Tropical.inf_eq_add /-
 @[simp]
 theorem inf_eq_add : ((· ⊓ ·) : Tropical R → Tropical R → Tropical R) = (· + ·) :=
   rfl
 #align tropical.inf_eq_add Tropical.inf_eq_add
+-/
 
+#print Tropical.trop_max_def /-
 theorem trop_max_def (x y : Tropical R) : max x y = trop (max (untrop x) (untrop y)) :=
   rfl
 #align tropical.trop_max_def Tropical.trop_max_def
+-/
 
+#print Tropical.trop_sup_def /-
 theorem trop_sup_def (x y : Tropical R) : x ⊔ y = trop (untrop x ⊔ untrop y) :=
   rfl
 #align tropical.trop_sup_def Tropical.trop_sup_def
+-/
 
+#print Tropical.add_eq_left /-
 @[simp]
 theorem add_eq_left ⦃x y : Tropical R⦄ (h : x ≤ y) : x + y = x :=
   untrop_injective (by simpa using h)
 #align tropical.add_eq_left Tropical.add_eq_left
+-/
 
+#print Tropical.add_eq_right /-
 @[simp]
 theorem add_eq_right ⦃x y : Tropical R⦄ (h : y ≤ x) : x + y = y :=
   untrop_injective (by simpa using h)
 #align tropical.add_eq_right Tropical.add_eq_right
+-/
 
+#print Tropical.add_eq_left_iff /-
 theorem add_eq_left_iff {x y : Tropical R} : x + y = x ↔ x ≤ y := by
   rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_left_iff]
 #align tropical.add_eq_left_iff Tropical.add_eq_left_iff
+-/
 
+#print Tropical.add_eq_right_iff /-
 theorem add_eq_right_iff {x y : Tropical R} : x + y = y ↔ y ≤ x := by
   rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_right_iff]
 #align tropical.add_eq_right_iff Tropical.add_eq_right_iff
+-/
 
+#print Tropical.add_self /-
 @[simp]
 theorem add_self (x : Tropical R) : x + x = x :=
   untrop_injective (min_eq_right le_rfl)
 #align tropical.add_self Tropical.add_self
+-/
 
+#print Tropical.bit0 /-
 @[simp]
 theorem bit0 (x : Tropical R) : bit0 x = x :=
   add_self x
 #align tropical.bit0 Tropical.bit0
+-/
 
+#print Tropical.add_eq_iff /-
 theorem add_eq_iff {x y z : Tropical R} : x + y = z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x := by
   rw [trop_add_def, trop_eq_iff_eq_untrop]; simp [min_eq_iff]
 #align tropical.add_eq_iff Tropical.add_eq_iff
+-/
 
+#print Tropical.add_eq_zero_iff /-
 @[simp]
 theorem add_eq_zero_iff {a b : Tropical (WithTop R)} : a + b = 0 ↔ a = 0 ∧ b = 0 :=
   by
@@ -438,6 +483,7 @@ theorem add_eq_zero_iff {a b : Tropical (WithTop R)} : a + b = 0 ↔ a = 0 ∧ b
   · rintro ⟨rfl, rfl⟩
     simp
 #align tropical.add_eq_zero_iff Tropical.add_eq_zero_iff
+-/
 
 instance [OrderTop R] : AddCommMonoid (Tropical R) :=
   { Tropical.hasZero,
@@ -530,16 +576,20 @@ instance [AddCommSemigroup R] : CommSemigroup (Tropical R) :=
 
 instance {α : Type _} [SMul α R] : Pow (Tropical R) α where pow x n := trop <| n • untrop x
 
+#print Tropical.untrop_pow /-
 @[simp]
 theorem untrop_pow {α : Type _} [SMul α R] (x : Tropical R) (n : α) :
     untrop (x ^ n) = n • untrop x :=
   rfl
 #align tropical.untrop_pow Tropical.untrop_pow
+-/
 
+#print Tropical.trop_smul /-
 @[simp]
 theorem trop_smul {α : Type _} [SMul α R] (x : R) (n : α) : trop (n • x) = trop x ^ n :=
   rfl
 #align tropical.trop_smul Tropical.trop_smul
+-/
 
 instance [AddZeroClass R] : MulOneClass (Tropical R)
     where
@@ -609,6 +659,7 @@ instance covariant_swap_mul [LE R] [Add R] [CovariantClass R R (Function.swap (
 #align tropical.covariant_swap_mul Tropical.covariant_swap_mul
 -/
 
+#print Tropical.covariant_add /-
 instance covariant_add [LinearOrder R] : CovariantClass (Tropical R) (Tropical R) (· + ·) (· ≤ ·) :=
   ⟨fun x y z h => by
     cases' le_total x y with hx hy
@@ -618,6 +669,7 @@ instance covariant_add [LinearOrder R] : CovariantClass (Tropical R) (Tropical R
       · rwa [add_eq_left hx]
       · rwa [add_eq_right hx]⟩
 #align tropical.covariant_add Tropical.covariant_add
+-/
 
 #print Tropical.covariant_mul_lt /-
 instance covariant_mul_lt [LT R] [Add R] [CovariantClass R R (· + ·) (· < ·)] :
@@ -642,6 +694,7 @@ instance [LinearOrder R] [Add R] [CovariantClass R R (· + ·) (· ≤ ·)]
   left_distrib _ _ _ := untrop_injective (min_add_add_left _ _ _).symm
   right_distrib _ _ _ := untrop_injective (min_add_add_right _ _ _).symm
 
+#print Tropical.add_pow /-
 @[simp]
 theorem add_pow [LinearOrder R] [AddMonoid R] [CovariantClass R R (· + ·) (· ≤ ·)]
     [CovariantClass R R (Function.swap (· + ·)) (· ≤ ·)] (x y : Tropical R) (n : ℕ) :
@@ -650,6 +703,7 @@ theorem add_pow [LinearOrder R] [AddMonoid R] [CovariantClass R R (· + ·) (·
   · rw [add_eq_left h, add_eq_left (pow_le_pow_of_le_left' h _)]
   · rw [add_eq_right h, add_eq_right (pow_le_pow_of_le_left' h _)]
 #align tropical.add_pow Tropical.add_pow
+-/
 
 end Distrib
 
@@ -663,6 +717,7 @@ instance : CommSemiring (Tropical R) :=
     zero_mul := fun _ => untrop_injective (top_add _)
     mul_zero := fun _ => untrop_injective (add_top _) }
 
+#print Tropical.succ_nsmul /-
 @[simp]
 theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) : (n + 1) • x = x :=
   by
@@ -670,7 +725,9 @@ theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) :
   · simp
   · rw [add_nsmul, IH, one_nsmul, add_self]
 #align tropical.succ_nsmul Tropical.succ_nsmul
+-/
 
+#print Tropical.mul_eq_zero_iff /-
 -- TODO: find/create the right classes to make this hold (for enat, ennreal, etc)
 -- Requires `zero_eq_bot` to be true
 -- lemma add_eq_zero_iff {a b : tropical R} :
@@ -679,6 +736,7 @@ theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) :
 theorem mul_eq_zero_iff {R : Type _} [LinearOrderedAddCommMonoid R] {a b : Tropical (WithTop R)} :
     a * b = 0 ↔ a = 0 ∨ b = 0 := by simp [← untrop_inj_iff, WithTop.add_eq_top]
 #align tropical.mul_eq_zero_iff Tropical.mul_eq_zero_iff
+-/
 
 instance {R : Type _} [LinearOrderedAddCommMonoid R] : NoZeroDivisors (Tropical (WithTop R)) :=
   ⟨fun _ _ => mul_eq_zero_iff.mp⟩

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

@@ -250,10 +250,12 @@ instance [Preorder R] : Preorder (Tropical R) :=
     le_trans := fun _ _ _ h h' => le_trans h h'
     lt_iff_le_not_le := fun _ _ => lt_iff_le_not_le }
 
+#print Tropical.tropOrderIso /-
 /-- Reinterpret `x : R` as an element of `tropical R`, preserving the order. -/
 def tropOrderIso [Preorder R] : R ≃o Tropical R :=
   { tropEquiv with map_rel_iff' := fun _ _ => untrop_le_iff }
 #align tropical.trop_order_iso Tropical.tropOrderIso
+-/
 
 @[simp]
 theorem tropOrderIso_coe_fn [Preorder R] : (tropOrderIso : R → Tropical R) = trop :=
@@ -624,11 +626,13 @@ instance covariant_mul_lt [LT R] [Add R] [CovariantClass R R (· + ·) (· < ·)
 #align tropical.covariant_mul_lt Tropical.covariant_mul_lt
 -/
 
+#print Tropical.covariant_swap_mul_lt /-
 instance covariant_swap_mul_lt [Preorder R] [Add R]
     [CovariantClass R R (Function.swap (· + ·)) (· < ·)] :
     CovariantClass (Tropical R) (Tropical R) (Function.swap (· * ·)) (· < ·) :=
   ⟨fun x y z h => add_lt_add_right h _⟩
 #align tropical.covariant_swap_mul_lt Tropical.covariant_swap_mul_lt
+-/
 
 instance [LinearOrder R] [Add R] [CovariantClass R R (· + ·) (· ≤ ·)]
     [CovariantClass R R (Function.swap (· + ·)) (· ≤ ·)] : Distrib (Tropical R)

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

@@ -250,54 +250,24 @@ instance [Preorder R] : Preorder (Tropical R) :=
     le_trans := fun _ _ _ h h' => le_trans h h'
     lt_iff_le_not_le := fun _ _ => lt_iff_le_not_le }
 
-/- warning: tropical.trop_order_iso -> Tropical.tropOrderIso is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1))
-Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso Tropical.tropOrderIsoₓ'. -/
 /-- Reinterpret `x : R` as an element of `tropical R`, preserving the order. -/
 def tropOrderIso [Preorder R] : R ≃o Tropical R :=
   { tropEquiv with map_rel_iff' := fun _ _ => untrop_le_iff }
 #align tropical.trop_order_iso Tropical.tropOrderIso
 
-/- warning: tropical.trop_order_iso_coe_fn -> Tropical.tropOrderIso_coe_fn is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (Tropical.tropOrderIso.{u1} R _inst_1)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (RelIso.hasCoeToFun.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} (R -> (Tropical.{u1} R)) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) R (fun (_x : R) => Tropical.{u1} R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
-Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso_coe_fn Tropical.tropOrderIso_coe_fnₓ'. -/
 @[simp]
 theorem tropOrderIso_coe_fn [Preorder R] : (tropOrderIso : R → Tropical R) = trop :=
   rfl
 #align tropical.trop_order_iso_coe_fn Tropical.tropOrderIso_coe_fn
 
-/- warning: tropical.trop_order_iso_symm_coe_fn -> Tropical.tropOrderIso_symm_coe_fn is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Tropical.{u1} R) R (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Preorder.toHasLe.{u1} R _inst_1)) (fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (RelIso.hasCoeToFun.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> R) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Tropical.{u1} R) (fun (_x : Tropical.{u1} R) => R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
-Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso_symm_coe_fn Tropical.tropOrderIso_symm_coe_fnₓ'. -/
 @[simp]
 theorem tropOrderIso_symm_coe_fn [Preorder R] : (tropOrderIso.symm : Tropical R → R) = untrop :=
   rfl
 #align tropical.trop_order_iso_symm_coe_fn Tropical.tropOrderIso_symm_coe_fn
 
-/- warning: tropical.trop_monotone -> Tropical.trop_monotone is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Monotone.{u1, u1} R (Tropical.{u1} R) _inst_1 (Tropical.preorder.{u1} R _inst_1) (Tropical.trop.{u1} R)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Monotone.{u1, u1} R (Tropical.{u1} R) _inst_1 (Tropical.instPreorderTropical.{u1} R _inst_1) (Tropical.trop.{u1} R)
-Case conversion may be inaccurate. Consider using '#align tropical.trop_monotone Tropical.trop_monotoneₓ'. -/
 theorem trop_monotone [Preorder R] : Monotone (trop : R → Tropical R) := fun _ _ => id
 #align tropical.trop_monotone Tropical.trop_monotone
 
-/- warning: tropical.untrop_monotone -> Tropical.untrop_monotone is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Monotone.{u1, u1} (Tropical.{u1} R) R (Tropical.preorder.{u1} R _inst_1) _inst_1 (Tropical.untrop.{u1} R)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Monotone.{u1, u1} (Tropical.{u1} R) R (Tropical.instPreorderTropical.{u1} R _inst_1) _inst_1 (Tropical.untrop.{u1} R)
-Case conversion may be inaccurate. Consider using '#align tropical.untrop_monotone Tropical.untrop_monotoneₓ'. -/
 theorem untrop_monotone [Preorder R] : Monotone (untrop : Tropical R → R) := fun _ _ => id
 #align tropical.untrop_monotone Tropical.untrop_monotone
 
@@ -338,12 +308,6 @@ theorem zero_ne_trop_coe (x : R) : (0 : Tropical (WithTop R)) ≠ trop x :=
 #align tropical.zero_ne_trop_coe Tropical.zero_ne_trop_coe
 -/
 
-/- warning: tropical.le_zero -> Tropical.le_zero is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LE.{u1} R] [_inst_2 : OrderTop.{u1} R _inst_1] (x : Tropical.{u1} R), LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R _inst_1) x (OfNat.ofNat.{u1} (Tropical.{u1} R) 0 (OfNat.mk.{u1} (Tropical.{u1} R) 0 (Zero.zero.{u1} (Tropical.{u1} R) (Tropical.hasZero.{u1} R (OrderTop.toHasTop.{u1} R _inst_1 _inst_2)))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LE.{u1} R] [_inst_2 : OrderTop.{u1} R _inst_1] (x : Tropical.{u1} R), LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R _inst_1) x (OfNat.ofNat.{u1} (Tropical.{u1} R) 0 (Zero.toOfNat0.{u1} (Tropical.{u1} R) (Tropical.instZeroTropical.{u1} R (OrderTop.toTop.{u1} R _inst_1 _inst_2))))
-Case conversion may be inaccurate. Consider using '#align tropical.le_zero Tropical.le_zeroₓ'. -/
 @[simp]
 theorem le_zero [LE R] [OrderTop R] (x : Tropical R) : x ≤ 0 :=
   le_top
@@ -364,45 +328,21 @@ instance : AddCommSemigroup (Tropical R)
   add_assoc _ _ _ := untrop_injective (min_assoc _ _ _)
   add_comm _ _ := untrop_injective (min_comm _ _)
 
-/- warning: tropical.untrop_add -> Tropical.untrop_add is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y)) (LinearOrder.min.{u1} R _inst_1 (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y)) (Min.min.{u1} R (LinearOrder.toMin.{u1} R _inst_1) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
-Case conversion may be inaccurate. Consider using '#align tropical.untrop_add Tropical.untrop_addₓ'. -/
 @[simp]
 theorem untrop_add (x y : Tropical R) : untrop (x + y) = min (untrop x) (untrop y) :=
   rfl
 #align tropical.untrop_add Tropical.untrop_add
 
-/- warning: tropical.trop_min -> Tropical.trop_min is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : R) (y : R), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (LinearOrder.min.{u1} R _inst_1 x y)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (Tropical.trop.{u1} R x) (Tropical.trop.{u1} R y))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : R) (y : R), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (Min.min.{u1} R (LinearOrder.toMin.{u1} R _inst_1) x y)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (Tropical.trop.{u1} R x) (Tropical.trop.{u1} R y))
-Case conversion may be inaccurate. Consider using '#align tropical.trop_min Tropical.trop_minₓ'. -/
 @[simp]
 theorem trop_min (x y : R) : trop (min x y) = trop x + trop y :=
   rfl
 #align tropical.trop_min Tropical.trop_min
 
-/- warning: tropical.trop_inf -> Tropical.trop_inf is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : R) (y : R), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (Inf.inf.{u1} R (SemilatticeInf.toHasInf.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) x y)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (Tropical.trop.{u1} R x) (Tropical.trop.{u1} R y))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : R) (y : R), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (Inf.inf.{u1} R (Lattice.toInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))) x y)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (Tropical.trop.{u1} R x) (Tropical.trop.{u1} R y))
-Case conversion may be inaccurate. Consider using '#align tropical.trop_inf Tropical.trop_infₓ'. -/
 @[simp]
 theorem trop_inf (x y : R) : trop (x ⊓ y) = trop x + trop y :=
   rfl
 #align tropical.trop_inf Tropical.trop_inf
 
-/- warning: tropical.trop_add_def -> Tropical.trop_add_def is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) (Tropical.trop.{u1} R (LinearOrder.min.{u1} R _inst_1 (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) (Tropical.trop.{u1} R (Min.min.{u1} R (LinearOrder.toMin.{u1} R _inst_1) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
-Case conversion may be inaccurate. Consider using '#align tropical.trop_add_def Tropical.trop_add_defₓ'. -/
 theorem trop_add_def (x y : Tropical R) : x + y = trop (min (untrop x) (untrop y)) :=
   rfl
 #align tropical.trop_add_def Tropical.trop_add_def
@@ -425,150 +365,66 @@ instance : LinearOrder (Tropical R) :=
       rw [trop_add_def, minDefault, min_def, apply_ite trop, trop_untrop, trop_untrop,
         if_congr untrop_le_iff rfl rfl] }
 
-/- warning: tropical.untrop_sup -> Tropical.untrop_sup is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (Sup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toHasSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)))) x y)) (Sup.sup.{u1} R (SemilatticeSup.toHasSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (Sup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))))) x y)) (Sup.sup.{u1} R (SemilatticeSup.toSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
-Case conversion may be inaccurate. Consider using '#align tropical.untrop_sup Tropical.untrop_supₓ'. -/
 @[simp]
 theorem untrop_sup (x y : Tropical R) : untrop (x ⊔ y) = untrop x ⊔ untrop y :=
   rfl
 #align tropical.untrop_sup Tropical.untrop_sup
 
-/- warning: tropical.untrop_max -> Tropical.untrop_max is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (LinearOrder.max.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1) x y)) (LinearOrder.max.{u1} R _inst_1 (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (Max.max.{u1} (Tropical.{u1} R) (LinearOrder.toMax.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)) x y)) (Max.max.{u1} R (LinearOrder.toMax.{u1} R _inst_1) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
-Case conversion may be inaccurate. Consider using '#align tropical.untrop_max Tropical.untrop_maxₓ'. -/
 @[simp]
 theorem untrop_max (x y : Tropical R) : untrop (max x y) = max (untrop x) (untrop y) :=
   rfl
 #align tropical.untrop_max Tropical.untrop_max
 
-/- warning: tropical.min_eq_add -> Tropical.min_eq_add is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (LinearOrder.min.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Min.min.{u1} (Tropical.{u1} R) (LinearOrder.toMin.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1534 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1536 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1534 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1536)
-Case conversion may be inaccurate. Consider using '#align tropical.min_eq_add Tropical.min_eq_addₓ'. -/
 @[simp]
 theorem min_eq_add : (min : Tropical R → Tropical R → Tropical R) = (· + ·) :=
   rfl
 #align tropical.min_eq_add Tropical.min_eq_add
 
-/- warning: tropical.inf_eq_add -> Tropical.inf_eq_add is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Inf.inf.{u1} (Tropical.{u1} R) (SemilatticeInf.toHasInf.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeInf.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1))))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1570 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1572 : Tropical.{u1} R) => Inf.inf.{u1} (Tropical.{u1} R) (Lattice.toInf.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1570 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1572) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1585 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1587 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1585 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1587)
-Case conversion may be inaccurate. Consider using '#align tropical.inf_eq_add Tropical.inf_eq_addₓ'. -/
 @[simp]
 theorem inf_eq_add : ((· ⊓ ·) : Tropical R → Tropical R → Tropical R) = (· + ·) :=
   rfl
 #align tropical.inf_eq_add Tropical.inf_eq_add
 
-/- warning: tropical.trop_max_def -> Tropical.trop_max_def is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (LinearOrder.max.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1) x y) (Tropical.trop.{u1} R (LinearOrder.max.{u1} R _inst_1 (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (Max.max.{u1} (Tropical.{u1} R) (LinearOrder.toMax.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)) x y) (Tropical.trop.{u1} R (Max.max.{u1} R (LinearOrder.toMax.{u1} R _inst_1) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
-Case conversion may be inaccurate. Consider using '#align tropical.trop_max_def Tropical.trop_max_defₓ'. -/
 theorem trop_max_def (x y : Tropical R) : max x y = trop (max (untrop x) (untrop y)) :=
   rfl
 #align tropical.trop_max_def Tropical.trop_max_def
 
-/- warning: tropical.trop_sup_def -> Tropical.trop_sup_def is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (Sup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toHasSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)))) x y) (Tropical.trop.{u1} R (Sup.sup.{u1} R (SemilatticeSup.toHasSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (Sup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))))) x y) (Tropical.trop.{u1} R (Sup.sup.{u1} R (SemilatticeSup.toSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
-Case conversion may be inaccurate. Consider using '#align tropical.trop_sup_def Tropical.trop_sup_defₓ'. -/
 theorem trop_sup_def (x y : Tropical R) : x ⊔ y = trop (untrop x ⊔ untrop y) :=
   rfl
 #align tropical.trop_sup_def Tropical.trop_sup_def
 
-/- warning: tropical.add_eq_left -> Tropical.add_eq_left is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) x)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x y) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) x)
-Case conversion may be inaccurate. Consider using '#align tropical.add_eq_left Tropical.add_eq_leftₓ'. -/
 @[simp]
 theorem add_eq_left ⦃x y : Tropical R⦄ (h : x ≤ y) : x + y = x :=
   untrop_injective (by simpa using h)
 #align tropical.add_eq_left Tropical.add_eq_left
 
-/- warning: tropical.add_eq_right -> Tropical.add_eq_right is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) y)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) y x) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) y)
-Case conversion may be inaccurate. Consider using '#align tropical.add_eq_right Tropical.add_eq_rightₓ'. -/
 @[simp]
 theorem add_eq_right ⦃x y : Tropical R⦄ (h : y ≤ x) : x + y = y :=
   untrop_injective (by simpa using h)
 #align tropical.add_eq_right Tropical.add_eq_right
 
-/- warning: tropical.add_eq_left_iff -> Tropical.add_eq_left_iff is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) x) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) x) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x y)
-Case conversion may be inaccurate. Consider using '#align tropical.add_eq_left_iff Tropical.add_eq_left_iffₓ'. -/
 theorem add_eq_left_iff {x y : Tropical R} : x + y = x ↔ x ≤ y := by
   rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_left_iff]
 #align tropical.add_eq_left_iff Tropical.add_eq_left_iff
 
-/- warning: tropical.add_eq_right_iff -> Tropical.add_eq_right_iff is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) y) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) y) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) y x)
-Case conversion may be inaccurate. Consider using '#align tropical.add_eq_right_iff Tropical.add_eq_right_iffₓ'. -/
 theorem add_eq_right_iff {x y : Tropical R} : x + y = y ↔ y ≤ x := by
   rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_right_iff]
 #align tropical.add_eq_right_iff Tropical.add_eq_right_iff
 
-/- warning: tropical.add_self -> Tropical.add_self is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x x) x
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x x) x
-Case conversion may be inaccurate. Consider using '#align tropical.add_self Tropical.add_selfₓ'. -/
 @[simp]
 theorem add_self (x : Tropical R) : x + x = x :=
   untrop_injective (min_eq_right le_rfl)
 #align tropical.add_self Tropical.add_self
 
-/- warning: tropical.bit0 -> Tropical.bit0 is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (bit0.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1) x) x
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (bit0.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1) x) x
-Case conversion may be inaccurate. Consider using '#align tropical.bit0 Tropical.bit0ₓ'. -/
 @[simp]
 theorem bit0 (x : Tropical R) : bit0 x = x :=
   add_self x
 #align tropical.bit0 Tropical.bit0
 
-/- warning: tropical.add_eq_iff -> Tropical.add_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R} {z : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) z) (Or (And (Eq.{succ u1} (Tropical.{u1} R) x z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y)) (And (Eq.{succ u1} (Tropical.{u1} R) y z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R} {z : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) z) (Or (And (Eq.{succ u1} (Tropical.{u1} R) x z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x y)) (And (Eq.{succ u1} (Tropical.{u1} R) y z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) y x)))
-Case conversion may be inaccurate. Consider using '#align tropical.add_eq_iff Tropical.add_eq_iffₓ'. -/
 theorem add_eq_iff {x y z : Tropical R} : x + y = z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x := by
   rw [trop_add_def, trop_eq_iff_eq_untrop]; simp [min_eq_iff]
 #align tropical.add_eq_iff Tropical.add_eq_iff
 
-/- warning: tropical.add_eq_zero_iff -> Tropical.add_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {a : Tropical.{u1} (WithTop.{u1} R)} {b : Tropical.{u1} (WithTop.{u1} R)}, Iff (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.{u1} (WithTop.{u1} R)) (Tropical.{u1} (WithTop.{u1} R)) (instHAdd.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.hasAdd.{u1} (WithTop.{u1} R) (WithTop.linearOrder.{u1} R _inst_1))) a b) (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (OfNat.mk.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.zero.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.hasZero.{u1} (WithTop.{u1} R) (WithTop.hasTop.{u1} R)))))) (And (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) a (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (OfNat.mk.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.zero.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.hasZero.{u1} (WithTop.{u1} R) (WithTop.hasTop.{u1} R)))))) (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) b (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (OfNat.mk.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.zero.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.hasZero.{u1} (WithTop.{u1} R) (WithTop.hasTop.{u1} R)))))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {a : Tropical.{u1} (WithTop.{u1} R)} {b : Tropical.{u1} (WithTop.{u1} R)}, Iff (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.{u1} (WithTop.{u1} R)) (Tropical.{u1} (WithTop.{u1} R)) (instHAdd.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.instAddTropical.{u1} (WithTop.{u1} R) (WithTop.linearOrder.{u1} R _inst_1))) a b) (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.toOfNat0.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.instZeroTropical.{u1} (WithTop.{u1} R) (WithTop.top.{u1} R))))) (And (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) a (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.toOfNat0.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.instZeroTropical.{u1} (WithTop.{u1} R) (WithTop.top.{u1} R))))) (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) b (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.toOfNat0.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.instZeroTropical.{u1} (WithTop.{u1} R) (WithTop.top.{u1} R))))))
-Case conversion may be inaccurate. Consider using '#align tropical.add_eq_zero_iff Tropical.add_eq_zero_iffₓ'. -/
 @[simp]
 theorem add_eq_zero_iff {a b : Tropical (WithTop R)} : a + b = 0 ↔ a = 0 ∧ b = 0 :=
   by
@@ -672,24 +528,12 @@ instance [AddCommSemigroup R] : CommSemigroup (Tropical R) :=
 
 instance {α : Type _} [SMul α R] : Pow (Tropical R) α where pow x n := trop <| n • untrop x
 
-/- warning: tropical.untrop_pow -> Tropical.untrop_pow is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {α : Type.{u2}} [_inst_1 : SMul.{u2, u1} α R] (x : Tropical.{u1} R) (n : α), Eq.{succ u1} R (Tropical.untrop.{u1} R (HPow.hPow.{u1, u2, u1} (Tropical.{u1} R) α (Tropical.{u1} R) (instHPow.{u1, u2} (Tropical.{u1} R) α (Tropical.hasPow.{u1, u2} R α _inst_1)) x n)) (SMul.smul.{u2, u1} α R _inst_1 n (Tropical.untrop.{u1} R x))
-but is expected to have type
-  forall {R : Type.{u2}} {α : Type.{u1}} [_inst_1 : SMul.{u1, u2} α R] (x : Tropical.{u2} R) (n : α), Eq.{succ u2} R (Tropical.untrop.{u2} R (HPow.hPow.{u2, u1, u2} (Tropical.{u2} R) α (Tropical.{u2} R) (instHPow.{u2, u1} (Tropical.{u2} R) α (Tropical.instPowTropical.{u2, u1} R α _inst_1)) x n)) (HSMul.hSMul.{u1, u2, u2} α R R (instHSMul.{u1, u2} α R _inst_1) n (Tropical.untrop.{u2} R x))
-Case conversion may be inaccurate. Consider using '#align tropical.untrop_pow Tropical.untrop_powₓ'. -/
 @[simp]
 theorem untrop_pow {α : Type _} [SMul α R] (x : Tropical R) (n : α) :
     untrop (x ^ n) = n • untrop x :=
   rfl
 #align tropical.untrop_pow Tropical.untrop_pow
 
-/- warning: tropical.trop_smul -> Tropical.trop_smul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {α : Type.{u2}} [_inst_1 : SMul.{u2, u1} α R] (x : R) (n : α), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (SMul.smul.{u2, u1} α R _inst_1 n x)) (HPow.hPow.{u1, u2, u1} (Tropical.{u1} R) α (Tropical.{u1} R) (instHPow.{u1, u2} (Tropical.{u1} R) α (Tropical.hasPow.{u1, u2} R α _inst_1)) (Tropical.trop.{u1} R x) n)
-but is expected to have type
-  forall {R : Type.{u2}} {α : Type.{u1}} [_inst_1 : SMul.{u1, u2} α R] (x : R) (n : α), Eq.{succ u2} (Tropical.{u2} R) (Tropical.trop.{u2} R (HSMul.hSMul.{u1, u2, u2} α R R (instHSMul.{u1, u2} α R _inst_1) n x)) (HPow.hPow.{u2, u1, u2} (Tropical.{u2} R) α (Tropical.{u2} R) (instHPow.{u2, u1} (Tropical.{u2} R) α (Tropical.instPowTropical.{u2, u1} R α _inst_1)) (Tropical.trop.{u2} R x) n)
-Case conversion may be inaccurate. Consider using '#align tropical.trop_smul Tropical.trop_smulₓ'. -/
 @[simp]
 theorem trop_smul {α : Type _} [SMul α R] (x : R) (n : α) : trop (n • x) = trop x ^ n :=
   rfl
@@ -763,12 +607,6 @@ instance covariant_swap_mul [LE R] [Add R] [CovariantClass R R (Function.swap (
 #align tropical.covariant_swap_mul Tropical.covariant_swap_mul
 -/
 
-/- warning: tropical.covariant_add -> Tropical.covariant_add is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1))) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3331 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3333 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3331 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3333) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3346 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3348 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3346 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3348)
-Case conversion may be inaccurate. Consider using '#align tropical.covariant_add Tropical.covariant_addₓ'. -/
 instance covariant_add [LinearOrder R] : CovariantClass (Tropical R) (Tropical R) (· + ·) (· ≤ ·) :=
   ⟨fun x y z h => by
     cases' le_total x y with hx hy
@@ -786,12 +624,6 @@ instance covariant_mul_lt [LT R] [Add R] [CovariantClass R R (· + ·) (· < ·)
 #align tropical.covariant_mul_lt Tropical.covariant_mul_lt
 -/
 
-/- warning: tropical.covariant_swap_mul_lt -> Tropical.covariant_swap_mul_lt is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R] [_inst_2 : Add.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R _inst_2))) (LT.lt.{u1} R (Preorder.toHasLt.{u1} R _inst_1))], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Function.swap.{succ u1, succ u1, succ u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (ᾰ : Tropical.{u1} R) (ᾰ : Tropical.{u1} R) => Tropical.{u1} R) (HMul.hMul.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHMul.{u1} (Tropical.{u1} R) (Tropical.hasMul.{u1} R _inst_2)))) (LT.lt.{u1} (Tropical.{u1} R) (Tropical.hasLt.{u1} R (Preorder.toHasLt.{u1} R _inst_1)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R] [_inst_2 : Add.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3643 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3645 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R _inst_2) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3643 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3645)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3658 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3660 : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R _inst_1) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3658 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3660)], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Function.swap.{succ u1, succ u1, succ u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (ᾰ : Tropical.{u1} R) (ᾰ : Tropical.{u1} R) => Tropical.{u1} R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3685 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3687 : Tropical.{u1} R) => HMul.hMul.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHMul.{u1} (Tropical.{u1} R) (Tropical.instMulTropical.{u1} R _inst_2)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3685 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3687)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3700 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3702 : Tropical.{u1} R) => LT.lt.{u1} (Tropical.{u1} R) (Tropical.instLTTropical.{u1} R (Preorder.toLT.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3700 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3702)
-Case conversion may be inaccurate. Consider using '#align tropical.covariant_swap_mul_lt Tropical.covariant_swap_mul_ltₓ'. -/
 instance covariant_swap_mul_lt [Preorder R] [Add R]
     [CovariantClass R R (Function.swap (· + ·)) (· < ·)] :
     CovariantClass (Tropical R) (Tropical R) (Function.swap (· * ·)) (· < ·) :=
@@ -806,12 +638,6 @@ instance [LinearOrder R] [Add R] [CovariantClass R R (· + ·) (· ≤ ·)]
   left_distrib _ _ _ := untrop_injective (min_add_add_left _ _ _).symm
   right_distrib _ _ _ := untrop_injective (min_add_add_right _ _ _).symm
 
-/- warning: tropical.add_pow -> Tropical.add_pow is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2)))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3921 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3923 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3921 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3923)] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3943 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3945 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3943 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3945)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3958 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3960 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3958 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3960)] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
-Case conversion may be inaccurate. Consider using '#align tropical.add_pow Tropical.add_powₓ'. -/
 @[simp]
 theorem add_pow [LinearOrder R] [AddMonoid R] [CovariantClass R R (· + ·) (· ≤ ·)]
     [CovariantClass R R (Function.swap (· + ·)) (· ≤ ·)] (x y : Tropical R) (n : ℕ) :
@@ -833,12 +659,6 @@ instance : CommSemiring (Tropical R) :=
     zero_mul := fun _ => untrop_injective (top_add _)
     mul_zero := fun _ => untrop_injective (add_top _) }
 
-/- warning: tropical.succ_nsmul -> Tropical.succ_nsmul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_2 : LinearOrder.{u1} R] [_inst_3 : OrderTop.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_2)))))] (x : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (SMul.smul.{0, u1} Nat (Tropical.{u1} R) (AddMonoid.SMul.{u1} (Tropical.{u1} R) (AddCommMonoid.toAddMonoid.{u1} (Tropical.{u1} R) (Tropical.addCommMonoid.{u1} R _inst_2 _inst_3))) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) x) x
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_2 : LinearOrder.{u1} R] [_inst_3 : OrderTop.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_2))))))] (x : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HSMul.hSMul.{0, u1, u1} Nat (Tropical.{u1} R) (Tropical.{u1} R) (instHSMul.{0, u1} Nat (Tropical.{u1} R) (AddMonoid.SMul.{u1} (Tropical.{u1} R) (AddCommMonoid.toAddMonoid.{u1} (Tropical.{u1} R) (Tropical.instAddCommMonoidTropical.{u1} R _inst_2 _inst_3)))) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) x) x
-Case conversion may be inaccurate. Consider using '#align tropical.succ_nsmul Tropical.succ_nsmulₓ'. -/
 @[simp]
 theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) : (n + 1) • x = x :=
   by
@@ -847,12 +667,6 @@ theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) :
   · rw [add_nsmul, IH, one_nsmul, add_self]
 #align tropical.succ_nsmul Tropical.succ_nsmul
 
-/- warning: tropical.mul_eq_zero_iff -> Tropical.mul_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_2 : LinearOrderedAddCommMonoid.{u1} R] {a : Tropical.{u1} (WithTop.{u1} R)} {b : Tropical.{u1} (WithTop.{u1} R)}, Iff (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) (HMul.hMul.{u1, u1, u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.{u1} (WithTop.{u1} R)) (Tropical.{u1} (WithTop.{u1} R)) (instHMul.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.hasMul.{u1} (WithTop.{u1} R) (WithTop.add.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (OrderedAddCommMonoid.toAddCommMonoid.{u1} R (LinearOrderedAddCommMonoid.toOrderedAddCommMonoid.{u1} R _inst_2)))))))) a b) (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (OfNat.mk.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.zero.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.hasZero.{u1} (WithTop.{u1} R) (WithTop.hasTop.{u1} R)))))) (Or (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) a (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (OfNat.mk.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.zero.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.hasZero.{u1} (WithTop.{u1} R) (WithTop.hasTop.{u1} R)))))) (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) b (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (OfNat.mk.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.zero.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.hasZero.{u1} (WithTop.{u1} R) (WithTop.hasTop.{u1} R)))))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_2 : LinearOrderedAddCommMonoid.{u1} R] {a : Tropical.{u1} (WithTop.{u1} R)} {b : Tropical.{u1} (WithTop.{u1} R)}, Iff (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) (HMul.hMul.{u1, u1, u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.{u1} (WithTop.{u1} R)) (Tropical.{u1} (WithTop.{u1} R)) (instHMul.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.instMulTropical.{u1} (WithTop.{u1} R) (WithTop.add.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (LinearOrderedAddCommMonoid.toAddCommMonoid.{u1} R _inst_2))))))) a b) (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.toOfNat0.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.instZeroTropical.{u1} (WithTop.{u1} R) (WithTop.top.{u1} R))))) (Or (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) a (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.toOfNat0.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.instZeroTropical.{u1} (WithTop.{u1} R) (WithTop.top.{u1} R))))) (Eq.{succ u1} (Tropical.{u1} (WithTop.{u1} R)) b (OfNat.ofNat.{u1} (Tropical.{u1} (WithTop.{u1} R)) 0 (Zero.toOfNat0.{u1} (Tropical.{u1} (WithTop.{u1} R)) (Tropical.instZeroTropical.{u1} (WithTop.{u1} R) (WithTop.top.{u1} R))))))
-Case conversion may be inaccurate. Consider using '#align tropical.mul_eq_zero_iff Tropical.mul_eq_zero_iffₓ'. -/
 -- TODO: find/create the right classes to make this hold (for enat, ennreal, etc)
 -- Requires `zero_eq_bot` to be true
 -- lemma add_eq_zero_iff {a b : tropical R} :

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

@@ -559,10 +559,8 @@ lean 3 declaration is
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R} {z : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) z) (Or (And (Eq.{succ u1} (Tropical.{u1} R) x z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x y)) (And (Eq.{succ u1} (Tropical.{u1} R) y z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) y x)))
 Case conversion may be inaccurate. Consider using '#align tropical.add_eq_iff Tropical.add_eq_iffₓ'. -/
-theorem add_eq_iff {x y z : Tropical R} : x + y = z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x :=
-  by
-  rw [trop_add_def, trop_eq_iff_eq_untrop]
-  simp [min_eq_iff]
+theorem add_eq_iff {x y z : Tropical R} : x + y = z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x := by
+  rw [trop_add_def, trop_eq_iff_eq_untrop]; simp [min_eq_iff]
 #align tropical.add_eq_iff Tropical.add_eq_iff
 
 /- warning: tropical.add_eq_zero_iff -> Tropical.add_eq_zero_iff is a dubious translation:

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

@@ -265,7 +265,7 @@ def tropOrderIso [Preorder R] : R ≃o Tropical R :=
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (Tropical.tropOrderIso.{u1} R _inst_1)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (RelIso.hasCoeToFun.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} (R -> (Tropical.{u1} R)) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) R (fun (_x : R) => Tropical.{u1} R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} (R -> (Tropical.{u1} R)) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) R (fun (_x : R) => Tropical.{u1} R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
 Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso_coe_fn Tropical.tropOrderIso_coe_fnₓ'. -/
 @[simp]
 theorem tropOrderIso_coe_fn [Preorder R] : (tropOrderIso : R → Tropical R) = trop :=
@@ -276,7 +276,7 @@ theorem tropOrderIso_coe_fn [Preorder R] : (tropOrderIso : R → Tropical R) = t
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Tropical.{u1} R) R (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Preorder.toHasLe.{u1} R _inst_1)) (fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (RelIso.hasCoeToFun.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> R) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Tropical.{u1} R) (fun (_x : Tropical.{u1} R) => R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> R) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Tropical.{u1} R) (fun (_x : Tropical.{u1} R) => R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
 Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso_symm_coe_fn Tropical.tropOrderIso_symm_coe_fnₓ'. -/
 @[simp]
 theorem tropOrderIso_symm_coe_fn [Preorder R] : (tropOrderIso.symm : Tropical R → R) = untrop :=

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

@@ -250,16 +250,20 @@ instance [Preorder R] : Preorder (Tropical R) :=
     le_trans := fun _ _ _ h h' => le_trans h h'
     lt_iff_le_not_le := fun _ _ => lt_iff_le_not_le }
 
-#print Tropical.tropOrderIso /-
+/- warning: tropical.trop_order_iso -> Tropical.tropOrderIso is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1))
+Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso Tropical.tropOrderIsoₓ'. -/
 /-- Reinterpret `x : R` as an element of `tropical R`, preserving the order. -/
 def tropOrderIso [Preorder R] : R ≃o Tropical R :=
   { tropEquiv with map_rel_iff' := fun _ _ => untrop_le_iff }
 #align tropical.trop_order_iso Tropical.tropOrderIso
--/
 
 /- warning: tropical.trop_order_iso_coe_fn -> Tropical.tropOrderIso_coe_fn is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (Tropical.tropOrderIso.{u1} R _inst_1)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1))) (fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (RelIso.hasCoeToFun.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (Tropical.tropOrderIso.{u1} R _inst_1)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (RelIso.hasCoeToFun.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} (R -> (Tropical.{u1} R)) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) R (fun (_x : R) => Tropical.{u1} R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
 Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso_coe_fn Tropical.tropOrderIso_coe_fnₓ'. -/
@@ -270,7 +274,7 @@ theorem tropOrderIso_coe_fn [Preorder R] : (tropOrderIso : R → Tropical R) = t
 
 /- warning: tropical.trop_order_iso_symm_coe_fn -> Tropical.tropOrderIso_symm_coe_fn is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Tropical.{u1} R) R (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Preorder.toLE.{u1} R _inst_1)) (fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (RelIso.hasCoeToFun.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Tropical.{u1} R) R (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Preorder.toHasLe.{u1} R _inst_1)) (fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (RelIso.hasCoeToFun.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R _inst_1))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toHasLe.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> R) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Tropical.{u1} R) (fun (_x : Tropical.{u1} R) => R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
 Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso_symm_coe_fn Tropical.tropOrderIso_symm_coe_fnₓ'. -/
@@ -487,7 +491,7 @@ theorem trop_sup_def (x y : Tropical R) : x ⊔ y = trop (untrop x ⊔ untrop y)
 
 /- warning: tropical.add_eq_left -> Tropical.add_eq_left is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) x)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) x)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x y) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) x)
 Case conversion may be inaccurate. Consider using '#align tropical.add_eq_left Tropical.add_eq_leftₓ'. -/
@@ -498,7 +502,7 @@ theorem add_eq_left ⦃x y : Tropical R⦄ (h : x ≤ y) : x + y = x :=
 
 /- warning: tropical.add_eq_right -> Tropical.add_eq_right is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) y)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) y)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {{x : Tropical.{u1} R}} {{y : Tropical.{u1} R}}, (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) y x) -> (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) y)
 Case conversion may be inaccurate. Consider using '#align tropical.add_eq_right Tropical.add_eq_rightₓ'. -/
@@ -509,7 +513,7 @@ theorem add_eq_right ⦃x y : Tropical R⦄ (h : y ≤ x) : x + y = y :=
 
 /- warning: tropical.add_eq_left_iff -> Tropical.add_eq_left_iff is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) x) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) x) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) x) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x y)
 Case conversion may be inaccurate. Consider using '#align tropical.add_eq_left_iff Tropical.add_eq_left_iffₓ'. -/
@@ -519,7 +523,7 @@ theorem add_eq_left_iff {x y : Tropical R} : x + y = x ↔ x ≤ y := by
 
 /- warning: tropical.add_eq_right_iff -> Tropical.add_eq_right_iff is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) y) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) y) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) y) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) y x)
 Case conversion may be inaccurate. Consider using '#align tropical.add_eq_right_iff Tropical.add_eq_right_iffₓ'. -/
@@ -551,7 +555,7 @@ theorem bit0 (x : Tropical R) : bit0 x = x :=
 
 /- warning: tropical.add_eq_iff -> Tropical.add_eq_iff is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R} {z : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) z) (Or (And (Eq.{succ u1} (Tropical.{u1} R) x z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y)) (And (Eq.{succ u1} (Tropical.{u1} R) y z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x)))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R} {z : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) z) (Or (And (Eq.{succ u1} (Tropical.{u1} R) x z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) x y)) (And (Eq.{succ u1} (Tropical.{u1} R) y z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))) y x)))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] {x : Tropical.{u1} R} {y : Tropical.{u1} R} {z : Tropical.{u1} R}, Iff (Eq.{succ u1} (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) z) (Or (And (Eq.{succ u1} (Tropical.{u1} R) x z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x y)) (And (Eq.{succ u1} (Tropical.{u1} R) y z) (LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) y x)))
 Case conversion may be inaccurate. Consider using '#align tropical.add_eq_iff Tropical.add_eq_iffₓ'. -/
@@ -763,7 +767,7 @@ instance covariant_swap_mul [LE R] [Add R] [CovariantClass R R (Function.swap (
 
 /- warning: tropical.covariant_add -> Tropical.covariant_add is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1))) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1))) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3331 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3333 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3331 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3333) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3346 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3348 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3346 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3348)
 Case conversion may be inaccurate. Consider using '#align tropical.covariant_add Tropical.covariant_addₓ'. -/
@@ -784,13 +788,17 @@ instance covariant_mul_lt [LT R] [Add R] [CovariantClass R R (· + ·) (· < ·)
 #align tropical.covariant_mul_lt Tropical.covariant_mul_lt
 -/
 
-#print Tropical.covariant_swap_mul_lt /-
+/- warning: tropical.covariant_swap_mul_lt -> Tropical.covariant_swap_mul_lt is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R] [_inst_2 : Add.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R _inst_2))) (LT.lt.{u1} R (Preorder.toHasLt.{u1} R _inst_1))], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Function.swap.{succ u1, succ u1, succ u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (ᾰ : Tropical.{u1} R) (ᾰ : Tropical.{u1} R) => Tropical.{u1} R) (HMul.hMul.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHMul.{u1} (Tropical.{u1} R) (Tropical.hasMul.{u1} R _inst_2)))) (LT.lt.{u1} (Tropical.{u1} R) (Tropical.hasLt.{u1} R (Preorder.toHasLt.{u1} R _inst_1)))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R] [_inst_2 : Add.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3643 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3645 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R _inst_2) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3643 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3645)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3658 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3660 : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R _inst_1) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3658 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3660)], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Function.swap.{succ u1, succ u1, succ u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (ᾰ : Tropical.{u1} R) (ᾰ : Tropical.{u1} R) => Tropical.{u1} R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3685 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3687 : Tropical.{u1} R) => HMul.hMul.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHMul.{u1} (Tropical.{u1} R) (Tropical.instMulTropical.{u1} R _inst_2)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3685 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3687)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3700 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3702 : Tropical.{u1} R) => LT.lt.{u1} (Tropical.{u1} R) (Tropical.instLTTropical.{u1} R (Preorder.toLT.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3700 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3702)
+Case conversion may be inaccurate. Consider using '#align tropical.covariant_swap_mul_lt Tropical.covariant_swap_mul_ltₓ'. -/
 instance covariant_swap_mul_lt [Preorder R] [Add R]
     [CovariantClass R R (Function.swap (· + ·)) (· < ·)] :
     CovariantClass (Tropical R) (Tropical R) (Function.swap (· * ·)) (· < ·) :=
   ⟨fun x y z h => add_lt_add_right h _⟩
 #align tropical.covariant_swap_mul_lt Tropical.covariant_swap_mul_lt
--/
 
 instance [LinearOrder R] [Add R] [CovariantClass R R (· + ·) (· ≤ ·)]
     [CovariantClass R R (Function.swap (· + ·)) (· ≤ ·)] : Distrib (Tropical R)
@@ -802,7 +810,7 @@ instance [LinearOrder R] [Add R] [CovariantClass R R (· + ·) (· ≤ ·)]
 
 /- warning: tropical.add_pow -> Tropical.add_pow is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2)))) (LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))))) (LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2)))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))))) (LE.le.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3921 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3923 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3921 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3923)] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3943 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3945 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3943 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3945)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3958 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3960 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3958 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3960)] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
 Case conversion may be inaccurate. Consider using '#align tropical.add_pow Tropical.add_powₓ'. -/
@@ -829,7 +837,7 @@ instance : CommSemiring (Tropical R) :=
 
 /- warning: tropical.succ_nsmul -> Tropical.succ_nsmul is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_2 : LinearOrder.{u1} R] [_inst_3 : OrderTop.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_2)))))] (x : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (SMul.smul.{0, u1} Nat (Tropical.{u1} R) (AddMonoid.SMul.{u1} (Tropical.{u1} R) (AddCommMonoid.toAddMonoid.{u1} (Tropical.{u1} R) (Tropical.addCommMonoid.{u1} R _inst_2 _inst_3))) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) x) x
+  forall {R : Type.{u1}} [_inst_2 : LinearOrder.{u1} R] [_inst_3 : OrderTop.{u1} R (Preorder.toHasLe.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_2)))))] (x : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (SMul.smul.{0, u1} Nat (Tropical.{u1} R) (AddMonoid.SMul.{u1} (Tropical.{u1} R) (AddCommMonoid.toAddMonoid.{u1} (Tropical.{u1} R) (Tropical.addCommMonoid.{u1} R _inst_2 _inst_3))) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) x) x
 but is expected to have type
   forall {R : Type.{u1}} [_inst_2 : LinearOrder.{u1} R] [_inst_3 : OrderTop.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_2))))))] (x : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HSMul.hSMul.{0, u1, u1} Nat (Tropical.{u1} R) (Tropical.{u1} R) (instHSMul.{0, u1} Nat (Tropical.{u1} R) (AddMonoid.SMul.{u1} (Tropical.{u1} R) (AddCommMonoid.toAddMonoid.{u1} (Tropical.{u1} R) (Tropical.instAddCommMonoidTropical.{u1} R _inst_2 _inst_3)))) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) x) x
 Case conversion may be inaccurate. Consider using '#align tropical.succ_nsmul Tropical.succ_nsmulₓ'. -/

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

@@ -261,7 +261,7 @@ def tropOrderIso [Preorder R] : R ≃o Tropical R :=
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (Tropical.tropOrderIso.{u1} R _inst_1)) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1))) (fun (_x : RelIso.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)))) => R -> (Tropical.{u1} R)) (RelIso.hasCoeToFun.{u1, u1} R (Tropical.{u1} R) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1)) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} (forall (a : R), (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => Tropical.{u1} R) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} R (Tropical.{u1} R)) R (fun (_x : R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : R) => Tropical.{u1} R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} R (Tropical.{u1} R)) R (Tropical.{u1} R) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} R (Tropical.{u1} R))) (RelEmbedding.toEmbedding.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (Tropical.tropOrderIso.{u1} R _inst_1)))) (Tropical.trop.{u1} R)
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} (R -> (Tropical.{u1} R)) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) R (fun (_x : R) => Tropical.{u1} R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} R (Tropical.{u1} R) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Tropical.tropOrderIso.{u1} R _inst_1)) (Tropical.trop.{u1} R)
 Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso_coe_fn Tropical.tropOrderIso_coe_fnₓ'. -/
 @[simp]
 theorem tropOrderIso_coe_fn [Preorder R] : (tropOrderIso : R → Tropical R) = trop :=
@@ -272,7 +272,7 @@ theorem tropOrderIso_coe_fn [Preorder R] : (tropOrderIso : R → Tropical R) = t
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Tropical.{u1} R) R (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Preorder.toLE.{u1} R _inst_1)) (fun (_x : RelIso.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1))) => (Tropical.{u1} R) -> R) (RelIso.hasCoeToFun.{u1, u1} (Tropical.{u1} R) R (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1))) (LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} (forall (a : Tropical.{u1} R), (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Tropical.{u1} R) => R) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (Tropical.{u1} R) R) (Tropical.{u1} R) (fun (_x : Tropical.{u1} R) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Tropical.{u1} R) => R) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (Tropical.{u1} R) R) (Tropical.{u1} R) R (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (Tropical.{u1} R) R)) (RelEmbedding.toEmbedding.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))))) (Tropical.untrop.{u1} R)
+  forall {R : Type.{u1}} [_inst_1 : Preorder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> R) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Tropical.{u1} R) (fun (_x : Tropical.{u1} R) => R) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Tropical.{u1} R) R (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Tropical.{u1} R) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : R) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R _inst_1) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (OrderIso.symm.{u1, u1} R (Tropical.{u1} R) (Preorder.toLE.{u1} R _inst_1) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R _inst_1)) (Tropical.tropOrderIso.{u1} R _inst_1))) (Tropical.untrop.{u1} R)
 Case conversion may be inaccurate. Consider using '#align tropical.trop_order_iso_symm_coe_fn Tropical.tropOrderIso_symm_coe_fnₓ'. -/
 @[simp]
 theorem tropOrderIso_symm_coe_fn [Preorder R] : (tropOrderIso.symm : Tropical R → R) = untrop :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/728baa2f54e6062c5879a3e397ac6bac323e506f

@@ -447,7 +447,7 @@ theorem untrop_max (x y : Tropical R) : untrop (max x y) = max (untrop x) (untro
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (LinearOrder.min.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Min.min.{u1} (Tropical.{u1} R) (LinearOrder.toMin.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1482 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1484 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1482 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1484)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Min.min.{u1} (Tropical.{u1} R) (LinearOrder.toMin.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1534 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1536 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1534 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1536)
 Case conversion may be inaccurate. Consider using '#align tropical.min_eq_add Tropical.min_eq_addₓ'. -/
 @[simp]
 theorem min_eq_add : (min : Tropical R → Tropical R → Tropical R) = (· + ·) :=
@@ -458,7 +458,7 @@ theorem min_eq_add : (min : Tropical R → Tropical R → Tropical R) = (· + ·
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Inf.inf.{u1} (Tropical.{u1} R) (SemilatticeInf.toHasInf.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeInf.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1))))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1518 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1520 : Tropical.{u1} R) => Inf.inf.{u1} (Tropical.{u1} R) (Lattice.toInf.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1518 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1520) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1533 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1535 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1533 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1535)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1570 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1572 : Tropical.{u1} R) => Inf.inf.{u1} (Tropical.{u1} R) (Lattice.toInf.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1570 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1572) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1585 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1587 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1585 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1587)
 Case conversion may be inaccurate. Consider using '#align tropical.inf_eq_add Tropical.inf_eq_addₓ'. -/
 @[simp]
 theorem inf_eq_add : ((· ⊓ ·) : Tropical R → Tropical R → Tropical R) = (· + ·) :=
@@ -765,7 +765,7 @@ instance covariant_swap_mul [LE R] [Add R] [CovariantClass R R (Function.swap (
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1))) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3279 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3281 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3279 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3281) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3294 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3296 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3294 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3296)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3331 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3333 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3331 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3333) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3346 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3348 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3346 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3348)
 Case conversion may be inaccurate. Consider using '#align tropical.covariant_add Tropical.covariant_addₓ'. -/
 instance covariant_add [LinearOrder R] : CovariantClass (Tropical R) (Tropical R) (· + ·) (· ≤ ·) :=
   ⟨fun x y z h => by
@@ -804,7 +804,7 @@ instance [LinearOrder R] [Add R] [CovariantClass R R (· + ·) (· ≤ ·)]
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2)))) (LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))))) (LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3854 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3856 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3854 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3856) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3869 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3871 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3869 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3871)] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3891 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3893 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3891 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3893)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908)] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3921 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3923 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3921 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3923)] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3943 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3945 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3943 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3945)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3958 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3960 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3958 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3960)] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
 Case conversion may be inaccurate. Consider using '#align tropical.add_pow Tropical.add_powₓ'. -/
 @[simp]
 theorem add_pow [LinearOrder R] [AddMonoid R] [CovariantClass R R (· + ·) (· ≤ ·)]

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

@@ -447,7 +447,7 @@ theorem untrop_max (x y : Tropical R) : untrop (max x y) = max (untrop x) (untro
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (LinearOrder.min.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Min.min.{u1} (Tropical.{u1} R) (LinearOrder.toMin.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1478 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1480 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1478 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1480)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Min.min.{u1} (Tropical.{u1} R) (LinearOrder.toMin.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1482 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1484 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1482 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1484)
 Case conversion may be inaccurate. Consider using '#align tropical.min_eq_add Tropical.min_eq_addₓ'. -/
 @[simp]
 theorem min_eq_add : (min : Tropical R → Tropical R → Tropical R) = (· + ·) :=
@@ -458,7 +458,7 @@ theorem min_eq_add : (min : Tropical R → Tropical R → Tropical R) = (· + ·
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Inf.inf.{u1} (Tropical.{u1} R) (SemilatticeInf.toHasInf.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeInf.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1))))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1514 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1516 : Tropical.{u1} R) => Inf.inf.{u1} (Tropical.{u1} R) (Lattice.toInf.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1514 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1516) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1529 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1531 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1529 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1531)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1518 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1520 : Tropical.{u1} R) => Inf.inf.{u1} (Tropical.{u1} R) (Lattice.toInf.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1518 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1520) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1533 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1535 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1533 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1535)
 Case conversion may be inaccurate. Consider using '#align tropical.inf_eq_add Tropical.inf_eq_addₓ'. -/
 @[simp]
 theorem inf_eq_add : ((· ⊓ ·) : Tropical R → Tropical R → Tropical R) = (· + ·) :=
@@ -765,7 +765,7 @@ instance covariant_swap_mul [LE R] [Add R] [CovariantClass R R (Function.swap (
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1))) (LE.le.{u1} (Tropical.{u1} R) (Tropical.hasLe.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1)))))))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3275 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3277 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3275 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3277) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3290 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3292 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3290 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3292)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], CovariantClass.{u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3279 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3281 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3279 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3281) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3294 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3296 : Tropical.{u1} R) => LE.le.{u1} (Tropical.{u1} R) (Tropical.instLETropical.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3294 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3296)
 Case conversion may be inaccurate. Consider using '#align tropical.covariant_add Tropical.covariant_addₓ'. -/
 instance covariant_add [LinearOrder R] : CovariantClass (Tropical R) (Tropical R) (· + ·) (· ≤ ·) :=
   ⟨fun x y z h => by
@@ -804,7 +804,7 @@ instance [LinearOrder R] [Add R] [CovariantClass R R (· + ·) (· ≤ ·)]
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2)))) (LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toHasAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))))) (LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))))))] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.hasPow.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3850 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3852 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3850 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3852) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3865 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3867 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3865 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3867)] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3887 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3889 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3887 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3889)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3902 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3904 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3902 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3904)] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] [_inst_2 : AddMonoid.{u1} R] [_inst_3 : CovariantClass.{u1, u1} R R (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3854 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3856 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3854 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3856) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3869 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3871 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3869 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3871)] [_inst_4 : CovariantClass.{u1, u1} R R (Function.swap.{succ u1, succ u1, succ u1} R R (fun (ᾰ : R) (ᾰ : R) => R) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3891 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3893 : R) => HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (AddZeroClass.toAdd.{u1} R (AddMonoid.toAddZeroClass.{u1} R _inst_2))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3891 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3893)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 : R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908 : R) => LE.le.{u1} R (Preorder.toLE.{u1} R (PartialOrder.toPreorder.{u1} R (SemilatticeInf.toPartialOrder.{u1} R (Lattice.toSemilatticeInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.3906 x._@.Mathlib.Algebra.Tropical.Basic._hyg.3908)] (x : Tropical.{u1} R) (y : Tropical.{u1} R) (n : Nat), Eq.{succ u1} (Tropical.{u1} R) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x y) n) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) x n) (HPow.hPow.{u1, 0, u1} (Tropical.{u1} R) Nat (Tropical.{u1} R) (instHPow.{u1, 0} (Tropical.{u1} R) Nat (Tropical.instPowTropical.{u1, 0} R Nat (AddMonoid.SMul.{u1} R _inst_2))) y n))
 Case conversion may be inaccurate. Consider using '#align tropical.add_pow Tropical.add_powₓ'. -/
 @[simp]
 theorem add_pow [LinearOrder R] [AddMonoid R] [CovariantClass R R (· + ·) (· ≤ ·)]

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

@@ -384,9 +384,9 @@ theorem trop_min (x y : R) : trop (min x y) = trop x + trop y :=
 
 /- warning: tropical.trop_inf -> Tropical.trop_inf is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : R) (y : R), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (HasInf.inf.{u1} R (SemilatticeInf.toHasInf.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) x y)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (Tropical.trop.{u1} R x) (Tropical.trop.{u1} R y))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : R) (y : R), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (Inf.inf.{u1} R (SemilatticeInf.toHasInf.{u1} R (Lattice.toSemilatticeInf.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) x y)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)) (Tropical.trop.{u1} R x) (Tropical.trop.{u1} R y))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : R) (y : R), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (HasInf.inf.{u1} R (Lattice.toHasInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))) x y)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (Tropical.trop.{u1} R x) (Tropical.trop.{u1} R y))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : R) (y : R), Eq.{succ u1} (Tropical.{u1} R) (Tropical.trop.{u1} R (Inf.inf.{u1} R (Lattice.toInf.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1))) x y)) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) (Tropical.trop.{u1} R x) (Tropical.trop.{u1} R y))
 Case conversion may be inaccurate. Consider using '#align tropical.trop_inf Tropical.trop_infₓ'. -/
 @[simp]
 theorem trop_inf (x y : R) : trop (x ⊓ y) = trop x + trop y :=
@@ -423,9 +423,9 @@ instance : LinearOrder (Tropical R) :=
 
 /- warning: tropical.untrop_sup -> Tropical.untrop_sup is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (HasSup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toHasSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)))) x y)) (HasSup.sup.{u1} R (SemilatticeSup.toHasSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (Sup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toHasSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)))) x y)) (Sup.sup.{u1} R (SemilatticeSup.toHasSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (HasSup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toHasSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))))) x y)) (HasSup.sup.{u1} R (SemilatticeSup.toHasSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} R (Tropical.untrop.{u1} R (Sup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))))) x y)) (Sup.sup.{u1} R (SemilatticeSup.toSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y))
 Case conversion may be inaccurate. Consider using '#align tropical.untrop_sup Tropical.untrop_supₓ'. -/
 @[simp]
 theorem untrop_sup (x y : Tropical R) : untrop (x ⊔ y) = untrop x ⊔ untrop y :=
@@ -456,9 +456,9 @@ theorem min_eq_add : (min : Tropical R → Tropical R → Tropical R) = (· + ·
 
 /- warning: tropical.inf_eq_add -> Tropical.inf_eq_add is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (HasInf.inf.{u1} (Tropical.{u1} R) (SemilatticeInf.toHasInf.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeInf.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1))))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (Inf.inf.{u1} (Tropical.{u1} R) (SemilatticeInf.toHasInf.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeInf.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1))))) (HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.hasAdd.{u1} R _inst_1)))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1514 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1516 : Tropical.{u1} R) => HasInf.inf.{u1} (Tropical.{u1} R) (Lattice.toHasInf.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1514 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1516) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1529 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1531 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1529 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1531)
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R], Eq.{succ u1} ((Tropical.{u1} R) -> (Tropical.{u1} R) -> (Tropical.{u1} R)) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1514 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1516 : Tropical.{u1} R) => Inf.inf.{u1} (Tropical.{u1} R) (Lattice.toInf.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1)))) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1514 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1516) (fun (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1529 : Tropical.{u1} R) (x._@.Mathlib.Algebra.Tropical.Basic._hyg.1531 : Tropical.{u1} R) => HAdd.hAdd.{u1, u1, u1} (Tropical.{u1} R) (Tropical.{u1} R) (Tropical.{u1} R) (instHAdd.{u1} (Tropical.{u1} R) (Tropical.instAddTropical.{u1} R _inst_1)) x._@.Mathlib.Algebra.Tropical.Basic._hyg.1529 x._@.Mathlib.Algebra.Tropical.Basic._hyg.1531)
 Case conversion may be inaccurate. Consider using '#align tropical.inf_eq_add Tropical.inf_eq_addₓ'. -/
 @[simp]
 theorem inf_eq_add : ((· ⊓ ·) : Tropical R → Tropical R → Tropical R) = (· + ·) :=
@@ -477,9 +477,9 @@ theorem trop_max_def (x y : Tropical R) : max x y = trop (max (untrop x) (untrop
 
 /- warning: tropical.trop_sup_def -> Tropical.trop_sup_def is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (HasSup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toHasSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)))) x y) (Tropical.trop.{u1} R (HasSup.sup.{u1} R (SemilatticeSup.toHasSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (Sup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toHasSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (LinearOrder.toLattice.{u1} (Tropical.{u1} R) (Tropical.linearOrder.{u1} R _inst_1)))) x y) (Tropical.trop.{u1} R (Sup.sup.{u1} R (SemilatticeSup.toHasSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (LinearOrder.toLattice.{u1} R _inst_1))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (HasSup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toHasSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))))) x y) (Tropical.trop.{u1} R (HasSup.sup.{u1} R (SemilatticeSup.toHasSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
+  forall {R : Type.{u1}} [_inst_1 : LinearOrder.{u1} R] (x : Tropical.{u1} R) (y : Tropical.{u1} R), Eq.{succ u1} (Tropical.{u1} R) (Sup.sup.{u1} (Tropical.{u1} R) (SemilatticeSup.toSup.{u1} (Tropical.{u1} R) (Lattice.toSemilatticeSup.{u1} (Tropical.{u1} R) (DistribLattice.toLattice.{u1} (Tropical.{u1} R) (instDistribLattice.{u1} (Tropical.{u1} R) (Tropical.instLinearOrderTropical.{u1} R _inst_1))))) x y) (Tropical.trop.{u1} R (Sup.sup.{u1} R (SemilatticeSup.toSup.{u1} R (Lattice.toSemilatticeSup.{u1} R (DistribLattice.toLattice.{u1} R (instDistribLattice.{u1} R _inst_1)))) (Tropical.untrop.{u1} R x) (Tropical.untrop.{u1} R y)))
 Case conversion may be inaccurate. Consider using '#align tropical.trop_sup_def Tropical.trop_sup_defₓ'. -/
 theorem trop_sup_def (x y : Tropical R) : x ⊔ y = trop (untrop x ⊔ untrop y) :=
   rfl

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

Scatter the content of Data.Nat.Basic across:

• Data.Nat.Defs for the lemmas having no dependencies
• Algebra.Group.Nat for the monoid instances and the few miscellaneous lemmas needing them.
• Algebra.Ring.Nat for the semiring instance and the few miscellaneous lemmas following it.

Similarly, scatter

• Data.Int.Basic across Data.Int.Defs, Algebra.Group.Int, Algebra.Ring.Int
• Data.Nat.Order.Basic across Data.Nat.Defs, Algebra.Order.Group.Nat, Algebra.Order.Ring.Nat
• Data.Int.Order.Basic across Data.Int.Defs, Algebra.Order.Group.Int, Algebra.Order.Ring.Int

Also move a few lemmas from Data.Nat.Order.Lemmas to Data.Nat.Defs.

Before

After

@@ -7,7 +7,7 @@ import Mathlib.Algebra.GroupPower.CovariantClass
 import Mathlib.Algebra.Order.Monoid.WithTop
 import Mathlib.Algebra.SMulWithZero
 import Mathlib.Order.Hom.Basic
-import Mathlib.Data.Nat.Order.Basic
+import Mathlib.Algebra.Order.Ring.Nat
 
 #align_import algebra.tropical.basic from "leanprover-community/mathlib"@"9116dd6709f303dcf781632e15fdef382b0fc579"
 

Classifies by adding issue number #10618 to porting notes claiming "simp can prove it".

@@ -343,7 +343,7 @@ theorem add_eq_right_iff {x y : Tropical R} : x + y = y ↔ y ≤ x := by
   rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_right_iff]
 #align tropical.add_eq_right_iff Tropical.add_eq_right_iff
 
--- Porting note: removing `simp`. `simp` can prove it
+-- Porting note (#10618): removing `simp`. `simp` can prove it
 theorem add_self (x : Tropical R) : x + x = x :=
   untrop_injective (min_eq_right le_rfl)
 #align tropical.add_self Tropical.add_self
@@ -577,7 +577,7 @@ theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) :
 -- Requires `zero_eq_bot` to be true
 -- lemma add_eq_zero_iff {a b : tropical R} :
 --   a + b = 1 ↔ a = 1 ∨ b = 1 := sorry
--- Porting note: removing @[simp], `simp` can prove it
+-- Porting note (#10618): removing @[simp], `simp` can prove it
 theorem mul_eq_zero_iff {R : Type*} [LinearOrderedAddCommMonoid R] {a b : Tropical (WithTop R)} :
     a * b = 0 ↔ a = 0 ∨ b = 0 := by simp [← untrop_inj_iff, WithTop.add_eq_top]
 #align tropical.mul_eq_zero_iff Tropical.mul_eq_zero_iff

This PR removes the default values for nsmul and zsmul, forcing the user to populate them manually. The previous behavior can be obtained by writing nsmul := nsmulRec and zsmul := zsmulRec, which is now in the docstring for these fields.

The motivation here is to make it more obvious when module diamonds are being introduced, or at least where they might be hiding; you can now simply search for nsmulRec in the source code.

Arguably we should do the same thing for intCast, natCast, pow, and zpow too, but diamonds are less common in those fields, so I'll leave them to a subsequent PR.

Co-authored-by: Matthew Ballard <matt@mrb.email>

@@ -373,7 +373,8 @@ theorem add_eq_zero_iff {a b : Tropical (WithTop R)} : a + b = 0 ↔ a = 0 ∧ b
 instance instAddCommMonoidTropical [OrderTop R] : AddCommMonoid (Tropical R) :=
   { instZeroTropical, instAddCommSemigroupTropical with
     zero_add := fun _ => untrop_injective (min_top_left _)
-    add_zero := fun _ => untrop_injective (min_top_right _) }
+    add_zero := fun _ => untrop_injective (min_top_right _)
+    nsmul := nsmulRec }
 
 end Order
 

This PR accompanies #11246, squeezing some non-terminal simps highlighted by the linter until I decided to stop!

@@ -291,9 +291,11 @@ instance instLinearOrderTropical : LinearOrder (Tropical R) :=
     le_total := fun a b => le_total (untrop a) (untrop b)
     decidableLE := Tropical.decidableLE
     max := fun a b => trop (max (untrop a) (untrop b))
-    max_def := fun a b => untrop_injective (by simp [max_def]; split_ifs <;> simp)
+    max_def := fun a b => untrop_injective (by
+      simp only [max_def, untrop_le_iff, untrop_trop]; split_ifs <;> simp)
     min := (· + ·)
-    min_def := fun a b => untrop_injective (by simp [min_def]; split_ifs <;> simp) }
+    min_def := fun a b => untrop_injective (by
+      simp only [untrop_add, min_def, untrop_le_iff]; split_ifs <;> simp) }
 
 @[simp]
 theorem untrop_sup (x y : Tropical R) : untrop (x ⊔ y) = untrop x ⊔ untrop y :=

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

@@ -240,12 +240,12 @@ theorem trop_top [Top R] : trop (⊤ : R) = 0 :=
 
 @[simp]
 theorem trop_coe_ne_zero (x : R) : trop (x : WithTop R) ≠ 0 :=
-  fun.
+  nofun
 #align tropical.trop_coe_ne_zero Tropical.trop_coe_ne_zero
 
 @[simp]
 theorem zero_ne_trop_coe (x : R) : (0 : Tropical (WithTop R)) ≠ trop x :=
-  fun.
+  nofun
 #align tropical.zero_ne_trop_coe Tropical.zero_ne_trop_coe
 
 @[simp]

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -100,7 +100,7 @@ theorem untrop_trop (x : R) : untrop (trop x) = x :=
   rfl
 #align tropical.untrop_trop Tropical.untrop_trop
 
---Porting note: New attribute seems to fix things
+-- Porting note: New attribute seems to fix things
 attribute [irreducible] Tropical
 
 theorem leftInverse_trop : Function.LeftInverse (trop : R → Tropical R) untrop :=
@@ -341,7 +341,7 @@ theorem add_eq_right_iff {x y : Tropical R} : x + y = y ↔ y ≤ x := by
   rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_right_iff]
 #align tropical.add_eq_right_iff Tropical.add_eq_right_iff
 
---Porting note: removing `simp`. `simp` can prove it
+-- Porting note: removing `simp`. `simp` can prove it
 theorem add_self (x : Tropical R) : x + x = x :=
   untrop_injective (min_eq_right le_rfl)
 #align tropical.add_self Tropical.add_self
@@ -574,7 +574,7 @@ theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) :
 -- Requires `zero_eq_bot` to be true
 -- lemma add_eq_zero_iff {a b : tropical R} :
 --   a + b = 1 ↔ a = 1 ∨ b = 1 := sorry
---Porting note: removing @[simp], `simp` can prove it
+-- Porting note: removing @[simp], `simp` can prove it
 theorem mul_eq_zero_iff {R : Type*} [LinearOrderedAddCommMonoid R] {a b : Tropical (WithTop R)} :
     a * b = 0 ↔ a = 0 ∨ b = 0 := by simp [← untrop_inj_iff, WithTop.add_eq_top]
 #align tropical.mul_eq_zero_iff Tropical.mul_eq_zero_iff

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -3,10 +3,11 @@ Copyright (c) 2021 Yakov Pechersky. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yakov Pechersky
 -/
-import Mathlib.Algebra.GroupPower.Order
+import Mathlib.Algebra.GroupPower.CovariantClass
 import Mathlib.Algebra.Order.Monoid.WithTop
 import Mathlib.Algebra.SMulWithZero
-import Mathlib.Algebra.Order.Monoid.MinMax
+import Mathlib.Order.Hom.Basic
+import Mathlib.Data.Nat.Order.Basic
 
 #align_import algebra.tropical.basic from "leanprover-community/mathlib"@"9116dd6709f303dcf781632e15fdef382b0fc579"
 

I literally went through and regex'd some uses of cases', replacing them with rcases; this is meant to be a low effort PR as I hope that tools can do this in the future.

rcases is an easier replacement than cases, though with better tools we could in future do a second pass converting simple rcases added here (and existing ones) to cases.

@@ -512,10 +512,10 @@ instance covariant_swap_mul [LE R] [Add R] [CovariantClass R R (Function.swap (
 
 instance covariant_add [LinearOrder R] : CovariantClass (Tropical R) (Tropical R) (· + ·) (· ≤ ·) :=
   ⟨fun x y z h => by
-    cases' le_total x y with hx hy
+    rcases le_total x y with hx | hy
     · rw [add_eq_left hx, add_eq_left (hx.trans h)]
     · rw [add_eq_right hy]
-      cases' le_total x z with hx hx
+      rcases le_total x z with hx | hx
       · rwa [add_eq_left hx]
       · rwa [add_eq_right hx]⟩
 #align tropical.covariant_add Tropical.covariant_add
@@ -543,7 +543,7 @@ instance instDistribTropical [LinearOrder R] [Add R] [CovariantClass R R (· + 
 theorem add_pow [LinearOrder R] [AddMonoid R] [CovariantClass R R (· + ·) (· ≤ ·)]
     [CovariantClass R R (Function.swap (· + ·)) (· ≤ ·)] (x y : Tropical R) (n : ℕ) :
     (x + y) ^ n = x ^ n + y ^ n := by
-  cases' le_total x y with h h
+  rcases le_total x y with h | h
   · rw [add_eq_left h, add_eq_left (pow_le_pow_left' h _)]
   · rw [add_eq_right h, add_eq_right (pow_le_pow_left' h _)]
 #align tropical.add_pow Tropical.add_pow

The names for lemmas about monotonicity of (a ^ ·) and (· ^ n) were a mess. This PR tidies up everything related by following the naming convention for (a * ·) and (· * b). Namely, (a ^ ·) is pow_right and (· ^ n) is pow_left in lemma names. All lemma renames follow the corresponding multiplication lemma names closely.

Renames

Algebra.GroupPower.Order

• pow_mono → pow_right_mono
• pow_le_pow → pow_le_pow_right
• pow_le_pow_of_le_left → pow_le_pow_left
• pow_lt_pow_of_lt_left → pow_lt_pow_left
• strictMonoOn_pow → pow_left_strictMonoOn
• pow_strictMono_right → pow_right_strictMono
• pow_lt_pow → pow_lt_pow_right
• pow_lt_pow_iff → pow_lt_pow_iff_right
• pow_le_pow_iff → pow_le_pow_iff_right
• self_lt_pow → lt_self_pow
• strictAnti_pow → pow_right_strictAnti
• pow_lt_pow_iff_of_lt_one → pow_lt_pow_iff_right_of_lt_one
• pow_lt_pow_of_lt_one → pow_lt_pow_right_of_lt_one
• lt_of_pow_lt_pow → lt_of_pow_lt_pow_left
• le_of_pow_le_pow → le_of_pow_le_pow_left
• pow_lt_pow₀ → pow_lt_pow_right₀

Algebra.GroupPower.CovariantClass

• pow_le_pow_of_le_left' → pow_le_pow_left'
• nsmul_le_nsmul_of_le_right → nsmul_le_nsmul_right
• pow_lt_pow' → pow_lt_pow_right'
• nsmul_lt_nsmul → nsmul_lt_nsmul_left
• pow_strictMono_left → pow_right_strictMono'
• nsmul_strictMono_right → nsmul_left_strictMono
• StrictMono.pow_right' → StrictMono.pow_const
• StrictMono.nsmul_left → StrictMono.const_nsmul
• pow_strictMono_right' → pow_left_strictMono
• nsmul_strictMono_left → nsmul_right_strictMono
• Monotone.pow_right → Monotone.pow_const
• Monotone.nsmul_left → Monotone.const_nsmul
• lt_of_pow_lt_pow' → lt_of_pow_lt_pow_left'
• lt_of_nsmul_lt_nsmul → lt_of_nsmul_lt_nsmul_right
• pow_le_pow' → pow_le_pow_right'
• nsmul_le_nsmul → nsmul_le_nsmul_left
• pow_le_pow_of_le_one' → pow_le_pow_right_of_le_one'
• nsmul_le_nsmul_of_nonpos → nsmul_le_nsmul_left_of_nonpos
• le_of_pow_le_pow' → le_of_pow_le_pow_left'
• le_of_nsmul_le_nsmul' → le_of_nsmul_le_nsmul_right'
• pow_le_pow_iff' → pow_le_pow_iff_right'
• nsmul_le_nsmul_iff → nsmul_le_nsmul_iff_left
• pow_lt_pow_iff' → pow_lt_pow_iff_right'
• nsmul_lt_nsmul_iff → nsmul_lt_nsmul_iff_left

Data.Nat.Pow

• Nat.pow_lt_pow_of_lt_left → Nat.pow_lt_pow_left
• Nat.pow_le_iff_le_left → Nat.pow_le_pow_iff_left
• Nat.pow_lt_iff_lt_left → Nat.pow_lt_pow_iff_left

Lemmas added

• pow_le_pow_iff_left
• pow_lt_pow_iff_left
• pow_right_injective
• pow_right_inj
• Nat.pow_le_pow_left to have the correct name since Nat.pow_le_pow_of_le_left is in Std.
• Nat.pow_le_pow_right to have the correct name since Nat.pow_le_pow_of_le_right is in Std.

Lemmas removed

• self_le_pow was a duplicate of le_self_pow.
• Nat.pow_lt_pow_of_lt_right is defeq to pow_lt_pow_right.
• Nat.pow_right_strictMono is defeq to pow_right_strictMono.
• Nat.pow_le_iff_le_right is defeq to pow_le_pow_iff_right.
• Nat.pow_lt_iff_lt_right is defeq to pow_lt_pow_iff_right.

Other changes

• A bunch of proofs have been golfed.
• Some lemma assumptions have been turned from 0 < n or 1 ≤ n to n ≠ 0.
• A few Nat lemmas have been protected.
• One docstring has been fixed.

@@ -544,8 +544,8 @@ theorem add_pow [LinearOrder R] [AddMonoid R] [CovariantClass R R (· + ·) (·
     [CovariantClass R R (Function.swap (· + ·)) (· ≤ ·)] (x y : Tropical R) (n : ℕ) :
     (x + y) ^ n = x ^ n + y ^ n := by
   cases' le_total x y with h h
-  · rw [add_eq_left h, add_eq_left (pow_le_pow_of_le_left' h _)]
-  · rw [add_eq_right h, add_eq_right (pow_le_pow_of_le_left' h _)]
+  · rw [add_eq_left h, add_eq_left (pow_le_pow_left' h _)]
+  · rw [add_eq_right h, add_eq_right (pow_le_pow_left' h _)]
 #align tropical.add_pow Tropical.add_pow
 
 end Distrib

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

This has nice performance benefits.

@@ -440,16 +440,16 @@ instance instSemigroupTropical [AddSemigroup R] : Semigroup (Tropical R) where
 instance instCommSemigroupTropical [AddCommSemigroup R] : CommSemigroup (Tropical R) :=
   { instSemigroupTropical with mul_comm := fun _ _ => untrop_injective (add_comm _ _) }
 
-instance {α : Type _} [SMul α R] : Pow (Tropical R) α where pow x n := trop <| n • untrop x
+instance {α : Type*} [SMul α R] : Pow (Tropical R) α where pow x n := trop <| n • untrop x
 
 @[simp]
-theorem untrop_pow {α : Type _} [SMul α R] (x : Tropical R) (n : α) :
+theorem untrop_pow {α : Type*} [SMul α R] (x : Tropical R) (n : α) :
     untrop (x ^ n) = n • untrop x :=
   rfl
 #align tropical.untrop_pow Tropical.untrop_pow
 
 @[simp]
-theorem trop_smul {α : Type _} [SMul α R] (x : R) (n : α) : trop (n • x) = trop x ^ n :=
+theorem trop_smul {α : Type*} [SMul α R] (x : R) (n : α) : trop (n • x) = trop x ^ n :=
   rfl
 #align tropical.trop_smul Tropical.trop_smul
 
@@ -574,11 +574,11 @@ theorem succ_nsmul {R} [LinearOrder R] [OrderTop R] (x : Tropical R) (n : ℕ) :
 -- lemma add_eq_zero_iff {a b : tropical R} :
 --   a + b = 1 ↔ a = 1 ∨ b = 1 := sorry
 --Porting note: removing @[simp], `simp` can prove it
-theorem mul_eq_zero_iff {R : Type _} [LinearOrderedAddCommMonoid R] {a b : Tropical (WithTop R)} :
+theorem mul_eq_zero_iff {R : Type*} [LinearOrderedAddCommMonoid R] {a b : Tropical (WithTop R)} :
     a * b = 0 ↔ a = 0 ∨ b = 0 := by simp [← untrop_inj_iff, WithTop.add_eq_top]
 #align tropical.mul_eq_zero_iff Tropical.mul_eq_zero_iff
 
-instance {R : Type _} [LinearOrderedAddCommMonoid R] : NoZeroDivisors (Tropical (WithTop R)) :=
+instance {R : Type*} [LinearOrderedAddCommMonoid R] : NoZeroDivisors (Tropical (WithTop R)) :=
   ⟨mul_eq_zero_iff.mp⟩
 
 end Semiring

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.