File: Mathlib/Algebra/Order/Module/Defs.lean

full_name: PosSMulMono
code: /-- Typeclass for monotonicity of scalar multiplication by nonnegative elements on the left,
namely `b₁ ≤ b₂ → a • b₁ ≤ a • b₂` if `0 ≤ a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulMono : Prop where
  /-- Do not use this. Use `smul_le_smul_of_nonneg_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 ≤ a) ⦃b₁ b₂ : β⦄ (hb : b₁ ≤ b₂) : a • b₁ ≤ a • b₂
goal: Prop

full_name: PosSMulMono.elim
code: /-- Typeclass for monotonicity of scalar multiplication by nonnegative elements on the left,
namely `b₁ ≤ b₂ → a • b₁ ≤ a • b₂` if `0 ≤ a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulMono : Prop where
  /-- Do not use this. Use `smul_le_smul_of_nonneg_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 ≤ a) ⦃b₁ b₂ : β⦄ (hb : b₁ ≤ b₂) : a • b₁ ≤ a • b₂
goal: a • b₁ ≤ a • b₂

full_name: PosSMulStrictMono
code: /-- Typeclass for strict monotonicity of scalar multiplication by positive elements on the left,
namely `b₁ < b₂ → a • b₁ < a • b₂` if `0 < a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulStrictMono : Prop where
  /-- Do not use this. Use `smul_lt_smul_of_pos_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 < a) ⦃b₁ b₂ : β⦄ (hb : b₁ < b₂) : a • b₁ < a • b₂
goal: Prop

full_name: PosSMulStrictMono.elim
code: /-- Typeclass for strict monotonicity of scalar multiplication by positive elements on the left,
namely `b₁ < b₂ → a • b₁ < a • b₂` if `0 < a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulStrictMono : Prop where
  /-- Do not use this. Use `smul_lt_smul_of_pos_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 < a) ⦃b₁ b₂ : β⦄ (hb : b₁ < b₂) : a • b₁ < a • b₂
goal: a • b₁ < a • b₂

full_name: PosSMulReflectLT
code: /-- Typeclass for strict reverse monotonicity of scalar multiplication by nonnegative elements on
the left, namely `a • b₁ < a • b₂ → b₁ < b₂` if `0 ≤ a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulReflectLT : Prop where
  /-- Do not use this. Use `lt_of_smul_lt_smul_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 ≤ a) ⦃b₁ b₂ : β⦄ (hb : a • b₁ < a • b₂) : b₁ < b₂
goal: Prop

full_name: PosSMulReflectLT.elim
code: /-- Typeclass for strict reverse monotonicity of scalar multiplication by nonnegative elements on
the left, namely `a • b₁ < a • b₂ → b₁ < b₂` if `0 ≤ a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulReflectLT : Prop where
  /-- Do not use this. Use `lt_of_smul_lt_smul_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 ≤ a) ⦃b₁ b₂ : β⦄ (hb : a • b₁ < a • b₂) : b₁ < b₂
goal: b₁ < b₂

full_name: PosSMulReflectLE.elim
code: /-- Typeclass for reverse monotonicity of scalar multiplication by positive elements on the left,
namely `a • b₁ ≤ a • b₂ → b₁ ≤ b₂` if `0 < a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulReflectLE : Prop where
  /-- Do not use this. Use `le_of_smul_lt_smul_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 < a) ⦃b₁ b₂ : β⦄ (hb : a • b₁ ≤ a • b₂) : b₁ ≤ b₂
goal: b₁ ≤ b₂

full_name: PosSMulReflectLE
code: /-- Typeclass for reverse monotonicity of scalar multiplication by positive elements on the left,
namely `a • b₁ ≤ a • b₂ → b₁ ≤ b₂` if `0 < a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulReflectLE : Prop where
  /-- Do not use this. Use `le_of_smul_lt_smul_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 < a) ⦃b₁ b₂ : β⦄ (hb : a • b₁ ≤ a • b₂) : b₁ ≤ b₂
goal: Prop

full_name: SMulPosMono.elim
code: /-- Typeclass for monotonicity of scalar multiplication by nonnegative elements on the left,
namely `a₁ ≤ a₂ → a₁ • b ≤ a₂ • b` if `0 ≤ b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosMono : Prop where
  /-- Do not use this. Use `smul_le_smul_of_nonneg_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 ≤ b) ⦃a₁ a₂ : α⦄ (ha : a₁ ≤ a₂) : a₁ • b ≤ a₂ • b
goal: a₁ • b ≤ a₂ • b

full_name: SMulPosMono
code: /-- Typeclass for monotonicity of scalar multiplication by nonnegative elements on the left,
namely `a₁ ≤ a₂ → a₁ • b ≤ a₂ • b` if `0 ≤ b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosMono : Prop where
  /-- Do not use this. Use `smul_le_smul_of_nonneg_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 ≤ b) ⦃a₁ a₂ : α⦄ (ha : a₁ ≤ a₂) : a₁ • b ≤ a₂ • b
goal: Prop

full_name: SMulPosStrictMono
code: /-- Typeclass for strict monotonicity of scalar multiplication by positive elements on the left,
namely `a₁ < a₂ → a₁ • b < a₂ • b` if `0 < b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosStrictMono : Prop where
  /-- Do not use this. Use `smul_lt_smul_of_pos_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 < b) ⦃a₁ a₂ : α⦄ (ha : a₁ < a₂) : a₁ • b < a₂ • b
goal: Prop

full_name: SMulPosStrictMono.elim
code: /-- Typeclass for strict monotonicity of scalar multiplication by positive elements on the left,
namely `a₁ < a₂ → a₁ • b < a₂ • b` if `0 < b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosStrictMono : Prop where
  /-- Do not use this. Use `smul_lt_smul_of_pos_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 < b) ⦃a₁ a₂ : α⦄ (ha : a₁ < a₂) : a₁ • b < a₂ • b
goal: a₁ • b < a₂ • b

full_name: SMulPosReflectLT
code: /-- Typeclass for strict reverse monotonicity of scalar multiplication by nonnegative elements on
the left, namely `a₁ • b < a₂ • b → a₁ < a₂` if `0 ≤ b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosReflectLT : Prop where
  /-- Do not use this. Use `lt_of_smul_lt_smul_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 ≤ b) ⦃a₁ a₂ : α⦄ (hb : a₁ • b < a₂ • b) : a₁ < a₂
goal: Prop

full_name: SMulPosReflectLT.elim
code: /-- Typeclass for strict reverse monotonicity of scalar multiplication by nonnegative elements on
the left, namely `a₁ • b < a₂ • b → a₁ < a₂` if `0 ≤ b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosReflectLT : Prop where
  /-- Do not use this. Use `lt_of_smul_lt_smul_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 ≤ b) ⦃a₁ a₂ : α⦄ (hb : a₁ • b < a₂ • b) : a₁ < a₂
goal: a₁ • b < a₂ • b → a₁ < a₂

