ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FreeLieAlgebra.liftAux_map_mul
theorem liftAux_map_mul (f : X → L) (a b : lib R X) :
    liftAux R f (a * b) = ⁅liftAux R f a, liftAux R f b⁆ 
Arguments: (R : Type u) {X : Type v} [CommRing R] {L : Type w} [LieRing L] [LieAlgebra R L] (f : X → L) (a b : lib R X)
Goal: (FreeLieAlgebra.liftAux R f) (a * b) = ⁅(FreeLieAlgebra.liftAux R f) a, (FreeLieAlgebra.liftAux R f) b⁆
-- FreeLieAlgebra.liftAux_spec
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b 
Arguments: (R : Type u) {X : Type v} [CommRing R] {L : Type w} [LieRing L] [LieAlgebra R L] (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b)
Goal: (FreeLieAlgebra.liftAux R f) a = (FreeLieAlgebra.liftAux R f) b
-- FreeLieAlgebra.lift_symm_apply
@[simp]
theorem lift_symm_apply (F : FreeLieAlgebra R X →ₗ⁅R⁆ L) : (lift R).symm F = F ∘ of R 
Arguments: (R : Type u) {X : Type v} [CommRing R] {L : Type w} [LieRing L] [LieAlgebra R L] (F : FreeLieAlgebra R X →ₗ⁅R⁆ L)
Goal: (FreeLieAlgebra.lift R).symm F = ⇑F ∘ FreeLieAlgebra.of R
-- FreeLieAlgebra.of_comp_lift
@[simp]
theorem of_comp_lift (f : X → L) : lift R f ∘ of R = f 
Arguments: {R : Type u} {X : Type v} [CommRing R] {L : Type w} [LieRing L] [LieAlgebra R L] (f : X → L)
Goal: ⇑((FreeLieAlgebra.lift R) f) ∘ FreeLieAlgebra.of R = f
-- FreeLieAlgebra.lift_unique
@[simp]
theorem lift_unique (f : X → L) (g : FreeLieAlgebra R X →ₗ⁅R⁆ L) : g ∘ of R = f ↔ g = lift R f 
Arguments: {R : Type u} {X : Type v} [CommRing R] {L : Type w} [LieRing L] [LieAlgebra R L] (f : X → L) (g : FreeLieAlgebra R X →ₗ⁅R⁆ L)
Goal: ⇑g ∘ FreeLieAlgebra.of R = f ↔ g = (FreeLieAlgebra.lift R) f
-- FreeLieAlgebra.lift_of_apply
@[simp]
theorem lift_of_apply (f : X → L) (x) : lift R f (of R x) = f x 
Arguments: {R : Type u} {X : Type v} [CommRing R] {L : Type w} [LieRing L] [LieAlgebra R L] (f : X → L) (x : X)
Goal: ((FreeLieAlgebra.lift R) f) (FreeLieAlgebra.of R x) = f x
-- FreeLieAlgebra.lift_comp_of
@[simp]
theorem lift_comp_of (F : FreeLieAlgebra R X →ₗ⁅R⁆ L) : lift R (F ∘ of R) = F 
Arguments: {R : Type u} {X : Type v} [CommRing R] {L : Type w} [LieRing L] [LieAlgebra R L] (F : FreeLieAlgebra R X →ₗ⁅R⁆ L)
Goal: (FreeLieAlgebra.lift R) (⇑F ∘ FreeLieAlgebra.of R) = F
-- FreeLieAlgebra.hom_ext
@[ext]
theorem hom_ext {F₁ F₂ : FreeLieAlgebra R X →ₗ⁅R⁆ L} (h : ∀ x, F₁ (of R x) = F₂ (of R x)) :
    F₁ = F₂ 
Arguments: {R : Type u} {X : Type v} [CommRing R] {L : Type w} [LieRing L] [LieAlgebra R L] {F₁ F₂ : FreeLieAlgebra R X →ₗ⁅R⁆ L} (h : ∀ (x : X), F₁ (FreeLieAlgebra.of R x) = F₂ (FreeLieAlgebra.of R x))
Goal: F₁ = F₂
-- FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra_apply
@[simps!]
def universalEnvelopingEquivFreeAlgebra :
    UniversalEnvelopingAlgebra R (FreeLieAlgebra R X) ≃ₐ[R] FreeAlgebra R X 
