Proving Regularity of Overlapping Substrings: {w|ww ∈ L} Given L is Regular

Given a regular language ( L ), how can we prove that the language ( L' { w mid ww in L } ) is also regular? This article delves into a detailed proof using closure properties of regular languages, particularly focusing on the construction of a deterministic finite automaton (DFA) for ( L' ).

Proof Outline

To prove that ( L' { w mid ww in L } ) is a regular language, we can leverage the closure properties of regular languages. Specifically, we utilize the closure under concatenation and homomorphism. The key step involves constructing a new DFA that recognizes the language ( L' ).

Closure Properties

Regular languages are closed under concatenation and homomorphism. This means that if we have two regular languages ( A ) and ( B ), the concatenation ( A cdot B ) and the homomorphic transformation ( f(A) ) are also regular. In our case, we will use the closure under concatenation and homomorphism to construct the automaton recognizing ( L' ).

Constructing a Finite Automaton for ( L )

Given that ( L ) is a regular language, there exists a Deterministic Finite Automaton (DFA) ( M (Q, Sigma, delta, q_0, F) ) that recognizes ( L ).

Constructing a New Automaton for ( L' )

We need to construct a DFA ( M' ) that recognizes ( L' ). The key idea here is to simulate the original DFA ( M ) on the input ( w ) twice and check whether both instances are accepted by ( M ).

State Tracking

We can track the state of ( M ) as it processes the first ( w ) and then simulate processing the second ( w ). Specifically, we can create a new DFA ( M' ) with the following properties:

States: The states of ( M' ) will be pairs of states from ( M ), so ( Q' Q times Q ). Start State: The start state of ( M' ) will be ( (q_0, q_0) ). Transition Function: The transition function ( delta' ) for ( M' ) will be defined as follows:

For each symbol ( a in Sigma ) and for each pair of states ( (q, r) in Q' ):

If ( delta(q, a) q' ) and ( delta(r, a) r' ), then ( delta'((q, r), a) (q', r') ). After reading the first ( w ) and reaching state ( (q, r) ), switch the second state to the state obtained by processing the same input ( w ) again: ( delta'((q, r), a) (q, delta'(r, a)) ).

Accepting Condition

The DFA ( M' ) will accept ( w ) if, after processing the input, the second component of the pair is in the set of accepting states ( F ) of the original DFA ( M ).

Formal Construction

States: The states of ( M' ) are pairs ( (q, r) ) where ( q, r in Q ).

Start State: The start state of ( M' ) is ( (q_0, q_0) ).

Transition Function:

For each symbol ( a in Sigma ) and for each pair ( (q, r) in Q' ):

Transition on ( a ) in the first component: ( q' delta(q, a) ). Transition on ( a ) in the second component: ( r' delta(r, a) ). Construct the new state: ( delta'((q, r), a) (q', r') ). After reading the first ( w ) and reaching state ( (q, r) ), switch the second state to the state obtained by processing the same input ( w ) again: ( delta'((q, r), a) (q, delta'(r, a)) ).

Accepting Condition: ( M' ) will accept ( w ) if and only if, after processing the input, the second component of the pair is in the set of accepting states ( F ) of the original DFA ( M ).

Conclusion

Since we have constructed a new DFA ( M' ) that recognizes ( L' ) based on the transitions of the original DFA ( M ), and since the set of states and the transition function are finite, ( L' ) is also a regular language. Therefore, we conclude that if ( L ) is a regular language, then ( L' { w mid ww in L } ) is also a regular language.

This proof demonstrates the power of closure properties in finite automata theory and how they can be used to derive new regular languages from existing ones.