Quantum Gates: The Moves an Attacker Can Make (Hadamard, CNOT, Pauli)

// main.go
// run: go run main.go
package main

import (
	"fmt"
	"math"
	"math/cmplx"
)

type Matrix [][]complex128

func matMul(a, b Matrix) Matrix {
	n := len(a)
	m := len(b[0])
	p := len(b)
	c := make(Matrix, n)
	for i := range c {
		c[i] = make([]complex128, m)
		for j := 0; j < m; j++ {
			for k := 0; k < p; k++ {
				c[i][j] += a[i][k] * b[k][j]
			}
		}
	}
	return c
}

func conjT(a Matrix) Matrix {
	n := len(a)
	m := len(a[0])
	b := make(Matrix, m)
	for i := range b {
		b[i] = make([]complex128, n)
		for j := 0; j < n; j++ {
			b[i][j] = cmplx.Conj(a[j][i])
		}
	}
	return b
}

func eye(n int) Matrix {
	e := make(Matrix, n)
	for i := range e {
		e[i] = make([]complex128, n)
		e[i][i] = 1
	}
	return e
}

func normFro(a Matrix) float64 {
	var s float64
	for _, row := range a {
		for _, v := range row {
			s += real(v*cmplx.Conj(v))
		}
	}
	return math.Sqrt(s)
}

func matvec(m Matrix, v []complex128) []complex128 {
	n := len(m)
	out := make([]complex128, n)
	for i := 0; i < n; i++ {
		for j, x := range v {
			out[i] += m[i][j] * x
		}
	}
	return out
}

func subMat(a, b Matrix) Matrix {
	n := len(a)
	c := make(Matrix, n)
	for i := range a {
		c[i] = make([]complex128, len(a[i]))
		for j := range a[i] {
			c[i][j] = a[i][j] - b[i][j]
		}
	}
	return c
}

func main() {
	s := 1 / math.Sqrt(2)
	H := Matrix{
		{complex(s, 0), complex(s, 0)},
		{complex(s, 0), complex(-s, 0)},
	}
	X := Matrix{{0, 1}, {1, 0}}
	Y := Matrix{{0, -1i}, {1i, 0}}
	Z := Matrix{{1, 0}, {0, -1}}
	CNOT := Matrix{
		{1, 0, 0, 0},
		{0, 1, 0, 0},
		{0, 0, 0, 1},
		{0, 0, 1, 0},
	}

	ket0 := []complex128{1, 0}

	// Apply H to |0>
	plus := matvec(H, ket0)
	var norm float64
	for _, v := range plus {
		norm += real(v * cmplx.Conj(v))
	}
	fmt.Printf("H|0> = %v   norm = %.6f\n", plus, norm)

	// Verify unitarity: U^dagger U = I
	gates := []struct {
		name string
		u    Matrix
	}{
		{"H", H}, {"X", X}, {"Y", Y}, {"Z", Z}, {"CNOT", CNOT},
	}
	for _, g := range gates {
		product := matMul(conjT(g.u), g.u)
		err := normFro(subMat(product, eye(len(g.u))))
		fmt.Printf("%-4s  ||U^dagger U - I|| = %.2e\n", g.name, err)
	}
}