File: Mathlib/Algebra/Associated/Basic.lean

full_name: Prime
code: /-- An element `p` of a commutative monoid with zero (e.g., a ring) is called *prime*,
if it's not zero, not a unit, and `p ∣ a * b → p ∣ a ∨ p ∣ b` for all `a`, `b`. -/
def Prime (p : α) : Prop 
goal: Prop

full_name: Prime.ne_zero
code: theorem ne_zero : p ≠ 0 
goal: p ≠ 0

full_name: Prime.not_unit
code: theorem not_unit : ¬IsUnit p 
goal: ¬IsUnit p

full_name: Prime.not_dvd_one
code: theorem not_dvd_one : ¬p ∣ 1 
goal: ¬p ∣ 1

full_name: Prime.ne_one
code: theorem ne_one : p ≠ 1 
goal: p ≠ 1

full_name: Prime.dvd_or_dvd
code: theorem dvd_or_dvd (hp : Prime p) {a b : α} (h : p ∣ a * b) : p ∣ a ∨ p ∣ b 
goal: p ∣ a ∨ p ∣ b

full_name: Prime.dvd_mul
code: theorem dvd_mul {a b : α} : p ∣ a * b ↔ p ∣ a ∨ p ∣ b 
goal: p ∣ a * b ↔ p ∣ a ∨ p ∣ b

full_name: Prime.isPrimal
code: theorem isPrimal (hp : Prime p) : IsPrimal p 
goal: IsPrimal p

full_name: Prime.not_dvd_mul
code: theorem not_dvd_mul {a b : α} (ha : ¬ p ∣ a) (hb : ¬ p ∣ b) : ¬ p ∣ a * b 
goal: ¬p ∣ a * b

full_name: Prime.dvd_of_dvd_pow
code: theorem dvd_of_dvd_pow (hp : Prime p) {a : α} {n : ℕ} (h : p ∣ a ^ n) : p ∣ a 
goal: p ∣ a

full_name: Prime.dvd_pow_iff_dvd
code: theorem dvd_pow_iff_dvd {a : α} {n : ℕ} (hn : n ≠ 0) : p ∣ a ^ n ↔ p ∣ a 
goal: p ∣ a ^ n ↔ p ∣ a

full_name: not_prime_zero
code: @[simp]
theorem not_prime_zero : ¬Prime (0 : α) 
goal: ¬Prime 0

full_name: not_prime_one
code: @[simp]
theorem not_prime_one : ¬Prime (1 : α) 
goal: ¬Prime 1

full_name: comap_prime
code: theorem comap_prime (hinv : ∀ a, g (f a : β) = a) (hp : Prime (f p)) : Prime p 
goal: Prime p

full_name: MulEquiv.prime_iff
code: theorem MulEquiv.prime_iff (e : α ≃* β) : Prime p ↔ Prime (e p) 
goal: Prime p ↔ Prime (e p)

full_name: Prime.left_dvd_or_dvd_right_of_dvd_mul
code: theorem Prime.left_dvd_or_dvd_right_of_dvd_mul [CancelCommMonoidWithZero α] {p : α} (hp : Prime p)
    {a b : α} : a ∣ p * b → p ∣ a ∨ a ∣ b 
goal: a ∣ p * b → p ∣ a ∨ a ∣ b

