File: Mathlib/FieldTheory/RatFunc/Basic.lean

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.18
code: /-- The zero rational function. -/
protected irreducible_def zero : RatFunc K 
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.zero_def
code: /-- The zero rational function. -/
protected irreducible_def zero : RatFunc K 
goal: RatFunc.zero = { toFractionRing := 0 }

full_name: RatFunc.zero
code: /-- The zero rational function. -/
protected irreducible_def zero : RatFunc K 
goal: RatFunc K

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.18
code: /-- The zero rational function. -/
protected irreducible_def zero : RatFunc K 
goal: RatFunc K

full_name: RatFunc.instZero
code: instance : Zero (RatFunc K) 
goal: Zero (RatFunc K)

full_name: RatFunc.ofFractionRing_zero
code: theorem ofFractionRing_zero : (ofFractionRing 0 : RatFunc K) = 0 
goal: { toFractionRing := 0 } = 0

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.181
code: /-- Addition of rational functions. -/
protected irreducible_def add : RatFunc K → RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K → RatFunc K

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.181
code: /-- Addition of rational functions. -/
protected irreducible_def add : RatFunc K → RatFunc K → RatFunc K
  
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.add
code: /-- Addition of rational functions. -/
protected irreducible_def add : RatFunc K → RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K → RatFunc K

full_name: RatFunc.add_def
code: /-- Addition of rational functions. -/
protected irreducible_def add : RatFunc K → RatFunc K → RatFunc K
  
goal: ∀ (x x_1 : RatFunc K),
  x.add x_1 =
    match x, x_1 with
    | { toFractionRing := p }, { toFractionRing := q } => { toFractionRing := p + q }

full_name: RatFunc.instAdd
code: instance : Add (RatFunc K) 
goal: Add (RatFunc K)

full_name: RatFunc.ofFractionRing_add
code: theorem ofFractionRing_add (p q : FractionRing K[X]) :
    ofFractionRing (p + q) = ofFractionRing p + ofFractionRing q 
goal: { toFractionRing := p + q } = { toFractionRing := p } + { toFractionRing := q }

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.409
code: /-- Subtraction of rational functions. -/
protected irreducible_def sub : RatFunc K → RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K → RatFunc K

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.409
code: /-- Subtraction of rational functions. -/
protected irreducible_def sub : RatFunc K → RatFunc K → RatFunc K
  
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.sub_def
code: /-- Subtraction of rational functions. -/
protected irreducible_def sub : RatFunc K → RatFunc K → RatFunc K
  
goal: ∀ (x x_1 : RatFunc K),
  x.sub x_1 =
    match x, x_1 with
    | { toFractionRing := p }, { toFractionRing := q } => { toFractionRing := p - q }

full_name: RatFunc.sub
code: /-- Subtraction of rational functions. -/
protected irreducible_def sub : RatFunc K → RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K → RatFunc K

full_name: RatFunc.instSub
code: instance : Sub (RatFunc K) 
goal: Sub (RatFunc K)

full_name: RatFunc.ofFractionRing_sub
code: theorem ofFractionRing_sub (p q : FractionRing K[X]) :
    ofFractionRing (p - q) = ofFractionRing p - ofFractionRing q 
goal: { toFractionRing := p - q } = { toFractionRing := p } - { toFractionRing := q }

full_name: RatFunc.neg
code: /-- Additive inverse of a rational function. -/
protected irreducible_def neg : RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.637
code: /-- Additive inverse of a rational function. -/
protected irreducible_def neg : RatFunc K → RatFunc K
  
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.neg_def
code: /-- Additive inverse of a rational function. -/
protected irreducible_def neg : RatFunc K → RatFunc K
  
goal: ∀ (x : RatFunc K),
  x.neg =
    match x with
    | { toFractionRing := p } => { toFractionRing := -p }

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.637
code: /-- Additive inverse of a rational function. -/
protected irreducible_def neg : RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K

full_name: RatFunc.instNeg
code: instance : Neg (RatFunc K) 
goal: Neg (RatFunc K)

full_name: RatFunc.ofFractionRing_neg
code: theorem ofFractionRing_neg (p : FractionRing K[X]) :
    ofFractionRing (-p) = -ofFractionRing p 
goal: { toFractionRing := -p } = -{ toFractionRing := p }

full_name: RatFunc.one
code: /-- The multiplicative unit of rational functions. -/
protected irreducible_def one : RatFunc K 
goal: RatFunc K

full_name: RatFunc.one_def
code: /-- The multiplicative unit of rational functions. -/
protected irreducible_def one : RatFunc K 
goal: RatFunc.one = { toFractionRing := 1 }

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.834
code: /-- The multiplicative unit of rational functions. -/
protected irreducible_def one : RatFunc K 
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.834
code: /-- The multiplicative unit of rational functions. -/
protected irreducible_def one : RatFunc K 
goal: RatFunc K

full_name: RatFunc.instOne
code: instance : One (RatFunc K) 
goal: One (RatFunc K)

