File: .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean

full_name: Nat.dvd_refl
code: protected theorem dvd_refl (a : Nat) : a ∣ a 
goal: a ∣ a

full_name: Nat.dvd_zero
code: protected theorem dvd_zero (a : Nat) : a ∣ 0 
goal: a ∣ 0

full_name: Nat.dvd_mul_left
code: protected theorem dvd_mul_left (a b : Nat) : a ∣ b * a 
goal: a ∣ b * a

full_name: Nat.dvd_mul_right
code: protected theorem dvd_mul_right (a b : Nat) : a ∣ a * b 
goal: a ∣ a * b

full_name: Nat.dvd_trans
code: protected theorem dvd_trans {a b c : Nat} (h₁ : a ∣ b) (h₂ : b ∣ c) : a ∣ c 
goal: a ∣ c

full_name: Nat.eq_zero_of_zero_dvd
code: protected theorem eq_zero_of_zero_dvd {a : Nat} (h : 0 ∣ a) : a = 0 
goal: a = 0

full_name: Nat.zero_dvd
code: @[simp] protected theorem zero_dvd {n : Nat} : 0 ∣ n ↔ n = 0 
goal: 0 ∣ n ↔ n = 0

full_name: Nat.dvd_add
code: protected theorem dvd_add {a b c : Nat} (h₁ : a ∣ b) (h₂ : a ∣ c) : a ∣ b + c 
goal: a ∣ b + c

full_name: Nat.dvd_add_iff_right
code: protected theorem dvd_add_iff_right {k m n : Nat} (h : k ∣ m) : k ∣ n ↔ k ∣ m + n 
goal: k ∣ n ↔ k ∣ m + n

full_name: Nat.dvd_add_iff_left
code: protected theorem dvd_add_iff_left {k m n : Nat} (h : k ∣ n) : k ∣ m ↔ k ∣ m + n 
goal: k ∣ m ↔ k ∣ m + n

full_name: Nat.dvd_mod_iff
code: theorem dvd_mod_iff {k m n : Nat} (h: k ∣ n) : k ∣ m % n ↔ k ∣ m 
goal: k ∣ m % n ↔ k ∣ m

full_name: Nat.le_of_dvd
code: theorem le_of_dvd {m n : Nat} (h : 0 < n) : m ∣ n → m ≤ n
  
goal: m ∣ n → m ≤ n

full_name: Nat.dvd_antisymm
code: protected theorem dvd_antisymm : ∀ {m n : Nat}, m ∣ n → n ∣ m → m = n
  
goal: m ∣ n → n ∣ m → m = n

full_name: Nat.pos_of_dvd_of_pos
code: theorem pos_of_dvd_of_pos {m n : Nat} (H1 : m ∣ n) (H2 : 0 < n) : 0 < m 
goal: 0 < m

full_name: Nat.one_dvd
code: @[simp] protected theorem one_dvd (n : Nat) : 1 ∣ n 
goal: 1 ∣ n

full_name: Nat.eq_one_of_dvd_one
code: theorem eq_one_of_dvd_one {n : Nat} (H : n ∣ 1) : n = 1 
goal: n = 1

full_name: Nat.mod_eq_zero_of_dvd
code: theorem mod_eq_zero_of_dvd {m n : Nat} (H : m ∣ n) : n % m = 0 
goal: n % m = 0

full_name: Nat.dvd_of_mod_eq_zero
code: theorem dvd_of_mod_eq_zero {m n : Nat} (H : n % m = 0) : m ∣ n 
goal: m ∣ n

full_name: Nat.dvd_iff_mod_eq_zero
code: theorem dvd_iff_mod_eq_zero (m n : Nat) : m ∣ n ↔ n % m = 0 
goal: m ∣ n ↔ n % m = 0

full_name: Nat.decidable_dvd
code: instance decidable_dvd : @DecidableRel Nat (·∣·) 
goal: DecidableRel fun x x_1 => x ∣ x_1

full_name: Nat.emod_pos_of_not_dvd
code: theorem emod_pos_of_not_dvd {a b : Nat} (h : ¬ a ∣ b) : 0 < b % a 
goal: 0 < b % a

full_name: Nat.mul_div_cancel'
code: protected theorem mul_div_cancel' {n m : Nat} (H : n ∣ m) : n * (m / n) = m 
goal: n * (m / n) = m

full_name: Nat.div_mul_cancel
code: protected theorem div_mul_cancel {n m : Nat} (H : n ∣ m) : m / n * n = m 
goal: m / n * n = m

full_name: Nat.mod_mod_of_dvd
code: @[simp] theorem mod_mod_of_dvd (a : Nat) (h : c ∣ b) : a % b % c = a % c 
goal: a % b % c = a % c

full_name: Nat.dvd_of_mul_dvd_mul_left
code: protected theorem dvd_of_mul_dvd_mul_left
    (kpos : 0 < k) (H : k * m ∣ k * n) : m ∣ n 
goal: m ∣ n

full_name: Nat.dvd_of_mul_dvd_mul_right
code: protected theorem dvd_of_mul_dvd_mul_right (kpos : 0 < k) (H : m * k ∣ n * k) : m ∣ n 
goal: m ∣ n

full_name: Nat.dvd_sub
code: theorem dvd_sub {k m n : Nat} (H : n ≤ m) (h₁ : k ∣ m) (h₂ : k ∣ n) : k ∣ m - n 
goal: k ∣ m - n

full_name: Nat.mul_dvd_mul
code: protected theorem mul_dvd_mul {a b c d : Nat} : a ∣ b → c ∣ d → a * c ∣ b * d
  
goal: a ∣ b → c ∣ d → a * c ∣ b * d

full_name: Nat.mul_dvd_mul_left
code: protected theorem mul_dvd_mul_left (a : Nat) (h : b ∣ c) : a * b ∣ a * c 
goal: a * b ∣ a * c

full_name: Nat.mul_dvd_mul_right
code: protected theorem mul_dvd_mul_right (h: a ∣ b) (c : Nat) : a * c ∣ b * c 
goal: a * c ∣ b * c

full_name: Nat.dvd_one
code: @[simp] theorem dvd_one {n : Nat} : n ∣ 1 ↔ n = 1 
goal: n ∣ 1 ↔ n = 1

full_name: Nat.mul_div_assoc
code: protected theorem mul_div_assoc (m : Nat) (H : k ∣ n) : m * n / k = m * (n / k) 
goal: m * n / k = m * (n / k)