/-- An `OrderedCommSemiring` is a commutative semiring with a partial order such that addition is
monotone and multiplication by a nonnegative number is monotone. -/
class OrderedCommSemiring (α : Type u) extends OrderedSemiring α, CommSemiring α where
  mul_le_mul_of_nonneg_right a b c ha hc :=
    -- parentheses ensure this generates an `optParam` rather than an `autoParam`
    (by 

Proof state:
α✝ : Type u
β : Type u_1
α : Type u
toOrderedSemiring : OrderedSemiring α
toSemiring : Semiring α := OrderedSemiring.toSemiring
toNonUnitalSemiring : NonUnitalSemiring α := Semiring.toNonUnitalSemiring
toNonUnitalNonAssocSemiring : NonUnitalNonAssocSemiring α := NonUnitalSemiring.toNonUnitalNonAssocSemiring
toAddCommMonoid : AddCommMonoid α := NonUnitalNonAssocSemiring.toAddCommMonoid
toAddMonoid : AddMonoid α := AddCommMonoid.toAddMonoid
toAddSemigroup : AddSemigroup α := AddMonoid.toAddSemigroup
toAdd : Add α := AddSemigroup.toAdd
add : α → α → α := Add.add
add_assoc : ∀ (a b c : α), a + b + c = a + (b + c) := AddSemigroup.add_assoc
toZero : Zero α := AddMonoid.toZero
zero : α := Zero.zero
zero_add : ∀ (a : α), 0 + a = a := AddMonoid.zero_add
add_zero : ∀ (a : α), a + 0 = a := AddMonoid.add_zero
nsmul : ℕ → α → α := AddMonoid.nsmul
nsmul_zero : ∀ (x : α), AddMonoid.nsmul 0 x = 0 := AddMonoid.nsmul_zero
nsmul_succ : ∀ (n : ℕ) (x : α), AddMonoid.nsmul (n + 1) x = x + AddMonoid.nsmul n x := AddMonoid.nsmul_succ
add_comm : ∀ (a b : α), a + b = b + a := AddCommMonoid.add_comm
toMul : Mul α := NonUnitalNonAssocSemiring.toMul
mul : α → α → α := Mul.mul
left_distrib : ∀ (a b c : α), a * (b + c) = a * b + a * c := NonUnitalNonAssocSemiring.left_distrib
right_distrib : ∀ (a b c : α), (a + b) * c = a * c + b * c := NonUnitalNonAssocSemiring.right_distrib
zero_mul : ∀ (a : α), 0 * a = 0 := NonUnitalNonAssocSemiring.zero_mul
mul_zero : ∀ (a : α), a * 0 = 0 := NonUnitalNonAssocSemiring.mul_zero
mul_assoc : ∀ (a b c : α), a * b * c = a * (b * c) := NonUnitalSemiring.mul_assoc
toOne : One α := Semiring.toOne
one : α := One.one
one_mul : ∀ (a : α), 1 * a = a := Semiring.one_mul
mul_one : ∀ (a : α), a * 1 = a := Semiring.mul_one
toNatCast : NatCast α := Semiring.toNatCast
natCast : ℕ → α := NatCast.natCast
natCast_zero : NatCast.natCast 0 = 0 := Semiring.natCast_zero
natCast_succ : ∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1 := Semiring.natCast_succ
npow : ℕ → α → α := Semiring.npow
npow_zero : ∀ (x : α), Semiring.npow 0 x = 1 := Semiring.npow_zero
npow_succ : ∀ (n : ℕ) (x : α), Semiring.npow (n + 1) x = x * Semiring.npow n x := Semiring.npow_succ
toPartialOrder : PartialOrder α := OrderedSemiring.toPartialOrder
toPreorder : Preorder α := PartialOrder.toPreorder
toLE : LE α := Preorder.toLE
le : α → α → Prop := LE.le
toLT : LT α := Preorder.toLT
lt : α → α → Prop := LT.lt
le_refl : ∀ (a : α), a ≤ a := Preorder.le_refl
le_trans : ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c := Preorder.le_trans
lt_iff_le_not_le : ∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a := Preorder.lt_iff_le_not_le
le_antisymm : ∀ (a b : α), a ≤ b → b ≤ a → a = b := PartialOrder.le_antisymm
add_le_add_left : ∀ (a b : α), a ≤ b → ∀ (c : α), c + a ≤ c + b := OrderedSemiring.add_le_add_left
zero_le_one : 0 ≤ 1 := OrderedSemiring.zero_le_one
mul_le_mul_of_nonneg_left : ∀ (a b c : α), a ≤ b → 0 ≤ c → c * a ≤ c * b := OrderedSemiring.mul_le_mul_of_nonneg_left
mul_le_mul_of_nonneg_right : ∀ (a b c : α), a ≤ b → 0 ≤ c → a * c ≤ b * c := OrderedSemiring.mul_le_mul_of_nonneg_right
mul_comm : ∀ (a b : α), a * b = b * a
a b c : α
ha : a ≤ b
hc : 0 ≤ c
⊢ a * c ≤ b * c

Next tactic:
simpa only [mul_comm] using mul_le_mul_of_nonneg_left a b c ha hc