File: Mathlib/Data/PNat/Basic.lean

full_name: PNat.instWellFoundedLT
code: instance instWellFoundedLT : WellFoundedLT ℕ+ 
goal: WellFoundedLT ℕ+

full_name: PNat.instIsWellOrder
code: instance instIsWellOrder : IsWellOrder ℕ+ (· < ·) 
goal: IsWellOrder ℕ+ fun x x_1 => x < x_1

full_name: PNat.one_add_natPred
code: @[simp]
theorem one_add_natPred (n : ℕ+) : 1 + n.natPred = n 
goal: 1 + n.natPred = ↑n

full_name: PNat.natPred_add_one
code: @[simp]
theorem natPred_add_one (n : ℕ+) : n.natPred + 1 = n 
goal: n.natPred + 1 = ↑n

full_name: PNat.natPred_strictMono
code: @[mono]
theorem natPred_strictMono : StrictMono natPred 
goal: StrictMono PNat.natPred

full_name: PNat.natPred_monotone
code: @[mono]
theorem natPred_monotone : Monotone natPred 
goal: Monotone PNat.natPred

full_name: PNat.natPred_injective
code: theorem natPred_injective : Function.Injective natPred 
goal: Function.Injective PNat.natPred

full_name: PNat.natPred_lt_natPred
code: @[simp]
theorem natPred_lt_natPred {m n : ℕ+} : m.natPred < n.natPred ↔ m < n 
goal: m.natPred < n.natPred ↔ m < n

full_name: PNat.natPred_le_natPred
code: @[simp]
theorem natPred_le_natPred {m n : ℕ+} : m.natPred ≤ n.natPred ↔ m ≤ n 
goal: m.natPred ≤ n.natPred ↔ m ≤ n

full_name: PNat.natPred_inj
code: @[simp]
theorem natPred_inj {m n : ℕ+} : m.natPred = n.natPred ↔ m = n 
goal: m.natPred = n.natPred ↔ m = n

full_name: PNat.val_ofNat
code: @[simp, norm_cast]
lemma val_ofNat (n : ℕ) [NeZero n] :
    ((no_index (OfNat.ofNat n) : ℕ+) : ℕ) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: PNat.mk_ofNat