full_name: RatFunc.ofFractionRing_one
code: theorem ofFractionRing_one : (ofFractionRing 1 : RatFunc K) = 1 
goal: { toFractionRing := 1 } = 1

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.997
code: /-- Multiplication of rational functions. -/
protected irreducible_def mul : RatFunc K → RatFunc K → RatFunc K
  
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.mul_def
code: /-- Multiplication of rational functions. -/
protected irreducible_def mul : RatFunc K → RatFunc K → RatFunc K
  
goal: ∀ (x x_1 : RatFunc K),
  x.mul x_1 =
    match x, x_1 with
    | { toFractionRing := p }, { toFractionRing := q } => { toFractionRing := p * q }

full_name: RatFunc.mul
code: /-- Multiplication of rational functions. -/
protected irreducible_def mul : RatFunc K → RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K → RatFunc K

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.997
code: /-- Multiplication of rational functions. -/
protected irreducible_def mul : RatFunc K → RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K → RatFunc K

full_name: RatFunc.instMul
code: instance : Mul (RatFunc K) 
goal: Mul (RatFunc K)

full_name: RatFunc.ofFractionRing_mul
code: theorem ofFractionRing_mul (p q : FractionRing K[X]) :
    ofFractionRing (p * q) = ofFractionRing p * ofFractionRing q 
goal: { toFractionRing := p * q } = { toFractionRing := p } * { toFractionRing := q }

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.1235
code: /-- Division of rational functions. -/
protected irreducible_def div : RatFunc K → RatFunc K → RatFunc K
  
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.1235
code: /-- Division of rational functions. -/
protected irreducible_def div : RatFunc K → RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K → RatFunc K

full_name: RatFunc.div
code: /-- Division of rational functions. -/
protected irreducible_def div : RatFunc K → RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K → RatFunc K

full_name: RatFunc.div_def
code: /-- Division of rational functions. -/
protected irreducible_def div : RatFunc K → RatFunc K → RatFunc K
  
goal: ∀ (x x_1 : RatFunc K),
  x.div x_1 =
    match x, x_1 with
    | { toFractionRing := p }, { toFractionRing := q } => { toFractionRing := p / q }

full_name: RatFunc.instDiv
code: instance : Div (RatFunc K) 
goal: Div (RatFunc K)

full_name: RatFunc.ofFractionRing_div
code: theorem ofFractionRing_div (p q : FractionRing K[X]) :
    ofFractionRing (p / q) = ofFractionRing p / ofFractionRing q 
goal: { toFractionRing := p / q } = { toFractionRing := p } / { toFractionRing := q }

full_name: RatFunc.inv_def
code: /-- Multiplicative inverse of a rational function. -/
protected irreducible_def inv : RatFunc K → RatFunc K
  
goal: ∀ (x : RatFunc K),
  x.inv =
    match x with
    | { toFractionRing := p } => { toFractionRing := p⁻¹ }

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.1482
code: /-- Multiplicative inverse of a rational function. -/
protected irreducible_def inv : RatFunc K → RatFunc K
  
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.inv
code: /-- Multiplicative inverse of a rational function. -/
protected irreducible_def inv : RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.1482
code: /-- Multiplicative inverse of a rational function. -/
protected irreducible_def inv : RatFunc K → RatFunc K
  
goal: RatFunc K → RatFunc K

full_name: RatFunc.instInv
code: instance : Inv (RatFunc K) 
goal: Inv (RatFunc K)

full_name: RatFunc.ofFractionRing_inv
code: theorem ofFractionRing_inv (p : FractionRing K[X]) :
    ofFractionRing p⁻¹ = (ofFractionRing p)⁻¹ 
goal: { toFractionRing := p⁻¹ } = { toFractionRing := p }⁻¹

full_name: RatFunc.mul_inv_cancel
code: theorem mul_inv_cancel : ∀ {p : RatFunc K}, p ≠ 0 → p * p⁻¹ = 1
  
goal: p ≠ 0 → p * p⁻¹ = 1

full_name: RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.1838
code: /-- Scalar multiplication of rational functions. -/
protected irreducible_def smul [SMul R (FractionRing K[X])] : R → RatFunc K → RatFunc K
  
goal: Subtype (Eq @RatFunc.definition✝)

full_name: RatFunc.smul_def
code: /-- Scalar multiplication of rational functions. -/
protected irreducible_def smul [SMul R (FractionRing K[X])] : R → RatFunc K → RatFunc K
  
goal: ∀ (x : R) (x_1 : RatFunc K),
  RatFunc.smul x x_1 =
    match x, x_1 with
    | r, { toFractionRing := p } => { toFractionRing := r • p }

full_name: RatFunc.smul
code: /-- Scalar multiplication of rational functions. -/
protected irreducible_def smul [SMul R (FractionRing K[X])] : R → RatFunc K → RatFunc K
  
goal: R → RatFunc K → RatFunc K

full_name: RatFunc.definition._@.Mathlib.FieldTheory.RatFunc.Basic._hyg.1838
code: /-- Scalar multiplication of rational functions. -/
protected irreducible_def smul [SMul R (FractionRing K[X])] : R → RatFunc K → RatFunc K
  
goal: R → RatFunc K → RatFunc K

full_name: RatFunc.instSMulOfFractionRingPolynomial
code: instance [SMul R (FractionRing K[X])] : SMul R (RatFunc K) 
goal: SMul R (RatFunc K)

full_name: RatFunc.ofFractionRing_smul
code: theorem ofFractionRing_smul [SMul R (FractionRing K[X])] (c : R) (p : FractionRing K[X]) :
    ofFractionRing (c • p) = c • ofFractionRing p 
goal: { toFractionRing := c • p } = c • { toFractionRing := p }

full_name: RatFunc.toFractionRing_smul
code: theorem toFractionRing_smul [SMul R (FractionRing K[X])] (c : R) (p : RatFunc K) :
    toFractionRing (c • p) = c • toFractionRing p 
goal: (c • p).toFractionRing = c • p.toFractionRing

full_name: RatFunc.smul_eq_C_smul
code: theorem smul_eq_C_smul (x : RatFunc K) (r : K) : r • x = Polynomial.C r • x 
goal: r • x = Polynomial.C r • x

full_name: RatFunc.mk_smul
code: theorem mk_smul (c : R) (p q : K[X]) : RatFunc.mk (c • p) q = c • RatFunc.mk p q 
goal: RatFunc.mk (c • p) q = c • RatFunc.mk p q

full_name: RatFunc.instIsScalarTowerPolynomial
code: instance : IsScalarTower R K[X] (RatFunc K) 
goal: IsScalarTower R K[X] (RatFunc K)

full_name: RatFunc.instSubsingleton
code: instance [Subsingleton K] : Subsingleton (RatFunc K) 
goal: Subsingleton (RatFunc K)

full_name: RatFunc.instInhabited
code: instance : Inhabited (RatFunc K) 
goal: Inhabited (RatFunc K)

full_name: RatFunc.instNontrivial
code: instance instNontrivial [Nontrivial K] : Nontrivial (RatFunc K) 
goal: Nontrivial (RatFunc K)

full_name: RatFunc.toFractionRingRingEquiv
code: /-- `RatFunc K` is isomorphic to the field of fractions of `K[X]`, as rings.

This is an auxiliary definition; `simp`-normal form is `IsLocalization.algEquiv`.
-/
@[simps apply]
def toFractionRingRingEquiv : RatFunc K ≃+* FractionRing K[X] 
goal: RatFunc K ≃+* FractionRing K[X]

full_name: RatFunc.toFractionRingRingEquiv_apply
code: /-- `RatFunc K` is isomorphic to the field of fractions of `K[X]`, as rings.

This is an auxiliary definition; `simp`-normal form is `IsLocalization.algEquiv`.
-/
@[simps apply]
def toFractionRingRingEquiv : RatFunc K ≃+* FractionRing K[X] 
goal: (RatFunc.toFractionRingRingEquiv K) self = self.toFractionRing

full_name: RatFunc._aux_Mathlib_FieldTheory_RatFunc_Basic___macroRules_RatFunc_tacticFrac_tac_1
code: macro "frac_tac" : tactic => `(tactic| repeat (rintro (⟨⟩ : RatFunc _)) <;>
  try simp only [← ofFractionRing_zero, ← ofFractionRing_add, ← ofFractionRing_sub,
    ← ofFractionRing_neg, ← ofFractionRing_one, ← ofFractionRing_mul, ← ofFractionRing_div,
    ← ofFractionRing_inv,
    add_assoc, zero_add, add_zero, mul_assoc, mul_zero, mul_one, mul_add, inv_zero,
    add_comm, add_left_comm, mul_comm, mul_left_comm, sub_eq_add_neg, div_eq_mul_inv,
    add_mul, zero_mul, one_mul, neg_mul, mul_neg, add_right_neg])
goal: Lean.Macro

full_name: RatFunc.tacticFrac_tac
code: macro "frac_tac" : tactic => `(tactic| repeat (rintro (⟨⟩ : RatFunc _)) <;>
  try simp only [← ofFractionRing_zero, ← ofFractionRing_add, ← ofFractionRing_sub,
    ← ofFractionRing_neg, ← ofFractionRing_one, ← ofFractionRing_mul, ← ofFractionRing_div,
    ← ofFractionRing_inv,
    add_assoc, zero_add, add_zero, mul_assoc, mul_zero, mul_one, mul_add, inv_zero,
    add_comm, add_left_comm, mul_comm, mul_left_comm, sub_eq_add_neg, div_eq_mul_inv,
    add_mul, zero_mul, one_mul, neg_mul, mul_neg, add_right_neg])
goal: Lean.ParserDescr

full_name: RatFunc._aux_Mathlib_FieldTheory_RatFunc_Basic___macroRules_RatFunc_tacticSmul_tac_1
code: macro "smul_tac" : tactic => `(tactic|
    repeat
      (first
        | rintro (⟨⟩ : RatFunc _)
        | intro) <;>
    simp_rw [← ofFractionRing_smul] <;>
    simp only [add_comm, mul_comm, zero_smul, succ_nsmul, zsmul_eq_mul, mul_add, mul_one, mul_zero,
      neg_add, mul_neg,
      Int.ofNat_eq_coe, Int.cast_zero, Int.cast_add, Int.cast_one,
      Int.cast_negSucc, Int.cast_natCast, Nat.cast_succ,
      Localization.mk_zero, Localization.add_mk_self, Localization.neg_mk,
      ofFractionRing_zero, ← ofFractionRing_add, ← ofFractionRing_neg])
goal: Lean.Macro

full_name: RatFunc.tacticSmul_tac
code: macro "smul_tac" : tactic => `(tactic|
    repeat
      (first
        | rintro (⟨⟩ : RatFunc _)
        | intro) <;>
    simp_rw [← ofFractionRing_smul] <;>
    simp only [add_comm, mul_comm, zero_smul, succ_nsmul, zsmul_eq_mul, mul_add, mul_one, mul_zero,
      neg_add, mul_neg,
      Int.ofNat_eq_coe, Int.cast_zero, Int.cast_add, Int.cast_one,
      Int.cast_negSucc, Int.cast_natCast, Nat.cast_succ,
      Localization.mk_zero, Localization.add_mk_self, Localization.neg_mk,
      ofFractionRing_zero, ← ofFractionRing_add, ← ofFractionRing_neg])
goal: Lean.ParserDescr

full_name: RatFunc.instCommMonoid
code: /-- `RatFunc K` is a commutative monoid.

This is an intermediate step on the way to the full instance `RatFunc.instCommRing`.
-/
def instCommMonoid : CommMonoid (RatFunc K) 
goal: CommMonoid (RatFunc K)

full_name: RatFunc.instAddCommGroup
code: /-- `RatFunc K` is an additive commutative group.

This is an intermediate step on the way to the full instance `RatFunc.instCommRing`.
-/
def instAddCommGroup : AddCommGroup (RatFunc K) 
goal: AddCommGroup (RatFunc K)

full_name: RatFunc.instCommRing
code: instance instCommRing : CommRing (RatFunc K) 
goal: CommRing (RatFunc K)

full_name: RatFunc.map
code: /-- Lift a monoid homomorphism that maps polynomials `φ : R[X] →* S[X]`
to a `RatFunc R →* RatFunc S`,
on the condition that `φ` maps non zero divisors to non zero divisors,
by mapping both the numerator and denominator and quotienting them. -/

def map [MonoidHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ S[X]⁰.comap φ) :
    RatFunc R →* RatFunc S 
goal: RatFunc R →* RatFunc S

full_name: RatFunc.map_apply_ofFractionRing_mk
code: 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⟩) 
goal: (RatFunc.map φ hφ) { toFractionRing := Localization.mk n d } = { toFractionRing := Localization.mk (φ n) ⟨φ ↑d, ⋯⟩ }

full_name: RatFunc.map_injective
code: theorem map_injective [MonoidHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ S[X]⁰.comap φ)
    (hf : Function.Injective φ) : Function.Injective (map φ hφ) 
goal: Function.Injective ⇑(RatFunc.map φ hφ)

full_name: RatFunc.mapRingHom
code: /-- Lift a ring homomorphism that maps polynomials `φ : R[X] →+* S[X]`
to a `RatFunc R →+* RatFunc S`,
on the condition that `φ` maps non zero divisors to non zero divisors,
by mapping both the numerator and denominator and quotienting them. -/
def mapRingHom [RingHomClass F R[X] S[X]] (φ : F) (hφ : R[X]⁰ ≤ S[X]⁰.comap φ) :
    RatFunc R →+* RatFunc S 
goal: RatFunc R →+* RatFunc S

full_name: RatFunc.coe_mapRingHom_eq_coe_map
code: 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φ 
goal: ⇑(RatFunc.mapRingHom φ hφ) = ⇑(RatFunc.map φ hφ)

full_name: RatFunc.liftMonoidWithZeroHom
code: /-- Lift a monoid with zero homomorphism `R[X] →*₀ G₀` to a `RatFunc R →*₀ G₀`
on the condition that `φ` maps non zero divisors to non zero divisors,
by mapping both the numerator and denominator and quotienting them. -/
def liftMonoidWithZeroHom (φ : R[X] →*₀ G₀) (hφ : R[X]⁰ ≤ G₀⁰.comap φ) : RatFunc R →*₀ G₀ 
goal: RatFunc R →*₀ G₀

