# Operations on Codewords

## Construction of a Codeword

### `C ! [a₁, ..., aₙ]: Code, [ RngElt ] -> ModTupRngElt`

### `elt< C | a₁, ..., aₙ>: Code, List -> ModTupRngElt`

Given a length $n$ additive code $C$ with alphabet $F$, then the codewords of $C$ lie in $F^{(n)}$. Given elements $a_1, \ldots, a_n$ belonging to $F$, construct the codeword $(a_1, \ldots, a_n)$ of $C$. A check is made that the vector ($a_1, \ldots, a_n$) is an element of $C$.

### `C ! u: Code, ModTupRngElt -> ModTupRngElt`

Given an additive code $C$ which is defined as a subset of the $F$-space $V = F^{(n)}$, and an element $u$ belonging to $V$, create the codeword of $C$ corresponding to $u$. The function will fail if $u$ does not belong to $C$.

### `C ! 0: Code, RngIntElt -> ModTupRngElt`

The zero word of the additive code $C$.

### `Random(C): Code -> ModTupRngElt`

A random codeword of the additive code $C$.

## Arithmetic Operations on Codewords

### `u + v: ModTupRngElt, ModTupRngElt -> ModTupRngElt`

Sum of the codewords $u$ and $v$, where $u$ and $v$ belong to the same linear code $C$.

### `- u: ModTupRngElt -> ModTupRngElt`

Additive inverse of the codeword $u$ belonging to the linear code $C$.

### `u - v: ModTupRngElt, ModTupRngElt -> ModTupRngElt`

Difference of the codewords $u$ and $v$, where $u$ and $v$ belong to the same linear code $C$.

### `a * u: RngElt, ModTupRngElt -> ModTupRngElt`

Given an element $a$ belonging to the alphabet $F$, and a codeword $u$ belonging to the additive code $C$, return the codeword $a*u$.

### `Normalize(u): ModTupRngElt -> ModTupRngElt`

Normalize a codeword $u$ of an additive code $C$, returning a scalar multiple of $u$ such that its first non-zero entry is $1$.

## Distance and Weight

### `Distance(u, v): ModTupRngElt, ModTupRngElt -> RngIntElt`

The Hamming distance between the codewords $u$ and $v$, where $u$ and $v$ belong to the same additive code $C$.

### `Weight(u): ModTupRngElt -> RngIntElt`

The Hamming weight of the codeword $u$, i.e., the number of non-zero components of $u$.

## Vector Space and Related Operations

### `(u, v): ModTupRngElt, ModTupRngElt -> RngElt`

### `InnerProduct(u, v): ModTupRngElt, ModTupRngElt -> RngElt`

Inner product of the vectors $u$ and $v$ with respect to the Euclidean norm, where $u$ and $v$ belong to the parent vector space of the code $C$.

### `TraceInnerProduct(K, u, v): FldFin, ModTupFldElt, ModTupFldElt -> FldFinElt`

Given vectors $u$ and $v$ defined over a finite field $L$ and a subfield $K$ of $L$, this function returns the trace of the inner product of the vectors $u$ and $v$ with respect to $K$.

### `Support(w): ModTupRngElt -> { RngIntElt }`

Given a word $w$ belonging to the $[n, k]$ code $C$, return its support as a subset of the integer set $\{ 1 .. n \}$. The support of $w$ consists of the coordinates at which $w$ has non-zero entries.

### `Coordinates(C, u): Code, ModTupRngElt -> [ RngFinElt ]`

Given an $[n, k\, :\,k_g]$ $K$-additive code $C$ and a codeword $u$ of $C$ return the coordinates of $u$ with respect to the current basis of $C$. The coordinates of $u$ are returned as a sequence $Q = [a_1, \ldots, a_{k_g}]$ of elements from $K$ such that $u = a_1 * C.1 + \ldots + a_{k_g} * C.{k_g}$.

### `Parent(w): ModTupRngElt -> ModTupRng`

Given a word $w$ belonging to the code $C$, return the ambient space $V$ of $C$.

### `Rotate(u, k): ModTupRngElt, RngIntElt -> ModTupRngElt`

Given a vector $u$, return the vector obtained from $u$ by cyclically shifting its components to the right by $k$ coordinate positions.

### `Rotate(~u, k): ModTupRngElt, RngIntElt`

Given a vector $u$, destructively rotate $u$ by $k$ coordinate positions.

### `Trace(u, S): ModTupFldElt, FldFin -> ModTupFldElt`

### `Trace(u): ModTupFldElt -> ModTupFldElt`

Given a vector $u$ with components in $K$, and a subfield $S$ of $K$, construct the vector with components in $S$ obtained from $u$ by taking the trace of each component with respect to $S$. If $S$ is omitted, it is taken to be the prime field of $K$.

## Predicates for Codewords

### `u eq v: ModTupRngElt, ModTupRngElt -> BoolElt`

The function returns `true` if and only if the codewords $u$ and $v$ belonging to the same additive code are equal.

### `u ne v: ModTupRngElt, ModTupRngElt -> BoolElt`

The function returns `true` if and only if the codewords $u$ and $v$ belonging to the same additive code are not equal.

### `IsZero(u): ModTupRngElt -> BoolElt`

The function returns `true` if and only if the codeword $u$ is the zero vector.

## Accessing Components of a Codeword

### `u[i]: ModTupRngElt, RngIntElt -> RngElt`

Given a codeword $u$ belonging to the code $C$ defined over the ring $R$, return the $i$-th component of $u$ (as an element of $R$).

### `u[i] := x;`

Given an element $u$ belonging to a subcode $C$ of the full $R$-space $V = R^n$, a positive integer $i$, $1 \leq i\leq n$, and an element $x$ of $R$, this function returns a vector in $V$ which is $u$ with its $i$-th component redefined to be $x$.