diff --git a/Numeric/Additive/Class.hs b/Numeric/Additive/Class.hs
--- a/Numeric/Additive/Class.hs
+++ b/Numeric/Additive/Class.hs
@@ -8,7 +8,7 @@
   , Abelian
   -- * Additive Monoids
   , Idempotent
-  , replicate1pIdempotent
+  , sinnum1pIdempotent
   -- * Partitionable semigroups
   , Partitionable(..)
   ) where
@@ -29,15 +29,15 @@
 
 -- | 
 -- > (a + b) + c = a + (b + c)
--- > replicate 1 a = a
--- > replicate (2 * n) a = replicate n a + replicate n a
--- > replicate (2 * n + 1) a = replicate n a + replicate n a + a
+-- > sinnum 1 a = a
+-- > sinnum (2 * n) a = sinnum n a + sinnum n a
+-- > sinnum (2 * n + 1) a = sinnum n a + sinnum n a + a
 class Additive r where
   (+) :: r -> r -> r
 
-  -- | replicate1p n r = replicate (1 + n) r
-  replicate1p :: Whole n => n -> r -> r
-  replicate1p y0 x0 = f x0 (1 Prelude.+ y0)
+  -- | sinnum1p n r = sinnum (1 + n) r
+  sinnum1p :: Whole n => n -> r -> r
+  sinnum1p y0 x0 = f x0 (1 Prelude.+ y0)
     where
       f x y
         | even y = f (x + x) (y `quot` 2)
@@ -58,86 +58,86 @@
 
 instance Additive r => Additive (b -> r) where
   f + g = \e -> f e + g e 
-  replicate1p n f e = replicate1p n (f e)
+  sinnum1p n f e = sinnum1p n (f e)
   sumWith1 f xs e = sumWith1 (`f` e) xs
 
 instance (HasTrie b, Additive r) => Additive (b :->: r) where
   (+) = zipWith (+)
-  replicate1p = fmap . replicate1p
+  sinnum1p = fmap . sinnum1p
   sumWith1 f xs = tabulate $ \e -> sumWith1 (\a -> index (f a) e) xs
 
 instance Additive Bool where
   (+) = (||)
-  replicate1p _ a = a
+  sinnum1p _ a = a
 
 instance Additive Natural where
   (+) = (Prelude.+)
-  replicate1p n r = (1 Prelude.+ toNatural n) * r
+  sinnum1p n r = (1 Prelude.+ toNatural n) * r
 
 instance Additive Integer where 
   (+) = (Prelude.+)
-  replicate1p n r = (1 Prelude.+ toInteger n) * r
+  sinnum1p n r = (1 Prelude.+ toInteger n) * r
 
 instance Additive Int where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Int8 where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Int16 where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Int32 where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Int64 where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Word where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Word8 where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Word16 where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Word32 where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive Word64 where
   (+) = (Prelude.+)
-  replicate1p n r = fromIntegral (1 Prelude.+ n) * r
+  sinnum1p n r = fromIntegral (1 Prelude.+ n) * r
 
 instance Additive () where
   _ + _ = ()
-  replicate1p _ _ = () 
+  sinnum1p _ _ = () 
   sumWith1 _ _ = ()
 
 instance (Additive a, Additive b) => Additive (a,b) where
   (a,b) + (i,j) = (a + i, b + j)
-  replicate1p n (a,b) = (replicate1p n a, replicate1p n b)
+  sinnum1p n (a,b) = (sinnum1p n a, sinnum1p n b)
 
 instance (Additive a, Additive b, Additive c) => Additive (a,b,c) where
   (a,b,c) + (i,j,k) = (a + i, b + j, c + k)
-  replicate1p n (a,b,c) = (replicate1p n a, replicate1p n b, replicate1p n c)
+  sinnum1p n (a,b,c) = (sinnum1p n a, sinnum1p n b, sinnum1p n c)
 
 instance (Additive a, Additive b, Additive c, Additive d) => Additive (a,b,c,d) where
   (a,b,c,d) + (i,j,k,l) = (a + i, b + j, c + k, d + l)