full_name: RatFunc.liftMonoidWithZeroHom_apply_ofFractionRing_mk
code: 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 
goal: (RatFunc.liftMonoidWithZeroHom φ hφ) { toFractionRing := Localization.mk n d } = φ n / φ ↑d

full_name: RatFunc.liftMonoidWithZeroHom_injective
code: 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φ') 
goal: Function.Injective ⇑(RatFunc.liftMonoidWithZeroHom φ hφ')

full_name: RatFunc.liftRingHom
code: /-- Lift an injective ring homomorphism `R[X] →+* L` to a `RatFunc R →+* L`
by mapping both the numerator and denominator and quotienting them. -/
def liftRingHom (φ : R[X] →+* L) (hφ : R[X]⁰ ≤ L⁰.comap φ) : RatFunc R →+* L 
goal: RatFunc R →+* L

full_name: RatFunc.liftRingHom_apply_ofFractionRing_mk
code: 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 
goal: (RatFunc.liftRingHom φ hφ) { toFractionRing := Localization.mk n d } = φ n / φ ↑d

full_name: RatFunc.liftRingHom_injective
code: 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φ') 
goal: Function.Injective ⇑(RatFunc.liftRingHom φ hφ')

full_name: RatFunc.instField
code: instance instField [IsDomain K] : Field (RatFunc K) 
goal: Field (RatFunc K)

full_name: RatFunc.instAlgebraOfPolynomial
code: instance (R : Type*) [CommSemiring R] [Algebra R K[X]] : Algebra R (RatFunc K) 
goal: Algebra R (RatFunc K)

full_name: RatFunc.coePolynomial
code: /-- The coercion from polynomials to rational functions, implemented as the algebra map from a
domain to its field of fractions -/
@[coe]
def coePolynomial (P : Polynomial K) : RatFunc K 
goal: RatFunc K

full_name: RatFunc.instCoePolynomial
code: instance : Coe (Polynomial K) (RatFunc K) 
goal: Coe K[X] (RatFunc K)

full_name: RatFunc.mk_one
code: theorem mk_one (x : K[X]) : RatFunc.mk x 1 = algebraMap _ _ x 
goal: RatFunc.mk x 1 = (algebraMap K[X] (RatFunc K)) x

full_name: RatFunc.ofFractionRing_algebraMap
code: theorem ofFractionRing_algebraMap (x : K[X]) :
    ofFractionRing (algebraMap _ (FractionRing K[X]) x) = algebraMap _ _ x 
goal: { toFractionRing := (algebraMap K[X] (FractionRing K[X])) x } = (algebraMap K[X] (RatFunc K)) x

full_name: RatFunc.mk_eq_div
code: @[simp]
theorem mk_eq_div (p q : K[X]) : RatFunc.mk p q = algebraMap _ _ p / algebraMap _ _ q 
goal: RatFunc.mk p q = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q

full_name: RatFunc.div_smul
code: @[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) 
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)

full_name: RatFunc.algebraMap_apply
code: 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 
goal: (algebraMap R (RatFunc K)) x = (algebraMap K[X] (RatFunc K)) ((algebraMap R K[X]) x) / (algebraMap K[X] (RatFunc K)) 1

full_name: RatFunc.map_apply_div_ne_zero
code: 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) 
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)

full_name: RatFunc.map_apply_div
code: @[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) 
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)

