Browse Source

Added Automata :D

master
Joshua Moerman 12 years ago
parent
commit
b5e9aca237
  1. 56
      Automata.hs
  2. 10
      Coalgebra.hs
  3. 11
      Streams.hs

56
Automata.hs

@ -0,0 +1,56 @@
{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, TypeOperators, ScopedTypeVariables, OverlappingInstances #-}
import Control.Monad.Instances
import Control.Compose
import Coalgebra
-- F X = 2 x X^A, for some fixed alphabet A
type F a = (,) Bool `O` ((->) a)
-- Fixpoint, ie languages
type Language a = Mu (F a)
-- basic constructor
ctor :: Bool -> (a -> Language a) -> Language a
ctor b t = phi (O (b, t))
-- For every (F a)-coalgebra x, there is a arrow x -> Language a
-- and it is unique, so `Language a` is the final (F a)-coalgebra!
sem :: (Coalgebra (F a) x) => x -> Language a
sem s = ctor b (\w -> sem $ trans w) where O (b, trans) = psi s
-- auciliry function
is_member :: [a] -> Language a -> Bool
is_member [] l = b where O (b, _) = psi l
is_member (a:r) l = is_member r (trans a) where O (_, trans) = psi l
-- Our alphabet
data A = A | B
deriving Show
-- Our example automaton, we will look at its language given by sem
data X = One | Two | Three
trans :: X -> A -> X
trans One A = Two
trans One B = Three
trans Two A = Three
trans Two B = One
trans Three _ = Three
fin :: X -> Bool
fin One = True;
fin Two = True;
fin _ = False;
instance Coalgebra (F A) X where
psi x = O (fin x, trans x)
-- Test a word against it
show_member word = putStrLn $ show (word, is_member word (sem One :: Language A))
main = do
let words = [[A], [A,B], [A,B,B], [A,B,B,A], [A,B,A,B,A]]
sequence $ map show_member words

10
Coalgebra.hs

@ -1,13 +1,13 @@
{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FunctionalDependencies #-}
module Coalgebra where module Coalgebra where
import Control.Monad import Control.Monad.Instances
-- Definitions for (co)algebras -- Definitions for (co)algebras, adding fundeps helped in the Automata case...
class Functor f => Algebra f m where class Functor f => Algebra f m | m -> f where
phi :: f m -> m phi :: f m -> m
class Functor f => Coalgebra f m where class Functor f => Coalgebra f m | m -> f where
psi :: m -> f m psi :: m -> f m
-- Fixpoint, ie f (Mu f) = Mu f -- Fixpoint, ie f (Mu f) = Mu f

11
Streams.hs

@ -3,16 +3,17 @@
import Control.Monad.Instances import Control.Monad.Instances
import Coalgebra import Coalgebra
-- F X = A x X, for a fixed A, The prelude already provides the functor instance :) -- F X = A x X, for a fixed A, this has a functor instance
type F a = (,) a type F a = (,) a
-- This will give the fixpoint, ie a coalgebra. -- This will give the fixpoint, ie a coalgebra, because F is a functor
type Stream a = Mu (F a) type Stream a = Mu (F a)
-- basic constructor
(+:+) :: a -> Stream a -> Stream a (+:+) :: a -> Stream a -> Stream a
(+:+) a s = In (a, s) (+:+) a s = phi (a, s)
-- For every other (F a)-coalgebra x, there is a arrow x -> Stream a -- For every (F a)-coalgebra x, there is a arrow x -> Stream a
-- and it is unique, so `Stream a` is the final (F a)-coalgebra! -- and it is unique, so `Stream a` is the final (F a)-coalgebra!
sem :: (Coalgebra (F a) x) => x -> Stream a sem :: (Coalgebra (F a) x) => x -> Stream a
sem x = x0 +:+ sem x' where (x0, x') = psi x sem x = x0 +:+ sem x' where (x0, x') = psi x
@ -22,7 +23,7 @@ toList :: Stream a -> [a]
toList s = a0 : toList a' where (a0, a') = psi s toList s = a0 : toList a' where (a0, a') = psi s
-- example, with a very simple (F Int)-coalgebra, 1 -> 2, 2 -> 3, 3 -> 2 -- example with a very simple (F Int)-coalgebra, 1 -> 2, 2 -> 3, 3 -> 2
data X = One | Two | Three data X = One | Two | Three
instance Coalgebra (F Int) X where instance Coalgebra (F Int) X where
psi One = (1, Two) psi One = (1, Two)