-  replicate1p n (a,b,c,d) = (replicate1p n a, replicate1p n b, replicate1p n c, replicate1p n d)
+  sinnum1p n (a,b,c,d) = (sinnum1p n a, sinnum1p n b, sinnum1p n c, sinnum1p n d)
 
 instance (Additive a, Additive b, Additive c, Additive d, Additive e) => Additive (a,b,c,d,e) where
   (a,b,c,d,e) + (i,j,k,l,m) = (a + i, b + j, c + k, d + l, e + m)
-  replicate1p n (a,b,c,d,e) = (replicate1p n a, replicate1p n b, replicate1p n c, replicate1p n d, replicate1p n e)
+  sinnum1p n (a,b,c,d,e) = (sinnum1p n a, sinnum1p n b, sinnum1p n c, sinnum1p n d, sinnum1p n e)
 
 
 concat :: NonEmpty (NonEmpty a) -> NonEmpty a
@@ -212,8 +212,8 @@
 --
 class Additive r => Idempotent r
 
-replicate1pIdempotent :: Natural -> r -> r
-replicate1pIdempotent _ r = r
+sinnum1pIdempotent :: Natural -> r -> r
+sinnum1pIdempotent _ r = r
 
 instance Idempotent ()
 instance Idempotent Bool
diff --git a/Numeric/Algebra.hs b/Numeric/Algebra.hs
--- a/Numeric/Algebra.hs
+++ b/Numeric/Algebra.hs
@@ -9,8 +9,8 @@
   , Abelian
   -- ** additive idempotent semigroups
   , Idempotent
-  , replicate1pIdempotent
-  , replicateIdempotent
+  , sinnum1pIdempotent
+  , sinnumIdempotent
   -- ** partitionable additive semigroups
   , Partitionable(..)
   -- ** additive monoids
@@ -108,9 +108,9 @@
   , Whole(toNatural)
 
   -- * Representable Additive
-  , addRep, replicate1pRep
+  , addRep, sinnum1pRep
   -- * Representable Monoidal
-  , zeroRep, replicateRep
+  , zeroRep, sinnumRep
   -- * Representable Group
   , negateRep, minusRep, subtractRep, timesRep
   -- * Representable Multiplicative (via Algebra)
diff --git a/Numeric/Algebra/Class.hs b/Numeric/Algebra/Class.hs
--- a/Numeric/Algebra/Class.hs
+++ b/Numeric/Algebra/Class.hs
@@ -14,7 +14,7 @@
   -- * Additive Monoids
   , Monoidal(..)
   , sum
-  , replicateIdempotent
+  , sinnumIdempotent
   -- * Associative algebras
   , Algebra(..)
   -- * Coassociative coalgebras
@@ -32,7 +32,7 @@
 import Data.Map (Map)
 import Data.Monoid (mappend)
 -- import Data.Semigroup.Foldable
-import Data.Sequence hiding (reverse,replicate,index)
+import Data.Sequence hiding (reverse,index)
 import Data.Set (Set)
 import Data.Word
 import Numeric.Additive.Class
@@ -490,9 +490,9 @@
 class (LeftModule Natural m, RightModule Natural m) => Monoidal m where
   zero :: m
 
-  replicate :: Whole n => n -> m -> m
-  replicate 0 _  = zero
-  replicate n x0 = f x0 n
+  sinnum :: Whole n => n -> m -> m
+  sinnum 0 _  = zero
+  sinnum n x0 = f x0 n
     where
       f x y
         | even y = f (x + x) (y `quot` 2)
@@ -509,91 +509,91 @@
 sum :: (Foldable f, Monoidal m) => f m -> m
 sum = sumWith id
 
-replicateIdempotent :: (Integral n, Idempotent r, Monoidal r) => n -> r -> r
-replicateIdempotent 0 _ = zero
-replicateIdempotent _ x = x
+sinnumIdempotent :: (Integral n, Idempotent r, Monoidal r) => n -> r -> r
+sinnumIdempotent 0 _ = zero
+sinnumIdempotent _ x = x
 
 instance Monoidal Bool where 
   zero = False
-  replicate 0 _ = False
-  replicate _ r = r
+  sinnum 0 _ = False
+  sinnum _ r = r
 
 instance Monoidal Natural where
   zero = 0
