# Task counts vs. success rates: why the same 1730 means wildly different things
def task_count_vs_success(total_tasks=1730, robots=6, hours=24):
    """
    Given only the task count, back out what different success rates imply.
    """
    scenarios = {}

    for rate in [0.99, 0.95, 0.90, 0.80, 0.70]:
        success = int(total_tasks * rate)
        fail = total_tasks - success
        # Rough assumption: one human intervention per failure (optimistic)
        interventions = fail
        per_robot_hours = hours
        interventions_per_robot_hour = interventions / (robots * per_robot_hours)

        scenarios[f"{rate:.0%}"] = {
            "successful tasks": success,
            "failed tasks": fail,
            "implied interventions": interventions,
            "interventions per robot-hour": f"{interventions_per_robot_hour:.2f}",
        }

    return scenarios

print(f"{'Success rate':<14}{'Success':<10}{'Fail':<8}{'Interventions':<16}{'Per robot-hour'}")
print("-" * 68)
for rate, d in task_count_vs_success().items():
    print(f"{rate:<14}{d['successful tasks']:<10}{d['failed tasks']:<8}"
          f"{d['implied interventions']:<16}{d['interventions per robot-hour']}")

# Four shifts, and what each one actually tests
def shift_breakdown():
    shifts = [
        {
            "shift": "early-morning breakfast rush",
            "time window": "06:00-10:00",
            "traffic": "spiky, high per-customer urgency",
            "technical focus": "peak concurrency, queue backlog, coffee + hot food handoff",
        },
        {
            "shift": "midday peak probation",
            "time window": "11:00-14:00",
            "traffic": "highest density, most interference",
            "technical focus": "multi-robot contention, aisle obstruction, path conflicts",
        },
        {
            "shift": "evening peak stress test",
            "time window": "17:00-21:00",
            "traffic": "high and sustained",
            "technical focus": "sustained load, battery/thermal, accumulated error",
        },
        {
            "shift": "late-night solo watch",
            "time window": "22:00-06:00",
            "traffic": "near zero",
            "technical focus": "idle self-practice, memory consolidation, autonomous restocking",
        },
    ]
    return shifts

for s in shift_breakdown():
    print(f"\n[{s['shift']}] {s['time window']}")
    print(f"  traffic      : {s['traffic']}")
    print(f"  tests        : {s['technical focus']}")

# Three levels of "unmanned" — the challenge only proves the first two
def unmanned_levels():
    return {
        "L1: no teleoperation": {
            "meaning": "robots decide and execute actions themselves, no human driving",
            "proven by": "task counts + livestream (actions visibly autonomous)",
            "evidence strength": "strong",
        },
        "L2: no on-site tuning": {
            "meaning": "engineers don't adjust parameters on site during the run",
            "proven by": "official statement",
            "evidence strength": "medium (self-reported)",
        },
        "L3: no human intervention on failure": {
            "meaning": "when the robot fails, it recovers by itself without a human stepping in",
            "proven by": "would require publishing intervention counts",
            "evidence strength": "not disclosed",
        },
    }

for level, d in unmanned_levels().items():
    print(f"\n{level}")
    for k, v in d.items():
        print(f"  {k:20s}: {v}")

                    ┌──────────────────────────────────────┐
                    │         Genie Master (shared brain)  │
                    │                                      │
                    │  ┌────────────────────────────────┐  │
                    │  │  L1  调度层                     │  │
                    │  │  · task assignment by scene     │  │
                    │  │  · six-robot contention resolve │  │
                    │  │  · priority by customer waiting │  │
                    │  └──────────────┬─────────────────┘  │
                    │                 │                    │
                    │  ┌──────────────▼─────────────────┐  │
                    │  │  L2  执行层 (Embodied Execution │  │
                    │  │       Protocol)                 │  │
                    │  │  · task judgment → action       │  │
                    │  │  · real-time perception adjust  │  │
                    │  │  · result feedback upstream     │  │
                    │  └──────────────┬─────────────────┘  │
                    │                 │                    │
                    │  ┌──────────────▼─────────────────┐  │
                    │  │  L3  学习层                     │  │
                    │  │  · daily success/failure review │  │
                    │  │  · long-term memory storage     │  │
                    │  │  · corrected policy → training  │  │
                    │  │  · idle-time self-practice      │  │
                    │  └────────────────────────────────┘  │
                    └──────────────────────────────────────┘
                              │              │
              ┌───────────────┘              └──────────────┐
              ▼                                             ▼
     ┌─────────────────┐                          ┌─────────────────┐
     │  6 × G2 robots  │                          │  training data  │
     │  (each a worker │                          │  (feeds back to │
     │   session)      │                          │   action model) │
     └─────────────────┘                          └─────────────────┘

