Minimum Distance

generate_automorphisms(
    C::AbstractLinearCode
) -> Vector{Vector{Int64}}

Return known coordinate-permutation generators for C. An empty vector means that no family-specific generators are currently implemented.

heuristic_info_set_selection(
    C::AbstractLinearCode
) -> Symbol

Selects the most mathematically efficient information set algorithm based on the code's length, dimension, and algebraic structure.

information_sets(
    G::Union{Nemo.FqMatrix, Nemo.fpMatrix, Hecke.SMat, SparseArrays.SparseMatrixCSC};
    ...
) -> Tuple{Vector{Any}, Vector{Any}, Vector{Int64}}
information_sets(
    G::Union{Nemo.FqMatrix, Nemo.fpMatrix, Hecke.SMat, SparseArrays.SparseMatrixCSC},
    alg::Symbol;
    permute,
    only_A
) -> Tuple{Vector{Any}, Vector{Any}, Vector{Int64}}

Return the systematic matrices, associated column permutations, and ranks produced from G by the selected information-set algorithm. When only_A is true, return only each nonsystematic block in the matrix collection; when permute is true, move each selected information set to the front.

minimum_distance(
    C::AbstractLinearCode;
    alg,
    info_set_alg,
    auts,
    verbose
) -> Union{Nothing, Tuple{Any, Any}}

Return the minimum distance of the linear code if known, otherwise computes it using the dynamically optimal algorithm or the explicit algorithm of alg.

minimum_distance_zssmp(
    C::AbstractLinearCode;
    verbose,
    kwargs...
) -> Union{Nothing, Tuple{Any, Any}}

Executes the ZSSMP attack from Joundan et al. (2019). Extracts the fixed subcodes for known automorphisms and runs the highly optimized Brouwer–Zimmermann engines on the drastically reduced dimension k_sub.

logbinomial(n::Int64, k::Int64) -> Float64

Safely computes log(n choose k) using the Gamma function to prevent BigInt overflow. Return -Inf if k < 0 or k > n.

probabilistic_minimum_distance_bjmm(
    C::AbstractLinearCode;
    confidence,
    p,
    ϵ1,
    l1,
    l2,
    verbose
) -> Tuple{Any, Any}

Return an upper bound on the minimum distance and a codeword witnessing that bound, as found by the Becker–Joux–May–Meurer (BJMM) algorithm. If the search fails, return (n, zeros(Int, n)).

probabilistic_minimum_distance_lee_brickell(
    C::AbstractLinearCode;
    confidence,
    p,
    verbose
) -> Tuple{Any, Any}

Return an upper bound on the minimum distance and a codeword witnessing that bound, as found by the Lee–Brickell algorithm at the target confidence level. If the search fails, return (n, zeros(Int, n)).

probabilistic_minimum_distance_lee_brickell(
    G::Matrix{Int64};
    confidence,
    p,
    verbose
) -> Tuple{Int64, Vector{Int64}}

Return an upper bound on the minimum distance and a codeword witnessing that bound, as found by the Lee–Brickell algorithm. If the search fails, return (n, zeros(Int, n)).

probabilistic_minimum_distance_leon(
    C::AbstractLinearCode;
    confidence,
    p,
    l,
    verbose
) -> Tuple{Any, Any}

Return an upper bound on the minimum distance and a codeword witnessing that bound, as found by Leon's algorithm at the target confidence level. If the search fails, return (n, zeros(Int, n)).

probabilistic_minimum_distance_mmt(
    C::AbstractLinearCode;
    confidence,
    p,
    l1,
    l2,
    verbose
) -> Tuple{Any, Any}

Return an upper bound on the minimum distance and a codeword witnessing that bound, as found by the May–Meurer–Thomae (MMT) four-way merge tree. If the search fails, return (n, zeros(Int, n)).

probabilistic_minimum_distance_prange(
    C::AbstractLinearCode;
    confidence,
    verbose
) -> Tuple{Any, Any}

probabilistic_minimum_distance_stern(
    G::Matrix{Int64};
    confidence,
    p,
    l,
    verbose
) -> Tuple{Int64, Vector{Int64}}

Return an upper bound on the minimum distance and a codeword witnessing that bound, as found by Stern's algorithm. If the search fails, return (n, zeros(Int, n)).

probabilistic_minimum_distance_stern_DOOM(
    C::AbstractLinearCode;
    confidence,
    p,
    l,
    verbose
) -> Tuple{Any, Any}

Return an upper bound on the minimum distance and a codeword witnessing that bound, as found by Sendrier's DOOM framework applied to Stern's algorithm. If the search fails, return (n, zeros(Int, n)).

DOOM targets an error vector of weight w-1 by simultaneously checking all n columns of the parity-check matrix, drastically reducing the required number of iterations compared to standard Stern.

heuristic_minimum_distance_aco(
    C::AbstractLinearCode;
    y_max,
    m_ants,
    verbose
) -> Tuple{Any, Any}

Executes a standalone Ant Colony Optimization algorithm (Bouzkraoui et al., 2018) to estimate the minimum distance of a linear code. Return (d_upper_bound, witness). Note that this is a probabilistic metaheuristic and does NOT mathematically guarantee the true minimum distance.

heuristic_minimum_distance_ga(
    C::AbstractLinearCode;
    max_gens,
    pop_size,
    verbose
) -> Tuple{Any, Any}

Executes a standalone Genetic Algorithm (Askali et al., 2013) to estimate the minimum distance of a linear code. Return (d_upper_bound, witness). Note that this is a probabilistic metaheuristic and does NOT mathematically guarantee the true minimum distance.

heuristic_minimum_distance_gga_order(
    C::AbstractLinearCode;
    max_gens,
    pop_size,
    verbose
) -> Tuple{Any, Any}

Executes the GGA-Order metaheuristic (Cuéllar et al., 2020) to estimate the minimum distance. Explores the permutation space S_n rather than the discrete message space F_q^k. Return (d_upper_bound, witness). Does NOT mathematically guarantee the true minimum distance.

heuristic_minimum_distance_irons(
    C::AbstractLinearCode;
    num_iters,
    p_max,
    verbose
) -> Tuple{Any, Any}

Implements the non-binary probabilistic algorithm (Algorithm 5) from Irons (2005). Randomly selects combinations of up to p_max rows of the generator matrix and evaluates their weights. Extremely fast Monte Carlo estimation for generic non-binary codes.

heuristic_minimum_distance_nncs(
    C::AbstractLinearCode;
    verbose
) -> Tuple{Any, Any}

Implements the Nearest Nonzero Codeword Search (NNCS) using the Bit-Reversing noise pattern from Hu et al. (2004). Uses an OSD-0 (Order Statistic Decoding) hard-decision erasure strategy tailored for LDPC codes.

heuristic_weight_distribution_hirotomo(
    C::AbstractLinearCode,
    target_w::Int64;
    t_iters
) -> Dict{Int64, Float64}

Return a Dict of weight to estimated count for the low-weight part of the weight distribution $A_w$ of an LDPC code, using the method of Hirotomo et al. (2005). Stern's algorithm is run t_iters times to populate the frequency spectrum $B_w$, and the multiplicity is estimated by dividing by Stern's success probability $\pi_w$.