Removendo estados iguais e estados resultantes. Como: {q0,q0}, {q1,q1}, {q0,q1}, {q1,q0}.

Marcando estados trivialmente não equivalentes (pares com estados de aceitação e de

não-aceitação).

Agora faremos a verificação de equivalência pelos estados não marcados.

A etapa de verificação acabou, logo são removidas as listas encadeadas e visto os estados
equivalentes.

Portanto, são criados 2 novos estados da união dos pares equivalentes: q16, q234.
Por fim a etapa de minimização. É utilizado o autômato não-minimizado para ver as
transições e criar as novas. Primeiro repete-se os estados não-equivalentes.

Os novos estados:

Agora é feito cada transição. Começando por q0. De q0 lendo a: q0 → q1, lendo b: q0 → q6
e lendo c: q0 → q5. Logo lendo ‘a’ e ‘b’, q0 → q16 e lendo ‘c’, q0 → q5.
Agora em q5. De q5 lendo a: q5 → q6, lendo b: q5 → q1 e lendo c: q5 → q4. Então, lendo
‘a’ e ‘b’, q5 → q16 e lendo ‘c’, q5 → q234.

Agora em q7. Em q7 lendo ‘a’, ‘b’ e ‘c’: q7 → q7.

Agora do estado unido q16. Como esse estado é a união dos estados q1 e q6, então as
transições serão as de ambos. Começando por q1, q1 lendo ‘a’: q1 → q3, lendo ‘b’: q1 →
q2, lendo ‘c’: q1 → q7. Agora em q6, q6 lendo ‘a’: q6 → q2, lendo ‘b’: q6 → q3, lendo ‘c’: q6
→ q7. Então, q16 lendo ‘a’ e ‘b’, q16 → q234 e lendo ‘c’, q16 → q7.
Por último, q234, que seriam as transições de q2, q3 e q4. Começando por q2, lendo ‘a’: q2
→ q3, lendo ‘b’: q2 → q7, lendo ‘c’: q2 → q2. Agora em q3, lendo ‘a’: q3 → q2, lendo ‘b’: q3
→ q7, lendo ‘c’: q3 → q3. Por último, q4, lendo ‘a’: q4 → q4, lendo ‘b’: q4 → q7, lendo ‘c’:
q4 → q4. Então, as transições ficariam: lendo ‘a’, q234 → q234, lendo ‘b’, q234 → q7 e
lendo ‘c’, q234 → q234.

E por fim, designam-se os estados de aceitação.

Testes:
É descartado os estados iguais e os estados redundantes.

Agora é marcado os estados trivialmente não equivalentes.

Agora é feita a etapa de verificação dos pares não equivalentes, testando cada transição
dos pares de estados.
Etapa finalizada. É removido as listas encadeadas, os estados sem marcações são
equivalentes.
Os estados então unidos foram os pares: {q3,q10}, {q4,q9}, {q4,q5}, {q5,q9}. Ou juntando,
novos estados q310, q459.
É iniciada então a etapa de minimização com os novos estados. Colocando os estados não
afetados e os novos estados.

Agora, começando por q0, as transições de estados pelos caracteres baseado no automato
anterior. Em q0 lendo ‘a’, q0 -> q10, lendo ‘b’, q0 -> q1, lendo ‘c’, q0 -> q6. Então
minimizando ficaria, em ‘a’, q0 -> q310, ‘b’, q0 -> q1 e ‘c’, q0->q6.

Agora em q1. Em q1 lendo ‘a’, q1 -> q2, lendo ‘b’, q1 -> q11, lendo ‘c’, q1 -> q11. As
transições se mantêm do mesmo modo.
Agora em q2. Em q2 lendo ‘a’, q2 -> q11, lendo ‘b’, q2 -> q3, lendo ‘c’, q2 -> q7. Então o
único que mudaria seria a transição ‘b’, onde iria para o estado q310.

Agora em q6. Em q6 lendo ‘a’ e ‘c’, q6 -> q11, e lendo ‘b’, q6 -> q7. Se mantêm as mesmas
transições.

