Upload 4 files

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+ENV MPLBACKEND=Agg \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends libgfortran5 gfortran libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8501
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,563 @@
+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"<b>{order + 1}. {city_name}</b><br>"
+            f"Local time: {arrivals[order]['local_time'].strftime('%H:%M')}<br>"
+            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"""
+                <div class="quantum-card">
+                    <h4>{title}</h4>
+                    <p>{body}</p>
+                </div>
+                """,
+                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"""
+        <style>
+        :root {{
+            --red: #8b0000;
+            --gold: #d4af37;
+            --blue1: #0a192f;
+            --blue2: #1a2a6c;
+            --ice: #e6f1ff;
+        }}
+        html, body, [class*="css"] {{
+            font-family: "Cinzel", "Georgia", serif;
+        }}
+        .stApp {{
+            background: linear-gradient(135deg, var(--blue1), var(--blue2));
+            color: var(--ice);
+        }}
+        section.main > div {{
+            animation: {glow};
+            border: 1px solid rgba(212, 175, 55, 0.2);
+            border-radius: 16px;
+            padding: 1.25rem;
+            background: rgba(10, 25, 47, 0.45);
+            backdrop-filter: blur(6px);
+        }}
+        h1, h2, h3 {{
+            color: var(--ice);
+        }}
+        .metric-card {{
+            background: rgba(255, 255, 255, 0.08);
+            border: 1px solid rgba(212, 175, 55, 0.35);
+            border-radius: 14px;
+            padding: 1rem;
+            text-align: center;
+            box-shadow: 0 6px 18px rgba(0, 0, 0, 0.25);
+        }}
+        .metric-card h3 {{
+            margin-bottom: 0.25rem;
+            color: var(--gold);
+        }}
+        .metric-card p {{
+            margin: 0;
+            font-size: 1.3rem;
+            color: var(--ice);
+        }}
+        .quantum-card {{
+            background: rgba(255, 255, 255, 0.08);
+            border: 1px solid rgba(212, 175, 55, 0.35);
+            border-radius: 12px;
+            padding: 0.75rem 1rem;
+            height: 100%;
+        }}
+        .quantum-card h4 {{
+            margin: 0 0 0.5rem 0;
+            color: var(--gold);
+        }}
+        div.stButton > button {{
+            background: linear-gradient(120deg, #d4af37, #f7d774);
+            color: #2b1b00;
+            font-weight: 700;
+            border: none;
+            padding: 0.6rem 1.4rem;
+            border-radius: 999px;
+            font-size: 1.1rem;
+        }}
+        div.stButton > button:hover {{
+            filter: brightness(1.05);
+        }}
+        @keyframes glowBorder {{
+            from {{ box-shadow: 0 0 12px rgba(212, 175, 55, 0.2); }}
+            to {{ box-shadow: 0 0 24px rgba(212, 175, 55, 0.45); }}
+        }}
+        .snowflake {{
+            position: fixed;
+            top: -10px;
+            color: rgba(230, 241, 255, 0.8);
+            user-select: none;
+            z-index: 9999;
+            animation: fall 10s linear infinite;
+        }}
+        @keyframes fall {{
+            0% {{ transform: translateY(-10px); opacity: 0; }}
+            10% {{ opacity: 1; }}
+            100% {{ transform: translateY(110vh); opacity: 0; }}
+        }}
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    if christmas_mode:
+        flakes = "".join(
+            f'<div class="snowflake" style="left:{i * 8}%; animation-delay:{i * 0.6}s;">{SNOWFLAKE}</div>'
+            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"""
+        <div style="display:flex;gap:8px;align-items:center;">
+          <button onclick="navigator.clipboard.writeText('{escaped}')"
+            style="background:#d4af37;color:#2b1b00;font-weight:700;border:none;padding:10px 16px;border-radius:999px;">
+            Copy Route Summary
+          </button>
+          <span style="color:#e6f1ff;font-size:0.9rem;">Ready to share {GIFT}</span>
+        </div>
+        """,
+        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"<div class='metric-card'><h3>Total Distance</h3><p>{total_distance:.0f} km</p></div>",
+                unsafe_allow_html=True,
+            )
+            metrics[1].markdown(
+                f"<div class='metric-card'><h3>Average Risk</h3><p>{avg_risk:.0%}</p></div>",
+                unsafe_allow_html=True,
+            )
+            metrics[2].markdown(
+                f"<div class='metric-card'><h3>Optimization Time</h3><p>{elapsed:.2f} s</p></div>",
+                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()

packages.txt

@@ -0,0 +1,3 @@
+libgfortran5
+gfortran
+libgl1

requirements.txt

@@ -0,0 +1,9 @@
+streamlit==1.32.0
+numpy==1.26.4
+networkx==3.2.1
+folium==0.17.0
+streamlit-folium==0.18.0
+pandas==2.2.1
+geopy==2.4.1
+matplotlib==3.8.3
+scipy==1.11.4