v0.7.1: LLR-based physical weight formalism for surface decoders

Author: DennisWayo

CMakeLists.txt

@@ -19,6 +19,7 @@ add_executable(lidmas
         src/models/NeuralWeightModel.cpp
         src/UniformWeightField.cpp
         src/NeuralWeightField.cpp
+        src/LLRWeightField.cpp
         include/core/DecoderConfig.h
         include/core/IDecoderPlugin.h
         include/core/PluginRegistry.h

README.md

@@ -143,6 +143,10 @@ Adaptive-threshold flags:
 - `--target_ci_halfwidth=<x>`
 - `--target_rel_ci=<x>`
 - `--monotonic_smooth`
+- `--weight_mode=uniform|neural|llr`
+- `--llr_p_data=<x> --llr_p_meas=<x> --llr_p_idle=<x>`
+- `--llr_clamp_min=<x> --llr_clamp_max=<x>`
+- `--mwpm_weight_scale=<x>`
 
 CSV header:
 
@@ -152,6 +156,14 @@ distance,p,trials,ler,ci_low,ci_high,defect_mean,weight_mean,decoder_fail_rate
 
 Per-point console output includes Wilson 95% CI and decoder fail rate.
 
+Quick v0.7.1 smoke commands:
+
+```bash
+./lidmas --surface_threshold --decoder=uf --weight_mode=uniform --threads=8 --trials=2000 --d=5 --p_start=0.01 --p_end=0.03 --p_step=0.01
+./lidmas --surface_threshold --decoder=uf --weight_mode=llr --threads=8 --trials=2000 --d=5 --p_start=0.01 --p_end=0.03 --p_step=0.01
+./lidmas --surface_threshold --decoder=mwpm --weight_mode=llr --threads=8 --trials=2000 --d=5 --p_start=0.01 --p_end=0.03 --p_step=0.01
+```
+
 ## Run: Smoke Checks
 
 ```bash

include/LLRWeightField.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "WeightField.h"
+
+class LLRWeightField : public WeightField {
+public:
+    LLRWeightField(double p_data,
+                   double p_meas,
+                   double p_idle,
+                   double clamp_min = 1e-12,
+                   double clamp_max = 1.0 - 1e-12);
+
+    double edge_weight(int u, int v) const override;
+
+private:
+    double p_data_ = 0.01;
+    double p_meas_ = 0.01;
+    double p_idle_ = 0.01;
+    double clamp_min_ = 1e-12;
+    double clamp_max_ = 1.0 - 1e-12;
+};

include/plugins/mwpm/MWPMPlugin.h

@@ -1,7 +1,12 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "WeightField.h"
 #include "core/DecoderConfig.h"
 #include "surface/ISurfaceDecoderPlugin.h"
+#include "surface/MWPMDecoder.h"
 
 class MWPMPlugin : public ISurfaceDecoderPlugin {
 public:
@@ -12,4 +17,16 @@ class MWPMPlugin : public ISurfaceDecoderPlugin {
 
 private:
     DecoderConfig cfg_;
+    const SurfaceCode* cached_code_ = nullptr;
+    std::string cached_weight_mode_ = "uniform";
+    uint64_t cached_seed_ = 0;
+    double cached_p_error_ = -1.0;
+    double cached_weight_scale_ = 1000.0;
+    double cached_llr_p_data_ = -1.0;
+    double cached_llr_p_meas_ = -1.0;
+    double cached_llr_p_idle_ = -1.0;
+    double cached_llr_clamp_min_ = 1e-12;
+    double cached_llr_clamp_max_ = 1.0 - 1e-12;
+    std::unique_ptr<WeightField> cached_weight_field_;
+    std::unique_ptr<MWPMDecoder> cached_decoder_;
 };

include/plugins/uf/UnionFindPlugin.h

@@ -24,6 +24,11 @@ class UnionFindPlugin : public ISurfaceDecoderPlugin {
     std::string cached_weight_mode_ = "uniform";
     uint64_t cached_seed_ = 0;
     double cached_p_error_ = -1.0;
+    double cached_llr_p_data_ = -1.0;
+    double cached_llr_p_meas_ = -1.0;
+    double cached_llr_p_idle_ = -1.0;
+    double cached_llr_clamp_min_ = 1e-12;
+    double cached_llr_clamp_max_ = 1.0 - 1e-12;
     std::unique_ptr<WeightField> cached_weight_field_;
     std::unique_ptr<UnionFindDecoder> cached_decoder_;
     std::unique_ptr<lidmas_v07::UnionFindDecoder> cached_weighted_decoder_;

include/sim/SurfaceSimulation.h

@@ -14,6 +14,12 @@ struct SurfaceSweepConfig {
     std::string decoder_name = "stub";
     std::string weight_mode = "uniform";
     bool uf_weighted = false;
+    double llr_p_data = -1.0; // <0 => use point p
+    double llr_p_meas = -1.0; // <0 => use point p
+    double llr_p_idle = -1.0; // <0 => use point p
+    double llr_clamp_min = 1e-12;
+    double llr_clamp_max = 1.0 - 1e-12;
+    double mwpm_weight_scale = 1000.0;
     std::string neural_weights_path;
     std::string neural_model_path;
 };

include/sim/SurfaceThresholdRunner.h

@@ -19,6 +19,12 @@ struct SurfaceThresholdConfig {
     bool monotonic_smooth = false;
     std::string weight_mode = "uniform";
     bool uf_weighted = false;
+    double llr_p_data = -1.0; // <0 => use sweep point p
+    double llr_p_meas = -1.0; // <0 => use sweep point p
+    double llr_p_idle = -1.0; // <0 => use sweep point p
+    double llr_clamp_min = 1e-12;
+    double llr_clamp_max = 1.0 - 1e-12;
+    double mwpm_weight_scale = 1000.0;
     std::string neural_weights_path;
     std::string neural_model_path;
     int min_trials = 200;

include/surface/MWPMDecoder.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <vector>
+#include "WeightField.h"
+#include "UniformWeightField.h"
 #include "core/BinaryMatrix.h"
 #include "surface/BlossomMWPM.h"
 #include "surface/ISurfaceDecoder.h"
@@ -23,11 +25,16 @@ class MWPMDecoder : public ISurfaceDecoder {
     };
 
     explicit MWPMDecoder(const SurfaceCode& code);
+    MWPMDecoder(const SurfaceCode& code, const WeightField* weight_field, double weight_scale = 1000.0);
     std::vector<int> decode(const SurfaceSyndrome& syn) override;
 
 private:
     const SurfaceCode& code_;
     int d_ = 0;
+    UniformWeightField uniform_weight_field_;
+    const WeightField* weight_field_ = nullptr;
+    bool weighted_mode_ = false;
+    double weight_scale_ = 1000.0;
 
     int hIndex(int x, int y) const;
     int vIndex(int x, int y) const;
@@ -37,6 +44,8 @@ class MWPMDecoder : public ISurfaceDecoder {
     std::vector<Defect> defectsFromPlaquetteSyndrome(const std::vector<int>& sz) const;
     std::vector<Defect> defectsFromStarSyndrome(const std::vector<int>& sx) const;
     int manhattan(const Defect& a, const Defect& b) const;
+    int weightedCost(const Defect& a, const Defect& b, bool plaquette_mode) const;
+    int weightedBoundaryCost(const Defect& d, bool plaquette_mode) const;
     int DistToBoundaryZ(LatticeCoord zdef, int d) const;
     int DistToBoundaryX(LatticeCoord xdef, int d) const;
     int boundaryDistance(const Defect& d, bool plaquette_mode) const;

src/LLRWeightField.cpp

@@ -0,0 +1,48 @@
+#include "LLRWeightField.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace {
+
+double clampProb(double p, double lo, double hi) {
+    return std::clamp(p, lo, hi);
+}
+
+double llrFromProb(double p) {
+    const double w = std::log((1.0 - p) / p);
+    if (!std::isfinite(w)) return 0.0;
+    return std::max(0.0, w);
+}
+
+} // namespace
+
+LLRWeightField::LLRWeightField(double p_data,
+                               double p_meas,
+                               double p_idle,
+                               double clamp_min,
+                               double clamp_max)
+    : p_data_(p_data),
+      p_meas_(p_meas),
+      p_idle_(p_idle),
+      clamp_min_(std::max(1e-18, clamp_min)),
+      clamp_max_(std::min(1.0 - 1e-18, clamp_max)) {
+    if (clamp_min_ > clamp_max_) std::swap(clamp_min_, clamp_max_);
+}
+
+double LLRWeightField::edge_weight(int u, int v) const {
+    // No explicit time dimension in current surface graph: default all non-self edges to data errors.
+    // Self-edge is used as boundary/idle proxy where needed by decoder plugins.
+    double p_e = p_data_;
+    if (u == v) {
+        p_e = p_idle_;
+    }
+
+    // Future-proof hook for time-like edges when time index is encoded in node IDs.
+    if (u < 0 || v < 0) {
+        p_e = p_meas_;
+    }
+
+    const double p = clampProb(p_e, clamp_min_, clamp_max_);
+    return llrFromProb(p);
+}

src/decoders/UnionFindDecoder.h

@@ -1,3 +1,4 @@
+
 #pragma once
 
 #include <atomic>