me/wireless-docs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

simple tree walk

Browse Source
This commit is contained in:
David Allemang
2026-10-01 10:02:14 -04:00
parent dd460f3973
commit 9719324d41
5 changed files with 579 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
finite-state-refine.py
View File

@@ -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)
print_chain(c)

176
finite_state.py
View File

@@ -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")

47
grammar.py
View File

@@ -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)}")
print(f"Prev Chain: {flatten_chain(prev_chain)}")

168
permute.py
View File

@@ -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)

170
simple-enum.py Normal file
View File

@@ -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 = }')