From 9719324d4139c194d6a09fb432d8e886db7000e3 Mon Sep 17 00:00:00 2001 From: David Allemang Date: Thu, 1 Oct 2026 10:02:14 -0400 Subject: [PATCH] simple tree walk --- finite-state-refine.py | 187 +++++++++++++++++++++++++++++++---------- finite_state.py | 176 +++++++++++++++++++++++--------------- grammar.py | 47 +++++++---- permute.py | 168 +++++++++++++++++++++++++++--------- simple-enum.py | 170 +++++++++++++++++++++++++++++++++++++ 5 files changed, 579 insertions(+), 169 deletions(-) create mode 100644 simple-enum.py diff --git a/finite-state-refine.py b/finite-state-refine.py index d7b0a3db..75b39bc9 100644 --- a/finite-state-refine.py +++ b/finite-state-refine.py @@ -10,23 +10,28 @@ import tqdm # 1. CORE TYPES & ENUMS # ========================================== + class Edge(IntEnum): RISING = 0 FALLING_PENDING = 1 FALLING_UTILIZED = 2 + class Context(IntEnum): OTHER = 0 WIRE = 1 DIODE = 2 + START_STATE = "START" + @dataclass(frozen=True) class Entry: priority: int delay: int - name: str = '-' + name: str = "-" + @dataclass(frozen=True) class Transition: @@ -37,8 +42,14 @@ class Transition: def total_delay(self) -> int: return sum(e.delay for e in self.entries) + class TilesetFSM: - def __init__(self, transitions: List[Transition], start_state: str, accept_states: Set[Union[Tuple[Edge, Context], str]]): + def __init__( + self, + transitions: List[Transition], + start_state: str, + accept_states: Set[Union[Tuple[Edge, Context], str]], + ): self.transitions = transitions self.start_state = start_state self.accept_states = accept_states @@ -53,6 +64,7 @@ class TilesetFSM: # 2. EVENT-DRIVEN SORTING (Numba-Ready) # ========================================== + def get_timing_events(chain: Tuple[Entry, ...]) -> Tuple[Tuple[int, int], ...]: """Converts a chain into a dense tuple of (tick, priority) events.""" events = [] @@ -63,6 +75,7 @@ def get_timing_events(chain: Tuple[Entry, ...]) -> Tuple[Tuple[int, int], ...]: tick += e.delay return tuple(events) + def cmp_chains(chain_a: Tuple[Entry, ...], chain_b: Tuple[Entry, ...]) -> int: """ O(K) lexicographical comparison replicating the behavior of `-inf` padding. @@ -77,8 +90,10 @@ def cmp_chains(chain_a: Tuple[Entry, ...], chain_b: Tuple[Entry, ...]) -> int: tick_b, pri_b = events_b[idx_b] if tick_a == tick_b: - if pri_a < pri_b: return -1 - if pri_a > pri_b: return 1 + if pri_a < pri_b: + return -1 + if pri_a > pri_b: + return 1 idx_a += 1 idx_b += 1 elif tick_a < tick_b: @@ -87,12 +102,16 @@ def cmp_chains(chain_a: Tuple[Entry, ...], chain_b: Tuple[Entry, ...]) -> int: else: return -1 - if idx_a < len(events_a): return 1 - if idx_b < len(events_b): return -1 + if idx_a < len(events_a): + return 1 + if idx_b < len(events_b): + return -1 # Tie-breaker on component count (fewer components is preferred/smaller) - if len(chain_a) < len(chain_b): return -1 - if len(chain_a) > len(chain_b): return 1 + if len(chain_a) < len(chain_b): + return -1 + if len(chain_a) > len(chain_b): + return 1 return 0 @@ -108,55 +127,91 @@ for edge in Edge: # A. Wire if ctx == Context.DIODE: - transitions.append(Transition(state, (edge, Context.WIRE), (Entry(0, 0, '---'),))) + transitions.append( + Transition(state, (edge, Context.WIRE), (Entry(0, 0, "---"),)) + ) # B. Torch if ctx == Context.DIODE: if edge == Edge.RISING: - transitions.append(Transition(state, (Edge.FALLING_PENDING, Context.OTHER), (Entry(0, 2, 'torch '),))) + transitions.append( + Transition( + state, + (Edge.FALLING_PENDING, Context.OTHER), + (Entry(0, 2, "torch "),), + ) + ) elif edge == Edge.FALLING_UTILIZED: - transitions.append(Transition(state, (Edge.RISING, Context.OTHER), (Entry(0, 2, 'torch '),))) + transitions.append( + Transition( + state, (Edge.RISING, Context.OTHER), (Entry(0, 2, "torch "),) + ) + ) # C. Comparator cmp_pri = -1 if ctx == Context.DIODE else 0 - transitions.append(Transition(state, (edge, Context.DIODE), (Entry(cmp_pri, 2, 'cmp'),))) + transitions.append( + Transition(state, (edge, Context.DIODE), (Entry(cmp_pri, 2, "cmp"),)) + ) # D. Repeaters for d in (2, 4, 6, 8): if ctx == Context.DIODE: - transitions.append(Transition(state, (edge, Context.DIODE), (Entry(-3, d, f're{d}'),))) + transitions.append( + Transition(state, (edge, Context.DIODE), (Entry(-3, d, f"re{d}"),)) + ) else: if edge == Edge.RISING: if ctx != Context.WIRE: - transitions.append(Transition(state, (edge, Context.DIODE), (Entry(-1, d, f're{d}'),))) + transitions.append( + Transition( + state, (edge, Context.DIODE), (Entry(-1, d, f"re{d}"),) + ) + ) else: - transitions.append(Transition(state, (Edge.FALLING_UTILIZED, Context.DIODE), (Entry(-2, d, f're{d}'),))) + transitions.append( + Transition( + state, + (Edge.FALLING_UTILIZED, Context.DIODE), + (Entry(-2, d, f"re{d}"),), + ) + ) # E. Fluids if edge == Edge.RISING: for d in (5, 10, 30): - fluid_macro = (Entry(0, 2, 'obs'), Entry(1, d, f'fluid{d}'), Entry(0, 4, 'disp')) - transitions.append(Transition(state, (Edge.RISING, Context.OTHER), fluid_macro)) + fluid_macro = ( + Entry(0, 2, "obs"), + Entry(1, d, f"fluid{d}"), + Entry(0, 4, "disp"), + ) + transitions.append( + Transition(state, (Edge.RISING, Context.OTHER), fluid_macro) + ) # START state boundary start_transitions = [] for t in transitions: if t.from_state == (Edge.RISING, Context.OTHER): - if not (len(t.entries) == 1 and t.entries[0].name == '---'): + if not (len(t.entries) == 1 and t.entries[0].name == "---"): start_transitions.append(Transition(START_STATE, t.to_state, t.entries)) -start_transitions.append(Transition(START_STATE, (Edge.FALLING_PENDING, Context.OTHER), (Entry(0, 2, 'torch '),))) +start_transitions.append( + Transition( + START_STATE, (Edge.FALLING_PENDING, Context.OTHER), (Entry(0, 2, "torch "),) + ) +) transitions.extend(start_transitions) -all_states = set(t.from_state for t in transitions) | set(t.to_state for t in transitions) +all_states = set(t.from_state for t in transitions) | set( + t.to_state for t in transitions +) # Accept states are any normal state tuple (skip START_STATE string) accept_states = {s for s in all_states if isinstance(s, tuple) and s[0] == Edge.RISING} model = TilesetFSM( - transitions=transitions, - start_state=START_STATE, - accept_states=accept_states + transitions=transitions, start_state=START_STATE, accept_states=accept_states ) @@ -164,6 +219,7 @@ model = TilesetFSM( # 4. FAST DP GENERATOR # ========================================== + def generate_all_fast(model: TilesetFSM, target_delay: int) -> List[List[Entry]]: all_states = set(model.adj_list.keys()) | model.accept_states can_reach = {d: {s: False for s in all_states} for d in range(target_delay + 1)} @@ -206,7 +262,10 @@ def generate_all_fast(model: TilesetFSM, target_delay: int) -> List[List[Entry]] return [list(c) for c in sorted_chains] -def cmp_prefix(events_prefix: Tuple[Tuple[int, int], ...], events_target: Tuple[Tuple[int, int], ...]) -> int: +def cmp_prefix( + events_prefix: Tuple[Tuple[int, int], ...], + events_target: Tuple[Tuple[int, int], ...], +) -> int: """ Evaluates prefix divergence. Returns 0 if they match exactly so far. If it returns non-zero, the divergence is permanent for ANY valid completion. @@ -217,8 +276,10 @@ def cmp_prefix(events_prefix: Tuple[Tuple[int, int], ...], events_target: Tuple[ tick_t, pri_t = events_target[idx_t] if tick_p == tick_t: - if pri_p < pri_t: return -1 - if pri_p > pri_t: return 1 + if pri_p < pri_t: + return -1 + if pri_p > pri_t: + return 1 idx_p += 1 idx_t += 1 elif tick_p < tick_t: @@ -228,7 +289,9 @@ def cmp_prefix(events_prefix: Tuple[Tuple[int, int], ...], events_target: Tuple[ return 0 -def neighborhood(model: TilesetFSM, target_chain: List[Entry], before: int, after: int) -> Tuple[List[List[Entry]], List[List[Entry]]]: +def neighborhood( + model: TilesetFSM, target_chain: List[Entry], before: int, after: int +) -> Tuple[List[List[Entry]], List[List[Entry]]]: """ Finds the exact immediate neighborhood around a target chain without enumerating the language. Uses DP-guided Branch and Bound to prune the astronomical search space. @@ -239,7 +302,8 @@ def neighborhood(model: TilesetFSM, target_chain: List[Entry], before: int, afte # 1. Build the Reachability Table (O(States * Target Delay) - Extremely Fast) all_states = set(model.adj_list.keys()) | model.accept_states can_reach = {d: {s: False for s in all_states} for d in range(target_delay + 1)} - for s in model.accept_states: can_reach[0][s] = True + for s in model.accept_states: + can_reach[0][s] = True for d in range(1, target_delay + 1): for state in all_states: for t in model.adj_list.get(state, []): @@ -252,9 +316,14 @@ def neighborhood(model: TilesetFSM, target_chain: List[Entry], before: int, afte return cmp_chains(t1.entries, t2.entries) # Ascending sort: Explores lexicographically smaller transitions first - adj_list_asc = {k: sorted(v, key=cmp_to_key(cmp_transitions)) for k, v in model.adj_list.items()} + adj_list_asc = { + k: sorted(v, key=cmp_to_key(cmp_transitions)) for k, v in model.adj_list.items() + } # Descending sort: Explores lexicographically larger transitions first - adj_list_desc = {k: sorted(v, key=cmp_to_key(cmp_transitions), reverse=True) for k, v in model.adj_list.items()} + adj_list_desc = { + k: sorted(v, key=cmp_to_key(cmp_transitions), reverse=True) + for k, v in model.adj_list.items() + } # --- SEARCH AFTER --- found_after = {} @@ -272,23 +341,36 @@ def neighborhood(model: TilesetFSM, target_chain: List[Entry], before: int, afte found_after[ev_key] = chain if len(found_after) > after: - sorted_items = sorted(found_after.values(), key=cmp_to_key(cmp_chains)) - found_after = {get_timing_events(c): c for c in sorted_items[:after]} + sorted_items = sorted( + found_after.values(), key=cmp_to_key(cmp_chains) + ) + found_after = { + get_timing_events(c): c for c in sorted_items[:after] + } ub_chain = sorted_items[after - 1] ub_events = get_timing_events(ub_chain) continue # Prune branches that are <= target or > our worst accepted bound div_t = cmp_prefix(events_so_far, events_target) - if div_t < 0: continue - if ub_events and cmp_prefix(events_so_far, ub_events) > 0: continue + if div_t < 0: + continue + if ub_events and cmp_prefix(events_so_far, ub_events) > 0: + continue # Push in reverse so the smallest transitions are popped/explored first for t in reversed(adj_list_asc.get(curr_state, [])): t_delay = t.total_delay() if t_delay <= rem_delay and can_reach[rem_delay - t_delay][t.to_state]: new_chain = chain + t.entries - stack.append((t.to_state, rem_delay - t_delay, new_chain, get_timing_events(new_chain))) + stack.append( + ( + t.to_state, + rem_delay - t_delay, + new_chain, + get_timing_events(new_chain), + ) + ) # --- SEARCH BEFORE --- found_before = {} @@ -305,29 +387,43 @@ def neighborhood(model: TilesetFSM, target_chain: List[Entry], before: int, afte found_before[ev_key] = chain if len(found_before) > before: - sorted_items = sorted(found_before.values(), key=cmp_to_key(cmp_chains)) - found_before = {get_timing_events(c): c for c in sorted_items[-before:]} + sorted_items = sorted( + found_before.values(), key=cmp_to_key(cmp_chains) + ) + found_before = { + get_timing_events(c): c for c in sorted_items[-before:] + } lb_chain = sorted_items[-before] lb_events = get_timing_events(lb_chain) continue # Prune branches that are >= target or < our worst accepted bound div_t = cmp_prefix(events_so_far, events_target) - if div_t > 0: continue - if lb_events and cmp_prefix(events_so_far, lb_events) < 0: continue + if div_t > 0: + continue + if lb_events and cmp_prefix(events_so_far, lb_events) < 0: + continue # Push in reverse so the largest transitions are popped/explored first for t in reversed(adj_list_desc.get(curr_state, [])): t_delay = t.total_delay() if t_delay <= rem_delay and can_reach[rem_delay - t_delay][t.to_state]: new_chain = chain + t.entries - stack.append((t.to_state, rem_delay - t_delay, new_chain, get_timing_events(new_chain))) + stack.append( + ( + t.to_state, + rem_delay - t_delay, + new_chain, + get_timing_events(new_chain), + ) + ) sorted_before = sorted(found_before.values(), key=cmp_to_key(cmp_chains)) sorted_after = sorted(found_after.values(), key=cmp_to_key(cmp_chains)) return [list(c) for c in sorted_before], [list(c) for c in sorted_after] + def format_csv_timing(chain: List[Entry], target_delay: int) -> str: """Helper to reconstruct your original CSV string format without allocating infs.""" events = dict(get_timing_events(tuple(chain))) @@ -374,8 +470,10 @@ def parse_names(model: TilesetFSM, names: List[str]) -> List[Entry]: chunk_norm = [] for n in chunk: n = n.strip() - if n == 'wire': n = '---' - if n.startswith('rep'): n = n.replace('rep', 're') + if n == "wire": + n = "---" + if n.startswith("rep"): + n = n.replace("rep", "re") chunk_norm.append(n) # Check if this transition matches the input @@ -400,13 +498,14 @@ def parse_names(model: TilesetFSM, names: List[str]) -> List[Entry]: return inferred_chain + # ========================================== # USAGE EXAMPLE # ========================================== if __name__ == "__main__": # Your target sequence (using friendly names!) - input_str = 'cmp rep2 torch rep2 torch' + input_str = "cmp rep2 torch rep2 torch" names_list = input_str.split() print(f"Parsing: {names_list}...") @@ -431,4 +530,4 @@ if __name__ == "__main__": print("\n--- AFTER ---") for c in after_chains: - print_chain(c) \ No newline at end of file + print_chain(c) diff --git a/finite_state.py b/finite_state.py index 0e1727d6..8353e9ea 100644 --- a/finite_state.py +++ b/finite_state.py @@ -9,13 +9,14 @@ import tqdm class Entry: priority: int delay: int - name: str = '-' + name: str = "-" def linear_parts(self) -> Tuple[int | float, ...]: if self.delay == 0: return () return (self.priority,) + (-inf,) * (self.delay - 1) + @dataclass(frozen=True) class Transition: from_state: str @@ -28,8 +29,11 @@ class Transition: def total_delay(self) -> int: return sum(e.delay for e in self.entries) + class TilesetFSM: - def __init__(self, transitions: List[Transition], start_state: str, accept_states: Set[str]): + def __init__( + self, transitions: List[Transition], start_state: str, accept_states: Set[str] + ): self.transitions = transitions self.start_state = start_state self.accept_states = accept_states @@ -39,22 +43,30 @@ class TilesetFSM: for t in transitions: self.adj_list[t.from_state].append(t) - def _check_divergence(self, prefix: Tuple[int, ...], target: Tuple[int, ...]) -> int: + def _check_divergence( + self, prefix: Tuple[int, ...], target: Tuple[int, ...] + ) -> int: """ Returns -1 if prefix is lexicographically < target, 1 if prefix is lexicographically > target, 0 if prefix is a strict prefix of target (no divergence yet). """ for p_val, t_val in zip(prefix, target): - if p_val < t_val: return -1 - if p_val > t_val: return 1 + if p_val < t_val: + return -1 + if p_val > t_val: + return 1 return 0 - def find_next(self, current_lin: Tuple[int, ...], target_delay: int) -> Optional[List[Entry]]: + def find_next( + self, current_lin: Tuple[int, ...], target_delay: int + ) -> Optional[List[Entry]]: best_next_chain = None best_next_lin = None - def dfs(chain_so_far: Tuple[Transition, ...], delay_so_far: int, current_state: str): + def dfs( + chain_so_far: Tuple[Transition, ...], delay_so_far: int, current_state: str + ): nonlocal best_next_chain, best_next_lin # Base Case: Exact delay reached AND machine is in an accepting state @@ -73,8 +85,10 @@ class TilesetFSM: p_lin = tuple(p for t in chain_so_far for p in t.linearize()) # Prefix Pruning - if self._check_divergence(p_lin, current_lin) == -1: return - if best_next_lin and self._check_divergence(p_lin, best_next_lin) == 1: return + if self._check_divergence(p_lin, current_lin) == -1: + return + if best_next_lin and self._check_divergence(p_lin, best_next_lin) == 1: + return for t in self.adj_list.get(current_state, []): dfs(chain_so_far + (t,), delay_so_far + t.total_delay(), t.to_state) @@ -137,37 +151,45 @@ for signal in signals: # A. Wire if context == "DIODE": - transitions.append(Transition( - from_state=current_state, - to_state=f"{signal}_WIRE", - entries=(Entry(0, 0, '---'),) - )) + transitions.append( + Transition( + from_state=current_state, + to_state=f"{signal}_WIRE", + entries=(Entry(0, 0, "---"),), + ) + ) # B. Torch if context == "DIODE": if signal == "NORMAL": # Enter inverted mode as PENDING (haven't used -2 yet) - transitions.append(Transition( - from_state=current_state, - to_state="INV_PENDING_OTHER", - entries=(Entry(0, 2, 'torch '),) - )) + transitions.append( + Transition( + from_state=current_state, + to_state="INV_PENDING_OTHER", + entries=(Entry(0, 2, "torch "),), + ) + ) elif signal == "INV_UTILIZED": # Un-invert is ONLY allowed if we successfully utilized the -2 priority - transitions.append(Transition( - from_state=current_state, - to_state="NORMAL_OTHER", - entries=(Entry(0, 2, 'torch '),) - )) + transitions.append( + Transition( + from_state=current_state, + to_state="NORMAL_OTHER", + entries=(Entry(0, 2, "torch "),), + ) + ) # Notice there is no torch transition for INV_PENDING! # C. Comparator cmp_pri = -1 if context == "DIODE" else 0 - transitions.append(Transition( - from_state=current_state, - to_state=f"{signal}_DIODE", - entries=(Entry(cmp_pri, 2, 'cmp'),) - )) + transitions.append( + Transition( + from_state=current_state, + to_state=f"{signal}_DIODE", + entries=(Entry(cmp_pri, 2, "cmp"),), + ) + ) # D. Repeaters for d in (2, 4, 6, 8): @@ -180,30 +202,38 @@ for signal in signals: if signal == "NORMAL": rep_pri = -1 next_signal = signal - allow_rep = (context != "WIRE") # Block redundant rep after + allow_rep = context != "WIRE" # Block redundant rep after else: # We are in an inverted mode and facing OTHER/WIRE. # This yields the special -2 priority! rep_pri = -2 - next_signal = "INV_UTILIZED" # Mark the -2 as successfully utilized + next_signal = "INV_UTILIZED" # Mark the -2 as successfully utilized allow_rep = True if allow_rep: - transitions.append(Transition( - from_state=current_state, - to_state=f"{next_signal}_DIODE", - entries=(Entry(rep_pri, d, f're{d}'),) - )) + transitions.append( + Transition( + from_state=current_state, + to_state=f"{next_signal}_DIODE", + entries=(Entry(rep_pri, d, f"re{d}"),), + ) + ) # E. Fluids if signal == "NORMAL": for d in (5, 10, 30): - fluid_macro = (Entry(0, 2, 'obs'), Entry(1, d, f'fluid{d}'), Entry(0, 4, 'disp')) - transitions.append(Transition( - from_state=current_state, - to_state="NORMAL_OTHER", - entries=fluid_macro - )) + fluid_macro = ( + Entry(0, 2, "obs"), + Entry(1, d, f"fluid{d}"), + Entry(0, 4, "disp"), + ) + transitions.append( + Transition( + from_state=current_state, + to_state="NORMAL_OTHER", + entries=fluid_macro, + ) + ) # ========================================== # 2. CREATE THE BOUNDARY 'START' STATE @@ -213,39 +243,42 @@ start_transitions = [] for t in transitions: if t.from_state == "NORMAL_OTHER": # Allow everything EXCEPT the zero-delay at the very start - if not (len(t.entries) == 1 and t.entries[0].name == '---'): - start_transitions.append(Transition( - from_state="START", - to_state=t.to_state, - entries=t.entries - )) -start_transitions.append(Transition( - from_state="START", - to_state="INV_PENDING_OTHER", - entries=(Entry(0, 2, 'torch '),) -)) + if not (len(t.entries) == 1 and t.entries[0].name == "---"): + start_transitions.append( + Transition(from_state="START", to_state=t.to_state, entries=t.entries) + ) +start_transitions.append( + Transition( + from_state="START", + to_state="INV_PENDING_OTHER", + entries=(Entry(0, 2, "torch "),), + ) +) transitions.extend(start_transitions) -all_states = set(t.from_state for t in transitions) | set(t.to_state for t in transitions) +all_states = set(t.from_state for t in transitions) | set( + t.to_state for t in transitions +) accept_states = {s for s in all_states if s.startswith("NORMAL")} model = TilesetFSM( - transitions=transitions, - start_state='START', - accept_states=accept_states + transitions=transitions, start_state="START", accept_states=accept_states ) # ========================================== # 2. USAGE EXAMPLES # ========================================== + def display_chain(entries): # Print the chain, highlighting the name and generated priority return " <- ".join([f"{e.name}({e.priority})" for e in entries]) + def linearize_entries(entries): return tuple(p for e in entries for p in e.linear_parts()) + def generate_all_fast(model: TilesetFSM, target_delay: int) -> List[List[Entry]]: """ Uses Dynamic Programming to generate all valid chains of a given delay in O(N log N) time, @@ -273,7 +306,9 @@ def generate_all_fast(model: TilesetFSM, target_delay: int) -> List[List[Entry]] # 3. Guided DFS raw_chains = [] - def build_chain(current_state: str, remaining_delay: int, current_chain: Tuple[Entry, ...]): + def build_chain( + current_state: str, remaining_delay: int, current_chain: Tuple[Entry, ...] + ): bar.update(1) if remaining_delay == 0 and current_state in model.accept_states: raw_chains.append(list(current_chain)) @@ -283,7 +318,9 @@ def generate_all_fast(model: TilesetFSM, target_delay: int) -> List[List[Entry]] t_delay = t.total_delay() if t_delay <= remaining_delay: if can_reach[remaining_delay - t_delay][t.to_state]: - build_chain(t.to_state, remaining_delay - t_delay, current_chain + t.entries) + build_chain( + t.to_state, remaining_delay - t_delay, current_chain + t.entries + ) with tqdm.tqdm() as bar: build_chain(model.start_state, target_delay, ()) @@ -306,21 +343,24 @@ def generate_all_fast(model: TilesetFSM, target_delay: int) -> List[List[Entry]] unique_chains[lin_key] = chain # 5. Sort the purely unique chains - sorted_chains = sorted(unique_chains.values(), - key=lambda chain: tuple(p for e in chain for p in e.linear_parts())) + sorted_chains = sorted( + unique_chains.values(), + key=lambda chain: tuple(p for e in chain for p in e.linear_parts()), + ) return sorted_chains + if __name__ == "__main__": target_delay = 20 - - with open('chains.csv', 'w') as f: + + with open("chains.csv", "w") as f: for chain in generate_all_fast(model, target_delay): for el in chain: f.write(el.name) - f.write(' ') - f.write(',') + f.write(" ") + f.write(",") for el in linearize_entries(chain): - f.write(f'{el:+}' if isfinite(el) else ' ') - f.write(' ') - f.write('\n') + f.write(f"{el:+}" if isfinite(el) else " ") + f.write(" ") + f.write("\n") diff --git a/grammar.py b/grammar.py index d7859834..f71b5473 100644 --- a/grammar.py +++ b/grammar.py @@ -1,26 +1,31 @@ from dataclasses import dataclass from typing import Tuple, Optional, List + @dataclass(frozen=True) class Entry: priority: int delay: int - name: str = '-' + name: str = "-" def linear_parts(self) -> Tuple[int, ...]: return (self.priority,) * self.delay + # A ComponentBlock is an atomic sequence of Entries that can be physically built. ComponentBlock = Tuple[Entry, ...] + def block_linearize(block: ComponentBlock) -> Tuple[int, ...]: """Linearizes a single macro-block.""" return tuple(p for e in block for p in e.linear_parts()) + def chain_linearize(chain: Tuple[ComponentBlock, ...]) -> Tuple[int, ...]: """Linearizes a full sequence of blocks.""" return tuple(p for b in chain for p in block_linearize(b)) + def flatten_chain(chain: Tuple[ComponentBlock, ...]) -> List[Entry]: """Converts the internal tuple-based chain back to your flat List[Entry] format.""" return [entry for block in chain for entry in block] @@ -30,18 +35,24 @@ class TilesetModel: def __init__(self, allowed_blocks: List[ComponentBlock]): self.blocks = allowed_blocks - def _check_divergence(self, prefix: Tuple[int, ...], target: Tuple[int, ...]) -> int: + def _check_divergence( + self, prefix: Tuple[int, ...], target: Tuple[int, ...] + ) -> int: """ Returns -1 if prefix is lexicographically < target, 1 if prefix is lexicographically > target, 0 if prefix is a strict prefix of target (no divergence yet). """ for p_val, t_val in zip(prefix, target): - if p_val < t_val: return -1 - if p_val > t_val: return 1 + if p_val < t_val: + return -1 + if p_val > t_val: + return 1 return 0 - def find_next(self, current_chain: Tuple[ComponentBlock, ...]) -> Optional[Tuple[ComponentBlock, ...]]: + def find_next( + self, current_chain: Tuple[ComponentBlock, ...] + ) -> Optional[Tuple[ComponentBlock, ...]]: """Finds the lexicographically next chain that perfectly matches the total delay.""" target_delay = sum(e.delay for b in current_chain for e in b) current_lin = chain_linearize(current_chain) @@ -85,7 +96,9 @@ class TilesetModel: dfs((), 0) return best_next_chain - def find_previous(self, current_chain: Tuple[ComponentBlock, ...]) -> Optional[Tuple[ComponentBlock, ...]]: + def find_previous( + self, current_chain: Tuple[ComponentBlock, ...] + ) -> Optional[Tuple[ComponentBlock, ...]]: """Finds the lexicographically previous chain matching total delay.""" target_delay = sum(e.delay for b in current_chain for e in b) current_lin = chain_linearize(current_chain) @@ -123,24 +136,26 @@ class TilesetModel: dfs((), 0) return best_prev_chain + # --- Define the "Alphabet" of valid Macro-Blocks --- # Standard Components -repeaters = [(Entry(p, d, f'rep({p},{d})'),) for p in (-1, -3) for d in (2, 4, 6, 8)] -comparators = [(Entry(p, 2, f'cmp({p})'),) for p in (0, -1)] -others = [(Entry(0, 2, 'other'),)] +repeaters = [(Entry(p, d, f"rep({p},{d})"),) for p in (-1, -3) for d in (2, 4, 6, 8)] +comparators = [(Entry(p, 2, f"cmp({p})"),) for p in (0, -1)] +others = [(Entry(0, 2, "other"),)] # Subsequences: Signal Inverted Repeaters # (Note: Updates flow right-to-left. Torch2 updates latest so it goes on the left) inv_repeaters = [ - (Entry(0, 2, 'torch2'), Entry(p, d, f'inv_rep({p},{d})'), Entry(0, 2, 'torch1')) - for p in (-2, -3) for d in (2, 4, 6, 8) + (Entry(0, 2, "torch2"), Entry(p, d, f"inv_rep({p},{d})"), Entry(0, 2, "torch1")) + for p in (-2, -3) + for d in (2, 4, 6, 8) ] # Subsequences: Fluids & Observers # (Observer updates latest so it goes on the left) fluids = [ - (Entry(0, 2, 'obs'), Entry(1, d, f'fluid({d})'), Entry(0, 4, 'disp')) + (Entry(0, 2, "obs"), Entry(1, d, f"fluid({d})"), Entry(0, 4, "disp")) for d in (5, 10, 30) ] @@ -153,9 +168,9 @@ model = TilesetModel(ALL_MACRO_BLOCKS) # Let's say we have a specific chain of Total Delay = 14 current = ( - (Entry(0, 2, 'cmp(0)'),), - (Entry(-3, 8, 'rep(-3,8)'),), - (Entry(-1, 4, 'rep(-1,4)'),) + (Entry(0, 2, "cmp(0)"),), + (Entry(-3, 8, "rep(-3,8)"),), + (Entry(-1, 4, "rep(-1,4)"),), ) print(f"Current Chain: {flatten_chain(current)}") @@ -166,4 +181,4 @@ if next_chain: prev_chain = model.find_previous(current) if prev_chain: - print(f"Prev Chain: {flatten_chain(prev_chain)}") \ No newline at end of file + print(f"Prev Chain: {flatten_chain(prev_chain)}") diff --git a/permute.py b/permute.py index c5a459fd..7350e08d 100644 --- a/permute.py +++ b/permute.py @@ -10,75 +10,161 @@ from typing import Iterable # Note that components which update later in time have stronger significance on the order of execution; so for our notation we place these on the left-hand-side (first in lists) to match left-to-right lexicographic notation. + @dataclass class Entry: priority: int delay: int - name: str = '-' + name: str = "-" + # We can model this by linearizing these tuples into tuples, then lexicographically sort these linearized keys. # We directly sort on priority: more-negative priorities update before more-positive priorities, so these are correctly sorted lexicographically. However we only want this behavior in the case that the components update at the same time, so we can 'pad out' the effect of delay by repeating the priority. + def linear_parts(entry: Entry): assert entry.delay > 0 # return (-np.inf,) * (entry.delay - 1) + (entry.priority,) return (entry.priority,) * entry.delay + def linearize(entries: Iterable[Entry]): return [part for entry in entries for part in linear_parts(entry)] + def sort(chains: list[Entry]): return sorted(chains, key=linearize) + # one framework to produce a tileset is to encode binary values by comparator and repeater. all cases have equal delay, so it just falls to the priorities. comparators have priority 0 at the end and -1 in the middle, while repeaters have priority -1 at the end and -2 in the middle. chains = [ - [Entry(-0, 2, 'cmp'), Entry(-1, 2, 'cmp'), Entry(-1, 2, 'cmp'), Entry(-1, 2, 'cmp')], - [Entry(-0, 2, 'cmp'), Entry(-1, 2, 'cmp'), Entry(-1, 2, 'cmp'), Entry(-2, 2, 'rep')], - [Entry(-0, 2, 'cmp'), Entry(-1, 2, 'cmp'), Entry(-2, 2, 'rep'), Entry(-1, 2, 'cmp')], - [Entry(-0, 2, 'cmp'), Entry(-1, 2, 'cmp'), Entry(-2, 2, 'rep'), Entry(-2, 2, 'rep')], - [Entry(-0, 2, 'cmp'), Entry(-3, 2, 'rep'), Entry(-1, 2, 'cmp'), Entry(-1, 2, 'cmp')], - [Entry(-0, 2, 'cmp'), Entry(-3, 2, 'rep'), Entry(-1, 2, 'cmp'), Entry(-3, 2, 'rep')], - [Entry(-0, 2, 'cmp'), Entry(-3, 2, 'rep'), Entry(-3, 2, 'rep'), Entry(-1, 2, 'cmp')], - [Entry(-0, 2, 'cmp'), Entry(-3, 2, 'rep'), Entry(-3, 2, 'rep'), Entry(-3, 2, 'rep')], - [Entry(-1, 2, 'rep'), Entry(-1, 2, 'cmp'), Entry(-1, 2, 'cmp'), Entry(-1, 2, 'cmp')], - [Entry(-1, 2, 'rep'), Entry(-1, 2, 'cmp'), Entry(-1, 2, 'cmp'), Entry(-3, 2, 'rep')], - [Entry(-1, 2, 'rep'), Entry(-1, 2, 'cmp'), Entry(-3, 2, 'rep'), Entry(-1, 2, 'cmp')], - [Entry(-1, 2, 'rep'), Entry(-1, 2, 'cmp'), Entry(-3, 2, 'rep'), Entry(-3, 2, 'rep')], - [Entry(-1, 2, 'rep'), Entry(-3, 2, 'rep'), Entry(-1, 2, 'cmp'), Entry(-1, 2, 'cmp')], - [Entry(-1, 2, 'rep'), Entry(-3, 2, 'rep'), Entry(-1, 2, 'cmp'), Entry(-3, 2, 'rep')], - [Entry(-1, 2, 'rep'), Entry(-3, 2, 'rep'), Entry(-3, 2, 'rep'), Entry(-1, 2, 'cmp')], - [Entry(-1, 2, 'rep'), Entry(-3, 2, 'rep'), Entry(-3, 2, 'rep'), Entry(-3, 2, 'rep')], + [ + Entry(-0, 2, "cmp"), + Entry(-1, 2, "cmp"), + Entry(-1, 2, "cmp"), + Entry(-1, 2, "cmp"), + ], + [ + Entry(-0, 2, "cmp"), + Entry(-1, 2, "cmp"), + Entry(-1, 2, "cmp"), + Entry(-2, 2, "rep"), + ], + [ + Entry(-0, 2, "cmp"), + Entry(-1, 2, "cmp"), + Entry(-2, 2, "rep"), + Entry(-1, 2, "cmp"), + ], + [ + Entry(-0, 2, "cmp"), + Entry(-1, 2, "cmp"), + Entry(-2, 2, "rep"), + Entry(-2, 2, "rep"), + ], + [ + Entry(-0, 2, "cmp"), + Entry(-3, 2, "rep"), + Entry(-1, 2, "cmp"), + Entry(-1, 2, "cmp"), + ], + [ + Entry(-0, 2, "cmp"), + Entry(-3, 2, "rep"), + Entry(-1, 2, "cmp"), + Entry(-3, 2, "rep"), + ], + [ + Entry(-0, 2, "cmp"), + Entry(-3, 2, "rep"), + Entry(-3, 2, "rep"), + Entry(-1, 2, "cmp"), + ], + [ + Entry(-0, 2, "cmp"), + Entry(-3, 2, "rep"), + Entry(-3, 2, "rep"), + Entry(-3, 2, "rep"), + ], + [ + Entry(-1, 2, "rep"), + Entry(-1, 2, "cmp"), + Entry(-1, 2, "cmp"), + Entry(-1, 2, "cmp"), + ], + [ + Entry(-1, 2, "rep"), + Entry(-1, 2, "cmp"), + Entry(-1, 2, "cmp"), + Entry(-3, 2, "rep"), + ], + [ + Entry(-1, 2, "rep"), + Entry(-1, 2, "cmp"), + Entry(-3, 2, "rep"), + Entry(-1, 2, "cmp"), + ], + [ + Entry(-1, 2, "rep"), + Entry(-1, 2, "cmp"), + Entry(-3, 2, "rep"), + Entry(-3, 2, "rep"), + ], + [ + Entry(-1, 2, "rep"), + Entry(-3, 2, "rep"), + Entry(-1, 2, "cmp"), + Entry(-1, 2, "cmp"), + ], + [ + Entry(-1, 2, "rep"), + Entry(-3, 2, "rep"), + Entry(-1, 2, "cmp"), + Entry(-3, 2, "rep"), + ], + [ + Entry(-1, 2, "rep"), + Entry(-3, 2, "rep"), + Entry(-3, 2, "rep"), + Entry(-1, 2, "cmp"), + ], + [ + Entry(-1, 2, "rep"), + Entry(-3, 2, "rep"), + Entry(-3, 2, "rep"), + Entry(-3, 2, "rep"), + ], ] shuffle(chains) # another framework is to use permutations of repeaters on varying delay. now all cases have equal priority, so it just falls to the delays. chains = [ - [Entry(-1, 8, 'r4'), Entry(-3, 6, 'r3'), Entry(-3, 4, 'r2'), Entry(-3, 2, 'r1')], - [Entry(-1, 8, 'r4'), Entry(-3, 6, 'r3'), Entry(-3, 2, 'r1'), Entry(-3, 4, 'r2')], - [Entry(-1, 8, 'r4'), Entry(-3, 4, 'r2'), Entry(-3, 6, 'r3'), Entry(-3, 2, 'r1')], - [Entry(-1, 8, 'r4'), Entry(-3, 4, 'r2'), Entry(-3, 2, 'r1'), Entry(-3, 6, 'r3')], - [Entry(-1, 8, 'r4'), Entry(-3, 2, 'r1'), Entry(-3, 6, 'r3'), Entry(-3, 4, 'r2')], - [Entry(-1, 8, 'r4'), Entry(-3, 2, 'r1'), Entry(-3, 4, 'r2'), Entry(-3, 6, 'r3')], - [Entry(-1, 6, 'r3'), Entry(-3, 8, 'r4'), Entry(-3, 4, 'r2'), Entry(-3, 2, 'r1')], - [Entry(-1, 6, 'r3'), Entry(-3, 8, 'r4'), Entry(-3, 2, 'r1'), Entry(-3, 4, 'r2')], - [Entry(-1, 6, 'r3'), Entry(-3, 4, 'r2'), Entry(-3, 8, 'r4'), Entry(-3, 2, 'r1')], - [Entry(-1, 6, 'r3'), Entry(-3, 4, 'r2'), Entry(-3, 2, 'r1'), Entry(-3, 8, 'r4')], - [Entry(-1, 6, 'r3'), Entry(-3, 2, 'r1'), Entry(-3, 8, 'r4'), Entry(-3, 4, 'r2')], - [Entry(-1, 6, 'r3'), Entry(-3, 2, 'r1'), Entry(-3, 4, 'r2'), Entry(-3, 8, 'r4')], - [Entry(-1, 4, 'r2'), Entry(-3, 8, 'r4'), Entry(-3, 6, 'r3'), Entry(-3, 2, 'r1')], - [Entry(-1, 4, 'r2'), Entry(-3, 8, 'r4'), Entry(-3, 2, 'r1'), Entry(-3, 6, 'r3')], - [Entry(-1, 4, 'r2'), Entry(-3, 6, 'r3'), Entry(-3, 8, 'r4'), Entry(-3, 2, 'r1')], - [Entry(-1, 4, 'r2'), Entry(-3, 6, 'r3'), Entry(-3, 2, 'r1'), Entry(-3, 8, 'r4')], - [Entry(-1, 4, 'r2'), Entry(-3, 2, 'r1'), Entry(-3, 8, 'r4'), Entry(-3, 6, 'r3')], - [Entry(-1, 4, 'r2'), Entry(-3, 2, 'r1'), Entry(-3, 6, 'r3'), Entry(-3, 8, 'r4')], - [Entry(-1, 2, 'r1'), Entry(-3, 8, 'r4'), Entry(-3, 6, 'r3'), Entry(-3, 4, 'r2')], - [Entry(-1, 2, 'r1'), Entry(-3, 8, 'r4'), Entry(-3, 4, 'r2'), Entry(-3, 6, 'r3')], - [Entry(-1, 2, 'r1'), Entry(-3, 6, 'r3'), Entry(-3, 8, 'r4'), Entry(-3, 4, 'r2')], - [Entry(-1, 2, 'r1'), Entry(-3, 6, 'r3'), Entry(-3, 4, 'r2'), Entry(-3, 8, 'r4')], - [Entry(-1, 2, 'r1'), Entry(-3, 4, 'r2'), Entry(-3, 8, 'r4'), Entry(-3, 6, 'r3')], - [Entry(-1, 2, 'r1'), Entry(-3, 4, 'r2'), Entry(-3, 6, 'r3'), Entry(-3, 8, 'r4')], + [Entry(-1, 8, "r4"), Entry(-3, 6, "r3"), Entry(-3, 4, "r2"), Entry(-3, 2, "r1")], + [Entry(-1, 8, "r4"), Entry(-3, 6, "r3"), Entry(-3, 2, "r1"), Entry(-3, 4, "r2")], + [Entry(-1, 8, "r4"), Entry(-3, 4, "r2"), Entry(-3, 6, "r3"), Entry(-3, 2, "r1")], + [Entry(-1, 8, "r4"), Entry(-3, 4, "r2"), Entry(-3, 2, "r1"), Entry(-3, 6, "r3")], + [Entry(-1, 8, "r4"), Entry(-3, 2, "r1"), Entry(-3, 6, "r3"), Entry(-3, 4, "r2")], + [Entry(-1, 8, "r4"), Entry(-3, 2, "r1"), Entry(-3, 4, "r2"), Entry(-3, 6, "r3")], + [Entry(-1, 6, "r3"), Entry(-3, 8, "r4"), Entry(-3, 4, "r2"), Entry(-3, 2, "r1")], + [Entry(-1, 6, "r3"), Entry(-3, 8, "r4"), Entry(-3, 2, "r1"), Entry(-3, 4, "r2")], + [Entry(-1, 6, "r3"), Entry(-3, 4, "r2"), Entry(-3, 8, "r4"), Entry(-3, 2, "r1")], + [Entry(-1, 6, "r3"), Entry(-3, 4, "r2"), Entry(-3, 2, "r1"), Entry(-3, 8, "r4")], + [Entry(-1, 6, "r3"), Entry(-3, 2, "r1"), Entry(-3, 8, "r4"), Entry(-3, 4, "r2")], + [Entry(-1, 6, "r3"), Entry(-3, 2, "r1"), Entry(-3, 4, "r2"), Entry(-3, 8, "r4")], + [Entry(-1, 4, "r2"), Entry(-3, 8, "r4"), Entry(-3, 6, "r3"), Entry(-3, 2, "r1")], + [Entry(-1, 4, "r2"), Entry(-3, 8, "r4"), Entry(-3, 2, "r1"), Entry(-3, 6, "r3")], + [Entry(-1, 4, "r2"), Entry(-3, 6, "r3"), Entry(-3, 8, "r4"), Entry(-3, 2, "r1")], + [Entry(-1, 4, "r2"), Entry(-3, 6, "r3"), Entry(-3, 2, "r1"), Entry(-3, 8, "r4")], + [Entry(-1, 4, "r2"), Entry(-3, 2, "r1"), Entry(-3, 8, "r4"), Entry(-3, 6, "r3")], + [Entry(-1, 4, "r2"), Entry(-3, 2, "r1"), Entry(-3, 6, "r3"), Entry(-3, 8, "r4")], + [Entry(-1, 2, "r1"), Entry(-3, 8, "r4"), Entry(-3, 6, "r3"), Entry(-3, 4, "r2")], + [Entry(-1, 2, "r1"), Entry(-3, 8, "r4"), Entry(-3, 4, "r2"), Entry(-3, 6, "r3")], + [Entry(-1, 2, "r1"), Entry(-3, 6, "r3"), Entry(-3, 8, "r4"), Entry(-3, 4, "r2")], + [Entry(-1, 2, "r1"), Entry(-3, 6, "r3"), Entry(-3, 4, "r2"), Entry(-3, 8, "r4")], + [Entry(-1, 2, "r1"), Entry(-3, 4, "r2"), Entry(-3, 8, "r4"), Entry(-3, 6, "r3")], + [Entry(-1, 2, "r1"), Entry(-3, 4, "r2"), Entry(-3, 6, "r3"), Entry(-3, 8, "r4")], ] shuffle(chains) diff --git a/simple-enum.py b/simple-enum.py new file mode 100644 index 00000000..1dddb74c --- /dev/null +++ b/simple-enum.py @@ -0,0 +1,170 @@ +from contextlib import redirect_stdout +from functools import cache +from pathlib import Path +from pprint import pprint + + +class Comp: + def __init__(self, priority: int, delay: int, name: str, head: bool = True, blocks = ()): + self.priority = priority + self.delay = delay + self.head = head + self.name = name + self.blocks = tuple(blocks) + + def __lt__(self, other: Comp) -> bool: + if self.priority == other.priority: + return self.delay > other.delay + else: + return self.priority < other.priority + + def __str__(self) -> str: + return self.name + + def __repr__(self) -> str: + return f"{self.name} ({self.priority} / {self.delay})" + +COMPONENTS = [ + Comp(priority=-3, delay=8, name="R4", head=False, blocks=[ + 'repeater facing=south powered=false locked=false delay=4', + ]), + Comp(priority=-3, delay=6, name="R3", head=False, blocks=[ + 'repeater facing=south powered=false locked=false delay=3' + ]), + Comp(priority=-3, delay=4, name="R2", head=False, blocks=[ + 'repeater facing=south powered=false locked=false delay=2' + ]), + Comp(priority=-3, delay=2, name="R1", head=False, blocks=[ + 'repeater facing=south powered=false locked=false delay=1' + ]), + Comp(priority=-1, delay=8, name="- R4", head=True, blocks=[ + 'redstone_wire north=side south=side power=0', + 'repeater facing=south powered=false locked=false delay=4' + ]), + Comp(priority=-1, delay=6, name="- R3", head=True, blocks=[ + 'redstone_wire north=side south=side power=0', + 'repeater facing=south powered=false locked=false delay=3' + ]), + Comp(priority=-1, delay=4, name="- R2", head=True, blocks=[ + 'redstone_wire north=side south=side power=0', + 'repeater facing=south powered=false locked=false delay=2' + ]), + Comp(priority=-1, delay=2, name="C", head=False, blocks=[ + 'comparator facing=south powered=false mode=compare' + ]), + Comp(priority=-1, delay=2, name="- R1", head=True, blocks=[ + 'redstone_wire north=side south=side power=0', + 'repeater facing=south powered=false locked=false delay=1' + ]), + Comp(priority=0, delay=2, name="- C", head=True, blocks=[ + 'redstone_wire north=side south=side power=0', + 'comparator facing=south powered=false mode=compare' + ]), +] + +COMPONENTS.sort() + + +from functools import cache + + +@cache +def tileset(total_delay, head=True): + tree = {} + seen = set() + + for comp in COMPONENTS: + if comp.delay <= total_delay: + if head and not comp.head: + continue + + key = (comp.priority, comp.delay) + if key in seen: + continue + + seen.add(key) + tree[comp] = tileset(total_delay - comp.delay, head=False) + + return tree + + +def show(tree, flat=False): + if flat: + + def _print_flat(current_tree, current_path): + # If the dict is empty, we've reached the end of a valid chain + if not current_tree: + print(" ".join(str(comp) for comp in current_path)) + return + for comp, subtree in current_tree.items(): + _print_flat(subtree, current_path + [comp]) + + _print_flat(tree, []) + + else: + + def _print_tree(current_tree, prefix=""): + items = list(current_tree.items()) + for i, (comp, subtree) in enumerate(items): + is_last = i == len(items) - 1 + connector = "└ " if is_last else "├ " + print(f"{prefix}{connector}{comp}") + + # If this is the last item, children don't need a vertical line + extension = " " if is_last else "│ " + _print_tree(subtree, prefix + extension) + + _print_tree(tree) + + +# def diorama(tree, step=1.125): +# x = 0 +# +# def inner(prefix, node): +# nonlocal x +# +# if not node: +# z = 0 +# for pref in prefix: +# for block in pref.blocks: +# print(f'p {x:.3f} 0 {z} {block}') +# print(f'p {x:.3f} -1 {z} smooth_stone_slab type=top') +# z += 1 +# x -= step +# else: +# for comp, sub in node.items(): +# inner((*prefix, comp), sub) +# +# inner((), tree) + +def dioramas(tree): + count = 0 + + def inner(prefix, node): + nonlocal count + + if not node: + count += 1 + print('```mc-diorama') + z = 0 + for pref in prefix: + for block in pref.blocks: + print(f'p 0 0 {z} {block}') + print(f'p 0 -1 {z} smooth_stone_slab type=top') + z += 1 + print('```') + else: + for comp, sub in node.items(): + inner((*prefix, comp), sub) + + inner((), tree) + + return count + + +# show(tileset(4, head=True)) +# print() + +with Path('~/src/wireless/content/tilesets-lexicographic.typ').expanduser().open('w') as f, redirect_stdout(f): + total = dioramas(tileset(10, head=True)) +print(f'{total = }')