File: Mathlib/Data/PNat/Prime.lean

full_name: Nat.Primes.toPNat
code: /-- The canonical map from `Nat.Primes` to `ℕ+` -/
@[coe] def toPNat : Nat.Primes → ℕ+ 
goal: Nat.Primes → ℕ+

full_name: Nat.Primes.coePNat
code: instance coePNat : Coe Nat.Primes ℕ+ 
goal: Coe Nat.Primes ℕ+

full_name: Nat.Primes.coe_pnat_nat
code: @[norm_cast]
theorem coe_pnat_nat (p : Nat.Primes) : ((p : ℕ+) : ℕ) = p 
goal: ↑↑p = ↑p

full_name: Nat.Primes.coe_pnat_injective
code: theorem coe_pnat_injective : Function.Injective ((↑) : Nat.Primes → ℕ+) 
goal: Function.Injective Nat.Primes.toPNat

full_name: Nat.Primes.coe_pnat_inj
code: @[norm_cast]
theorem coe_pnat_inj (p q : Nat.Primes) : (p : ℕ+) = (q : ℕ+) ↔ p = q 
goal: ↑p = ↑q ↔ p = q

full_name: PNat.gcd
code: /-- The greatest common divisor (gcd) of two positive natural numbers,
  viewed as positive natural number. -/
def gcd (n m : ℕ+) : ℕ+ 
goal: ℕ+

full_name: PNat.lcm
code: /-- The least common multiple (lcm) of two positive natural numbers,
  viewed as positive natural number. -/
def lcm (n m : ℕ+) : ℕ+ 
goal: ℕ+

full_name: PNat.gcd_coe
code: @[simp, norm_cast]
theorem gcd_coe (n m : ℕ+) : (gcd n m : ℕ) = Nat.gcd n m 
goal: ↑(n.gcd m) = (↑n).gcd ↑m

full_name: PNat.lcm_coe
code: @[simp, norm_cast]
theorem lcm_coe (n m : ℕ+) : (lcm n m : ℕ) = Nat.lcm n m 
goal: ↑(n.lcm m) = (↑n).lcm ↑m

full_name: PNat.gcd_dvd_left
code: theorem gcd_dvd_left (n m : ℕ+) : gcd n m ∣ n 
goal: n.gcd m ∣ n

full_name: PNat.gcd_dvd_right
code: theorem gcd_dvd_right (n m : ℕ+) : gcd n m ∣ m 
goal: n.gcd m ∣ m

full_name: PNat.dvd_gcd
code: theorem dvd_gcd {m n k : ℕ+} (hm : k ∣ m) (hn : k ∣ n) : k ∣ gcd m n 
goal: k ∣ m.gcd n

full_name: PNat.dvd_lcm_left
code: theorem dvd_lcm_left (n m : ℕ+) : n ∣ lcm n m 
goal: n ∣ n.lcm m

full_name: PNat.dvd_lcm_right
code: theorem dvd_lcm_right (n m : ℕ+) : m ∣ lcm n m 
goal: m ∣ n.lcm m

full_name: PNat.lcm_dvd
code: theorem lcm_dvd {m n k : ℕ+} (hm : m ∣ k) (hn : n ∣ k) : lcm m n ∣ k 
goal: m.lcm n ∣ k

full_name: PNat.gcd_mul_lcm
code: theorem gcd_mul_lcm (n m : ℕ+) : gcd n m * lcm n m = n * m 
goal: n.gcd m * n.lcm m = n * m

full_name: PNat.eq_one_of_lt_two
code: theorem eq_one_of_lt_two {n : ℕ+} : n < 2 → n = 1 
goal: n < 2 → n = 1

full_name: PNat.Prime
code: /-- Primality predicate for `ℕ+`, defined in terms of `Nat.Prime`. -/
def Prime (p : ℕ+) : Prop 
goal: Prop

full_name: PNat.Prime.one_lt
code: theorem Prime.one_lt {p : ℕ+} : p.Prime → 1 < p 
goal: p.Prime → 1 < p