Arguments: (R : Type u) (X : Type v) [CommRing R] (a : UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))
Goal: (FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra R X) a =
  ((UniversalEnvelopingAlgebra.lift R) ((FreeLieAlgebra.lift R) (FreeAlgebra.ι R))) a
-- FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra_symm_apply
@[simps!]
def universalEnvelopingEquivFreeAlgebra :
    UniversalEnvelopingAlgebra R (FreeLieAlgebra R X) ≃ₐ[R] FreeAlgebra R X 
Arguments: (R : Type u) (X : Type v) [CommRing R] (a : FreeAlgebra R X)
Goal: (FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra R X).symm a =
  ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ FreeLieAlgebra.of R)) a
-- TensorProduct.LieModule.lie_tmul_right
@[simp]
theorem lie_tmul_right (x : L) (m : M) (n : N) : ⁅x, m ⊗ₜ[R] n⁆ = ⁅x, m⁆ ⊗ₜ n + m ⊗ₜ ⁅x, n⁆ 
Arguments: {R : Type u} [CommRing R] {L : Type v} {M : Type w} {N : Type w₁} [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [AddCommGroup N] [Module R N] [LieRingModule L N] [LieModule R L N] (x : L) (m : M) (n : N)
Goal: ⁅x, m ⊗ₜ[R] n⁆ = ⁅x, m⁆ ⊗ₜ[R] n + m ⊗ₜ[R] ⁅x, n⁆
-- TensorProduct.LieModule.lift_apply
@[simp]
theorem lift_apply (f : M →ₗ[R] N →ₗ[R] P) (m : M) (n : N) : lift R L M N P f (m ⊗ₜ n) = f m n 
Arguments: (R : Type u) [CommRing R] (L : Type v) (M : Type w) (N : Type w₁) (P : Type w₂) [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [AddCommGroup N] [Module R N] [LieRingModule L N] [LieModule R L N] [AddCommGroup P] [Module R P] [LieRingModule L P] [LieModule R L P] (f : M →ₗ[R] N →ₗ[R] P) (m : M) (n : N)
Goal: ((TensorProduct.LieModule.lift R L M N P) f) (m ⊗ₜ[R] n) = (f m) n
-- TensorProduct.LieModule.coe_liftLie_eq_lift_coe
@[simp]
theorem coe_liftLie_eq_lift_coe (f : M →ₗ⁅R,L⁆ N →ₗ[R] P) :
    ⇑(liftLie R L M N P f) = lift R L M N P f 
Arguments: (R : Type u) [CommRing R] (L : Type v) (M : Type w) (N : Type w₁) (P : Type w₂) [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [AddCommGroup N] [Module R N] [LieRingModule L N] [LieModule R L N] [AddCommGroup P] [Module R P] [LieRingModule L P] [LieModule R L P] (f : M →ₗ⁅R,L⁆ N →ₗ[R] P)
Goal: ⇑((TensorProduct.LieModule.liftLie R L M N P) f) = ⇑((TensorProduct.LieModule.lift R L M N P) ↑f)
-- TensorProduct.LieModule.liftLie_apply
theorem liftLie_apply (f : M →ₗ⁅R,L⁆ N →ₗ[R] P) (m : M) (n : N) :
    liftLie R L M N P f (m ⊗ₜ n) = f m n 
Arguments: (R : Type u) [CommRing R] (L : Type v) (M : Type w) (N : Type w₁) (P : Type w₂) [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [AddCommGroup N] [Module R N] [LieRingModule L N] [LieModule R L N] [AddCommGroup P] [Module R P] [LieRingModule L P] [LieModule R L P] (f : M →ₗ⁅R,L⁆ N →ₗ[R] P) (m : M) (n : N)
Goal: ((TensorProduct.LieModule.liftLie R L M N P) f) (m ⊗ₜ[R] n) = (f m) n
-- TensorProduct.LieModule.coe_linearMap_map
@[simp]
theorem coe_linearMap_map (f : M →ₗ⁅R,L⁆ P) (g : N →ₗ⁅R,L⁆ Q) :
    (map f g : M ⊗[R] N →ₗ[R] P ⊗[R] Q) = TensorProduct.map (f : M →ₗ[R] P) (g : N →ₗ[R] Q) 
Arguments: {R : Type u} [CommRing R] {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} {Q : Type w₃} [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [AddCommGroup N] [Module R N] [LieRingModule L N] [LieModule R L N] [AddCommGroup P] [Module R P] [LieRingModule L P] [LieModule R L P] [AddCommGroup Q] [Module R Q] [LieRingModule L Q] [LieModule R L Q] (f : M →ₗ⁅R,L⁆ P) (g : N →ₗ⁅R,L⁆ Q)
Goal: ↑(TensorProduct.LieModule.map f g) = TensorProduct.map ↑f ↑g
-- TensorProduct.LieModule.map_tmul
@[simp]
nonrec theorem map_tmul (f : M →ₗ⁅R,L⁆ P) (g : N →ₗ⁅R,L⁆ Q) (m : M) (n : N) :
    map f g (m ⊗ₜ n) = f m ⊗ₜ g n 
Arguments: {R : Type u} [CommRing R] {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} {Q : Type w₃} [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [AddCommGroup N] [Module R N] [LieRingModule L N] [LieModule R L N] [AddCommGroup P] [Module R P] [LieRingModule L P] [LieModule R L P] [AddCommGroup Q] [Module R Q] [LieRingModule L Q] [LieModule R L Q] (f : M →ₗ⁅R,L⁆ P) (g : N →ₗ⁅R,L⁆ Q) (m : M) (n : N)
Goal: (TensorProduct.LieModule.map f g) (m ⊗ₜ[R] n) = f m ⊗ₜ[R] g n
-- TensorProduct.LieModule.mapIncl_def
@[simp]
theorem mapIncl_def (M' : LieSubmodule R L M) (N' : LieSubmodule R L N) :
    mapIncl M' N' = map M'.incl N'.incl 
Arguments: {R : Type u} [CommRing R] {L : Type v} {M : Type w} {N : Type w₁} [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [AddCommGroup N] [Module R N] [LieRingModule L N] [LieModule R L N] (M' : LieSubmodule R L M) (N' : LieSubmodule R L N)
Goal: TensorProduct.LieModule.mapIncl M' N' = TensorProduct.LieModule.map M'.incl N'.incl
-- LieModule.toModuleHom_apply
@[simp]
theorem toModuleHom_apply (x : L) (m : M) : toModuleHom R L M (x ⊗ₜ m) = ⁅x, m⁆ 
Arguments: (R : Type u) [CommRing R] (L : Type v) (M : Type w) [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] (x : L) (m : M)
Goal: (LieModule.toModuleHom R L M) (x ⊗ₜ[R] m) = ⁅x, m⁆
-- LieSubmodule.lieIdeal_oper_eq_tensor_map_range
theorem lieIdeal_oper_eq_tensor_map_range :
    ⁅I, N⁆ = ((toModuleHom R L M).comp (mapIncl I N : (↥I) ⊗[R] (↥N) →ₗ⁅R,L⁆ L ⊗[R] M)).range 
Arguments: {R : Type u} [CommRing R] {L : Type v} {M : Type w} [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] (I : LieIdeal R L) (N : LieSubmodule R L M)
Goal: ⁅I, N⁆ = ((LieModule.toModuleHom R L M).comp (TensorProduct.LieModule.mapIncl I N)).range
-- LieSubmodule.mem_normalizer
@[simp]
theorem mem_normalizer (m : M) : m ∈ N.normalizer ↔ ∀ x : L, ⁅x, m⁆ ∈ N 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] (N : LieSubmodule R L M) (m : M)
Goal: m ∈ N.normalizer ↔ ∀ (x : L), ⁅x, m⁆ ∈ N
-- LieSubmodule.le_normalizer
@[simp]
theorem le_normalizer : N ≤ N.normalizer 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] (N : LieSubmodule R L M)
Goal: N ≤ N.normalizer
-- LieSubmodule.normalizer_inf
theorem normalizer_inf : (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] {N₁ N₂ : LieSubmodule R L M}
Goal: (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer
-- LieSubmodule.normalizer_mono
@[gcongr, mono]
theorem normalizer_mono (h : N₁ ≤ N₂) : normalizer N₁ ≤ normalizer N₂ 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] {N₁ N₂ : LieSubmodule R L M} (h : N₁ ≤ N₂)
Goal: N₁.normalizer ≤ N₂.normalizer
-- LieSubmodule.monotone_normalizer
theorem monotone_normalizer : Monotone (normalizer : LieSubmodule R L M → LieSubmodule R L M) 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M]
Goal: Monotone LieSubmodule.normalizer
-- LieSubmodule.comap_normalizer
@[simp]
theorem comap_normalizer (f : M' →ₗ⁅R,L⁆ M) : N.normalizer.comap f = (N.comap f).normalizer 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} {M' : Type u_4} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] [LieModule R L M'] (N : LieSubmodule R L M) (f : M' →ₗ⁅R,L⁆ M)
Goal: LieSubmodule.comap f N.normalizer = (LieSubmodule.comap f N).normalizer
-- LieSubmodule.top_lie_le_iff_le_normalizer
theorem top_lie_le_iff_le_normalizer (N' : LieSubmodule R L M) :
    ⁅(⊤ : LieIdeal R L), N⁆ ≤ N' ↔ N ≤ N'.normalizer 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] (N N' : LieSubmodule R L M)
Goal: ⁅⊤, N⁆ ≤ N' ↔ N ≤ N'.normalizer
-- LieSubmodule.gc_top_lie_normalizer
theorem gc_top_lie_normalizer :
    GaloisConnection (fun N : LieSubmodule R L M => ⁅(⊤ : LieIdeal R L), N⁆) normalizer 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M]
Goal: GaloisConnection (fun N => ⁅⊤, N⁆) LieSubmodule.normalizer
-- LieSubmodule.normalizer_bot_eq_maxTrivSubmodule
theorem normalizer_bot_eq_maxTrivSubmodule :
    (⊥ : LieSubmodule R L M).normalizer = LieModule.maxTrivSubmodule R L M 
Arguments: (R : Type u_1) (L : Type u_2) (M : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M]
Goal: ⊥.normalizer = LieModule.maxTrivSubmodule R L M
-- LieSubmodule.mem_idealizer
@[simp]
lemma mem_idealizer {x : L} : x ∈ N.idealizer ↔ ∀ m : M, ⁅x, m⁆ ∈ N 
Arguments: {R : Type u_1} {L : Type u_2} {M : Type u_3} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] (N : LieSubmodule R L M) {x : L}
Goal: x ∈ N.idealizer ↔ ∀ (m : M), ⁅x, m⁆ ∈ N
-- LieIdeal.idealizer_eq_normalizer
@[simp]
lemma _root_.LieIdeal.idealizer_eq_normalizer (I : LieIdeal R L) :
    I.idealizer = I.normalizer 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L)
Goal: LieSubmodule.idealizer I = LieSubmodule.normalizer I
-- LieSubalgebra.mem_normalizer_iff'
theorem mem_normalizer_iff' (x : L) : x ∈ H.normalizer ↔ ∀ y : L, y ∈ H → ⁅y, x⁆ ∈ H 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] (H : LieSubalgebra R L) (x : L)
Goal: x ∈ H.normalizer ↔ ∀ y ∈ H, ⁅y, x⁆ ∈ H
-- LieSubalgebra.mem_normalizer_iff
theorem mem_normalizer_iff (x : L) : x ∈ H.normalizer ↔ ∀ y : L, y ∈ H → ⁅x, y⁆ ∈ H 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] (H : LieSubalgebra R L) (x : L)
Goal: x ∈ H.normalizer ↔ ∀ y ∈ H, ⁅x, y⁆ ∈ H
-- LieSubalgebra.le_normalizer
theorem le_normalizer : H ≤ H.normalizer 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] (H : LieSubalgebra R L)
Goal: H ≤ H.normalizer
-- LieSubalgebra.coe_normalizer_eq_normalizer
theorem coe_normalizer_eq_normalizer :
    (H.toLieSubmodule.normalizer : Submodule R L) = H.normalizer 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] (H : LieSubalgebra R L)
Goal: ↑H.toLieSubmodule.normalizer = H.normalizer.toSubmodule
-- LieSubalgebra.lie_mem_sup_of_mem_normalizer
theorem lie_mem_sup_of_mem_normalizer {x y z : L} (hx : x ∈ H.normalizer) (hy : y ∈ (R ∙ x) ⊔ ↑H)
    (hz : z ∈ (R ∙ x) ⊔ ↑H) : ⁅y, z⁆ ∈ (R ∙ x) ⊔ ↑H 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] {H : LieSubalgebra R L} {x y z : L} (hx : x ∈ H.normalizer) (hy : y ∈ Submodule.span R {x} ⊔ H.toSubmodule) (hz : z ∈ Submodule.span R {x} ⊔ H.toSubmodule)
Goal: ⁅y, z⁆ ∈ Submodule.span R {x} ⊔ H.toSubmodule
-- LieSubalgebra.ideal_in_normalizer
theorem ideal_in_normalizer {x y : L} (hx : x ∈ H.normalizer) (hy : y ∈ H) : ⁅x, y⁆ ∈ H 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] {H : LieSubalgebra R L} {x y : L} (hx : x ∈ H.normalizer) (hy : y ∈ H)
Goal: ⁅x, y⁆ ∈ H
-- LieSubalgebra.exists_nested_lieIdeal_ofLe_normalizer
theorem exists_nested_lieIdeal_ofLe_normalizer {K : LieSubalgebra R L} (h₁ : H ≤ K)
    (h₂ : K ≤ H.normalizer) : ∃ I : LieIdeal R K, (I : LieSubalgebra R K) = ofLe h₁ 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] {H K : LieSubalgebra R L} (h₁ : H ≤ K) (h₂ : K ≤ H.normalizer)