full_name: SMulPosReflectLE.elim
code: /-- Typeclass for reverse monotonicity of scalar multiplication by positive elements on the left,
namely `a₁ • b ≤ a₂ • b → a₁ ≤ a₂` if `0 < b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosReflectLE : Prop where
  /-- Do not use this. Use `le_of_smul_lt_smul_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 < b) ⦃a₁ a₂ : α⦄ (hb : a₁ • b ≤ a₂ • b) : a₁ ≤ a₂
goal: a₁ • b ≤ a₂ • b → a₁ ≤ a₂

full_name: SMulPosReflectLE
code: /-- Typeclass for reverse monotonicity of scalar multiplication by positive elements on the left,
namely `a₁ • b ≤ a₂ • b → a₁ ≤ a₂` if `0 < b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosReflectLE : Prop where
  /-- Do not use this. Use `le_of_smul_lt_smul_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 < b) ⦃a₁ a₂ : α⦄ (hb : a₁ • b ≤ a₂ • b) : a₁ ≤ a₂
goal: Prop

full_name: PosMulMono.toPosSMulMono
code: instance (priority := 100) PosMulMono.toPosSMulMono [PosMulMono α] : PosSMulMono α α 
goal: PosSMulMono α α

full_name: PosMulStrictMono.toPosSMulStrictMono
code: instance (priority := 100) PosMulStrictMono.toPosSMulStrictMono [PosMulStrictMono α] :
    PosSMulStrictMono α α 
goal: PosSMulStrictMono α α

full_name: PosMulReflectLT.toPosSMulReflectLT
code: instance (priority := 100) PosMulReflectLT.toPosSMulReflectLT [PosMulReflectLT α] :
    PosSMulReflectLT α α 
goal: PosSMulReflectLT α α

full_name: PosMulReflectLE.toPosSMulReflectLE
code: instance (priority := 100) PosMulReflectLE.toPosSMulReflectLE [PosMulReflectLE α] :
    PosSMulReflectLE α α 
goal: PosSMulReflectLE α α

full_name: MulPosMono.toSMulPosMono
code: instance (priority := 100) MulPosMono.toSMulPosMono [MulPosMono α] : SMulPosMono α α 
goal: SMulPosMono α α

full_name: MulPosStrictMono.toSMulPosStrictMono
code: instance (priority := 100) MulPosStrictMono.toSMulPosStrictMono [MulPosStrictMono α] :
    SMulPosStrictMono α α 
goal: SMulPosStrictMono α α

full_name: MulPosReflectLT.toSMulPosReflectLT
code: instance (priority := 100) MulPosReflectLT.toSMulPosReflectLT [MulPosReflectLT α] :
    SMulPosReflectLT α α 
goal: SMulPosReflectLT α α

full_name: MulPosReflectLE.toSMulPosReflectLE
code: instance (priority := 100) MulPosReflectLE.toSMulPosReflectLE [MulPosReflectLE α] :
    SMulPosReflectLE α α 
goal: SMulPosReflectLE α α

full_name: monotone_smul_left_of_nonneg
code: lemma monotone_smul_left_of_nonneg [PosSMulMono α β] (ha : 0 ≤ a) : Monotone ((a • ·) : β → β) 
goal: Monotone fun x => a • x

full_name: strictMono_smul_left_of_pos
code: lemma strictMono_smul_left_of_pos [PosSMulStrictMono α β] (ha : 0 < a) :
    StrictMono ((a • ·) : β → β) 
goal: StrictMono fun x => a • x

full_name: smul_le_smul_of_nonneg_left
code: @[gcongr] lemma smul_le_smul_of_nonneg_left [PosSMulMono α β] (hb : b₁ ≤ b₂) (ha : 0 ≤ a) :
    a • b₁ ≤ a • b₂ 
goal: a • b₁ ≤ a • b₂

full_name: smul_lt_smul_of_pos_left
code: @[gcongr] lemma smul_lt_smul_of_pos_left [PosSMulStrictMono α β] (hb : b₁ < b₂) (ha : 0 < a) :
    a • b₁ < a • b₂ 
goal: a • b₁ < a • b₂

full_name: lt_of_smul_lt_smul_left
code: lemma lt_of_smul_lt_smul_left [PosSMulReflectLT α β] (h : a • b₁ < a • b₂) (ha : 0 ≤ a) : b₁ < b₂ 
goal: b₁ < b₂

full_name: le_of_smul_le_smul_left
code: lemma le_of_smul_le_smul_left [PosSMulReflectLE α β] (h : a • b₁ ≤ a • b₂) (ha : 0 < a) : b₁ ≤ b₂ 
goal: b₁ ≤ b₂

full_name: smul_le_smul_iff_of_pos_left
code: @[simp]
lemma smul_le_smul_iff_of_pos_left [PosSMulMono α β] [PosSMulReflectLE α β] (ha : 0 < a) :
    a • b₁ ≤ a • b₂ ↔ b₁ ≤ b₂ 
goal: a • b₁ ≤ a • b₂ ↔ b₁ ≤ b₂

full_name: smul_lt_smul_iff_of_pos_left
code: @[simp]
lemma smul_lt_smul_iff_of_pos_left [PosSMulStrictMono α β] [PosSMulReflectLT α β] (ha : 0 < a) :
    a • b₁ < a • b₂ ↔ b₁ < b₂ 
goal: a • b₁ < a • b₂ ↔ b₁ < b₂

full_name: monotone_smul_right_of_nonneg
code: lemma monotone_smul_right_of_nonneg [SMulPosMono α β] (hb : 0 ≤ b) : Monotone ((· • b) : α → β) 
goal: Monotone fun x => x • b

full_name: strictMono_smul_right_of_pos
code: lemma strictMono_smul_right_of_pos [SMulPosStrictMono α β] (hb : 0 < b) :
    StrictMono ((· • b) : α → β) 
goal: StrictMono fun x => x • b

full_name: smul_le_smul_of_nonneg_right
code: @[gcongr] lemma smul_le_smul_of_nonneg_right [SMulPosMono α β] (ha : a₁ ≤ a₂) (hb : 0 ≤ b) :
    a₁ • b ≤ a₂ • b 
goal: a₁ • b ≤ a₂ • b

full_name: smul_lt_smul_of_pos_right
code: @[gcongr] lemma smul_lt_smul_of_pos_right [SMulPosStrictMono α β] (ha : a₁ < a₂) (hb : 0 < b) :
    a₁ • b < a₂ • b 
goal: a₁ • b < a₂ • b

full_name: lt_of_smul_lt_smul_right
code: lemma lt_of_smul_lt_smul_right [SMulPosReflectLT α β] (h : a₁ • b < a₂ • b) (hb : 0 ≤ b) :
    a₁ < a₂ 
goal: a₁ < a₂

full_name: le_of_smul_le_smul_right
code: lemma le_of_smul_le_smul_right [SMulPosReflectLE α β] (h : a₁ • b ≤ a₂ • b) (hb : 0 < b) :
    a₁ ≤ a₂ 
goal: a₁ ≤ a₂