full_name: Prime.pow_dvd_of_dvd_mul_left
code: theorem Prime.pow_dvd_of_dvd_mul_left [CancelCommMonoidWithZero α] {p a b : α} (hp : Prime p)
    (n : ℕ) (h : ¬p ∣ a) (h' : p ^ n ∣ a * b) : p ^ n ∣ b 
goal: p ^ n ∣ b

full_name: Prime.pow_dvd_of_dvd_mul_right
code: theorem Prime.pow_dvd_of_dvd_mul_right [CancelCommMonoidWithZero α] {p a b : α} (hp : Prime p)
    (n : ℕ) (h : ¬p ∣ b) (h' : p ^ n ∣ a * b) : p ^ n ∣ a 
goal: p ^ n ∣ a

full_name: Prime.dvd_of_pow_dvd_pow_mul_pow_of_square_not_dvd
code: theorem Prime.dvd_of_pow_dvd_pow_mul_pow_of_square_not_dvd [CancelCommMonoidWithZero α] {p a b : α}
    {n : ℕ} (hp : Prime p) (hpow : p ^ n.succ ∣ a ^ n.succ * b ^ n) (hb : ¬p ^ 2 ∣ b) : p ∣ a 
goal: p ∣ a

full_name: prime_pow_succ_dvd_mul
code: theorem prime_pow_succ_dvd_mul {α : Type*} [CancelCommMonoidWithZero α] {p x y : α} (h : Prime p)
    {i : ℕ} (hxy : p ^ (i + 1) ∣ x * y) : p ^ (i + 1) ∣ x ∨ p ∣ y 
goal: p ^ (i + 1) ∣ x ∨ p ∣ y

full_name: Irreducible.isUnit_or_isUnit'
code: /-- `Irreducible p` states that `p` is non-unit and only factors into units.

We explicitly avoid stating that `p` is non-zero, this would require a semiring. Assuming only a
monoid allows us to reuse irreducible for associated elements.
-/
structure Irreducible [Monoid α] (p : α) : Prop where
  /-- `p` is not a unit -/
  not_unit : ¬IsUnit p
  /-- if `p` factors then one factor is a unit -/
  isUnit_or_isUnit' : ∀ a b, p = a * b → IsUnit a ∨ IsUnit b
goal: p = a * b → IsUnit a ∨ IsUnit b

full_name: Irreducible.not_unit
code: /-- `Irreducible p` states that `p` is non-unit and only factors into units.

We explicitly avoid stating that `p` is non-zero, this would require a semiring. Assuming only a
monoid allows us to reuse irreducible for associated elements.
-/
structure Irreducible [Monoid α] (p : α) : Prop where
  /-- `p` is not a unit -/
  not_unit : ¬IsUnit p
  /-- if `p` factors then one factor is a unit -/
  isUnit_or_isUnit' : ∀ a b, p = a * b → IsUnit a ∨ IsUnit b
goal: ¬IsUnit p

full_name: Irreducible
code: /-- `Irreducible p` states that `p` is non-unit and only factors into units.

We explicitly avoid stating that `p` is non-zero, this would require a semiring. Assuming only a
monoid allows us to reuse irreducible for associated elements.
-/
structure Irreducible [Monoid α] (p : α) : Prop where
  /-- `p` is not a unit -/
  not_unit : ¬IsUnit p
  /-- if `p` factors then one factor is a unit -/
  isUnit_or_isUnit' : ∀ a b, p = a * b → IsUnit a ∨ IsUnit b
goal: Prop

full_name: Irreducible.not_dvd_one
code: theorem not_dvd_one [CommMonoid α] {p : α} (hp : Irreducible p) : ¬p ∣ 1 
goal: ¬p ∣ 1

full_name: Irreducible.isUnit_or_isUnit
code: theorem isUnit_or_isUnit [Monoid α] {p : α} (hp : Irreducible p) {a b : α} (h : p = a * b) :
    IsUnit a ∨ IsUnit b 
goal: IsUnit a ∨ IsUnit b

full_name: irreducible_iff
code: theorem irreducible_iff [Monoid α] {p : α} :
    Irreducible p ↔ ¬IsUnit p ∧ ∀ a b, p = a * b → IsUnit a ∨ IsUnit b 
goal: Irreducible p ↔ ¬IsUnit p ∧ ∀ (a b : α), p = a * b → IsUnit a ∨ IsUnit b

full_name: not_irreducible_one
code: @[simp]
theorem not_irreducible_one [Monoid α] : ¬Irreducible (1 : α) 
goal: ¬Irreducible 1

full_name: Irreducible.ne_one
code: theorem Irreducible.ne_one [Monoid α] : ∀ {p : α}, Irreducible p → p ≠ 1
  
goal: Irreducible p → p ≠ 1

full_name: not_irreducible_zero
code: @[simp]
theorem not_irreducible_zero [MonoidWithZero α] : ¬Irreducible (0 : α)
  
goal: ¬Irreducible 0

full_name: Irreducible.ne_zero
code: theorem Irreducible.ne_zero [MonoidWithZero α] : ∀ {p : α}, Irreducible p → p ≠ 0
  
goal: Irreducible p → p ≠ 0

full_name: of_irreducible_mul
code: theorem of_irreducible_mul {α} [Monoid α] {x y : α} : Irreducible (x * y) → IsUnit x ∨ IsUnit y
  
goal: Irreducible (x * y) → IsUnit x ∨ IsUnit y

full_name: not_irreducible_pow
code: theorem not_irreducible_pow {α} [Monoid α] {x : α} {n : ℕ} (hn : n ≠ 1) :
    ¬ Irreducible (x ^ n) 
goal: ¬Irreducible (x ^ n)

full_name: irreducible_or_factor
code: theorem irreducible_or_factor {α} [Monoid α] (x : α) (h : ¬IsUnit x) :
    Irreducible x ∨ ∃ a b, ¬IsUnit a ∧ ¬IsUnit b ∧ a * b = x 
goal: Irreducible x ∨ ∃ a b, ¬IsUnit a ∧ ¬IsUnit b ∧ a * b = x

full_name: Irreducible.dvd_symm
code: /-- If `p` and `q` are irreducible, then `p ∣ q` implies `q ∣ p`. -/
theorem Irreducible.dvd_symm [Monoid α] {p q : α} (hp : Irreducible p) (hq : Irreducible q) :
    p ∣ q → q ∣ p 
goal: p ∣ q → q ∣ p

full_name: Irreducible.dvd_comm
code: theorem Irreducible.dvd_comm [Monoid α] {p q : α} (hp : Irreducible p) (hq : Irreducible q) :
    p ∣ q ↔ q ∣ p 
goal: p ∣ q ↔ q ∣ p

full_name: irreducible_units_mul
code: theorem irreducible_units_mul (a : αˣ) (b : α) : Irreducible (↑a * b) ↔ Irreducible b 
goal: Irreducible (↑a * b) ↔ Irreducible b

full_name: irreducible_isUnit_mul
code: theorem irreducible_isUnit_mul {a b : α} (h : IsUnit a) : Irreducible (a * b) ↔ Irreducible b 
goal: Irreducible (a * b) ↔ Irreducible b

full_name: irreducible_mul_units
code: theorem irreducible_mul_units (a : αˣ) (b : α) : Irreducible (b * ↑a) ↔ Irreducible b 
goal: Irreducible (b * ↑a) ↔ Irreducible b

full_name: irreducible_mul_isUnit
code: theorem irreducible_mul_isUnit {a b : α} (h : IsUnit a) : Irreducible (b * a) ↔ Irreducible b 
goal: Irreducible (b * a) ↔ Irreducible b

full_name: irreducible_mul_iff
code: theorem irreducible_mul_iff {a b : α} :
    Irreducible (a * b) ↔ Irreducible a ∧ IsUnit b ∨ Irreducible b ∧ IsUnit a 
goal: Irreducible (a * b) ↔ Irreducible a ∧ IsUnit b ∨ Irreducible b ∧ IsUnit a

full_name: Irreducible.not_square
code: theorem Irreducible.not_square (ha : Irreducible a) : ¬IsSquare a 
goal: ¬IsSquare a

full_name: IsSquare.not_irreducible
code: theorem IsSquare.not_irreducible (ha : IsSquare a) : ¬Irreducible a 
goal: ¬Irreducible a

full_name: Irreducible.prime_of_isPrimal
code: theorem Irreducible.prime_of_isPrimal {a : α}
    (irr : Irreducible a) (primal : IsPrimal a) : Prime a 
goal: Prime a

full_name: Irreducible.prime
code: theorem Irreducible.prime [DecompositionMonoid α] {a : α} (irr : Irreducible a) : Prime a 
goal: Prime a

full_name: Prime.irreducible
code: protected theorem Prime.irreducible (hp : Prime p) : Irreducible p 
goal: Irreducible p

full_name: irreducible_iff_prime
code: theorem irreducible_iff_prime [DecompositionMonoid α] {a : α} : Irreducible a ↔ Prime a 
goal: Irreducible a ↔ Prime a

full_name: succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul
code: theorem succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul (hp : Prime p) {a b : α} {k l : ℕ} :
    p ^ k ∣ a → p ^ l ∣ b → p ^ (k + l + 1) ∣ a * b → p ^ (k + 1) ∣ a ∨ p ^ (l + 1) ∣ b 
goal: p ^ k ∣ a → p ^ l ∣ b → p ^ (k + l + 1) ∣ a * b → p ^ (k + 1) ∣ a ∨ p ^ (l + 1) ∣ b

full_name: Prime.not_square
code: theorem Prime.not_square (hp : Prime p) : ¬IsSquare p 
goal: ¬IsSquare p

full_name: IsSquare.not_prime
code: theorem IsSquare.not_prime (ha : IsSquare a) : ¬Prime a 
goal: ¬Prime a

full_name: not_prime_pow
code: theorem not_prime_pow {n : ℕ} (hn : n ≠ 1) : ¬Prime (a ^ n) 
goal: ¬Prime (a ^ n)

full_name: Associated
code: /-- Two elements of a `Monoid` are `Associated` if one of them is another one
multiplied by a unit on the right. -/
def Associated [Monoid α] (x y : α) : Prop 
goal: Prop

full_name: «_aux_Mathlib_Algebra_Associated_Basic___macroRules_term_~ᵤ__1»
code: /-- Notation for two elements of a monoid are associated, i.e.
if one of them is another one multiplied by a unit on the right. -/
local infixl:50 " ~ᵤ " => Associated
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Associated_Basic___unexpand_Associated_1
code: /-- Notation for two elements of a monoid are associated, i.e.
if one of them is another one multiplied by a unit on the right. -/
local infixl:50 " ~ᵤ " => Associated
goal: Lean.PrettyPrinter.Unexpander

full_name: Associated.refl
code: @[refl]
protected theorem refl [Monoid α] (x : α) : x ~ᵤ x 
goal: x ~ᵤ x

full_name: Associated.rfl
code: protected theorem rfl [Monoid α] {x : α} : x ~ᵤ x 
goal: x ~ᵤ x

full_name: Associated.instIsRefl
code: instance [Monoid α] : IsRefl α Associated 
goal: IsRefl α Associated

full_name: Associated.symm
code: @[symm]
protected theorem symm [Monoid α] : ∀ {x y : α}, x ~ᵤ y → y ~ᵤ x
  
goal: x ~ᵤ y → y ~ᵤ x

full_name: Associated.instIsSymm
code: instance [Monoid α] : IsSymm α Associated 
goal: IsSymm α Associated

full_name: Associated.comm
code: protected theorem comm [Monoid α] {x y : α} : x ~ᵤ y ↔ y ~ᵤ x 
goal: x ~ᵤ y ↔ y ~ᵤ x

full_name: Associated.trans
code: @[trans]
protected theorem trans [Monoid α] : ∀ {x y z : α}, x ~ᵤ y → y ~ᵤ z → x ~ᵤ z
  
goal: x ~ᵤ y → y ~ᵤ z → x ~ᵤ z

full_name: Associated.instIsTrans
code: instance [Monoid α] : IsTrans α Associated 
goal: IsTrans α Associated

full_name: Associated.setoid
code: /-- The setoid of the relation `x ~ᵤ y` iff there is a unit `u` such that `x * u = y` -/
protected def setoid (α : Type*) [Monoid α] :
    Setoid α 
goal: Setoid α

full_name: Associated.map
code: theorem map {M N : Type*} [Monoid M] [Monoid N] {F : Type*} [FunLike F M N] [MonoidHomClass F M N]
    (f : F) {x y : M} (ha : Associated x y) : Associated (f x) (f y) 
goal: f x ~ᵤ f y

full_name: unit_associated_one
code: theorem unit_associated_one [Monoid α] {u : αˣ} : (u : α) ~ᵤ 1 
goal: ↑u ~ᵤ 1

full_name: associated_one_iff_isUnit
code: @[simp]
theorem associated_one_iff_isUnit [Monoid α] {a : α} : (a : α) ~ᵤ 1 ↔ IsUnit a 
goal: a ~ᵤ 1 ↔ IsUnit a

full_name: associated_zero_iff_eq_zero
code: @[simp]
theorem associated_zero_iff_eq_zero [MonoidWithZero α] (a : α) : a ~ᵤ 0 ↔ a = 0 
goal: a ~ᵤ 0 ↔ a = 0

full_name: associated_one_of_mul_eq_one
code: theorem associated_one_of_mul_eq_one [CommMonoid α] {a : α} (b : α) (hab : a * b = 1) : a ~ᵤ 1 
goal: a ~ᵤ 1

full_name: associated_one_of_associated_mul_one
code: theorem associated_one_of_associated_mul_one [CommMonoid α] {a b : α} : a * b ~ᵤ 1 → a ~ᵤ 1
  
goal: a * b ~ᵤ 1 → a ~ᵤ 1

full_name: associated_mul_unit_left
code: theorem associated_mul_unit_left {β : Type*} [Monoid β] (a u : β) (hu : IsUnit u) :
    Associated (a * u) a 
goal: a * u ~ᵤ a

full_name: associated_unit_mul_left
code: theorem associated_unit_mul_left {β : Type*} [CommMonoid β] (a u : β) (hu : IsUnit u) :
    Associated (u * a) a 
goal: u * a ~ᵤ a

full_name: associated_mul_unit_right
code: theorem associated_mul_unit_right {β : Type*} [Monoid β] (a u : β) (hu : IsUnit u) :
    Associated a (a * u) 
goal: a ~ᵤ a * u

full_name: associated_unit_mul_right
code: theorem associated_unit_mul_right {β : Type*} [CommMonoid β] (a u : β) (hu : IsUnit u) :
    Associated a (u * a) 
goal: a ~ᵤ u * a

full_name: associated_mul_isUnit_left_iff
code: theorem associated_mul_isUnit_left_iff {β : Type*} [Monoid β] {a u b : β} (hu : IsUnit u) :
    Associated (a * u) b ↔ Associated a b 
goal: a * u ~ᵤ b ↔ a ~ᵤ b

full_name: associated_isUnit_mul_left_iff
code: theorem associated_isUnit_mul_left_iff {β : Type*} [CommMonoid β] {u a b : β} (hu : IsUnit u) :
    Associated (u * a) b ↔ Associated a b 
goal: u * a ~ᵤ b ↔ a ~ᵤ b

full_name: associated_mul_isUnit_right_iff
code: theorem associated_mul_isUnit_right_iff {β : Type*} [Monoid β] {a b u : β} (hu : IsUnit u) :
    Associated a (b * u) ↔ Associated a b 
goal: a ~ᵤ b * u ↔ a ~ᵤ b

full_name: associated_isUnit_mul_right_iff
code: theorem associated_isUnit_mul_right_iff {β : Type*} [CommMonoid β] {a u b : β} (hu : IsUnit u) :
    Associated a (u * b) ↔ Associated a b 
goal: a ~ᵤ u * b ↔ a ~ᵤ b

full_name: associated_mul_unit_left_iff
code: @[simp]
theorem associated_mul_unit_left_iff {β : Type*} [Monoid β] {a b : β} {u : Units β} :
    Associated (a * u) b ↔ Associated a b 
goal: a * ↑u ~ᵤ b ↔ a ~ᵤ b

full_name: associated_unit_mul_left_iff
code: @[simp]
theorem associated_unit_mul_left_iff {β : Type*} [CommMonoid β] {a b : β} {u : Units β} :
    Associated (↑u * a) b ↔ Associated a b 
goal: ↑u * a ~ᵤ b ↔ a ~ᵤ b

full_name: associated_mul_unit_right_iff
code: @[simp]
theorem associated_mul_unit_right_iff {β : Type*} [Monoid β] {a b : β} {u : Units β} :
    Associated a (b * u) ↔ Associated a b 
goal: a ~ᵤ b * ↑u ↔ a ~ᵤ b

full_name: associated_unit_mul_right_iff
code: @[simp]
theorem associated_unit_mul_right_iff {β : Type*} [CommMonoid β] {a b : β} {u : Units β} :
    Associated a (↑u * b) ↔ Associated a b 
goal: a ~ᵤ ↑u * b ↔ a ~ᵤ b

full_name: Associated.mul_left
code: theorem Associated.mul_left [Monoid α] (a : α) {b c : α} (h : b ~ᵤ c) : a * b ~ᵤ a * c 
goal: a * b ~ᵤ a * c

full_name: Associated.mul_right
code: theorem Associated.mul_right [CommMonoid α] {a b : α} (h : a ~ᵤ b) (c : α) : a * c ~ᵤ b * c 
goal: a * c ~ᵤ b * c

full_name: Associated.mul_mul
code: theorem Associated.mul_mul [CommMonoid α] {a₁ a₂ b₁ b₂ : α}
    (h₁ : a₁ ~ᵤ b₁) (h₂ : a₂ ~ᵤ b₂) : a₁ * a₂ ~ᵤ b₁ * b₂ 
goal: a₁ * a₂ ~ᵤ b₁ * b₂

full_name: Associated.pow_pow
code: theorem Associated.pow_pow [CommMonoid α] {a b : α} {n : ℕ} (h : a ~ᵤ b) : a ^ n ~ᵤ b ^ n 
goal: a ^ n ~ᵤ b ^ n

full_name: Associated.dvd
code: protected theorem Associated.dvd [Monoid α] {a b : α} : a ~ᵤ b → a ∣ b 
goal: a ~ᵤ b → a ∣ b

full_name: Associated.dvd'
code: protected theorem Associated.dvd' [Monoid α] {a b : α} (h : a ~ᵤ b) : b ∣ a 
goal: b ∣ a

full_name: Associated.dvd_dvd
code: protected theorem Associated.dvd_dvd [Monoid α] {a b : α} (h : a ~ᵤ b) : a ∣ b ∧ b ∣ a 
goal: a ∣ b ∧ b ∣ a

full_name: associated_of_dvd_dvd
code: theorem associated_of_dvd_dvd [CancelMonoidWithZero α] {a b : α} (hab : a ∣ b) (hba : b ∣ a) :
    a ~ᵤ b 
goal: a ~ᵤ b

full_name: dvd_dvd_iff_associated
code: theorem dvd_dvd_iff_associated [CancelMonoidWithZero α] {a b : α} : a ∣ b ∧ b ∣ a ↔ a ~ᵤ b 
goal: a ∣ b ∧ b ∣ a ↔ a ~ᵤ b

full_name: instDecidableRelAssociatedOfDvd
code: instance [CancelMonoidWithZero α] [DecidableRel ((· ∣ ·) : α → α → Prop)] :
    DecidableRel ((· ~ᵤ ·) : α → α → Prop) 
goal: DecidableRel fun x x_1 => x ~ᵤ x_1

full_name: Associated.dvd_iff_dvd_left
code: theorem Associated.dvd_iff_dvd_left [Monoid α] {a b c : α} (h : a ~ᵤ b) : a ∣ c ↔ b ∣ c 
goal: a ∣ c ↔ b ∣ c

full_name: Associated.dvd_iff_dvd_right
code: theorem Associated.dvd_iff_dvd_right [Monoid α] {a b c : α} (h : b ~ᵤ c) : a ∣ b ↔ a ∣ c 
goal: a ∣ b ↔ a ∣ c

full_name: Associated.eq_zero_iff
code: theorem Associated.eq_zero_iff [MonoidWithZero α] {a b : α} (h : a ~ᵤ b) : a = 0 ↔ b = 0 
goal: a = 0 ↔ b = 0

full_name: Associated.ne_zero_iff
code: theorem Associated.ne_zero_iff [MonoidWithZero α] {a b : α} (h : a ~ᵤ b) : a ≠ 0 ↔ b ≠ 0 
goal: a ≠ 0 ↔ b ≠ 0

full_name: Associated.neg_left
code: theorem Associated.neg_left [Monoid α] [HasDistribNeg α] {a b : α} (h : Associated a b) :
    Associated (-a) b 
goal: -a ~ᵤ b

full_name: Associated.neg_right
code: theorem Associated.neg_right [Monoid α] [HasDistribNeg α] {a b : α} (h : Associated a b) :
    Associated a (-b) 
goal: a ~ᵤ -b

full_name: Associated.neg_neg
code: theorem Associated.neg_neg [Monoid α] [HasDistribNeg α] {a b : α} (h : Associated a b) :
    Associated (-a) (-b) 
goal: -a ~ᵤ -b

full_name: Associated.prime
code: protected theorem Associated.prime [CommMonoidWithZero α] {p q : α} (h : p ~ᵤ q) (hp : Prime p) :
    Prime q 
goal: Prime q

full_name: prime_mul_iff
code: theorem prime_mul_iff [CancelCommMonoidWithZero α] {x y : α} :
    Prime (x * y) ↔ (Prime x ∧ IsUnit y) ∨ (IsUnit x ∧ Prime y) 
goal: Prime (x * y) ↔ Prime x ∧ IsUnit y ∨ IsUnit x ∧ Prime y

full_name: prime_pow_iff
code: @[simp]
lemma prime_pow_iff [CancelCommMonoidWithZero α] {p : α} {n : ℕ} :
    Prime (p ^ n) ↔ Prime p ∧ n = 1 
goal: Prime (p ^ n) ↔ Prime p ∧ n = 1

full_name: Irreducible.dvd_iff
code: theorem Irreducible.dvd_iff [Monoid α] {x y : α} (hx : Irreducible x) :
    y ∣ x ↔ IsUnit y ∨ Associated x y 
goal: y ∣ x ↔ IsUnit y ∨ x ~ᵤ y

full_name: Irreducible.associated_of_dvd
code: theorem Irreducible.associated_of_dvd [Monoid α] {p q : α} (p_irr : Irreducible p)
    (q_irr : Irreducible q) (dvd : p ∣ q) : Associated p q 
goal: p ~ᵤ q

full_name: Irreducible.dvd_irreducible_iff_associated
code: theorem Irreducible.dvd_irreducible_iff_associated [Monoid α] {p q : α}
    (pp : Irreducible p) (qp : Irreducible q) : p ∣ q ↔ Associated p q 
goal: p ∣ q ↔ p ~ᵤ q

full_name: Prime.associated_of_dvd
code: theorem Prime.associated_of_dvd [CancelCommMonoidWithZero α] {p q : α} (p_prime : Prime p)
    (q_prime : Prime q) (dvd : p ∣ q) : Associated p q 
goal: p ~ᵤ q

full_name: Prime.dvd_prime_iff_associated
code: theorem Prime.dvd_prime_iff_associated [CancelCommMonoidWithZero α] {p q : α} (pp : Prime p)
    (qp : Prime q) : p ∣ q ↔ Associated p q 
goal: p ∣ q ↔ p ~ᵤ q

full_name: Associated.prime_iff
code: theorem Associated.prime_iff [CommMonoidWithZero α] {p q : α} (h : p ~ᵤ q) : Prime p ↔ Prime q 
goal: Prime p ↔ Prime q

full_name: Associated.isUnit
code: protected theorem Associated.isUnit [Monoid α] {a b : α} (h : a ~ᵤ b) : IsUnit a → IsUnit b 
goal: IsUnit a → IsUnit b

full_name: Associated.isUnit_iff
code: theorem Associated.isUnit_iff [Monoid α] {a b : α} (h : a ~ᵤ b) : IsUnit a ↔ IsUnit b 
goal: IsUnit a ↔ IsUnit b

full_name: Irreducible.isUnit_iff_not_associated_of_dvd
code: theorem Irreducible.isUnit_iff_not_associated_of_dvd [Monoid α]
    {x y : α} (hx : Irreducible x) (hy : y ∣ x) : IsUnit y ↔ ¬ Associated x y 
goal: IsUnit y ↔ ¬x ~ᵤ y

full_name: Associated.irreducible
code: protected theorem Associated.irreducible [Monoid α] {p q : α} (h : p ~ᵤ q) (hp : Irreducible p) :
    Irreducible q 
goal: Irreducible q

full_name: Associated.irreducible_iff
code: protected theorem Associated.irreducible_iff [Monoid α] {p q : α} (h : p ~ᵤ q) :
    Irreducible p ↔ Irreducible q 
goal: Irreducible p ↔ Irreducible q

full_name: Associated.of_mul_left
code: theorem Associated.of_mul_left [CancelCommMonoidWithZero α] {a b c d : α} (h : a * b ~ᵤ c * d)
    (h₁ : a ~ᵤ c) (ha : a ≠ 0) : b ~ᵤ d 
goal: b ~ᵤ d

full_name: Associated.of_mul_right
code: theorem Associated.of_mul_right [CancelCommMonoidWithZero α] {a b c d : α} :
    a * b ~ᵤ c * d → b ~ᵤ d → b ≠ 0 → a ~ᵤ c 
goal: a * b ~ᵤ c * d → b ~ᵤ d → b ≠ 0 → a ~ᵤ c

full_name: Associated.of_pow_associated_of_prime
code: theorem Associated.of_pow_associated_of_prime [CancelCommMonoidWithZero α] {p₁ p₂ : α} {k₁ k₂ : ℕ}
    (hp₁ : Prime p₁) (hp₂ : Prime p₂) (hk₁ : 0 < k₁) (h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂) : p₁ ~ᵤ p₂ 
goal: p₁ ~ᵤ p₂

full_name: Associated.of_pow_associated_of_prime'
code: theorem Associated.of_pow_associated_of_prime' [CancelCommMonoidWithZero α] {p₁ p₂ : α} {k₁ k₂ : ℕ}
    (hp₁ : Prime p₁) (hp₂ : Prime p₂) (hk₂ : 0 < k₂) (h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂) : p₁ ~ᵤ p₂ 
goal: p₁ ~ᵤ p₂

full_name: Irreducible.isRelPrime_iff_not_dvd
code: /-- See also `Irreducible.coprime_iff_not_dvd`. -/
lemma Irreducible.isRelPrime_iff_not_dvd [Monoid α] {p n : α} (hp : Irreducible p) :
    IsRelPrime p n ↔ ¬ p ∣ n 
goal: IsRelPrime p n ↔ ¬p ∣ n

full_name: Irreducible.dvd_or_isRelPrime
code: lemma Irreducible.dvd_or_isRelPrime [Monoid α] {p n : α} (hp : Irreducible p) :
    p ∣ n ∨ IsRelPrime p n 
goal: p ∣ n ∨ IsRelPrime p n

full_name: associated_iff_eq
code: theorem associated_iff_eq {x y : α} : x ~ᵤ y ↔ x = y 
goal: x ~ᵤ y ↔ x = y

full_name: associated_eq_eq
code: theorem associated_eq_eq : (Associated : α → α → Prop) = Eq 
goal: Associated = Eq

full_name: prime_dvd_prime_iff_eq
code: theorem prime_dvd_prime_iff_eq {M : Type*} [CancelCommMonoidWithZero M] [Unique Mˣ] {p q : M}
    (pp : Prime p) (qp : Prime q) : p ∣ q ↔ p = q 
goal: p ∣ q ↔ p = q

full_name: eq_of_prime_pow_eq
code: theorem eq_of_prime_pow_eq (hp₁ : Prime p₁) (hp₂ : Prime p₂) (hk₁ : 0 < k₁)
    (h : p₁ ^ k₁ = p₂ ^ k₂) : p₁ = p₂ 
goal: p₁ = p₂

full_name: eq_of_prime_pow_eq'
code: theorem eq_of_prime_pow_eq' (hp₁ : Prime p₁) (hp₂ : Prime p₂) (hk₁ : 0 < k₂)
    (h : p₁ ^ k₁ = p₂ ^ k₂) : p₁ = p₂ 
goal: p₁ = p₂

full_name: Associates
code: /-- The quotient of a monoid by the `Associated` relation. Two elements `x` and `y`
  are associated iff there is a unit `u` such that `x * u = y`. There is a natural
  monoid structure on `Associates α`. -/
abbrev Associates (α : Type*) [Monoid α] : Type _ 
goal: Type u_5

full_name: Associates.mk
code: /-- The canonical quotient map from a monoid `α` into the `Associates` of `α` -/
protected abbrev mk {α : Type*} [Monoid α] (a : α) : Associates α 
goal: Associates α

full_name: Associates.instInhabited
code: instance [Monoid α] : Inhabited (Associates α) 
goal: Inhabited (Associates α)

full_name: Associates.mk_eq_mk_iff_associated
code: theorem mk_eq_mk_iff_associated [Monoid α] {a b : α} : Associates.mk a = Associates.mk b ↔ a ~ᵤ b 
goal: Associates.mk a = Associates.mk b ↔ a ~ᵤ b

full_name: Associates.quotient_mk_eq_mk
code: theorem quotient_mk_eq_mk [Monoid α] (a : α) : ⟦a⟧ = Associates.mk a 
goal: ⟦a⟧ = Associates.mk a

full_name: Associates.quot_mk_eq_mk
code: theorem quot_mk_eq_mk [Monoid α] (a : α) : Quot.mk Setoid.r a = Associates.mk a 
goal: Quot.mk Setoid.r a = Associates.mk a

full_name: Associates.quot_out
code: @[simp]
theorem quot_out [Monoid α] (a : Associates α) : Associates.mk (Quot.out a) = a 
goal: Associates.mk (Quot.out a) = a

full_name: Associates.mk_quot_out
code: theorem mk_quot_out [Monoid α] (a : α) : Quot.out (Associates.mk a) ~ᵤ a 
goal: Quot.out (Associates.mk a) ~ᵤ a

full_name: Associates.forall_associated
code: theorem forall_associated [Monoid α] {p : Associates α → Prop} :
    (∀ a, p a) ↔ ∀ a, p (Associates.mk a) 
goal: (∀ (a : Associates α), p a) ↔ ∀ (a : α), p (Associates.mk a)

full_name: Associates.mk_surjective
code: theorem mk_surjective [Monoid α] : Function.Surjective (@Associates.mk α _) 
goal: Function.Surjective Associates.mk

full_name: Associates.instOne
code: instance [Monoid α] : One (Associates α) 
goal: One (Associates α)

full_name: Associates.mk_one
code: @[simp]
theorem mk_one [Monoid α] : Associates.mk (1 : α) = 1 
goal: Associates.mk 1 = 1

full_name: Associates.one_eq_mk_one
code: theorem one_eq_mk_one [Monoid α] : (1 : Associates α) = Associates.mk 1 
goal: 1 = Associates.mk 1

full_name: Associates.mk_eq_one
code: @[simp]
theorem mk_eq_one [Monoid α] {a : α} : Associates.mk a = 1 ↔ IsUnit a 
goal: Associates.mk a = 1 ↔ IsUnit a

full_name: Associates.instBot
code: instance [Monoid α] : Bot (Associates α) 
goal: Bot (Associates α)

full_name: Associates.bot_eq_one
code: theorem bot_eq_one [Monoid α] : (⊥ : Associates α) = 1 
goal: ⊥ = 1

full_name: Associates.exists_rep
code: theorem exists_rep [Monoid α] (a : Associates α) : ∃ a0 : α, Associates.mk a0 = a 
goal: ∃ a0, Associates.mk a0 = a

full_name: Associates.instUniqueOfSubsingleton
code: instance [Monoid α] [Subsingleton α] :
    Unique (Associates α) 
goal: Unique (Associates α)

full_name: Associates.mk_injective
code: theorem mk_injective [Monoid α] [Unique (Units α)] : Function.Injective (@Associates.mk α _) 
goal: Function.Injective Associates.mk

full_name: Associates.instMul
code: instance instMul : Mul (Associates α) 
goal: Mul (Associates α)

full_name: Associates.mk_mul_mk
code: theorem mk_mul_mk {x y : α} : Associates.mk x * Associates.mk y = Associates.mk (x * y) 
goal: Associates.mk x * Associates.mk y = Associates.mk (x * y)

full_name: Associates.instCommMonoid
code: instance instCommMonoid : CommMonoid (Associates α) 
goal: CommMonoid (Associates α)

full_name: Associates.instPreorder
code: instance instPreorder : Preorder (Associates α) 
goal: Preorder (Associates α)

full_name: Associates.mkMonoidHom
code: /-- `Associates.mk` as a `MonoidHom`. -/
protected def mkMonoidHom : α →* Associates α 
goal: α →* Associates α

full_name: Associates.mkMonoidHom_apply
code: @[simp]
theorem mkMonoidHom_apply (a : α) : Associates.mkMonoidHom a = Associates.mk a 
goal: Associates.mkMonoidHom a = Associates.mk a

full_name: Associates.associated_map_mk
code: theorem associated_map_mk {f : Associates α →* α} (hinv : Function.RightInverse f Associates.mk)
    (a : α) : a ~ᵤ f (Associates.mk a) 
goal: a ~ᵤ f (Associates.mk a)

full_name: Associates.mk_pow
code: theorem mk_pow (a : α) (n : ℕ) : Associates.mk (a ^ n) = Associates.mk a ^ n 
goal: Associates.mk (a ^ n) = Associates.mk a ^ n

full_name: Associates.dvd_eq_le
code: theorem dvd_eq_le : ((· ∣ ·) : Associates α → Associates α → Prop) = (· ≤ ·) 
goal: (fun x x_1 => x ∣ x_1) = fun x x_1 => x ≤ x_1

full_name: Associates.mul_eq_one_iff
code: theorem mul_eq_one_iff {x y : Associates α} : x * y = 1 ↔ x = 1 ∧ y = 1 
goal: x * y = 1 ↔ x = 1 ∧ y = 1

full_name: Associates.units_eq_one
code: theorem units_eq_one (u : (Associates α)ˣ) : u = 1 
goal: u = 1

full_name: Associates.uniqueUnits
code: instance uniqueUnits : Unique (Associates α)ˣ 
goal: Unique (Associates α)ˣ

full_name: Associates.coe_unit_eq_one
code: @[simp]
theorem coe_unit_eq_one (u : (Associates α)ˣ) : (u : Associates α) = 1 
goal: ↑u = 1

full_name: Associates.isUnit_iff_eq_one
code: theorem isUnit_iff_eq_one (a : Associates α) : IsUnit a ↔ a = 1 
goal: IsUnit a ↔ a = 1

full_name: Associates.isUnit_iff_eq_bot
code: theorem isUnit_iff_eq_bot {a : Associates α} : IsUnit a ↔ a = ⊥ 
goal: IsUnit a ↔ a = ⊥

full_name: Associates.isUnit_mk
code: theorem isUnit_mk {a : α} : IsUnit (Associates.mk a) ↔ IsUnit a 
goal: IsUnit (Associates.mk a) ↔ IsUnit a

full_name: Associates.mul_mono
code: theorem mul_mono {a b c d : Associates α} (h₁ : a ≤ b) (h₂ : c ≤ d) : a * c ≤ b * d 
goal: a * c ≤ b * d

full_name: Associates.one_le
code: theorem one_le {a : Associates α} : 1 ≤ a 
goal: 1 ≤ a

full_name: Associates.le_mul_right
code: theorem le_mul_right {a b : Associates α} : a ≤ a * b 
goal: a ≤ a * b

full_name: Associates.le_mul_left
code: theorem le_mul_left {a b : Associates α} : a ≤ b * a 
goal: a ≤ b * a

full_name: Associates.instOrderBot
code: instance instOrderBot : OrderBot (Associates α) 
goal: OrderBot (Associates α)

full_name: Associates.mk_dvd_mk
code: @[simp]
theorem mk_dvd_mk {a b : α} : Associates.mk a ∣ Associates.mk b ↔ a ∣ b 
goal: Associates.mk a ∣ Associates.mk b ↔ a ∣ b

full_name: Associates.dvd_of_mk_le_mk
code: theorem dvd_of_mk_le_mk {a b : α} : Associates.mk a ≤ Associates.mk b → a ∣ b 
goal: Associates.mk a ≤ Associates.mk b → a ∣ b

full_name: Associates.mk_le_mk_of_dvd
code: theorem mk_le_mk_of_dvd {a b : α} : a ∣ b → Associates.mk a ≤ Associates.mk b 
goal: a ∣ b → Associates.mk a ≤ Associates.mk b

full_name: Associates.mk_le_mk_iff_dvd
code: theorem mk_le_mk_iff_dvd {a b : α} : Associates.mk a ≤ Associates.mk b ↔ a ∣ b 
goal: Associates.mk a ≤ Associates.mk b ↔ a ∣ b

full_name: Associates.isPrimal_mk
code: @[simp]
theorem isPrimal_mk {a : α} : IsPrimal (Associates.mk a) ↔ IsPrimal a 
goal: IsPrimal (Associates.mk a) ↔ IsPrimal a

full_name: Associates.decompositionMonoid_iff
code: @[simp]
theorem decompositionMonoid_iff : DecompositionMonoid (Associates α) ↔ DecompositionMonoid α 
goal: DecompositionMonoid (Associates α) ↔ DecompositionMonoid α

full_name: Associates.instDecompositionMonoid
code: instance instDecompositionMonoid [DecompositionMonoid α] : DecompositionMonoid (Associates α) 
goal: DecompositionMonoid (Associates α)

full_name: Associates.mk_isRelPrime_iff
code: @[simp]
theorem mk_isRelPrime_iff {a b : α} :
    IsRelPrime (Associates.mk a) (Associates.mk b) ↔ IsRelPrime a b 
goal: IsRelPrime (Associates.mk a) (Associates.mk b) ↔ IsRelPrime a b

full_name: Associates.instZero
code: instance [Zero α] [Monoid α] : Zero (Associates α) 
goal: Zero (Associates α)

full_name: Associates.instTopOfZero
code: instance [Zero α] [Monoid α] : Top (Associates α) 
goal: Top (Associates α)

full_name: Associates.mk_zero
code: @[simp] theorem mk_zero [Zero α] [Monoid α] : Associates.mk (0 : α) = 0 
goal: Associates.mk 0 = 0

full_name: Associates.mk_eq_zero
code: @[simp]
theorem mk_eq_zero {a : α} : Associates.mk a = 0 ↔ a = 0 
goal: Associates.mk a = 0 ↔ a = 0

full_name: Associates.quot_out_zero
code: @[simp]
theorem quot_out_zero : Quot.out (0 : Associates α) = 0 
goal: Quot.out 0 = 0

full_name: Associates.mk_ne_zero
code: theorem mk_ne_zero {a : α} : Associates.mk a ≠ 0 ↔ a ≠ 0 
goal: Associates.mk a ≠ 0 ↔ a ≠ 0

full_name: Associates.instNontrivial
code: instance [Nontrivial α] : Nontrivial (Associates α) 
goal: Nontrivial (Associates α)

full_name: Associates.exists_non_zero_rep
code: theorem exists_non_zero_rep {a : Associates α} : a ≠ 0 → ∃ a0 : α, a0 ≠ 0 ∧ Associates.mk a0 = a 
goal: a ≠ 0 → ∃ a0, a0 ≠ 0 ∧ Associates.mk a0 = a

full_name: Associates.instCommMonoidWithZero
code: instance instCommMonoidWithZero : CommMonoidWithZero (Associates α) 
goal: CommMonoidWithZero (Associates α)

full_name: Associates.instOrderTop
code: instance instOrderTop : OrderTop (Associates α) 
goal: OrderTop (Associates α)

full_name: Associates.le_zero
code: @[simp] protected theorem le_zero (a : Associates α) : a ≤ 0 
goal: a ≤ 0

full_name: Associates.instBoundedOrder
code: instance instBoundedOrder : BoundedOrder (Associates α) 
goal: BoundedOrder (Associates α)

full_name: Associates.instDecidableRelDvd
code: instance [DecidableRel ((· ∣ ·) : α → α → Prop)] :
    DecidableRel ((· ∣ ·) : Associates α → Associates α → Prop) 
goal: DecidableRel fun x x_1 => x ∣ x_1

full_name: Associates.Prime.le_or_le
code: theorem Prime.le_or_le {p : Associates α} (hp : Prime p) {a b : Associates α} (h : p ≤ a * b) :
    p ≤ a ∨ p ≤ b 
goal: p ≤ a ∨ p ≤ b

full_name: Associates.prime_mk
code: @[simp]
theorem prime_mk {p : α} : Prime (Associates.mk p) ↔ Prime p 
goal: Prime (Associates.mk p) ↔ Prime p

full_name: Associates.irreducible_mk
code: @[simp]
theorem irreducible_mk {a : α} : Irreducible (Associates.mk a) ↔ Irreducible a 
goal: Irreducible (Associates.mk a) ↔ Irreducible a

full_name: Associates.mk_dvdNotUnit_mk_iff
code: @[simp]
theorem mk_dvdNotUnit_mk_iff {a b : α} :
    DvdNotUnit (Associates.mk a) (Associates.mk b) ↔ DvdNotUnit a b 
goal: DvdNotUnit (Associates.mk a) (Associates.mk b) ↔ DvdNotUnit a b

full_name: Associates.dvdNotUnit_of_lt
code: theorem dvdNotUnit_of_lt {a b : Associates α} (hlt : a < b) : DvdNotUnit a b 
goal: DvdNotUnit a b

full_name: Associates.irreducible_iff_prime_iff
code: theorem irreducible_iff_prime_iff :
    (∀ a : α, Irreducible a ↔ Prime a) ↔ ∀ a : Associates α, Irreducible a ↔ Prime a 
goal: (∀ (a : α), Irreducible a ↔ Prime a) ↔ ∀ (a : Associates α), Irreducible a ↔ Prime a

full_name: Associates.instPartialOrder
code: instance instPartialOrder : PartialOrder (Associates α) 
goal: PartialOrder (Associates α)

full_name: Associates.instCancelCommMonoidWithZero
code: instance instCancelCommMonoidWithZero : CancelCommMonoidWithZero (Associates α) 
goal: CancelCommMonoidWithZero (Associates α)

full_name: associates_irreducible_iff_prime
code: theorem _root_.associates_irreducible_iff_prime [DecompositionMonoid α] {p : Associates α} :
    Irreducible p ↔ Prime p 
goal: Irreducible p ↔ Prime p

full_name: Associates.instNoZeroDivisors
code: instance : NoZeroDivisors (Associates α) 
goal: NoZeroDivisors (Associates α)

full_name: Associates.le_of_mul_le_mul_left
code: theorem le_of_mul_le_mul_left (a b c : Associates α) (ha : a ≠ 0) : a * b ≤ a * c → b ≤ c
  
goal: a * b ≤ a * c → b ≤ c

full_name: Associates.one_or_eq_of_le_of_prime
code: theorem one_or_eq_of_le_of_prime {p m : Associates α} (hp : Prime p) (hle : m ≤ p) :
    m = 1 ∨ m = p 
goal: m = 1 ∨ m = p

full_name: Associates.dvdNotUnit_iff_lt
code: theorem dvdNotUnit_iff_lt {a b : Associates α} : DvdNotUnit a b ↔ a < b 
goal: DvdNotUnit a b ↔ a < b

full_name: Associates.le_one_iff
code: theorem le_one_iff {p : Associates α} : p ≤ 1 ↔ p = 1 
goal: p ≤ 1 ↔ p = 1

full_name: DvdNotUnit.isUnit_of_irreducible_right
code: theorem DvdNotUnit.isUnit_of_irreducible_right [CommMonoidWithZero α] {p q : α}
    (h : DvdNotUnit p q) (hq : Irreducible q) : IsUnit p 
goal: IsUnit p

full_name: not_irreducible_of_not_unit_dvdNotUnit
code: theorem not_irreducible_of_not_unit_dvdNotUnit [CommMonoidWithZero α] {p q : α} (hp : ¬IsUnit p)
    (h : DvdNotUnit p q) : ¬Irreducible q 
goal: ¬Irreducible q

full_name: DvdNotUnit.not_unit
code: theorem DvdNotUnit.not_unit [CommMonoidWithZero α] {p q : α} (hp : DvdNotUnit p q) : ¬IsUnit q 
goal: ¬IsUnit q

full_name: dvdNotUnit_of_dvdNotUnit_associated
code: theorem dvdNotUnit_of_dvdNotUnit_associated [CommMonoidWithZero α] [Nontrivial α] {p q r : α}
    (h : DvdNotUnit p q) (h' : Associated q r) : DvdNotUnit p r 
goal: DvdNotUnit p r

full_name: isUnit_of_associated_mul
code: theorem isUnit_of_associated_mul [CancelCommMonoidWithZero α] {p b : α} (h : Associated (p * b) p)
    (hp : p ≠ 0) : IsUnit b 
goal: IsUnit b

full_name: DvdNotUnit.not_associated
code: theorem DvdNotUnit.not_associated [CancelCommMonoidWithZero α] {p q : α} (h : DvdNotUnit p q) :
    ¬Associated p q 
goal: ¬p ~ᵤ q

full_name: DvdNotUnit.ne
code: theorem DvdNotUnit.ne [CancelCommMonoidWithZero α] {p q : α} (h : DvdNotUnit p q) : p ≠ q 
goal: p ≠ q

full_name: pow_injective_of_not_unit
code: theorem pow_injective_of_not_unit [CancelCommMonoidWithZero α] {q : α} (hq : ¬IsUnit q)
    (hq' : q ≠ 0) : Function.Injective fun n : ℕ => q ^ n 
goal: Function.Injective fun n => q ^ n

full_name: dvd_prime_pow
code: theorem dvd_prime_pow [CancelCommMonoidWithZero α] {p q : α} (hp : Prime p) (n : ℕ) :
    q ∣ p ^ n ↔ ∃ i ≤ n, Associated q (p ^ i) 
goal: q ∣ p ^ n ↔ ∃ i, i ≤ n ∧ q ~ᵤ p ^ i