File: Mathlib/Algebra/EuclideanDomain/Basic.lean

full_name: EuclideanDomain.«_aux_Mathlib_Algebra_EuclideanDomain_Basic___macroRules_EuclideanDomain_term_≺__1»
code: /-- The well founded relation in a Euclidean Domain satisfying `a % b ≺ b` for `b ≠ 0`  -/
local infixl:50 " ≺ " => EuclideanDomain.R
goal: Lean.Macro

full_name: EuclideanDomain.toMulDivCancelClass
code: instance (priority := 100) toMulDivCancelClass : MulDivCancelClass R 
goal: MulDivCancelClass R

full_name: EuclideanDomain.mod_eq_zero
code: @[simp]
theorem mod_eq_zero {a b : R} : a % b = 0 ↔ b ∣ a 
goal: a % b = 0 ↔ b ∣ a

full_name: EuclideanDomain.mod_self
code: @[simp]
theorem mod_self (a : R) : a % a = 0 
goal: a % a = 0

full_name: EuclideanDomain.dvd_mod_iff
code: theorem dvd_mod_iff {a b c : R} (h : c ∣ b) : c ∣ a % b ↔ c ∣ a 
goal: c ∣ a % b ↔ c ∣ a

full_name: EuclideanDomain.mod_one
code: @[simp]
theorem mod_one (a : R) : a % 1 = 0 
goal: a % 1 = 0

full_name: EuclideanDomain.zero_mod
code: @[simp]
theorem zero_mod (b : R) : 0 % b = 0 
goal: 0 % b = 0

full_name: EuclideanDomain.zero_div
code: @[simp]
theorem zero_div {a : R} : 0 / a = 0 
goal: 0 / a = 0

full_name: EuclideanDomain.div_self
code: @[simp]
theorem div_self {a : R} (a0 : a ≠ 0) : a / a = 1 
goal: a / a = 1

full_name: EuclideanDomain.eq_div_of_mul_eq_left
code: theorem eq_div_of_mul_eq_left {a b c : R} (hb : b ≠ 0) (h : a * b = c) : a = c / b 
goal: a = c / b

full_name: EuclideanDomain.eq_div_of_mul_eq_right
code: theorem eq_div_of_mul_eq_right {a b c : R} (ha : a ≠ 0) (h : a * b = c) : b = c / a 
goal: b = c / a

full_name: EuclideanDomain.mul_div_assoc
code: theorem mul_div_assoc (x : R) {y z : R} (h : z ∣ y) : x * y / z = x * (y / z) 
goal: x * y / z = x * (y / z)

full_name: EuclideanDomain.mul_div_cancel'
code: protected theorem mul_div_cancel' {a b : R} (hb : b ≠ 0) (hab : b ∣ a) : b * (a / b) = a 
goal: b * (a / b) = a

full_name: EuclideanDomain.div_one
code: @[simp]
theorem div_one (p : R) : p / 1 = p 
goal: p / 1 = p

full_name: EuclideanDomain.div_dvd_of_dvd
code: theorem div_dvd_of_dvd {p q : R} (hpq : q ∣ p) : p / q ∣ p 
goal: p / q ∣ p

full_name: EuclideanDomain.dvd_div_of_mul_dvd
code: theorem dvd_div_of_mul_dvd {a b c : R} (h : a * b ∣ c) : b ∣ c / a 
goal: b ∣ c / a

full_name: EuclideanDomain.gcd_zero_right
code: @[simp]
theorem gcd_zero_right (a : R) : gcd a 0 = a 
goal: EuclideanDomain.gcd a 0 = a

full_name: EuclideanDomain.gcd_val
code: theorem gcd_val (a b : R) : gcd a b = gcd (b % a) a 
goal: EuclideanDomain.gcd a b = EuclideanDomain.gcd (b % a) a

full_name: EuclideanDomain.gcd_dvd
code: theorem gcd_dvd (a b : R) : gcd a b ∣ a ∧ gcd a b ∣ b 
goal: EuclideanDomain.gcd a b ∣ a ∧ EuclideanDomain.gcd a b ∣ b

full_name: EuclideanDomain.gcd_dvd_left
code: theorem gcd_dvd_left (a b : R) : gcd a b ∣ a 
goal: EuclideanDomain.gcd a b ∣ a

full_name: EuclideanDomain.gcd_dvd_right
code: theorem gcd_dvd_right (a b : R) : gcd a b ∣ b 
goal: EuclideanDomain.gcd a b ∣ b

full_name: EuclideanDomain.gcd_eq_zero_iff
code: protected theorem gcd_eq_zero_iff {a b : R} : gcd a b = 0 ↔ a = 0 ∧ b = 0 
goal: EuclideanDomain.gcd a b = 0 ↔ a = 0 ∧ b = 0

full_name: EuclideanDomain.dvd_gcd
code: theorem dvd_gcd {a b c : R} : c ∣ a → c ∣ b → c ∣ gcd a b 
goal: c ∣ a → c ∣ b → c ∣ EuclideanDomain.gcd a b