full_name: smul_le_smul_iff_of_pos_right
code: @[simp]
lemma smul_le_smul_iff_of_pos_right [SMulPosMono α β] [SMulPosReflectLE α β] (hb : 0 < b) :
    a₁ • b ≤ a₂ • b ↔ a₁ ≤ a₂ 
goal: a₁ • b ≤ a₂ • b ↔ a₁ ≤ a₂

full_name: smul_lt_smul_iff_of_pos_right
code: @[simp]
lemma smul_lt_smul_iff_of_pos_right [SMulPosStrictMono α β] [SMulPosReflectLT α β] (hb : 0 < b) :
    a₁ • b < a₂ • b ↔ a₁ < a₂ 
goal: a₁ • b < a₂ • b ↔ a₁ < a₂

full_name: smul_lt_smul_of_le_of_lt
code: lemma smul_lt_smul_of_le_of_lt [PosSMulStrictMono α β] [SMulPosMono α β] (ha : a₁ ≤ a₂)
    (hb : b₁ < b₂) (h₁ : 0 < a₁) (h₂ : 0 ≤ b₂) : a₁ • b₁ < a₂ • b₂ 
goal: a₁ • b₁ < a₂ • b₂

full_name: smul_lt_smul_of_le_of_lt'
code: lemma smul_lt_smul_of_le_of_lt' [PosSMulStrictMono α β] [SMulPosMono α β] (ha : a₁ ≤ a₂)
    (hb : b₁ < b₂) (h₂ : 0 < a₂) (h₁ : 0 ≤ b₁) : a₁ • b₁ < a₂ • b₂ 
goal: a₁ • b₁ < a₂ • b₂

full_name: smul_lt_smul_of_lt_of_le
code: lemma smul_lt_smul_of_lt_of_le [PosSMulMono α β] [SMulPosStrictMono α β] (ha : a₁ < a₂)
    (hb : b₁ ≤ b₂) (h₁ : 0 ≤ a₁) (h₂ : 0 < b₂) : a₁ • b₁ < a₂ • b₂ 
goal: a₁ • b₁ < a₂ • b₂

full_name: smul_lt_smul_of_lt_of_le'
code: lemma smul_lt_smul_of_lt_of_le' [PosSMulMono α β] [SMulPosStrictMono α β] (ha : a₁ < a₂)
    (hb : b₁ ≤ b₂) (h₂ : 0 ≤ a₂) (h₁ : 0 < b₁) : a₁ • b₁ < a₂ • b₂ 
goal: a₁ • b₁ < a₂ • b₂

full_name: smul_lt_smul
code: lemma smul_lt_smul [PosSMulStrictMono α β] [SMulPosStrictMono α β] (ha : a₁ < a₂) (hb : b₁ < b₂)
    (h₁ : 0 < a₁) (h₂ : 0 < b₂) : a₁ • b₁ < a₂ • b₂ 
goal: a₁ • b₁ < a₂ • b₂

full_name: smul_lt_smul'
code: lemma smul_lt_smul' [PosSMulStrictMono α β] [SMulPosStrictMono α β] (ha : a₁ < a₂) (hb : b₁ < b₂)
    (h₂ : 0 < a₂) (h₁ : 0 < b₁) : a₁ • b₁ < a₂ • b₂ 
goal: a₁ • b₁ < a₂ • b₂

full_name: smul_le_smul
code: lemma smul_le_smul [PosSMulMono α β] [SMulPosMono α β] (ha : a₁ ≤ a₂) (hb : b₁ ≤ b₂)
    (h₁ : 0 ≤ a₁) (h₂ : 0 ≤ b₂) : a₁ • b₁ ≤ a₂ • b₂ 
goal: a₁ • b₁ ≤ a₂ • b₂

full_name: smul_le_smul'
code: lemma smul_le_smul' [PosSMulMono α β] [SMulPosMono α β] (ha : a₁ ≤ a₂) (hb : b₁ ≤ b₂) (h₂ : 0 ≤ a₂)
    (h₁ : 0 ≤ b₁) : a₁ • b₁ ≤ a₂ • b₂ 
goal: a₁ • b₁ ≤ a₂ • b₂

full_name: PosSMulStrictMono.toPosSMulReflectLE
code: instance (priority := 100) PosSMulStrictMono.toPosSMulReflectLE [PosSMulStrictMono α β] :
    PosSMulReflectLE α β 
goal: PosSMulReflectLE α β

full_name: PosSMulReflectLE.toPosSMulStrictMono
code: lemma PosSMulReflectLE.toPosSMulStrictMono [PosSMulReflectLE α β] : PosSMulStrictMono α β 
goal: PosSMulStrictMono α β

full_name: posSMulStrictMono_iff_PosSMulReflectLE
code: lemma posSMulStrictMono_iff_PosSMulReflectLE : PosSMulStrictMono α β ↔ PosSMulReflectLE α β 
goal: PosSMulStrictMono α β ↔ PosSMulReflectLE α β

full_name: PosSMulMono.toPosSMulReflectLT
code: instance PosSMulMono.toPosSMulReflectLT [PosSMulMono α β] : PosSMulReflectLT α β 
goal: PosSMulReflectLT α β

full_name: PosSMulReflectLT.toPosSMulMono
code: lemma PosSMulReflectLT.toPosSMulMono [PosSMulReflectLT α β] : PosSMulMono α β 
goal: PosSMulMono α β

full_name: posSMulMono_iff_posSMulReflectLT
code: lemma posSMulMono_iff_posSMulReflectLT : PosSMulMono α β ↔ PosSMulReflectLT α β 
goal: PosSMulMono α β ↔ PosSMulReflectLT α β

full_name: smul_max_of_nonneg
code: lemma smul_max_of_nonneg [PosSMulMono α β] (ha : 0 ≤ a) (b₁ b₂ : β) :
    a • max b₁ b₂ = max (a • b₁) (a • b₂) 
goal: a • max b₁ b₂ = max (a • b₁) (a • b₂)

full_name: smul_min_of_nonneg
code: lemma smul_min_of_nonneg [PosSMulMono α β] (ha : 0 ≤ a) (b₁ b₂ : β) :
    a • min b₁ b₂ = min (a • b₁) (a • b₂) 
goal: a • min b₁ b₂ = min (a • b₁) (a • b₂)

full_name: SMulPosReflectLE.toSMulPosStrictMono
code: lemma SMulPosReflectLE.toSMulPosStrictMono [SMulPosReflectLE α β] : SMulPosStrictMono α β 
goal: SMulPosStrictMono α β

full_name: SMulPosReflectLT.toSMulPosMono
code: lemma SMulPosReflectLT.toSMulPosMono [SMulPosReflectLT α β] : SMulPosMono α β 
goal: SMulPosMono α β

full_name: SMulPosStrictMono.toSMulPosReflectLE
code: instance (priority := 100) SMulPosStrictMono.toSMulPosReflectLE [SMulPosStrictMono α β] :
    SMulPosReflectLE α β 
goal: SMulPosReflectLE α β

full_name: SMulPosMono.toSMulPosReflectLT
code: lemma SMulPosMono.toSMulPosReflectLT [SMulPosMono α β] : SMulPosReflectLT α β 
goal: SMulPosReflectLT α β

