Zoo: [[2^j, 2^-j-2,3]] Gottesman /Quantum Hamming Code

docs/src/references.bib

@@ -225,3 +225,95 @@ @article{nahum2017quantum
 	author = {Nahum, Adam and Ruhman, Jonathan and Vijay, Sagar and Haah, Jeongwan},
   year = {2017}
 }
+
+@article{Fowler_2011,
+   title={Two-dimensional color-code quantum computation},
+   volume={83},
+   ISSN={1094-1622},
+   url={http://dx.doi.org/10.1103/PhysRevA.83.042310},
+   DOI={10.1103/physreva.83.042310},
+   number={4},
+   journal={Physical Review A},
+   publisher={American Physical Society (APS)},
+   author={Fowler, Austin G.},
+   year={2011},
+   month=apr }
+
+@misc{bombin2015gauge,
+      title={Gauge Color Codes: Optimal Transversal Gates and Gauge Fixing in Topological Stabilizer Codes}, 
+      author={H. Bombin},
+      year={2015},
+      eprint={1311.0879},
+      archivePrefix={arXiv},
+      primaryClass={quant-ph}
+}
+
+@misc{bravyi1998quantum,
+      title={Quantum codes on a lattice with boundary}, 
+      author={S. B. Bravyi and A. Yu. Kitaev},
+      year={1998},
+      eprint={quant-ph/9811052},
+      archivePrefix={arXiv},
+      primaryClass={quant-ph}
+}
+
+@article{Vasmer_2019,
+   title={Three-dimensional surface codes: Transversal gates and fault-tolerant architectures},
+   volume={100},
+   ISSN={2469-9934},
+   url={http://dx.doi.org/10.1103/PhysRevA.100.012312},
+   DOI={10.1103/physreva.100.012312},
+   number={1},
+   journal={Physical Review A},
+   publisher={American Physical Society (APS)},
+   author={Vasmer, Michael and Browne, Dan E.},
+   year={2019},
+   month=jul }
+
+@misc{fahimniya2023faulttolerant,
+      title={Fault-tolerant hyperbolic Floquet quantum error correcting codes}, 
+      author={Ali Fahimniya and Hossein Dehghani and Kishor Bharti and Sheryl Mathew and Alicia J. Kollár and Alexey V. Gorshkov and Michael J. Gullans},
+      year={2023},
+      eprint={2309.10033},
+      archivePrefix={arXiv},
+      primaryClass={quant-ph}
+}
+
+@article{Breuckmann_2021,
+   title={Quantum Low-Density Parity-Check Codes},
+   volume={2},
+   ISSN={2691-3399},
+   url={http://dx.doi.org/10.1103/PRXQuantum.2.040101},
+   DOI={10.1103/prxquantum.2.040101},
+   number={4},
+   journal={PRX Quantum},
+   publisher={American Physical Society (APS)},
+   author={Breuckmann, Nikolas P. and Eberhardt, Jens Niklas},
+   year={2021},
+   month=oct }
+
+@article{Krishna_2021,
+   title={Fault-Tolerant Gates on Hypergraph Product Codes},
+   volume={11},
+   ISSN={2160-3308},
+   url={http://dx.doi.org/10.1103/PhysRevX.11.011023},
+   DOI={10.1103/physrevx.11.011023},
+   number={1},
+   journal={Physical Review X},
+   publisher={American Physical Society (APS)},
+   author={Krishna, Anirudh and Poulin, David},
+   year={2021},
+   month=feb }
+
+@article{Roffe_2023,
+   title={Bias-tailored quantum LDPC codes},
+   volume={7},
+   ISSN={2521-327X},
+   url={http://dx.doi.org/10.22331/q-2023-05-15-1005},
+   DOI={10.22331/q-2023-05-15-1005},
+   journal={Quantum},
+   publisher={Verein zur Forderung des Open Access Publizierens in den Quantenwissenschaften},
+   author={Roffe, Joschka and Cohen, Lawrence Z. and Quintavalle, Armanda O. and Chandra, Daryus and Campbell, Earl T.},
+   year={2023},
+   month=may, pages={1005} }
+

docs/src/references.md

@@ -28,7 +28,17 @@ For circuit construction routines (for stabilizer measurements for a given code)
 - [grassl2002algorithmic](@cite)
 - [grassl2011variations](@cite)
 
+Quantum Error Correcting Codes:
+- 2D Color Code [Fowler_2011](@cite)
+- 3D Color Code [bombin2015gauge](@cite)
+- 2D Surface Code [bravyi1998quantum](@cite)
+- 3D Surface Code[Vasmer_2019](@cite)
+- Floquent Code [fahimniya2023faulttolerant](@cite) 
+- Quantum Low-Density Parity Check (QLDPC) Code [Breuckmann_2021](@cite)
+- Hypergraph Product Code [Krishna_2021](@cite)
+- Bias-tailored Quantum LDPC Codes [Roffe_2023](@cite)
+
 # References
 
 ```@bibliography
-```
+```

src/ecc/codes/QHammingcode.jl

@@ -0,0 +1,41 @@
+#The Gottesman code has the parameters [[2^r, 2^r - r - 2, 3]]
+#So, the parity check matrix will be of the form:
+#[[I_r, K, -I_r]
+#[K^T, I_(2^r - r - 2), 0]
+#[0, -K, I_r]]
+
+struct QHamming
+  r::Int
+end
+
+function parity_checks(code::QHamming)
+  r = code.r
+  n = 2^r
+
+  # Construct the K matrix (refer to Gottesman-Chuang codes for details)
+  K = zeros(Int, (n - r - 2), r)
+  for i in 1:n-r-2
+    j = i + 1
+    while j <= n
+      K[i, bit2int(Integer.tobits(j - 1)[end])] = 1
+      j += 1
+    end
+  end
+
+  # Parity check matrix
+  H = [[diagm(ones(Int, r)), K, -diagm(ones(Int, r))]
+       [K', diagm(ones(Int, n - r - 2)), zeros(Int, n - r - 2)]
+       [zeros(Int, n - r - 2), -K, diagm(ones(Int, r))]]
+
+  return CSS(H)
+end
+
+#how to use
+# Create two different instances of the quantum Hamming code
+#code1 = QHamming(5)  # r = 5
+#code2 = QHamming(7)  # r = 7
+
+# Get the parity check matrices for each instance
+#H1 = parity_checks(code1)
+#H2 = parity_checks(code2)
+

src/ecc/codes/code422.jl

@@ -0,0 +1,11 @@
+# TODO [[4,2,2]] qubit code (Simplest Surface Code)
+
+struct code422 <: AbstractECC end
+
+parity_checks(c::code422) = S"XZZX
+                              YXXY"
+#not sure about the two lines,I have a hunch it's correct. Need verification.
+parity_checks_x(c::code422) = stab_to_gf2(parity_checks(code422()))[1:2,1:end÷2]
+parity_checks_z(c::code422) = stab_to_gf2(parity_checks(code422()))[2:end,end÷2+1:end]
+
+distance(c::code422) = 2

src/ecc/codes/code833.jl

@@ -0,0 +1,14 @@
+# TODO [[8,1,3]] qubit code
+
+struct code833 <: AbstractECC end
+
+parity_checks(c::code833) = S"XXXXXXXX
+                              ZZZZZZZZ
+                              _X_XYZYZ
+                              _XZY_XZY
+                              _YXZXZ_Y"
+
+parity_checks_x(c::code833) = stab_to_gf2(parity_checks(code833()))[1:3,1:end÷2]
+parity_checks_z(c::code833) = stab_to_gf2(parity_checks(code833()))[5:end,end÷2+1:end]
+
+distance(c::code833) = 3

src/ecc/decoder_pipeline.jl

@@ -237,3 +237,66 @@ function PyMatchingDecoder(args...; kwargs...)
     end
     return ext.PyMatchingDecoder(args...; kwargs...)
 end
+
+"using QuantumClifford, Distances, JuMP"
+# Define a struct named `IterativeDecoder` that inherits from `AbstractSyndromeDecoder`
+struct IterativeDecoder <: AbstractSyndromeDecoder
+    # Stores the stabilizer matrix 
+    H
+    # Number of qubits in the code
+    n
+    # Number of data qubits (k = n - rank(H))
+    k
+    # Maximum number of iterations allowed in the decoding process
+    max_iterations
+end
+
+# Function to initialize an `IterativeDecoder` object
+function IterativeDecoder(c)
+    # Assuming H is already created
+    n, _ = size(H)
+    # Calculate number of data qubits based on stabilizer matrix rank
+    k = n - rank(H)
+    # Return an `IterativeDecoder` object with default max_iterations (can be adjusted)
+    return IterativeDecoder(H, n, k, 10)
+end
+
+# Function to perform iterative decoding using the Belief Propagation algorithm
+function decode(decoder::IterativeDecoder, syndrome_sample)
+    # Initialize error estimate vector with zeros
+    error_estimate = zeros(Int, decoder.n)
+    # Copy syndrome sample to a local variable
+    syndrome = syndrome_sample
+
+    # Loop for the maximum number of iterations
+    for _ in 1:decoder.max_iterations
+        # Use LDPCDecoders' belief_propagate function for one BP iteration
+        error_estimate = belief_propagate(decoder.H, syndrome, max_iterations=1)[:, end]
+
+        # Recalculate syndrome based on the updated error estimate using QuantumClifford's comm_all function
+        syndrome = comm_all(decoder.H, error_estimate)
+
+        # Check for stopping criteria: zero syndrome or max iterations reached
+        if all(syndrome == 0) || _ >= decoder.max_iterations
+            break
+        end
+    end
+
+    # Return the final error estimate vector
+    return error_estimate
+end
+
+function test_iterative_decoder()
+    # Create an instance of the decoder
+    decoder = IterativeDecoder(H)
+
+    # Generate a random syndrome sample 
+    n = size(H, 1)  # Number of qubits based on H
+    syndrome = rand(Bool, n)
+
+    # Decode the syndrome
+    decoded_errors = decode(decoder, syndrome)
+
+    # Define a test assertion: Check if all decoded errors are zeros (perfect decoding)
+    @test isall(decoded_errors == 0)
+end