full_name: PNat.prime_two
code: theorem prime_two : (2 : ℕ+).Prime 
goal: PNat.Prime 2

full_name: PNat.instFactPrimeValOfPrime
code: instance {p : ℕ+} [h : Fact p.Prime] : Fact (p : ℕ).Prime 
goal: Fact (Nat.Prime ↑p)

full_name: PNat.fact_prime_two
code: instance fact_prime_two : Fact (2 : ℕ+).Prime 
goal: Fact (PNat.Prime 2)

full_name: PNat.prime_three
code: theorem prime_three : (3 : ℕ+).Prime 
goal: PNat.Prime 3

full_name: PNat.fact_prime_three
code: instance fact_prime_three : Fact (3 : ℕ+).Prime 
goal: Fact (PNat.Prime 3)

full_name: PNat.prime_five
code: theorem prime_five : (5 : ℕ+).Prime 
goal: PNat.Prime 5

full_name: PNat.fact_prime_five
code: instance fact_prime_five : Fact (5 : ℕ+).Prime 
goal: Fact (PNat.Prime 5)

full_name: PNat.dvd_prime
code: theorem dvd_prime {p m : ℕ+} (pp : p.Prime) : m ∣ p ↔ m = 1 ∨ m = p 
goal: m ∣ p ↔ m = 1 ∨ m = p

full_name: PNat.Prime.ne_one
code: theorem Prime.ne_one {p : ℕ+} : p.Prime → p ≠ 1 
goal: p.Prime → p ≠ 1

full_name: PNat.not_prime_one
code: @[simp]
theorem not_prime_one : ¬(1 : ℕ+).Prime 
goal: ¬PNat.Prime 1

full_name: PNat.Prime.not_dvd_one
code: theorem Prime.not_dvd_one {p : ℕ+} : p.Prime → ¬p ∣ 1 
goal: p.Prime → ¬p ∣ 1

full_name: PNat.exists_prime_and_dvd
code: theorem exists_prime_and_dvd {n : ℕ+} (hn : n ≠ 1) : ∃ p : ℕ+, p.Prime ∧ p ∣ n 
goal: ∃ p, p.Prime ∧ p ∣ n

full_name: PNat.Coprime
code: /-- Two pnats are coprime if their gcd is 1. -/
def Coprime (m n : ℕ+) : Prop 
goal: Prop

full_name: PNat.coprime_coe
code: @[simp, norm_cast]
theorem coprime_coe {m n : ℕ+} : Nat.Coprime ↑m ↑n ↔ m.Coprime n 
goal: (↑m).Coprime ↑n ↔ m.Coprime n

full_name: PNat.Coprime.mul
code: theorem Coprime.mul {k m n : ℕ+} : m.Coprime k → n.Coprime k → (m * n).Coprime k 
goal: m.Coprime k → n.Coprime k → (m * n).Coprime k

full_name: PNat.Coprime.mul_right
code: theorem Coprime.mul_right {k m n : ℕ+} : k.Coprime m → k.Coprime n → k.Coprime (m * n) 
goal: k.Coprime m → k.Coprime n → k.Coprime (m * n)

full_name: PNat.gcd_comm
code: theorem gcd_comm {m n : ℕ+} : m.gcd n = n.gcd m 
goal: m.gcd n = n.gcd m

full_name: PNat.gcd_eq_left_iff_dvd
code: theorem gcd_eq_left_iff_dvd {m n : ℕ+} : m ∣ n ↔ m.gcd n = m 
goal: m ∣ n ↔ m.gcd n = m

full_name: PNat.gcd_eq_right_iff_dvd
code: theorem gcd_eq_right_iff_dvd {m n : ℕ+} : m ∣ n ↔ n.gcd m = m 
goal: m ∣ n ↔ n.gcd m = m

full_name: PNat.Coprime.gcd_mul_left_cancel
code: theorem Coprime.gcd_mul_left_cancel (m : ℕ+) {n k : ℕ+} :
    k.Coprime n → (k * m).gcd n = m.gcd n 