Agora em q7. Em q7 lendo ‘a’, q7 -> q8, lendo ‘b’, q7 -> q2, lendo ‘c’, q7 -> q6. Se mantêm
as mesmas transições.
Agora em q8. Em q8 lendo ‘a’, q8 -> q9, lendo ‘b’ e ‘c’, q8 -> q11. Altera-se apenas a
transição de ‘a’, onde q8 -> q459.

Por fim, os estados unidos, começando por q310. Em q3 lendo ‘a’, q3 -> q11, lendo ‘b’, q3
-> q4, lendo ‘c’, q3 -> q11. Em q10 lendo ‘a’, q10 -> q11, lendo ‘b’, q10 -> q5, lendo ‘c’, q10
-> q11.Então em ‘a’, q310 -> q11, em ‘c’ também e em ‘b’, q310 -> q459.

Agora em q459. Começando por q4, lendo ‘a’, q4 -> q11, lendo ‘b’, q4 -> q4, lendo ‘c’, q4 ->
q5. Em q5 lendo ‘a’, q5 -> q11, lendo ‘b’, q5 -> q5, lendo ‘c’, q5 -> q9. Em q9 lendo ‘a’, q9 ->
q11, lendo ‘b’, q9 -> q9, lendo ‘c’, q9 -> q5. Então as transições ficaram. Em ‘a’, q349 -> q11,
em ‘b’, q349 -> q349, e em ‘c’, q349 -> q349.
Para finalizar, é designado os estados de aceitação.
Testes:
Removem-se os estados iguais e os redundantes.

Agora é marcado os pares de estados trivialmente equivalentes.

Agora é feita a verificação dos pares de estados, para ver se são equivalentes.
Fim da etapa de verificação, é feito a limpa das listas encadeadas para demonstração dos
estados equivalentes.

Verifica-se que agora existe a união entre 3 estados, q5, q8 e q10. Gerando um novo estado
q5810.
Criando-se rapidamente a minimização, passamos as transições que não se alteraram, e os
estados não equivalentes.
As transições que são portadas sem o acesso ao estado novo. As novas transições seriam
de q5, q8 e q10, mas como são um estado unido ficam como:
Por fim, designar os estados de aceitação.

Testes:
Retirando estados iguais. (q0,q0), (q1,q1)...

Retirando estados redundantes:

Marcando estados trivialmente não equivalentes:

Agora, procura-se os outros estados não equivalentes. Começando pelo par não marcado
{q0,q1}.
Ao ler 0 em {q0,q1} leva-nos ao par {q1,q1}, como q1 = q1 não há nada a ser feito.
Ao ler 1 em {q0,q1} leva-nos ao par {q3,q2}, como q3 ≠ q2, verifica-se a marcação. Como o
par já está marcado, logo o par {q0,q1} não é equivalente.

Consequentemente, faça-se a mesma análise com todos até acabar esta etapa.
Completo as análises, exclui-se as listas encadeadas. Assim é possível notar que q1 é
equivalente a q3 e q2 é equivalente a q4.

Agora, por conta da equivalência é possível unir os pares resultando em: q13 e q24.
Podendo finalizar o processo de simplificação.
Adicionamos q0 (estado sem equivalência), e a união dos equivalentes(q13 e q24):
Agora, conectamos as transições com os estados novos comparando com o autômato
anterior. Começando com q0 ao ler 0 = q0 → q1 e q0 ao ler 1 = q0 → q3. Como q1 e q3
agora são q13, então q0 → q13:

Agora as transições de q13, que seriam as transições de q1 e q3 do autômato anterior.

q1 lendo 0: q1 → q1 e lendo 1: q1 → q2. Agora em q3, q3 lendo 0: q3 → q3 e lendo 1: q3
→ q4. Ou seja, lendo 0: q13 → q13 e lendo 1: q13 → q24.

Por último, as transições de q24, que seriam as transições de q2 e q4 do autômato anterior.

De q2 lendo 0: q2 → q3 e lendo 1: q2 → q4. Agora em q4, q4 lendo 0: q4 → q1 e lendo 1:
q4 → q2. Ou seja, lendo 0: q24 → q13 e lendo 1: q24 → q24.
Por fim, definem-se os estados de aceitação. Finalizando então a minimização.
Teste: