Abstract

Some sample problems relating to creating and manipulating regular expressions.

1 JFLAP

1. Read the Regular Expressions section of the
   JFLAP Tutorial.

2. JFLAP does not feature a direct way to check regular expressions against strings. You can do it indirectly by asking JFLAP to convert the regular expression to and NFA, and then running that NFA.

   It may be easier, however, to check your regular expressions via ordinary Linux commands. You may recall that grep is a program that tests lines of text against a regular expression, echoing those lines that match. We can convert the textbook & JFLAP style regular expressions to Linux regular expressions pretty easily:

   • Linux uses | for the union operator instead of +.
   • JFLAP uses ! for the $\epsilon$ character. In Linux/grep, we can use () instead.
   • grep matches any string containing the desired pattern. If we want grep to match only if the entire string matches the regular expression, we use the -x option.

   So if we wanted to check various strings against the regular expression $(a + b)^*$, we could give the commands

   echo a | grep -E -x '(a|b)*'
   echo aa | grep -E -x '(a|b)*'
   echo aab | grep -E -x '(a|b)*'
       ⋮
   

   (You might recall that Linux has keyboard shortcuts to recall recently entered commands, allowing you to make small changes to a prior command instead of retyping the whole thing.)

   This command will either print our string if it matches or will print nothing if it does not. (The ‘-E’ selects the “extended” form of grep that makes full regular expression processing available.)

   Try testing that regular expression with each of the following strings:

   • a
   • b
   • aaaba
   • aaaca

   You can enter $\epsilon$ (the empty string) for testing by using two quotes with nothing between them ('' or ""). Try testing the empty string against these regular expressions:

   • ‘(a|b)*’
   • ‘(a|b)’

   There is a difference in the output, subtle though it may be.

1. Write a regular expression to describe the set of strings with one element, the string 101.

   Reveal

   The regular expression is: 101

   (video) (includes a discussion of how the regular expression 101 is actually more complicated than the string “101”.

2. Prove: No regular expression that does not use closure (*) can accept a string longer than itself.

   Reveal

   This, like many properties of regular languages, can be proven by structural induction over the set of regular expression operators.

   (video)

3. Write regular expressions to describe the set of strings that

   • begin with 101
   • end with 101
   • contain 101
   Reveal

   Respectively:

   • 101(0+1)*
   • (0+1)*101
   • (0+1)*101(0+1)*

   (video)

1. Write a regular expression to describe the set of strings that begin with 101 and end with 110.

   Reveal

   The regular expression is: 101(1+0)*101

   (video)

2. Write a regular expression to describe the set of strings that consist of zero or more non-overlapping repetitions of 101.

   Reveal

   The regular expression is: (101)*

   (video)

1. Write a regular expression accepting the same language as this automaton:
    
   

   Can you write the first “iteration” of the table, containing $R^{(0)}$?

   Reveal

   The first iteration of the table is

   $R^{(0)}$:

   	i=1	2	3	4
   j=1	$\epsilon + 1$
   j=2	0	$\epsilon$
   j=3		1	$\epsilon+0+1$
   j=4		0		$\epsilon+0$

   Getting started: (video)

   Now that you’ve seen the method, can you fill in the rest of table?

   Reveal

   $R^{(1)}$:

   	i=1	2	3	4
   j=1	1*			11*
   j=2	1*0	$\epsilon$		11*0
   j=3		1	$\epsilon+0+1$
   j=4		0		$\epsilon+0$

   $R^{(2)}$:

   	i=1	2	3	4
   j=1	1*			11*
   j=2	1*0	$\epsilon$		11*0
   j=3	1*01	1	$\epsilon+0+1$	11*01
   j=4	1*00	0		$\epsilon+0+11*00$

   $R^{(3)}$:

   	i=1	2	3	4
   j=1	1*			11*
   j=2	1*0	$\epsilon$		11*0
   j=3	1*01	1	(0+1)*	11*01(0+1)*
   j=4	1*00	0		$\epsilon$+0+11*00

   $R^{(4)}$:

   	i=1	2	3	4
   j=1	1*+1*00(0 + 11*00)*11*	0(0 + 11*00)*11*		(0 + 11*00)* 11*
   j=2	1*0+1*00(0 + 11*00)*11*0	$\epsilon$ + 0(0 + 11*00)*11*0		(0 + 11*00)* 11*0
   j=3	1*01+1*00(0 + 11*00)*11*01	1 + 0(0 + 11*00)*	(0+1)*	(0 + 11*00)*11*01(0+1)*
   j=4	1*00(0 + 11*00)*	0 (0 + 11*00)*		(0 + 11*00)*

   Once we have completed the table, each accepting state $j$ in the FA is described by $R_{i,j}^{(n)}$ where $i$ is the starting state and $n$ is the number of states.  The entire automaton is described by the union (+) of all of those entries for all of the accepting states.

   So we can use this table both to give a regular expression for all states that contain 101 ($R_{4,3}^{(4)}$) and also for the languages of strings that do not contain 101 ($R_{4,4}^{(4)}+R_{4,1}^{(4)}+R_{4,2}^{(4)}$)