__________

Cascading two LTI systems

Let us consider the series interconnection of two causal discrete-time LTI systems, and , as depicted below

where and are the outputs of each LTI system in the cascade. Since the output of system is the input of system , we have .

What LTI systems should we consider? Let us choose the simplest ones: the accumulator and the differentiator. Thus, let be an accumulator (also known as “discrete-time integrator”), whose input-output relationship is as follows

,

and let be a first difference operator (also known as “discrete-time differentiator”), whose input-output relationship is

.

Note that the output of the cascade of these two LTI systems is thus

and, hence, the cascade is input-output equivalent to the identity operator. Since for all signals , we say that is the left-inverse of system . Since both systems are LTI, the operators commute, i.e., and, therefore, is also the right-inverse of system . Since is the left- and right-inverse of , we say that is the inverse of system (and vice-versa). Do keep in mind, however, that not all systems are invertible. For details, take a look at Oppenheim & Willsky [1].

__________

Implementation in Haskell

We can easily find a state-space realization for the accumulator, but that will not be necessary. As in previous posts, let us view discrete-signals as lists. Thus, the accumulator takes a list , and returns the following list

where we assume that the initial condition of the accumulator is zero (i.e., ). Instead of using scanl yet once again (which would require us to drop the head of the list), let us now use scanl1 to implement the accumulator:

acc :: Num a => System a a
acc = scanl1 (+)

Please note that if the initial condition of the accumulator is not zero, we should use the following code instead:

acc' :: Num a => System a a
acc' us = tail $ scanl (+) acc_ini us

where acc_ini is the initial condition of the accumulator (analogous to the constant of integration in integral calculus).

The differentiator is not a proper system [2] and, therefore, it has no state-space realization. The differentiator takes a list , and returns the following list

where we again assume that . Note the following

i.e., list is obtained by elementwise subtraction of a right-shifted version of list from list itself. Subtracting two lists elementwise can be implemented using zipWith:

diff :: Num a => System a a
diff ys = zipWith (-) ys (0 : ys)

If the initial condition of the differentiator is not zero, we should instead use the following code:

diff' :: Num a => System a a
diff' ys = zipWith (-) ys (diff_ini : ys)

where diff_ini is the initial condition of the differentiator. Piecing it all together, we finally obtain the following Haskell script:

type Signal a = [a]
type System a b = Signal a -> Signal b

-- accumulator
acc :: Num a => System a a
acc = scanl1 (+)

-- differentiator
diff :: Num a => System a a
diff ys = zipWith (-) ys (0 : ys)

-- cascade of the acc. and diff.
sys :: Num a => System a a
sys = diff . acc

Take a look at the last line. It says that cascading systems is the same as composing systems! Hence, the Haskell implementation is conceptually very close to the mathematical formulation using operators. Functional analysis meets functional programming…

We run the script above on GHCi and then play with it:

*Main> -- build unit impulse
*Main> let delta = 1.0 : repeat 0.0 :: Signal Float
*Main> -- output of the accumulator
*Main> let ys = acc delta
*Main> take 20 ys
[1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,
1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0]
*Main> -- output of the differentiator
*Main> let ws = diff ys
*Main> take 20 ws
[1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,
0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]
*Main> -- impulse response of the cascade
*Main> let hs = sys delta
*Main> take 20 hs
[1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,
0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]

The impulse response of the accumulator is the unit step. The impulse response of the cascade is the unit impulse, as we expected. The differentiator is the inverse of the accumulator, and vice-versa.

__________

References

[1] Alan V. Oppenheim, Alan S. Willsky, S. Hamid Nawab, Signals & Systems, 2nd edition, Prentice-Hall, 1997.

[2] Panos Antsaklis, Anthony Michel, A Linear Systems Primer, Birkhäuser Boston, 2007.

In this post, we will again consider the first-order causal discrete-time LTI system described by the difference equation

where . In my previous post, I obtained a state-space representation of this LTI system. In this post, I will propose a better implementation of the given system in Haskell.

__________

Signal and System type synonyms

What is a discrete-time signal? We can think of a discrete-time signal as a sequence of numbers or symbols. In Haskell, we often use lists of floating-point numbers to represent real-valued discrete-time signals. More generally, we have the type synonym:

