import datetime as dt import io import logging import random import wave import folium import networkx as nx import numpy as np import pandas as pd import streamlit as st from folium.plugins import AntPath from geopy.distance import geodesic from streamlit_folium import st_folium logging.basicConfig(level=logging.INFO, format="%(levelname)s:%(message)s") SANTA = "\U0001F385" SNOWFLAKE = "\u2744\ufe0f" SPARKLES = "\u2728" GIFT = "\U0001F381" st.set_page_config( page_title="Quantum Santa's Path Optimizer", page_icon=SANTA, layout="wide", initial_sidebar_state="expanded", ) CITY_DATA = [ {"name": "North Pole", "lat": 90.0, "lon": 0.0, "tz": 0.0, "icon": SNOWFLAKE, "base_risk": 0.05}, {"name": "New York", "lat": 40.7128, "lon": -74.0060, "tz": -5.0, "icon": "\U0001F5FD", "base_risk": 0.30}, {"name": "London", "lat": 51.5074, "lon": -0.1278, "tz": 0.0, "icon": "\U0001F3F0", "base_risk": 0.25}, {"name": "Tokyo", "lat": 35.6762, "lon": 139.6503, "tz": 9.0, "icon": "\U0001F5FC", "base_risk": 0.35}, {"name": "Sydney", "lat": -33.8688, "lon": 151.2093, "tz": 10.0, "icon": "\U0001F998", "base_risk": 0.20}, {"name": "Paris", "lat": 48.8566, "lon": 2.3522, "tz": 1.0, "icon": "\U0001F950", "base_risk": 0.28}, {"name": "Cairo", "lat": 30.0444, "lon": 31.2357, "tz": 2.0, "icon": "\U0001F9FF", "base_risk": 0.32}, {"name": "Rio de Janeiro", "lat": -22.9068, "lon": -43.1729, "tz": -3.0, "icon": "\U0001F334", "base_risk": 0.33}, {"name": "Cape Town", "lat": -33.9249, "lon": 18.4241, "tz": 2.0, "icon": "\U0001F427", "base_risk": 0.22}, {"name": "Moscow", "lat": 55.7558, "lon": 37.6176, "tz": 3.0, "icon": "\U0001F9CA", "base_risk": 0.27}, {"name": "Mumbai", "lat": 19.0760, "lon": 72.8777, "tz": 5.5, "icon": "\U0001F54C", "base_risk": 0.38}, {"name": "Singapore", "lat": 1.3521, "lon": 103.8198, "tz": 8.0, "icon": "\U0001F981", "base_risk": 0.31}, {"name": "Los Angeles", "lat": 34.0522, "lon": -118.2437, "tz": -8.0, "icon": "\U0001F3AC", "base_risk": 0.29}, {"name": "Mexico City", "lat": 19.4326, "lon": -99.1332, "tz": -6.0, "icon": "\U0001F32E", "base_risk": 0.34}, {"name": "Toronto", "lat": 43.6532, "lon": -79.3832, "tz": -5.0, "icon": "\U0001F341", "base_risk": 0.26}, ] def build_city_df(): return pd.DataFrame(CITY_DATA).set_index("name") def distance_km(city_a, city_b): return geodesic((city_a["lat"], city_a["lon"]), (city_b["lat"], city_b["lon"])).km def build_distance_matrix(city_df): names = list(city_df.index) n = len(names) dist = np.zeros((n, n)) for i in range(n): for j in range(i + 1, n): d = distance_km(city_df.loc[names[i]], city_df.loc[names[j]]) dist[i, j] = d dist[j, i] = d return dist, names def route_length(route, dist): total = 0.0 for i in range(len(route) - 1): total += dist[route[i], route[i + 1]] return total def nearest_neighbor_route(dist): n = dist.shape[0] unvisited = set(range(1, n)) route = [0] while unvisited: last = route[-1] next_city = min(unvisited, key=lambda x: dist[last, x]) route.append(next_city) unvisited.remove(next_city) route.append(0) return route def christofides_route(dist): n = dist.shape[0] g = nx.Graph() for i in range(n): for j in range(i + 1, n): g.add_edge(i, j, weight=dist[i, j]) cycle = nx.algorithms.approximation.traveling_salesman_problem( g, weight="weight", cycle=True, method=nx.algorithms.approximation.christofides, ) return rotate_cycle_start(cycle, 0) def rotate_cycle_start(route, start_index): if route[0] == start_index and route[-1] == start_index: return route if start_index in route: idx = route.index(start_index) rotated = route[idx:] + route[1:idx + 1] if rotated[0] != start_index: rotated = [start_index] + rotated if rotated[-1] != start_index: rotated.append(start_index) return rotated return [start_index] + route + [start_index] def compute_arrivals(route, city_df, dist, start_dt, speed_kmph): arrivals = [] elapsed_hours = 0.0 names = list(city_df.index) for idx, city_idx in enumerate(route): city_name = names[city_idx] city = city_df.loc[city_name] arrival_utc = start_dt + dt.timedelta(hours=elapsed_hours) local_time = arrival_utc + dt.timedelta(hours=city["tz"]) arrivals.append( { "city": city_name, "order": idx + 1, "arrival_utc": arrival_utc, "local_time": local_time, } ) if idx < len(route) - 1: leg_km = dist[route[idx], route[idx + 1]] elapsed_hours += leg_km / speed_kmph return arrivals def predict_awake_probability(base_prob, hour): if 23 <= hour or hour < 5: time_factor = 0.3 elif 5 <= hour < 8: time_factor = 0.7 elif 8 <= hour < 18: time_factor = 1.2 else: time_factor = 0.8 return min(0.95, base_prob * time_factor) def compute_route_metrics(route, city_df, dist, start_dt, speed_kmph): arrivals = compute_arrivals(route, city_df, dist, start_dt, speed_kmph) risks = [] for item in arrivals: city = city_df.loc[item["city"]] hour = item["local_time"].hour risk = predict_awake_probability(city["base_risk"], hour) item["risk"] = risk risks.append(risk) total_distance = route_length(route, dist) avg_risk = float(np.mean(risks)) if risks else 0.0 return total_distance, avg_risk, arrivals def route_edge_similarity(route_a, route_b): edges_a = {(route_a[i], route_a[i + 1]) for i in range(len(route_a) - 1)} edges_b = {(route_b[i], route_b[i + 1]) for i in range(len(route_b) - 1)} if not edges_a: return 0.0 return len(edges_a & edges_b) / len(edges_a) def quantum_inspired_tsp(dist, start_dt, strength, city_df, speed_kmph): base_route = nearest_neighbor_route(dist) candidates = [base_route] rng = np.random.default_rng() num_candidates = int(10 + 20 * strength) for _ in range(num_candidates): perm = base_route[1:-1] perm = perm.copy() swaps = max(1, int(strength * len(perm))) for _ in range(swaps): i, j = rng.integers(0, len(perm), size=2) perm[i], perm[j] = perm[j], perm[i] candidate = [0] + perm + [0] candidates.append(candidate) costs = [] for route in candidates: dist_km, avg_risk, _ = compute_route_metrics(route, city_df, dist, start_dt, speed_kmph) costs.append(dist_km * (1.0 + avg_risk)) best_idx = int(np.argmin(costs)) worst_idx = int(np.argmax(costs)) best_route = candidates[best_idx] worst_route = candidates[worst_idx] amplitudes = [] for route, cost in zip(candidates, costs): weight = 1.0 / (1.0 + cost) sim_best = route_edge_similarity(route, best_route) sim_worst = route_edge_similarity(route, worst_route) interference = (1.0 + 0.5 * sim_best) * (1.0 - 0.3 * sim_worst * strength) amplitudes.append(max(1e-6, weight * interference)) amplitudes = np.array(amplitudes) amplitudes = amplitudes / amplitudes.sum() if random.random() < 0.25 * strength: worse_pool = np.argsort(costs)[-max(2, len(candidates) // 4):] pick = int(rng.choice(worse_pool)) return candidates[pick] pick = int(rng.choice(len(candidates), p=amplitudes)) return candidates[pick] def build_map(city_df, route, arrivals): names = list(city_df.index) map_center = [city_df["lat"].mean(), city_df["lon"].mean()] fmap = folium.Map(location=map_center, zoom_start=1, tiles="CartoDB dark_matter") risk_lookup = {item["city"]: item["risk"] for item in arrivals} coords = [] for order, city_idx in enumerate(route): city_name = names[city_idx] city = city_df.loc[city_name] coords.append((city["lat"], city["lon"])) risk = risk_lookup.get(city_name, 0.0) color = "#2ecc71" if risk < 0.2 else "#f1c40f" if risk < 0.5 else "#e74c3c" popup = ( f"{order + 1}. {city_name}
" f"Local time: {arrivals[order]['local_time'].strftime('%H:%M')}
" f"Awake risk: {risk:.0%}" ) folium.CircleMarker( location=(city["lat"], city["lon"]), radius=7, color=color, fill=True, fill_color=color, popup=popup, ).add_to(fmap) folium.PolyLine(coords, weight=3, color="#d4af37", opacity=0.9).add_to(fmap) AntPath(coords, color="#e6f1ff", weight=2, delay=800).add_to(fmap) return fmap def santa_summary(route, city_df, total_distance, avg_risk): names = list(city_df.index) path = " -> ".join(names[i] for i in route) return f"Route: {path}\nDistance: {total_distance:.1f} km\nAvg awake risk: {avg_risk:.0%}" def render_quantum_cards(): cards = [ ("Superposition", "Explore many candidate routes at once to mimic quantum states."), ("Tunneling", "Occasionally accept worse routes to escape local minima."), ("Interference", "Reinforce good paths and dampen weak ones via similarity weighting."), ] cols = st.columns(3) for col, (title, body) in zip(cols, cards): with col: st.markdown( f"""

{title}

{body}

""", unsafe_allow_html=True, ) def render_css(christmas_mode): glow = "glowBorder 4s ease-in-out infinite alternate" if christmas_mode else "none" st.markdown( f""" """, unsafe_allow_html=True, ) if christmas_mode: flakes = "".join( f'
{SNOWFLAKE}
' for i in range(12) ) st.markdown(flakes, unsafe_allow_html=True) def render_share_button(text): escaped = text.replace("\\", "\\\\").replace("\n", "\\n").replace("'", "\\'").replace('"', '\\"') st.components.v1.html( f"""
Ready to share {GIFT}
""", height=60, ) @st.cache_data(show_spinner=False) def generate_bell_audio(): sample_rate = 22050 duration = 1.0 t = np.linspace(0, duration, int(sample_rate * duration), False) tone = 0.45 * np.sin(2 * np.pi * 880 * t) * np.exp(-3 * t) audio = np.int16(tone * 32767) buffer = io.BytesIO() with wave.open(buffer, "wb") as wav_file: wav_file.setnchannels(1) wav_file.setsampwidth(2) wav_file.setframerate(sample_rate) wav_file.writeframes(audio.tobytes()) return buffer.getvalue() def main(): today = dt.datetime.utcnow().date() christmas_mode = today.month == 12 and today.day in (24, 25) render_css(christmas_mode) st.title(f"{SANTA} Quantum Santa's Path Optimizer") st.write("Plan Santa's global gift route with quantum-inspired optimization and risk awareness.") city_df = build_city_df() dist_check, _ = build_distance_matrix(city_df) health_ok = len(city_df.index) >= 15 and np.isfinite(dist_check).all() left, right = st.columns([0.3, 0.7], gap="large") with left: st.subheader("Control Deck") city_names = list(city_df.index) city_labels = {name: f"{city_df.loc[name]['icon']} {name}" for name in city_names} selected = st.multiselect( "Select 3-15 cities (North Pole required)", options=city_names, default=["North Pole", "New York", "London", "Tokyo", "Sydney"], format_func=lambda x: city_labels[x], ) algo = st.selectbox( "Optimization mode", ["Quantum-Inspired", "Classic (Christofides)", "Classic (Greedy)"], ) strength = st.slider("Quantum strength", min_value=0.0, max_value=1.0, value=0.7, step=0.05) start_time = st.time_input("Departure time (UTC)", value=dt.time(22, 30)) speed = st.slider("Santa speed (km/h)", 300.0, 1500.0, 900.0, step=50.0) st.markdown("### Quantum Concepts") render_quantum_cards() enable_sound = st.checkbox("Enable bell sound (Christmas mode)", value=False) optimize_clicked = st.button(f"{SPARKLES} OPTIMIZE ROUTE", use_container_width=True, key="optimize") st.caption(f"Health check: {'OK' if health_ok else 'Issues detected'}") if len(selected) < 3: st.error("Pick at least 3 cities to begin the optimization.") return if len(selected) > 15: st.error("Please select 15 cities or fewer for a responsive experience.") return if "North Pole" not in selected: st.error("North Pole must be included as the starting point.") return selected = ["North Pole"] + [city for city in selected if city != "North Pole"] if optimize_clicked: with st.spinner("Optimizing across quantum states..."): progress = st.progress(0) for pct in range(0, 90, 15): progress.progress(pct) chosen_df = city_df.loc[selected] dist, _ = build_distance_matrix(chosen_df) start_dt = dt.datetime.combine(today, start_time) start_perf = dt.datetime.utcnow() try: if algo == "Quantum-Inspired": route = quantum_inspired_tsp(dist, start_dt, strength, chosen_df, speed) elif algo == "Classic (Christofides)": route = christofides_route(dist) else: route = nearest_neighbor_route(dist) except Exception as exc: logging.exception("Optimization failed: %s", exc) st.error("Optimization failed. Please try a different city set or algorithm.") return total_distance, avg_risk, arrivals = compute_route_metrics( route, chosen_df, dist, start_dt, speed ) elapsed = (dt.datetime.utcnow() - start_perf).total_seconds() progress.progress(100) st.balloons() st.session_state["last_result"] = { "cities": selected, "route": route, "dist": dist, "arrivals": arrivals, "total_distance": total_distance, "avg_risk": avg_risk, "elapsed": elapsed, } if "last_result" in st.session_state: result = st.session_state["last_result"] chosen_df = city_df.loc[result["cities"]] route = result["route"] dist = result["dist"] arrivals = result["arrivals"] total_distance = result["total_distance"] avg_risk = result["avg_risk"] elapsed = result["elapsed"] with right: st.subheader("Route Visualization") fmap = build_map(chosen_df, route, arrivals) st_folium(fmap, width=700, height=520) metrics = st.columns(3) metrics[0].markdown( f"

Total Distance

{total_distance:.0f} km

", unsafe_allow_html=True, ) metrics[1].markdown( f"

Average Risk

{avg_risk:.0%}

", unsafe_allow_html=True, ) metrics[2].markdown( f"

Optimization Time

{elapsed:.2f} s

", unsafe_allow_html=True, ) st.markdown("### Route Details") for idx, stop in enumerate(arrivals): leg_distance = "" if idx < len(route) - 1: leg_km = dist[route[idx], route[idx + 1]] leg_distance = f" - {leg_km:.0f} km to next" st.write( f"{stop['order']:02d}. {stop['city']} - " f"{stop['local_time'].strftime('%H:%M')} local - " f"risk {stop['risk']:.0%}{leg_distance}" ) summary = santa_summary(route, chosen_df, total_distance, avg_risk) render_share_button(summary) if avg_risk > 0.5: st.warning("Santa is departing too early. Many kids are still awake.") elif avg_risk > 0.3: st.info("Consider delaying departure to reduce awake risk.") else: st.success("Great timing! Most kids are asleep.") else: with right: st.subheader("Route Visualization") st.info("Select cities and click OPTIMIZE ROUTE to see the magic.") if christmas_mode and enable_sound: st.audio(generate_bell_audio(), format="audio/wav") if __name__ == "__main__": main()