-  replicate n r = toNatural n * r
+  sinnum n r = toNatural n * r
 
 instance Monoidal Integer where 
   zero = 0
-  replicate n r = toInteger n * r
+  sinnum n r = toInteger n * r
 
 instance Monoidal Int where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Int8 where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Int16 where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Int32 where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Int64 where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Word where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Word8 where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Word16 where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Word32 where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal Word64 where 
   zero = 0
-  replicate n r = fromIntegral n * r
+  sinnum n r = fromIntegral n * r
 
 instance Monoidal r => Monoidal (e -> r) where
   zero = const zero
   sumWith f xs e = sumWith (`f` e) xs
-  replicate n r e = replicate n (r e)
+  sinnum n r e = sinnum n (r e)
 
 instance (HasTrie e, Monoidal r) => Monoidal (e :->: r) where
   zero = pure zero
   sumWith f xs = tabulate $ \e -> sumWith (\a -> index (f a) e) xs
-  replicate n r = tabulate $ replicate n . index r
+  sinnum n r = tabulate $ sinnum n . index r
 
 instance Monoidal () where 
   zero = ()
-  replicate _ () = ()
+  sinnum _ () = ()
   sumWith _ _ = ()
 
 instance (Monoidal a, Monoidal b) => Monoidal (a,b) where
   zero = (zero,zero)
-  replicate n (a,b) = (replicate n a, replicate n b)
+  sinnum n (a,b) = (sinnum n a, sinnum n b)
 
 instance (Monoidal a, Monoidal b, Monoidal c) => Monoidal (a,b,c) where
   zero = (zero,zero,zero)
-  replicate n (a,b,c) = (replicate n a, replicate n b, replicate n c)
+  sinnum n (a,b,c) = (sinnum n a, sinnum n b, sinnum n c)
 
 instance (Monoidal a, Monoidal b, Monoidal c, Monoidal d) => Monoidal (a,b,c,d) where
   zero = (zero,zero,zero,zero)
-  replicate n (a,b,c,d) = (replicate n a, replicate n b, replicate n c, replicate n d)
+  sinnum n (a,b,c,d) = (sinnum n a, sinnum n b, sinnum n c, sinnum n d)
 
 instance (Monoidal a, Monoidal b, Monoidal c, Monoidal d, Monoidal e) => Monoidal (a,b,c,d,e) where
   zero = (zero,zero,zero,zero,zero)
-  replicate n (a,b,c,d,e) = (replicate n a, replicate n b, replicate n c, replicate n d, replicate n e)
+  sinnum n (a,b,c,d,e) = (sinnum n a, sinnum n b, sinnum n c, sinnum n d, sinnum n e)
 
diff --git a/Numeric/Algebra/Complex.hs b/Numeric/Algebra/Complex.hs
--- a/Numeric/Algebra/Complex.hs
+++ b/Numeric/Algebra/Complex.hs
@@ -150,7 +150,7 @@
 
 instance Additive r => Additive (Complex r) where
   (+) = addRep 
-  replicate1p = replicate1pRep
+  sinnum1p = sinnum1pRep
 
 instance LeftModule r s => LeftModule r (Complex s) where
   r .* Complex a b = Complex (r .* a) (r .* b)
@@ -160,7 +160,7 @@
 
 instance Monoidal r => Monoidal (Complex r) where
   zero = zeroRep
-  replicate = replicateRep
+  sinnum = sinnumRep
 
 instance Group r => Group (Complex r) where
   (-) = minusRep
diff --git a/Numeric/Algebra/Dual.hs b/Numeric/Algebra/Dual.hs
--- a/Numeric/Algebra/Dual.hs
+++ b/Numeric/Algebra/Dual.hs
@@ -129,7 +129,7 @@
 
 instance Additive r => Additive (Dual r) where
   (+) = addRep 
-  replicate1p = replicate1pRep
+  sinnum1p = sinnum1pRep
 
 instance LeftModule r s => LeftModule r (Dual s) where
   r .* Dual a b = Dual (r .* a) (r .* b)
@@ -139,7 +139,7 @@
 
 instance Monoidal r => Monoidal (Dual r) where
   zero = zeroRep
-  replicate = replicateRep
+  sinnum = sinnumRep
 
 instance Group r => Group (Dual r) where
   (-) = minusRep