Goal: ∃ I, lieIdealSubalgebra R (↥K) I = LieSubalgebra.ofLe h₁
-- LieSubalgebra.normalizer_eq_self_iff
theorem normalizer_eq_self_iff :
    H.normalizer = H ↔ (LieModule.maxTrivSubmodule R H <| L ⧸ H.toLieSubmodule) = ⊥ 
Arguments: {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] (H : LieSubalgebra R L)
Goal: H.normalizer = H ↔ LieModule.maxTrivSubmodule R (↥H) (L ⧸ H.toLieSubmodule) = ⊥
-- EuclideanDomain.quotient_zero
class EuclideanDomain (R : Type u) extends CommRing R, Nontrivial R where
    protected quotient : R → R → R
    protected quotient_zero : ∀ a, quotient a 0 = 0
    protected remainder : R → R → R
    protected quotient_mul_add_remainder_eq : ∀ a b, b * quotient a b + remainder a b = a
    protected r : R → R → Prop
    r_wellFounded : WellFounded r
    protected remainder_lt : ∀ (a) {b}, b ≠ 0 → r (remainder a b) b
    mul_left_not_lt : ∀ (a) {b}, b ≠ 0 → ¬r (a * b) a
Arguments: {R : Type u} [self : EuclideanDomain R] (a : R)
Goal: EuclideanDomain.quotient a 0 = 0
-- EuclideanDomain.quotient_mul_add_remainder_eq
class EuclideanDomain (R : Type u) extends CommRing R, Nontrivial R where
    protected quotient : R → R → R
    protected quotient_zero : ∀ a, quotient a 0 = 0
    protected remainder : R → R → R
    protected quotient_mul_add_remainder_eq : ∀ a b, b * quotient a b + remainder a b = a
    protected r : R → R → Prop
    r_wellFounded : WellFounded r
    protected remainder_lt : ∀ (a) {b}, b ≠ 0 → r (remainder a b) b
    mul_left_not_lt : ∀ (a) {b}, b ≠ 0 → ¬r (a * b) a
