Differences
This shows you the differences between two versions of the page.
| Both sides previous revision Previous revision | |||
|
lfa:2024:lab07 [2024/11/18 20:57] cata_chiru |
lfa:2024:lab07 [2024/11/18 21:00] (current) cata_chiru |
||
|---|---|---|---|
| Line 17: | Line 17: | ||
| - | <hidden> | + | <hidden Solution 7.2.1.> |
| $math[L/a = L((aaa \cup ba)^*(aa \cup b))] | $math[L/a = L((aaa \cup ba)^*(aa \cup b))] | ||
| </hidden> | </hidden> | ||
| Line 25: | Line 25: | ||
| - | <hidden> | + | <hidden Solution 7.2.2.> |
| $math[L/a = L(a^*)] | $math[L/a = L(a^*)] | ||
| </hidden> | </hidden> | ||
| Line 33: | Line 33: | ||
| - | <hidden> | + | <hidden Solution 7.2.3.> |
| Let $math[A] be a DFA which accepts $math[L]. We build a new DFA $math[A/c] which accepts $math[L/c]. This new DFA has the same number of states, initial state, same transitions and same alphabet. The set of final states is different though: $math[F/c = \{q' \in K | \exists q \in F. \delta(q',c) = q\}]. In other words, the final states of $math[A/c] are those states which are $math[c-]predecessors of some final state of $math[A]. Note that some $math[q'] may be equal to $math[q], and it may also be the case that no such predecessors exist. | Let $math[A] be a DFA which accepts $math[L]. We build a new DFA $math[A/c] which accepts $math[L/c]. This new DFA has the same number of states, initial state, same transitions and same alphabet. The set of final states is different though: $math[F/c = \{q' \in K | \exists q \in F. \delta(q',c) = q\}]. In other words, the final states of $math[A/c] are those states which are $math[c-]predecessors of some final state of $math[A]. Note that some $math[q'] may be equal to $math[q], and it may also be the case that no such predecessors exist. | ||
| </hidden> | </hidden> | ||
| Line 41: | Line 41: | ||
| - | <hidden> | + | <hidden Solution 7.2.4.> |
| The easiest way is to rely on other closure properties: $math[c/L = reverse(reverse(L)/c)] | The easiest way is to rely on other closure properties: $math[c/L = reverse(reverse(L)/c)] | ||
| </hidden> | </hidden> | ||
| Line 51: | Line 51: | ||
| - | <hidden> | + | <hidden Solution 7.3.1.> |
| Suppose $math[A] is the accepting DFA of L. We build a new NFA from A by adding $math[\epsilon-]transitions from the initial state to all other states of A (obs: if the initial state of A had transitions that entered it, then, in the new NFA, create another initial state that has an $math[\epsilon-]transition to the former initial state). Thus, we can nondeterministically //skip// any prefix $math[x] of any accepted word from $math[L]. This new DFA accepts $math[\text{suffix(L)}] | Suppose $math[A] is the accepting DFA of L. We build a new NFA from A by adding $math[\epsilon-]transitions from the initial state to all other states of A (obs: if the initial state of A had transitions that entered it, then, in the new NFA, create another initial state that has an $math[\epsilon-]transition to the former initial state). Thus, we can nondeterministically //skip// any prefix $math[x] of any accepted word from $math[L]. This new DFA accepts $math[\text{suffix(L)}] | ||
| </hidden> | </hidden> | ||
| Line 64: | Line 64: | ||
| - | <hidden> | + | <hidden Solution 7.4.1.> |
| $math[min(L)] is the set of words from $math[L] that have no proper ($math[\neq \epsilon]) prefix in $math[L]. | $math[min(L)] is the set of words from $math[L] that have no proper ($math[\neq \epsilon]) prefix in $math[L]. | ||
| </hidden> | </hidden> | ||
| Line 72: | Line 72: | ||
| - | <hidden> | + | <hidden Solution 7.4.2.> |
| $math[min(L(a^*)) = \{\epsilon\}] | $math[min(L(a^*)) = \{\epsilon\}] | ||
| </hidden> | </hidden> | ||
| Line 80: | Line 80: | ||
| - | <hidden> | + | <hidden Solution 7.4.3.> |
| No word from $math[L(a^*b)] has a prefix in this same language, hence the answer is $math[L(a^*b)]. | No word from $math[L(a^*b)] has a prefix in this same language, hence the answer is $math[L(a^*b)]. | ||
| </hidden> | </hidden> | ||
| Line 88: | Line 88: | ||
| - | <hidden> | + | <hidden Solution 7.4.4.> |
| Let $math[A] be the accepting DFA of L. If a word $math[w=xy \in L] has a proper prefix $math[x] in $math[L], then $math[(q_0,xy) \vdash^* (q_1,x) \vdash^* (q_2,\epsilon)] where $math[q_1,q_2] are final states. We need to //break-off// those paths leading from one final state (such as $math[q_1]) to another. | Let $math[A] be the accepting DFA of L. If a word $math[w=xy \in L] has a proper prefix $math[x] in $math[L], then $math[(q_0,xy) \vdash^* (q_1,x) \vdash^* (q_2,\epsilon)] where $math[q_1,q_2] are final states. We need to //break-off// those paths leading from one final state (such as $math[q_1]) to another. | ||
| Line 99: | Line 99: | ||
| - | <hidden> | + | <hidden Solution 7.4.5.> |
| The language $math[R] contains all those words formed by taking any suffix $math[x] of a word from $math[L] an appending its respective prefix $math[y] to it. | The language $math[R] contains all those words formed by taking any suffix $math[x] of a word from $math[L] an appending its respective prefix $math[y] to it. | ||
| We start from the accepting DFA $math[A] of $math[L]. We create a new initial state and a new final one. All states of A are no longer initial or final in our construction. We create $math[n] copies of $math[A], denoted as $math[A_q], one for each state $math[q\in K] of $math[A]. | We start from the accepting DFA $math[A] of $math[L]. We create a new initial state and a new final one. All states of A are no longer initial or final in our construction. We create $math[n] copies of $math[A], denoted as $math[A_q], one for each state $math[q\in K] of $math[A]. | ||
| Line 117: | Line 117: | ||
| **7.5.1.** Identify **different strategies** to verify that two regular expressions generate the same language. State them as algorithmic procedures. | **7.5.1.** Identify **different strategies** to verify that two regular expressions generate the same language. State them as algorithmic procedures. | ||
| - | <hidden> All strategies require building DFAs from the regexes. | + | <hidden Solution 7.5.1.> |
| + | All strategies require building DFAs from the regexes. | ||
| - You can use an existing minimisation algorithm to find the minimal DFAs. Then, label each state from each DFA from 0 to |K|. Fix an ordering of the symbols of the alphabet. Sort the transitions by symbol. Make a textual representation of each DFA which includes the number of states and the sorted transition function. If the textual representations of the two DFAs are identical then they accept the same language. | - You can use an existing minimisation algorithm to find the minimal DFAs. Then, label each state from each DFA from 0 to |K|. Fix an ordering of the symbols of the alphabet. Sort the transitions by symbol. Make a textual representation of each DFA which includes the number of states and the sorted transition function. If the textual representations of the two DFAs are identical then they accept the same language. | ||
| - Use the indistinguishability algorithm to check if the two initial states of the two DFAs are indistinguishable. | - Use the indistinguishability algorithm to check if the two initial states of the two DFAs are indistinguishable. | ||