diff --git a/Numeric/Algebra/Hyperbolic.hs b/Numeric/Algebra/Hyperbolic.hs
--- a/Numeric/Algebra/Hyperbolic.hs
+++ b/Numeric/Algebra/Hyperbolic.hs
@@ -121,7 +121,7 @@
 
 instance Additive r => Additive (Hyper' r) where
   (+) = addRep 
-  replicate1p = replicate1pRep
+  sinnum1p = sinnum1pRep
 
 instance LeftModule r s => LeftModule r (Hyper' s) where
   r .* Hyper' a b = Hyper' (r .* a) (r .* b)
@@ -131,7 +131,7 @@
 
 instance Monoidal r => Monoidal (Hyper' r) where
   zero = zeroRep
-  replicate = replicateRep
+  sinnum = sinnumRep
 
 instance Group r => Group (Hyper' r) where
   (-) = minusRep
diff --git a/Numeric/Algebra/Quaternion.hs b/Numeric/Algebra/Quaternion.hs
--- a/Numeric/Algebra/Quaternion.hs
+++ b/Numeric/Algebra/Quaternion.hs
@@ -180,7 +180,7 @@
 
 instance Additive r => Additive (Quaternion r) where
   (+) = addRep 
-  replicate1p = replicate1pRep
+  sinnum1p = sinnum1pRep
 
 instance LeftModule r s => LeftModule r (Quaternion s) where
   r .* Quaternion a b c d =
@@ -192,7 +192,7 @@
 
 instance Monoidal r => Monoidal (Quaternion r) where
   zero = zeroRep
-  replicate = replicateRep
+  sinnum = sinnumRep
 
 instance Group r => Group (Quaternion r) where
   (-) = minusRep
diff --git a/Numeric/Coalgebra/Dual.hs b/Numeric/Coalgebra/Dual.hs
--- a/Numeric/Coalgebra/Dual.hs
+++ b/Numeric/Coalgebra/Dual.hs
@@ -129,7 +129,7 @@
 
 instance Additive r => Additive (Dual' r) where
   (+) = addRep 
-  replicate1p = replicate1pRep
+  sinnum1p = sinnum1pRep
 
 instance LeftModule r s => LeftModule r (Dual' s) where
   r .* Dual' a b = Dual' (r .* a) (r .* b)
@@ -139,7 +139,7 @@
 
 instance Monoidal r => Monoidal (Dual' r) where
   zero = zeroRep
-  replicate = replicateRep
+  sinnum = sinnumRep
 
 instance Group r => Group (Dual' r) where
   (-) = minusRep
diff --git a/Numeric/Coalgebra/Hyperbolic.hs b/Numeric/Coalgebra/Hyperbolic.hs
--- a/Numeric/Coalgebra/Hyperbolic.hs
+++ b/Numeric/Coalgebra/Hyperbolic.hs
@@ -121,7 +121,7 @@
 
 instance Additive r => Additive (Hyper r) where
   (+) = addRep 
-  replicate1p = replicate1pRep
+  sinnum1p = sinnum1pRep
 
 instance LeftModule r s => LeftModule r (Hyper s) where
   r .* Hyper a b = Hyper (r .* a) (r .* b)
@@ -131,7 +131,7 @@
 
 instance Monoidal r => Monoidal (Hyper r) where
   zero = zeroRep
-  replicate = replicateRep
+  sinnum = sinnumRep
 
 instance Group r => Group (Hyper r) where
   (-) = minusRep
diff --git a/Numeric/Coalgebra/Quaternion.hs b/Numeric/Coalgebra/Quaternion.hs
--- a/Numeric/Coalgebra/Quaternion.hs
+++ b/Numeric/Coalgebra/Quaternion.hs
@@ -180,7 +180,7 @@
 
 instance Additive r => Additive (Quaternion' r) where
   (+) = addRep 
-  replicate1p = replicate1pRep
+  sinnum1p = sinnum1pRep
 
 instance LeftModule r s => LeftModule r (Quaternion' s) where
   r .* Quaternion' a b c d =
@@ -192,7 +192,7 @@
 
 instance Monoidal r => Monoidal (Quaternion' r) where
   zero = zeroRep
-  replicate = replicateRep
+  sinnum = sinnumRep
 
 instance Group r => Group (Quaternion' r) where
   (-) = minusRep
diff --git a/Numeric/Coalgebra/Trigonometric.hs b/Numeric/Coalgebra/Trigonometric.hs
--- a/Numeric/Coalgebra/Trigonometric.hs
+++ b/Numeric/Coalgebra/Trigonometric.hs
@@ -157,7 +157,7 @@
 
 instance Additive r => Additive (Trig r) where
   (+) = addRep 
-  replicate1p = replicate1pRep
+  sinnum1p = sinnum1pRep
 
 instance LeftModule r s => LeftModule r (Trig s) where
   r .* Trig a b = Trig (r .* a) (r .* b)
@@ -167,7 +167,7 @@
 
 instance Monoidal r => Monoidal (Trig r) where
   zero = zeroRep
-  replicate = replicateRep
+  sinnum = sinnumRep
 
 instance Group r => Group (Trig r) where
   (-) = minusRep
diff --git a/Numeric/Covector.hs b/Numeric/Covector.hs
--- a/Numeric/Covector.hs
+++ b/Numeric/Covector.hs
@@ -79,7 +79,7 @@
 
 instance Additive r => Additive (Covector r a) where
   Covector m + Covector n = Covector $ m + n
-  replicate1p n (Covector m) = Covector $ replicate1p n m
+  sinnum1p n (Covector m) = Covector $ sinnum1p n m
 
 instance Coalgebra r m => Multiplicative (Covector r m) where
   Covector f * Covector g = Covector $ \k -> f (\m -> g (comult k m))
@@ -135,7 +135,7 @@
 
 instance Monoidal s => Monoidal (Covector s a) where
   zero = Covector zero
-  replicate n (Covector m) = Covector (replicate n m)
+  sinnum n (Covector m) = Covector (sinnum n m)
 
 instance Abelian s => Abelian (Covector s a)
 
diff --git a/Numeric/Exp.hs b/Numeric/Exp.hs
--- a/Numeric/Exp.hs
+++ b/Numeric/Exp.hs
@@ -12,11 +12,11 @@
 instance Additive r => Multiplicative (Exp r) where
   Exp a * Exp b = Exp (a + b)
   productWith1 f = Exp . sumWith1 (runExp . f)
-  pow1p (Exp m) n = Exp (replicate1p n m)
+  pow1p (Exp m) n = Exp (sinnum1p n m)
 
 instance Monoidal r => Unital (Exp r) where
   one = Exp zero
-  pow (Exp m) n = Exp (replicate n m)
+  pow (Exp m) n = Exp (sinnum n m)
   productWith f = Exp . sumWith (runExp . f)
 
 instance Group r => Division (Exp r) where
diff --git a/Numeric/Log.hs b/Numeric/Log.hs
--- a/Numeric/Log.hs
+++ b/Numeric/Log.hs
@@ -13,7 +13,7 @@
 instance Multiplicative r => Additive (Log r) where
   Log a + Log b = Log (a * b)
   sumWith1 f = Log . productWith1 (runLog . f)
-  replicate1p n (Log m) = Log (pow1p m n)
+  sinnum1p n (Log m) = Log (pow1p m n)
 
 instance Unital r => LeftModule Natural (Log r) where
   n .* Log m = Log (pow m n)
@@ -23,7 +23,7 @@
 
 instance Unital r => Monoidal (Log r) where
   zero = Log one
-  replicate n (Log m) = Log (pow m n)
+  sinnum n (Log m) = Log (pow m n)
   sumWith f = Log . productWith (runLog . f)
 
 instance Division r => LeftModule Integer (Log r) where
diff --git a/Numeric/Map.hs b/Numeric/Map.hs
--- a/Numeric/Map.hs
+++ b/Numeric/Map.hs
@@ -212,7 +212,7 @@
 
 instance Additive r => Additive (Map r b a) where
   Map m + Map n = Map $ m + n
-  replicate1p n (Map m) = Map $ replicate1p n m
+  sinnum1p n (Map m) = Map $ sinnum1p n m
 
 instance Coalgebra r m => Multiplicative (Map r b m) where
   f * g = Map $ \k b -> (f $# \a -> (g $# comult k a) b) b
@@ -247,7 +247,7 @@
 
 instance Monoidal s => Monoidal (Map s b a) where
   zero = Map zero
-  replicate n (Map m) = Map $ replicate n m
+  sinnum n (Map m) = Map $ sinnum n m
 
 instance Abelian s => Abelian (Map s b a)
 
diff --git a/Numeric/Module/Representable.hs b/Numeric/Module/Representable.hs
--- a/Numeric/Module/Representable.hs
+++ b/Numeric/Module/Representable.hs
@@ -2,9 +2,9 @@
 module Numeric.Module.Representable 
   ( 
   -- * Representable Additive
-    addRep, replicate1pRep
+    addRep, sinnum1pRep
   -- * Representable Monoidal
-  , zeroRep, replicateRep
+  , zeroRep, sinnumRep
   -- * Representable Group
   , negateRep, minusRep, subtractRep, timesRep
   -- * Representable Multiplicative (via Algebra)
@@ -35,17 +35,17 @@
 addRep :: (Zip m, Additive r) => m r -> m r -> m r
 addRep = zipWith (+)
 
--- | `Additive.replicate1p` default definition
-replicate1pRep :: (Whole n, Functor m, Additive r) => n -> m r -> m r
-replicate1pRep = fmap . replicate1p
+-- | `Additive.sinnum1p` default definition
+sinnum1pRep :: (Whole n, Functor m, Additive r) => n -> m r -> m r
+sinnum1pRep = fmap . sinnum1p
 
 -- | `Monoidal.zero` default definition
 zeroRep :: (Applicative m, Monoidal r) => m r 
 zeroRep = pure zero
 
--- | `Monoidal.replicate` default definition
-replicateRep :: (Whole n, Functor m, Monoidal r) => n -> m r -> m r
-replicateRep = fmap . replicate
+-- | `Monoidal.sinnum` default definition
+sinnumRep :: (Whole n, Functor m, Monoidal r) => n -> m r -> m r
+sinnumRep = fmap . sinnum
 
 -- | `Group.negate` default definition
 negateRep :: (Functor m, Group r) => m r -> m r
diff --git a/Numeric/Natural.hs b/Numeric/Natural.hs
deleted file mode 100644
--- a/Numeric/Natural.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module Numeric.Natural 
-  ( Natural
-  , Whole(toNatural)
-  ) where
-
-import Numeric.Natural.Internal
diff --git a/Numeric/Natural/Internal.hs b/Numeric/Natural/Internal.hs
deleted file mode 100644
--- a/Numeric/Natural/Internal.hs
+++ /dev/null
@@ -1,96 +0,0 @@
-module Numeric.Natural.Internal
-  ( Natural(..)
-  , Whole(..)
-  ) where
-
-import Data.Word
-import Data.Bits
-import Text.Read
-import Data.Ix
-
-newtype Natural = Natural { runNatural :: Integer } deriving (Eq,Ord,Ix)
-
-instance Show Natural where
-  showsPrec d (Natural n) = showsPrec d n
-
-instance Read Natural where
-  readPrec = fmap Natural $ step readPrec
-
-instance Num Natural where
-  Natural n + Natural m = Natural (n + m)
-  Natural n * Natural m = Natural (n * m)
-  Natural n - Natural m | result < 0 = error "Natural.(-): negative result"
-                        | otherwise  = Natural result
-	where result = n - m
-  abs (Natural n) = Natural n
-  signum (Natural n) = Natural (signum n)
-  fromInteger n 
-    | n >= 0 = Natural n
-    | otherwise = error "Natural.fromInteger: negative"
-
-instance Bits Natural where
-  Natural n .&. Natural m = Natural (n .&. m)
-  Natural n .|. Natural m = Natural (n .|. m)
-  xor (Natural n) (Natural m) = Natural (xor n m)
-  complement _ = error "Bits.complement: Natural complement undefined"
-  shift (Natural n) = Natural . shift n
-  rotate (Natural n) = Natural . rotate n
-  bit = Natural . bit
-  setBit (Natural n) = Natural . setBit n
-  clearBit (Natural n) = Natural . clearBit n
-  complementBit (Natural n) = Natural . complementBit n
-  testBit = testBit . runNatural 
-  bitSize = bitSize . runNatural
-  isSigned _ = False
-  shiftL (Natural n) = Natural . shiftL n
-  shiftR (Natural n) = Natural . shiftR n
-  rotateL (Natural n) = Natural . rotateL n
-  rotateR (Natural n) = Natural . rotateR n
-
-instance Real Natural where
-  toRational (Natural a) = toRational a
-
-instance Enum Natural where
-  pred (Natural 0) = error "Natural.pred: 0"
-  pred (Natural n) = Natural (pred n)
-  succ (Natural n) = Natural (succ n)
-  fromEnum (Natural n) = fromEnum n
-  toEnum n | n < 0     = error "Natural.toEnum: negative"
-           | otherwise = Natural (toEnum n)
-
-instance Integral Natural where
-  quot (Natural a) (Natural b) = Natural (quot a b)
-  rem (Natural a) (Natural b) = Natural (rem a b)
-  div (Natural a) (Natural b) = Natural (div a b)
-  mod (Natural a) (Natural b) = Natural (mod a b)
-  divMod (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = divMod a b
-  quotRem (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = quotRem a b
-  toInteger = runNatural
-
-class Integral n => Whole n where
-  toNatural :: n -> Natural
-  unsafePred :: n -> n
-
-instance Whole Word where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-
-instance Whole Word8 where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-
-instance Whole Word16 where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-
-instance Whole Word32 where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-
-instance Whole Word64 where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-
-instance Whole Natural where
-  toNatural = id
-  unsafePred (Natural n) = Natural (n - 1)
diff --git a/Numeric/Rig/Class.hs b/Numeric/Rig/Class.hs
--- a/Numeric/Rig/Class.hs
+++ b/Numeric/Rig/Class.hs
@@ -17,7 +17,7 @@
 -- | A Ring without (n)egation
 class (Semiring r, Unital r, Monoidal r) => Rig r where
   fromNatural :: Natural -> r
-  fromNatural n = replicate n one
+  fromNatural n = sinnum n one
 
 fromWhole :: (Whole n, Rig r) => n -> r
 fromWhole = fromNatural . toNatural
diff --git a/Numeric/Ring/Opposite.hs b/Numeric/Ring/Opposite.hs
--- a/Numeric/Ring/Opposite.hs
+++ b/Numeric/Ring/Opposite.hs
@@ -32,11 +32,11 @@
   traverse1 f (Opposite r) = fmap Opposite (f r)
 instance Additive r => Additive (Opposite r) where
   Opposite a + Opposite b = Opposite (a + b)
-  replicate1p n (Opposite a) = Opposite (replicate1p n a)
+  sinnum1p n (Opposite a) = Opposite (sinnum1p n a)
   sumWith1 f = Opposite . sumWith1 (runOpposite . f)
 instance Monoidal r => Monoidal (Opposite r) where
   zero = Opposite zero
-  replicate n (Opposite a) = Opposite (replicate n a)
+  sinnum n (Opposite a) = Opposite (sinnum n a)
   sumWith f = Opposite . sumWith (runOpposite . f)
 instance Semiring r => LeftModule (Opposite r) (Opposite r) where
   (.*) = (*)
diff --git a/Numeric/Ring/Rng.hs b/Numeric/Ring/Rng.hs
--- a/Numeric/Ring/Rng.hs
+++ b/Numeric/Ring/Rng.hs
@@ -17,19 +17,19 @@
 
 instance Abelian r => Additive (RngRing r) where
   RngRing n a + RngRing m b = RngRing (n + m) (a + b)
-  replicate1p n (RngRing m a) = RngRing ((1 + toInteger n) * m) (replicate1p n a)
+  sinnum1p n (RngRing m a) = RngRing ((1 + toInteger n) * m) (sinnum1p n a)
 
 instance Abelian r => Abelian (RngRing r)
 
 instance (Abelian r, Monoidal r) => LeftModule Natural (RngRing r) where
-  n .* RngRing m a = RngRing (toInteger n * m) (replicate n a)
+  n .* RngRing m a = RngRing (toInteger n * m) (sinnum n a)
 
 instance (Abelian r, Monoidal r) => RightModule Natural (RngRing r) where
-  RngRing m a *. n = RngRing (toInteger n * m) (replicate n a)
+  RngRing m a *. n = RngRing (toInteger n * m) (sinnum n a)
 
 instance (Abelian r, Monoidal r) => Monoidal (RngRing r) where
   zero = RngRing 0 zero
-  replicate n (RngRing m a) = RngRing (toInteger n * m) (replicate n a)
+  sinnum n (RngRing m a) = RngRing (toInteger n * m) (sinnum n a)
 
 instance (Abelian r, Group r) => LeftModule Integer (RngRing r) where
   n .* RngRing m a = RngRing (toInteger n * m) (times n a)
diff --git a/Numeric/Rng/Zero.hs b/Numeric/Rng/Zero.hs
--- a/Numeric/Rng/Zero.hs
+++ b/Numeric/Rng/Zero.hs
@@ -27,7 +27,7 @@
 instance Monoidal r => Monoidal (ZeroRng r) where
   zero = ZeroRng zero
   sumWith f = ZeroRng . sumWith (runZeroRng . f)
-  replicate n (ZeroRng a) = ZeroRng (replicate n a)
+  sinnum n (ZeroRng a) = ZeroRng (sinnum n a)
   
 instance Group r => Group (ZeroRng r) where
   ZeroRng a - ZeroRng b = ZeroRng (a - b)
@@ -46,9 +46,9 @@
 instance Monoidal r => Commutative (ZeroRng r)
 instance (Group r, Abelian r) => Rng (ZeroRng r)
 instance Monoidal r => LeftModule Natural (ZeroRng r) where
-  (.*) = replicate
+  (.*) = sinnum
 instance Monoidal r => RightModule Natural (ZeroRng r) where
-  m *. n = replicate n m
+  m *. n = sinnum n m
 instance Group r => LeftModule Integer (ZeroRng r) where
   (.*) = times
 instance Group r => RightModule Integer (ZeroRng r) where
diff --git a/algebra.cabal b/algebra.cabal
--- a/algebra.cabal
+++ b/algebra.cabal
@@ -1,6 +1,6 @@
 name:          algebra
 category:      Math, Algebra
-version:       0.9.0.3
+version:       2.0
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -33,20 +33,20 @@
     GeneralizedNewtypeDeriving
 
   build-depends: 
-    array >= 0.3.0.2 && < 0.4,
-    base >= 4 && < 4.4,
-    distributive >= 0.2 && < 0.3,
-    transformers >= 0.2.0 && < 0.3,
-    tagged >= 0.2.2 && < 0.3,
-    categories >= 0.58.0 && < 0.59,
-    containers >= 0.3.0.0 && < 0.5,
-    keys >= 1.8 && < 1.9,
-    mtl >= 2.0 && < 2.1,
-    semigroups >= 0.6 && < 0.7,
-    semigroupoids >= 1.2.2 && < 1.3,
-    representable-functors >= 2.0 && < 2.1,
-    representable-tries >= 2.0 && < 2.1,
-    void >= 0.5.4 && < 0.6
+    array                   >= 0.3.0.2 && < 0.4,
+    base                    >= 4       && < 5,
+    distributive            >= 0.2     && < 0.3,
+    transformers            >= 0.2.0   && < 0.3,
+    tagged                  >= 0.2.2.3 && < 0.3,
+    categories              >= 0.58.0  && < 0.59,
+    containers              >= 0.3     && < 0.5,
+    keys                    >= 2.0     && < 2.1,
+    mtl                     >= 2.0     && < 2.1,
+    semigroups              >= 0.7.1   && < 0.8,
+    semigroupoids           >= 1.2.4   && < 1.3,
+    representable-functors  >= 2.0     && < 2.1,
+    representable-tries     >= 2.0     && < 2.1,
+    void                    >= 0.5.4.3 && < 0.6
 
   exposed-modules:
     Numeric.Additive.Class
@@ -91,8 +91,6 @@
     Numeric.Map
     Numeric.Module.Class
     Numeric.Module.Representable
-    Numeric.Natural
-    Numeric.Natural.Internal
     Numeric.Order.Additive
     Numeric.Order.Class
     Numeric.Order.LocallyFinite