full_name: EuclideanDomain.gcd_eq_left
code: theorem gcd_eq_left {a b : R} : gcd a b = a ↔ a ∣ b 
goal: EuclideanDomain.gcd a b = a ↔ a ∣ b

full_name: EuclideanDomain.gcd_one_left
code: @[simp]
theorem gcd_one_left (a : R) : gcd 1 a = 1 
goal: EuclideanDomain.gcd 1 a = 1

full_name: EuclideanDomain.gcd_self
code: @[simp]
theorem gcd_self (a : R) : gcd a a = a 
goal: EuclideanDomain.gcd a a = a

full_name: EuclideanDomain.xgcdAux_fst
code: @[simp]
theorem xgcdAux_fst (x y : R) : ∀ s t s' t', (xgcdAux x s t y s' t').1 = gcd x y 
goal: (EuclideanDomain.xgcdAux x s t y s' t').1 = EuclideanDomain.gcd x y

full_name: EuclideanDomain.xgcdAux_val
code: theorem xgcdAux_val (x y : R) : xgcdAux x 1 0 y 0 1 = (gcd x y, xgcd x y) 
goal: EuclideanDomain.xgcdAux x 1 0 y 0 1 = (EuclideanDomain.gcd x y, EuclideanDomain.xgcd x y)

full_name: _private.Mathlib.Algebra.EuclideanDomain.Basic.0.EuclideanDomain.P
code: private def P (a b : R) : R × R × R → Prop
  
goal: R × R × R → Prop

full_name: EuclideanDomain.xgcdAux_P
code: theorem xgcdAux_P (a b : R) {r r' : R} {s t s' t'} (p : P a b (r, s, t))
    (p' : P a b (r', s', t')) : P a b (xgcdAux r s t r' s' t') 
goal: EuclideanDomain.P a b (EuclideanDomain.xgcdAux r s t r' s' t')

full_name: EuclideanDomain.gcd_eq_gcd_ab
code: /-- An explicit version of **Bézout's lemma** for Euclidean domains. -/
theorem gcd_eq_gcd_ab (a b : R) : (gcd a b : R) = a * gcdA a b + b * gcdB a b 
goal: EuclideanDomain.gcd a b = a * EuclideanDomain.gcdA a b + b * EuclideanDomain.gcdB a b

full_name: EuclideanDomain.instNoZeroDivisors
code: instance (priority := 70) (R : Type*) [e : EuclideanDomain R] : NoZeroDivisors R 
goal: NoZeroDivisors R

full_name: EuclideanDomain.instIsDomain
code: instance (priority := 70) (R : Type*) [e : EuclideanDomain R] : IsDomain R 
goal: IsDomain R

full_name: EuclideanDomain.dvd_lcm_left
code: theorem dvd_lcm_left (x y : R) : x ∣ lcm x y 
goal: x ∣ EuclideanDomain.lcm x y

full_name: EuclideanDomain.dvd_lcm_right
code: theorem dvd_lcm_right (x y : R) : y ∣ lcm x y 
goal: y ∣ EuclideanDomain.lcm x y

full_name: EuclideanDomain.lcm_dvd
code: theorem lcm_dvd {x y z : R} (hxz : x ∣ z) (hyz : y ∣ z) : lcm x y ∣ z 
goal: EuclideanDomain.lcm x y ∣ z

full_name: EuclideanDomain.lcm_dvd_iff
code: @[simp]
theorem lcm_dvd_iff {x y z : R} : lcm x y ∣ z ↔ x ∣ z ∧ y ∣ z 
goal: EuclideanDomain.lcm x y ∣ z ↔ x ∣ z ∧ y ∣ z

full_name: EuclideanDomain.lcm_zero_left
code: @[simp]
theorem lcm_zero_left (x : R) : lcm 0 x = 0 
goal: EuclideanDomain.lcm 0 x = 0

full_name: EuclideanDomain.lcm_zero_right
code: @[simp]
theorem lcm_zero_right (x : R) : lcm x 0 = 0 
goal: EuclideanDomain.lcm x 0 = 0

full_name: EuclideanDomain.lcm_eq_zero_iff
code: @[simp]
theorem lcm_eq_zero_iff {x y : R} : lcm x y = 0 ↔ x = 0 ∨ y = 0 
goal: EuclideanDomain.lcm x y = 0 ↔ x = 0 ∨ y = 0

full_name: EuclideanDomain.gcd_mul_lcm
code: @[simp]
theorem gcd_mul_lcm (x y : R) : gcd x y * lcm x y = x * y 
goal: EuclideanDomain.gcd x y * EuclideanDomain.lcm x y = x * y

full_name: EuclideanDomain.mul_div_mul_cancel
code: theorem mul_div_mul_cancel {a b c : R} (ha : a ≠ 0) (hcb : c ∣ b) : a * b / (a * c) = b / c 
goal: a * b / (a * c) = b / c

full_name: EuclideanDomain.mul_div_mul_comm_of_dvd_dvd
code: theorem mul_div_mul_comm_of_dvd_dvd {a b c d : R} (hac : c ∣ a) (hbd : d ∣ b) :
    a * b / (c * d) = a / c * (b / d) 
goal: a * b / (c * d) = a / c * (b / d)