ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- RatFunc.sub_def
protected irreducible_def sub : RatFunc K → RatFunc K → RatFunc K
  
Arguments: {K : Type u_1} [CommRing K]
Goal: ∀ (x x_1 : RatFunc K),
  x.sub x_1 =
    match x, x_1 with
    | { toFractionRing := p }, { toFractionRing := q } => { toFractionRing := p - q }
-- RatFunc.ofFractionRing_sub
theorem ofFractionRing_sub (p q : FractionRing K[X]) :
    ofFractionRing (p - q) = ofFractionRing p - ofFractionRing q 
Arguments: {K : Type u} [CommRing K] (p q : FractionRing K[X])
Goal: { toFractionRing := p - q } = { toFractionRing := p } - { toFractionRing := q }
-- RatFunc.neg_def
protected irreducible_def neg : RatFunc K → RatFunc K
  
Arguments: {K : Type u_1} [CommRing K]
Goal: ∀ (x : RatFunc K),
  x.neg =
    match x with
    | { toFractionRing := p } => { toFractionRing := -p }
-- RatFunc.ofFractionRing_neg
theorem ofFractionRing_neg (p : FractionRing K[X]) :
    ofFractionRing (-p) = -ofFractionRing p 
Arguments: {K : Type u} [CommRing K] (p : FractionRing K[X])
Goal: { toFractionRing := -p } = -{ toFractionRing := p }
-- RatFunc.one_def
protected irreducible_def one : RatFunc K 
Arguments: {K : Type u_1} [CommRing K]
Goal: RatFunc.one = { toFractionRing := 1 }
-- RatFunc.ofFractionRing_one
theorem ofFractionRing_one : (ofFractionRing 1 : RatFunc K) = 1 
Arguments: {K : Type u} [CommRing K]
Goal: { toFractionRing := 1 } = 1
-- RatFunc.mul_def
protected irreducible_def mul : RatFunc K → RatFunc K → RatFunc K
  
Arguments: {K : Type u_1} [CommRing K]
Goal: ∀ (x x_1 : RatFunc K),
  x.mul x_1 =
    match x, x_1 with
    | { toFractionRing := p }, { toFractionRing := q } => { toFractionRing := p * q }
-- RatFunc.ofFractionRing_mul
theorem ofFractionRing_mul (p q : FractionRing K[X]) :
    ofFractionRing (p * q) = ofFractionRing p * ofFractionRing q 
Arguments: {K : Type u} [CommRing K] (p q : FractionRing K[X])
Goal: { toFractionRing := p * q } = { toFractionRing := p } * { toFractionRing := q }
-- RatFunc.div_def
protected irreducible_def div : RatFunc K → RatFunc K → RatFunc K
  
Arguments: {K : Type u_1} [CommRing K] [IsDomain K]
Goal: ∀ (x x_1 : RatFunc K),
  x.div x_1 =
    match x, x_1 with
    | { toFractionRing := p }, { toFractionRing := q } => { toFractionRing := p / q }
-- RatFunc.ofFractionRing_div
theorem ofFractionRing_div (p q : FractionRing K[X]) :
    ofFractionRing (p / q) = ofFractionRing p / ofFractionRing q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] (p q : FractionRing K[X])
Goal: { toFractionRing := p / q } = { toFractionRing := p } / { toFractionRing := q }
-- RatFunc.inv_def
protected irreducible_def inv : RatFunc K → RatFunc K
  
Arguments: {K : Type u_1} [CommRing K] [IsDomain K]
Goal: ∀ (x : RatFunc K),
  x.inv =
    match x with
    | { toFractionRing := p } => { toFractionRing := p⁻¹ }
-- RatFunc.ofFractionRing_inv
theorem ofFractionRing_inv (p : FractionRing K[X]) :
    ofFractionRing p⁻¹ = (ofFractionRing p)⁻¹ 
Arguments: {K : Type u} [CommRing K] [IsDomain K] (p : FractionRing K[X])
Goal: { toFractionRing := p⁻¹ } = { toFractionRing := p }⁻¹
-- RatFunc.mul_inv_cancel
theorem mul_inv_cancel : ∀ {p : RatFunc K}, p ≠ 0 → p * p⁻¹ = 1
  