full_name: smulPosStrictMono_iff_SMulPosReflectLE
code: lemma smulPosStrictMono_iff_SMulPosReflectLE : SMulPosStrictMono α β ↔ SMulPosReflectLE α β 
goal: SMulPosStrictMono α β ↔ SMulPosReflectLE α β

full_name: smulPosMono_iff_smulPosReflectLT
code: lemma smulPosMono_iff_smulPosReflectLT : SMulPosMono α β ↔ SMulPosReflectLT α β 
goal: SMulPosMono α β ↔ SMulPosReflectLT α β

full_name: smul_pos
code: lemma smul_pos [PosSMulStrictMono α β] (ha : 0 < a) (hb : 0 < b) : 0 < a • b 
goal: 0 < a • b

full_name: smul_neg_of_pos_of_neg
code: lemma smul_neg_of_pos_of_neg [PosSMulStrictMono α β] (ha : 0 < a) (hb : b < 0) : a • b < 0 
goal: a • b < 0

full_name: smul_pos_iff_of_pos_left
code: @[simp]
lemma smul_pos_iff_of_pos_left [PosSMulStrictMono α β] [PosSMulReflectLT α β] (ha : 0 < a) :
    0 < a • b ↔ 0 < b 
goal: 0 < a • b ↔ 0 < b

full_name: smul_neg_iff_of_pos_left
code: lemma smul_neg_iff_of_pos_left [PosSMulStrictMono α β] [PosSMulReflectLT α β] (ha : 0 < a) :
    a • b < 0 ↔ b < 0 
goal: a • b < 0 ↔ b < 0

full_name: smul_nonneg
code: lemma smul_nonneg [PosSMulMono α β] (ha : 0 ≤ a) (hb : 0 ≤ b₁) : 0 ≤ a • b₁ 
goal: 0 ≤ a • b₁

full_name: smul_nonpos_of_nonneg_of_nonpos
code: lemma smul_nonpos_of_nonneg_of_nonpos [PosSMulMono α β] (ha : 0 ≤ a) (hb : b ≤ 0) : a • b ≤ 0 
goal: a • b ≤ 0

full_name: pos_of_smul_pos_left
code: lemma pos_of_smul_pos_left [PosSMulReflectLT α β] (h : 0 < a • b) (ha : 0 ≤ a) : 0 < b 
goal: 0 < b

full_name: neg_of_smul_neg_left
code: lemma neg_of_smul_neg_left [PosSMulReflectLT α β] (h : a • b < 0) (ha : 0 ≤ a) : b < 0 
goal: b < 0

full_name: smul_pos'
code: lemma smul_pos' [SMulPosStrictMono α β] (ha : 0 < a) (hb : 0 < b) : 0 < a • b 
goal: 0 < a • b

full_name: smul_neg_of_neg_of_pos
code: lemma smul_neg_of_neg_of_pos [SMulPosStrictMono α β] (ha : a < 0) (hb : 0 < b) : a • b < 0 
goal: a • b < 0

full_name: smul_pos_iff_of_pos_right
code: @[simp]
lemma smul_pos_iff_of_pos_right [SMulPosStrictMono α β] [SMulPosReflectLT α β] (hb : 0 < b) :
    0 < a • b ↔ 0 < a 
goal: 0 < a • b ↔ 0 < a

full_name: smul_nonneg'
code: lemma smul_nonneg' [SMulPosMono α β] (ha : 0 ≤ a) (hb : 0 ≤ b₁) : 0 ≤ a • b₁ 
goal: 0 ≤ a • b₁

full_name: smul_nonpos_of_nonpos_of_nonneg
code: lemma smul_nonpos_of_nonpos_of_nonneg [SMulPosMono α β] (ha : a ≤ 0) (hb : 0 ≤ b) : a • b ≤ 0 
goal: a • b ≤ 0

full_name: pos_of_smul_pos_right
code: lemma pos_of_smul_pos_right [SMulPosReflectLT α β] (h : 0 < a • b) (hb : 0 ≤ b) : 0 < a 
goal: 0 < a

full_name: neg_of_smul_neg_right
code: lemma neg_of_smul_neg_right [SMulPosReflectLT α β] (h : a • b < 0) (hb : 0 ≤ b) : a < 0 
goal: a < 0

full_name: pos_iff_pos_of_smul_pos
code: lemma pos_iff_pos_of_smul_pos [PosSMulReflectLT α β] [SMulPosReflectLT α β] (hab : 0 < a • b) :
    0 < a ↔ 0 < b 
goal: 0 < a ↔ 0 < b

full_name: PosSMulMono.of_pos
code: /-- A constructor for `PosSMulMono` requiring you to prove `b₁ ≤ b₂ → a • b₁ ≤ a • b₂` only when
`0 < a`-/
lemma PosSMulMono.of_pos (h₀ : ∀ a : α, 0 < a → ∀ b₁ b₂ : β, b₁ ≤ b₂ → a • b₁ ≤ a • b₂) :
    PosSMulMono α β 
goal: PosSMulMono α β

full_name: PosSMulReflectLT.of_pos
code: /-- A constructor for `PosSMulReflectLT` requiring you to prove `a • b₁ < a • b₂ → b₁ < b₂` only
when `0 < a`-/
lemma PosSMulReflectLT.of_pos (h₀ : ∀ a : α, 0 < a → ∀ b₁ b₂ : β, a • b₁ < a • b₂ → b₁ < b₂) :
    PosSMulReflectLT α β 
goal: PosSMulReflectLT α β

full_name: SMulPosMono.of_pos
code: /-- A constructor for `SMulPosMono` requiring you to prove `a₁ ≤ a₂ → a₁ • b ≤ a₂ • b` only when
`0 < b`-/
lemma SMulPosMono.of_pos (h₀ : ∀ b : β, 0 < b → ∀ a₁ a₂ : α, a₁ ≤ a₂ → a₁ • b ≤ a₂ • b) :
    SMulPosMono α β 
goal: SMulPosMono α β

full_name: SMulPosReflectLT.of_pos
code: /-- A constructor for `SMulPosReflectLT` requiring you to prove `a₁ • b < a₂ • b → a₁ < a₂` only
when `0 < b`-/
lemma SMulPosReflectLT.of_pos (h₀ : ∀ b : β, 0 < b → ∀ a₁ a₂ : α, a₁ • b < a₂ • b → a₁ < a₂) :
    SMulPosReflectLT α β 
goal: SMulPosReflectLT α β

full_name: PosSMulStrictMono.toPosSMulMono
code: instance (priority := 100) PosSMulStrictMono.toPosSMulMono [PosSMulStrictMono α β] :
    PosSMulMono α β 
goal: PosSMulMono α β

full_name: SMulPosStrictMono.toSMulPosMono
code: instance (priority := 100) SMulPosStrictMono.toSMulPosMono [SMulPosStrictMono α β] :
    SMulPosMono α β 
goal: SMulPosMono α β

