q2ns-5-noisy-teleportation-advanced-example.cc

Go to the documentation of this file.

/*-----------------------------------------------------------------------------
 * Q2NS - Quantum Network Simulator
 * Copyright (c) 2026 quantuminternet.it
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *---------------------------------------------------------------------------*/
/**
 * @file q2ns-5-noisy-teleportation-advanced-example.cc
 * @brief Teleportation experiment with UDP/TCP control transport and Bob-side memory noise
 *
 * Demonstrates:
 *   - quantum teleportation over a quantum link
 *   - classical correction delivery over UDP or TCP
 *   - receiver setup via PacketSinkHelper
 *   - distance-dependent propagation delay
 *   - Bob-side depolarizing noise while waiting for classical corrections
 *   - repeated trials with fidelity / latency statistics
 *
 * Tunable parameters:
 *   --proto        udp | tcp
 *   --distanceKm   Alice-Bob distance in km
 *   --TDepMs       Bob memory characteristic time in ms (0 => ideal memory)
 *   --trials       number of repeated trials
 *   --verbose      print per-trial details
 *
 * Example:
 *   ./ns3 run q2ns-5-noisy-teleportation-advanced-example -- --proto=udp --distanceKm=50 --TDepMs=5
 *--trials=20 --verbose=1
 *   ./ns3 run q2ns-5-noisy-teleportation-advanced-example -- --proto=tcp --distanceKm=50 --TDepMs=5
 *--trials=20 --verbose=1
 *---------------------------------------------------------------------------*/
 
#include "ns3/applications-module.h"
#include "ns3/core-module.h"
#include "ns3/internet-module.h"
#include "ns3/network-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/simulator.h"
 
#include "ns3/q2ns-analysis.h"
#include "ns3/q2ns-netcontroller.h"
#include "ns3/q2ns-qmap.h"
#include "ns3/q2ns-qnode.h"
#include "ns3/q2ns-qubit.h"
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <limits>
#include <memory>
#include <numeric>
#include <string>
#include <vector>
 
using namespace ns3;
using namespace q2ns;
 
namespace {
 
struct RunningStats {
  std::vector<double> xs;
 
  void Add(double x) {
    xs.push_back(x);
  }
 
  double Mean() const {
    if (xs.empty()) {
      return 0.0;
    }
    return std::accumulate(xs.begin(), xs.end(), 0.0) / static_cast<double>(xs.size());
  }
 
  double StdDev() const {
    if (xs.size() < 2) {
      return 0.0;
    }
    const double mean = Mean();
    double acc = 0.0;
    for (double x : xs) {
      const double d = x - mean;
      acc += d * d;
    }
    return std::sqrt(acc / static_cast<double>(xs.size() - 1));
  }
 
  double Median() const {
    if (xs.empty()) {
      return 0.0;
    }
    std::vector<double> tmp = xs;
    std::sort(tmp.begin(), tmp.end());
    const size_t n = tmp.size();
    if (n % 2 == 1) {
      return tmp[n / 2];
    }
    return 0.5 * (tmp[n / 2 - 1] + tmp[n / 2]);
  }
};
 
struct BobInfo {
  std::shared_ptr<Qubit> qRemote;
  bool qubitArrived = false;
  bool bitsArrived = false;
  int m1 = 0;
  int m2 = 0;
  Time tQubitArrive = Seconds(0);
  Time tBitsArrive = Seconds(0);
  bool done = false;
  double finalFidelity = std::numeric_limits<double>::quiet_NaN();
  double completionMs = std::numeric_limits<double>::quiet_NaN();
};
 
struct TrialResult {
  double fidelity = std::numeric_limits<double>::quiet_NaN();
  double completionMs = std::numeric_limits<double>::quiet_NaN();
};
 
struct TcpSendState {
  Ptr<Packet> pendingPkt;
  bool sent = false;
  bool verbose = false;
};
 
 
void TryCorrections(Ptr<QNode> bob, NetController& net, BobInfo& info, Ptr<DepolarizingQMap> depol,
                    Ptr<UniformRandomVariable> u, std::shared_ptr<Qubit> qRef, Time tStart,
                    bool verbose) {
  if (info.done || !info.qubitArrived || !info.bitsArrived) {
    return;
  }
 
  // Bob's qubit sits in memory from quantum arrival until the classical bits arrive.
  const Time holdTime = info.tBitsArrive - info.tQubitArrive;
 
  QMapContext ctx;
  ctx.elapsedTime = holdTime;
 
  QMapInstance instance = depol->Sample(u, ctx);
  instance(*bob, info.qRemote);
 
  // Standard teleportation correction: X^m2 Z^m1
  if (info.m2) {
    bob->Apply(gates::X(), {info.qRemote});
  }
  if (info.m1) {
    bob->Apply(gates::Z(), {info.qRemote});
  }
 
  const auto finalState = net.GetState(info.qRemote);
  const auto idealState = net.GetState(qRef);
 
  info.finalFidelity = q2ns::analysis::Fidelity(*finalState, *idealState);
  info.completionMs = (Simulator::Now() - tStart).GetSeconds() * 1000.0;
  info.done = true;
 
  if (verbose) {
    std::cout << "[B] corrections applied"
              << "  hold_ms=" << std::fixed << std::setprecision(3)
              << holdTime.GetSeconds() * 1000.0 << "  fidelity=" << std::setprecision(4)
              << info.finalFidelity << "\n";
  }
 
  Simulator::Stop();
}
 
 
static void OnControlRxTrace(Ptr<QNode> bob, BobInfo* bobInfo, NetController* net,
                             Ptr<DepolarizingQMap> depol, Ptr<UniformRandomVariable> u,
                             std::shared_ptr<Qubit> qRef, Time* tStart, bool verbose,
                             Ptr<const Packet> packet, const Address&) {
  uint8_t bytes[2] = {0, 0};
  const uint32_t n = packet->CopyData(bytes, 2);
 
  if (n < 2) {
    return;
  }
 
  bobInfo->bitsArrived = true;
  bobInfo->m1 = bytes[0] & 1;
  bobInfo->m2 = bytes[1] & 1;
  bobInfo->tBitsArrive = Simulator::Now();
 
  if (verbose) {
    std::cout << "[RECV][classical][B] t=" << std::fixed << std::setprecision(6)
              << Simulator::Now().GetSeconds() << " s"
              << "  m1=" << bobInfo->m1 << "  m2=" << bobInfo->m2 << "\n";
  }
 
  TryCorrections(bob, *net, *bobInfo, depol, u, qRef, *tStart, verbose);
}
 
static void OnTcpConnectSuccess(std::shared_ptr<TcpSendState> tcpState, Ptr<Socket> s) {
  if (!tcpState->sent && tcpState->pendingPkt) {
    s->Send(tcpState->pendingPkt);
    tcpState->sent = true;
 
    if (tcpState->verbose) {
      std::cout << "[SEND][classical][tcp] A->B\n";
    }
 
    s->Close();
  }
}
 
static void OnTcpConnectFail(bool verbose, Ptr<Socket> s) {
  if (verbose) {
    std::cout << "[WARN] TCP connect failed\n";
  }
  s->Close();
}
 
TrialResult RunOnce(const std::string& proto, double distanceKm, double TDepMs, bool verbose) {
  const uint16_t port = 9000;
 
  // Approximate propagation in fiber: 5 microseconds / km
  const Time qDelay = MicroSeconds(static_cast<int64_t>(std::llround(5.0 * distanceKm)));
  const Time cDelay = MicroSeconds(static_cast<int64_t>(std::llround(5.0 * distanceKm)));
 
  BobInfo bobInfo;
  Time tStart = Seconds(0);
 
  NetController net;
  net.SetQStateBackend(QStateBackend::Ket);
 
  auto A = net.CreateNode();
  auto B = net.CreateNode();
 
  // Reference node for the ideal |+> state
  auto ref = net.CreateNode();
  auto qRef = ref->CreateQubit();
  ref->Apply(gates::H(), {qRef});
 
  // Bob memory-noise map: p = 1 - exp(-t / Tdep)
  auto depol = CreateObject<DepolarizingQMap>();
  if (TDepMs > 0.0) {
    const double ratePerSecond = 1000.0 / TDepMs; // TDepMs is in ms
    depol->SetAttribute("Rate", DoubleValue(ratePerSecond));
  } else {
    depol->SetAttribute("Probability", DoubleValue(0.0));
  }
 
  auto u = CreateObject<UniformRandomVariable>();
 
  // Quantum link
  auto ch = net.InstallQuantumLink(A, B);
  ch->SetAttribute("Delay", TimeValue(qDelay));
 
  // Classical link
  InternetStackHelper internet;
  internet.Install(A);
  internet.Install(B);
 
  PointToPointHelper p2p;
  p2p.SetDeviceAttribute("DataRate", StringValue("100Mbps"));
  p2p.SetChannelAttribute("Delay", TimeValue(cDelay));
  NetDeviceContainer devices = p2p.Install(A, B);
 
  Ipv4AddressHelper ip;
  ip.SetBase("10.1.1.0", "255.255.255.0");
  Ipv4InterfaceContainer interfaces = ip.Assign(devices);
 
  // Receiver side: PacketSink handles the transport-specific listening/accept path.
  Address bindAddr = InetSocketAddress(Ipv4Address::GetAny(), port);
  PacketSinkHelper sinkHelper((proto == "udp") ? "ns3::UdpSocketFactory" : "ns3::TcpSocketFactory",
                              bindAddr);
  ApplicationContainer sinkApps = sinkHelper.Install(B);
  sinkApps.Start(Seconds(0.0));
  sinkApps.Stop(Seconds(5.0));
 
  Ptr<PacketSink> sink = DynamicCast<PacketSink>(sinkApps.Get(0));
  if (!sink) {
    NS_ABORT_MSG("Failed to install PacketSink on Bob");
  }
 
  // PacketSink trace hookup.
  // If your local ns-3 build wants RxWithAddresses instead, swap this accordingly.
  sink->TraceConnectWithoutContext("Rx", MakeBoundCallback(&OnControlRxTrace, B, &bobInfo, &net,
                                                           depol, u, qRef, &tStart, verbose));
 
  // Sender side:
  // UDP = connect/send/close immediately
  // TCP = connect asynchronously, send pending packet on connect success
  auto tcpState = std::make_shared<TcpSendState>();
  tcpState->verbose = verbose;
 
  // Bob's quantum receive callback
  B->SetRecvCallback(
      [B, &bobInfo, &net, depol, u, qRef, &tStart, verbose](std::shared_ptr<Qubit> q) {
        bobInfo.qRemote = q;
        bobInfo.qubitArrived = true;
        bobInfo.tQubitArrive = Simulator::Now();
 
        if (verbose) {
          std::cout << "[RECV][quantum][B] t=" << std::fixed << std::setprecision(6)
                    << Simulator::Now().GetSeconds() << " s\n";
        }
 
        TryCorrections(B, net, bobInfo, depol, u, qRef, tStart, verbose);
      });
 
  auto sendCtrlPacket = [&](Ptr<Packet> pkt) {
    InetSocketAddress dst(interfaces.GetAddress(1), port);
 
    if (proto == "udp") {
      Ptr<Socket> sock = Socket::CreateSocket(A, UdpSocketFactory::GetTypeId());
      if (sock->Connect(dst) == 0) {
        sock->Send(pkt);
        if (verbose) {
          std::cout << "[SEND][classical][udp] A->B\n";
        }
      } else if (verbose) {
        std::cout << "[WARN] UDP connect failed\n";
      }
      sock->Close();
      return;
    }
 
    Ptr<Socket> sock = Socket::CreateSocket(A, TcpSocketFactory::GetTypeId());
    tcpState->pendingPkt = pkt;
    tcpState->sent = false;
 
    sock->SetConnectCallback(MakeBoundCallback(&OnTcpConnectSuccess, tcpState),
                             MakeBoundCallback(&OnTcpConnectFail, verbose));
 
    int rc = sock->Connect(dst);
    if (rc != 0) {
      if (verbose) {
        std::cout << "[WARN] TCP connect() immediate failure\n";
      }
      sock->Close();
      tcpState->pendingPkt = nullptr;
    }
  };
 
  // Teleportation protocol
  Simulator::Schedule(NanoSeconds(1), [&]() {
    tStart = Simulator::Now();
 
    auto [qA, qBRemote] = A->CreateBellPair();
    const bool ok = A->Send(qBRemote, B->GetId());
 
    if (verbose) {
      std::cout << "[SEND][quantum] A->B: " << (ok ? "ok" : "failed") << "\n";
    }
 
    auto psi = A->CreateQubit();
    A->Apply(gates::H(), {psi});
 
    auto [m1, m2] = A->MeasureBell(psi, qA);
 
    if (verbose) {
      std::cout << "[A] BSM results: " << m1 << ", " << m2 << "\n";
    }
 
    uint8_t bytes[2] = {
        static_cast<uint8_t>(m1),
        static_cast<uint8_t>(m2),
    };
 
    sendCtrlPacket(Create<Packet>(bytes, 2));
  });
 
  Simulator::Stop(Seconds(5));
  Simulator::Run();
  Simulator::Destroy();
 
  TrialResult r;
  r.fidelity = bobInfo.finalFidelity;
  r.completionMs = bobInfo.completionMs;
  return r;
}
 
} // namespace
 
int main(int argc, char* argv[]) {
  std::string proto = "udp";
  double distanceKm = 50.0;
  double TDepMs = 5.0;
  uint32_t trials = 10;
  uint32_t seed = 1;
  uint32_t run = 1;
  bool verbose = false;
 
  CommandLine cmd;
  cmd.AddValue("proto", "udp | tcp", proto);
  cmd.AddValue("distanceKm", "Distance between Alice and Bob in km", distanceKm);
  cmd.AddValue("TDepMs", "Bob memory characteristic time in ms (0 => ideal memory)", TDepMs);
  cmd.AddValue("trials", "Number of repeated trials", trials);
  cmd.AddValue("seed", "ns-3 RNG seed", seed);
  cmd.AddValue("run", "ns-3 RNG run number", run);
  cmd.AddValue("verbose", "Print per-trial details", verbose);
  cmd.Parse(argc, argv);
 
  if (proto != "udp" && proto != "tcp") {
    NS_ABORT_MSG("--proto must be udp or tcp");
  }
 
  RngSeedManager::SetSeed(seed);
 
  RunningStats fidelityStats;
  RunningStats latencyStats;
 
  if (verbose) {
    std::cout << "[DEMO] Noisy teleportation experiment starting\n";
    std::cout << "  proto      = " << proto << "\n";
    std::cout << "  distanceKm = " << distanceKm << "\n";
    std::cout << "  TDepMs     = " << TDepMs << "\n";
    std::cout << "  trials     = " << trials << "\n";
  }
 
  for (uint32_t t = 0; t < trials; ++t) {
    RngSeedManager::SetRun(run + t);
 
    if (verbose) {
      std::cout << "\n[TRIAL " << (t + 1) << "/" << trials << "]\n";
    }
 
    TrialResult r = RunOnce(proto, distanceKm, TDepMs, verbose);
    fidelityStats.Add(r.fidelity);
    latencyStats.Add(r.completionMs);
  }
 
  std::cout << "\n[RESULT]"
            << " proto=" << proto << " distance_km=" << std::fixed << std::setprecision(3)
            << distanceKm << " TDep_ms=" << TDepMs << " trials=" << trials
            << " fidelity_mean=" << std::setprecision(4) << fidelityStats.Mean()
            << " fidelity_median=" << fidelityStats.Median()
            << " fidelity_stddev=" << fidelityStats.StdDev()
            << " latency_mean_ms=" << std::setprecision(4) << latencyStats.Mean()
            << " latency_median_ms=" << latencyStats.Median()
            << " latency_stddev_ms=" << latencyStats.StdDev() << "\n";
 
  if (verbose) {
    std::cout << "[DONE] Noisy teleportation experiment finished\n";
  }
 
  return 0;
}