Sign type

This file defines the type of signs $\{-1, 0, 1\}$ and its basic arithmetic instances.

inductive SignType : Type

The type of signs.

• zero : SignType
• neg : SignType
• pos : SignType

@[implicit_reducible]

instance instDecidableEqSignType : DecidableEq SignType

@[implicit_reducible]

instance instInhabitedSignType : Inhabited SignType

def instInhabitedSignType.default : SignType

@[implicit_reducible]

instance instFintypeSignType : Fintype SignType

@[implicit_reducible]

instance SignType.instZero : Zero SignType

@[implicit_reducible]

instance SignType.instOne : One SignType

@[implicit_reducible]

instance SignType.instNeg : Neg SignType

@[simp]

theorem SignType.zero_eq_zero : zero = 0

@[simp]

theorem SignType.neg_eq_neg_one : neg = -1

@[simp]

theorem SignType.pos_eq_one : pos = 1

theorem SignType.trichotomy (a : SignType) : a = -1 ∨ a = 0 ∨ a = 1

@[implicit_reducible]

instance SignType.instMul : Mul SignType

inductive SignType.LE : SignType → SignType → Prop

The less-than-or-equal relation on signs.

• of_neg (a : SignType) : neg.LE a
• zero : SignType.zero.LE SignType.zero
• of_pos (a : SignType) : a.LE pos

@[implicit_reducible]

instance SignType.instLE : LE SignType

@[implicit_reducible]

instance SignType.instDecidableLE : DecidableLE SignType

@[implicit_reducible]

instance SignType.instCommGroupWithZero : CommGroupWithZero SignType

@[implicit_reducible]

instance SignType.instLinearOrder : LinearOrder SignType

@[implicit_reducible]

instance SignType.instBoundedOrder : BoundedOrder SignType

@[implicit_reducible]

instance SignType.instHasDistribNeg : HasDistribNeg SignType

def SignType.fin3Equiv : SignType ≃* Fin 3

SignType is equivalent to Fin 3.

theorem SignType.nonneg_iff {a : SignType} : 0 ≤ a ↔ a = 0 ∨ a = 1

theorem SignType.nonneg_iff_ne_neg_one {a : SignType} : 0 ≤ a ↔ a ≠ -1

theorem SignType.neg_one_lt_iff {a : SignType} : -1 < a ↔ 0 ≤ a

theorem SignType.nonpos_iff {a : SignType} : a ≤ 0 ↔ a = -1 ∨ a = 0

theorem SignType.nonpos_iff_ne_one {a : SignType} : a ≤ 0 ↔ a ≠ 1

theorem SignType.lt_one_iff {a : SignType} : a < 1 ↔ a ≤ 0

@[simp]

theorem SignType.neg_iff {a : SignType} : a < 0 ↔ a = -1

@[simp]

theorem SignType.le_neg_one_iff {a : SignType} : a ≤ -1 ↔ a = -1

@[simp]

theorem SignType.pos_iff {a : SignType} : 0 < a ↔ a = 1

@[simp]

theorem SignType.one_le_iff {a : SignType} : 1 ≤ a ↔ a = 1

@[simp]

theorem SignType.neg_one_le (a : SignType) : -1 ≤ a

@[simp]

theorem SignType.le_one (a : SignType) : a ≤ 1

@[simp]

theorem SignType.not_lt_neg_one (a : SignType) : ¬a < -1

@[simp]

theorem SignType.not_one_lt (a : SignType) : ¬1 < a

@[simp]

theorem SignType.self_eq_neg_iff {a : SignType} : a = -a ↔ a = 0

@[simp]

theorem SignType.neg_eq_self_iff {a : SignType} : -a = a ↔ a = 0

@[simp]

theorem SignType.neg_eq_zero_iff {a : SignType} : -a = 0 ↔ a = 0

@[simp]

theorem SignType.neg_one_lt_one : -1 < 1

@[simp]

theorem SignType.neg_le_neg_iff {a b : SignType} : -a ≤ -b ↔ b ≤ a

@[simp]

theorem SignType.neg_lt_neg_iff {a b : SignType} : -a < -b ↔ b < a

def SignType.cast {α : Type u_1} [Zero α] [One α] [Neg α] : SignType → α

Turn a SignType into zero, one, or minus one. This is a coercion instance.

@[implicit_reducible]

instance SignType.instCoeDep {α : Type u_1} [Zero α] [One α] [Neg α] (s : SignType) : CoeDep SignType s α

This can't be a CoeTail or Coe instance because we don't want it to fire when SignType isn't involved in the coercion (or CoeHead or CoeOut because of outParams). The only other user-exposed option is CoeDep then, which allows us to match on both given and expected type.

