Skip to content

分数体

module field-of-fractions where

open import apartness-relation
open import bottom-type
open import equivalence-relation
open import integral-domain
open import sigma-type
open import sum-type renaming (_+_ to _∐_)
module Construction (S : ApartedSet) (R : IntDomStr S) where
  open ApartedSet S
  open IntDomStr R
  open import commutative-monoid-properties (S , Mul-commutative-monoid-str)
  open SetoidReasoning setoid

  record Fraction : Set where
    field
      num   : X
      denom : X

      denom#0 : denom # zero

  open Fraction

  instance
    EquivFraction : Equiv Fraction
    EquivFraction = record
      { _≈_ = _eq_
      ; refl-≈ = λ x → refl-≈ (x .num · x .denom)
      ; sym-≈ = sym-≈
      ; trans-≈ = λ { {x = x} {y} {z} e1 e2 → t {x = x} {y = y} {z = z} e1 e2 }
      }
      where
        _eq_ : Fraction → Fraction → Set
        _eq_ x y = x .num · y .denom ≈ y .num · x .denom

        t : ∀ {x y z} → x eq y → y eq z → x eq z
        t {x = x} {y} {z} e1 e2 = cancel-·ᵣ (y .denom#0) .fst
          (
            (x .num · z .denom · y .denom)
              ≈⟨ swap-right ⟩
            (x .num · y .denom · z .denom)
              ≈⟨ Mul.·-pres-∼ₗ (z .denom) .fst e1 ⟩
            (y .num · x .denom · z .denom)
              ≈⟨ swap-right ⟩
            (y .num · z .denom · x .denom)
              ≈⟨ Mul.·-pres-∼ₗ (x .denom) .fst e2 ⟩
            (z .num · y .denom · x .denom)
              ≈⟨ swap-right ⟩
            (z .num · x .denom · y .denom)
          ∎)

  _#F_ : Fraction → Fraction → Set
  x #F y = x .num · y .denom # y .num · x .denom

  irrefl-#F : ∀ {x} → x #F x → ⊥
  irrefl-#F = irrefl-#

  sym-#F : ∀ {x y} → x #F y → y #F x
  sym-#F = sym-#

  comparison-#F : ∀ {x y z} → x #F z → (x #F y) ∐ (y #F z)
  comparison-#F {x = x} {y} {z} x#z = p
    where
      k : (num x · denom z) · denom y # (num z · denom x) · denom y
      k = cancel-·ᵣ (denom#0 y) .snd x#z

      p : (x #F y) ∐ (y #F z)
      p with comparison-# {y = num y · denom x · denom z} k
      ... | inl a = inl (Mul.·-pres-∼ₗ (denom z) .snd ?)
      ... | inr a = inr (Mul.·-pres-∼ₗ (denom x) .snd ?)

  inject : X → Fraction
  inject x = record
    { num = x
    ; denom = one
    ; denom#0 = sym-# non-trivial
    }

  zeroF : Fraction
  zeroF = inject zero

  oneF : Fraction
  oneF = inject one

  _+F_ : Fraction → Fraction → Fraction
  x +F y = record
    { num = x.num · y.denom + y.num · x.denom
    ; denom = x.denom · y.denom
    ; denom#0 = no-non-zero-divsor x.denom x.denom#0 y.denom .snd y.denom#0
    }
    where
      module x = Fraction x
      module y = Fraction y

  -F_ : Fraction → Fraction
  -F x = record
    { num = - x.num
    ; denom = x.denom
    ; denom#0 = x.denom#0
    }
    where
      module x = Fraction x

  _·F_ : Fraction → Fraction → Fraction
  x ·F y = record
    { num = x.num · y.num
    ; denom = x.denom · y.denom
    ; denom#0 = no-non-zero-divsor x.denom x.denom#0 y.denom .snd y.denom#0
    }
    where
      module x = Fraction x
      module y = Fraction y