type Signal a = [a]

which says that a signal of type is a list of elements of type . We can then have signals of various types: integer, fixed-point, floating-point, bit, binary word, etc. This should be particularly useful in case we want to simulate mixed-signal circuits.

What is a discrete-time system? It is that which maps input discrete-time signals to output discrete-time signals. We will use the type synonym:

type System a b = (Signal a -> Signal b)

which tells us that a system of type is a function that maps an input signal of type to an output signal of type . In other words, it takes a list whose elements are of type , and it returns a list whose elements are of type .

__________

Implementing the LTI system in Haskell

In my previous post, I created the state and output sequences using

xs = scanl f x0 us
ys = zipWith g xs us

Combining the two lines above into a single line, we obtain

ys = zipWith g (scanl f x0 us) us

which returns the output sequence when given the input sequence. Note that the state sequence is not created. Assuming zero initial condition, we can then create a system (i.e., a function that takes a list and returns a list) as follows

sys :: Floating a => System a a
sys us = zipWith g (scanl f 0.0 us) us

which takes signals of type and returns signals of the same type, where is a floating-point type (either Float or Double).

Putting it all together in a script, we finally obtain:

type Signal a = [a]

type System a b = (Signal a -> Signal b)

-- state-space model
f,g :: Floating a => a -> a -> a
f x u = (0.5 * x) + u  	-- state-transition
g x u = f x u		-- output

-- define LTI system
sys :: Floating a => System a a
sys us = zipWith g (scanl f 0.0 us) us

which defines the LTI system under study with . For this choice of , the system is a lowpass filter.

__________

Example: lowpass-filtering a square wave

We run the script above on GHCi to create the desired LTI system. Let us now create an input signal, a square wave of period equal to 16 and duty cycle equal to 50%, and lowpass-filter it using the LTI system we created:

*Main> -- create square wave
*Main> let ones  = take 8 $ repeat 1.0 :: Signal Float
*Main> let zeros = take 8 $ repeat 0.0 :: Signal Float
*Main> let us = cycle (ones ++ zeros) :: Signal Float
*Main> -- create output sequence
*Main> let ys = sys us
*Main> -- check types
*Main> :type us
us :: Signal Float
*Main> :type ys
ys :: Signal Float
*Main> :type sys
sys :: Floating a => System a a

Finally, we compute the first 64 samples of the input and output signals using function take, and plot the signals using MATLAB:

In case you are wondering why the peak amplitude of the output signal is twice that of the input signal, compute the transfer function of the LTI system and note that the DC gain is equal to .

where . This system can be represented by the block diagram

where is a unit-delay block, the output of which is . We now introduce state variable denoting the output of the unit-delay block, i.e., . Thus, and, since , we obtain the following state-transition equation

.

The initial condition is , which we assume to be zero. Note that the output is and, thus, the output equation is

.

Lastly, we define , which allows us to write the state-transition and output equations as follows

We can now implement this state-space model in Haskell!

__________

Implementation in Haskell

Given an initial state and an input sequence , we can compute the state sequence using the scanl trick I wrote about last weekend. Once we have obtained the state sequence , the output sequence is

.

Do you recognize the pattern? We are zipping lists and using function !! We thus use (higher-order) function zipWith to compute the output sequence.

For and a constant input sequence, the following Haskell code computes the state and output trajectories:

-- constant input sequence
us :: Floating a => [a]
us = repeat 1.0

-- parameter alpha
alpha :: Floating a => a
alpha = 7/8

-- state-transition function
f :: Floating a => a -> a -> a
f x u = (alpha * x) + u

-- output function
g :: Floating a => a -> a -> a
g x u = f x u

-- initial condition
x0 :: Floating a => a
x0 = 0.0

-- state sequence
xs :: Floating a => [a]
xs = scanl f x0 us

-- output sequence
ys :: Floating a => [a]
ys = zipWith g xs us

Not quite. I am still stuck in the imperative paradigm… and need to be corrected. The code above does not compute anything. It does declare what the input, state and output sequences are. After running the script above in GHCi, we compute 30 samples of the input and output sequences using function take:

