#include "quantum/state.h"
#include "quantum/gates.h"

int main(void) {
    // Create Bell state |Φ+⟩ = (|00⟩ + |11⟩)/√2
    quantum_state_t state;
    quantum_state_init(&state, 2);

    gate_hadamard(&state, 0);
    gate_cnot(&state, 0, 1);

    // Verify entanglement
    double entropy = quantum_entanglement_entropy(&state, 0);
    printf("Entanglement entropy: %.4f (max 1.0)\n", entropy);

    quantum_state_free(&state);
    return 0;
}

#include "algorithms/tensor_network/tn_state.h"
#include "algorithms/tensor_network/tn_gates.h"

// Create 100-qubit MPS with bond dimension 64
tn_mps_t* mps = tn_mps_create(100, 64);

// Apply gates (automatic SVD truncation)
tn_mps_apply_single(mps, 0, GATE_H);
tn_mps_apply_two(mps, 0, 1, GATE_CNOT);

// Measure expectation values
double magnetization = tn_mps_expectation_z(mps, 50);

#include "algorithms/tensor_network/dmrg.h"

// Heisenberg chain Hamiltonian
dmrg_params_t params = {
    .num_sites = 100,
    .max_bond_dim = 128,
    .num_sweeps = 20,
    .tolerance = 1e-10
};

dmrg_result_t result = dmrg_ground_state(&hamiltonian, &params);
printf("Ground state energy: %.10f\n", result.energy);

#include "algorithms/tensor_network/tdvp.h"

// Real-time dynamics
tdvp_evolve(mps, hamiltonian, dt, num_steps, TDVP_TWO_SITE);

#include "algorithms/tensor_network/lattice_2d.h"
#include "algorithms/tensor_network/mpo_2d.h"

// Create 10x10 lattice
lattice_2d_t* lattice = lattice_2d_create(10, 10, LATTICE_SQUARE);

// Apply 2D MPO Hamiltonian
mpo_2d_t* H = mpo_2d_heisenberg(lattice, J_coupling);

grover_result_t result = grover_search(&state, marked_state, num_qubits);
// O(√N) queries vs classical O(N)

#include "algorithms/vqe.h"

vqe_config_t config = {
    .ansatz = VQE_ANSATZ_UCCSD,
    .optimizer = VQE_OPT_BFGS,
    .max_iterations = 100
};

vqe_result_t result = vqe_minimize(&hamiltonian, &config);
printf("Ground state energy: %.8f Ha\n", result.energy);

#include "algorithms/qaoa.h"

// MaxCut problem
qaoa_result_t result = qaoa_maxcut(&graph, num_layers);
printf("Best cut: %zu edges\n", result.best_cut);

#include "algorithms/qpe.h"

double phase = qpe_estimate(&unitary, precision_qubits, &state);

#include "algorithms/bell_tests.h"

bell_result_t result = bell_chsh(&state, 0, 1, 10000);
printf("CHSH: %.4f (classical ≤ 2, quantum ≤ 2.828)\n", result.chsh_value);

#include "algorithms/topological/topological.h"

// Create Fibonacci anyon system
anyon_system_t* sys = anyon_system_fibonacci(num_anyons);

// Braid anyons (topological gate)
braid_anyons(sys, i, j, BRAID_COUNTERCLOCKWISE);

// Compute resulting unitary
complex_t* U = fusion_tree_to_unitary(sys->fusion_tree);

// Create distance-5 surface code
surface_code_t* code = surface_code_create(5, 5, BOUNDARY_PLANAR);

// Measure stabilizers
surface_code_measure_stabilizers(code);

// Decode and correct errors
int success = surface_code_decode_mwpm(code);

// Create toric code on 6x6 lattice
toric_code_t* toric = toric_code_create(6, 6);

// Measure plaquette and star operators
toric_code_measure_plaquettes(toric);
toric_code_measure_stars(toric);

// Apply logical X on first logical qubit
toric_code_logical_x(toric, 0);

// Compute topological entanglement entropy
double gamma = topological_entanglement_entropy(&state, &region);
// γ = log(D) where D is total quantum dimension

#include "algorithms/tensor_network/skyrmion_braiding.h"

// Initialize two skyrmions
skyrmion_t sk1 = { .x = 0.0, .y = 0.0, .charge = 1 };
skyrmion_t sk2 = { .x = 2.0, .y = 0.0, .charge = 1 };

// Define circular braiding path
braid_path_t* path = braid_path_circular(sk1, sk2, num_steps);

// Perform braiding with TDVP time evolution
topo_qubit_t* qubit = topo_qubit_create(mps, sk1, sk2);
braid_result_t result = skyrmion_braid(qubit, path, &params);

// Extract Berry phase
printf("Berry phase: %.6f\n", result.berry_phase);
printf("Fidelity: %.6f\n", result.fidelity);

// Apply topological gates via skyrmion exchange
topo_gate_apply(qubit, TOPO_GATE_EXCHANGE);  // π rotation
topo_gate_apply(qubit, TOPO_GATE_BRAID);     // Braiding unitary

#include "algorithms/chemistry/chemistry.h"

// Create fermionic operator a†_p a_q
fermion_op_t op = fermion_op_hopping(p, q);

// Transform to qubit Hamiltonian
jw_operator_t* jw = jordan_wigner_transform(&op);

// Get Pauli string representation
pauli_string_t* paulis = jw_to_pauli_strings(jw);

// Build UCCSD circuit for molecular simulation
uccsd_params_t params = {
    .num_electrons = 2,
    .num_orbitals = 4,
    .singles = true,
    .doubles = true
};

circuit_t* ansatz = uccsd_circuit(&params);

// H2 molecule in minimal basis
molecular_hamiltonian_t* H = molecular_hamiltonian_h2(bond_length);

// Run VQE
vqe_result_t result = vqe_minimize(H, &vqe_config);
printf("H2 energy: %.6f Ha\n", result.energy);

#include "algorithms/mbl/mbl.h"

// Create XXZ Hamiltonian with disorder
xxz_params_t params = {
    .num_sites = 16,
    .Jxy = 1.0,
    .Jz = 1.0,
    .disorder_strength = 5.0,  // Strong disorder (MBL phase)
    .seed = 42
};

xxz_hamiltonian_t* H = xxz_hamiltonian_create(&params);

// Level statistics (Poisson vs GOE)
double r = level_spacing_ratio(eigenvalues, num_eigenvalues);
// r ≈ 0.39 (Poisson, MBL) vs r ≈ 0.53 (GOE, thermal)

// Entanglement entropy dynamics
double S = entanglement_entropy_half_chain(state, num_sites);