# Multi-robot contention: how a simple priority scheduler behaves under load
import random

def simulate_contention(robots=6, minutes=60, task_rate=1.2, seed=42):
    """
    Simplified: at each minute, task_rate new tasks arrive on average;
    each robot can handle one task; conflicts arise when >1 robot wants the same zone.
    """
    random.seed(seed)
    zones = ["entrance", "shelf_A", "shelf_B", "coffee", "checkout", "cleaning"]
    busy = {z: 0 for z in zones}
    queue = 0
    conflicts = 0
    served = 0

    for m in range(minutes):
        arrivals = 0
        # Poisson-ish arrivals
        while random.random() < task_rate / 60 * 10:
            arrivals += 1
        queue += arrivals

        for _ in range(robots):
            if queue <= 0:
                break
            zone = random.choice(zones)
            if busy[zone] > 0:
                conflicts += 1
                continue
            busy[zone] = random.randint(2, 6)  # task takes 2-6 minutes
            queue -= 1
            served += 1

        for z in zones:
            if busy[z] > 0:
                busy[z] -= 1

    return {
        "tasks arrived": served + queue,
        "tasks served": served,
        "backlog": queue,
        "zone conflicts": conflicts,
        "conflict rate": f"{conflicts / max(served,1):.1%}",
    }

for k, v in simulate_contention().items():
    print(f"  {k:18s} {v}")

# The learning loop: memory reuse vs. policy update, two different paths
def learning_loop(days=30, tasks_per_day=1730, success_0=0.88):
    """
    Two mechanisms work in parallel:
      1) memory reuse: solved cases retrieved directly (fast, no retraining)
      2) policy update: corrected trajectories become training data (slow, generalizes)
    """
    success = success_0
    memory = 0          # reusable cases in long-term memory
    policy_gain = 0.0   # cumulative generalization gain
    history = []

    for d in range(1, days + 1):
        # memory grows from solved tasks, with decay for stale cases
        memory = int(memory * 0.98 + tasks_per_day * success * 0.15)

        # policy gain compounds slowly, saturating
        policy_gain += 0.004 * (1 - policy_gain / 0.12)

        # combined effect: memory gives immediate lift, policy gives lasting lift
        memory_lift = min(memory / 20000 * 0.05, 0.05)
        success = min(success_0 + memory_lift + policy_gain, 0.995)

        if d % 5 == 0 or d == 1:
            history.append((d, memory, f"{success:.3f}"))

    return history

print(f"{'Day':<6}{'Memory cases':<16}{'Success rate'}")
print("-" * 36)
for d, mem, rate in learning_loop():
    print(f"{d:<6}{mem:<16}{rate}")

# Dual verification: voice + vision must agree before acting
def dual_verify(voice_intent, vision_labels, threshold=0.85):
    """
    voice_intent: attribute extracted from speech, e.g. "sugar_free"
    vision_labels: list of (label, confidence) from visual inspection
    """
    best = max(vision_labels, key=lambda x: x[1])

    if best[0] != voice_intent:
        return {
            "action": "abort_and_ask",
            "reason": f"vision says '{best[0]}', voice says '{voice_intent}'",
            "confidence": best[1],
        }

    if best[1] < threshold:
        return {
            "action": "re_scan",
            "reason": f"label confidence {best[1]:.2f} below threshold {threshold}",
            "confidence": best[1],
        }

    return {
        "action": "grasp",
        "reason": "voice and vision agree with high confidence",
        "confidence": best[1],
    }

# Case A: clear label
print("Case A (clear label):")
for k, v in dual_verify("sugar_free", [("sugar_free", 0.94), ("regular", 0.05)]).items():
    print(f"  {k:12s} {v}")

# Case B: ambiguous / low confidence
print("\nCase B (ambiguous):")
for k, v in dual_verify("sugar_free", [("sugar_free", 0.71), ("regular", 0.28)]).items():
    print(f"  {k:12s} {v}")

# Case C: conflict
print("\nCase C (conflict):")
for k, v in dual_verify("sugar_free", [("regular", 0.88), ("sugar_free", 0.11)]).items():
    print(f"  {k:12s} {v}")

# Two paradigms for shelf restocking — and why only one survives disorder
def restocking_paradigms():
    return {
        "position memory": {
            "logic": "remember item i belongs at slot j",
            "works when": "shelf layout never changes",
            "fails when": "items are shuffled, layout changes, new SKUs arrive",
            "robustness": "low",
        },
        "visual inventory": {
            "logic": "recognize each item, then find its correct slot",
            "works when": "recognition is reliable",
            "fails when": "packaging is visually near-identical (e.g. sugar-free vs regular)",
            "robustness": "high",
        },
        "hybrid (what was shown)": {
            "logic": "recognize item + cross-check slot constraints + verify after placing",
            "works when": "recognition + spatial reasoning both hold",
            "fails when": "heavy occlusion or new packaging never seen",
            "robustness": "highest, at higher compute cost",
        },
    }

for name, d in restocking_paradigms().items():
    print(f"\n[{name}]")
    for k, v in d.items():
        print(f"  {k:14s}: {v}")

# Obstacle policy: stop-first vs. keep-moving, and the safety math
def obstacle_policy(robot_mass_kg=45, speed_mps=1.0, reaction_s=0.3):
    """
    Simplified stopping-distance comparison.
    """
    results = {}

    # Policy A: stop first, then re-plan
    stop_distance_a = speed_mps * reaction_s + (speed_mps ** 2) / (2 * 2.0)
    results["A: stop then re-plan"] = {
        "stopping distance (m)": f"{stop_distance_a:.2f}",
        "extra time (s)": "2.5-4.0 (re-planning)",
        "collision risk": "very low",
    }

    # Policy B: keep moving while computing
    stop_distance_b = speed_mps * (reaction_s + 0.8) + (speed_mps ** 2) / (2 * 2.0)
    results["B: compute while moving"] = {
        "stopping distance (m)": f"{stop_distance_b:.2f}",
        "extra time (s)": "0.3-0.8",
        "collision risk": "elevated (path may change underfoot)",
    }

    return results

for policy, d in obstacle_policy().items():
    print(f"\n{policy}")
    for k, v in d.items():
        print(f"  {k:22s}: {v}")

# Back-of-envelope: what 1730 tasks over 24 hours actually implies
def task_pacing():
    total = 1730
    robots = 6
    hours = 24
    breakdown = {
        "customer reception": 683,
        "item fetch/delivery": 369,
        "coffee making": 147,
        "breakfast service": 126,
        "restocking/shelf check": 277,
        "table cleaning": 128,
    }

    print(f"Total tasks: {total}")
    print(f"Per robot: {total/robots:.1f} tasks over {hours}h")
    print(f"Per robot-hour: {total/(robots*hours):.1f} tasks")
    print(f"Average interval: {robots*hours*60/total:.1f} min between tasks\n")

    print(f"{'Task type':<24}{'Count':<8}{'Share':<9}{'Per hour (all robots)'}")
    print("-" * 66)
    for name, count in breakdown.items():
        share = count / total
        per_hour = count / hours
        print(f"{name:<24}{count:<8}{share:<9.1%}{per_hour:.1f}")

    # Implied concurrency at peak
    print("\nPeak-hour implication (assume 30% of daily tasks in 4 peak hours):")
    peak_tasks = total * 0.30
    peak_hours = 4
    peak_rate = peak_tasks / peak_hours
    print(f"  peak task rate: {peak_rate:.1f} tasks/hour")
    print(f"  per robot at peak: {peak_rate/robots:.1f} tasks/hour "
          f"(≈ 1 task every {60/(peak_rate/robots):.1f} min)")

task_pacing()

# AgiBot's public live-demo track record, for context
def historical_baselines():
    return [
        {
            "date": "2025-07",
            "scene": "Fulin Precision Mianyang plant (A2-W)",
            "duration": "3 hours",
            "reported result": "zero failures",
            "metric type": "claimed zero-failure",
        },
        {
            "date": "2025-08",
            "scene": "24h summer city walk (A2)",
            "duration": "24 hours",
            "reported result": "completed",
            "metric type": "completion, no task rate",
        },
        {
            "date": "2025-11",
            "scene": "106km walk Suzhou→Shanghai (A2)",
            "duration": "56 hours, 15 battery swaps",
            "reported result": "completed",
            "metric type": "endurance, no manipulation",
        },
        {
            "date": "2026-06",
            "scene": "Nanchang Longqi plant, 8× G2",
            "duration": "6 consecutive days, 8am-7pm",
            "reported result": "99.99% task success",
            "metric type": "explicit success rate",
        },
        {
            "date": "2026-11",
            "scene": "Shanghai Xuhui convenience store, 6× G2",
            "duration": "24 hours",
            "reported result": "1730 tasks, 4/6 passed",
            "metric type": "task counts only",
        },
    ]

print(f"{'Date':<10}{'Duration':<32}{'Reported':<28}{'Metric'}")
print("-" * 96)
for b in historical_baselines():
    print(f"{b['date']:<10}{b['duration']:<32}{b['reported result']:<28}{b['metric type']}")