*Main> take 30 us
[1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,
1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,
1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0]
*Main> take 30 ys
[1.0,1.875,2.640625,3.310546875,3.896728515625,
4.409637451171875,4.858432769775391,5.251128673553467,
5.5947375893592834,5.895395390689373,6.158470966853201,
6.388662095996551,6.590079333996982,6.7663194172473595,
6.92052949009144,7.05546330383001,7.173530390851258,
7.276839091994852,7.367234205495495,7.446329929808559,
7.515538688582489,7.576096352509678,7.629084308445968,
7.675448769890222,7.716017673653944,7.751515464447201,
7.782576031391301,7.809754027467388,7.833534774033964,
7.854342927279719]

We can plot these sequences in MATLAB:

We now know how to simulate discrete-time LTI systems using Haskell. Note that our framework is based on state-space models, not on transfer functions. Hence, it should be possible to simulate discrete-time nonlinear systems in the same manner: using scanl to compute the state sequence, and zipWith to compute the output sequence. All we need is a state-space representation of the system under study.

There used to be a saying among Soviet intelligentsia—”to understand each other with half-words.” What is shared is silence, tone of voice, nuance of intonation. To say a full word is to say too much; communication on the level of words is already excessive, banal, almost kitschy. This peculiar form of communication “with half-words” is a mark of belonging to an imagined community that exists on the margin of the official public sphere. Hence the American metaphors for being sincere and authentic—”saying what you mean,” “going public,” and “being straightforward”—do not translate properly into the Soviet and Russian contexts. “Saying what you mean” could be interpreted as being stupid, naïve, or not streetwise. Such a profession of sincerity could be seen, at best, as a sign of foreign theatrical behavior; at worst, as a cunning provocation. There is no word for authenticity in Russian, but there are two words for truth, pravda and istina. It is possible to tell the truth (pravda), but istina—the word that, according to Vladimir Nabokov, does not rhyme with anything—must remain unarticulated.

In Russian cyrillic: istina = истина, pravda = правда. I would be delighted if any native Russians would care to comment on or critique this passage.

__________

Source:

Svetlana Boym, Common places: mythologies of everyday life in Russia, Harvard University Press, 1994.

where is the state, is the input, and is the state-transition function, where and  are the state set and input set, respectively.

Given an initial state and a (possibly infinite) input sequence , we would like to compute the state trajectory . Iterating, we obtain

and so on. Let us pause to take a look at the following equation

.

If you happen to be acquainted with functional programming, you will probably recognize this pattern. It is a left fold!! Hence, for every integer , we can compute in Haskell using function foldl, as follows

.

However, we would like to obtain the intermediate states as well. We can compute the entire state trajectory using function scanl instead

which returns a (finite) list of states . Amazingly (or perhaps not), since Haskell is lazy, we can obtain a state trajectory of infinite length corresponding to a given initial state and a given input sequence of infinite length!

__________

Example

Consider the logistic map with a control input

where we will use , for which the dynamics (of the unforced system) are chaotic. Let the initial state be (note that is a fixed-point of the unforced logistic map), and let the input sequence be a discrete-time sinusoid of infinite length

whose period is . The following Haskell program computes the infinite-length state trajectory using the aforementioned scanl trick:

-- define logistic map with control input
f :: Floating a => a -> a -> a
f x u = (3.8 * x * (1 - x)) + u

-- frequency of the input sinusoid
omega :: Floating a => a
omega = pi / 10

-- generate sinusoidal control input
us :: Floating a => [a]
us = map ((0.2*) . sin . (omega*) . fromIntegral) [0..]

-- initial state
x0 :: Floating a => a
x0 = 0.0

-- compute the state trajectory
xs :: Floating a => [a]
xs = scanl f x0 us

where we used map, function composition, and an infinite list of non-negative integers to generate the sinusoidal input.

To be more precise, the program above does not quite compute the state trajectory, it merely “promises” to compute it when needed. After running the program in GHCi, we can obtain the first 20 values of the input sequence and the first 21 values of the state sequence using function take, as follows