goal: k.Coprime n → (k * m).gcd n = m.gcd n

full_name: PNat.Coprime.gcd_mul_right_cancel
code: theorem Coprime.gcd_mul_right_cancel (m : ℕ+) {n k : ℕ+} :
    k.Coprime n → (m * k).gcd n = m.gcd n 
goal: k.Coprime n → (m * k).gcd n = m.gcd n

full_name: PNat.Coprime.gcd_mul_left_cancel_right
code: theorem Coprime.gcd_mul_left_cancel_right (m : ℕ+) {n k : ℕ+} :
    k.Coprime m → m.gcd (k * n) = m.gcd n 
goal: k.Coprime m → m.gcd (k * n) = m.gcd n

full_name: PNat.Coprime.gcd_mul_right_cancel_right
code: theorem Coprime.gcd_mul_right_cancel_right (m : ℕ+) {n k : ℕ+} :
    k.Coprime m → m.gcd (n * k) = m.gcd n 
goal: k.Coprime m → m.gcd (n * k) = m.gcd n

full_name: PNat.one_gcd
code: @[simp]
theorem one_gcd {n : ℕ+} : gcd 1 n = 1 
goal: PNat.gcd 1 n = 1

full_name: PNat.gcd_one
code: @[simp]
theorem gcd_one {n : ℕ+} : gcd n 1 = 1 
goal: n.gcd 1 = 1

full_name: PNat.Coprime.symm
code: @[symm]
theorem Coprime.symm {m n : ℕ+} : m.Coprime n → n.Coprime m 
goal: m.Coprime n → n.Coprime m

full_name: PNat.one_coprime
code: @[simp]
theorem one_coprime {n : ℕ+} : (1 : ℕ+).Coprime n 
goal: PNat.Coprime 1 n

full_name: PNat.coprime_one
code: @[simp]
theorem coprime_one {n : ℕ+} : n.Coprime 1 
goal: n.Coprime 1

full_name: PNat.Coprime.coprime_dvd_left
code: theorem Coprime.coprime_dvd_left {m k n : ℕ+} : m ∣ k → k.Coprime n → m.Coprime n 
goal: m ∣ k → k.Coprime n → m.Coprime n

full_name: PNat.Coprime.factor_eq_gcd_left
code: theorem Coprime.factor_eq_gcd_left {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n) :
    a = (a * b).gcd m 
goal: a = (a * b).gcd m

full_name: PNat.Coprime.factor_eq_gcd_right
code: theorem Coprime.factor_eq_gcd_right {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m) (bn : b ∣ n) :
    a = (b * a).gcd m 
goal: a = (b * a).gcd m

full_name: PNat.Coprime.factor_eq_gcd_left_right
code: theorem Coprime.factor_eq_gcd_left_right {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m)
    (bn : b ∣ n) : a = m.gcd (a * b) 
goal: a = m.gcd (a * b)

full_name: PNat.Coprime.factor_eq_gcd_right_right
code: theorem Coprime.factor_eq_gcd_right_right {a b m n : ℕ+} (cop : m.Coprime n) (am : a ∣ m)
    (bn : b ∣ n) : a = m.gcd (b * a) 
goal: a = m.gcd (b * a)

full_name: PNat.Coprime.gcd_mul
code: theorem Coprime.gcd_mul (k : ℕ+) {m n : ℕ+} (h : m.Coprime n) :
    k.gcd (m * n) = k.gcd m * k.gcd n 
goal: k.gcd (m * n) = k.gcd m * k.gcd n

full_name: PNat.gcd_eq_left
code: theorem gcd_eq_left {m n : ℕ+} : m ∣ n → m.gcd n = m 
goal: m ∣ n → m.gcd n = m

full_name: PNat.Coprime.pow
code: theorem Coprime.pow {m n : ℕ+} (k l : ℕ) (h : m.Coprime n) : (m ^ k : ℕ).Coprime (n ^ l) 
goal: (↑m ^ k).Coprime (↑n ^ l)