diff --git a/Algebra.hs b/Algebra.hs
--- a/Algebra.hs
+++ b/Algebra.hs
@@ -105,7 +105,7 @@
 (+) :: Semigroup (Sum a) => a -> a -> a
 a + b = getSum (Sum a <> Sum b)
 
-(-) :: (Semigroup (Sum a), Group (Sum a)) => a -> a -> a
+(-) :: Group (Sum a) => a -> a -> a
 a - b = getSum (Sum a <> invert (Sum b))
 
 (*) :: Semigroup (Product a) => a -> a -> a
diff --git a/Data/BitSet.hs b/Data/BitSet.hs
--- a/Data/BitSet.hs
+++ b/Data/BitSet.hs
@@ -1,3 +1,5 @@
+{-# LANGUAGE FlexibleInstances #-}
+
 module Data.BitSet where
 
 import Control.Applicative
@@ -36,3 +38,34 @@
 
 (.&?¬) :: (PartialOrd a, Bits a) => a -> a -> Maybe a
 a .&?¬ b = a .&¬ b <$ guard (b ≤ a)
+
+instance Bits a => Semigroup (Min (BitSet a)) where Min a <> Min b = Min (a .&. b)
+instance Bits a => Semigroup (Max (BitSet a)) where Max a <> Max b = Max (a .|. b)
+
+instance Bits a => Abelian (Min (BitSet a))
+instance Bits a => Abelian (Max (BitSet a))
+
+instance Bits a => Idempotent (Min (BitSet a))
+instance Bits a => Idempotent (Max (BitSet a))
+
+instance Bits a => Monoid (Min (BitSet a)) where
+    mappend = (<>)
+    mempty = Min (complement zeroBits)
+instance Bits a => Monoid (Max (BitSet a)) where
+    mappend = (<>)
+    mempty = Max zeroBits
+
+instance Bits a => Preord (Min (BitSet a)) where
+    Min (BitSet a) ≤ Min (BitSet b) = a .&. b == a
+instance Bits a => Preord (Max (BitSet a)) where
+    Max (BitSet a) ≤ Max (BitSet b) = a .&. b == b
+
+instance Bits a => PartialEq (Min (BitSet a)) where (≡) = (==)
+instance Bits a => PartialEq (Max (BitSet a)) where (≡) = (==)
+instance Bits a => Eq (Min (BitSet a))
+instance Bits a => Eq (Max (BitSet a))
+instance Bits a => PartialOrd (Min (BitSet a))
+instance Bits a => PartialOrd (Max (BitSet a))
+
+instance Bits a => Monus (Max (BitSet a)) where monus a b = a .&. complement b
+instance Bits a => Monus (Min (BitSet a)) where monus a b = a .|. complement b
diff --git a/Relation/Binary/Comparison.hs b/Relation/Binary/Comparison.hs
--- a/Relation/Binary/Comparison.hs
+++ b/Relation/Binary/Comparison.hs
@@ -8,19 +8,21 @@
 import Algebra
 import Control.Applicative
 import Control.Monad
+import Data.Bits
 import Data.Bool
 import Data.Either
 import Data.Function (flip, on)
 import Data.Int
 import Data.Maybe
 import Data.Monoid (Sum (..))
-import Data.Ord (Ordering (..))
+import Data.Ord (Down (..), Ordering (..))
 import Data.Word
 import Numeric.Natural
 
 infix 4 ≤, ≥, <, >, ≡, ≢
 
 class Preord a where
+    {-# MINIMAL (≥) | (≤) #-}
     (≤), (≥), (<), (>) :: a -> a -> Bool
     (≤) = flip (≥)
     (≥) = flip (≤)
@@ -28,6 +30,7 @@
     (>) = flip (<)
 
 class PartialEq a where
+    {-# MINIMAL (≡) | (≢) #-}
     (≡), (≢) :: a -> a -> Bool
     a ≡ b = not (a ≢ b)
     a ≢ b = not (a ≡ b)
@@ -46,6 +49,16 @@
     compare :: a -> a -> Ordering
     compare a b = fromJust (tryCompare a b)
 
+instance Preord a => Preord (Down a) where
+    Down a ≤ Down b = a ≥ b
+    Down a ≥ Down b = a ≤ b
+    Down a < Down b = a > b
+    Down a > Down b = a < b
+deriving instance PartialEq a => PartialEq (Down a)
+instance PartialOrd a => PartialOrd (Down a) where Down a `tryCompare` Down b = tryCompare b a
+deriving instance Eq a => Eq (Down a)
+instance Ord a => Ord (Down a)
+
 instance Preord () where () ≤ () = True
 instance PartialEq () where () ≡ () = True
 instance PartialOrd () where tryCompare () () = Just EQ
@@ -213,6 +226,16 @@
 instance (Eq a, Eq b) => Eq (Lexical (Either a b))
 instance (Ord a, Ord b) => Ord (Lexical (Either a b))
 
+instance (Preord a) => Preord (Lexical (Maybe a)) where
+    Lexical Nothing ≤ Lexical (Just _) = True
+    Lexical x ≤ Lexical y = x ≤ y
+instance (PartialOrd a) => PartialOrd (Lexical (Maybe a)) where
+    Lexical Nothing `tryCompare` Lexical (Just _) = Just LT
+    Lexical (Just _) `tryCompare` Lexical Nothing = Just GT
+    Lexical x `tryCompare` Lexical y = tryCompare x y
+instance (Eq a) => Eq (Lexical (Maybe a))
+instance (Ord a) => Ord (Lexical (Maybe a))
+
 newtype Lexical a = Lexical a deriving (PartialEq, Semigroup, Monoid, Group)
 
 instance PartialEq a => PartialEq (Maybe a) where (≡) = (≡) `on` maybe (Left ()) Right
@@ -237,3 +260,13 @@
 
 (∸) :: Monus (Sum a) => a -> a -> a
 a ∸ b = getSum (Sum a `monus` Sum b)
+
+max, min :: Ord a => a -> a -> a
+max a b | a > b = a | otherwise = b
+min a b | a < b = a | otherwise = b
+
+newtype Max a = Max { unMax :: a } deriving (Prelude.Eq, Bits, FiniteBits, Prelude.Read, Prelude.Show)
+newtype Min a = Min { unMin :: a } deriving (Prelude.Eq, Bits, FiniteBits, Prelude.Read, Prelude.Show)
+
+instance {-# OVERLAPPABLE #-} Ord a => Semigroup (Max a) where Max a <> Max b = Max (max a b)
+instance {-# OVERLAPPABLE #-} Ord a => Semigroup (Min a) where Min a <> Min b = Min (min a b)
diff --git a/alg.cabal b/alg.cabal
--- a/alg.cabal
+++ b/alg.cabal
@@ -1,5 +1,5 @@
 name:                alg
-version:             0.2.5.0
+version:             0.2.6.0
 synopsis:            Algebraic structures
 -- description:         
 license:             BSD3
@@ -11,9 +11,7 @@
 build-type:          Simple
 -- extra-source-files:  
 cabal-version:       >=1.10
-tested-with:         GHC ==8.0.2
-                   , GHC ==8.2.2
-                   , GHC ==8.4.2
+tested-with:         GHC ==8.4.2
 
 library
   exposed-modules:     Algebra
@@ -21,7 +19,7 @@
                      , Relation.Binary.Comparison
   -- other-modules:       
   other-extensions:    
-  build-depends:       base >=4.9 && <5
+  build-depends:       base >=4.11 && <5
                      , util >=0.1.9 && <0.2
   -- hs-source-dirs:      
   default-language:    Haskell2010
@@ -33,4 +31,4 @@
                      , PolyKinds
                      , StandaloneDeriving
                      , GeneralizedNewtypeDeriving
-  ghc-options:         -Wall -Wno-partial-type-signatures
+  ghc-options:         -Wall -Wcompat -Wredundant-constraints -Wno-partial-type-signatures