*Main> take 20 us
[0.0,6.180339887498948e-,0.11755705045849463,
0.1618033988749895,0.1902113032590307,0.2,
0.19021130325903074,0.1618033988749895,
0.11755705045849466, 6.180339887498951e-2,
2.4492127076447546e17,-6.180339887498946e2,
-0.11755705045849461,-0.16180339887498948,
-0.1902113032590307,-0.2,-0.19021130325903074,
-0.1618033988749895,-0.11755705045849468,
-6.180339887498953e-2]
*Main> take 21 xs
[0.0,0.0,6.180339887498948e-2,0.33789525775595064,
1.0119471985345525,0.14426955372699996,
0.6691322284587664,1.031509602586003,
3.8294059838691885e-2,0.2575020247735924,
0.7883433805171414,0.6340607606653986,
0.8199019084343063,0.44356147166584237,
0.7760924326990134,0.4701259774450641,
0.7466086625502713,0.5286885334506017,
0.7850690797091344,0.5236383047578965,
0.8860732772080671]

In other words, the input and state sequences are only computed when the expressions with take are evaluated by the interpreter. We can plot these sequences in MATLAB:

Last but not least, here is the MATLAB code that generates the plot:

figure; hold on;
stem([0:1:19],u,'b');
stem([0:1:20],x,'r');
legend('input','state');
xlabel('k (time)'); ylabel('amplitude');
axis([0 21 -0.25 1.20]);

where (row) vectors and are the lists produced by GHCi.

__________

Lastly, please do note that the class of dynamical systems we have considered in this post is extremely broad. It encompasses difference equations obtained from the time-discretization of differential equations, IIR filters, finite and infinite automata, etc.

Not all birds can fly.

This sentence can be paraphrased as

It is not the case that all things which are birds can fly.

Let be the set of all things of interest (i.e., the universe under discussion). We now introduce predicates and , defined by

and

Finally, using (unary) predicates and , the declarative sentence “Not all birds can fly” can be encoded as follows

where we used negation (), universal quantification (), and material implication (). The (well-formed) formula above should be read as: “it is not the case that for all , if is a bird, then can fly”. Whether the (universally quantified) formula evaluates to or depends on the set we consider. For example, if is the set of all living things on Earth on January 1, 2012, then the formula evaluates to because penguins are birds which cannot fly. However, if we spend the next century eradicating all birds that cannot fly, then on January 1, 2112, the formula might evaluate to .

__________

Technicalities

Let us consider the formula , where is a predicate. If this formula evaluates to , then it is not the case that for all we have that , which is the same as saying that there exists a for which or, in other words, for which . Hence, formula is equivalent (in some sense) to the formula , where is the existential quantifier. We write to denote this equivalence. Hence, we conclude that

.

Given propositional atoms and , we have that the formula is semantically equivalent [1] to the formula . We write to denote this equivalence. Thus, we have that

which allows us to conclude that

.

Using one of De Morgan’s laws, namely, , we conclude that . Eliminating the double negation (we can do that in Classical Logic, but not in Intuitionistic Logic), we obtain . Without further ado, we have that

.

From all these equivalences, we finally conclude that

.

What does this equivalence say? It tells us that the declarative sentence “Not all birds can fly” can be paraphrased as follows

There exists a thing which is a bird and which cannot fly.

That “thing” could be, for example, a penguin. For the sake of convenience, let us introduce predicates and , defined by

so that the last equivalence can be written more compactly as

where . This will be useful later on.

__________

Creating our universe

Let us suppose that we do not know that penguins are birds and that they cannot fly. Evaluating the formula using planet Earth’s fauna as the set of all things of interest would require us to consult quite a few Zoology books. However, it is Sunday night and the library is closed for the Winter break. And, to make matters worse, we are somewhat lazy.

Instead of bothering with the actual universe, let us create our own imaginary universe in which there are only three classes of animals: birds, cats, and dogs. Each class contains only three species each.

We construct this imaginary universe in Haskell:

-- create Animal data type
data Animal = Bird String |
              Cat String |
              Dog String deriving (Show, Eq)

-- create list of animals
animals = [Bird "Dove", Bird "Hawk", Bird "Penguin",
           Cat "Burmese", Cat "Persian", Cat "Siamese",
           Dog "Dalmatian", Dog "Husky", Dog "Terrier"]

-- define isBird predicate
isBird :: Animal -> Bool
isBird (Bird s) = True
isBird _ = False

-- define canFly predicate
canFly :: Animal -> Bool
canFly (Bird "Dove") = True
canFly (Bird "Hawk") = True
canFly _ = False

-- define phi predicate
phi :: Animal -> Bool
phi x = ((not . isBird) x) || (canFly x) 

-- define psi predicate
psi :: Animal -> Bool
psi x = (isBird x) && ((not . canFly) x)

Let us now play with these objects and predicates and evaluate the quantified formulas using the GHCi interpreter:

*Main> -- print list of animals
*Main> animals
[Bird "Dove",Bird "Hawk",Bird "Penguin",Cat "Burmese",Cat "Persian",
Cat "Siamese",Dog "Dalmatian",Dog "Husky",Dog "Terrier"]
*Main> -- test isBird predicate
*Main> map isBird animals
[True,True,True,False,False,False,False,False,False]
*Main> -- test canFly predicate
*Main> map canFly animals
[True,True,False,False,False,False,False,False,False]
*Main> -- test phi predicate
*Main> map phi animals
[True,True,False,True,True,True,True,True,True]
*Main> -- test psi predicate
*Main> map psi animals
[False,False,True,False,False,False,False,False,False]
*Main> -- evaluate universally quantified formula
*Main> not (all phi animals)
True
*Main> -- evaluate existentially quantified formula
*Main> any psi animals
True

where we used functions all and any to emulate the universal and existential quantifiers, respectively. Note that both formulas evaluate to , as expected.

__________

Caution: do not confuse the arrow used in the definition of the predicates with the arrow used in material implication. They look the same, but they are different symbols and context should allow one to distinguish the two.

Remark: this post is based on an example in chapter 2 of Huth & Ryan [1].

__________

References

[1] Michael Huth, Mark Ryan, Logic in Computer Science: Modelling and Reasoning about Systems, 2nd ed., Cambridge University Press, June 2004.

Hat tip: Luboš Motl

where is also a sequence of length . Note that the matrix above is a circulant matrix, as each row is a circularly right-shifted version of the previous one. Each is obtained by taking the inner product of the -th row of the matrix with the vector.

In Digital Signal Processing (DSP), we often think of finite sequences as vectors, which allows us to compute convolutions using matrix operations. Taking a more Computer Science-ish approach, one can think of finite sequences as finite lists, and compute convolutions using list operations. The matrix above can be thought of as a list of lists (where each row is a list). We know how to multiply a matrix by a vector, but how do we “multiply” a list of lists by a list?

I started teaching myself Haskell this Summer, and I am (obviously) looking for interesting problems at which to throw some functional firepower. Solutions looking for a problem. But, first, let us “begin at the beginning”…

__________

Reverse

Take another look at the matrix above and note that its last row, when viewed as a list, is the reversal of list , which means that we need a function that reverses lists. Fortunately, we do not need to implement such a function, as there is the function reverse in Prelude that uses foldl and flip:

reverse :: [a] -> [a]
reverse = foldl (flip (:)) []

__________

Circular shifts

Yet once again, let us look at the matrix at the top of this post. Note that the 2nd row is a circularly right-shifted version of the 1st one, and that the 3rd row is a circularly right-shifted version of the 2nd one, et cetera. Also, note that the -th row is a circularly left-shifted version of the -th row, and so and so on. Thus, we need to implement functions that perform circular shifts.

The following function circularly right-shifts a list:

circShiftR :: [a] -> [a]
circShiftR [] = []
circShiftR x = last x : init x

This function merely takes the last element of the list and moves it to the beginning. We can circularly left-shift a list using the function:

circShiftL :: [a] -> [a]
circShiftL [] = []
circShiftL xs = (tail xs) ++ [head xs]

which moves the first element of a list to the end. Let us now test these functions on some simple lists using the GHCi interpreter:

*Main> circShiftR [0..9]
[9,0,1,2,3,4,5,6,7,8]
*Main> circShiftR (circShiftR [0..9])
[8,9,0,1,2,3,4,5,6,7]
*Main> (circShiftR . circShiftR) [0..9]
[8,9,0,1,2,3,4,5,6,7]
*Main> circShiftL [0..9]
[1,2,3,4,5,6,7,8,9,0]
*Main> (circShiftL . circShiftL) [0..9]
[2,3,4,5,6,7,8,9,0,1]

