Equivalenza degli stati DFA raggiungibili
Raggruppa gli stati raggiungibili di un DFA completo con massimo 16 stati e quattro simboli secondo i suffissi accettati.
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| Progetto | Controlla stati equivalenti e distinguibili, escludendo gli irraggiungibili e rifiutando transizioni errate. |
|---|---|
| Controlla prima di applicare | Confronta il comportamento effettivo con il risultato atteso. Se una verifica fallisce, indaga la causa prima di altre modifiche. |
| Modelli | Configura un endpoint compatibile con OpenAI o Anthropic usando URL di base e chiave API, se necessaria. Prova la connessione. Il server locale deve essere in esecuzione; gli strumenti remoti possono trasmettere dati separatamente. |
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 = refinedSemplifica il codice con stato preservando il comportamento osservabile
StateAmaranth è un ambiente di programmazione per Windows per esaminare software con stato con un modello di IA collegato. Parti dagli eventi accettati dal sistema e dai risultati osservabili dal chiamante. Una richiesta di semplificare gli stati necessita di quel contesto affinché una rappresentazione più piccola non diventi l'obiettivo a scapito del comportamento dell'applicazione.
L'esempio fornito di stati deterministici dà un'attività concreta: esaminare l'equivalenza tra stati raggiungibili preservando il comportamento di accettazione. Porta nella discussione la tabella delle transizioni e lo stato iniziale previsto. Chiedi al modello di spiegare quali distinzioni contano prima di richiedere modifiche, soprattutto se l'applicazione circostante espone più di un semplice risultato di accettazione o rifiuto.
Rivedi ogni raggruppamento proposto usando brevi sequenze di eventi con risultati noti. Includi percorsi che raggiungono stati diversi e casi con voci irraggiungibili, poi esegui i controlli nel progetto. Esamina anche l'interfaccia che usa il raggruppamento, perché cambiare numerazione o rappresentazione degli stati può compromettere i chiamanti anche preservando il comportamento di accettazione.
Puoi selezionare un modello di IA senza restrizioni tramite un endpoint supportato compatibile con OpenAI o Anthropic che ne offra uno. Configura le credenziali necessarie e verifica limiti di contesto e disponibilità degli strumenti. Il comportamento delle risposte del modello continua a dipendere dall'endpoint; le prove per una semplificazione sicura provengono dalle osservazioni dichiarate e dai controlli eseguiti.
Domande sulla ristrutturazione di una macchina a stati
- Cosa deve contare come comportamento osservabile nella richiesta?
Elenca output o decisioni su cui fanno affidamento i chiamanti, non solo nomi degli stati interni. Se le transizioni producono azioni o errori, includili. L'esempio illustrato basato sull'accettazione può essere più ristretto del comportamento che la tua applicazione deve preservare.
- Stati equivalenti per accettazione possono sempre essere uniti nell'app?
Non senza verificare il resto del contratto. L'applicazione può esporre identificatori, azioni o altri effetti dipendenti dallo stato. Chiedi all'assistente di esaminare quel codice utilizzatore prima di applicare un ragionamento di equivalenza basato solo sull'accettazione.
- Come gestire gli stati irraggiungibili durante la revisione?
Indica lo stato iniziale e come viene determinata la raggiungibilità. Includi un caso con voci irraggiungibili e l'output previsto. Rivedi se i chiamanti si aspettano che quelle voci restino identificabili prima di accettare una rimozione o un nuovo raggruppamento.
- Cosa devo testare dopo aver cambiato gli identificatori degli stati?
Controlla transizioni, riferimenti memorizzati e ogni interfaccia che mostra o usa identificatori. Esegui sequenze comportamentali oltre ai controlli sulla struttura del raggruppamento restituito. La sola accettazione preservata non dimostra che il codice dipendente interpreti ancora correttamente la rappresentazione.
StateAmaranth · Aggiornato 2026-10-25