full_name: PosSMulReflectLE.toPosSMulReflectLT
code: instance (priority := 100) PosSMulReflectLE.toPosSMulReflectLT [PosSMulReflectLE α β] :
    PosSMulReflectLT α β 
goal: PosSMulReflectLT α β

full_name: SMulPosReflectLE.toSMulPosReflectLT
code: instance (priority := 100) SMulPosReflectLE.toSMulPosReflectLT [SMulPosReflectLE α β] :
    SMulPosReflectLT α β 
goal: SMulPosReflectLT α β

full_name: smul_eq_smul_iff_eq_and_eq_of_pos
code: lemma smul_eq_smul_iff_eq_and_eq_of_pos [PosSMulStrictMono α β] [SMulPosStrictMono α β]
    (ha : a₁ ≤ a₂) (hb : b₁ ≤ b₂) (h₁ : 0 < a₁) (h₂ : 0 < b₂) :
    a₁ • b₁ = a₂ • b₂ ↔ a₁ = a₂ ∧ b₁ = b₂ 
goal: a₁ • b₁ = a₂ • b₂ ↔ a₁ = a₂ ∧ b₁ = b₂

full_name: smul_eq_smul_iff_eq_and_eq_of_pos'
code: lemma smul_eq_smul_iff_eq_and_eq_of_pos' [PosSMulStrictMono α β] [SMulPosStrictMono α β]
    (ha : a₁ ≤ a₂) (hb : b₁ ≤ b₂) (h₂ : 0 < a₂) (h₁ : 0 < b₁) :
    a₁ • b₁ = a₂ • b₂ ↔ a₁ = a₂ ∧ b₁ = b₂ 
goal: a₁ • b₁ = a₂ • b₂ ↔ a₁ = a₂ ∧ b₁ = b₂

full_name: pos_and_pos_or_neg_and_neg_of_smul_pos
code: lemma pos_and_pos_or_neg_and_neg_of_smul_pos [PosSMulMono α β] [SMulPosMono α β] (hab : 0 < a • b) :
    0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0 
goal: 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0

full_name: neg_of_smul_pos_right
code: lemma neg_of_smul_pos_right [PosSMulMono α β] [SMulPosMono α β] (h : 0 < a • b) (ha : a ≤ 0) :
    b < 0 
goal: b < 0

full_name: neg_of_smul_pos_left
code: lemma neg_of_smul_pos_left [PosSMulMono α β] [SMulPosMono α β] (h : 0 < a • b) (ha : b ≤ 0) :
    a < 0 
goal: a < 0

full_name: neg_iff_neg_of_smul_pos
code: lemma neg_iff_neg_of_smul_pos [PosSMulMono α β] [SMulPosMono α β] (hab : 0 < a • b) :
    a < 0 ↔ b < 0 
goal: a < 0 ↔ b < 0

full_name: neg_of_smul_neg_left'
code: lemma neg_of_smul_neg_left' [SMulPosMono α β] (h : a • b < 0) (ha : 0 ≤ a) : b < 0 
goal: b < 0

full_name: neg_of_smul_neg_right'
code: lemma neg_of_smul_neg_right' [PosSMulMono α β] (h : a • b < 0) (hb : 0 ≤ b) : a < 0 
goal: a < 0

full_name: le_smul_iff_one_le_left
code: @[simp]
lemma le_smul_iff_one_le_left [SMulPosMono α β] [SMulPosReflectLE α β] (hb : 0 < b) :
    b ≤ a • b ↔ 1 ≤ a 
goal: b ≤ a • b ↔ 1 ≤ a

full_name: lt_smul_iff_one_lt_left
code: @[simp]
lemma lt_smul_iff_one_lt_left [SMulPosStrictMono α β] [SMulPosReflectLT α β] (hb : 0 < b) :
    b < a • b ↔ 1 < a 
goal: b < a • b ↔ 1 < a

full_name: smul_le_iff_le_one_left
code: @[simp]
lemma smul_le_iff_le_one_left [SMulPosMono α β] [SMulPosReflectLE α β] (hb : 0 < b) :
    a • b ≤ b ↔ a ≤ 1 
goal: a • b ≤ b ↔ a ≤ 1

full_name: smul_lt_iff_lt_one_left
code: @[simp]
lemma smul_lt_iff_lt_one_left [SMulPosStrictMono α β] [SMulPosReflectLT α β] (hb : 0 < b) :
    a • b < b ↔ a < 1 
goal: a • b < b ↔ a < 1

full_name: smul_le_of_le_one_left
code: lemma smul_le_of_le_one_left [SMulPosMono α β] (hb : 0 ≤ b) (h : a ≤ 1) : a • b ≤ b 
goal: a • b ≤ b

full_name: le_smul_of_one_le_left
code: lemma le_smul_of_one_le_left [SMulPosMono α β] (hb : 0 ≤ b) (h : 1 ≤ a) : b ≤ a • b 
goal: b ≤ a • b

full_name: smul_lt_of_lt_one_left
code: lemma smul_lt_of_lt_one_left [SMulPosStrictMono α β] (hb : 0 < b) (h : a < 1) : a • b < b 
goal: a • b < b

full_name: lt_smul_of_one_lt_left
code: lemma lt_smul_of_one_lt_left [SMulPosStrictMono α β] (hb : 0 < b) (h : 1 < a) : b < a • b 
goal: b < a • b

full_name: PosSMulMono.toPosSMulStrictMono
code: lemma PosSMulMono.toPosSMulStrictMono [PosSMulMono α β] : PosSMulStrictMono α β 
goal: PosSMulStrictMono α β

full_name: PosSMulReflectLT.toPosSMulReflectLE
code: instance PosSMulReflectLT.toPosSMulReflectLE [PosSMulReflectLT α β] : PosSMulReflectLE α β 
goal: PosSMulReflectLE α β

full_name: posSMulMono_iff_posSMulStrictMono
code: lemma posSMulMono_iff_posSMulStrictMono : PosSMulMono α β ↔ PosSMulStrictMono α β 
goal: PosSMulMono α β ↔ PosSMulStrictMono α β

full_name: PosSMulReflectLE_iff_posSMulReflectLT
code: lemma PosSMulReflectLE_iff_posSMulReflectLT : PosSMulReflectLE α β ↔ PosSMulReflectLT α β 
goal: PosSMulReflectLE α β ↔ PosSMulReflectLT α β

full_name: SMulPosMono.toSMulPosStrictMono
code: lemma SMulPosMono.toSMulPosStrictMono [SMulPosMono α β] : SMulPosStrictMono α β 
goal: SMulPosStrictMono α β

full_name: smulPosMono_iff_smulPosStrictMono
code: lemma smulPosMono_iff_smulPosStrictMono : SMulPosMono α β ↔ SMulPosStrictMono α β 
goal: SMulPosMono α β ↔ SMulPosStrictMono α β

full_name: SMulPosReflectLT.toSMulPosReflectLE
code: lemma SMulPosReflectLT.toSMulPosReflectLE [SMulPosReflectLT α β] : SMulPosReflectLE α β 
goal: SMulPosReflectLE α β

full_name: SMulPosReflectLE_iff_smulPosReflectLT
code: lemma SMulPosReflectLE_iff_smulPosReflectLT : SMulPosReflectLE α β ↔ SMulPosReflectLT α β 
goal: SMulPosReflectLE α β ↔ SMulPosReflectLT α β

full_name: inv_smul_le_iff_of_pos
code: lemma inv_smul_le_iff_of_pos [PosSMulMono α β] [PosSMulReflectLE α β] (ha : 0 < a) :
    a⁻¹ • b₁ ≤ b₂ ↔ b₁ ≤ a • b₂ 
goal: a⁻¹ • b₁ ≤ b₂ ↔ b₁ ≤ a • b₂

full_name: le_inv_smul_iff_of_pos
code: lemma le_inv_smul_iff_of_pos [PosSMulMono α β] [PosSMulReflectLE α β] (ha : 0 < a) :
    b₁ ≤ a⁻¹ • b₂ ↔ a • b₁ ≤ b₂ 
goal: b₁ ≤ a⁻¹ • b₂ ↔ a • b₁ ≤ b₂

full_name: inv_smul_lt_iff_of_pos
code: lemma inv_smul_lt_iff_of_pos [PosSMulStrictMono α β] [PosSMulReflectLT α β] (ha : 0 < a) :
    a⁻¹ • b₁ < b₂ ↔ b₁ < a • b₂ 
goal: a⁻¹ • b₁ < b₂ ↔ b₁ < a • b₂

full_name: lt_inv_smul_iff_of_pos
code: lemma lt_inv_smul_iff_of_pos [PosSMulStrictMono α β] [PosSMulReflectLT α β] (ha : 0 < a) :
    b₁ < a⁻¹ • b₂ ↔ a • b₁ < b₂ 
goal: b₁ < a⁻¹ • b₂ ↔ a • b₁ < b₂

full_name: OrderIso.smulRight_symm_apply
code: /-- Right scalar multiplication as an order isomorphism. -/
@[simps!]
def OrderIso.smulRight [PosSMulMono α β] [PosSMulReflectLE α β] {a : α} (ha : 0 < a) : β ≃o β 
goal: (RelIso.symm (OrderIso.smulRight ha)) b = a⁻¹ • b

full_name: OrderIso.smulRight_apply
code: /-- Right scalar multiplication as an order isomorphism. -/
@[simps!]
def OrderIso.smulRight [PosSMulMono α β] [PosSMulReflectLE α β] {a : α} (ha : 0 < a) : β ≃o β 
goal: (OrderIso.smulRight ha) b = a • b

full_name: OrderIso.smulRight
code: /-- Right scalar multiplication as an order isomorphism. -/
@[simps!]
def OrderIso.smulRight [PosSMulMono α β] [PosSMulReflectLE α β] {a : α} (ha : 0 < a) : β ≃o β 
goal: β ≃o β

full_name: OrderDual.instPosSMulMono
code: instance instPosSMulMono [PosSMulMono α β] : PosSMulMono α βᵒᵈ 
goal: PosSMulMono α βᵒᵈ

full_name: OrderDual.instPosSMulStrictMono
code: instance instPosSMulStrictMono [PosSMulStrictMono α β] : PosSMulStrictMono α βᵒᵈ 
goal: PosSMulStrictMono α βᵒᵈ

full_name: OrderDual.instPosSMulReflectLT
code: instance instPosSMulReflectLT [PosSMulReflectLT α β] : PosSMulReflectLT α βᵒᵈ 
goal: PosSMulReflectLT α βᵒᵈ

full_name: OrderDual.instPosSMulReflectLE
code: instance instPosSMulReflectLE [PosSMulReflectLE α β] : PosSMulReflectLE α βᵒᵈ 
goal: PosSMulReflectLE α βᵒᵈ

full_name: OrderDual.instSMulPosMono
code: instance instSMulPosMono [SMulPosMono α β] : SMulPosMono α βᵒᵈ 
goal: SMulPosMono α βᵒᵈ

full_name: OrderDual.instSMulPosStrictMono
code: instance instSMulPosStrictMono [SMulPosStrictMono α β] : SMulPosStrictMono α βᵒᵈ 
goal: SMulPosStrictMono α βᵒᵈ

full_name: OrderDual.instSMulPosReflectLT
code: instance instSMulPosReflectLT [SMulPosReflectLT α β] : SMulPosReflectLT α βᵒᵈ 
goal: SMulPosReflectLT α βᵒᵈ

full_name: OrderDual.instSMulPosReflectLE
code: instance instSMulPosReflectLE [SMulPosReflectLE α β] : SMulPosReflectLE α βᵒᵈ 
goal: SMulPosReflectLE α βᵒᵈ

full_name: smul_le_smul_of_nonpos_left
code: lemma smul_le_smul_of_nonpos_left (h : b₁ ≤ b₂) (ha : a ≤ 0) : a • b₂ ≤ a • b₁ 
goal: a • b₂ ≤ a • b₁

full_name: antitone_smul_left
code: lemma antitone_smul_left (ha : a ≤ 0) : Antitone ((a • ·) : β → β) 
goal: Antitone fun x => a • x

full_name: PosSMulMono.toSMulPosMono
code: instance PosSMulMono.toSMulPosMono : SMulPosMono α β 
goal: SMulPosMono α β

full_name: smul_lt_smul_of_neg_left
code: lemma smul_lt_smul_of_neg_left (hb : b₁ < b₂) (ha : a < 0) : a • b₂ < a • b₁ 
goal: a • b₂ < a • b₁

full_name: strictAnti_smul_left
code: lemma strictAnti_smul_left (ha : a < 0) : StrictAnti ((a • ·) : β → β) 
goal: StrictAnti fun x => a • x

full_name: PosSMulStrictMono.toSMulPosStrictMono
code: instance PosSMulStrictMono.toSMulPosStrictMono : SMulPosStrictMono α β 
goal: SMulPosStrictMono α β

full_name: le_of_smul_le_smul_of_neg
code: lemma le_of_smul_le_smul_of_neg [PosSMulReflectLE α β] (h : a • b₁ ≤ a • b₂) (ha : a < 0) :
    b₂ ≤ b₁ 
goal: b₂ ≤ b₁

full_name: lt_of_smul_lt_smul_of_nonpos
code: lemma lt_of_smul_lt_smul_of_nonpos [PosSMulReflectLT α β] (h : a • b₁ < a • b₂) (ha : a ≤ 0) :
    b₂ < b₁ 
goal: b₂ < b₁

full_name: smul_nonneg_of_nonpos_of_nonpos
code: lemma smul_nonneg_of_nonpos_of_nonpos [SMulPosMono α β] (ha : a ≤ 0) (hb : b ≤ 0) : 0 ≤ a • b 
goal: 0 ≤ a • b

full_name: smul_le_smul_iff_of_neg_left
code: lemma smul_le_smul_iff_of_neg_left [PosSMulMono α β] [PosSMulReflectLE α β] (ha : a < 0) :
    a • b₁ ≤ a • b₂ ↔ b₂ ≤ b₁ 
goal: a • b₁ ≤ a • b₂ ↔ b₂ ≤ b₁

full_name: smul_lt_smul_iff_of_neg_left
code: lemma smul_lt_smul_iff_of_neg_left (ha : a < 0) : a • b₁ < a • b₂ ↔ b₂ < b₁ 
goal: a • b₁ < a • b₂ ↔ b₂ < b₁

full_name: smul_pos_iff_of_neg_left
code: lemma smul_pos_iff_of_neg_left (ha : a < 0) : 0 < a • b ↔ b < 0 
goal: 0 < a • b ↔ b < 0

full_name: smul_neg_iff_of_neg_left
code: lemma smul_neg_iff_of_neg_left (ha : a < 0) : a • b < 0 ↔ 0 < b 
goal: a • b < 0 ↔ 0 < b

full_name: smul_add_smul_le_smul_add_smul
code: /-- Binary **rearrangement inequality**. -/
lemma smul_add_smul_le_smul_add_smul [PosSMulMono α β]
    {b₁ b₂ : α} {a d : β} (hab : b₁ ≤ b₂) (hcd : a ≤ d) : b₁ • d + b₂ • a ≤ b₁ • a + b₂ • d 
goal: b₁ • d + b₂ • a ≤ b₁ • a + b₂ • d

full_name: smul_add_smul_le_smul_add_smul'
code: /-- Binary **rearrangement inequality**. -/
lemma smul_add_smul_le_smul_add_smul' [PosSMulMono α β]
    {b₁ b₂ : α} {a d : β} (hba : b₂ ≤ b₁) (hdc : d ≤ a) : b₁ • d + b₂ • a ≤ b₁ • a + b₂ • d 
goal: b₁ • d + b₂ • a ≤ b₁ • a + b₂ • d

full_name: smul_add_smul_lt_smul_add_smul
code: /-- Binary strict **rearrangement inequality**. -/
lemma smul_add_smul_lt_smul_add_smul [PosSMulStrictMono α β]
    {b₁ b₂ : α} {a d : β} (hab : b₁ < b₂) (hcd : a < d) :
    b₁ • d + b₂ • a < b₁ • a + b₂ • d 
goal: b₁ • d + b₂ • a < b₁ • a + b₂ • d

full_name: smul_add_smul_lt_smul_add_smul'
code: /-- Binary strict **rearrangement inequality**. -/
lemma smul_add_smul_lt_smul_add_smul' [PosSMulStrictMono α β]
    {b₁ b₂ : α} {a d : β} (hba : b₂ < b₁) (hdc : d < a) :
    b₁ • d + b₂ • a < b₁ • a + b₂ • d 
goal: b₁ • d + b₂ • a < b₁ • a + b₂ • d

full_name: smul_max_of_nonpos
code: lemma smul_max_of_nonpos (ha : a ≤ 0) (b₁ b₂ : β) : a • max b₁ b₂ = min (a • b₁) (a • b₂) 
goal: a • max b₁ b₂ = min (a • b₁) (a • b₂)

full_name: smul_min_of_nonpos
code: lemma smul_min_of_nonpos (ha : a ≤ 0) (b₁ b₂ : β) : a • min b₁ b₂ = max (a • b₁) (a • b₂) 
goal: a • min b₁ b₂ = max (a • b₁) (a • b₂)

full_name: nonneg_and_nonneg_or_nonpos_and_nonpos_of_smul_nonneg
code: lemma nonneg_and_nonneg_or_nonpos_and_nonpos_of_smul_nonneg (hab : 0 ≤ a • b) :
    0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0 
goal: 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0

full_name: smul_nonneg_iff
code: lemma smul_nonneg_iff : 0 ≤ a • b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0 
goal: 0 ≤ a • b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0

full_name: smul_nonpos_iff
code: lemma smul_nonpos_iff : a • b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b 
goal: a • b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b

full_name: smul_nonneg_iff_pos_imp_nonneg
code: lemma smul_nonneg_iff_pos_imp_nonneg : 0 ≤ a • b ↔ (0 < a → 0 ≤ b) ∧ (0 < b → 0 ≤ a) 
goal: 0 ≤ a • b ↔ (0 < a → 0 ≤ b) ∧ (0 < b → 0 ≤ a)

full_name: smul_nonneg_iff_neg_imp_nonpos
code: lemma smul_nonneg_iff_neg_imp_nonpos : 0 ≤ a • b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0) 
goal: 0 ≤ a • b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0)

full_name: smul_nonpos_iff_pos_imp_nonpos
code: lemma smul_nonpos_iff_pos_imp_nonpos : a • b ≤ 0 ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a) 
goal: a • b ≤ 0 ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)

full_name: smul_nonpos_iff_neg_imp_nonneg
code: lemma smul_nonpos_iff_neg_imp_nonneg : a • b ≤ 0 ↔ (a < 0 → 0 ≤ b) ∧ (0 < b → a ≤ 0) 
goal: a • b ≤ 0 ↔ (a < 0 → 0 ≤ b) ∧ (0 < b → a ≤ 0)

full_name: PosSMulMono.toPosSMulReflectLE
code: instance (priority := 100) PosSMulMono.toPosSMulReflectLE [MulAction α β] [PosSMulMono α β] :
    PosSMulReflectLE α β 
goal: PosSMulReflectLE α β

full_name: PosSMulStrictMono.toPosSMulReflectLT
code: instance (priority := 100) PosSMulStrictMono.toPosSMulReflectLT [MulActionWithZero α β]
    [PosSMulStrictMono α β] : PosSMulReflectLT α β 
goal: PosSMulReflectLT α β

full_name: inv_smul_le_iff_of_neg
code: lemma inv_smul_le_iff_of_neg (h : a < 0) : a⁻¹ • b₁ ≤ b₂ ↔ a • b₂ ≤ b₁ 
goal: a⁻¹ • b₁ ≤ b₂ ↔ a • b₂ ≤ b₁

full_name: smul_inv_le_iff_of_neg
code: lemma smul_inv_le_iff_of_neg (h : a < 0) : b₁ ≤ a⁻¹ • b₂ ↔ b₂ ≤ a • b₁ 
goal: b₁ ≤ a⁻¹ • b₂ ↔ b₂ ≤ a • b₁

full_name: OrderIso.smulRightDual
code: /-- Left scalar multiplication as an order isomorphism. -/
@[simps!]
def OrderIso.smulRightDual (ha : a < 0) : β ≃o βᵒᵈ 
goal: β ≃o βᵒᵈ

full_name: OrderIso.smulRightDual_symm_apply
code: /-- Left scalar multiplication as an order isomorphism. -/
@[simps!]
def OrderIso.smulRightDual (ha : a < 0) : β ≃o βᵒᵈ 
goal: ∀ (a_1 : βᵒᵈ), (RelIso.symm (OrderIso.smulRightDual β ha)) a_1 = a⁻¹ • OrderDual.ofDual a_1