Arguments: {K : Type u} [CommRing K] [IsDomain K] {p : RatFunc K}
Goal: p ≠ 0 → p * p⁻¹ = 1
-- RatFunc.smul_def
protected irreducible_def smul [SMul R (FractionRing K[X])] : R → RatFunc K → RatFunc K
  
Arguments: {K : Type u_2} [CommRing K] {R : Type u_3} [SMul R (FractionRing K[X])]
Goal: ∀ (x : R) (x_1 : RatFunc K),
  RatFunc.smul x x_1 =
    match x, x_1 with
    | r, { toFractionRing := p } => { toFractionRing := r • p }
-- RatFunc.ofFractionRing_smul
theorem ofFractionRing_smul [SMul R (FractionRing K[X])] (c : R) (p : FractionRing K[X]) :
    ofFractionRing (c • p) = c • ofFractionRing p 
Arguments: {K : Type u} [CommRing K] {R : Type u_1} [SMul R (FractionRing K[X])] (c : R) (p : FractionRing K[X])
Goal: { toFractionRing := c • p } = c • { toFractionRing := p }
-- RatFunc.toFractionRing_smul
theorem toFractionRing_smul [SMul R (FractionRing K[X])] (c : R) (p : RatFunc K) :
    toFractionRing (c • p) = c • toFractionRing p 
Arguments: {K : Type u} [CommRing K] {R : Type u_1} [SMul R (FractionRing K[X])] (c : R) (p : RatFunc K)
Goal: (c • p).toFractionRing = c • p.toFractionRing
-- RatFunc.smul_eq_C_smul
theorem smul_eq_C_smul (x : RatFunc K) (r : K) : r • x = Polynomial.C r • x 
Arguments: {K : Type u} [CommRing K] (x : RatFunc K) (r : K)
Goal: r • x = Polynomial.C r • x
-- RatFunc.mk_smul
theorem mk_smul (c : R) (p q : K[X]) : RatFunc.mk (c • p) q = c • RatFunc.mk p q 
Arguments: {K : Type u} [CommRing K] {R : Type u_1} [IsDomain K] [Monoid R] [DistribMulAction R K[X]] [IsScalarTower R K[X] K[X]] (c : R) (p q : K[X])
Goal: RatFunc.mk (c • p) q = c • RatFunc.mk p q
-- RatFunc.toFractionRingRingEquiv_apply
@[simps apply]
def toFractionRingRingEquiv : RatFunc K ≃+* FractionRing K[X] 
Arguments: (K : Type u) [CommRing K] (self : RatFunc K)
Goal: (RatFunc.toFractionRingRingEquiv K) self = self.toFractionRing
-- RatFunc.map_apply_ofFractionRing_mk
theorem map_apply_ofFractionRing_mk [MonoidHomClass F R[X] S[X]] (φ : F)
    (hφ : R[X]⁰ ≤ S[X]⁰.comap φ) (n : R[X]) (d : R[X]⁰) :
    map φ hφ (ofFractionRing (Localization.mk n d)) =
      ofFractionRing (Localization.mk (φ n) ⟨φ d, hφ d.prop⟩) 
Arguments: {R : Type u_3} {S : Type u_4} {F : Type u_5} [CommRing R] [CommRing S] [FunLike F R[X] S[X]] [MonoidHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰) (n : R[X]) (d : ↥R[X]⁰)
Goal: (RatFunc.map φ hφ) { toFractionRing := Localization.mk n d } = { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, ⋯⟩ }
-- RatFunc.map_injective
theorem map_injective [MonoidHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ S[X]⁰.comap φ)
    (hf : Function.Injective φ) : Function.Injective (map φ hφ) 
Arguments: {R : Type u_3} {S : Type u_4} {F : Type u_5} [CommRing R] [CommRing S] [FunLike F R[X] S[X]] [MonoidHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰) (hf : Function.Injective ⇑φ)
Goal: Function.Injective ⇑(RatFunc.map φ hφ)
-- RatFunc.coe_mapRingHom_eq_coe_map
theorem coe_mapRingHom_eq_coe_map [RingHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ S[X]⁰.comap φ) :
    (mapRingHom φ hφ : RatFunc R → RatFunc S) = map φ hφ 
