def RandomLinearCodeGuava(n, k, F):
r"""
The method used is to first construct a `k \times n` matrix of the block
form `(I,A)`, where `I` is a `k \times k` identity matrix and `A` is a
`k \times (n-k)` matrix constructed using random elements of `F`. Then
the columns are permuted using a randomly selected element of the symmetric
group `S_n`.
INPUT:
- ``n,k`` -- integers with `n>k>1`.
OUTPUT:
Returns a "random" linear code with length `n`, dimension `k` over field `F`.
EXAMPLES::
sage: C = codes.RandomLinearCodeGuava(30,15,GF(2)); C # optional - gap_packages (Guava package)
[30, 15] linear code over GF(2)
sage: C = codes.RandomLinearCodeGuava(10,5,GF(4,'a')); C # optional - gap_packages (Guava package)
[10, 5] linear code over GF(4)
AUTHOR: David Joyner (11-2005)
"""
current_randstate().set_seed_gap()
GapPackage("guava", spkg="gap_packages").require()
libgap.load_package("guava")
C=libgap.RandomLinearCode(n,k,F)
G=C.GeneratorMat()
MS = MatrixSpace(F, len(G), len(G[0]))
return LinearCode(MS(G))
def QuasiQuadraticResidueCode(p):
r"""
A (binary) quasi-quadratic residue code (or QQR code).
Follows the definition of Proposition 2.2 in [BM2003]_. The code has a generator
matrix in the block form `G=(Q,N)`. Here `Q` is a `p \times p` circulant
matrix whose top row is `(0,x_1,...,x_{p-1})`, where `x_i=1` if and only if
`i` is a quadratic residue `\mod p`, and `N` is a `p \times p` circulant
matrix whose top row is `(0,y_1,...,y_{p-1})`, where `x_i+y_i=1` for all
`i`.
INPUT:
- ``p`` -- a prime `>2`.
OUTPUT:
Returns a QQR code of length `2p`.
EXAMPLES::
sage: C = codes.QuasiQuadraticResidueCode(11); C # optional - gap_packages (Guava package)
[22, 11] linear code over GF(2)
These are self-orthogonal in general and self-dual when $p \\equiv 3 \\pmod 4$.
AUTHOR: David Joyner (11-2005)
"""
GapPackage("guava", spkg="gap_packages").require()
libgap.load_package("guava")
C=libgap.QQRCode(p)
G=C.GeneratorMat()
MS = MatrixSpace(GF(2), len(G), len(G[0]))
return LinearCode(MS(G))
def bounds_on_minimum_distance_in_guava(n, k, F):
r"""
Compute a lower and upper bound on the greatest minimum distance of a
`[n,k]` linear code over the field ``F``.
This function requires the optional GAP package GUAVA.
The function returns a GAP record with the two bounds and an explanation for
each bound. The method ``Display`` can be used to show the explanations.
The values for the lower and upper bound are obtained from a table
constructed by Cen Tjhai for GUAVA, derived from the table of
Brouwer. See http://www.codetables.de/ for the most recent data.
These tables contain lower and upper bounds for `q=2` (when ``n <= 257``),
`q=3` (when ``n <= 243``), `q=4` (``n <= 256``). (Current as of
11 May 2006.) For codes over other fields and for larger word lengths,
trivial bounds are used.
INPUT:
- ``n`` -- the length of the code to look up
- ``k`` -- the dimension of the code to look up
- ``F`` -- the base field of the code to look up
OUTPUT:
- A GAP record object. See below for an example.
EXAMPLES::
sage: gap_rec = codes.databases.bounds_on_minimum_distance_in_guava(10,5,GF(2)) # optional - gap_packages (Guava package)
sage: gap_rec.Display() # optional - gap_packages (Guava package)
rec(
construction := [ <Operation "ShortenedCode">,
[ [ <Operation "UUVCode">,
[ [ <Operation "DualCode">,
[ [ <Operation "RepetitionCode">, [ 8, 2 ] ] ] ],
[ <Operation "UUVCode">, [ [ <Operation "DualCode">,
[ [ <Operation "RepetitionCode">, [ 4, 2 ] ] ] ],
[ <Operation "RepetitionCode">, [ 4, 2 ] ] ] ] ] ],
[ 1, 2, 3, 4, 5, 6 ] ] ],
k := 5,
lowerBound := 4,
lowerBoundExplanation := ...
n := 10,
q := 2,
references := rec(
),
upperBound := 4,
upperBoundExplanation := ... )
"""
GapPackage("guava", spkg="gap_packages").require()
libgap.load_package("guava")
return libgap.BoundsMinimumDistance(n, k, F)
def RandomLinearCodeGuava(n, k, F):
r"""
The method used is to first construct a `k \times n` matrix of the block
form `(I,A)`, where `I` is a `k \times k` identity matrix and `A` is a
`k \times (n-k)` matrix constructed using random elements of `F`. Then
the columns are permuted using a randomly selected element of the symmetric
group `S_n`.
INPUT:
- ``n,k`` -- integers with `n>k>1`.
OUTPUT:
Returns a "random" linear code with length `n`, dimension `k` over field `F`.
EXAMPLES::
sage: C = codes.RandomLinearCodeGuava(30,15,GF(2)); C # optional - gap_packages (Guava package)
[30, 15] linear code over GF(2)
sage: C = codes.RandomLinearCodeGuava(10,5,GF(4,'a')); C # optional - gap_packages (Guava package)
[10, 5] linear code over GF(4)
AUTHOR: David Joyner (11-2005)
"""
current_randstate().set_seed_gap()
q = F.order()
GapPackage("guava", spkg="gap_packages").require()
gap.load_package("guava")
gap.eval("C:=RandomLinearCode(" + str(n) + "," + str(k) + ", GF(" +
str(q) + "))")
gap.eval("G:=GeneratorMat(C)")
k = int(gap.eval("Length(G)"))
n = int(gap.eval("Length(G[1])"))
G = [[
gfq_gap_to_sage(gap.eval("G[%s][%s]" % (i, j)), F)
for j in range(1, n + 1)
] for i in range(1, k + 1)]
MS = MatrixSpace(F, k, n)
return LinearCode(MS(G))
def QuasiQuadraticResidueCode(p):
r"""
A (binary) quasi-quadratic residue code (or QQR code).
Follows the definition of Proposition 2.2 in [BM]. The code has a generator
matrix in the block form `G=(Q,N)`. Here `Q` is a `p \times p` circulant
matrix whose top row is `(0,x_1,...,x_{p-1})`, where `x_i=1` if and only if
`i` is a quadratic residue `\mod p`, and `N` is a `p \times p` circulant
matrix whose top row is `(0,y_1,...,y_{p-1})`, where `x_i+y_i=1` for all
`i`.
INPUT:
- ``p`` -- a prime `>2`.
OUTPUT:
Returns a QQR code of length `2p`.
EXAMPLES::
sage: C = codes.QuasiQuadraticResidueCode(11); C # optional - gap_packages (Guava package)
[22, 11] linear code over GF(2)
These are self-orthogonal in general and self-dual when $p \\equiv 3 \\pmod 4$.
AUTHOR: David Joyner (11-2005)
"""
GapPackage("guava", spkg="gap_packages").require()
F = GF(2)
gap.load_package("guava")
gap.eval("C:=QQRCode(" + str(p) + ")")
gap.eval("G:=GeneratorMat(C)")
k = int(gap.eval("Length(G)"))
n = int(gap.eval("Length(G[1])"))
G = [[
gfq_gap_to_sage(gap.eval("G[%s][%s]" % (i, j)), F)
for j in range(1, n + 1)
] for i in range(1, k + 1)]
MS = MatrixSpace(F, k, n)
return LinearCode(MS(G))
def best_linear_code_in_guava(n, k, F):
r"""
Returns the linear code of length ``n``, dimension ``k`` over field ``F``
with the maximal minimum distance which is known to the GAP package GUAVA.
The function uses the tables described in ``bounds_on_minimum_distance_in_guava`` to
construct this code. This requires the optional GAP package GUAVA.
INPUT:
- ``n`` -- the length of the code to look up
- ``k`` -- the dimension of the code to look up
- ``F`` -- the base field of the code to look up
OUTPUT:
- A :class:`LinearCode` which is a best linear code of the given parameters known to GUAVA.
EXAMPLES::
sage: codes.databases.best_linear_code_in_guava(10,5,GF(2)) # long time; optional - gap_packages (Guava package)
[10, 5] linear code over GF(2)
sage: gap.eval("C:=BestKnownLinearCode(10,5,GF(2))") # long time; optional - gap_packages (Guava package)
'a linear [10,5,4]2..4 shortened code'
This means that the best possible binary linear code of length 10 and
dimension 5 is a code with minimum distance 4 and covering radius s somewhere
between 2 and 4. Use ``bounds_on_minimum_distance_in_guava(10,5,GF(2))``
for further details.
"""
GapPackage("guava", spkg="gap_packages").require()
gap.load_package("guava")
q = F.order()
C = gap("BestKnownLinearCode(%s,%s,GF(%s))" % (n, k, q))
from .linear_code import LinearCode
return LinearCode(C.GeneratorMat()._matrix_(F))