原です。

>> 今回の問題に特化するなら、not(le_a a c) || (le_b b d) は
>> 順番を逆にしたほうが効率的ですよ。
>
>いえこれは微妙で、チェックの回数は多いけど、le_a の方が le_b
>よりコストが低いのです。試してみると、、、

あれっ、間違えました逆です。le_a の方が複雑でしたね。(^^;)


>これです!私も iterate を使えるような型を作ろうとしていたんですが、

できました。結局、台集合の方で、選択 | を使って再帰で型を書けば良
いのでした。

import System

data Poset a = Poset [a] (a -> a -> Bool)
type Transf x = [(x, x)]

power :: Poset a -> Poset a -> Poset (Transf a)
power (Poset bx le_b) (Poset ax le_a) = Poset set le where
    set = foldr extend [[]] ax
    extend a funcs = [(a,b):func | func <- funcs, b <- bx, check a b func]
    check a b func = and [(le_b b d) || not(le_a a c) | (c, d) <- func ]
    le f1 f2 = and [le_b b d | ((_, b), (_, d)) <- zip f1 f2]

showGraph :: Poset a -> String
showGraph x = "digraph G {\nrankdir=TB;\n" ++ pointshow x ++ graphshow x ++ "}"
    where 
    printGraph x = putStrLn ("digraph G {\nrankdir=TB;\n" ++
                     pointshow x ++ graphshow x ++ "}")
    pointshow (Poset v _) = concat ["x" ++ show i ++ ";\n" |
                              (_, i) <- zip v [0..]]
    graphshow (Poset u le) = concat ["x"++show i++" -> "++"x"++show j++";\n"
                           | ((_, i), (_, j)) <- graph le (zip u [0..])]
    graph le ui = [(fi, gj) | fi <- ui, gj <- foldr (extend_graph le fi) [] ui]
    extend_graph le (f, i) (g, j) fs
      | i == j = fs
      | (or [le g h | (h, _) <- fs]) = fs
      | (le g f) = (filter (\(h, _) -> not (le h g)) fs) ++ [(g, j)]
      | True = fs

data Y t = I t | X (Transf (Y t))

posetI :: Poset t -> Poset (Y t)
posetI (Poset is ile) = Poset (map I is) le
                   where le (I i1) (I i2) = (ile i1 i2)

posetX :: Poset (Transf (Y t)) -> Poset (Y t)
posetX (Poset xs xle) = Poset (map X xs) le
                   where le (X x1) (X x2) = (xle x1 x2)

limitSequence :: Poset (Y t) -> Poset (Y t) -> [Poset (Y t)]
limitSequence init pos = iterate (posetX . power pos) init

d :: Int -> Poset (Y Int)
d o = posetI (Poset [0..o] (<=))

main :: IO ()
main =
    do n:o:_ <- mfunct (map read . update ["3", "2"]) getArgs
       putStrLn (showGraph (limitSequence (d 0) (d o) !! n))
    where update (d:ds) (a:as) = a : update ds as
          update [] as = as
          update ds [] = ds
          mfunct f = (>>= return.f)


--
ML: haskell-jp / quickml.com
使い方: http://QuickML.com/