Equivalência de estados DFA alcançáveis
Agrupe estados alcançáveis de um DFA completo com até 16 estados e quatro símbolos pelos sufixos aceitos.
def dfa_classes(table, accepting):
if type(table) is not list or not 1 <= len(table) <= 16:
raise ValueError("state count")
n = len(table)
if type(table[0]) is not list or not 1 <= len(table[0]) <= 4:
raise ValueError("alphabet size")
width = len(table[0])
if any(type(row) is not list or len(row) != width or
any(type(x) is not int or not 0 <= x < n for x in row)
for row in table):
raise ValueError("complete transition table")
if type(accepting) is not set or any(
type(x) is not int or not 0 <= x < n for x in accepting):
raise ValueError("accepting states")
seen, pending = {0}, [0]
while pending:
for dest in table[pending.pop()]:
if dest not in seen:
seen.add(dest); pending.append(dest)
groups = [g for g in (seen & accepting, seen - accepting) if g]
while True:
owner = {s: i for i, g in enumerate(groups) for s in g}
refined = []
for group in groups:
buckets = {}
for state in sorted(group):
key = tuple(owner[d] for d in table[state])
buckets.setdefault(key, set()).add(state)
refined.extend(buckets.values())
if len(refined) == len(groups):
return sorted([sorted(g) for g in refined])
groups = refined| Projeto | Teste estados equivalentes e distinguíveis, excluindo inalcançáveis e rejeitando transições inválidas. |
|---|---|
| Revise antes de aplicar | Compare o comportamento real com o resultado esperado. Se uma verificação falhar, investigue a causa antes de fazer outras alterações. |
| Modelos | Configure um endpoint compatível com OpenAI ou Anthropic com a URL base e uma chave API, quando necessária. Teste a conexão. O servidor local precisa estar em execução; ferramentas remotas podem transmitir dados separadamente. |
def dfa_classes(table, accepting):
if type(table) is not list or not 1 <= len(table) <= 16:
raise ValueError("state count")
n = len(table)
if type(table[0]) is not list or not 1 <= len(table[0]) <= 4:
raise ValueError("alphabet size")
width = len(table[0])
if any(type(row) is not list or len(row) != width or
any(type(x) is not int or not 0 <= x < n for x in row)
for row in table):
raise ValueError("complete transition table")
if type(accepting) is not set or any(
type(x) is not int or not 0 <= x < n for x in accepting):
raise ValueError("accepting states")
seen, pending = {0}, [0]
while pending:
for dest in table[pending.pop()]:
if dest not in seen:
seen.add(dest); pending.append(dest)
groups = [g for g in (seen & accepting, seen - accepting) if g]
while True:
owner = {s: i for i, g in enumerate(groups) for s in g}
refined = []
for group in groups:
buckets = {}
for state in sorted(group):
key = tuple(owner[d] for d in table[state])
buckets.setdefault(key, set()).add(state)
refined.extend(buckets.values())
if len(refined) == len(groups):
return sorted([sorted(g) for g in refined])
groups = refinedSimplifique código com estado preservando o comportamento observável
StateAmaranth é um ambiente de programação para Windows para examinar software com estado usando um modelo de IA conectado. Comece pelos eventos que o sistema aceita e pelos resultados que um chamador pode observar. Uma solicitação para simplificar estados precisa desse contexto para que uma representação menor não se torne o objetivo à custa do comportamento da aplicação.
O exemplo determinístico de estados fornecido dá uma tarefa concreta: examinar equivalência entre estados alcançáveis preservando o comportamento de aceitação. Inclua na discussão a tabela de transições e o estado inicial pretendido. Peça ao modelo para explicar quais distinções importam antes de solicitar alterações, especialmente se a aplicação ao redor expõe mais que um simples resultado de aceitação ou rejeição.
Revise qualquer agrupamento proposto com sequências curtas de eventos de resultados conhecidos. Inclua caminhos que alcancem estados diferentes e casos com entradas inalcançáveis; depois execute as verificações no projeto. Examine também a interface que consome o agrupamento, pois mudar a numeração ou a representação dos estados pode quebrar chamadores mesmo quando o comportamento de aceitação é preservado.
Um modelo de IA sem restrições pode ser selecionado por um endpoint compatível com OpenAI ou Anthropic aceito que o ofereça. Configure credenciais conforme necessário e verifique limites de contexto e disponibilidade de ferramentas. O comportamento de resposta do modelo continua dependendo do endpoint; as evidências para uma simplificação segura vêm das observações declaradas e das verificações realizadas.
Dúvidas sobre refatoração de máquinas de estados
- O que deve contar como comportamento observável na solicitação?
Liste as saídas ou decisões das quais os chamadores dependem, não apenas nomes internos de estados. Se transições emitem ações ou erros, inclua-os. O exemplo ilustrado baseado em aceitação pode ser mais restrito que o comportamento que sua aplicação real precisa preservar.
- Estados equivalentes quanto à aceitação sempre podem ser mesclados na aplicação?
Não sem verificar o restante do contrato. Sua aplicação pode expor identificadores, ações ou outros efeitos dependentes de estado. Peça ao assistente para examinar esses consumidores antes de aplicar um argumento de equivalência baseado apenas em aceitação.
- Como tratar estados inalcançáveis durante a revisão?
Declare o estado inicial e como a alcançabilidade é determinada. Inclua um caso com entradas inalcançáveis e a saída pretendida. Revise se os chamadores esperam que essas entradas continuem identificáveis antes de aceitar uma remoção ou um reagrupamento proposto.
- O que testar após mudar identificadores de estados?
Confira transições, referências armazenadas e qualquer interface que exiba ou consuma identificadores. Execute sequências comportamentais e verificações da estrutura do agrupamento retornado. Preservar a aceitação, por si só, não prova que o código dependente continue interpretando corretamente a representação.
StateAmaranth · Atualizado 2026-10-25