Arguments: {R : Type u_3} {S : Type u_4} {F : Type u_5} [CommRing R] [CommRing S] [FunLike F R[X] S[X]] [RingHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ Submonoid.comap φ S[X]⁰)
Goal: ⇑(RatFunc.mapRingHom φ hφ) = ⇑(RatFunc.map φ hφ)
-- RatFunc.liftMonoidWithZeroHom_apply_ofFractionRing_mk
theorem liftMonoidWithZeroHom_apply_ofFractionRing_mk (φ : R[X] →*₀ G₀) (hφ : R[X]⁰ ≤ G₀⁰.comap φ)
    (n : R[X]) (d : R[X]⁰) :
    liftMonoidWithZeroHom φ hφ (ofFractionRing (Localization.mk n d)) = φ n / φ d 
Arguments: {G₀ : Type u_1} {R : Type u_3} [CommGroupWithZero G₀] [CommRing R] (φ : R[X] →*₀ G₀) (hφ : R[X]⁰ ≤ Submonoid.comap φ G₀⁰) (n : R[X]) (d : ↥R[X]⁰)
Goal: (RatFunc.liftMonoidWithZeroHom φ hφ) { toFractionRing := Localization.mk n d } = φ n / φ ↑d
-- RatFunc.liftMonoidWithZeroHom_injective
theorem liftMonoidWithZeroHom_injective [Nontrivial R] (φ : R[X] →*₀ G₀) (hφ : Function.Injective φ)
    (hφ' : R[X]⁰ ≤ G₀⁰.comap φ := nonZeroDivisors_le_comap_nonZeroDivisors_of_injective _ hφ) :
    Function.Injective (liftMonoidWithZeroHom φ hφ') 
Arguments: {G₀ : Type u_1} {R : Type u_3} [CommGroupWithZero G₀] [CommRing R] [Nontrivial R] (φ : R[X] →*₀ G₀) (hφ : Function.Injective ⇑φ) (hφ' : R[X]⁰ ≤ Submonoid.comap φ G₀⁰ := ⋯)
Goal: Function.Injective ⇑(RatFunc.liftMonoidWithZeroHom φ hφ')
-- RatFunc.liftRingHom_apply_ofFractionRing_mk
theorem liftRingHom_apply_ofFractionRing_mk (φ : R[X] →+* L) (hφ : R[X]⁰ ≤ L⁰.comap φ) (n : R[X])
    (d : R[X]⁰) : liftRingHom φ hφ (ofFractionRing (Localization.mk n d)) = φ n / φ d 
Arguments: {L : Type u_2} {R : Type u_3} [Field L] [CommRing R] (φ : R[X] →+* L) (hφ : R[X]⁰ ≤ Submonoid.comap φ L⁰) (n : R[X]) (d : ↥R[X]⁰)
Goal: (RatFunc.liftRingHom φ hφ) { toFractionRing := Localization.mk n d } = φ n / φ ↑d
-- RatFunc.liftRingHom_injective
theorem liftRingHom_injective [Nontrivial R] (φ : R[X] →+* L) (hφ : Function.Injective φ)
    (hφ' : R[X]⁰ ≤ L⁰.comap φ := nonZeroDivisors_le_comap_nonZeroDivisors_of_injective _ hφ) :
    Function.Injective (liftRingHom φ hφ') 
Arguments: {L : Type u_2} {R : Type u_3} [Field L] [CommRing R] [Nontrivial R] (φ : R[X] →+* L) (hφ : Function.Injective ⇑φ) (hφ' : R[X]⁰ ≤ Submonoid.comap φ L⁰ := ⋯)
Goal: Function.Injective ⇑(RatFunc.liftRingHom φ hφ')
-- RatFunc.mk_one
theorem mk_one (x : K[X]) : RatFunc.mk x 1 = algebraMap _ _ x 
Arguments: {K : Type u} [CommRing K] [IsDomain K] (x : K[X])
Goal: RatFunc.mk x 1 = (algebraMap K[X] (RatFunc K)) x
-- RatFunc.ofFractionRing_algebraMap
theorem ofFractionRing_algebraMap (x : K[X]) :
    ofFractionRing (algebraMap _ (FractionRing K[X]) x) = algebraMap _ _ x 
Arguments: {K : Type u} [CommRing K] [IsDomain K] (x : K[X])
Goal: { toFractionRing := (algebraMap K[X] (FractionRing K[X])) x } = (algebraMap K[X] (RatFunc K)) x
-- RatFunc.mk_eq_div
@[simp]
theorem mk_eq_div (p q : K[X]) : RatFunc.mk p q = algebraMap _ _ p / algebraMap _ _ q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] (p q : K[X])
Goal: RatFunc.mk p q = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q
-- RatFunc.div_smul
@[simp]
theorem div_smul {R} [Monoid R] [DistribMulAction R K[X]] [IsScalarTower R K[X] K[X]] (c : R)
    (p q : K[X]) :
    algebraMap _ (RatFunc K) (c • p) / algebraMap _ _ q =
      c • (algebraMap _ _ p / algebraMap _ _ q) 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {R : Type u_1} [Monoid R] [DistribMulAction R K[X]] [IsScalarTower R K[X] K[X]] (c : R) (p q : K[X])
Goal: (algebraMap K[X] (RatFunc K)) (c • p) / (algebraMap K[X] (RatFunc K)) q =
  c • ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q)
-- RatFunc.algebraMap_apply
theorem algebraMap_apply {R : Type*} [CommSemiring R] [Algebra R K[X]] (x : R) :
    algebraMap R (RatFunc K) x = algebraMap _ _ (algebraMap R K[X] x) / algebraMap K[X] _ 1 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {R : Type u_1} [CommSemiring R] [Algebra R K[X]] (x : R)
Goal: (algebraMap R (RatFunc K)) x = (algebraMap K[X] (RatFunc K)) ((algebraMap R K[X]) x) / (algebraMap K[X] (RatFunc K)) 1
-- RatFunc.map_apply_div_ne_zero
theorem map_apply_div_ne_zero {R F : Type*} [CommRing R] [IsDomain R]
    [FunLike F K[X] R[X]] [MonoidHomClass F K[X] R[X]]
    (φ : F) (hφ : K[X]⁰ ≤ R[X]⁰.comap φ) (p q : K[X]) (hq : q ≠ 0) :
    map φ hφ (algebraMap _ _ p / algebraMap _ _ q) =
      algebraMap _ _ (φ p) / algebraMap _ _ (φ q) 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {R : Type u_1} {F : Type u_2} [CommRing R] [IsDomain R] [FunLike F K[X] R[X]] [MonoidHomClass F K[X] R[X]] (φ : F) (hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰) (p q : K[X]) (hq : q ≠ 0)
Goal: (RatFunc.map φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) =
  (algebraMap R[X] (RatFunc R)) (φ p) / (algebraMap R[X] (RatFunc R)) (φ q)
-- RatFunc.map_apply_div
@[simp]
theorem map_apply_div {R F : Type*} [CommRing R] [IsDomain R]
    [FunLike F K[X] R[X]] [MonoidWithZeroHomClass F K[X] R[X]]
    (φ : F) (hφ : K[X]⁰ ≤ R[X]⁰.comap φ) (p q : K[X]) :
    map φ hφ (algebraMap _ _ p / algebraMap _ _ q) =
      algebraMap _ _ (φ p) / algebraMap _ _ (φ q) 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {R : Type u_1} {F : Type u_2} [CommRing R] [IsDomain R] [FunLike F K[X] R[X]] [MonoidWithZeroHomClass F K[X] R[X]] (φ : F) (hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰) (p q : K[X])
Goal: (RatFunc.map φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) =
  (algebraMap R[X] (RatFunc R)) (φ p) / (algebraMap R[X] (RatFunc R)) (φ q)
-- RatFunc.liftMonoidWithZeroHom_apply_div
theorem liftMonoidWithZeroHom_apply_div {L : Type*} [CommGroupWithZero L]
    (φ : MonoidWithZeroHom K[X] L) (hφ : K[X]⁰ ≤ L⁰.comap φ) (p q : K[X]) :
    liftMonoidWithZeroHom φ hφ (algebraMap _ _ p / algebraMap _ _ q) = φ p / φ q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {L : Type u_1} [CommGroupWithZero L] (φ : K[X] →*₀ L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (p q : K[X])
Goal: (RatFunc.liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q
-- RatFunc.liftMonoidWithZeroHom_apply_div'
@[simp]
theorem liftMonoidWithZeroHom_apply_div' {L : Type*} [CommGroupWithZero L]
    (φ : MonoidWithZeroHom K[X] L) (hφ : K[X]⁰ ≤ L⁰.comap φ) (p q : K[X]) :
    liftMonoidWithZeroHom φ hφ (algebraMap _ _ p) / liftMonoidWithZeroHom φ hφ (algebraMap _ _ q) =
      φ p / φ q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {L : Type u_1} [CommGroupWithZero L] (φ : K[X] →*₀ L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (p q : K[X])
Goal: (RatFunc.liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p) /
    (RatFunc.liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) q) =
  φ p / φ q
-- RatFunc.liftRingHom_apply_div
theorem liftRingHom_apply_div {L : Type*} [Field L] (φ : K[X] →+* L) (hφ : K[X]⁰ ≤ L⁰.comap φ)
    (p q : K[X]) : liftRingHom φ hφ (algebraMap _ _ p / algebraMap _ _ q) = φ p / φ q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {L : Type u_1} [Field L] (φ : K[X] →+* L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (p q : K[X])
Goal: (RatFunc.liftRingHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q
-- RatFunc.liftRingHom_apply_div'
@[simp]
theorem liftRingHom_apply_div' {L : Type*} [Field L] (φ : K[X] →+* L) (hφ : K[X]⁰ ≤ L⁰.comap φ)
    (p q : K[X]) : liftRingHom φ hφ (algebraMap _ _ p) / liftRingHom φ hφ (algebraMap _ _ q) =
      φ p / φ q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {L : Type u_1} [Field L] (φ : K[X] →+* L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (p q : K[X])
Goal: (RatFunc.liftRingHom φ hφ) ((algebraMap K[X] (RatFunc K)) p) /
    (RatFunc.liftRingHom φ hφ) ((algebraMap K[X] (RatFunc K)) q) =
  φ p / φ q
-- RatFunc.ofFractionRing_comp_algebraMap
theorem ofFractionRing_comp_algebraMap :
    ofFractionRing ∘ algebraMap K[X] (FractionRing K[X]) = algebraMap _ _ 
Arguments: (K : Type u) [CommRing K] [IsDomain K]
Goal: RatFunc.ofFractionRing ∘ ⇑(algebraMap K[X] (FractionRing K[X])) = ⇑(algebraMap K[X] (RatFunc K))
-- RatFunc.algebraMap_injective
theorem algebraMap_injective : Function.Injective (algebraMap K[X] (RatFunc K)) 
Arguments: (K : Type u) [CommRing K] [IsDomain K]
Goal: Function.Injective ⇑(algebraMap K[X] (RatFunc K))
-- RatFunc.algebraMap_eq_zero_iff
@[simp]
theorem algebraMap_eq_zero_iff {x : K[X]} : algebraMap K[X] (RatFunc K) x = 0 ↔ x = 0 
Arguments: (K : Type u) [CommRing K] [IsDomain K] {x : K[X]}
Goal: (algebraMap K[X] (RatFunc K)) x = 0 ↔ x = 0
-- RatFunc.algebraMap_ne_zero
theorem algebraMap_ne_zero {x : K[X]} (hx : x ≠ 0) : algebraMap K[X] (RatFunc K) x ≠ 0 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {x : K[X]} (hx : x ≠ 0)
Goal: (algebraMap K[X] (RatFunc K)) x ≠ 0
-- RatFunc.coe_mapAlgHom_eq_coe_map
theorem coe_mapAlgHom_eq_coe_map (φ : K[X] →ₐ[S] R[X]) (hφ : K[X]⁰ ≤ R[X]⁰.comap φ) :
    (mapAlgHom φ hφ : RatFunc K → RatFunc R) = map φ hφ 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {R : Type u_2} {S : Type u_3} [CommRing R] [IsDomain R] [CommSemiring S] [Algebra S K[X]] [Algebra S R[X]] (φ : K[X] →ₐ[S] R[X]) (hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰)
Goal: ⇑(RatFunc.mapAlgHom φ hφ) = ⇑(RatFunc.map φ hφ)
-- RatFunc.liftAlgHom_apply_ofFractionRing_mk
theorem liftAlgHom_apply_ofFractionRing_mk (n : K[X]) (d : K[X]⁰) :
    liftAlgHom φ hφ (ofFractionRing (Localization.mk n d)) = φ n / φ d 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {L : Type u_1} {S : Type u_3} [Field L] [CommSemiring S] [Algebra S K[X]] [Algebra S L] (φ : K[X] →ₐ[S] L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (n : K[X]) (d : ↥K[X]⁰)
Goal: (RatFunc.liftAlgHom φ hφ) { toFractionRing := Localization.mk n d } = φ n / φ ↑d
-- RatFunc.liftAlgHom_injective
theorem liftAlgHom_injective (φ : K[X] →ₐ[S] L) (hφ : Function.Injective φ)
    (hφ' : K[X]⁰ ≤ L⁰.comap φ := nonZeroDivisors_le_comap_nonZeroDivisors_of_injective _ hφ) :
    Function.Injective (liftAlgHom φ hφ') 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {L : Type u_1} {S : Type u_3} [Field L] [CommSemiring S] [Algebra S K[X]] [Algebra S L] (φ : K[X] →ₐ[S] L) (hφ : Function.Injective ⇑φ) (hφ' : K[X]⁰ ≤ Submonoid.comap φ L⁰ := ⋯)
Goal: Function.Injective ⇑(RatFunc.liftAlgHom φ hφ')
-- RatFunc.liftAlgHom_apply_div'
@[simp]
theorem liftAlgHom_apply_div' (p q : K[X]) :
    liftAlgHom φ hφ (algebraMap _ _ p) / liftAlgHom φ hφ (algebraMap _ _ q) = φ p / φ q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {L : Type u_1} {S : Type u_3} [Field L] [CommSemiring S] [Algebra S K[X]] [Algebra S L] (φ : K[X] →ₐ[S] L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (p q : K[X])
Goal: (RatFunc.liftAlgHom φ hφ) ((algebraMap K[X] (RatFunc K)) p) /
    (RatFunc.liftAlgHom φ hφ) ((algebraMap K[X] (RatFunc K)) q) =
  φ p / φ q
-- RatFunc.liftAlgHom_apply_div
theorem liftAlgHom_apply_div (p q : K[X]) :
    liftAlgHom φ hφ (algebraMap _ _ p / algebraMap _ _ q) = φ p / φ q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {L : Type u_1} {S : Type u_3} [Field L] [CommSemiring S] [Algebra S K[X]] [Algebra S L] (φ : K[X] →ₐ[S] L) (hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰) (p q : K[X])
Goal: (RatFunc.liftAlgHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q
-- RatFunc.liftOn_div
@[simp]
theorem liftOn_div {P : Sort v} (p q : K[X]) (f : K[X] → K[X] → P) (f0 : ∀ p, f p 0 = f 0 1)
    (H' : ∀ {p q p' q'} (_hq : q ≠ 0) (_hq' : q' ≠ 0), q' * p = q * p' → f p q = f p' q')
    (H : ∀ {p q p' q'} (_hq : q ∈ K[X]⁰) (_hq' : q' ∈ K[X]⁰), q' * p = q * p' → f p q = f p' q' :=
      fun {p q p' q'} hq hq' h => H' (nonZeroDivisors.ne_zero hq) (nonZeroDivisors.ne_zero hq') h) :
    (RatFunc.liftOn (algebraMap _ (RatFunc K) p / algebraMap _ _ q)) f @H = f p q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {P : Sort v} (p q : K[X]) (f : K[X] → K[X] → P) (f0 : ∀ (p : K[X]), f p 0 = f 0 1) (H' : ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q') (H : ∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q' := ⋯)
Goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).liftOn f H = f p q
-- RatFunc.liftOn'_div
@[simp]
theorem liftOn'_div {P : Sort v} (p q : K[X]) (f : K[X] → K[X] → P) (f0 : ∀ p, f p 0 = f 0 1)
    (H) :
    (RatFunc.liftOn' (algebraMap _ (RatFunc K) p / algebraMap _ _ q)) f @H = f p q 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {P : Sort v} (p q : K[X]) (f : K[X] → K[X] → P) (f0 : ∀ (p : K[X]), f p 0 = f 0 1) (H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q)
Goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).liftOn' f H = f p q
-- RatFunc.induction_on
protected theorem induction_on {P : RatFunc K → Prop} (x : RatFunc K)
    (f : ∀ (p q : K[X]) (hq : q ≠ 0), P (algebraMap _ (RatFunc K) p / algebraMap _ _ q)) : P x 
Arguments: {K : Type u} [CommRing K] [IsDomain K] {P : RatFunc K → Prop} (x : RatFunc K) (f : ∀ (p q : K[X]), q ≠ 0 → P ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q))
Goal: P x
-- RatFunc.ofFractionRing_mk'
theorem ofFractionRing_mk' (x : K[X]) (y : K[X]⁰) :
    -- Porting note: I gave explicitly the argument `(FractionRing K[X])`
    ofFractionRing (IsLocalization.mk' (FractionRing K[X]) x y) =
      IsLocalization.mk' (RatFunc K) x y 
Arguments: {K : Type u} [CommRing K] [IsDomain K] (x : K[X]) (y : ↥K[X]⁰)
Goal: { toFractionRing := IsLocalization.mk' (FractionRing K[X]) x y } = IsLocalization.mk' (RatFunc K) x y
-- RatFunc.mk_eq_mk'
theorem mk_eq_mk' (f : Polynomial K) {g : Polynomial K} (hg : g ≠ 0) :
    RatFunc.mk f g = IsLocalization.mk' (RatFunc K) f ⟨g, mem_nonZeroDivisors_iff_ne_zero.2 hg⟩ 
Arguments: {K : Type u} [CommRing K] [IsDomain K] (f : K[X]) {g : K[X]} (hg : g ≠ 0)
Goal: RatFunc.mk f g = IsLocalization.mk' (RatFunc K) f ⟨g, ⋯⟩
-- RatFunc.ofFractionRing_eq
@[simp]
theorem ofFractionRing_eq :
    (ofFractionRing : FractionRing K[X] → RatFunc K) = IsLocalization.algEquiv K[X]⁰ _ _ 
Arguments: {K : Type u} [CommRing K] [IsDomain K]
Goal: RatFunc.ofFractionRing = ⇑(IsLocalization.algEquiv K[X]⁰ (FractionRing K[X]) (RatFunc K))
-- RatFunc.toFractionRing_eq
@[simp]
theorem toFractionRing_eq :
    (toFractionRing : RatFunc K → FractionRing K[X]) = IsLocalization.algEquiv K[X]⁰ _ _ 
Arguments: {K : Type u} [CommRing K] [IsDomain K]
Goal: RatFunc.toFractionRing = ⇑(IsLocalization.algEquiv K[X]⁰ (RatFunc K) (FractionRing K[X]))
-- RatFunc.toFractionRingRingEquiv_symm_eq
@[simp]
theorem toFractionRingRingEquiv_symm_eq :
    (toFractionRingRingEquiv K).symm = (IsLocalization.algEquiv K[X]⁰ _ _).toRingEquiv 
Arguments: {K : Type u} [CommRing K] [IsDomain K]
Goal: (RatFunc.toFractionRingRingEquiv K).symm = (IsLocalization.algEquiv K[X]⁰ (FractionRing K[X]) (RatFunc K)).toRingEquiv
-- RatFunc.numDenom_div
@[simp]
theorem numDenom_div (p : K[X]) {q : K[X]} (hq : q ≠ 0) :
    numDenom (algebraMap _ _ p / algebraMap _ _ q) =
      (Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q),
        Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (q / gcd p q)) 
Arguments: {K : Type u} [Field K] (p : K[X]) {q : K[X]} (hq : q ≠ 0)
Goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).numDenom =
  (Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q), Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (q / gcd p q))
-- _private.Mathlib.FieldTheory.RatFunc.Basic.0.RatFunc.num_div'
private theorem num_div' (p : K[X]) {q : K[X]} (hq : q ≠ 0) :
    num (algebraMap _ _ p / algebraMap _ _ q) =
      Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q) 
Arguments: {K : Type u} [Field K] (p : K[X]) {q : K[X]} (hq : q ≠ 0)
Goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).num =
  Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q)
-- RatFunc.num_zero
@[simp]
theorem num_zero : num (0 : RatFunc K) = 0 
Arguments: {K : Type u} [Field K]
Goal: RatFunc.num 0 = 0
-- RatFunc.num_div
@[simp]
theorem num_div (p q : K[X]) :
    num (algebraMap _ _ p / algebraMap _ _ q) =
      Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q) 
Arguments: {K : Type u} [Field K] (p q : K[X])
Goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).num =
  Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q)
-- RatFunc.num_one
@[simp]
theorem num_one : num (1 : RatFunc K) = 1 
Arguments: {K : Type u} [Field K]
Goal: RatFunc.num 1 = 1
-- RatFunc.num_algebraMap
@[simp]
theorem num_algebraMap (p : K[X]) : num (algebraMap _ _ p) = p 
Arguments: {K : Type u} [Field K] (p : K[X])
Goal: ((algebraMap K[X] (RatFunc K)) p).num = p
-- RatFunc.num_div_dvd
theorem num_div_dvd (p : K[X]) {q : K[X]} (hq : q ≠ 0) :
    num (algebraMap _ _ p / algebraMap _ _ q) ∣ p 
Arguments: {K : Type u} [Field K] (p : K[X]) {q : K[X]} (hq : q ≠ 0)
Goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).num ∣ p
-- RatFunc.num_div_dvd'
@[simp]
theorem num_div_dvd' (p : K[X]) {q : K[X]} (hq : q ≠ 0) :
    C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q) ∣ p 
Arguments: {K : Type u} [Field K] (p : K[X]) {q : K[X]} (hq : q ≠ 0)
Goal: Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q) ∣ p
-- RatFunc.denom_div
@[simp]
theorem denom_div (p : K[X]) {q : K[X]} (hq : q ≠ 0) :
    denom (algebraMap _ _ p / algebraMap _ _ q) =
      Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (q / gcd p q) 
Arguments: {K : Type u} [Field K] (p : K[X]) {q : K[X]} (hq : q ≠ 0)
Goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).denom =
  Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (q / gcd p q)
-- RatFunc.monic_denom
theorem monic_denom (x : RatFunc K) : (denom x).Monic 
Arguments: {K : Type u} [Field K] (x : RatFunc K)
Goal: x.denom.Monic
-- RatFunc.denom_ne_zero
theorem denom_ne_zero (x : RatFunc K) : denom x ≠ 0 
Arguments: {K : Type u} [Field K] (x : RatFunc K)
Goal: x.denom ≠ 0
-- RatFunc.denom_zero
@[simp]
theorem denom_zero : denom (0 : RatFunc K) = 1 
Arguments: {K : Type u} [Field K]
Goal: RatFunc.denom 0 = 1
-- RatFunc.denom_one
@[simp]
theorem denom_one : denom (1 : RatFunc K) = 1 
Arguments: {K : Type u} [Field K]
Goal: RatFunc.denom 1 = 1
-- RatFunc.denom_algebraMap
@[simp]
theorem denom_algebraMap (p : K[X]) : denom (algebraMap _ (RatFunc K) p) = 1 
Arguments: {K : Type u} [Field K] (p : K[X])
Goal: ((algebraMap K[X] (RatFunc K)) p).denom = 1