full_name: RatFunc.liftMonoidWithZeroHom_apply_div
code: 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 
goal: (RatFunc.liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q

full_name: RatFunc.liftMonoidWithZeroHom_apply_div'
code: @[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 
goal: (RatFunc.liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p) /
    (RatFunc.liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) q) =
  φ p / φ q

full_name: RatFunc.liftRingHom_apply_div
code: 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 
goal: (RatFunc.liftRingHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q

full_name: RatFunc.liftRingHom_apply_div'
code: @[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 
goal: (RatFunc.liftRingHom φ hφ) ((algebraMap K[X] (RatFunc K)) p) /
    (RatFunc.liftRingHom φ hφ) ((algebraMap K[X] (RatFunc K)) q) =
  φ p / φ q

full_name: RatFunc.ofFractionRing_comp_algebraMap
code: theorem ofFractionRing_comp_algebraMap :
    ofFractionRing ∘ algebraMap K[X] (FractionRing K[X]) = algebraMap _ _ 
goal: RatFunc.ofFractionRing ∘ ⇑(algebraMap K[X] (FractionRing K[X])) = ⇑(algebraMap K[X] (RatFunc K))

full_name: RatFunc.algebraMap_injective
code: theorem algebraMap_injective : Function.Injective (algebraMap K[X] (RatFunc K)) 
goal: Function.Injective ⇑(algebraMap K[X] (RatFunc K))

full_name: RatFunc.algebraMap_eq_zero_iff
code: @[simp]
theorem algebraMap_eq_zero_iff {x : K[X]} : algebraMap K[X] (RatFunc K) x = 0 ↔ x = 0 
goal: (algebraMap K[X] (RatFunc K)) x = 0 ↔ x = 0

full_name: RatFunc.algebraMap_ne_zero
code: theorem algebraMap_ne_zero {x : K[X]} (hx : x ≠ 0) : algebraMap K[X] (RatFunc K) x ≠ 0 
goal: (algebraMap K[X] (RatFunc K)) x ≠ 0

full_name: RatFunc.mapAlgHom
code: /-- Lift an algebra homomorphism that maps polynomials `φ : K[X] →ₐ[S] R[X]`
to a `RatFunc K →ₐ[S] RatFunc R`,
on the condition that `φ` maps non zero divisors to non zero divisors,
by mapping both the numerator and denominator and quotienting them. -/
def mapAlgHom (φ : K[X] →ₐ[S] R[X]) (hφ : K[X]⁰ ≤ R[X]⁰.comap φ) : RatFunc K →ₐ[S] RatFunc R 
goal: RatFunc K →ₐ[S] RatFunc R

full_name: RatFunc.coe_mapAlgHom_eq_coe_map
code: 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φ 
goal: ⇑(RatFunc.mapAlgHom φ hφ) = ⇑(RatFunc.map φ hφ)

full_name: RatFunc.liftAlgHom
code: /-- Lift an injective algebra homomorphism `K[X] →ₐ[S] L` to a `RatFunc K →ₐ[S] L`
by mapping both the numerator and denominator and quotienting them. -/
def liftAlgHom : RatFunc K →ₐ[S] L 
goal: RatFunc K →ₐ[S] L

full_name: RatFunc.liftAlgHom_apply_ofFractionRing_mk
code: theorem liftAlgHom_apply_ofFractionRing_mk (n : K[X]) (d : K[X]⁰) :
    liftAlgHom φ hφ (ofFractionRing (Localization.mk n d)) = φ n / φ d 
goal: (RatFunc.liftAlgHom φ hφ) { toFractionRing := Localization.mk n d } = φ n / φ ↑d

full_name: RatFunc.liftAlgHom_injective
code: 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φ') 
goal: Function.Injective ⇑(RatFunc.liftAlgHom φ hφ')

full_name: RatFunc.liftAlgHom_apply_div'
code: @[simp]
theorem liftAlgHom_apply_div' (p q : K[X]) :
    liftAlgHom φ hφ (algebraMap _ _ p) / liftAlgHom φ hφ (algebraMap _ _ q) = φ p / φ q 
goal: (RatFunc.liftAlgHom φ hφ) ((algebraMap K[X] (RatFunc K)) p) /
    (RatFunc.liftAlgHom φ hφ) ((algebraMap K[X] (RatFunc K)) q) =
  φ p / φ q

full_name: RatFunc.liftAlgHom_apply_div
code: theorem liftAlgHom_apply_div (p q : K[X]) :
    liftAlgHom φ hφ (algebraMap _ _ p / algebraMap _ _ q) = φ p / φ q 
goal: (RatFunc.liftAlgHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q

full_name: RatFunc.instIsFractionRingPolynomial
code: /-- `RatFunc K` is the field of fractions of the polynomials over `K`. -/
instance : IsFractionRing K[X] (RatFunc K) 
goal: IsFractionRing K[X] (RatFunc K)

full_name: RatFunc.liftOn_div
code: @[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 
goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).liftOn f H = f p q

full_name: RatFunc.liftOn'_div
code: @[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 
goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).liftOn' f H = f p q

full_name: RatFunc.induction_on
code: /-- Induction principle for `RatFunc K`: if `f p q : P (p / q)` for all `p q : K[X]`,
then `P` holds on all elements of `RatFunc K`.

See also `induction_on'`, which is a recursion principle defined in terms of `RatFunc.mk`.
-/
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 
goal: P x

full_name: RatFunc.ofFractionRing_mk'
code: 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 
goal: { toFractionRing := IsLocalization.mk' (FractionRing K[X]) x y } = IsLocalization.mk' (RatFunc K) x y

full_name: RatFunc.mk_eq_mk'
code: 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⟩ 
goal: RatFunc.mk f g = IsLocalization.mk' (RatFunc K) f ⟨g, ⋯⟩

full_name: RatFunc.ofFractionRing_eq
code: @[simp]
theorem ofFractionRing_eq :
    (ofFractionRing : FractionRing K[X] → RatFunc K) = IsLocalization.algEquiv K[X]⁰ _ _ 
goal: RatFunc.ofFractionRing = ⇑(IsLocalization.algEquiv K[X]⁰ (FractionRing K[X]) (RatFunc K))

full_name: RatFunc.toFractionRing_eq
code: @[simp]
theorem toFractionRing_eq :
    (toFractionRing : RatFunc K → FractionRing K[X]) = IsLocalization.algEquiv K[X]⁰ _ _ 
goal: RatFunc.toFractionRing = ⇑(IsLocalization.algEquiv K[X]⁰ (RatFunc K) (FractionRing K[X]))

full_name: RatFunc.toFractionRingRingEquiv_symm_eq
code: @[simp]
theorem toFractionRingRingEquiv_symm_eq :
    (toFractionRingRingEquiv K).symm = (IsLocalization.algEquiv K[X]⁰ _ _).toRingEquiv 
goal: (RatFunc.toFractionRingRingEquiv K).symm = (IsLocalization.algEquiv K[X]⁰ (FractionRing K[X]) (RatFunc K)).toRingEquiv

full_name: RatFunc.numDenom
code: /-- `RatFunc.numDenom` are numerator and denominator of a rational function over a field,
normalized such that the denominator is monic. -/
def numDenom (x : RatFunc K) : K[X] × K[X] 
goal: K[X] × K[X]

full_name: RatFunc.numDenom_div
code: @[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)) 
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))

full_name: RatFunc.num
code: /-- `RatFunc.num` is the numerator of a rational function,
normalized such that the denominator is monic. -/
def num (x : RatFunc K) : K[X] 
goal: K[X]

full_name: _private.Mathlib.FieldTheory.RatFunc.Basic.0.RatFunc.num_div'
code: 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) 
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)

full_name: RatFunc.num_zero
code: @[simp]
theorem num_zero : num (0 : RatFunc K) = 0 
goal: RatFunc.num 0 = 0

full_name: RatFunc.num_div
code: @[simp]
theorem num_div (p q : K[X]) :
    num (algebraMap _ _ p / algebraMap _ _ q) =
      Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q) 
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)

full_name: RatFunc.num_one
code: @[simp]
theorem num_one : num (1 : RatFunc K) = 1 
goal: RatFunc.num 1 = 1

full_name: RatFunc.num_algebraMap
code: @[simp]
theorem num_algebraMap (p : K[X]) : num (algebraMap _ _ p) = p 
goal: ((algebraMap K[X] (RatFunc K)) p).num = p

full_name: RatFunc.num_div_dvd
code: theorem num_div_dvd (p : K[X]) {q : K[X]} (hq : q ≠ 0) :
    num (algebraMap _ _ p / algebraMap _ _ q) ∣ p 
goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).num ∣ p

full_name: RatFunc.num_div_dvd'
code: /-- A version of `num_div_dvd` with the LHS in simp normal form -/
@[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 
goal: Polynomial.C (q / gcd p q).leadingCoeff⁻¹ * (p / gcd p q) ∣ p

full_name: RatFunc.denom
code: /-- `RatFunc.denom` is the denominator of a rational function,
normalized such that it is monic. -/
def denom (x : RatFunc K) : K[X] 
goal: K[X]

full_name: RatFunc.denom_div
code: @[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) 
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)

full_name: RatFunc.monic_denom
code: theorem monic_denom (x : RatFunc K) : (denom x).Monic 
goal: x.denom.Monic

full_name: RatFunc.denom_ne_zero
code: theorem denom_ne_zero (x : RatFunc K) : denom x ≠ 0 
goal: x.denom ≠ 0

full_name: RatFunc.denom_zero
code: @[simp]
theorem denom_zero : denom (0 : RatFunc K) = 1 
goal: RatFunc.denom 0 = 1

full_name: RatFunc.denom_one
code: @[simp]
theorem denom_one : denom (1 : RatFunc K) = 1 
goal: RatFunc.denom 1 = 1

full_name: RatFunc.denom_algebraMap
code: @[simp]
theorem denom_algebraMap (p : K[X]) : denom (algebraMap _ (RatFunc K) p) = 1 
goal: ((algebraMap K[X] (RatFunc K)) p).denom = 1

full_name: RatFunc.denom_div_dvd
code: @[simp]
theorem denom_div_dvd (p q : K[X]) : denom (algebraMap _ _ p / algebraMap _ _ q) ∣ q 
goal: ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).denom ∣ q

full_name: RatFunc.num_div_denom
code: @[simp]
theorem num_div_denom (x : RatFunc K) : algebraMap _ _ (num x) / algebraMap _ _ (denom x) = x 
goal: (algebraMap K[X] (RatFunc K)) x.num / (algebraMap K[X] (RatFunc K)) x.denom = x

full_name: RatFunc.isCoprime_num_denom
code: theorem isCoprime_num_denom (x : RatFunc K) : IsCoprime x.num x.denom 
goal: IsCoprime x.num x.denom

full_name: RatFunc.num_eq_zero_iff
code: @[simp]
theorem num_eq_zero_iff {x : RatFunc K} : num x = 0 ↔ x = 0 
goal: x.num = 0 ↔ x = 0

full_name: RatFunc.num_ne_zero
code: theorem num_ne_zero {x : RatFunc K} (hx : x ≠ 0) : num x ≠ 0 
goal: x.num ≠ 0

full_name: RatFunc.num_mul_eq_mul_denom_iff
code: theorem num_mul_eq_mul_denom_iff {x : RatFunc K} {p q : K[X]} (hq : q ≠ 0) :
    x.num * q = p * x.denom ↔ x = algebraMap _ _ p / algebraMap _ _ q 
