File: Mathlib/Algebra/Group/Nat.lean

full_name: Nat.instAddCancelCommMonoid
code: instance instAddCancelCommMonoid : AddCancelCommMonoid ℕ 
goal: AddCancelCommMonoid ℕ

full_name: Nat.instCommMonoid
code: instance instCommMonoid : CommMonoid ℕ 
goal: CommMonoid ℕ

full_name: Nat.instAddCommMonoid
code: instance instAddCommMonoid    : AddCommMonoid ℕ    
goal: AddCommMonoid ℕ

full_name: Nat.instAddMonoid
code: instance instAddMonoid        : AddMonoid ℕ        
goal: AddMonoid ℕ

full_name: Nat.instMonoid
code: instance instMonoid           : Monoid ℕ           
goal: Monoid ℕ

full_name: Nat.instCommSemigroup
code: instance instCommSemigroup    : CommSemigroup ℕ    
goal: CommSemigroup ℕ

full_name: Nat.instSemigroup
code: instance instSemigroup        : Semigroup ℕ        
goal: Semigroup ℕ

full_name: Nat.instAddCommSemigroup
code: instance instAddCommSemigroup : AddCommSemigroup ℕ 
goal: AddCommSemigroup ℕ

full_name: Nat.instAddSemigroup
code: instance instAddSemigroup     : AddSemigroup ℕ     
goal: AddSemigroup ℕ

full_name: Nat.nsmul_eq_mul
code: @[simp, nolint simpNF] protected lemma nsmul_eq_mul (m n : ℕ) : m • n = m * n 
goal: m • n = m * n

full_name: Nat.toAdd_pow
code: lemma toAdd_pow (a : Multiplicative ℕ) (b : ℕ) : toAdd (a ^ b) = toAdd a * b 
goal: Multiplicative.toAdd (a ^ b) = Multiplicative.toAdd a * b

full_name: Nat.ofAdd_mul
code: @[simp] lemma ofAdd_mul (a b : ℕ) : ofAdd (a * b) = ofAdd a ^ b 
goal: Multiplicative.ofAdd (a * b) = Multiplicative.ofAdd a ^ b

full_name: Nat.even_iff
code: lemma even_iff : Even n ↔ n % 2 = 0 
goal: Even n ↔ n % 2 = 0

full_name: Nat.instDecidablePredEven
code: instance : DecidablePred (Even : ℕ → Prop) 
goal: DecidablePred Even

full_name: Nat.instDecidablePredIsSquare
code: /-- `IsSquare` can be decided on `ℕ` by checking against the square root. -/
instance : DecidablePred (IsSquare : ℕ → Prop) 
goal: DecidablePred IsSquare

full_name: Nat.not_even_iff
code: lemma not_even_iff : ¬ Even n ↔ n % 2 = 1 
goal: ¬Even n ↔ n % 2 = 1

full_name: Nat.two_dvd_ne_zero
code: @[simp] lemma two_dvd_ne_zero : ¬2 ∣ n ↔ n % 2 = 1 
goal: ¬2 ∣ n ↔ n % 2 = 1

full_name: Nat.not_even_one
code: @[simp] lemma not_even_one : ¬Even 1 
goal: ¬Even 1

full_name: Nat.even_add
code: @[parity_simps] lemma even_add : Even (m + n) ↔ (Even m ↔ Even n) 
goal: Even (m + n) ↔ (Even m ↔ Even n)

full_name: Nat.even_add_one
code: @[parity_simps] lemma even_add_one : Even (n + 1) ↔ ¬Even n 
goal: Even (n + 1) ↔ ¬Even n

full_name: Nat.succ_mod_two_eq_zero_iff
code: lemma succ_mod_two_eq_zero_iff {m : ℕ} : (m + 1) % 2 = 0 ↔ m % 2 = 1 
goal: (m + 1) % 2 = 0 ↔ m % 2 = 1

full_name: Nat.succ_mod_two_eq_one_iff
code: lemma succ_mod_two_eq_one_iff {m : ℕ} : (m + 1) % 2 = 1 ↔ m % 2 = 0 
goal: (m + 1) % 2 = 1 ↔ m % 2 = 0

full_name: Nat.two_not_dvd_two_mul_add_one
code: lemma two_not_dvd_two_mul_add_one (n : ℕ) : ¬2 ∣ 2 * n + 1 
goal: ¬2 ∣ 2 * n + 1

full_name: Nat.two_not_dvd_two_mul_sub_one
code: lemma two_not_dvd_two_mul_sub_one : ∀ {n}, 0 < n → ¬2 ∣ 2 * n - 1
  
goal: 0 < n → ¬2 ∣ 2 * n - 1

full_name: Nat.even_sub
code: @[parity_simps] lemma even_sub (h : n ≤ m) : Even (m - n) ↔ (Even m ↔ Even n) 
goal: Even (m - n) ↔ (Even m ↔ Even n)

full_name: Nat.even_mul
code: @[parity_simps] lemma even_mul : Even (m * n) ↔ Even m ∨ Even n 
goal: Even (m * n) ↔ Even m ∨ Even n

full_name: Nat.even_pow
code: /-- If `m` and `n` are natural numbers, then the natural number `m^n` is even
if and only if `m` is even and `n` is positive. -/
@[parity_simps] lemma even_pow : Even (m ^ n) ↔ Even m ∧ n ≠ 0 
goal: Even (m ^ n) ↔ Even m ∧ n ≠ 0

full_name: Nat.even_pow'
code: lemma even_pow' (h : n ≠ 0) : Even (m ^ n) ↔ Even m 
goal: Even (m ^ n) ↔ Even m

full_name: Nat.even_mul_succ_self
code: lemma even_mul_succ_self (n : ℕ) : Even (n * (n + 1)) 
goal: Even (n * (n + 1))

full_name: Nat.even_mul_pred_self
code: lemma even_mul_pred_self : ∀ n : ℕ, Even (n * (n - 1))
  
goal: Even (n * (n - 1))

full_name: Nat.two_mul_div_two_of_even
code: lemma two_mul_div_two_of_even : Even n → 2 * (n / 2) = n 
goal: Even n → 2 * (n / 2) = n

full_name: Nat.div_two_mul_two_of_even
code: lemma div_two_mul_two_of_even : Even n → n / 2 * 2 = n 
goal: Even n → n / 2 * 2 = n

full_name: Nat.units_eq_one
code: lemma units_eq_one (u : ℕˣ) : u = 1 
goal: u = 1

full_name: Nat.addUnits_eq_zero
code: lemma addUnits_eq_zero (u : AddUnits ℕ) : u = 0 
goal: u = 0

full_name: Nat.isUnit_iff
code: @[simp] protected lemma isUnit_iff {n : ℕ} : IsUnit n ↔ n = 1 
goal: IsUnit n ↔ n = 1

full_name: Nat.unique_units
code: instance unique_units : Unique ℕˣ 
goal: Unique ℕˣ

full_name: Nat.unique_addUnits
code: instance unique_addUnits : Unique (AddUnits ℕ) 
goal: Unique (AddUnits ℕ)