         (self.lowerDegree, self.coeffs) = normalized(lowerDegree, coeffs)
     }
     
-    public init(_ coeffs: K...) {
+    public init(_ coeffs: R...) {
         self.init(lowerDegree: 0, coeffs: coeffs)
     }
     
-    public init(lowerDegree: Int, upperDegree: Int, gen: ((Int) -> K)) {
+    public init(lowerDegree: Int, upperDegree: Int, gen: ((Int) -> R)) {
         let coeffs = (lowerDegree ... upperDegree).map(gen)
         self.init(lowerDegree: lowerDegree, coeffs: coeffs)
     }
     
-    public var normalizeUnit: LaurentPolynomial<K> {
-        return LaurentPolynomial(leadCoeff.inverse!)
+    public var normalizeUnit: LaurentPolynomial<R> {
+        if let a = leadCoeff.inverse {
+            return LaurentPolynomial(a)
+        } else {
+            return LaurentPolynomial(.identity)
+        }
     }
     
     public var upperDegree: Int {

    }
    
    public static var symbol: String {
        return "\(K.symbol)[x, x⁻¹]"
    }
    
    public var hashValue: Int {

        }
    }
    
    public static func * (r: R, f: LaurentPolynomial<R>) -> LaurentPolynomial<R> {
        return f.mapCoeffs { r * $0 }
    }
    
    public static func * (f: LaurentPolynomial<R>, r: R) -> LaurentPolynomial<R> {
        return f.mapCoeffs { $0 * r }
    }
    