theorem SignType.map_cast' {α : Type u_1} [Zero α] [One α] [Neg α] {β : Type u_2} [One β] [Neg β] [Zero β] (f : α → β) (h₁ : f 1 = 1) (h₂ : f 0 = 0) (h₃ : f (-1) = -1) (s : SignType) : f ↑s = ↑s

Casting out of SignType respects composition with functions preserving 0, 1, -1.

theorem SignType.map_cast {α : Type u_2} {β : Type u_3} {F : Type u_4} [AddGroupWithOne α] [One β] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] [OneHomClass F α β] (f : F) (s : SignType) : f ↑s = ↑s

Casting out of SignType respects composition with suitable bundled homomorphism types.

@[simp]

theorem SignType.coe_zero {α : Type u_1} [Zero α] [One α] [Neg α] : ↑0 = 0

@[simp]

theorem SignType.coe_one {α : Type u_1} [Zero α] [One α] [Neg α] : ↑1 = 1

@[simp]

theorem SignType.coe_neg_one {α : Type u_1} [Zero α] [One α] [Neg α] : ↑(-1) = -1

@[simp]

theorem SignType.coe_neg {α : Type u_2} [One α] [SubtractionMonoid α] (s : SignType) : ↑(-s) = -↑s

def SignType.sign {α : Type u_1} [Zero α] [Preorder α] [DecidableLT α] : α →o SignType

The sign of an element is 1 if it's positive, -1 if negative, 0 otherwise.

theorem sign_apply {α : Type u_1} [Zero α] [Preorder α] [DecidableLT α] {a : α} : SignType.sign a = if 0 < a then 1 else if a < 0 then -1 else 0

@[simp]

theorem sign_zero {α : Type u_1} [Zero α] [Preorder α] [DecidableLT α] : SignType.sign 0 = 0

@[simp]

theorem sign_pos {α : Type u_1} [Zero α] [Preorder α] [DecidableLT α] {a : α} (ha : 0 < a) : SignType.sign a = 1

@[simp]

theorem sign_neg {α : Type u_1} [Zero α] [Preorder α] [DecidableLT α] {a : α} (ha : a < 0) : SignType.sign a = -1

theorem sign_eq_one_iff {α : Type u_1} [Zero α] [Preorder α] [DecidableLT α] {a : α} : SignType.sign a = 1 ↔ 0 < a

theorem sign_eq_neg_one_iff {α : Type u_1} [Zero α] [Preorder α] [DecidableLT α] {a : α} : SignType.sign a = -1 ↔ a < 0

theorem StrictMono.sign_comp {α : Type u_1} [Zero α] [LinearOrder α] {β : Type u_2} {F : Type u_3} [Zero β] [Preorder β] [DecidableLT β] [FunLike F α β] [ZeroHomClass F α β] {f : F} (hf : StrictMono ⇑f) (a : α) : SignType.sign (f a) = SignType.sign a

SignType.sign respects strictly monotone zero-preserving maps.

@[simp]

theorem sign_eq_zero_iff {α : Type u_1} [Zero α] [LinearOrder α] {a : α} : SignType.sign a = 0 ↔ a = 0

theorem sign_ne_zero {α : Type u_1} [Zero α] [LinearOrder α] {a : α} : SignType.sign a ≠ 0 ↔ a ≠ 0

@[simp]

theorem sign_nonneg_iff {α : Type u_1} [Zero α] [LinearOrder α] {a : α} : 0 ≤ SignType.sign a ↔ 0 ≤ a

@[simp]

theorem sign_nonpos_iff {α : Type u_1} [Zero α] [LinearOrder α] {a : α} : SignType.sign a ≤ 0 ↔ a ≤ 0

theorem sign_eq_sign_or_eq_neg {α : Type u_1} [Zero α] [LinearOrder α] {a b : α} (ha : a ≠ 0) (hb : b ≠ 0) : SignType.sign a = SignType.sign b ∨ SignType.sign a = -SignType.sign b

theorem sign_one {α : Type u_1} [Semiring α] [PartialOrder α] [IsOrderedRing α] [DecidableLT α] [Nontrivial α] : SignType.sign 1 = 1

theorem Left.sign_neg {α : Type u_1} [AddGroup α] [Preorder α] [DecidableLT α] [AddLeftStrictMono α] (a : α) : SignType.sign (-a) = -SignType.sign a

theorem Right.sign_neg {α : Type u_1} [AddGroup α] [Preorder α] [DecidableLT α] [AddRightStrictMono α] (a : α) : SignType.sign (-a) = -SignType.sign a

theorem Int.sign_eq_sign (n : ℤ) : n.sign = ↑(SignType.sign n)