Arguments: {R : Type u} [self : EuclideanDomain R] (a b : R)
Goal: b * EuclideanDomain.quotient a b + EuclideanDomain.remainder a b = a
-- EuclideanDomain.r_wellFounded
class EuclideanDomain (R : Type u) extends CommRing R, Nontrivial R where
    protected quotient : R → R → R
    protected quotient_zero : ∀ a, quotient a 0 = 0
    protected remainder : R → R → R
    protected quotient_mul_add_remainder_eq : ∀ a b, b * quotient a b + remainder a b = a
    protected r : R → R → Prop
    r_wellFounded : WellFounded r
    protected remainder_lt : ∀ (a) {b}, b ≠ 0 → r (remainder a b) b
    mul_left_not_lt : ∀ (a) {b}, b ≠ 0 → ¬r (a * b) a
Arguments: {R : Type u} [self : EuclideanDomain R]
Goal: WellFounded EuclideanDomain.r
-- EuclideanDomain.mul_left_not_lt
class EuclideanDomain (R : Type u) extends CommRing R, Nontrivial R where
    protected quotient : R → R → R
    protected quotient_zero : ∀ a, quotient a 0 = 0
    protected remainder : R → R → R
    protected quotient_mul_add_remainder_eq : ∀ a b, b * quotient a b + remainder a b = a
    protected r : R → R → Prop
    r_wellFounded : WellFounded r
    protected remainder_lt : ∀ (a) {b}, b ≠ 0 → r (remainder a b) b
    mul_left_not_lt : ∀ (a) {b}, b ≠ 0 → ¬r (a * b) a
Arguments: {R : Type u} [self : EuclideanDomain R] (a : R) {b : R}
Goal: b ≠ 0 → ¬EuclideanDomain.r (a * b) a
-- EuclideanDomain.remainder_lt
class EuclideanDomain (R : Type u) extends CommRing R, Nontrivial R where
    protected quotient : R → R → R
    protected quotient_zero : ∀ a, quotient a 0 = 0
    protected remainder : R → R → R
    protected quotient_mul_add_remainder_eq : ∀ a b, b * quotient a b + remainder a b = a
    protected r : R → R → Prop
    r_wellFounded : WellFounded r
    protected remainder_lt : ∀ (a) {b}, b ≠ 0 → r (remainder a b) b
    mul_left_not_lt : ∀ (a) {b}, b ≠ 0 → ¬r (a * b) a
Arguments: {R : Type u} [self : EuclideanDomain R] (a : R) {b : R}
Goal: b ≠ 0 → EuclideanDomain.r (EuclideanDomain.remainder a b) b
-- EuclideanDomain.div_add_mod
theorem div_add_mod (a b : R) : b * (a / b) + a % b = a 
Arguments: {R : Type u} [EuclideanDomain R] (a b : R)
Goal: b * (a / b) + a % b = a
-- EuclideanDomain.mod_add_div
theorem mod_add_div (a b : R) : a % b + b * (a / b) = a 
Arguments: {R : Type u} [EuclideanDomain R] (a b : R)
Goal: a % b + b * (a / b) = a
-- EuclideanDomain.mod_add_div'
theorem mod_add_div' (m k : R) : m % k + m / k * k = m 
Arguments: {R : Type u} [EuclideanDomain R] (m k : R)
Goal: m % k + m / k * k = m
-- EuclideanDomain.div_add_mod'
theorem div_add_mod' (m k : R) : m / k * k + m % k = m 
Arguments: {R : Type u} [EuclideanDomain R] (m k : R)
Goal: m / k * k + m % k = m
-- EuclideanDomain.mod_eq_sub_mul_div
theorem mod_eq_sub_mul_div {R : Type*} [EuclideanDomain R] (a b : R) : a % b = a - b * (a / b) 
Arguments: {R : Type u_1} [EuclideanDomain R] (a b : R)
Goal: a % b = a - b * (a / b)
-- EuclideanDomain.mod_lt
theorem mod_lt : ∀ (a) {b : R}, b ≠ 0 → a % b ≺ b 
Arguments: {R : Type u} [EuclideanDomain R] (a : R) {b : R}
Goal: b ≠ 0 → EuclideanDomain.r (a % b) b
-- EuclideanDomain.mul_right_not_lt
theorem mul_right_not_lt {a : R} (b) (h : a ≠ 0) : ¬a * b ≺ b 
Arguments: {R : Type u} [EuclideanDomain R] {a : R} (b : R) (h : a ≠ 0)
Goal: ¬EuclideanDomain.r (a * b) b
-- EuclideanDomain.mod_zero
@[simp]
theorem mod_zero (a : R) : a % 0 = a 
Arguments: {R : Type u} [EuclideanDomain R] (a : R)
Goal: a % 0 = a
-- EuclideanDomain.lt_one
theorem lt_one (a : R) : a ≺ (1 : R) → a = 0 
Arguments: {R : Type u} [EuclideanDomain R] (a : R)
Goal: EuclideanDomain.r a 1 → a = 0
-- EuclideanDomain.val_dvd_le
theorem val_dvd_le : ∀ a b : R, b ∣ a → a ≠ 0 → ¬a ≺ b
  
Arguments: {R : Type u} [EuclideanDomain R] (a b : R)
Goal: b ∣ a → a ≠ 0 → ¬EuclideanDomain.r a b
-- EuclideanDomain.div_zero
@[simp]
theorem div_zero (a : R) : a / 0 = 0 
Arguments: {R : Type u} [EuclideanDomain R] (a : R)
Goal: a / 0 = 0
-- EuclideanDomain.GCD.induction
@[elab_as_elim]
theorem GCD.induction {P : R → R → Prop} (a b : R) (H0 : ∀ x, P 0 x)
    (H1 : ∀ a b, a ≠ 0 → P (b % a) a → P a b) : P a b 
Arguments: {R : Type u} [EuclideanDomain R] {P : R → R → Prop} (a b : R) (H0 : ∀ (x : R), P 0 x) (H1 : ∀ (a b : R), a ≠ 0 → P (b % a) a → P a b)
Goal: P a b
-- EuclideanDomain.gcd_zero_left
@[simp]
theorem gcd_zero_left (a : R) : gcd 0 a = a 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a : R)
Goal: EuclideanDomain.gcd 0 a = a
-- EuclideanDomain.xgcd_zero_left
@[simp]
theorem xgcd_zero_left {s t r' s' t' : R} : xgcdAux 0 s t r' s' t' = (r', s', t') 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {s t r' s' t' : R}
Goal: EuclideanDomain.xgcdAux 0 s t r' s' t' = (r', s', t')
-- EuclideanDomain.xgcdAux_rec
theorem xgcdAux_rec {r s t r' s' t' : R} (h : r ≠ 0) :
    xgcdAux r s t r' s' t' = xgcdAux (r' % r) (s' - r' / r * s) (t' - r' / r * t) r s t 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {r s t r' s' t' : R} (h : r ≠ 0)
Goal: EuclideanDomain.xgcdAux r s t r' s' t' = EuclideanDomain.xgcdAux (r' % r) (s' - r' / r * s) (t' - r' / r * t) r s t
-- EuclideanDomain.gcdA_zero_left
@[simp]
theorem gcdA_zero_left {s : R} : gcdA 0 s = 0 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {s : R}
Goal: EuclideanDomain.gcdA 0 s = 0
-- EuclideanDomain.gcdB_zero_left
@[simp]
theorem gcdB_zero_left {s : R} : gcdB 0 s = 1 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {s : R}
Goal: EuclideanDomain.gcdB 0 s = 1
-- EuclideanDomain.xgcd_val
theorem xgcd_val (x y : R) : xgcd x y = (gcdA x y, gcdB x y) 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (x y : R)
Goal: EuclideanDomain.xgcd x y = (EuclideanDomain.gcdA x y, EuclideanDomain.gcdB x y)
-- EuclideanDomain.mod_eq_zero
@[simp]
theorem mod_eq_zero {a b : R} : a % b = 0 ↔ b ∣ a 
Arguments: {R : Type u} [EuclideanDomain R] {a b : R}
Goal: a % b = 0 ↔ b ∣ a
-- EuclideanDomain.mod_self
@[simp]
theorem mod_self (a : R) : a % a = 0 
Arguments: {R : Type u} [EuclideanDomain R] (a : R)
Goal: a % a = 0
-- EuclideanDomain.dvd_mod_iff
theorem dvd_mod_iff {a b c : R} (h : c ∣ b) : c ∣ a % b ↔ c ∣ a 
Arguments: {R : Type u} [EuclideanDomain R] {a b c : R} (h : c ∣ b)
Goal: c ∣ a % b ↔ c ∣ a
-- EuclideanDomain.mod_one
@[simp]
theorem mod_one (a : R) : a % 1 = 0 
Arguments: {R : Type u} [EuclideanDomain R] (a : R)
Goal: a % 1 = 0
-- EuclideanDomain.zero_mod
@[simp]
theorem zero_mod (b : R) : 0 % b = 0 
Arguments: {R : Type u} [EuclideanDomain R] (b : R)
Goal: 0 % b = 0
-- EuclideanDomain.zero_div
@[simp]
theorem zero_div {a : R} : 0 / a = 0 
Arguments: {R : Type u} [EuclideanDomain R] {a : R}
Goal: 0 / a = 0
-- EuclideanDomain.div_self
@[simp]
theorem div_self {a : R} (a0 : a ≠ 0) : a / a = 1 
Arguments: {R : Type u} [EuclideanDomain R] {a : R} (a0 : a ≠ 0)
Goal: a / a = 1
-- EuclideanDomain.eq_div_of_mul_eq_left
theorem eq_div_of_mul_eq_left {a b c : R} (hb : b ≠ 0) (h : a * b = c) : a = c / b 
Arguments: {R : Type u} [EuclideanDomain R] {a b c : R} (hb : b ≠ 0) (h : a * b = c)
Goal: a = c / b
-- EuclideanDomain.eq_div_of_mul_eq_right
theorem eq_div_of_mul_eq_right {a b c : R} (ha : a ≠ 0) (h : a * b = c) : b = c / a 
Arguments: {R : Type u} [EuclideanDomain R] {a b c : R} (ha : a ≠ 0) (h : a * b = c)
Goal: b = c / a
-- EuclideanDomain.mul_div_assoc
theorem mul_div_assoc (x : R) {y z : R} (h : z ∣ y) : x * y / z = x * (y / z) 
Arguments: {R : Type u} [EuclideanDomain R] (x : R) {y z : R} (h : z ∣ y)
Goal: x * y / z = x * (y / z)
-- EuclideanDomain.mul_div_cancel'
protected theorem mul_div_cancel' {a b : R} (hb : b ≠ 0) (hab : b ∣ a) : b * (a / b) = a 
Arguments: {R : Type u} [EuclideanDomain R] {a b : R} (hb : b ≠ 0) (hab : b ∣ a)
Goal: b * (a / b) = a
-- EuclideanDomain.div_one
@[simp]
theorem div_one (p : R) : p / 1 = p 
Arguments: {R : Type u} [EuclideanDomain R] (p : R)
Goal: p / 1 = p
-- EuclideanDomain.div_dvd_of_dvd
theorem div_dvd_of_dvd {p q : R} (hpq : q ∣ p) : p / q ∣ p 
Arguments: {R : Type u} [EuclideanDomain R] {p q : R} (hpq : q ∣ p)
Goal: p / q ∣ p