diff --git a/include/data/encoding/base58.hpp b/include/data/encoding/base58.hpp
index cc482fa7..109c0c46 100644
--- a/include/data/encoding/base58.hpp
+++ b/include/data/encoding/base58.hpp
@@ -167,6 +167,14 @@ namespace data::math {
     bool is_zero (const base58_uint &);
     bool is_negative (const base58_uint &);
     bool is_positive (const base58_uint &);
+
+    template <>
+    struct divide<base58_uint> {
+        division<base58_uint> operator () (const base58_uint &v, const base58_uint &z) {
+            auto d = divide<N> {} (N (v), N (z));
+            return {encoding::base58::encode (d.Quotient), encoding::base58::encode (d.Remainder)};
+        }
+    };
     
 }
 
diff --git a/include/data/encoding/endian/arithmetic.hpp b/include/data/encoding/endian/arithmetic.hpp
index d7fcbaf1..6cc60a9d 100644
--- a/include/data/encoding/endian/arithmetic.hpp
+++ b/include/data/encoding/endian/arithmetic.hpp
@@ -10,6 +10,7 @@
 #include <data/encoding/words.hpp>
 #include <data/math/abs.hpp>
 #include <data/math/sign.hpp>
+#include <data/math/division.hpp>
 
 namespace data::endian {
 
@@ -264,6 +265,30 @@ namespace data::math {
         return x > 0;
     }
 
+    template <endian::order r, size_t x>
+    struct divide<endian::arithmetic<false, r, x>, endian::arithmetic<false, r, x>> {
+        division<endian::arithmetic<false, r, x>, endian::arithmetic<false, r, x>> operator ()
+        (const endian::arithmetic<false, r, x> &v, const endian::arithmetic<false, r, x> &z) {
+            return {v / z, v % z};
+        }
+    };
+
+    template <endian::order r, size_t x>
+    struct divide<endian::arithmetic<true, r, x>, endian::arithmetic<true, r, x>> {
+        division<endian::arithmetic<true, r, x>, endian::arithmetic<false, r, x>> operator ()
+        (const endian::arithmetic<true, r, x> &v, const endian::arithmetic<true, r, x> &z) {
+            return {v / z, v % z};
+        }
+    };
+
+    template <endian::order r, size_t x>
+    struct divide<endian::arithmetic<true, r, x>, endian::arithmetic<false, r, x>> {
+        division<endian::arithmetic<true, r, x>, endian::arithmetic<false, r, x>> operator ()
+        (const endian::arithmetic<true, r, x> &v, const endian::arithmetic<false, r, x> &z) {
+            return {v / z, v % z};
+        }
+    };
+
 }
 
 namespace data {
diff --git a/include/data/encoding/integer.hpp b/include/data/encoding/integer.hpp
index 4020afe4..e5901d40 100644
--- a/include/data/encoding/integer.hpp
+++ b/include/data/encoding/integer.hpp
@@ -443,6 +443,16 @@ namespace data::math {
     template <hex_case zz> struct abs<hex::int2<zz>> {
         hex::int2<zz> operator () (const hex::int2<zz> &);
     };
+
+    template <> struct times<dec_int> {
+        dec_int operator () (const dec_int &, const dec_int &);
+        nonzero<dec_int> operator () (const nonzero<dec_int> &, const nonzero<dec_int> &);
+    };
+
+    template <number::complement c, hex_case zz> struct times<hex::integer<c, zz>> {
+        hex::integer<c, zz> operator () (const hex::integer<c, zz> &, const hex::integer<c, zz> &);
+        nonzero<hex::integer<c, zz>> operator () (const nonzero<hex::integer<c, zz>> &, const nonzero<hex::integer<c, zz>> &);
+    };
     
     template <> struct commutative<plus<dec_uint>, dec_uint> {};
     template <> struct associative<plus<dec_uint>, dec_uint> {};
@@ -490,6 +500,38 @@ namespace data::math {
     
     template <hex_case cx> 
     bool is_negative_zero (const hex::int2<cx> &);
+
+    template <> struct divide<dec_uint, dec_uint> {
+        division<dec_uint, dec_uint> operator () (const dec_uint &, const dec_uint &);
+    };
+
+    template <> struct divide<dec_int, dec_int> {
+        division<dec_int, dec_uint> operator () (const dec_int &, const dec_int &);
+    };
+
+    template <> struct divide<dec_int, dec_uint> {
+        division<dec_int, dec_uint> operator () (const dec_int &, const dec_uint &);
+    };
+
+    template <hex_case zz>
+    struct divide<hex::uint<zz>, hex::uint<zz>> {
+        division<hex::uint<zz>, hex::uint<zz>> operator () (const hex::uint<zz> &, const hex::uint<zz> &);
+    };
+
+    template <hex_case zz>
+    struct divide<hex::int1<zz>, hex::int1<zz>> {
+        division<hex::int1<zz>, hex::uint<zz>> operator () (const hex::int1<zz> &, const hex::int1<zz> &);
+    };
+
+    template <hex_case zz>
+    struct divide<hex::int1<zz>, hex::uint<zz>> {
+        division<hex::int1<zz>, hex::uint<zz>> operator () (const hex::int1<zz> &, const hex::uint<zz> &);
+    };
+
+    template <hex_case zz>
+    struct divide<hex::int2<zz>, hex::int2<zz>> {
+        division<hex::int2<zz>, hex::int2<zz>> operator () (const hex::int2<zz> &, const hex::int2<zz> &);
+    };
     
 }
 
@@ -576,6 +618,7 @@ namespace data::encoding::decimal {
         
         explicit operator double () const;
         explicit operator uint64 () const;
+        explicit operator math::N () const;
     };
     
     signed_decimal::string operator - (const string &);
@@ -621,6 +664,7 @@ namespace data::encoding::signed_decimal {
         
         explicit operator double () const;
         explicit operator int64 () const;
+        explicit operator math::Z () const;
     };
     
     template <endian::order r>
@@ -662,6 +706,8 @@ namespace data::encoding::hexidecimal {
         integer<c, cx> operator + (int64) const;
         integer<c, cx> operator - (int64) const;
         integer<c, cx> operator * (int64) const;
+
+        explicit operator math::Z () const;
     };
 
     template <hex::letter_case cx>
@@ -677,6 +723,8 @@ namespace data::encoding::hexidecimal {
         data::hex::uint<cx> operator + (uint64) const;
         data::hex::uint<cx> operator - (uint64) const;
         data::hex::uint<cx> operator * (uint64) const;
+
+        explicit operator math::N () const;
     };
     
     template <complement c, hex::letter_case cx>
@@ -995,9 +1043,17 @@ namespace data::encoding::signed_decimal {
     string inline &operator &= (string &n, const decimal::string &x) {
         return n &= string {static_cast<const std::string> (x)};
     }
-    
-    string inline operator / (const string &n, const decimal::string &x) {
-        return n / string {static_cast<const std::string> (x)};
+
+    string inline operator / (const string &v, const decimal::string &z) {
+        return math::divide<string, decimal::string> {} (v, z).Quotient;
+    }
+
+    string inline operator / (const string &v, const string &z) {
+        return math::divide<string, string> {} (v, z).Quotient;
+    }
+
+    decimal::string inline operator % (const string &v, const decimal::string &z) {
+        return math::divide<string, decimal::string> {} (v, z).Remainder;
     }
     
     string inline operator ++ (string &x, int) {
diff --git a/include/data/encoding/words.hpp b/include/data/encoding/words.hpp
index 29bc6033..6d7462cd 100644
--- a/include/data/encoding/words.hpp
+++ b/include/data/encoding/words.hpp
@@ -16,6 +16,9 @@
 
 namespace data::encoding {
     
+    // words is for iterating over digits that have an endian order.
+    // Using words, you will always iterate from least to most
+    // significant digits. Reverse iteration will go from most to least.
     template <endian::order o, typename digit> struct words;
     
     template <typename digit> struct words<endian::little, digit> {
diff --git a/include/data/float.hpp b/include/data/float.hpp
index ea2c4897..39c42176 100644
--- a/include/data/float.hpp
+++ b/include/data/float.hpp
@@ -6,7 +6,7 @@
 #define DATA_FLOAT
 
 #include <data/math/abs.hpp>
-#include <data/math/arithmetic.hpp>
+#include <data/math/algebra.hpp>
 #include <data/math/commutative.hpp>
 #include <data/math/associative.hpp>
 
@@ -120,6 +120,18 @@ namespace data::math {
             return x * x;
         }
     };
+
+    template <std::floating_point X> struct times<X> {
+        X operator () (const X &a, const X &b) {
+            return a * b;
+        }
+
+        // technically, it is not true that there are no zero divisors but
+        // we use floats as an approximation for real numbers.
+        nonzero<X> operator () (const nonzero<X> &a, const nonzero<X> &b) {
+            return a * b;
+        }
+    };
     
     template <std::floating_point X> struct commutative<plus<X>, X> {};
     template <std::floating_point X> struct commutative<times<X>, X> {};
@@ -143,6 +155,12 @@ namespace data::math {
             return b - a;
         }
     };
+
+    template <std::floating_point X> struct inverse<times<X>, X> {
+        nonzero<X> operator () (const nonzero<X> &a, const nonzero<X> &b) {
+            return b / a;
+        }
+    };
     
 }
 
diff --git a/include/data/functional/queue.hpp b/include/data/functional/queue.hpp
index f972232b..f27cb76a 100644
--- a/include/data/functional/queue.hpp
+++ b/include/data/functional/queue.hpp
@@ -15,19 +15,19 @@ namespace data::interface {
     
     template <typename list, typename element>
     concept has_queue_constructor = requires (list x, element e) {
-        { list{x, e} } -> std::same_as<list>;
+        { list {x, e} } -> std::same_as<list>;
     } && requires (element e) {
-        { list{e} } -> std::same_as<list>;
+        { list {e} } -> std::same_as<list>;
     };
     
     template <typename list, typename element>
     concept has_append_method = requires (list x, element e) {
-        { x.append(e) } -> std::convertible_to<list>;
+        { x.append (e) } -> std::convertible_to<list>;
     };
     
     template <typename list>
     concept has_sort_method = requires (list x) {
-        { x.sort() } -> std::convertible_to<list>;
+        { x.sort () } -> std::convertible_to<list>;
     };
     
 }
@@ -35,35 +35,35 @@ namespace data::interface {
 namespace data {
     
     template <typename list, typename elem> requires interface::has_append_method<list, elem>
-    inline list append(const list& x, const elem& e) {
-        return x.append(e);
+    inline list append (const list &x, const elem &e) {
+        return x.append (e);
     }
     
 }
 
 namespace data::functional {
     
-    template <typename L, typename elem = decltype(std::declval<L>().first())> 
+    template <typename L, typename elem = decltype(std::declval<L> ().first())>
     concept queue = sequence<const L, elem> && interface::has_append_method<const L, elem> && 
         interface::has_queue_constructor<L, elem> && std::default_initializable<L>;
     
     template <queue list> 
-    list take_queue(const list &x, size_t n, const list &z = {});
+    list take_queue (const list &x, size_t n, const list &z = {});
     
     template <queue list>
     list join_queue(const list&a, const list& b) {
-        if (data::empty(b)) return a;
-        return join_queue(append(a, first(b)), rest(b));
+        if (data::empty (b)) return a;
+        return join_queue (append(a, first(b)), rest(b));
     }
     
     template <queue L> requires ordered<element_of<L>>
-    L merge_queue(const L &a, const L &b, const L &n = {}) {
-        if (data::empty(a) && data::empty(b)) return reverse(n);
-        if (data::empty(a)) return merge_queue(a, rest(b), prepend(n, first(b)));
-        if (data::empty(b)) return merge_queue(rest(a), b, prepend(n, first(a)));
-        return first(a) < first(b) ? 
-            merge_queue(rest(a), b, prepend(n, first(a))): 
-            merge_queue(a, rest(b), prepend(n, first(b)));
+    L merge_queue (const L &a, const L &b, const L &n = {}) {
+        if (data::empty (a) && data::empty(b)) return reverse(n);
+        if (data::empty (a)) return merge_queue(a, rest(b), prepend(n, first(b)));
+        if (data::empty (b)) return merge_queue(rest(a), b, prepend(n, first(a)));
+        return first (a) < first(b) ?
+            merge_queue (rest (a), b, prepend(n, first(a))):
+            merge_queue (a, rest(b), prepend(n, first(b)));
     }
     
 }
@@ -71,46 +71,46 @@ namespace data::functional {
 namespace data {
     
     template <functional::queue list>
-    list select(list l, function<bool (element_of<list>)> satisfies, list found = {}) {
-        if (data::empty(l)) return found;
-        auto f0 = first(l);
-        if (satisfies(f0)) select(rest(l), satisfies, append(found, f0));
-        return select(rest(l), satisfies, found);
+    list select (list l, function<bool (element_of<list>)> satisfies, list found = {}) {
+        if (data::empty (l)) return found;
+        auto f0 = first (l);
+        if (satisfies (f0)) select (rest (l), satisfies, append (found, f0));
+        return select (rest (l), satisfies, found);
     }
     
     template <functional::queue L>
-    L rotate_left(const L x) {
-        size_t s = size(x);
+    L rotate_left (const L x) {
+        size_t s = size (x);
         if (s == 0 || s == 1) return x; 
         
-        return append(rest(x), first(x));
+        return append (rest (x), first (x));
     }
     
     template <functional::queue L>
-    L rotate_left(const L x, uint32 n) {
+    L rotate_left (const L x, uint32 n) {
         if (n == 0) return x;
         
-        size_t s = size(x);
+        size_t s = size (x);
         if (s == 0 || s == 1) return x; 
         
-        if (n > s) return rotate_left(x, n % s);
-        return rotate_left(rotate_left(x, n - 1));
+        if (n > s) return rotate_left (x, n % s);
+        return rotate_left (rotate_left (x, n - 1));
     }
     
     template <functional::queue L>
-    inline L rotate_right(const L x) {
-        return reverse(rotate_left(reverse(x)));
+    inline L rotate_right (const L x) {
+        return reverse (rotate_left (reverse (x)));
     }
     
     template <functional::queue L>
-    L rotate_right(const L x, uint32 n) {
+    L rotate_right (const L x, uint32 n) {
         if (n == 0) return x;
         
-        size_t s = size(x);
+        size_t s = size (x);
         if (s == 0 || s == 1) return x; 
         
-        if (n > s) return rotate_right(x, n % s);
-        return rotate_right(rotate_right(x, n - 1));
+        if (n > s) return rotate_right (x, n % s);
+        return rotate_right (rotate_right (x, n - 1));
     }
     
 }
diff --git a/include/data/functional/stack.hpp b/include/data/functional/stack.hpp
index 06331991..a1d3d8a5 100644
--- a/include/data/functional/stack.hpp
+++ b/include/data/functional/stack.hpp
@@ -20,42 +20,42 @@ namespace data::interface {
     
     template <typename list, typename element>
     concept has_stack_constructor = requires (list x, element e) {
-        { list{e, x} } -> std::same_as<list>;
+        { list {e, x} } -> std::same_as<list>;
     } && requires (element e) {
-        { list{e} } -> std::same_as<list>;
+        { list {e} } -> std::same_as<list>;
     };
     
     template <typename list, typename element>
     concept has_prepend_method = requires (list x, element e) {
-        { x.prepend(e) } -> std::convertible_to<list>;
+        { x.prepend (e) } -> std::convertible_to<list>;
     };
     
 }
 
 namespace data { 
     template <typename list, typename elem> requires interface::has_prepend_method<list, elem>
-    inline list prepend(const list& x, const elem& e) {
-        return x.prepend(e);
+    inline list prepend (const list &x, const elem &e) {
+        return x.prepend (e);
     }
 }
 
 namespace data::functional { 
     
-    template <typename L, typename elem = std::remove_reference_t<decltype(std::declval<L>().first())>>
+    template <typename L, typename elem = std::remove_reference_t<decltype (std::declval<L> ().first ())>>
     concept stack = sequence<const L, elem> && interface::has_prepend_method<const L, elem> && 
         interface::has_stack_constructor<L, elem> && std::default_initializable<L>;
     
     template <stack list> 
-    list take_stack(const list &x, size_t n, const list &z = {});
+    list take_stack (const list &x, size_t n, const list &z = {});
     
     template <functional::stack list>
-    list join_stack(const list&a, const list& b);
+    list join_stack (const list&a, const list& b);
     
     template <stack L> requires ordered<element_of<L>>
-    L merge_stack(const L &a, const L &b, const L &n = {});
+    L merge_stack (const L &a, const L &b, const L &n = {});
     
     template <typename times, typename L1, typename L2, typename plus, typename value>
-    value inner(times t, L1 l1, L2 l2, plus p);
+    value inner (times t, L1 l1, L2 l2, plus p);
 }
 
 namespace data {
@@ -67,28 +67,28 @@ namespace data {
 namespace data::functional { 
     
     template <functional::stack list>
-    list join_stack(const list&a, const list& b) {
-        if (data::empty(a)) return b;
-        return prepend(join_stack(rest(a), b), first(a));
+    list join_stack (const list &a, const list &b) {
+        if (data::empty (a)) return b;
+        return prepend (join_stack (rest (a), b), first (a));
     }
     
     template <stack L> requires ordered<element_of<L>>
-    L merge_stack(const L &a, const L &b, const L &n) {
-        if (data::empty(a) && data::empty(b)) return reverse(n);
-        if (data::empty(a)) return merge_stack(a, rest(b), prepend(n, first(b)));
-        if (data::empty(b)) return merge_stack(rest(a), b, prepend(n, first(a)));
-        return first(a) < first(b) ? 
-            merge_stack(rest(a), b, prepend(n, first(a))): 
-            merge_stack(a, rest(b), prepend(n, first(b)));
+    L merge_stack (const L &a, const L &b, const L &n) {
+        if (data::empty (a) && data::empty(b)) return reverse(n);
+        if (data::empty (a)) return merge_stack (a, rest (b), prepend (n, first (b)));
+        if (data::empty (b)) return merge_stack (rest (a), b, prepend (n, first (a)));
+        return first (a) < first (b) ?
+            merge_stack(rest(a), b, prepend (n, first (a))):
+            merge_stack (a, rest(b), prepend (n, first (b)));
     }
     
     template <typename times, typename L1, typename L2, typename plus, typename value>
-    value inner(times t, L1 l1, L2 l2, plus p) {
-        uint32 size = l1.size();
-        if (size != l2.size()) exception{"lists must be the same size"};
-        if (size == 0) return value{};
+    value inner (times t, L1 l1, L2 l2, plus p) {
+        uint32 size = l1.size ();
+        if (size != l2.size ()) exception {"lists must be the same size"};
+        if (size == 0) return value {};
         
-        return p(t(l1.first(), l2.first()), inner(t, rest(l1), rest(l2), p));
+        return p (t (l1.first (), l2.first ()), inner (t, rest (l1), rest (l2), p));
     }
     
     // This is a node that you could perhaps use to make a list. 
@@ -98,49 +98,49 @@ namespace data::functional {
         Y Rest;
         size_t Size;
         
-        stack_node(X x, Y r);
-        stack_node(X x);
+        stack_node (X x, Y r);
+        stack_node (X x);
         
-        X& first();
+        X& first ();
         const X& first() const;
-        Y rest() const;
+        Y rest () const;
         
-        bool valid() const;
-        size_t size() const;
-        bool contains(X x) const;
+        bool valid () const;
+        size_t size () const;
+        bool contains (X x) const;
     };
     
     template <typename X, typename Y>
-    inline stack_node<X, Y>::stack_node(X x, Y r) : First(x), Rest(r), Size{data::size(r) + 1} {}
+    inline stack_node<X, Y>::stack_node (X x, Y r) : First (x), Rest(r), Size {data::size (r) + 1} {}
     
     template <typename X, typename Y>
-    inline stack_node<X, Y>::stack_node(X x) : First(x), Rest{}, Size{1} {}
+    inline stack_node<X, Y>::stack_node (X x) : First (x), Rest {}, Size {1} {}
     
     template <typename X, typename Y>
-    inline const X& stack_node<X, Y>::first() const {
+    inline const X& stack_node<X, Y>::first () const {
         return First;
     }
     
     template <typename X, typename Y>
-    inline Y stack_node<X, Y>::rest() const {
+    inline Y stack_node<X, Y>::rest () const {
         return Rest;
     }
     
     template <typename X, typename Y>
-    inline bool stack_node<X, Y>::valid() const {
-        return data::valid(First) && data::valid(Rest);
+    inline bool stack_node<X, Y>::valid () const {
+        return data::valid (First) && data::valid (Rest);
     }
     
     template <typename X, typename Y>
-    inline size_t stack_node<X, Y>::size() const {
+    inline size_t stack_node<X, Y>::size () const {
         return Size;
     }
     
     template <typename X, typename Y>
-    inline bool stack_node<X, Y>::contains(X x) const {
+    inline bool stack_node<X, Y>::contains (X x) const {
         if (x == First) return true;
         
-        return data::functional::contains(Rest, x);
+        return data::functional::contains (Rest, x);
     }
 
 }
diff --git a/include/data/math.hpp b/include/data/math.hpp
index 3da232b9..ad08114a 100644
--- a/include/data/math.hpp
+++ b/include/data/math.hpp
@@ -5,17 +5,20 @@
 #ifndef DATA_MATH
 #define DATA_MATH
 
-#include <data/math/permutation.hpp>
 #include <data/math/fraction.hpp>
+#include <data/math/permutation.hpp>
+#include <data/math/polynomial.hpp>
 
 namespace data {
     
+    // fractions
+    template <typename Z, typename N = decltype (abs (std::declval<Z> ()))> using fraction = math::fraction<Z, N>;
+    
     // permutations
-    template <typename X>
-    using permutation = data::math::permutation<X>;
+    template <typename X> using permutation = math::permutation<X>;
     
-    template <typename Z, typename N = Z>
-    using fraction = data::math::fraction<Z, N>;
+    // Polynomials 
+    template <typename X, typename N, char x = 'x'> using polynomial = math::polynomial<X, N, x>;
     
 }
 
diff --git a/include/data/math/algebra.hpp b/include/data/math/algebra.hpp
index bb034231..bbae5a18 100644
--- a/include/data/math/algebra.hpp
+++ b/include/data/math/algebra.hpp
@@ -5,33 +5,42 @@
 #ifndef DATA_MATH_ALGEBRA
 #define DATA_MATH_ALGEBRA
 
-#include <data/math/point.hpp>
+#include <data/types.hpp>
 
-namespace data::interface {
-    // TODO
-    
-    /*
-    template <typename x, typename r>
-    struct algebra : public linear::space<x, r> {
-        x times(x a, x b) const {
-            return a ^ b;
+namespace data::math {
+
+    template <typename F, typename x> struct identity;
+    template <typename F, typename x> struct inverse;
+
+    template <typename X> struct plus {
+        X operator () (const X &a, const X &b) {
+            return a + b;
         }
     };
-        
-    template <typename x, typename r>
-    struct division_algebra : public algebra<x, r> {
-        x divide(x a, x b) const {
-            return a / b;
+
+    template <typename X> struct identity<plus<X>, X> {
+        X operator () () {
+            return X {0};
         }
     };
-        
-    template <typename x, typename r>
-    struct normed_division_algebra : public ring<x> {
-        nonnegative<r> norm(x a) const {
-            return a.norm();
+
+    template <typename X> struct times {
+        X operator () (const X &a, const X &b) {
+            return a * b;
+        }
+    };
+
+    template <typename X> struct identity<times<X>, X> {
+        X operator () () {
+            return X {1};
+        }
+    };
+
+    template <std::signed_integral X> struct inverse<plus<X>, X> {
+        X operator () (X a, X b) {
+            return b - a;
         }
     };
-    */
     
 }
 
diff --git a/include/data/math/algebra/finite_field.hpp b/include/data/math/algebra/finite_field.hpp
index 7866503f..ccddb8b8 100644
--- a/include/data/math/algebra/finite_field.hpp
+++ b/include/data/math/algebra/finite_field.hpp
@@ -16,31 +16,28 @@ namespace data::math::algebra {
     template <typename N, typename Z, auto &P> struct prime_field_element;
     
     template <typename N, typename Z, auto &P>
-    bool operator==(const prime_field_element<N, Z, P> &, const prime_field_element<N, Z, P> &);
-    
-    template <typename N, typename Z, auto &P>
-    bool operator!=(const prime_field_element<N, Z, P> &, const prime_field_element<N, Z, P> &);
+    bool operator == (const prime_field_element<N, Z, P> &, const prime_field_element<N, Z, P> &);
     
     template <typename N, typename Z, auto &P> struct prime_field;
     
     template <typename N, typename Z, auto &P>
     struct prime_field_element : ptr<number::modular<N, P>> {
     
-        prime_field_element operator+(const prime_field_element &) const;
-        prime_field_element operator-(const prime_field_element &) const;
-        prime_field_element operator*(const prime_field_element &) const;
-        prime_field_element operator/(const prime_field_element &) const;
+        prime_field_element operator + (const prime_field_element &) const;
+        prime_field_element operator - (const prime_field_element &) const;
+        prime_field_element operator * (const prime_field_element &) const;
+        prime_field_element operator / (const prime_field_element &) const;
         
-        prime_field_element inverse() const;
+        prime_field_element inverse () const;
         
-        bool valid() const {
-            return *this != nullptr && (*this)->valid();
+        bool valid () const {
+            return *this != nullptr && (*this)->valid ();
         }
         
     private:
-        prime_field_element() : ptr<number::modular<N, P>>{} {}
+        prime_field_element() : ptr<number::modular<N, P>> {} {}
         template<typename... X>
-        prime_field_element(X... x) : ptr<number::modular<N, P>>(std::make_shared<number::modular<N, P>>(x...)) {}
+        prime_field_element (X... x) : ptr<number::modular<N, P>> (std::make_shared<number::modular<N, P>> (x...)) {}
         
         friend struct prime_field<N, Z, P>;
     };
@@ -48,19 +45,19 @@ namespace data::math::algebra {
     template <typename N, typename Z, auto &P>
     struct prime_field {
         number::prime<N> Modulus;
-        prime_field(number::prime<N> p) : Modulus{p.Prime == N(P) ? p : number::prime<N>{}} {}
+        prime_field (number::prime<N> p) : Modulus {p.Prime == N (P) ? p : number::prime<N> {}} {}
         
-        bool valid() const {
-            return Modulus.valid() && Modulus.Prime == N(P);
+        bool valid () const {
+            return Modulus.valid () && Modulus.Prime == N (P);
         }
         
         template <typename... X>
-        prime_field_element<N, Z, P> make(X... x);
+        prime_field_element<N, Z, P> make (X... x);
     };
 
     template <typename N, typename Z, auto &P>
-    inline std::ostream& operator<<(std::ostream& o, const prime_field_element<N, Z, P>& m) {
-        return o << "f<"<<P<<">{"<<m->Value<<"}";
+    std::ostream inline &operator << (std::ostream &o, const prime_field_element<N, Z, P> &m) {
+        return o << "f<" << P << ">{" << m->Value << "}";
     }
     
 }
@@ -82,7 +79,7 @@ namespace data::math {
     struct commutative<
         times<algebra::prime_field_element<N, Z, prime>>, 
         algebra::prime_field_element<N, Z, prime>>
-        : commutative<times<N>, N> {};;
+        : commutative<times<N>, N> {};
     
     template <typename N, typename Z, auto & prime>
     struct associative<
@@ -95,8 +92,8 @@ namespace data::math {
         plus<algebra::prime_field_element<N, Z, prime>>, 
         algebra::prime_field_element<N, Z, prime>>
         : identity<plus<N>, N> {
-        static const algebra::prime_field_element<N, Z, prime> value() {
-            return {identity<plus<N>, N>::value()};
+        static const algebra::prime_field_element<N, Z, prime> value () {
+            return {identity<plus<N>, N>::value ()};
         }
     };
     
@@ -105,8 +102,8 @@ namespace data::math {
         times<algebra::prime_field_element<N, Z, prime>>, 
         algebra::prime_field_element<N, Z, prime>>
         : identity<times<N>, N> {
-        static const algebra::prime_field_element<N, Z, prime> value() {
-            return {identity<times<N>, N>::value()};
+        static const algebra::prime_field_element<N, Z, prime> value () {
+            return {identity<times<N>, N>::value ()};
         }
     };
     
@@ -115,61 +112,56 @@ namespace data::math {
 namespace data::math::algebra {
     
     template <typename N, typename Z, auto &P>
-    bool inline operator==(const prime_field_element<N, Z, P> &a, const prime_field_element<N, Z, P> &b) {
-        if (static_cast<ptr<number::modular<N, P>>>(a) == static_cast<ptr<number::modular<N, P>>>(b)) return true;
-        return *static_cast<ptr<number::modular<N, P>>>(a) == *static_cast<ptr<number::modular<N, P>>>(b);
-    }
-    
-    template <typename N, typename Z, auto &P>
-    bool inline operator!=(const prime_field_element<N, Z, P> &a, const prime_field_element<N, Z, P> &b) {
-        return !(a == b);
+    bool inline operator == (const prime_field_element<N, Z, P> &a, const prime_field_element<N, Z, P> &b) {
+        if (static_cast<ptr<number::modular<N, P>>> (a) == static_cast<ptr<number::modular<N, P>>> (b)) return true;
+        return *static_cast<ptr<number::modular<N, P>>> (a) == *static_cast<ptr<number::modular<N, P>>> (b);
     }
     
     template <typename N, typename Z, auto &P> 
     prime_field_element<N, Z, P> inline 
-    prime_field_element<N, Z, P>::operator+(
+    prime_field_element<N, Z, P>::operator + (
         const prime_field_element<N, Z, P> &e) const {
         if (*this == nullptr || e == nullptr) return {};
-        return {*this->get() + *e.get()};
+        return {*this->get () + *e.get ()};
     }
     
     template <typename N, typename Z, auto &P> 
     prime_field_element<N, Z, P> inline
-    prime_field_element<N, Z, P>::operator-(const prime_field_element& e) const {
+    prime_field_element<N, Z, P>::operator - (const prime_field_element &e) const {
         if (*this == nullptr || e == nullptr) return {};
-        return {*this->get() - *e.get()};
+        return {*this->get () - *e.get ()};
     }
     
     template <typename N, typename Z, auto &P> 
     prime_field_element<N, Z, P> inline
-    prime_field_element<N, Z, P>::operator*(const prime_field_element& e) const {
+    prime_field_element<N, Z, P>::operator * (const prime_field_element &e) const {
         if (*this == nullptr || e == nullptr) return {};
-        return {*this->get() * *e.get()};
+        return {*this->get () * *e.get ()};
     }
     
     template <typename N, typename Z, auto &P> 
     prime_field_element<N, Z, P> 
     prime_field_element<N, Z, P>::inverse() const {
-        if (*this == nullptr || *this == prime_field_element{0}) return {};
-        Z bt = number::euclidian::extended<N, Z>::algorithm(N{P}, 
-            this->get()->Value).BezoutT;
-        if (bt < 0) bt += N{P};
-        return prime_field_element{math::abs<Z>{}(bt)};
+        if (*this == nullptr || *this == prime_field_element {0}) return {};
+        Z bt = number::euclidian::extended<N, Z>::algorithm (N {P},
+            this->get ()->Value).BezoutT;
+        if (bt < 0) bt += N {P};
+        return prime_field_element {math::abs<Z> {} (bt)};
     }
     
     template <typename N, typename Z, auto &P> 
     inline prime_field_element<N, Z, P> 
-    prime_field_element<N, Z, P>::operator/(const prime_field_element& e) const {
+    prime_field_element<N, Z, P>::operator / (const prime_field_element &e) const {
         if (*this == nullptr || e == nullptr) return {};
-        if (e == prime_field_element{0}) throw division_by_zero{};
-        return *this * e.inverse();
+        if (e == prime_field_element {0}) throw division_by_zero {};
+        return *this * e.inverse ();
     }
     
     template <typename N, typename Z, auto &P> 
     template <typename... X>
-    inline prime_field_element<N, Z, P> prime_field<N, Z, P>::make(X... x) {
-        if (!valid()) return {};
-        return prime_field_element<N, Z, P>(x...);
+    inline prime_field_element<N, Z, P> prime_field<N, Z, P>::make (X... x) {
+        if (!valid ()) return {};
+        return prime_field_element<N, Z, P> (x...);
     }
 }
 
diff --git a/include/data/math/arithmetic.hpp b/include/data/math/arithmetic.hpp
index c85b7512..eaf0c8bf 100644
--- a/include/data/math/arithmetic.hpp
+++ b/include/data/math/arithmetic.hpp
@@ -16,45 +16,6 @@ namespace data::math {
             return X {0};
         }
     };
-    
-    template <typename F, typename x> struct identity;
-    template <typename F, typename x> struct inverse;
-    
-    template <typename X> struct plus {
-        X operator () (const X &a, const X &b) {
-            return a + b;
-        }
-    };
-    
-    template <typename X> struct identity<plus<X>, X> {
-        X operator () () {
-            return X {0};
-        }
-    };
-    
-    template <typename X> struct times {
-        X operator () (const X &a, const X &b) {
-            return a * b;
-        }
-    };
-    
-    template <typename X> struct identity<times<X>, X> {
-        X operator () () {
-            return X {1};
-        }
-    };
-    
-    template <> struct inverse<plus<int8_t>, int8_t> {
-        int8_t operator () (const int8_t &a, const int8_t &b) {
-            return b - a;
-        }
-    };
-    
-    template <std::integral X> struct inverse<plus<X>, X> {
-        X operator () (X a, X b) {
-            return b - a;
-        }
-    };
 
 }
 
diff --git a/include/data/math/associative.hpp b/include/data/math/associative.hpp
index c09f9c00..8726ad68 100644
--- a/include/data/math/associative.hpp
+++ b/include/data/math/associative.hpp
@@ -5,10 +5,15 @@
 #ifndef DATA_MATH_ASSOCIATIVE
 #define DATA_MATH_ASSOCIATIVE
 
+#include <data/math/algebra.hpp>
+
 namespace data::math {
     
     template <typename f, typename x> struct associative;
     
+    template <typename x> using associative_plus = associative<plus<x>, x>;
+    template <typename x> using associative_times = associative<times<x>, x>;
+    
 }
 
 #endif 
diff --git a/include/data/math/commutative.hpp b/include/data/math/commutative.hpp
index dce449db..c3311cc5 100644
--- a/include/data/math/commutative.hpp
+++ b/include/data/math/commutative.hpp
@@ -5,10 +5,15 @@
 #ifndef DATA_MATH_COMMUTATIVE
 #define DATA_MATH_COMMUTATIVE
 
+#include <data/math/algebra.hpp>
+
 namespace data::math {
     
     template <typename f, typename x> struct commutative;
     
+    template <typename x> using commutative_plus = commutative<plus<x>, x>;
+    template <typename x> using commutative_times = commutative<times<x>, x>;
+    
 }
 
 #endif 
diff --git a/include/data/math/field.hpp b/include/data/math/field.hpp
index fc9dc78b..5403b36b 100644
--- a/include/data/math/field.hpp
+++ b/include/data/math/field.hpp
@@ -12,10 +12,12 @@
 namespace data::math {
     
     template <typename elem, typename plus = math::plus<elem>, typename times = math::times<elem>>
-    concept field = math::ring<elem, plus, times> && abelian<elem, plus> && 
-    requires (const elem &a, const math::nonzero<elem> &b) {
+    concept field = integral_domain<elem, plus, times> &&
+    requires (const elem &a, const elem &b) {
         {a / b} -> std::same_as<elem>;
-    } && math::abelian<math::nonzero<elem>, times>;
+    } && requires (const nonzero<elem> &a, const nonzero<elem> &b) {
+        {inverse<times, elem> {} (a, b)} -> std::convertible_to<nonzero<elem>>;
+    };
     
 }
 
diff --git a/include/data/math/fraction.hpp b/include/data/math/fraction.hpp
index 73e6f8a7..bb5840ab 100644
--- a/include/data/math/fraction.hpp
+++ b/include/data/math/fraction.hpp
@@ -20,6 +20,54 @@ namespace data::math {
     template <typename Z, typename N>
     std::weak_ordering operator <=> (const fraction<Z, N> &, const fraction<Z, N> &);
 
+    template <typename Z> fraction<Z> operator - (const fraction<Z> &);
+    template <typename Z> fraction<Z> operator + (const fraction<Z> &, const fraction<Z> &);
+    template <typename Z> fraction<Z> operator - (const fraction<Z> &, const fraction<Z> &);
+    template <typename Z> fraction<Z> operator * (const fraction<Z> &, const fraction<Z> &);
+
+    template <typename Z, typename N>
+    struct commutative<plus<fraction<Z, N>>, fraction<Z, N>> : commutative<plus<Z>, Z> {};
+
+    template <typename Z, typename N>
+    struct associative<plus<fraction<Z, N>>, fraction<Z, N>> : associative<plus<Z>, Z> {};
+
+    template <typename Z, typename N>
+    struct commutative<times<fraction<Z, N>>, fraction<Z, N>> : commutative<times<Z>, Z> {};
+
+    template <typename Z, typename N>
+    struct associative<times<fraction<Z, N>>, fraction<Z, N>> : associative<times<Z>, Z> {};
+
+    template <typename Z, typename N>
+    struct identity<plus<fraction<Z, N>>, fraction<Z, N>> : identity<plus<Z>, Z> {
+        fraction<Z, N> operator () ();
+    };
+
+    template <typename Z, typename N>
+    struct identity<times<fraction<Z, N>>, fraction<Z, N>> : identity<times<Z>, Z> {
+        fraction<Z, N> operator () ();
+    };
+
+    template <typename Z, typename N>
+    struct inverse<plus<fraction<Z, N>>, fraction<Z, N>> : inverse<plus<Z>, Z> {
+        fraction<Z, N> operator () (const fraction<Z, N> &a, const fraction<Z, N> &b);
+    };
+
+    template <ring Z, typename N> struct inverse<plus<fraction<Z, N>>, fraction<Z, N>> : inverse<plus<Z>, Z> {
+        fraction<Z, N> operator () (const fraction<Z, N> &a, const fraction<Z, N> &b);
+    };
+
+    template <integral_domain Z> struct times<fraction<Z>> {
+        fraction<Z> operator () (const fraction<Z> &, const fraction<Z> &);
+        nonzero<fraction<Z>> operator () (const nonzero<fraction<Z>> &, const nonzero<fraction<Z>> &);
+    };
+
+    template <integral_domain Z> struct inverse<times<fraction<Z>>, fraction<Z>> {
+        nonzero<fraction<Z>> operator () (const nonzero<fraction<Z>> &);
+        nonzero<fraction<Z>> operator () (const nonzero<fraction<Z>> &, const nonzero<fraction<Z>> &);
+    };
+
+    template <integral_domain Z> fraction<Z> operator / (const fraction<Z> &, const fraction<Z> &);
+
     template <typename Z, typename N>
     std::ostream &operator << (std::ostream &o, const fraction<Z, N> &x);
     
@@ -44,6 +92,8 @@ namespace data::math {
             return number::euclidian::extended<Z, N>::algorithm (a, b).GCD;
         }
 
+    public:
+        // reduce to lowest terms.
         static fraction divide (Z n, N d) {
             if (d == 0) return fraction {Z {0}, nonzero<N> {N {0u}}}; // Invalid value.
             if (n == 0) return fraction {Z {0}, nonzero<N> {N {1u}}};
@@ -51,23 +101,17 @@ namespace data::math {
             return fraction (n / Z (gcd_ab), nonzero (d / gcd_ab));
         }
 
-    public:
         fraction ();
-        fraction (Z n);
-        fraction (Z n, N d);
+
+        template <typename ZZ> fraction (ZZ n);
+
+        template <typename ZZ, typename NN> fraction (ZZ n, NN d);
         
         bool operator == (const Z &z) const;
-        
-        static maybe<fraction> inverse (const fraction &f);
-        
-        fraction operator - () const;
-        fraction operator + (const fraction &f) const;
+
         fraction operator + (const Z &z) const;
-        fraction operator - (const fraction &f) const;
         fraction operator - (const Z &z) const;
-        fraction operator * (const fraction &f) const;
         fraction operator * (const Z &z) const;
-        fraction operator / (const nonzero<fraction> &f) const;
         fraction operator / (const Z &z) const;
         
         fraction &operator += (const fraction &f);
@@ -75,39 +119,15 @@ namespace data::math {
         fraction &operator *= (const fraction &f);
         fraction &operator /= (const fraction &f);
 
+        friend class inverse<times<fraction<Z>>, fraction<Z>>;
+
     };
 
     template <typename Z, typename N>
     std::ostream inline &operator << (std::ostream &o, const fraction<Z, N> &x) {
-        return o << "fraction {" << x.Numerator << ", " << x.Denominator.Value << "}";
+        if (x.Denominator.Value == 1) return o << x.Numerator;
+        return o << "(" << x.Numerator << " / " << x.Denominator.Value << ")";
     }
-    
-    template <typename Z, typename N> 
-    struct commutative<plus<fraction<Z, N>>, fraction<Z, N>> : commutative<plus<Z>, Z> {};
-    
-    template <typename Z, typename N> 
-    struct associative<plus<fraction<Z, N>>, fraction<Z, N>> : associative<plus<Z>, Z> {};
-    
-    template <typename Z, typename N> 
-    struct commutative<times<fraction<Z, N>>, fraction<Z, N>> : commutative<times<Z>, Z> {};
-    
-    template <typename Z, typename N> 
-    struct associative<times<fraction<Z, N>>, fraction<Z, N>> : associative<times<Z>, Z> {};
-    
-    template <typename Z, typename N> 
-    struct identity<plus<fraction<Z, N>>, fraction<Z, N>> : identity<plus<Z>, Z> {
-        fraction<Z, N> operator () ();
-    };
-    
-    template <typename Z, typename N> 
-    struct identity<times<fraction<Z, N>>, fraction<Z, N>> : identity<times<Z>, Z> {
-        fraction<Z, N> operator () ();
-    };
-    
-    template <typename Z, typename N> 
-    struct inverse<plus<fraction<Z, N>>, fraction<Z, N>> : inverse<plus<Z>, Z> {
-        fraction<Z, N> operator () (const fraction<Z, N> &a, const fraction<Z, N> &b);
-    };
 
     template <typename Z, typename N>
     struct abs<fraction<Z, N>> {
@@ -123,10 +143,17 @@ namespace data::math {
     inline fraction<Z, N>::fraction () : Numerator {0}, Denominator {1u} {}
 
     template <typename Z, typename N>
-    inline fraction<Z, N>::fraction (Z n, N d) : fraction (divide (n, d)) {}
+    template <typename ZZ, typename NN>
+    inline fraction<Z, N>::fraction (ZZ n, NN d) : fraction (divide (Z (n), N (d))) {}
 
     template <typename Z, typename N>
-    inline fraction<Z, N>::fraction (Z n) : Numerator {n}, Denominator {uint64 {1}} {}
+    template <typename ZZ>
+    inline fraction<Z, N>::fraction (ZZ n) : Numerator {Z (n)}, Denominator {1u} {}
+
+    template <typename Z, typename N>
+    bool inline operator == (const fraction<Z, N> &a, const fraction<Z, N> &b) {
+        return a <=> b == 0;
+    }
 
     template <typename Z, typename N>
     std::weak_ordering inline operator <=> (const fraction<Z, N> &a, const fraction<Z, N> &b) {
@@ -134,58 +161,61 @@ namespace data::math {
     }
 
     template <typename Z, typename N>
-    bool inline operator == (const fraction<Z, N> &a, const fraction<Z, N> &b) {
-        return a <=> b == 0;
+    bool inline fraction<Z, N>::operator == (const Z &z) const {
+        return *this == fraction {z};
     }
 
-    template <typename Z, typename N>
-    maybe<fraction<Z, N>> inline fraction<Z, N>::inverse (const fraction &f) {
-        if (f == 0) return nullptr;
-        return std::make_shared<fraction> (
-            fraction {Z {f.Denominator} * data::sign (f.Numerator), nonzero {data::abs (f.Numerator)}});
+    template <typename Z>
+    fraction<Z> inline operator - (const fraction<Z> &x) {
+        auto z = x;
+        z.Numerator = -z.Numerator;
+        return z;
     }
 
-    template <typename Z, typename N>
-    fraction<Z, N> inline fraction<Z, N>::operator - () const {
-        return {-Numerator, Denominator};
+    template <typename Z>
+    fraction<Z> inline operator + (const fraction<Z> &a, const fraction<Z> &b) {
+        return fraction<Z>::divide (b.Numerator * a.Denominator.Value + a.Numerator * b.Denominator.Value,
+            a.Denominator.Value * b.Denominator.Value);
     }
 
-    template <typename Z, typename N>
-    fraction<Z, N> inline fraction<Z, N>::operator + (const fraction &f) const {
-        return divide (f.Numerator * Denominator.Value + Numerator * f.Denominator.Value,
-            Denominator.Value * f.Denominator.Value);
+    template <typename Z>
+    fraction<Z> inline operator - (const fraction<Z> &a, const fraction<Z> &b) {
+        return a + (-b);
     }
 
-    template <typename Z, typename N>
-    fraction<Z, N> inline fraction<Z, N>::operator + (const Z &z) const {
-        return operator + (fraction {z});
+    template <typename Z>
+    fraction<Z> inline operator * (const fraction<Z> &a, const fraction<Z> &b) {
+        return fraction<Z> {a.Numerator * b.Numerator, a.Denominator.Value * b.Denominator.Value};
     }
 
-    template <typename Z, typename N>
-    fraction<Z, N> inline fraction<Z, N>::operator - (const fraction &f) const {
-        return (*this) + (-f);
+    template <integral_domain Z>
+    nonzero<fraction<Z>> inverse<times<fraction<Z>>, fraction<Z>>::operator () (const nonzero<fraction<Z>> &x) {
+        if (x.Value.Numerator == 0) throw division_by_zero {};
+        return nonzero {fraction<Z> {Z (x.Value.Denominator) * data::sign (x.Value.Numerator), nonzero {data::abs (x.Value.Numerator)}}};
     }
 
-    template <typename Z, typename N>
-    fraction<Z, N> fraction<Z, N>::operator - (const Z &z) const {
-        return operator - (fraction {z});
+    template <integral_domain Z>
+    nonzero<fraction<Z>> inverse<times<fraction<Z>>, fraction<Z>>::operator () (const nonzero<fraction<Z>> &a, const nonzero<fraction<Z>> &b) {
+        return nonzero {b.Value / a.Value};
+    }
+
+    template <integral_domain Z> fraction<Z> operator / (const fraction<Z> &a, const fraction<Z> &b) {
+        return a * inverse<times<fraction<Z>>, fraction<Z>> {} (nonzero {b}).Value;
     }
 
     template <typename Z, typename N>
-    fraction<Z, N> inline fraction<Z, N>::operator * (const fraction &f) const {
-        return fraction {Numerator * f.Numerator, Denominator * f.Denominator};
+    fraction<Z, N> inline fraction<Z, N>::operator + (const Z &z) const {
+        return operator + (fraction {z});
     }
 
     template <typename Z, typename N>
-    fraction<Z, N> inline fraction<Z, N>::operator * (const Z &z) const {
-        return *this * fraction {z};
+    fraction<Z, N> fraction<Z, N>::operator - (const Z &z) const {
+        return operator - (fraction {z});
     }
 
     template <typename Z, typename N>
-    fraction<Z, N> inline fraction<Z, N>::operator / (const nonzero<fraction> &f) const {
-        auto ii = inverse (f);
-        if (!bool (ii)) throw division_by_zero {};
-        return (*this) * *ii;
+    fraction<Z, N> inline fraction<Z, N>::operator * (const Z &z) const {
+        return *this * fraction {z};
     }
 
     template <typename Z, typename N>
diff --git a/include/data/math/nonnegative.hpp b/include/data/math/nonnegative.hpp
index 4c7a842d..11be91ac 100644
--- a/include/data/math/nonnegative.hpp
+++ b/include/data/math/nonnegative.hpp
@@ -10,140 +10,111 @@
 
 namespace data::math {
     
+    template <ordered R> struct nonnegative;
+    template <typename R> struct nonzero;
+
+    template <typename R> bool operator <=> (const nonnegative<R> &, const nonnegative<R> &);
+    template <typename R> bool operator <=> (const nonzero<R> &, const nonzero<R> &);
+
+    template <typename R> nonnegative<R> operator + (const nonnegative<R> &m, const nonnegative<R> &n);
+    template <typename R> nonnegative<R> operator * (const nonnegative<R> &m, const nonnegative<R> &n);
+
+    template <typename R> nonzero<R> operator * (const nonzero<R> &m, const nonzero<R> &n);
+
     template <ordered R> struct nonnegative {
         R Value;
         
-        explicit nonnegative(const R& n) : Value{n} {}
-        explicit nonnegative(R&& n) : Value{n} {}
-        nonnegative() : Value{-1} {}
+        explicit nonnegative (const R& n) : Value {n} {}
+        explicit nonnegative (R &&n) : Value {n} {}
+        nonnegative () : Value {-1} {}
         
-        bool valid() {
-            return data::valid(Value) && Value >= R(0);
+        bool valid () {
+            return data::valid (Value) && Value >= R (0);
         }
         
-        operator R() const {
+        operator R () const {
             return Value;
         }
+
+        nonnegative &operator = (const R &n) {
+            Value = n;
+            return *this;
+        }
+
+        nonnegative &operator = (R &&n) {
+            Value = n;
+            return *this;
+        }
         
-        nonnegative& operator++();
-        nonnegative operator++(int);
+        nonnegative &operator ++ ();
+        nonnegative operator ++ (int);
     };
     
     template <typename R> struct nonzero {
         R Value;
         
-        explicit nonzero(const R &n) : Value{n} {}
-        explicit nonzero(R &&n) : Value{n} {}
-        nonzero() : Value{0} {}
+        explicit nonzero (const R &n) : Value {n} {}
+        explicit nonzero (R &&n) : Value {n} {}
+        nonzero () : Value {0} {}
         
-        bool valid() const {
-            return data::valid(Value) && Value != R(0);
+        bool valid () const {
+            return data::valid (Value) && Value != R (0);
         }
         
-        operator R() const {
+        operator R () const {
             return Value;
         }
         
-        nonzero& operator=(const R &n) {
+        nonzero &operator = (const R &n) {
             Value = n;
             return *this;
         }
         
-        nonzero& operator=(R &&n) {
+        nonzero &operator = (R &&n) {
             Value = n;
             return *this;
         }
     };
     
     template <typename R>
-    nonzero(const R &) -> nonzero<R>;
-
-    template <typename R>
-    inline nonnegative<R> operator+(const nonnegative<R>& m, const nonnegative<R>& n) {
-        return nonnegative<R>{m.Value + n.Value};
-    }
-
-    template <typename R>
-    inline nonnegative<R> operator*(const nonnegative<R>& m, const nonnegative<R>& n) {
-        return nonnegative<R>{m.Value * n.Value};
-    }
-
-    template <typename R>
-    inline bool operator==(const nonnegative<R>& m, const nonnegative<R>& n) {
-        return m.Value == n.Value;
-    }
+    nonzero (const R &) -> nonzero<R>;
 
     template <typename R>
-    inline bool operator!=(const nonnegative<R>& m, const nonnegative<R>& n) {
-        return m.Value != n.Value;
+    bool inline operator <=> (const nonnegative<R> &m, const nonnegative<R> &n) {
+        return m.Value <=> n.Value;
     }
 
     template <typename R>
-    inline bool operator>(const nonnegative<R>& m, const nonnegative<R>& n) {
-        return m.Value > n.Value;
+    bool inline operator <=> (const nonzero<R> &m, const nonzero<R> &n) {
+        return m.Value <=> n.Value;
     }
 
     template <typename R>
-    inline bool operator>=(const nonnegative<R>& m, const nonnegative<R>& n) {
-        return m.Value >= n.Value;
+    nonnegative<R> inline operator + (const nonnegative<R> &m, const nonnegative<R> &n) {
+        return nonnegative<R> {m.Value + n.Value};
     }
 
     template <typename R>
-    inline bool operator<(const nonnegative<R>& m, const nonnegative<R>& n) {
-        return m.Value < n.Value;
+    nonnegative<R> inline operator * (const nonnegative<R> &m, const nonnegative<R> &n) {
+        return nonnegative<R> {m.Value * n.Value};
     }
 
     template <typename R>
-    inline bool operator<=(const nonnegative<R>& m, const nonnegative<R>& n) {
-        return m.Value <= n.Value;
+    nonzero<R> inline operator * (const nonzero<R> &m, const nonzero<R> &n) {
+        return nonzero<R> {m.Value * n.Value};
     }
     
-    template <typename R> nonnegative<R>& nonnegative<R>::operator++() {
+    template <typename R> nonnegative<R> inline &nonnegative<R>::operator ++ () {
         ++Value;
         return *this;
     }
     
-    template <typename R> nonnegative<R> nonnegative<R>::operator++(int) {
+    template <typename R> nonnegative<R> inline nonnegative<R>::operator ++ (int) {
         nonnegative<R> n = *this;
         ++Value;
         return n;
     }
 
-    template <typename R>
-    inline nonzero<R> operator*(const nonzero<R>& m, const nonzero<R>& n) {
-        return nonzero<R>{m.Value * n.Value};
-    }
-
-    template <typename R>
-    inline bool operator==(const nonzero<R>& m, const nonzero<R>& n) {
-        return m.Value == n.Value;
-    }
-
-    template <typename R>
-    inline bool operator!=(const nonzero<R>& m, const nonzero<R>& n) {
-        return m.Value != n.Value;
-    }
-
-    template <typename R>
-    inline bool operator>(const nonzero<R>& m, const nonzero<R>& n) {
-        return m.Value > n.Value;
-    }
-
-    template <typename R>
-    inline bool operator>=(const nonzero<R>& m, const nonzero<R>& n) {
-        return m.Value >= n.Value;
-    }
-
-    template <typename R>
-    inline bool operator<(const nonzero<R>& m, const nonzero<R>& n) {
-        return m.Value < n.Value;
-    }
-
-    template <typename R>
-    inline bool operator<=(const nonzero<R>& m, const nonzero<R>& n) {
-        return m.Value <= n.Value;
-    }
-
 }
 
 #endif
diff --git a/include/data/math/number/bounded.hpp b/include/data/math/number/bounded.hpp
index 28b599b9..9a399225 100644
--- a/include/data/math/number/bounded.hpp
+++ b/include/data/math/number/bounded.hpp
@@ -12,9 +12,9 @@
 #include <data/math/number/integer.hpp>
 
 namespace data::math::number {
-    
+
     template <bool u, endian::order r, size_t x> bounded<u, r, x> inline operator / (const bounded<u, r, x> &a, const bounded<u, r, x> &b) {
-        return divide<bounded<u, r, x>> (a, b).Quotient;
+        return divide<bounded<u, r, x>> {} (a, b).Quotient;
     }
     
     template <endian::order r, size_t x> uint<r, x> inline operator / (const uint<r, x> &a, uint64 b) {
@@ -50,6 +50,26 @@ namespace data::math::number {
     }
 }
 
+namespace data::math {
+    template <endian::order r, size_t x>
+    division<uint<r, x>, uint<r, x>> inline divide<uint<r, x>, uint<r, x>>::operator () (const uint<r, x> &v, const uint<r, x> &z) {
+        auto d = divide<N_bytes<r>, N_bytes<r>> {} (v, z);
+        return {uint<r, x> {d.Quotient}, uint<r, x> {d.Remainder}};
+    }
+
+    template <endian::order r, size_t x>
+    division<sint<r, x>, uint<r, x>> inline divide<sint<r, x>, sint<r, x>>::operator () (const sint<r, x> &v, const sint<r, x> &z) {
+        auto d = divide<Z_bytes<r>, Z_bytes<r>> {} (v, z);
+        return {sint<r, x> {d.Quotient}, uint<r, x> {d.Remainder}};
+    }
+
+    template <endian::order r, size_t x>
+    division<sint<r, x>, uint<r, x>> inline divide<sint<r, x>, uint<r, x>>::operator () (const sint<r, x> &v, const uint<r, x> &z) {
+        auto d = divide<Z_bytes<r>, N_bytes<r>> {} (v, z);
+        return {sint<r, x> {d.Quotient}, uint<r, x> {d.Remainder}};
+    }
+}
+
 namespace data::encoding::hexidecimal {
 
     template <endian::order r, size_t x>
diff --git a/include/data/math/number/bounded/bounded.hpp b/include/data/math/number/bounded/bounded.hpp
index 32300a8d..7988c3d7 100644
--- a/include/data/math/number/bounded/bounded.hpp
+++ b/include/data/math/number/bounded/bounded.hpp
@@ -150,7 +150,19 @@ namespace data::math {
     
     template <endian::order r, size_t x> bool is_positive (const uint<r, x> &);
     template <endian::order r, size_t x> bool is_positive (const sint<r, x> &);
-    
+
+    template <endian::order r, size_t x> struct divide<uint<r, x>, uint<r, x>> {
+        division<uint<r, x>, uint<r, x>> operator () (const uint<r, x> &, const uint<r, x> &);
+    };
+
+    template <endian::order r, size_t x> struct divide<sint<r, x>, sint<r, x>> {
+        division<sint<r, x>, uint<r, x>> operator () (const sint<r, x> &, const sint<r, x> &);
+    };
+
+    template <endian::order r, size_t x> struct divide<sint<r, x>, uint<r, x>> {
+        division<sint<r, x>, uint<r, x>> operator () (const sint<r, x> &, const uint<r, x> &);
+    };
+
 }
 
 namespace data {
@@ -421,7 +433,6 @@ namespace data::math::number {
 
         explicit operator int64 () const;
         
-    private:
         explicit bounded (const Z_bytes<r, complement::ones> &z) {
             if (z.size () <= size) {
                 std::copy (z.words ().begin (), z.words ().end (), this->words ().begin ());
diff --git a/include/data/math/number/bytes.hpp b/include/data/math/number/bytes.hpp
index 57bfed9d..b6e08156 100644
--- a/include/data/math/number/bytes.hpp
+++ b/include/data/math/number/bytes.hpp
@@ -99,6 +99,31 @@ namespace data::math::number {
     
 }
 
+namespace data::math {
+
+
+    template <endian::order r>
+    division<N_bytes<r>, N_bytes<r>> inline divide<N_bytes<r>, N_bytes<r>>::operator () (const N_bytes<r> &v, const N_bytes<r> &z) {
+        return number::natural::divide (v, z);
+    }
+
+    template <endian::order r>
+    division<Z_bytes<r>, N_bytes<r>> inline divide<Z_bytes<r>, Z_bytes<r>>::operator () (const Z_bytes<r> &v, const Z_bytes<r> &z) {
+        return number::integer::divide (v, z);
+    }
+
+    template <endian::order r>
+    division<Z_bytes<r>, N_bytes<r>> inline divide<Z_bytes<r>, N_bytes<r>>::operator () (const Z_bytes<r> &v, const N_bytes<r> &z) {
+        return number::integer::divide (v, Z_bytes (r) (z));
+    }
+
+    template <endian::order r>
+    division<Z_bytes_twos<r>, Z_bytes_twos<r>> inline divide<Z_bytes_twos<r>, Z_bytes_twos<r>>::operator ()
+    (const Z_bytes_twos<r> &v, const Z_bytes_twos<r> &z) {
+        return number::integer::divide (v, z);
+    }
+}
+
 #include <data/encoding/digits.hpp>
 #include <data/math/number/integer.hpp>
 
diff --git a/include/data/math/number/bytes/Z.hpp b/include/data/math/number/bytes/Z.hpp
index f2124a11..6cf0041c 100644
--- a/include/data/math/number/bytes/Z.hpp
+++ b/include/data/math/number/bytes/Z.hpp
@@ -435,6 +435,18 @@ namespace data::math {
         std::copy (z.begin (), z.end (), n.begin ());
         return n;
     }
+
+    template <endian::order r, number::complement zz>
+    number::Z_bytes<r, zz> inline times<number::Z_bytes<r, zz>>::operator ()
+    (const number::Z_bytes<r, zz> &a, const number::Z_bytes<r, zz> &b) {
+        return a * b;
+    }
+
+    template <endian::order r, number::complement zz>
+    nonzero<number::Z_bytes<r, zz>> inline times<number::Z_bytes<r, zz>>::operator ()
+    (const nonzero<number::Z_bytes<r, zz>> &a, const nonzero<number::Z_bytes<r, zz>> &b) {
+        return a * b;
+    }
     
     template <endian::order r> N_bytes<r> inline quadrance<N_bytes<r>>::operator () (const N_bytes<r> &x) {
         return x * x;
@@ -981,8 +993,8 @@ namespace data::math::number {
     template <endian::order r> N_bytes<r>::operator N () const {
         N x {};
 
-        for (const byte &b : this->words ()) {
-            x << 8;
+        for (const byte &b : this->words ().reverse ()) {
+            x <<= 8;
             x += b;
         }
 
@@ -998,8 +1010,8 @@ namespace data::math::number {
         auto ab = data::abs (*this);
         N x {};
 
-        for (const byte &b : ab.words ()) {
-            x << 8;
+        for (const byte &b : ab.words ().reverse ()) {
+            x <<= 8;
             x += b;
         }
 
diff --git a/include/data/math/number/bytes/bytes.hpp b/include/data/math/number/bytes/bytes.hpp
index 598a1e1a..dc0ea8ea 100644
--- a/include/data/math/number/bytes/bytes.hpp
+++ b/include/data/math/number/bytes/bytes.hpp
@@ -202,6 +202,11 @@ namespace data::math {
     template <endian::order r> struct abs<number::Z_bytes<r, number::complement::ones>> {
         N_bytes<r> operator () (const number::Z_bytes<r, number::complement::ones> &);
     };
+
+    template <endian::order r, number::complement zz> struct times<number::Z_bytes<r, zz>> {
+        number::Z_bytes<r, zz> operator () (const number::Z_bytes<r, zz> &a, const number::Z_bytes<r, zz> &b);
+        nonzero<number::Z_bytes<r, zz>> operator () (const nonzero<number::Z_bytes<r, zz>> &a, const nonzero<number::Z_bytes<r, zz>> &b);
+    };
     
     template <endian::order r> struct abs<number::Z_bytes<r, number::complement::twos>> {
         number::Z_bytes<r, number::complement::twos> operator () (const number::Z_bytes<r, number::complement::twos> &);
@@ -245,6 +250,22 @@ namespace data::math {
             return b - a;
         }
     };
+
+    template <endian::order r> struct divide<N_bytes<r>, N_bytes<r>> {
+        division<N_bytes<r>, N_bytes<r>> operator () (const N_bytes<r> &, const N_bytes<r> &);
+    };
+
+    template <endian::order r> struct divide<Z_bytes<r>, Z_bytes<r>> {
+        division<Z_bytes<r>, N_bytes<r>> operator () (const Z_bytes<r> &, const Z_bytes<r> &);
+    };
+
+    template <endian::order r> struct divide<Z_bytes<r>, N_bytes<r>> {
+        division<Z_bytes<r>, N_bytes<r>> operator () (const Z_bytes<r> &, const N_bytes<r> &);
+    };
+
+    template <endian::order r> struct divide<Z_bytes_twos<r>, Z_bytes_twos<r>> {
+        division<Z_bytes_twos<r>, Z_bytes_twos<r>> operator () (const Z_bytes_twos<r> &, const Z_bytes_twos<r> &);
+    };
     
 }
 
diff --git a/include/data/math/number/gmp/N.hpp b/include/data/math/number/gmp/N.hpp
index c4c9a497..139c0395 100644
--- a/include/data/math/number/gmp/N.hpp
+++ b/include/data/math/number/gmp/N.hpp
@@ -98,7 +98,7 @@ namespace data::math::number::GMP {
     }
     
     uint64 inline operator % (const N &a, uint64 b) {
-        return uint64 (a.divide(b).Remainder);
+        return uint64 (a.divide (b).Remainder);
     }
     
     uint64 inline operator % (const Z &a, uint64 b) {
@@ -365,6 +365,14 @@ namespace data::math {
         __gmp_abs_function::eval (n.Value.MPZ, i.MPZ);
         return n;
     }
+
+    N inline times<N>::operator () (const N &a, const N &b) {
+        return a * b;
+    }
+
+    nonzero<N> inline times<N>::operator () (const nonzero<N> &a, const nonzero<N> &b) {
+        return a * b;
+    }
 }
 
 namespace data::math::number {
@@ -406,10 +414,6 @@ namespace data {
         return math::number::GMP::sign (z.Value.MPZ[0]);
     }
     
-    math::sign inline sign (const math::Z &z) {
-        return math::number::GMP::sign (z.MPZ[0]);
-    }
-    
     math::N inline square (const math::N &n) {
         return n * n;
     }
diff --git a/include/data/math/number/gmp/Z.hpp b/include/data/math/number/gmp/Z.hpp
index a58002a7..ee2f7a4f 100644
--- a/include/data/math/number/gmp/Z.hpp
+++ b/include/data/math/number/gmp/Z.hpp
@@ -147,6 +147,12 @@ namespace data::math::number::GMP {
     
 }
 
+namespace data {
+    math::sign inline sign (const math::Z &z) {
+        return math::number::GMP::sign (z.MPZ[0]);
+    }
+}
+
 namespace data::math {
     
     Z inline identity<plus<Z>, Z>::operator () () {
@@ -160,6 +166,14 @@ namespace data::math {
     Z inline inverse<plus<Z>, Z>::operator () (const Z &a, const Z &b) {
         return b - a;
     }
+
+    Z inline times<Z>::operator () (const Z &a, const Z &b) {
+        return a * b;
+    }
+
+    nonzero<Z> inline times<Z>::operator () (const nonzero<Z> &a, const nonzero<Z> &b) {
+        return a * b;
+    }
 }
 
 namespace data::encoding::hexidecimal { 
diff --git a/include/data/math/number/gmp/gmp.hpp b/include/data/math/number/gmp/gmp.hpp
index 3c8dfca5..9d608afc 100644
--- a/include/data/math/number/gmp/gmp.hpp
+++ b/include/data/math/number/gmp/gmp.hpp
@@ -8,4 +8,82 @@
 #include <data/math/number/gmp/N.hpp>
 #include <data/math/number/gmp/sqrt.hpp>
 
+namespace data::math {
+
+    division<N, N> inline divide<N, N>::operator () (const N &v, const N &z) {
+        return number::natural::divide (v, z);
+    }
+
+    division<Z, N> inline divide<Z, Z>::operator () (const Z &v, const Z &z) {
+        return number::integer::divide (v, z);
+    }
+
+    division<Z, N> inline divide<Z, N>::operator () (const Z &v, const N &z) {
+        return number::integer::divide (v, Z (z));
+    }
+
+    division<dec_uint, dec_uint> inline divide<dec_uint, dec_uint>::operator () (const dec_uint &v, const dec_uint &z) {
+        auto d = divide<N> {} (N (v), N (z));
+        return {encoding::decimal::write (d.Quotient), encoding::decimal::write (d.Remainder)};
+    }
+
+    division<dec_int, dec_uint> inline divide<dec_int, dec_uint>::operator () (const dec_int &v, const dec_uint &z) {
+        auto d = divide<Z, N> {} (Z (v), N (z));
+        return {encoding::signed_decimal::write (d.Quotient), encoding::decimal::write (d.Remainder)};
+    }
+
+    division<dec_int, dec_uint> inline divide<dec_int, dec_int>::operator () (const dec_int &v, const dec_int &z) {
+        auto d = divide<Z, Z> {} (Z (v), Z (z));
+        return {encoding::signed_decimal::write (d.Quotient), encoding::decimal::write (d.Remainder)};
+    }
+
+    template <hex_case zz>
+    division<hex::uint<zz>, hex::uint<zz>> divide<hex::uint<zz>, hex::uint<zz>>::operator () (const hex::uint<zz> &v, const hex::uint<zz> &z) {
+        auto d = divide<N> {} (N (v), N (z));
+        return {encoding::hexidecimal::write<zz> (d.Quotient), encoding::hexidecimal::write<zz> (d.Remainder)};
+    }
+
+    template <hex_case zz>
+    division<hex::int1<zz>, hex::uint<zz>> divide<hex::int1<zz>, hex::int1<zz>>::operator () (const hex::int1<zz> &v, const hex::int1<zz> &z) {
+        auto d = divide<Z, N> {} (Z (v), N (z));
+        return {encoding::hexidecimal::write<number::complement::ones, zz> (d.Quotient), encoding::hexidecimal::write<zz> (d.Remainder)};
+    }
+
+    template <hex_case zz>
+    division<hex::int1<zz>, hex::uint<zz>> divide<hex::int1<zz>, hex::uint<zz>>::operator () (const hex::int1<zz> &v, const hex::uint<zz> &z) {
+        auto d = divide<Z, N> {} (Z (v), N (z));
+        return {encoding::hexidecimal::write<number::complement::ones, zz> (d.Quotient), encoding::hexidecimal::write<zz> (d.Remainder)};
+    }
+
+    template <hex_case zz>
+    division<hex::int2<zz>, hex::int2<zz>> divide<hex::int2<zz>, hex::int2<zz>>::operator () (const hex::int2<zz> &v, const hex::int2<zz> &z) {
+        auto d = divide<Z, Z> {} (Z (v), Z (z));
+        return {encoding::hexidecimal::write<number::complement::twos, zz> (d.Quotient),
+            encoding::hexidecimal::write<number::complement::twos, zz> (d.Remainder)};
+    }
+}
+
+namespace data::encoding::decimal {
+    inline string::operator math::N () const {
+        return math::N::read (*this);
+    }
+}
+
+namespace data::encoding::signed_decimal {
+    inline string::operator math::Z () const {
+        return math::Z::read (*this);
+    }
+}
+
+namespace data::encoding::hexidecimal {
+
+    template <complement c, hex::letter_case cx> inline complemented_string<c, cx>::operator math::Z () const {
+        return math::Z (math::Z_bytes_twos<endian::big>::read (*this));
+    }
+
+    template <hex::letter_case cx> inline complemented_string<complement::nones, cx>::operator math::N () const {
+        return math::N::read (*this);
+    }
+}
+
 #endif 
diff --git a/include/data/math/number/gmp/mpz.hpp b/include/data/math/number/gmp/mpz.hpp
index b6156965..402a3491 100644
--- a/include/data/math/number/gmp/mpz.hpp
+++ b/include/data/math/number/gmp/mpz.hpp
@@ -166,6 +166,16 @@ namespace data::math {
     template <> struct abs<Z> { 
         N operator () (const Z &);
     };
+
+    template <> struct times<N> {
+        N operator () (const N &a, const N &b);
+        nonzero<N> operator () (const nonzero<N> &a, const nonzero<N> &b);
+    };
+
+    template <> struct times<Z> {
+        Z operator () (const Z &a, const Z &b);
+        nonzero<Z> operator () (const nonzero<Z> &a, const nonzero<Z> &b);
+    };
     
     template <> struct commutative<plus<N>, N> {};
     template <> struct associative<plus<N>, N> {};
@@ -196,6 +206,22 @@ namespace data::math {
     template <> struct inverse<plus<Z>, Z> {
         Z operator () (const Z &a, const Z &b);
     };
+
+    template <> struct inverse<times<Z>, Z> {
+        nonzero<Z> operator () (const nonzero<Z> &a, const nonzero<Z> &b);
+    };
+
+    template <> struct divide<N, N> {
+        division<N, N> operator () (const N &, const N &);
+    };
+
+    template <> struct divide<Z, Z> {
+        division<Z, N> operator () (const Z &, const Z &);
+    };
+
+    template <> struct divide<Z, N> {
+        division<Z, N> operator () (const Z &, const N &);
+    };
     
     bool is_zero (const N&);
     bool is_zero (const Z&);
@@ -237,7 +263,7 @@ namespace data::encoding::hexidecimal {
     template <complement, hex_case> struct integer;
     
     template <hex_case zz> integer<complement::nones, zz> write (const math::N&);
-    template <complement n, hex_case zz> integer<n, zz> write(const math::Z&);
+    template <complement n, hex_case zz> integer<n, zz> write (const math::Z&);
     
     std::ostream &write (std::ostream &, const math::N &, hex_case = hex_case::lower);
     std::ostream &write (std::ostream &, const math::Z &, hex_case = hex_case::lower, complement = complement::ones);
diff --git a/include/data/math/polynomial.hpp b/include/data/math/polynomial.hpp
index a76fa4bb..10e1c820 100644
--- a/include/data/math/polynomial.hpp
+++ b/include/data/math/polynomial.hpp
@@ -9,114 +9,168 @@
 #include <data/math/division.hpp>
 #include <data/math/arithmetic.hpp>
 #include <data/math/power.hpp>
+#include <data/math/field.hpp>
 
 namespace data::math {
 
-    template <typename A, typename N, char x> struct polynomial;
+    template <ring A, typename N, char x> struct polynomial;
+
+    template <ring A, typename N, char x>
+    bool operator == (const polynomial<A, N, x>, const polynomial<A, N, x>);
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> operator - (const polynomial<A, N, x>);
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> operator + (const polynomial<A, N, x>, const polynomial<A, N, x>);
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> operator - (const polynomial<A, N, x>, const polynomial<A, N, x>);
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> operator * (const polynomial<A, N, x>, const polynomial<A, N, x>);
+
+    // the other operations work if A is a ring, but for division we need A to be a field.
+    template <field A, typename N, char x>
+    struct divide<polynomial<A, N, x>> {
+        division<polynomial<A, N, x>> operator () (const polynomial<A, N, x>, const nonzero<polynomial<A, N, x>>);
+    };
 
     template <typename A, typename N, char x>
     std::ostream &operator << (std::ostream &o, const polynomial<A, N, x> &p);
 
+    template <typename A, typename N, char x>
+    struct commutative<plus<polynomial<A, N, x>>, polynomial<A, N, x>> : commutative_plus<A> {};
+
+    template <typename A, typename N, char x>
+    struct associative<plus<polynomial<A, N, x>>, polynomial<A, N, x>> : associative_plus<A> {};
+
+    template <typename A, typename N, char x>
+    struct commutative<times<polynomial<A, N, x>>, polynomial<A, N, x>> : commutative_times<A>{};
+
+    template <typename A, typename N, char x>
+    struct associative<times<polynomial<A, N, x>>, polynomial<A, N, x>> : associative_times<A> {};
+
+    template <typename A, typename N, char x>
+    struct identity<plus<polynomial<A, N, x>>, polynomial<A, N, x>> : identity<plus<A>, A> {
+        polynomial<A, N, x> operator () ();
+    };
+
+    template <typename A, typename N, char x>
+    struct identity<times<polynomial<A, N, x>>, polynomial<A, N, x>> : identity<times<A>, A> {
+        polynomial<A, N, x> operator () ();
+    };
+
     template <char name> struct variable {};
 
     template <char name>
-    std::ostream inline &operator << (std::ostream &o, const variable<name> &x) {
-        return o << name;
-    }
-    
-    template <typename A, typename N, char x>
+    bool operator == (variable<name>, variable<name>);
+
+    template <char name>
+    std::ostream &operator << (std::ostream &o, const variable<name> &x);
+
+    template <ring A, typename N, char x>
     struct polynomial {
-        struct term {
-            A Coefficient;
-            power<variable<x>, N> Power;
-            
-            term (A, N);
-            
-            bool operator == (const term &) const;
-            bool operator == (const A &) const;
-            
-            bool operator != (const term &) const;
-            bool operator != (const A &) const;
-            
-            A operator () (const A) const;
-            polynomial operator () (const polynomial) const;
-            
-            term operator * (const term &) const;
-            term operator * (const A) const;
-            polynomial operator * (const polynomial) const;
-        };
         
         polynomial ();
         polynomial (const A a);
-        polynomial (const term t);
-        
-        constexpr static polynomial unit ();
+
+        bool valid () const;
         
         constexpr static polynomial zero ();
+        constexpr static polynomial unit ();
+        constexpr static polynomial var ();
         
         uint32 degree () const;
         
         static bool equal (const polynomial, const polynomial);
-        
-        bool operator == (const polynomial) const;
-        bool operator != (const polynomial) const;
-        
-        static polynomial plus (const polynomial, const term);
-        static polynomial plus (const polynomial, const A);
+        static polynomial negative (const polynomial);
         static polynomial plus (const polynomial, const polynomial);
+        static polynomial minus (const polynomial, const polynomial);
+        static polynomial times (const polynomial, const polynomial);
+        static polynomial pow (const polynomial, const N &);
+        
+        bool operator == (const A &) const;
         
-        polynomial operator + (const term) const;
         polynomial operator + (const A) const;
-        polynomial operator + (const polynomial &) const;
         
-        polynomial operator += (const term);
         polynomial operator += (const A);
         polynomial operator += (const polynomial &);
         
         polynomial operator * (const A) const;
-        polynomial operator * (const term) const;
-        polynomial operator * (const polynomial) const;
-        
-        polynomial operator ^ (const N) const;
         
+        polynomial operator *= (const A) const;
+        polynomial operator *= (const polynomial) const;
+
         polynomial operator () (const A) const;
         polynomial operator () (const polynomial) const;
-        
-        bool operator == (const polynomial &);
-        
-        bool operator != (const polynomial &);
-        
-        division<polynomial> divide (const polynomial Dividend, const polynomial Divisor);
-        
-        division<polynomial> operator / (const polynomial) const;
-        
-        polynomial derivative () const;
+
+        polynomial operator ^ (const N &n) const;
         
         bool operator > (const polynomial) const;
         bool operator < (const polynomial) const;
         bool operator <= (const polynomial) const;
         bool operator >= (const polynomial) const;
-        
-        template <typename ... P>
-        static polynomial make (P... rest);
+
+        polynomial derivative () const;
+
+        static division<polynomial> divide (const polynomial, const polynomial);
         
     private:
-        // for ordering terms in the polynomial by power. 
-        struct ordering {
-            term Term;
+        // remove any terms that are equal to zero.
+        polynomial normalize () const;
+
+        using power = math::power<variable<x>, N>;
+
+        // a term in a polynomial is the part like A (x ^ N).
+        struct term {
+            A Coefficient;
+            power Power;
             
-            ordering (term t);
+            explicit term () : Coefficient {0}, Power {{}, 1} {}
+            explicit term (A, const N &n);
+
+            // cannot have 0 ^ 0.
+            bool valid () const {
+                return Coefficient != 0 || Power.Exponent != 0u;
+            }
+            
+            bool operator == (const term &) const;
+            bool operator == (const A &) const;
+            
+            A operator () (const A) const;
+            polynomial operator () (const polynomial) const;
             
-            bool operator == (const ordering &) const;
-            bool operator > (const ordering &) const;
-            bool operator < (const ordering &) const;
-            bool operator <= (const ordering &) const;
-            bool operator >= (const ordering &) const;
+            term operator - () const {
+                return term {-Coefficient, Power.Exponent};
+            }
+
+            term operator * (const term &) const;
+            term operator * (const A) const;
+            polynomial operator * (const polynomial) const;
             
-            division<ordering> operator / (const ordering &) const;
+            // used for ordering terms so the fact that one term < another
+            // does not mean that it is actually numerically bigger.
+            std::weak_ordering operator <=> (const term &o) const {
+                return Coefficient == 0 && o.Coefficient == 0 || Power.Exponent == 0u && o.Power.Exponent == 0u ? std::weak_ordering::equivalent :
+                    Power.Exponent == o.Power.Exponent ? Coefficient <=> o.Coefficient : o.Power.Exponent <=> Power.Exponent;
+            } 
+
+            term derivative () const {
+                if (Power.Exponent == 0) return term {};
+                return term {Coefficient * Power.Exponent, Power.Exponent - 1};
+            }
         };
         
-        using terms = ordered_list<ordering>;
+        polynomial (const term t);
+        
+        polynomial operator + (const term t) const;
+        
+        polynomial operator += (const term t);
+        
+        polynomial operator * (const term t) const;
+        
+        using terms = ordered_list<term>;
         
         terms Terms;
         
@@ -124,49 +178,39 @@ namespace data::math {
         
         polynomial rest () const;
         
-        polynomial (const terms l);
-        polynomial (const list<term> l);
-        
-        friend std::ostream &operator << <A, N> (std::ostream &, const polynomial &);
+        friend std::ostream &operator << <A, N, x> (std::ostream &, const polynomial &);
         
         polynomial insert (const term) const;
         polynomial insert (const terms) const;
-        polynomial insert (const polynomial p) const;
         
-        static polynomial build (const polynomial p);
-        
-        template <typename ... P>
-        static polynomial build (const polynomial p, const A, P... rest);
-        
-        template <typename ... P>
-        static polynomial build (const polynomial p, const term, P... rest);
+        explicit polynomial (const terms t, void*) : Terms {t} {}
     };
-
-    template <typename A, typename N, char x>
-    struct commutative<plus<polynomial<A, N, x>>, polynomial<A, N, x>> : commutative<plus<A>, A> {};
-    
-    template <typename A, typename N, char x>
-    struct associative<plus<polynomial<A, N, x>>, polynomial<A, N, x>> : associative<plus<A>, A> {};
-    
-    template <typename A, typename N, char x>
-    struct commutative<times<polynomial<A, N, x>>, polynomial<A, N, x>> : commutative<times<A>, A>{};
-    
-    template <typename A, typename N, char x>
-    struct associative<times<polynomial<A, N, x>>, polynomial<A, N, x>> : associative<times<A>, A> {};
     
     template <typename A, typename N, char x>
-    struct identity<plus<polynomial<A, N, x>>, polynomial<A, N, x>> : identity<plus<A>, A> {
-        static const polynomial<A, N, x> value () {
-            return identity<plus<A>, A>::value ();
-        }
-    };
+    polynomial<A, N, x> inline identity<plus<polynomial<A, N, x>>, polynomial<A, N, x>>::operator () () {
+        return identity<plus<A>, A>::value ();
+    }
     
     template <typename A, typename N, char x>
-    struct identity<times<polynomial<A, N, x>>, polynomial<A, N, x>> : identity<times<A>, A> {
-        static const polynomial<A, N, x> value () {
-            return identity<times<A>, A>::value ();
-        }
-    };
+    polynomial<A, N, x> inline identity<times<polynomial<A, N, x>>, polynomial<A, N, x>>::operator () () {
+        return identity<times<A>, A>::value ();
+    }
+
+    template <char name>
+    bool inline operator == (variable<name>, variable<name>) {
+        return true;
+    }
+
+    template <char name>
+    std::ostream inline &operator << (std::ostream &o, const variable<name> &x) {
+        return o << name;
+    }
+
+    template <field A, typename N, char x>
+    division<polynomial<A, N, x>> inline divide<polynomial<A, N, x>>::operator ()
+    (const polynomial<A, N, x> a, const nonzero<polynomial<A, N, x>> b) {
+        return polynomial<A, N, x>::divide (a, b);
+    }
 
     template <typename A, typename N, char x>
     std::ostream &operator << (std::ostream &o, const polynomial<A, N, x> &p) {
@@ -174,226 +218,198 @@ namespace data::math {
         if (!p.Terms.empty ()) {
             typename polynomial<A, N, x>::terms z = p.Terms;
             while (true) {
-                typename polynomial<A, N, x>::term t = z.first ().Term;
-                o << t.Coefficient << " " << t.Power;
+                typename polynomial<A, N, x>::term t = z.first ();
+                if (t.Power.Exponent == 0) o << t.Coefficient;
+                else {
+                    if (t.Coefficient != 1) o << t.Coefficient << " ";
+                    o << t.Power;
+                }
                 z = z.rest ();
                 if (z.empty ()) break;
                 o << " + ";
             }
-        }
+        } else o << "0";
         return o << "}";
     }
-    
-    template <typename A, typename N, char x>
-    inline bool polynomial<A, N, x>::term::operator == (const term &t) const {
-        return Coefficient == t.Coefficient && Power.Exponent == t.Power.Exponent;
+
+    template <ring A, typename N, char x>
+    bool inline operator == (const polynomial<A, N, x> a, const polynomial<A, N, x> b) {
+        return polynomial<A, N, x>::equal (a, b);
     }
-    
-    template <typename A, typename N, char x>
-    inline bool polynomial<A, N, x>::term::operator == (const A &a) const {
-        return operator == (term {a, 0});
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> inline operator - (const polynomial<A, N, x> p) {
+        return polynomial<A, N, x>::negative (p);
     }
-    
-    template <typename A, typename N, char x>
-    bool inline polynomial<A, N, x>::term::operator != (const term &t) const {
-        return !operator == (t);
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> inline operator + (const polynomial<A, N, x> a, const polynomial<A, N, x> b) {
+        return polynomial<A, N, x>::plus (a, b);
     }
-    
-    template <typename A, typename N, char x>
-    bool inline polynomial<A, N, x>::term::operator != (const A &a) const {
-        return !operator == (term {a, 0});
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> inline operator - (const polynomial<A, N, x> a, const polynomial<A, N, x> b) {
+        return polynomial<A, N, x>::minus (a, b);
     }
-    
-    template <typename A, typename N, char x>
-    A inline polynomial<A, N, x>::term::operator () (const A f) const{
-        return (f ^ Power) * Coefficient;
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> inline operator * (const polynomial<A, N, x> a, const polynomial<A, N, x> b) {
+        return polynomial<A, N, x>::times (a, b);
     }
-    
-    template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::term::operator () (const polynomial p) const {
-        return (p ^ Power.Exponent) * Coefficient;
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> inline polynomial<A, N, x>::operator ^ (const N &n) const {
+        return polynomial<A, N, x>::pow (*this, n);
     }
-    
-    template <typename A, typename N, char x>
-    typename polynomial<A, N, x>::term inline polynomial<A, N, x>::term::operator * (const term &z) const {
-        return term {Coefficient * z.Coefficient, Power.Exponent + z.Power.Exponent};
+
+    template <ring A, typename N, char x>
+    polynomial<A, N, x> inline polynomial<A, N, x>::pow (const polynomial p, const N &n) {
+        return data::pow (p, n);
+        //throw 0;
     }
-    
-    template <typename A, typename N, char x>
-    typename polynomial<A, N, x>::term inline polynomial<A, N, x>::term::operator * (const A z) const {
-        return term {Coefficient * z, Power.Exponent};
+
+    template <ring A, typename N, char x>
+    bool polynomial<A, N, x>::valid () const {
+        return Terms.valid ();
     }
     
     template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::term::operator * (const polynomial p) const {
-        return polynomial {for_each ([this] (ordering o) -> term {
-            return this->operator * (o.Term);
-        }, p.Terms)};
+    bool inline polynomial<A, N, x>::term::operator == (const term &t) const {
+        return *this <=> t == 0;
     }
-
-    template <typename A, typename N, char x>
-    inline polynomial<A, N, x>::term::term (A a, N p) : Coefficient {a}, Power {variable<x> {}, p} {}
-    
-    template <typename A, typename N, char x>
-    inline polynomial<A, N, x>::ordering::ordering (term t) : Term{t} {}
     
     template <typename A, typename N, char x>
-    inline bool polynomial<A, N, x>::ordering::operator == (const ordering &o) const {
-        return Term.Power.Exponent == o.Term.Power.Exponent;
+    bool inline polynomial<A, N, x>::term::operator == (const A &a) const {
+        return operator == (term {a, 0});
     }
     
     template <typename A, typename N, char x>
-    inline bool polynomial<A, N, x>::ordering::operator > (const ordering &o) const {
-        return Term.Power.Exponent > o.Term.Power.Exponent;
+    A inline polynomial<A, N, x>::term::operator () (const A f) const{
+        return (f ^ Power) * Coefficient;
     }
     
     template <typename A, typename N, char x>
-    inline bool polynomial<A, N, x>::ordering::operator < (const ordering &o) const {
-        return Term.Power.Exponent < o.Term.Power.Exponent;
+    polynomial<A, N, x> inline polynomial<A, N, x>::term::operator () (const polynomial p) const {
+        return (p ^ Power.Exponent) * Coefficient;
     }
     
     template <typename A, typename N, char x>
-    inline bool polynomial<A, N, x>::ordering::operator <= (const ordering &o) const {
-        return Term.Power.Exponent <= o.Term.Power.Exponent;
+    typename polynomial<A, N, x>::term inline polynomial<A, N, x>::term::operator * (const term &t) const {
+        return term {Coefficient * t.Coefficient, Power.Exponent + t.Power.Exponent};
     }
-    
+
     template <typename A, typename N, char x>
-    inline bool polynomial<A, N, x>::ordering::operator >= (const ordering &o) const {
-        return Term.Power.Exponent >= o.Term.Power.Exponent;
+    typename polynomial<A, N, x>::term inline polynomial<A, N, x>::term::operator * (const A a) const {
+        return term {Coefficient * a, Power.Exponent};
     }
     
     template <typename A, typename N, char x>
-    division<typename polynomial<A, N, x>::ordering>
-    polynomial<A, N, x>::ordering::operator / (const ordering &o) const {
-        if (o.Term == 0) throw division_by_zero {};
-        if (Term.Power < o.Term.Power) return division<polynomial> {*this, o};
-        return division<ordering> {
-            ordering {term {
-                Term.Coefficient / o.Term.Coefficient, 
-                Term.Power - o.Term.Power}}, 
-            ordering {0}};
+    polynomial<A, N, x> inline polynomial<A, N, x>::term::operator * (const polynomial p) const {
+        return fold ([this] (const polynomial &p, const term &t) -> polynomial {
+            return p + (*this * t);
+        }, polynomial {}, reverse (p.Terms));
     }
-    
-    template <typename A, typename N, char x>
-    inline polynomial<A, N, x>::polynomial (const terms l) : Terms {l} {}
-    
+
     template <typename A, typename N, char x>
-    polynomial<A, N, x>::polynomial (const list<term> l) : Terms {} {
-        list<term> t = l;
-        while (!t.empty ()) {
-            operator += (t.first ());
-            t = t.rest ();
-        }
-    }
+    inline polynomial<A, N, x>::term::term (A a, const N& n) : Coefficient {a}, Power {{}, n} {}
     
     template <typename A, typename N, char x>
     inline polynomial<A, N, x>::polynomial () : Terms {} {}
     
     template <typename A, typename N, char x>
-    inline polynomial<A, N, x>::polynomial (const A a) : Terms {terms {}.insert (ordering {term {a, 0}})} {}
+    inline polynomial<A, N, x>::polynomial (const A a) : Terms {terms {}.insert (term {a, 0})} {}
     
     template <typename A, typename N, char x>
-    inline polynomial<A, N, x>::polynomial (const term t) : Terms {terms {}.insert (ordering {t})} {}
+    inline polynomial<A, N, x>::polynomial (const term t) : Terms {terms {}.insert (t)} {}
     
     template <typename A, typename N, char x>
     typename polynomial<A, N, x>::term inline polynomial<A, N, x>::first () const {
-        return Terms.first ().Term;
+        return Terms.first ();
     }
     
     template <typename A, typename N, char x>
     polynomial<A, N, x> inline polynomial<A, N, x>::rest () const {
-        return Terms.rest ();
+        return polynomial {Terms.rest (), nullptr};
     }
     
     template <typename A, typename N, char x>
     constexpr polynomial<A, N, x> inline polynomial<A, N, x>::unit () {
-        return polynomial {term {A {1}, N {0}}};
+        return polynomial {term {A {1}, 0}};
     } 
     
     template <typename A, typename N, char x>
     constexpr polynomial<A, N, x> inline polynomial<A, N, x>::zero () {
-        return polynomial {term {A {0}, N {0}}};
+        return polynomial {term {A {0}, 0}};
     }
     
     template <typename A, typename N, char x>
-    uint32 inline polynomial<A, N, x>::degree () const {
-        if (Terms.empty ()) return 0;
-        return Terms.first ().Term.Power.Exponent;
+    constexpr polynomial<A, N, x> inline polynomial<A, N, x>::var () {
+        return polynomial (term {A (1), 1});
     }
     
     template <typename A, typename N, char x>
-    bool polynomial<A, N, x>::equal (const polynomial p, const polynomial q) {
-        if (p.degree () != q.degree ()) return false;
-        if (p.Terms.empty ()) return true;
-        if (p.first () != q.first ()) return false;
-        return equal (p.rest (), q.rest ());
+    uint32 inline polynomial<A, N, x>::degree () const {
+        auto p = normalize ();
+        if (p.Terms.empty ()) return 0;
+        return p.Terms.first ().Power.Exponent;
     }
     
     template <typename A, typename N, char x>
-    bool inline polynomial<A, N, x>::operator == (const polynomial p) const {
-        return equal (*this, p);
+    bool inline polynomial<A, N, x>::equal (const polynomial p, const polynomial q) {
+        return p.normalize ().Terms == q.normalize ().Terms;
     }
-    
+
     template <typename A, typename N, char x>
-    bool inline polynomial<A, N, x>::operator != (const polynomial p) const {
-        return !equal (*this, p);
+    bool inline polynomial<A, N, x>::operator == (const A &p) const {
+        return equal (*this, polynomial {p});
     }
-    
+
     template <typename A, typename N, char x>
-    polynomial<A, N, x> polynomial<A, N, x>::insert (const term z) const {
-        if (Terms.empty ()) return z;
-        if (z == term {A {0}, N {0}}) return *this;
-        ordering first = Terms.first ();
-        if (first == ordering {z})
-            return rest ().insert (term {z.Coefficient + first.Term.Coefficient, z.Power.Exponent});
-        return Terms.insert (ordering {z});
+    polynomial<A, N, x> polynomial<A, N, x>::insert (const term t) const {
+        if (t == term {}) return *this;
+        if (Terms.empty ()) return {t};
+        term first = Terms.first ();
+        if (t.Power.Exponent > first.Power.Exponent) return polynomial {Terms.insert (t), nullptr};
+        if (first.Power.Exponent == t.Power.Exponent) return rest ().insert (term {t.Coefficient + first.Coefficient, t.Power.Exponent});
+        return rest ().insert (t).insert (first);
     }
-    
+
     template <typename A, typename N, char x>
     polynomial<A, N, x> inline polynomial<A, N, x>::insert (terms t) const {
-        if (Terms.empty ()) return {t};
+        if (Terms.empty ()) return polynomial {t, nullptr};
         if (t.empty ()) return *this;
-        return insert (t.first ().Term).insert (t.rest ());
+        return polynomial {insert (t.first ()).insert (t.rest ())};
     }
     
     template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::insert (const polynomial p) const {
-        if (Terms.empty ()) return p;
-        return insert (p.Terms);
+    polynomial<A, N, x> inline polynomial<A, N, x>::operator + (const A a) const {
+        return insert (term {a, 0});
     }
     
     template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::plus (const polynomial p, const term z) {
-        return p.insert (z);
+    polynomial<A, N, x> inline polynomial<A, N, x>::plus (const polynomial a, const polynomial b) {
+        return a.insert (b.Terms).normalize ();
     }
-    
+
     template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::plus (const polynomial t, const A a) {
-        return plus (t, term {a, 0});
+    polynomial<A, N, x> inline polynomial<A, N, x>::minus (const polynomial a, const polynomial b) {
+        return a + -b;
     }
-    
+
     template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::plus (const polynomial a, const polynomial b) {
-        return a.insert (b.Terms);
+    polynomial<A, N, x> inline polynomial<A, N, x>::negative (const polynomial a) {
+        return fold ([] (const polynomial p, const term &t) -> polynomial {
+            return p + -t;
+        }, polynomial {}, reverse (a.Terms));
     }
     
     template <typename A, typename N, char x>
     polynomial<A, N, x> inline polynomial<A, N, x>::operator + (const term t) const {
-        return plus (*this, t);
+        return insert (t);
     };
     
     template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::operator + (const A a) const {
-        return plus (*this, a);
-    }
-    
-    template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::operator + (const polynomial& p) const {
-        return plus (*this, p);
-    }
-    
-    template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::operator += (const term t) {
+    inline polynomial<A, N, x> polynomial<A, N, x>::operator += (const term t) {
         return *this = *this + t;
     }
     
@@ -406,36 +422,26 @@ namespace data::math {
     polynomial<A, N, x> inline polynomial<A, N, x>::operator += (const polynomial &p) {
         return *this = *this + p;
     }
-    
+
     template <typename A, typename N, char x>
     polynomial<A, N, x> inline polynomial<A, N, x>::operator * (const A z) const {
-        return reduce<polynomial> (math::plus<polynomial> {},
-            for_each ([z] (ordering o) -> polynomial {
-                return o.Term * z;
-            }, Terms));
+        return fold ([z] (const polynomial p, const term &t) -> polynomial {
+            return p + t * z;
+        }, polynomial {}, reverse (Terms));
     }
-    
+
     template <typename A, typename N, char x>
     polynomial<A, N, x> inline polynomial<A, N, x>::operator * (const term z) const {
-        return reduce<polynomial> (math::plus<polynomial> {},
-            for_each ([z] (ordering o) -> polynomial {
-                return o.Term * z;
-            }, Terms));
+        return fold ([z] (const polynomial p, const term &t) -> polynomial {
+            return p + t * z;
+        }, polynomial {}, reverse (Terms));
     }
-    
-    template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::operator * (const polynomial p) const {
-        return reduce<polynomial> (math::plus<polynomial> {},
-            for_each ([p] (ordering o) -> polynomial {
-                return o.Term * p;
-            }, Terms));
-    }
-    
+
     template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::operator ^ (const N n) const {
-        if (n == 0) return unit ();
-        if (n == 1) return *this;
-        return operator * (*this) ^ (n - 1);
+    polynomial<A, N, x> inline polynomial<A, N, x>::times (const polynomial a, const polynomial b) {
+        return fold ([b] (const polynomial p, const term &t) -> polynomial {
+            return p + t * b;
+        }, polynomial {}, reverse (a.Terms));
     }
     
     template <typename A, typename N, char x>
@@ -447,65 +453,39 @@ namespace data::math {
     // inefficient as it computes powers repeatedly. 
     template <typename A, typename N, char x>
     polynomial<A, N, x> polynomial<A, N, x>::operator () (const polynomial p) const {
-        return reduce<polynomial> (math::plus<polynomial> {},
-            for_each ([p] (ordering o) -> polynomial {
-                return o.Term (p);
-            }, Terms));
-    }
-    
-    template <typename A, typename N, char x>
-    bool inline polynomial<A, N, x>::operator == (const polynomial &p) {
-        return equal (Terms, p.Terms);
-    }
-    
-    template <typename A, typename N, char x>
-    bool inline polynomial<A, N, x>::operator != (const polynomial &p) {
-        return !operator == (p);
+        return fold ([p] (const polynomial n, const term &t) -> polynomial {
+            return n + t (p);
+        }, polynomial {}, reverse (Terms));
     }
-    
+
     template <typename A, typename N, char x>
-    division<polynomial<A, N, x>> inline polynomial<A, N, x>::divide (const polynomial Dividend, const polynomial Divisor) {
+    division<polynomial<A, N, x>> polynomial<A, N, x>::divide (const polynomial Dividend, const polynomial Divisor) {
         if (Divisor == 0) throw division_by_zero {};
-        if (Divisor.degree () > Dividend.degree ()) return division<polynomial> {Dividend, Divisor};
-        term z = Divisor.first () / Dividend.first ();
-        return polynomial {z} + divide (Dividend - Divisor * x, Divisor);
+
+        function<division<polynomial> (const polynomial, const polynomial)> f = [&f] (const polynomial d, const polynomial s) {
+            if (s.degree () > d.degree ()) return division<polynomial> {polynomial::zero (), d};
+            auto d1 = d.first ();
+            auto s1 = s.first ();
+            term t {d1.Coefficient / s1.Coefficient, d1.Power.Exponent - s1.Power.Exponent};
+            division<polynomial<A, N, x>> div = f (d - s * t, s);
+            return division<polynomial<A, N, x>> {div.Quotient + t, div.Remainder};
+        };
+
+        return f (Dividend.normalize (), Divisor.normalize ());
     }
-    
+
     template <typename A, typename N, char x>
-    division<polynomial<A, N, x>> inline polynomial<A, N, x>::operator / (const polynomial p) const {
-        return divide (*this, p);
+    polynomial<A, N, x> polynomial<A, N, x>::normalize () const {
+        return polynomial {select (Terms, function<bool (const term &)> {[] (const term &t) -> bool {
+            return t.Coefficient != 0;
+        }}), nullptr};
     }
-    
+
     template <typename A, typename N, char x>
     polynomial<A, N, x> inline polynomial<A, N, x>::derivative () const {
-        return reduce (math::plus<polynomial> {},
-            for_each([] (ordering o)->polynomial {
-                if (o.Term.Power == 0) return zero ();
-                return polynomial {term {o.Term.Coefficient * o.Term.Power, o.Term.Power - 1}};
-            }, Terms));
-    }
-    
-    template <typename A, typename N, char x>
-    template <typename ... P>
-    polynomial<A, N, x> inline polynomial<A, N, x>::make (P... rest) {
-        return build (polynomial {}, rest...);
-    }
-    
-    template <typename A, typename N, char x>
-    polynomial<A, N, x> inline polynomial<A, N, x>::build (const polynomial p) {
-        return p;
-    }
-    
-    template <typename A, typename N, char x>
-    template <typename ... P>
-    polynomial<A, N, x> inline polynomial<A, N, x>::build (const polynomial p, const A z, P... rest) {
-        return build (p + z, rest...);
-    }
-    
-    template <typename A, typename N, char x>
-    template <typename ... P>
-    polynomial<A, N, x> inline polynomial<A, N, x>::build (const polynomial p, const term z, P... rest) {
-        return build (p + z, rest...);
+        return fold ([] (const polynomial p, const term &t) -> polynomial {
+            return p + t.derivative ();
+        }, polynomial {}, reverse (Terms)).normalize ();
     }
     
 }
diff --git a/include/data/math/power.hpp b/include/data/math/power.hpp
index d54bb58b..dea1ca82 100644
--- a/include/data/math/power.hpp
+++ b/include/data/math/power.hpp
@@ -6,6 +6,7 @@
 #define DATA_MATH_POWER
 
 #include <data/math/division.hpp>
+#include <iostream>
 
 namespace data::math {
 
@@ -21,7 +22,9 @@ namespace data::math {
 
     template <typename X, typename N>
     std::ostream inline &operator << (std::ostream &o, const power<X, N> &p) {
-        return o << p.Base << " ^ " << p.Exponent;
+        o << p.Base;
+        if (p.Exponent != 1) o << " ^ " << p.Exponent;
+        return o;
     }
 
     template <typename X, typename N>
@@ -29,19 +32,19 @@ namespace data::math {
         static X square (X x) {
             return x * x;
         }
-        
-        static X power (X so_far, X pow_2n, N p) {
-            if (p == 0) return so_far;
-            division<X> d = data::divide (p, 2);
-            return pow (d.Remainder == 1 ? so_far + pow_2n : so_far, square (pow_2n), d.Quotient);
+
+        // p is at least 2
+        static X step (X so_far, X pow_2n, N p) {
+            X next_step = p & 1 == 1 ? so_far * pow_2n : so_far;
+            N n = p >> 1;
+            if (n == 0) return next_step;
+            return step (next_step, square (pow_2n), n);
         }
         
     public:
         X operator () (X x, N n) const {
-            if (n == 0) return 1;
-            if (n == 1) return x;
-            if (n == 2) return square (x);
-            return power (0, x, n);
+            if (n == 0) return X {1};
+            return step (X {1}, x, n);
         }
     };
 
@@ -49,7 +52,7 @@ namespace data::math {
 
 namespace data {
     template <typename X, typename N> 
-    X inline pow (X x, N n) {
+    X inline pow (const X &x, const N &n) {
         return math::pow<X, N> {} (x, n);
     }
 }
diff --git a/include/data/math/ring.hpp b/include/data/math/ring.hpp
index 4dc7bebd..d0919dbe 100644
--- a/include/data/math/ring.hpp
+++ b/include/data/math/ring.hpp
@@ -16,6 +16,13 @@ namespace data::math {
     } && requires (const elem &a, elem &b) {
         {times {} (a, b)} -> std::convertible_to<elem>;
     };
+
+    template <typename elem, typename plus = plus<elem>, typename times = times<elem>>
+    concept integral_domain = ring<elem, plus, times> && requires () {
+        typename math::commutative<times, elem>;
+    } && requires (const nonzero<elem> &a, const nonzero<elem> &b) {
+        {times {} (a, b)} -> std::convertible_to<nonzero<elem>>;
+    };
     
 }
 
diff --git a/include/data/tools.hpp b/include/data/tools.hpp
index 3c7b4f0d..d8a49773 100644
--- a/include/data/tools.hpp
+++ b/include/data/tools.hpp
@@ -84,6 +84,22 @@ namespace data {
         return X.contains (k) ? X.remove (k).insert (k, v) : X;
     }
 
+    template <typename elem>
+    stack<elem> reverse (const ordered_list<elem> x) {
+        stack<elem> n;
+        for (const elem &e : x) n <<= e;
+        return n;
+    }
+
+    template <typename elem>
+    ordered_list<elem> select (const ordered_list<elem> x, function<bool (const elem &)> satisfies) {
+        stack<const elem &> n;
+        for (const elem &e : x) if (satisfies (e)) n <<= e;
+        ordered_list<elem> r;
+        for (const elem &e : n) r = r.insert (e);
+        return r;
+    }
+
 }
 
 #endif
diff --git a/src/data/encoding/base58.cpp b/src/data/encoding/base58.cpp
index d00f674c..ac753ce4 100644
--- a/src/data/encoding/base58.cpp
+++ b/src/data/encoding/base58.cpp
@@ -139,7 +139,7 @@ namespace data::encoding::base58 {
             int last = string::size () - 1;
             return math::division<string, uint64> {
                 string {std::string::substr (0, last)},
-                static_cast<uint64> (digit (std::string::operator[] (last)))};
+                static_cast<uint64> (digit (std::string::operator [] (last)))};
         }
         
         math::division<nat> div = decode<nat> (*this)->divide (nat {static_cast<uint64> (x)});
@@ -149,5 +149,5 @@ namespace data::encoding::base58 {
     string string::read (const std::string &x) {
         return encode (nat::read (x));
     }
-
 }
+
diff --git a/test/testAbs.cpp b/test/testAbs.cpp
index b80d2353..664e2b61 100644
--- a/test/testAbs.cpp
+++ b/test/testAbs.cpp
@@ -107,6 +107,8 @@ namespace data {
             int_little<11>, uint_little<11>,
             Z_bytes_little, N_bytes_little,
             Z_bytes_big, N_bytes_big,
+            Z_bytes_twos_big, Z_bytes_twos_big,
+            Z_bytes_twos_little, Z_bytes_twos_little,
             dec_int, dec_uint,
             hex_int, hex_uint,
             hex_int_twos, hex_int_twos>;
diff --git a/test/testDivision.cpp b/test/testDivision.cpp
index 8455d5f6..17647a7c 100644
--- a/test/testDivision.cpp
+++ b/test/testDivision.cpp
@@ -9,16 +9,20 @@
 namespace data {
     template <typename N>
     void test_division_natural_case (const N &numerator, const N &denominator, const N &quotient, const N &remainder) {
-        auto div = math::number::natural::divide (numerator, denominator);
-        EXPECT_EQ (div.Quotient, quotient);
-        EXPECT_EQ (div.Remainder, remainder);
+        auto div = divide (numerator, math::nonzero {denominator});
+        EXPECT_EQ (div.Quotient, quotient)
+            << "expected " << numerator << " / " << denominator << " = " << quotient << " but got " << div.Quotient;
+        EXPECT_EQ (div.Remainder, remainder)
+            << "expected " << numerator << " % " << denominator << " = " << remainder << " but got " << div.Remainder;
     }
 
     template <typename Z, typename N>
     void test_division_integer_case (const Z &numerator, const Z &denominator, const Z &quotient, const N &remainder) {
-        auto div = math::number::integer::divide (numerator, denominator);
-        EXPECT_EQ (div.Quotient, quotient);
-        EXPECT_EQ (div.Remainder, remainder);
+        auto div = divide (numerator, math::nonzero {denominator});
+        EXPECT_EQ (div.Quotient, quotient)
+            << "expected " << numerator << " / " << denominator << " = " << quotient << " but got " << div.Quotient;
+        EXPECT_EQ (div.Remainder, remainder)
+            << "expected " << numerator << " % " << denominator << " = " << remainder << " but got " << div.Remainder;
     }
 
     template <typename N>
diff --git a/test/testFraction.cpp b/test/testFraction.cpp
index 95330636..439d4ccd 100644
--- a/test/testFraction.cpp
+++ b/test/testFraction.cpp
@@ -7,43 +7,49 @@
 
 namespace data {
 
-    template <typename Q> void test_divide_by_zero () {}
+    template <typename Q> void test_divide_by_zero () {
+
+    }
+
     template <typename Q> void test_lowest_terms () {}
     template <typename Q> void test_compare () {}
     template <typename Q> void test_arithmetic () {}
 
-    template <typename Z> void test_fraction () {
-        using Q = math::fraction<Z>;
+    template <math::ring Z>
+    struct test_fraction {
+        void operator () () {
+            using Q = math::fraction<Z>;
 
-        EXPECT_TRUE (Q {0}.valid ());
-        EXPECT_TRUE (Q {1}.valid ());
-        EXPECT_TRUE (Q {-1}.valid ());
+            EXPECT_TRUE (Q {0}.valid ());
+            EXPECT_TRUE (Q {1}.valid ());
+            EXPECT_TRUE (Q {-1}.valid ());
 
-        test_divide_by_zero<Q> ();
-        test_lowest_terms<Q> ();
-        test_compare<Q> ();
-        test_arithmetic<Q> ();
-    }
+            test_divide_by_zero<Q> ();
+            test_lowest_terms<Q> ();
+            test_compare<Q> ();
+            test_arithmetic<Q> ();
+        }
+    };
 
     TEST (FractionTest, TestFraction) {
 
-        test_fraction<int64> ();
-        test_fraction<Z> ();
-        test_fraction<Z_bytes_little> ();
-        test_fraction<Z_bytes_big> ();
-        test_fraction<Z_bytes_twos_big> ();
-        test_fraction<Z_bytes_twos_little> ();
-        test_fraction<int_big<9>> ();
-        test_fraction<int_little<9>> ();
-        test_fraction<int_big<10>> ();
-        test_fraction<int_little<10>> ();
-        test_fraction<int_big<11>> ();
-        test_fraction<int_little<11>> ();
-        test_fraction<int_big<12>> ();
-        test_fraction<int_little<12>> ();
-        test_fraction<dec_int> ();
-        test_fraction<hex_int> ();
-        test_fraction<hex_int_twos> ();
+        test_fraction<int64> {} ();
+        test_fraction<Z> {} ();
+        test_fraction<Z_bytes_little> {} ();
+        test_fraction<Z_bytes_big> {} ();
+        test_fraction<Z_bytes_twos_big> {} ();
+        test_fraction<Z_bytes_twos_little> {} ();
+        test_fraction<int_big<9>> {} ();
+        test_fraction<int_little<9>> {} ();
+        test_fraction<int_big<10>> {} ();
+        test_fraction<int_little<10>> {} ();
+        test_fraction<int_big<11>> {} ();
+        test_fraction<int_little<11>> {} ();
+        test_fraction<int_big<12>> {} ();
+        test_fraction<int_little<12>> {} ();
+        test_fraction<dec_int> {} ();
+        test_fraction<hex_int> {} ();
+        test_fraction<hex_int_twos> {} ();
 
     }
 
diff --git a/test/testPolynomial.cpp b/test/testPolynomial.cpp
index 4ac1fd28..66cc8c20 100644
--- a/test/testPolynomial.cpp
+++ b/test/testPolynomial.cpp
@@ -2,30 +2,162 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "data/data.hpp"
-#include "data/math/polynomial.hpp"
-#include "data/math/number/rational.hpp"
+// note: if the ordering of these next two includes is reversed,
+// the program breaks. This is quite fragile and it is due to
+// using overloads of data::sign. This is very bad.
+#include <data/numbers.hpp>
+#include <data/math.hpp>
+
 #include "gtest/gtest.h"
 
-TEST(PolynomialTest, TestPolynomial) {
-    using namespace data;
-    
-    using polynomial = data::math::polynomial<data::math::fraction<Z, N>, uint32, 'x'>;
-    using term = polynomial::term;
-    
-    polynomial p1 = polynomial::make (Z {1}, term {Z {1}, 2});
-    polynomial p2 = polynomial::make (Z {2}, term {Z {3}, 1});
-    
-    polynomial expected_sum = polynomial::make (Z {3}, term {Z {3}, 1}, term {Z {1}, 2});
-    polynomial expected_product = polynomial::make (Z {2}, term {Z {3}, 1}, term {Z {2}, 2}, term {Z {3}, 3});
-    polynomial expected_composition = polynomial::make(Z {5}, term{Z {12}, 1}, term {Z {9}, 2});
-    
-    EXPECT_FALSE (p1 == p2);
-    EXPECT_TRUE (p1 + p2 == expected_sum);
-    EXPECT_TRUE (p1 * p2 == expected_product);
-    EXPECT_TRUE (p1(p2) == expected_composition);
-    
-    // TODO polynomial long division
+using namespace data;
+
+template <math::ring Q>
+struct test_polynomial {
+    using poly = polynomial<Q, uint32>;
+
+    poly X;
+    poly P1;
+    poly P2;
+
+    test_polynomial () :
+    X {poly::var ()},
+    P1 {(X ^ 2) + 1},
+    P2 {X * 3 + 2} {
+        EXPECT_EQ (X.degree (), 1);
+        EXPECT_EQ (P1.degree (), 2);
+        EXPECT_EQ (P2.degree (), 1);
+
+        EXPECT_FALSE (P1 == P2);
+
+        EXPECT_EQ ((X ^ 3).degree (), 3);
+
+        auto sum = P1 + P2;
+        auto product = P1 * P2;
+        auto comp_right = P1 (P2);
+        auto comp_left = P2 (P1);
+
+        auto expected_sum = (X ^ 2u) + X * 3u + 3u;
+        auto expected_product = (X ^ 3u) * 3u + (X ^ 2u) * 2u + X * 3u + 2u;
+        auto expected_comp_right = (X ^ 2u) * 9u + X * 12u + 5u;
+        auto expected_comp_left = (X ^ 2u) * 3u + 5u;
+
+        EXPECT_TRUE (sum == expected_sum);
+        EXPECT_TRUE (product == expected_product) << "expected " << P1 << " * " << P2 << " -> " << expected_product << " but got " << product;
+        EXPECT_TRUE (comp_right == expected_comp_right);
+        EXPECT_TRUE (comp_left == expected_comp_left);
+
+        poly expected_d_p1 = X * 2;
+        poly expected_d_p2 = poly {3};
+        auto expected_d_sum = X * 2 + 3;
+        auto expected_d_product = (X ^ 2u) * 9u + X * 4u + 3u;
+        auto expected_d_comp_right = X * 18u + 12;
+        auto expected_d_comp_left = X * 6u;
+
+        EXPECT_TRUE (P1.derivative () == expected_d_p1);
+        EXPECT_TRUE (P2.derivative () == expected_d_p2);
+        EXPECT_TRUE (sum.derivative () == expected_d_sum);
+        EXPECT_TRUE (product.derivative () == expected_d_product);
+        EXPECT_TRUE (comp_right.derivative () == expected_d_comp_right);
+        EXPECT_TRUE (comp_left.derivative () == expected_d_comp_left);
+
+    }
+
+    void test_polynomial_division () {
+        auto expected_quotient = X * Q {1, 3} + Q {2, 9};
+        auto expected_remainder = Q {13, 9};
+
+        auto d = math::divide<poly> {} (P1, math::nonzero {P2});
+        EXPECT_EQ (d.Quotient, expected_quotient);
+        EXPECT_EQ (d.Remainder, expected_remainder);
+    }
+};
+
+template <math::ring Z> requires math::field<fraction<Z>>
+struct test_polynomial_division : test_polynomial<Z> {
+    test_polynomial_division () : test_polynomial<Z> {} {
+        test_polynomial<Z>::test_polynomial_division ();
+    }
+};
+
+TEST (PolynomialTest, TestPolynomial) {
     
+    test_polynomial<int64> {};
+    test_polynomial<int_big<9>> {};
+    test_polynomial<int_little<9>> {};
+    test_polynomial<int_big<10>> {};
+    test_polynomial<int_little<10>> {};
+    test_polynomial<int_big<11>> {};
+    test_polynomial<int_little<11>> {};
+    test_polynomial<int_big<12>> {};
+    test_polynomial<int_little<12>> {};
+    test_polynomial<Z> {};
+
+    test_polynomial<Z_bytes_little> {};
+    test_polynomial<Z_bytes_big> {};
+    test_polynomial<Z_bytes_twos_little> {};
+    test_polynomial<Z_bytes_twos_big> {};
+    test_polynomial<dec_int> {};
+    test_polynomial<hex_int_ones> {};
+    test_polynomial<hex_int_twos> {};
+
+    test_polynomial<fraction<int64>> {};
+    test_polynomial<fraction<int_big<9>>> {};
+    test_polynomial<fraction<int_little<9>>> {};
+    test_polynomial<fraction<int_big<10>>> {};
+    test_polynomial<fraction<int_little<10>>> {};
+    test_polynomial<fraction<int_big<11>>> {};
+    test_polynomial<fraction<int_little<11>>> {};
+    test_polynomial<fraction<int_big<12>>> {};
+    test_polynomial<fraction<int_little<12>>> {};
+
+    test_polynomial_division<Q> {};
+    test_polynomial_division<Q_little> {};
+    test_polynomial_division<Q_big> {};
+    test_polynomial_division<Q_twos_little> {};
+    test_polynomial_division<Q_twos_big> {};
+    test_polynomial_division<fraction<dec_int>> {};
+    test_polynomial_division<fraction<hex_int_ones>> {};
+    test_polynomial_division<fraction<hex_int_twos>> {};
+
+    // can't get complex numbers yet for some reason.
+    // quaternions and octonions are not a field so they don't work because of that.
+    // However, they ought to work with the right concepts.
+    /*
+    test_polynomial<G> {};
+    test_polynomial<GH> {};
+    test_polynomial<GO> {};*/
+    /*
+    test_polynomial_division<QC> {};
+    test_polynomial_division<QH> {};
+    test_polynomial_division<QO> {};*/
+
+    // can't test these as fields because can't reliably subtract
+    // two numbers that ought to be equal to get zero.
+
+    // there is also a problem with using weak_ordering instead of partial_ordering.
+    // floats use partial_ordering. There ought to be a way to figure out the correct
+    // ordering.
+
+    /*test_polynomial<float64> {};
+    test_polynomial<float32> {};
+    test_polynomial<complex128> {};
+    test_polynomial<complex64> {};
+    test_polynomial<quat256> {};
+    test_polynomial<quat128> {};
+    test_polynomial<oct512> {};
+    test_polynomial<oct256> {};*/
+
+    // should be able to do finite fields eventually.
+
+/*
+    test_polynomial_division<prime_field<2>>;
+    test_polynomial_division<prime_field<3>>;
+    test_polynomial_division<prime_field<5>>;
+    test_polynomial_division<prime_field<7>>;
+    test_polynomial_division<prime_field<11>>;
+    test_polynomial_division<prime_field<13>>;
+    test_polynomial_division<prime_field<17>>;
+    test_polynomial_division<prime_field<19>>;*/
 }
 
diff --git a/test/testStringNumbers.cpp b/test/testStringNumbers.cpp
index 28e26555..63426b3d 100644
--- a/test/testStringNumbers.cpp
+++ b/test/testStringNumbers.cpp
@@ -190,4 +190,30 @@ namespace data::encoding {
         EXPECT_EQ (base58_uint {num}.divide (57),  b58_expected_57);
         
     }
+
+    TEST (StringNumbersTest, TestConvertStringNumbers) {
+        EXPECT_EQ (N (dec_uint {1145}), N (1145));
+        EXPECT_EQ (N (dec_uint {916}), N (916));
+        EXPECT_EQ (N (dec_uint {229}), N (229));
+
+        EXPECT_EQ (Z (dec_int {1145}), Z (1145));
+        EXPECT_EQ (Z (dec_int {916}), Z (916));
+        EXPECT_EQ (Z (dec_int {229}), Z (229));
+
+        EXPECT_EQ (N (base58_uint {1145}), N (1145));
+        EXPECT_EQ (N (base58_uint {916}), N (916));
+        EXPECT_EQ (N (base58_uint {229}), N (229));
+
+        EXPECT_EQ (N (hex_uint {1145}), N (1145));
+        EXPECT_EQ (N (hex_uint {916}), N (916));
+        EXPECT_EQ (N (hex_uint {229}), N (229));
+
+        EXPECT_EQ (Z (hex_int {1145}), Z (1145));
+        EXPECT_EQ (Z (hex_int {916}), Z (916));
+        EXPECT_EQ (Z (hex_int {229}), Z (229));
+
+        EXPECT_EQ (Z (hex_int_twos {1145}), Z (1145));
+        EXPECT_EQ (Z (hex_int_twos {916}), Z (916));
+        EXPECT_EQ (Z (hex_int_twos {229}), Z (229));
+    }
 }
diff --git a/test/testZBytes.cpp b/test/testZBytes.cpp
index 69f4a5ca..321bbfba 100644
--- a/test/testZBytes.cpp
+++ b/test/testZBytes.cpp
@@ -233,12 +233,34 @@ namespace data {
         Z_Bytes_to_Z (0);
         Z_Bytes_to_Z (1);
         Z_Bytes_to_Z (3);
+        Z_Bytes_to_Z (229);
         Z_Bytes_to_Z (767);
+        Z_Bytes_to_Z (916);
+        Z_Bytes_to_Z (1145);
         Z_Bytes_to_Z ("0x0f00000a00aabbccddeeffffffffffffffff");
         Z_Bytes_to_Z ("0xf000000a00aabbccddeeffffffffffffffff");
         
     }
 
+    TEST (ZBytesTest, TestZBytesOnesAndTwos) {
+
+        EXPECT_EQ (Z_bytes_big (Z_bytes_twos_big (Z_bytes_big {1145})), Z_bytes_big {1145});
+        EXPECT_EQ (Z_bytes_big (Z_bytes_twos_big (Z_bytes_big {916})), Z_bytes_big {916});
+        EXPECT_EQ (Z_bytes_big (Z_bytes_twos_big (Z_bytes_big {229})), Z_bytes_big {229});
+
+        EXPECT_EQ (Z_bytes_little (Z_bytes_twos_little (Z_bytes_little {1145})), Z_bytes_little {1145});
+        EXPECT_EQ (Z_bytes_little (Z_bytes_twos_little (Z_bytes_little {916})), Z_bytes_little {916});
+        EXPECT_EQ (Z_bytes_little (Z_bytes_twos_little (Z_bytes_little {229})), Z_bytes_little {229});
+
+        EXPECT_EQ (Z_bytes_twos_big (Z_bytes_big (Z_bytes_twos_big {1145})), Z_bytes_twos_big {1145});
+        EXPECT_EQ (Z_bytes_twos_big (Z_bytes_big (Z_bytes_twos_big {916})), Z_bytes_twos_big {916});
+        EXPECT_EQ (Z_bytes_twos_big (Z_bytes_big (Z_bytes_twos_big {229})), Z_bytes_twos_big {229});
+
+        EXPECT_EQ (Z_bytes_twos_little (Z_bytes_little (Z_bytes_twos_little {1145})), Z_bytes_twos_little {1145});
+        EXPECT_EQ (Z_bytes_twos_little (Z_bytes_little (Z_bytes_twos_little {916})), Z_bytes_twos_little {916});
+        EXPECT_EQ (Z_bytes_twos_little (Z_bytes_little (Z_bytes_twos_little {229})), Z_bytes_twos_little {229});
+    }
+
     TEST (ZBytesTest, TestZBytesZero) {
         list<string> ones_zeros {"0", "0x", "0x00", "0x0000"};
         list<string> twos_zeros {"0", "0x", "0x00", "0x0000", "0x80", "0x8000"};