Note that in the 3rd and 5th inputs we composed the circular shifting functions to perform double right- and left-shifts.

__________

Iterate

Since each row of the matrix is a right-shifted version of the previous one or a left-shifted version of the next one, we can generate the matrix from its first or last rows. Putting it in terms of lists, we can generate a list of lists that represents the matrix from a single list using the iterate function in Prelude:

iterate :: (a -> a) -> a -> [a]
iterate f x =  x : iterate f (f x)

and the circular shifting functions we implemented before. To make things concrete, we can generate all four circular right-shifts of a list of length 4, as follows:

*Main> take 4 (iterate circShiftR [0..3])
[[0,1,2,3],[3,0,1,2],[2,3,0,1],[1,2,3,0]]

A word of caution is in order. Note that we take the first four lists, as

iterate f x

does generate an infinite list containing , , , , et cetera. We do not need an infinite list of lists.

We now know how to generate a list of lists representing the matrix.

__________

Inner product

To obtain the circular convolution of and , we multiply a matrix by a (column) vector, which consists of computing inner products. However, in this post we are thinking in terms of lists. We thus need to implement a function that computes the inner product of two (finite) lists, as follows:

innerProd :: Num a => [a] -> [a] -> a
innerProd xs ys = sum(zipWith (*) xs ys)

where we first use zipWith to obtain a list of the products, and then use sum to compute the sum . Let us test the inner product function:

*Main> let xs = [1..4]
*Main> let ys = [0..3]
*Main> zipWith (*) xs ys
[0,2,6,12]
*Main> sum(zipWith (*) xs ys)
20

__________

Circular convolution

We finally have all we need to compute the circular convolution.

For example, suppose we want to compute the circular convolution of two 4-point sequences, say, and . Using matrix-vector multiplication, we obtain:

Alternatively, we can compute the circular convolution by representing sequences by lists and using the functions we have implemented before:

*Main> -- define lists
*Main> let xs = [1,1,1,1]
*Main> let ys = [0,1,2,3]
*Main> -- reverse and right-shift ys
*Main> let ys' = (circShiftR . reverse) ys
*Main> ys'
[0,3,2,1]
*Main> -- compute list of lists representing the matrix
*Main> let yss = take 4 (iterate circShiftR ys')
*Main> yss
[[0,3,2,1],[1,0,3,2],[2,1,0,3],[3,2,1,0]]
*Main> -- compute inner product of xs with each list in yss
*Main> map (innerProd xs) yss
[6,6,6,6]

Note that I wrote comments on the GHCi command line in order to improve readability. We are now ready to implement the function that computes the circular convolution:

circConv :: Num a => [a] -> [a] -> [a]
circConv xs ys = map (innerProd xs) yss
		 where
	     	   n   = length xs
	           ys' = (circShiftR . reverse) ys
		   yss = take n (iterate circShiftR ys')

How does it work? We first take sequence , reverse and right-shift it (to obtain the 1st row of the matrix), generate the remaining rows by right-shifting the previous ones, and finally compute the inner product of each row with sequence using map. Note that

innerProd xs

is a partial application of the inner product function, as we provide only the first argument. We could define a function as follows:

*Main> let g = innerProd [1,1,1,1]
*Main> :type g
g :: [Integer] -> Integer
*Main> g [0..3]
6

Note that takes a list of integers and returns its inner product with the list of four ones. Putting it all together in a .hs file, we have:

-- circular right-shift
circShiftR :: [a] -> [a]
circShiftR [] = []
circShiftR x = last x : init x

-- inner product of two lists
innerProd :: Num a => [a] -> [a] -> a
innerProd xs ys = sum(zipWith (*) xs ys)

-- circular convolution of two lists
circConv :: Num a => [a] -> [a] -> [a]
circConv xs ys = map (innerProd xs) yss
		 where
	     	    n   = length xs
	            ys' = (circShiftR . reverse) ys
		    yss = take n (iterate circShiftR ys')

We use several higher-order functions in this implementation: map, iterate, zipWith. We also use function composition and partial function application. A lot of beautiful ideas in only a dozen lines of code!

I am a Haskell neophyte, and I make no claims that the code above cannot be improved. If you have any constructive suggestions, I would be happy to hear them. Please use the HTML tags <pre> and </pre> to post code in the comments.

__________

Testing

Last but not least, let us carry out a couple of tests using examples from Mitra’s book [1]:

*Main> -- problem 5.2 b)
*Main> let xs = [-1,5,3,0,3]
*Main> let hs = [-2,0,5,3,-2]
*Main> circConv xs hs
[1,-1,-2,16,26]
*Main> -- problem 5.45 b)
*Main> let gs = [2,-1,3,0]
*Main> let hs = [-2,4,2,-1]
*Main> circConv gs hs
[3,7,-6,8]

It appears to be working! Please let me know if you find any bugs.

__________

References

[1] Sanjit K. Mitra, Digital Signal Processing: a computer-based approach, 3rd edition, McGraw-Hill, 2005.

For instance, consider a graph whose vertex set is and whose edge set is . A pictorial representation of this graph is depicted below

Note that this graph is complete. We can assign two distinct colors to any two vertices, but we cannot assign a color to the third vertex that will yield a proper coloring. Therefore, the graph is not 2-colorable. To illustrate, we use the color set and generate all possible vertex 2-colorings, as depicted below

Notice that none of these 2-colorings is proper, as expected.

As discussed by De Loera et alia [1], the graph vertex-coloring problem can be modeled using polynomial equations. We introduce variables , where if vertex is assigned the color , and if vertex is assigned the color . Given an edge , we have that:

• if both vertices are pink, we get .

• if both vertices are blue, we get .

• if the vertices have distinct colors, we get .

Thus, stating that adjacent vertices must be assigned distinct colors is equivalent to imposing the constraints for all . We thus obtain a system of three equations

where . This is still a combinatorial problem, though. We can transform it into an algebraic-geometric problem. Here is a truly beautiful trick [1]: the constraint can be encoded as with . How quaint!! We then obtain a system of six equations with polynomials in

whose solution set, which we denote by , is algebraic [2]. The given graph is 2-colorable if and only if the system of polynomial equations above is feasible, i.e., if set is nonempty [1]. The following REDUCE + REDLOG script uses quantifier elimination to decide if is nonempty:

% feasibility via quantifier elimination

load_package redlog;
rlset ofsf;

% define polynomial functions
f1 := x1+x2;
f2 := x1+x3;
f3 := x2+x3;
f4 := x1^2-1;
f5 := x2^2-1;
f6 := x3^2-1;

% define existential formula
phi := ex({x1,x2,x3}, f1=0 and f2=0 and f3=0 and
                      f4=0 and f5=0 and f6=0);

% perform quantifier elimination
rlqe phi;

end;

This script produces the truth value false. Thus, the solution set is empty, which means that the system of polynomial equations is infeasible. We conclude that the given graph is not 2-colorable.

__________

References

[1] Jesús De Loera, Jon Lee, Susan Margulies, Shmuel Onn, Expressing Combinatorial Optimization Problems by Systems of Polynomial Equations and the Nullstellensatz, 2007.

[2] Jacek Bochnak, Michel Coste, Marie-Françoise Roy, Real Algebraic Geometry, Springer, 1998.

is nonempty. This is the same as determining whether the following system of polynomial inequalities

is feasible. We now define , and . Set is depicted below

and set is depicted below

Note that . We depict this intersection below

Visual inspection of the plot of the intersection allows us to conclude that in nonempty. Asserting that is nonempty is the same as stating that the proposition

is true. We can determine the truth value of this proposition via quantifier elimination using the following REDUCE + REDLOG script:

% feasibility via quantifier elimination

load_package redlog;
rlset ofsf;

% define polynomial functions
g1 :=  x-y^2+1;
g2 := -x-y^2+1;

% define existential formula
phi := ex({x,y}, g1>=0 and g2>=0);

% perform quantifier elimination
rlqe phi;

end;

which produces the truth value true. This means that there exists a that satisfies the polynomial inequalities, i.e., is nonempty.

__________

Remark: the plots in this post were generated by Wolfram Alpha.