goal: x.num * q = p * x.denom ↔ x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q

full_name: RatFunc.num_denom_add
code: theorem num_denom_add (x y : RatFunc K) :
    (x + y).num * (x.denom * y.denom) = (x.num * y.denom + x.denom * y.num) * (x + y).denom 
goal: (x + y).num * (x.denom * y.denom) = (x.num * y.denom + x.denom * y.num) * (x + y).denom

full_name: RatFunc.num_denom_neg
code: theorem num_denom_neg (x : RatFunc K) : (-x).num * x.denom = -x.num * (-x).denom 
goal: (-x).num * x.denom = -x.num * (-x).denom

full_name: RatFunc.num_denom_mul
code: theorem num_denom_mul (x y : RatFunc K) :
    (x * y).num * (x.denom * y.denom) = x.num * y.num * (x * y).denom 
goal: (x * y).num * (x.denom * y.denom) = x.num * y.num * (x * y).denom

full_name: RatFunc.num_dvd
code: theorem num_dvd {x : RatFunc K} {p : K[X]} (hp : p ≠ 0) :
    num x ∣ p ↔ ∃ q : K[X], q ≠ 0 ∧ x = algebraMap _ _ p / algebraMap _ _ q 
goal: x.num ∣ p ↔ ∃ q, q ≠ 0 ∧ x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q

full_name: RatFunc.denom_dvd
code: theorem denom_dvd {x : RatFunc K} {q : K[X]} (hq : q ≠ 0) :
    denom x ∣ q ↔ ∃ p : K[X], x = algebraMap _ _ p / algebraMap _ _ q 
goal: x.denom ∣ q ↔ ∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q

full_name: RatFunc.num_mul_dvd
code: theorem num_mul_dvd (x y : RatFunc K) : num (x * y) ∣ num x * num y 
goal: (x * y).num ∣ x.num * y.num

full_name: RatFunc.denom_mul_dvd
code: theorem denom_mul_dvd (x y : RatFunc K) : denom (x * y) ∣ denom x * denom y 
goal: (x * y).denom ∣ x.denom * y.denom

full_name: RatFunc.denom_add_dvd
code: theorem denom_add_dvd (x y : RatFunc K) : denom (x + y) ∣ denom x * denom y 
goal: (x + y).denom ∣ x.denom * y.denom

full_name: RatFunc.map_denom_ne_zero
code: theorem map_denom_ne_zero {L F : Type*} [Zero L] [FunLike F K[X] L] [ZeroHomClass F K[X] L]
    (φ : F) (hφ : Function.Injective φ) (f : RatFunc K) : φ f.denom ≠ 0 
goal: φ f.denom ≠ 0

full_name: RatFunc.map_apply
code: theorem map_apply {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 φ) (f : RatFunc K) :
    map φ hφ f = algebraMap _ _ (φ f.num) / algebraMap _ _ (φ f.denom) 
goal: (RatFunc.map φ hφ) f = (algebraMap R[X] (RatFunc R)) (φ f.num) / (algebraMap R[X] (RatFunc R)) (φ f.denom)

full_name: RatFunc.liftMonoidWithZeroHom_apply
code: theorem liftMonoidWithZeroHom_apply {L : Type*} [CommGroupWithZero L] (φ : K[X] →*₀ L)
    (hφ : K[X]⁰ ≤ L⁰.comap φ) (f : RatFunc K) :
    liftMonoidWithZeroHom φ hφ f = φ f.num / φ f.denom 
goal: (RatFunc.liftMonoidWithZeroHom φ hφ) f = φ f.num / φ f.denom

full_name: RatFunc.liftRingHom_apply
code: theorem liftRingHom_apply {L : Type*} [Field L] (φ : K[X] →+* L) (hφ : K[X]⁰ ≤ L⁰.comap φ)
    (f : RatFunc K) : liftRingHom φ hφ f = φ f.num / φ f.denom 
goal: (RatFunc.liftRingHom φ hφ) f = φ f.num / φ f.denom

full_name: RatFunc.liftAlgHom_apply
code: theorem liftAlgHom_apply {L S : Type*} [Field L] [CommSemiring S] [Algebra S K[X]] [Algebra S L]
    (φ : K[X] →ₐ[S] L) (hφ : K[X]⁰ ≤ L⁰.comap φ) (f : RatFunc K) :
    liftAlgHom φ hφ f = φ f.num / φ f.denom 
goal: (RatFunc.liftAlgHom φ hφ) f = φ f.num / φ f.denom

full_name: RatFunc.num_mul_denom_add_denom_mul_num_ne_zero
code: theorem num_mul_denom_add_denom_mul_num_ne_zero {x y : RatFunc K} (hxy : x + y ≠ 0) :
    x.num * y.denom + x.denom * y.num ≠ 0 
goal: x.num * y.denom + x.denom * y.num ≠ 0