code: @[simp]
lemma mk_ofNat (n : ℕ) (h : 0 < n) :
    @Eq ℕ+ (⟨no_index (OfNat.ofNat n), h⟩ : ℕ+) (haveI : NeZero n := ⟨h.ne'⟩; OfNat.ofNat n) 
goal: ⟨OfNat.ofNat n, h⟩ = OfNat.ofNat n

full_name: Nat.succPNat_strictMono
code: @[mono]
theorem succPNat_strictMono : StrictMono succPNat 
goal: StrictMono Nat.succPNat

full_name: Nat.succPNat_mono
code: @[mono]
theorem succPNat_mono : Monotone succPNat 
goal: Monotone Nat.succPNat

full_name: Nat.succPNat_lt_succPNat
code: @[simp]
theorem succPNat_lt_succPNat {m n : ℕ} : m.succPNat < n.succPNat ↔ m < n 
goal: m.succPNat < n.succPNat ↔ m < n

full_name: Nat.succPNat_le_succPNat
code: @[simp]
theorem succPNat_le_succPNat {m n : ℕ} : m.succPNat ≤ n.succPNat ↔ m ≤ n 
goal: m.succPNat ≤ n.succPNat ↔ m ≤ n

full_name: Nat.succPNat_injective
code: theorem succPNat_injective : Function.Injective succPNat 
goal: Function.Injective Nat.succPNat

full_name: Nat.succPNat_inj
code: @[simp]
theorem succPNat_inj {n m : ℕ} : succPNat n = succPNat m ↔ n = m 
goal: n.succPNat = m.succPNat ↔ n = m

full_name: PNat.coe_inj
code: /-- We now define a long list of structures on `ℕ+` induced by
 similar structures on `ℕ`. Most of these behave in a completely
 obvious way, but there are a few things to be said about
 subtraction, division and powers.
-/
@[simp, norm_cast]
theorem coe_inj {m n : ℕ+} : (m : ℕ) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

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

full_name: PNat.coeAddHom
code: /-- `coe` promoted to an `AddHom`, that is, a morphism which preserves addition. -/
def coeAddHom : AddHom ℕ+ ℕ 
goal: AddHom ℕ+ ℕ

full_name: PNat.covariantClass_add_le
code: instance covariantClass_add_le : CovariantClass ℕ+ ℕ+ (· + ·) (· ≤ ·) 
goal: CovariantClass ℕ+ ℕ+ (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: PNat.covariantClass_add_lt
code: instance covariantClass_add_lt : CovariantClass ℕ+ ℕ+ (· + ·) (· < ·) 
goal: CovariantClass ℕ+ ℕ+ (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: PNat.contravariantClass_add_le
code: instance contravariantClass_add_le : ContravariantClass ℕ+ ℕ+ (· + ·) (· ≤ ·) 
goal: ContravariantClass ℕ+ ℕ+ (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: PNat.contravariantClass_add_lt
code: instance contravariantClass_add_lt : ContravariantClass ℕ+ ℕ+ (· + ·) (· < ·) 
goal: ContravariantClass ℕ+ ℕ+ (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: OrderIso.pnatIsoNat_apply
code: /-- The order isomorphism between ℕ and ℕ+ given by `succ`. -/
@[simps! (config := .asFn) apply]
def _root_.OrderIso.pnatIsoNat : ℕ+ ≃o ℕ 
goal: ⇑OrderIso.pnatIsoNat = PNat.natPred

full_name: OrderIso.pnatIsoNat
code: /-- The order isomorphism between ℕ and ℕ+ given by `succ`. -/
@[simps! (config := .asFn) apply]
def _root_.OrderIso.pnatIsoNat : ℕ+ ≃o ℕ 
goal: ℕ+ ≃o ℕ

full_name: OrderIso.pnatIsoNat_symm_apply
code: @[simp]
theorem _root_.OrderIso.pnatIsoNat_symm_apply : OrderIso.pnatIsoNat.symm = Nat.succPNat 
goal: ⇑OrderIso.pnatIsoNat.symm = Nat.succPNat

full_name: PNat.lt_add_one_iff
code: theorem lt_add_one_iff : ∀ {a b : ℕ+}, a < b + 1 ↔ a ≤ b 
goal: a < b + 1 ↔ a ≤ b

full_name: PNat.add_one_le_iff
code: theorem add_one_le_iff : ∀ {a b : ℕ+}, a + 1 ≤ b ↔ a < b 
goal: a + 1 ≤ b ↔ a < b

full_name: PNat.instOrderBot
code: instance instOrderBot : OrderBot ℕ+ 
goal: OrderBot ℕ+

full_name: PNat.bot_eq_one
code: @[simp]
theorem bot_eq_one : (⊥ : ℕ+) = 1 
goal: ⊥ = 1

full_name: PNat.caseStrongInductionOn
code: /-- Strong induction on `ℕ+`, with `n = 1` treated separately. -/
def caseStrongInductionOn {p : ℕ+ → Sort*} (a : ℕ+) (hz : p 1)
    (hi : ∀ n, (∀ m, m ≤ n → p m) → p (n + 1)) : p a 
goal: p a

full_name: PNat.recOn
code: /-- An induction principle for `ℕ+`: it takes values in `Sort*`, so it applies also to Types,
not only to `Prop`. -/
@[elab_as_elim]
def recOn (n : ℕ+) {p : ℕ+ → Sort*} (p1 : p 1) (hp : ∀ n, p n → p (n + 1)) : p n 
goal: p n

full_name: PNat.recOn_one
code: @[simp]
theorem recOn_one {p} (p1 hp) : @PNat.recOn 1 p p1 hp = p1 
goal: PNat.recOn 1 p1 hp = p1

full_name: PNat.recOn_succ
code: @[simp]
theorem recOn_succ (n : ℕ+) {p : ℕ+ → Sort*} (p1 hp) :
    @PNat.recOn (n + 1) p p1 hp = hp n (@PNat.recOn n p p1 hp) 
goal: (n + 1).recOn p1 hp = hp n (n.recOn p1 hp)

full_name: PNat.ofNat_le_ofNat
code: @[simp]
theorem ofNat_le_ofNat {m n : ℕ} [NeZero m] [NeZero n] :
    (no_index (OfNat.ofNat m) : ℕ+) ≤ no_index (OfNat.ofNat n) ↔ OfNat.ofNat m ≤ OfNat.ofNat n 
goal: OfNat.ofNat m ≤ OfNat.ofNat n ↔ OfNat.ofNat m ≤ OfNat.ofNat n

full_name: PNat.ofNat_lt_ofNat
code: @[simp]
theorem ofNat_lt_ofNat {m n : ℕ} [NeZero m] [NeZero n] :
    (no_index (OfNat.ofNat m) : ℕ+) < no_index (OfNat.ofNat n) ↔ OfNat.ofNat m < OfNat.ofNat n 
goal: OfNat.ofNat m < OfNat.ofNat n ↔ OfNat.ofNat m < OfNat.ofNat n

full_name: PNat.ofNat_inj
code: @[simp]
theorem ofNat_inj {m n : ℕ} [NeZero m] [NeZero n] :
    (no_index (OfNat.ofNat m) : ℕ+) = no_index (OfNat.ofNat n) ↔ OfNat.ofNat m = OfNat.ofNat n 
goal: OfNat.ofNat m = OfNat.ofNat n ↔ OfNat.ofNat m = OfNat.ofNat n

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

full_name: PNat.coeMonoidHom
code: /-- `PNat.coe` promoted to a `MonoidHom`. -/
def coeMonoidHom : ℕ+ →* ℕ 
goal: ℕ+ →* ℕ

full_name: PNat.coe_coeMonoidHom
code: @[simp]
theorem coe_coeMonoidHom : (coeMonoidHom : ℕ+ → ℕ) = Coe.coe 
goal: ⇑PNat.coeMonoidHom = Coe.coe

full_name: PNat.le_one_iff
code: @[simp]
theorem le_one_iff {n : ℕ+} : n ≤ 1 ↔ n = 1 
goal: n ≤ 1 ↔ n = 1

full_name: PNat.lt_add_left
code: theorem lt_add_left (n m : ℕ+) : n < m + n 
goal: n < m + n

full_name: PNat.lt_add_right
code: theorem lt_add_right (n m : ℕ+) : n < n + m 
goal: n < n + m

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

full_name: PNat.one_lt_of_lt
code: /-- b is greater one if any a is less than b -/
theorem one_lt_of_lt {a b : ℕ+} (hab : a < b) : 1 < b 
goal: 1 < b

full_name: PNat.add_one
code: theorem add_one (a : ℕ+) : a + 1 = succPNat a 
goal: a + 1 = (↑a).succPNat

full_name: PNat.lt_succ_self
code: theorem lt_succ_self (a : ℕ+) : a < succPNat a 
goal: a < (↑a).succPNat

full_name: PNat.instSub
code: /-- Subtraction a - b is defined in the obvious way when
  a > b, and by a - b = 1 if a ≤ b.
-/
instance instSub : Sub ℕ+ 
goal: Sub ℕ+

full_name: PNat.sub_coe
code: theorem sub_coe (a b : ℕ+) : ((a - b : ℕ+) : ℕ) = ite (b < a) (a - b : ℕ) 1 
goal: ↑(a - b) = if b < a then ↑a - ↑b else 1

full_name: PNat.sub_le
code: theorem sub_le (a b : ℕ+) : a - b ≤ a 
goal: a - b ≤ a

full_name: PNat.le_sub_one_of_lt
code: theorem le_sub_one_of_lt {a b : ℕ+} (hab : a < b) : a ≤ b - (1 : ℕ+) 
goal: a ≤ b - 1

full_name: PNat.add_sub_of_lt
code: theorem add_sub_of_lt {a b : ℕ+} : a < b → a + (b - a) = b 
goal: a < b → a + (b - a) = b

full_name: PNat.exists_eq_succ_of_ne_one
code: /-- If `n : ℕ+` is different from `1`, then it is the successor of some `k : ℕ+`. -/
theorem exists_eq_succ_of_ne_one : ∀ {n : ℕ+} (_ : n ≠ 1), ∃ k : ℕ+, n = k + 1
  
goal: n ≠ 1 → ∃ k, n = k + 1

full_name: PNat.modDivAux_spec
code: /-- Lemmas with div, dvd and mod operations -/
theorem modDivAux_spec :
    ∀ (k : ℕ+) (r q : ℕ) (_ : ¬(r = 0 ∧ q = 0)),
      ((modDivAux k r q).1 : ℕ) + k * (modDivAux k r q).2 = r + k * q
  
goal: ¬(r = 0 ∧ q = 0) → ↑(k.modDivAux r q).1 + ↑k * (k.modDivAux r q).2 = r + ↑k * q

full_name: PNat.mod_add_div
code: theorem mod_add_div (m k : ℕ+) : (mod m k + k * div m k : ℕ) = m 
goal: ↑(m.mod k) + ↑k * m.div k = ↑m

full_name: PNat.div_add_mod
code: theorem div_add_mod (m k : ℕ+) : (k * div m k + mod m k : ℕ) = m 
goal: ↑k * m.div k + ↑(m.mod k) = ↑m

full_name: PNat.mod_add_div'
code: theorem mod_add_div' (m k : ℕ+) : (mod m k + div m k * k : ℕ) = m 
goal: ↑(m.mod k) + m.div k * ↑k = ↑m

full_name: PNat.div_add_mod'
code: theorem div_add_mod' (m k : ℕ+) : (div m k * k + mod m k : ℕ) = m 
goal: m.div k * ↑k + ↑(m.mod k) = ↑m

full_name: PNat.mod_le
code: theorem mod_le (m k : ℕ+) : mod m k ≤ m ∧ mod m k ≤ k 
goal: m.mod k ≤ m ∧ m.mod k ≤ k

full_name: PNat.dvd_iff
code: theorem dvd_iff {k m : ℕ+} : k ∣ m ↔ (k : ℕ) ∣ (m : ℕ) 
goal: k ∣ m ↔ ↑k ∣ ↑m

full_name: PNat.dvd_iff'
code: theorem dvd_iff' {k m : ℕ+} : k ∣ m ↔ mod m k = k 
goal: k ∣ m ↔ m.mod k = k

full_name: PNat.le_of_dvd
code: theorem le_of_dvd {m n : ℕ+} : m ∣ n → m ≤ n 
goal: m ∣ n → m ≤ n

full_name: PNat.mul_div_exact
code: theorem mul_div_exact {m k : ℕ+} (h : k ∣ m) : k * divExact m k = m 
goal: k * m.divExact k = m

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

full_name: PNat.dvd_one_iff
code: theorem dvd_one_iff (n : ℕ+) : n ∣ 1 ↔ n = 1 
goal: n ∣ 1 ↔ n = 1

full_name: PNat.pos_of_div_pos
code: theorem pos_of_div_pos {n : ℕ+} {a : ℕ} (h : a ∣ n) : 0 < a 
goal: 0 < a