full_name: OrderIso.smulRightDual_apply
code: /-- Left scalar multiplication as an order isomorphism. -/
@[simps!]
def OrderIso.smulRightDual (ha : a < 0) : β ≃o βᵒᵈ 
goal: ∀ (a_1 : β), (OrderIso.smulRightDual β ha) a_1 = a • OrderDual.toDual a_1

full_name: inv_smul_lt_iff_of_neg
code: lemma inv_smul_lt_iff_of_neg (h : a < 0) : a⁻¹ • b₁ < b₂ ↔ a • b₂ < b₁ 
goal: a⁻¹ • b₁ < b₂ ↔ a • b₂ < b₁

full_name: smul_inv_lt_iff_of_neg
code: lemma smul_inv_lt_iff_of_neg (h : a < 0) : b₁ < a⁻¹ • b₂ ↔ b₂ < a • b₁ 
goal: b₁ < a⁻¹ • b₂ ↔ b₂ < a • b₁

full_name: Pi.instPosSMulMono
code: instance instPosSMulMono [∀ i, PosSMulMono α (β i)] : PosSMulMono α (∀ i, β i) 
goal: PosSMulMono α ((i : ι) → β i)

full_name: Pi.instSMulPosMono
code: instance instSMulPosMono [∀ i, SMulPosMono α (β i)] : SMulPosMono α (∀ i, β i) 
goal: SMulPosMono α ((i : ι) → β i)

full_name: Pi.instPosSMulReflectLE
code: instance instPosSMulReflectLE [∀ i, PosSMulReflectLE α (β i)] : PosSMulReflectLE α (∀ i, β i) 
goal: PosSMulReflectLE α ((i : ι) → β i)

full_name: Pi.instSMulPosReflectLE
code: instance instSMulPosReflectLE [∀ i, SMulPosReflectLE α (β i)] : SMulPosReflectLE α (∀ i, β i) 
goal: SMulPosReflectLE α ((i : ι) → β i)

full_name: Pi.instPosSMulStrictMono
code: instance instPosSMulStrictMono [∀ i, PosSMulStrictMono α (β i)] :
    PosSMulStrictMono α (∀ i, β i) 
goal: PosSMulStrictMono α ((i : ι) → β i)

full_name: Pi.instSMulPosStrictMono
code: instance instSMulPosStrictMono [∀ i, SMulPosStrictMono α (β i)] :
    SMulPosStrictMono α (∀ i, β i) 
goal: SMulPosStrictMono α ((i : ι) → β i)

full_name: Pi.instSMulPosReflectLT
code: instance instSMulPosReflectLT [∀ i, SMulPosReflectLT α (β i)] : SMulPosReflectLT α (∀ i, β i) 
goal: SMulPosReflectLT α ((i : ι) → β i)

full_name: PosSMulMono.lift
code: lemma PosSMulMono.lift [PosSMulMono α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b) : PosSMulMono α β 
goal: PosSMulMono α β

full_name: PosSMulStrictMono.lift
code: lemma PosSMulStrictMono.lift [PosSMulStrictMono α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b) : PosSMulStrictMono α β 
goal: PosSMulStrictMono α β

full_name: PosSMulReflectLE.lift
code: lemma PosSMulReflectLE.lift [PosSMulReflectLE α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b) : PosSMulReflectLE α β 
goal: PosSMulReflectLE α β

full_name: PosSMulReflectLT.lift
code: lemma PosSMulReflectLT.lift [PosSMulReflectLT α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b) : PosSMulReflectLT α β 
goal: PosSMulReflectLT α β

full_name: SMulPosMono.lift
code: lemma SMulPosMono.lift [SMulPosMono α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b)
    (zero : f 0 = 0) : SMulPosMono α β 
goal: SMulPosMono α β

full_name: SMulPosStrictMono.lift
code: lemma SMulPosStrictMono.lift [SMulPosStrictMono α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b)
    (zero : f 0 = 0) : SMulPosStrictMono α β 
goal: SMulPosStrictMono α β

full_name: SMulPosReflectLE.lift
code: lemma SMulPosReflectLE.lift [SMulPosReflectLE α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b)
    (zero : f 0 = 0) : SMulPosReflectLE α β 
goal: SMulPosReflectLE α β

full_name: SMulPosReflectLT.lift
code: lemma SMulPosReflectLT.lift [SMulPosReflectLT α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b)
    (zero : f 0 = 0) : SMulPosReflectLT α β 
goal: SMulPosReflectLT α β

full_name: OrderedSemiring.toPosSMulMonoNat
code: instance OrderedSemiring.toPosSMulMonoNat [OrderedSemiring α] : PosSMulMono ℕ α 
goal: PosSMulMono ℕ α

full_name: OrderedSemiring.toSMulPosMonoNat
code: instance OrderedSemiring.toSMulPosMonoNat [OrderedSemiring α] : SMulPosMono ℕ α 
goal: SMulPosMono ℕ α

full_name: StrictOrderedSemiring.toPosSMulStrictMonoNat
code: instance StrictOrderedSemiring.toPosSMulStrictMonoNat [StrictOrderedSemiring α] :
    PosSMulStrictMono ℕ α 
goal: PosSMulStrictMono ℕ α

full_name: StrictOrderedSemiring.toSMulPosStrictMonoNat
code: instance StrictOrderedSemiring.toSMulPosStrictMonoNat [StrictOrderedSemiring α] :
    SMulPosStrictMono ℕ α 
goal: SMulPosStrictMono ℕ α

full_name: _private.Mathlib.Algebra.Order.Module.Defs.0.Mathlib.Meta.Positivity.smul_nonneg_of_pos_of_nonneg
code: private theorem smul_nonneg_of_pos_of_nonneg (ha : 0 < a) (hb : 0 ≤ b) : 0 ≤ a • b 
goal: 0 ≤ a • b

full_name: _private.Mathlib.Algebra.Order.Module.Defs.0.Mathlib.Meta.Positivity.smul_nonneg_of_nonneg_of_pos
code: private theorem smul_nonneg_of_nonneg_of_pos (ha : 0 ≤ a) (hb : 0 < b) : 0 ≤ a • b 
goal: 0 ≤ a • b

full_name: _private.Mathlib.Algebra.Order.Module.Defs.0.Mathlib.Meta.Positivity.smul_ne_zero_of_pos_of_ne_zero
code: private theorem smul_ne_zero_of_pos_of_ne_zero [Preorder α] (ha : 0 < a) (hb : b ≠ 0) : a • b ≠ 0 
goal: a • b ≠ 0

full_name: _private.Mathlib.Algebra.Order.Module.Defs.0.Mathlib.Meta.Positivity.smul_ne_zero_of_ne_zero_of_pos
code: private theorem smul_ne_zero_of_ne_zero_of_pos [Preorder β] (ha : a ≠ 0) (hb : 0 < b) : a • b ≠ 0 
goal: a • b ≠ 0

full_name: Mathlib.Meta.Positivity.evalHSMul
code: /-- Positivity extension for HSMul, i.e. (_ • _).  -/
@[positivity HSMul.hSMul _ _]
def evalHSMul : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt