**************************************************************************
   *                                                                        *
   *   PLEASE READ THE FOLLOWING NOTE!                                      *
   *                                                                        *
   *   1.  This file is the source for the article "Optimal binary linear   *
   *   codes of length <= 30", to appear in Discrete Mathematics.           *
   *   Copyright for the latter article is owned by the publisher.          *
   *   You may not produce a facsimile of the article from this file        *
   *   without permission of the publisher.                                 *
   *                                                                        *
   *   2.  Modification and redistribution of this file is allowed, but     *
   *   please exercise caution.  It would be undesirable to distribute      *
   *   (without warning) a version of this file which corresponds almost    *
   *   completely (but not exactly) to the published article.               *
   *                                                                        *
   **************************************************************************
     
define(TEX_IN,`tex/code.tex1')
define(DATA_IN,`inputs/code.data1')
define(newresultcounter,0)
include(src/MACROS)

|-> tex/code.tex1

% \second
\hfuzz 10pt

% Set up a svb macro, which is like verbatim, but doesn't put
% vertical spacing at the beginning and end.

\catcode`\@=11
 
\begingroup \catcode `|=0 \catcode `[= 1
\catcode`]=2 \catcode `\{=12 \catcode `\}=12
\catcode`\\=12 |gdef|@xsvb#1\end{svb}[#1|end[svb]]
|gdef|@sxsvb#1\end{svb*}[#1|end[svb*]]
|endgroup

\def\@svb{
\leftskip\@totalleftmargin\rightskip\z@
\parindent\z@\parfillskip\@flushglue\parskip\z@
\@tempswafalse \def\par{\if@tempswa\hbox{}\fi\@tempswatrue\@@par
\penalty\interlinepenalty}%
\obeylines \tt \catcode``=13 \@noligs \let\do\@makeother \dospecials}
 
\def\svb{\@svb \frenchspacing\@vobeyspaces \@xsvb}
\let\endsvb=\relax

\def\mindex{\@bsphack\begingroup\@sanitize\@wrindexa}
\catcode`\@=12

\vspace*{-1.3in} 
\par\noindent\raise1.3in\hbox to 0in{
\hbox{{\tt to appear in }{\it Discrete Mathematics}}}
{\par\noindent\Large\bf Optimal binary linear codes of length 
     \mbox{\boldmath$\leq 30$}}
\vskip 0.15in
\def\boxitTable{\lower3pt\hbox{\vbox{\hrule\hbox{\vrule\kern3pt
      \vbox{\kern3pt\hbox{Table}\kern3pt}\kern3pt\vrule}\hrule}}}
\def\makeaddress{
     \vskip 0.15in
     \par\noindent {\footnotesize Department of Mathematics and Statistics, 
                                  University of Nebraska}
     \par\noindent {\footnotesize Lincoln, NE 68588-0323, USA\ \ (\email)}}
\def\nsfatnebraska{ \def\thefootnote{\fnsymbol{footnote}}
     \par\noindent David B. Jaffe\protect\footnote{Partially supported by 
                    NSF grants DMS-9100983, DMS-9623205, and
                    DMS-9801581.}
     \makeaddress\def\thefootnote{\arabic{footnote}}\setcounter{footnote}{0}}
\nsfatnebraska
\begin{center}
\fbox{%
\begin{minipage}{6in}
For $n \leq 30$, we determine when an $[n,k,d]$ (binary linear) code exists,
and we classify optimal $[n,k,d]$ codes, where by {\it optimal\/} we mean
that no $[n-1,k,d]$, $[n+1,k+1,d]$, or $[n+1,k,d+1]$ code exists.  Subsumed
therein are the following nontrivial new results: there are exactly six
$[24,7,10]$ codes (discovered independently by Kapralov
[.kapralov fifth enumeration.], exactly eleven $[28,10,10]$ codes, no
$[29,11,10]$ code, exactly one $[28,14,8]$ code, and no $[29,15,8]$ code.
We also show that there are exactly two $[32,11,12]$ codes.  All
the results, new and old, are presented as a proof in the author's computer
language {\tt Split}, whose execution takes about $11$ hours on a 1996-era
desktop computer, exclusive of a single line in the $[28,10,10]$
classification, which takes $115$ hours.
\end{minipage}%
}
\end{center}

\catcode`\@=11
\def\tableofcontents{\@starttoc{toc}}
\catcode`\@=12

{\footnotesize\tableofcontents}

\newpage

\addcontentsline{toc}{part}{I\kern12pt Introduction}
\par\noindent{\LARGE\bf Part I: Introduction}

\block{Synopsis}

In this paragraph we recall briefly a few basic definitions.%
\footnote{See [.macwilliams sloane book.] for more information.  Another
good reference is [.lint coding theory.].}
A {\it binary linear code\/} (hereafter called just {\it code}) is a 
nonzero subspace 
of the vector space $\F_2^n$ (for some $n$, which is called the {\it length\/} 
of the code.  Its elements are called {\it codewords}.  Two codes are declared 
{\it isomorphic\/} if they have the same length and some permutation of 
coordinates moves one to the other.  The distance between two codewords is the 
number of coordinate positions in which they differ.  The 
{\it minimum distance\/} of a code is the smallest number which appears as
the distance between two distinct codewords in the code.  An $[n,k,d]$ code is 
defined here to be a code having length $n$, dimension $k$, and minimum 
distance {\it at least\/} $d$.

An $[n,k,d]$ code is {\it distance-optimal\/} if no $[n,k,d+1]$ code exists.
We prefer to use the stronger notion of optimality (defined in the 
abstract), because if one knows all the optimal codes (as thusly defined), one 
can answer the question of which parameters $[n,k,d]$ are realized by codes.

We set the goal of finding and understanding the optimal codes.  In this paper
we find the optimal codes of length $\leq 30$, and to a limited extent arrive
at an understanding of them.  To do this, we 
utilize the author's language {\tt Split}, which can be obtained over the
World Wide Web at ``\verb|http://www.math.unl.edu/~djaffe/#coding|''.%
\footnote{See in particular [.jaffe split guide.] and 
[.brief tour split main.].}
Indeed the body of this paper is a formal program in the {\tt Split} language, 
which can be verified by execution.

This paper builds on the work of numerous people, who have exhibited codes
with particular parameters, or proved that they do not exist.  Explicit
credits are given in the body of the paper.  We defer to [.jaffe split guide.]
and [.brouwer verhoeff 1993.] for further references.

To classify optimal codes of length $\leq 30$, one has to classify various
nonoptimal codes.  Thus for example, to classify $[28,10,10]$ codes (which are
optimal), we classify $[23,6,10]$ codes, which are distance-optimal, but not 
optimal (because there exist $[24,7,10]$ codes).  Moreover, the formal program 
of this paper is a prelude to the classification of many longer codes (in 
[.jaffe split guide.]), and thus certain classifications of nonoptimal codes 
are given here because they aid in the latter classification.  For example,
the twenty-nine $[23,6,10]$ codes give rise to $29$ optimal
$[87,7,42]$ codes.

The following table summarizes the classification of optimal codes of
length $\leq 30$.  For the codes of dimensions $2$ and $3$, proofs are not
provided in this paper.

\newpage

\def\sharp{\kern5pt\verb|\#|\kern5pt}

\renewcommand{\arraystretch}{1.2}
\begin{center}
{\bf Optimal \mbox{\boldmath$[n,k]$} binary linear codes with 
\mbox{\boldmath$n \leq 30$}}
\end{center}
\begin{center}
\begin{tabular}{|c|c|l|}\hline
\mbox{\boldmath$[n,k,d]$}     &  {\bf \# of codes} & 
     {\bf structure}\\ \hline\hline
$[3r,2,2r]$ & 
     \hbox{\vbox{\kern3pt\hbox{$\displaystyle{\hbox{1 each} \atop
     \hbox{\vbox{\hbox{\raise7pt\hbox{$\scriptstyle
     (3 \leq r \leq 10)
     $}}}}}$}}}
     & $\verb|AntiCode( 2, { }|^r\verb| )|$\\ \hline
$[7r,3,4r]$ &
     \hbox{\vbox{\kern3pt\hbox{$\displaystyle{\hbox{1 each} \atop
     \hbox{\vbox{\hbox{\raise7pt\hbox{$\scriptstyle
     (3 \leq r \leq 4)
     $}}}}}$}}}
     & $\verb|AntiCode( 3, { }|^r\verb| )|$\\ \hline
$[7r+4,3,4r+2]$ &
     \hbox{\vbox{\kern3pt\hbox{$\displaystyle{\hbox{1 each} \atop
     \hbox{\vbox{\hbox{\raise7pt\hbox{$\scriptstyle
     (2 \leq r \leq 3)
     $}}}}}$}}}
     & $\verb|AntiCode( 3, { }|^r\verb|, {{1,2}} )|$\\ \hline
$[8,4,4]$     &  1  & first-order Reed-Muller code\\ \hline
$[12,4,6]$    &  1  & \verb|AntiCode( 4, {{1,2}} )|\\ \hline
$[16,5,8]$    &  1  & first-order Reed-Muller code\\ \hline
$[16,11,4]$   &  1  & dual to first-order Reed-Muller code\\ \hline
$[18,9,6]$    &  1  & extended quadratic residue code\\ \hline
$[21,5,10]$   &  2  & one is \verb|AntiCode( 5, {{1,2,3},{4,5}} )|\\ \hline
$[24,5,12]$   &  1  & \verb|AntiCode( 5, {{1,2,3}} )|\\ \hline
$[24,7,10]$   &  6  &one has a simple graph-theoretic description\\ \hline
$[24,12,8]$   &  1  & the Golay code (extended quadratic residue code)\\ \hline
$[24,14,6]$   &  1  &\\ \hline
$[27,7,12]$   &  1  &\\ \hline
$[28,5,14]$   &  1  &\verb|AntiCode( 5, {{1,2}} )|\\ \hline
$[28,10,10]$  &  11 &\\ \hline
$[28,14,8]$   &  1  &\\ \hline
\end{tabular}
\end{center}

We explain the \verb|AntiCode| notation used in the structure column of the
table.  If $T_i \IN {\cal P}(\setof{1,\ldots,k})$ for $i = 1,\ldots,r$, then
$\verb|AntiCode(|k,\vec T1r\verb|)|$ represents the
horizontal concatenation of certain matrices, one for each $i$.  For a
given $i$, first form the matrix which has all nonzero columns of length
$k$, with entries in $\F_2$.  Then for each $T_{ij}$ in $T_i$, delete
those columns which lie in $\SPAN\setof{e_\ell : \ell \in T_{ij}}$.
If a superscript is attached to one
of the $T_i$'s, we mean that it is to be repeated that number of times.  The
codes having generator matrices of this type are modelled after the codes of
Solomon and Stiffler [.solomon stiffler.].

\block{Explanation of some examples}

It is not possible to completely understand what is done in this paper without 
looking at [.jaffe split guide.].  However, the purpose of this section is to 
make it possible to glean a reasonable amount of information from this paper 
without accessing another source.  We do this by explaining some examples
from the body of the paper.  A better (although still incomplete) 
understanding may be obtained by also reading [.brief tour split main.].

The source code for {\tt Split}, the program file (inputted to {\tt Split})
for this paper, and a program file for longer codes (still under development)
are available from the author's web page.  In addition, the page points to an 
online database, which gives information (such as generator 
matrices) for all the codes described in this paper.  See also
[.brouwer verhoeff 1993.] for extensive tables of bounds on codes.

\midhead{Example 1 (from \S\ref{26_6_12-section})}

\begin{svb}
[27_7_12] type [27,7,12];
EX_WECAT(![[a] := Cyclic(1, 27, 7, 100101101100011110011)]!, 1 + 82t^12 + 39t^16 + 6t^20)
...
[26_6_12] type [26,6,12];
[a1..2] := [27_7_12.a] ~ column;
EX_CLASSIFICATION_OF([base], x_12|x66|x2244, ![[a1..2]]!)
status: classified, weights = {12,16,20},
     constraints = {45 <= y12 <= 46, 15 <= y16 <= 17, 1 <= y20 <= 2};
\end{svb}

\vspace{0.1in}

The first line of this declares that $[27,7,12]$ codes are under consideration, 
and that the label \verb|[27_7_12]| is assigned to the work that follows.  

The second line defines a code (labelled \verb|[a]|) and asks the program to 
verify that it has the given weight enumerator.  We note the following:
\begin{itemize}
\item Although the input file to {\tt Split} is a plain text (ascii) file,
      this document has been prettified somewhat, so you see (e.g.) 
      ``$82t^{12}$'' instead of ``\verb|82t^12|''.
\item Future references to the code are given by \verb|[27_7_12.a]|.
\item \verb|100101101100011110011000000| and its six successive cyclic right 
      shifts define a generator matrix for code \verb|[a]|, which is not in
      fact a cyclic code.
\end{itemize}

Skipping over the omitted lines (\verb|...|) and the following 
{\tt type} command, we come to a command which defines codes
\verb|[26_6_12.a1]| and \verb|[26_6_12.a2]|.  The command specifies that
these are obtained from the generator matrix of \verb|[27_7_12.a]| by 
deleting a single column (\verb|~ column|).  Up to isomorphism, one obtains
two codes in this way.

The next line (``\verb|classification of|'') classifies the codes of type 
$[26,6,12]$.  It does so by first showing that such codes have a word 
(say $u$) of weight $12$.  Then it shows that in addition such a code must 
have a word (say $v$) of weight $12$ which meets $u$ along $6$ bits.  Next
it shows that such a code must have a word (say $w$) of weight $12$, as in the 
following picture:

\widepost{100}{65}{
{{(u) BigCenterPrint} 25 6 xyput} -160 4 xyput
{{(v) BigCenterPrint} 25 6 xyput} -160 -30 xyput
{{(w) BigCenterPrint} 25 6 xyput} -160 -64 xyput
{{50 26 Box {(2) BigCenterPrint} 25 6 xyput} -150 4 xyput
{50 26 Box {(4) BigCenterPrint} 25 6 xyput} -100 4 xyput
{50 26 Box {(2) BigCenterPrint} 25 6 xyput} -50 4 xyput
{50 26 Box {(4) BigCenterPrint} 25 6 xyput} 0 4 xyput
{50 26 Box {(2) BigCenterPrint} 25 6 xyput} -150 -30 xyput
{50 26 Box {(4) BigCenterPrint} 25 6 xyput} -100 -30 xyput
{50 26 Box {(4) BigCenterPrint} 25 6 xyput} 50 -30 xyput
{50 26 Box {(2) BigCenterPrint} 25 6 xyput} 100 -30 xyput
{50 26 Box {(2) BigCenterPrint} 25 6 xyput} -150 -64 xyput
{50 26 Box {(2) BigCenterPrint} 25 6 xyput} -50 -64 xyput
{50 26 Box {(4) BigCenterPrint} 25 6 xyput} 50 -64 xyput
{50 26 Box {(4) BigCenterPrint} 25 6 xyput} 150 -64 xyput} 50 xput}

\par\noindent
All these steps are accomplished by split linear programming -- linear
programming applied to some split weight enumerator for the codes under
investigation.  After this, an explicit search (starting from the 
three-dimensional code $\inn{u,v,w}$) shows that any $[26,6,12]$ code is
isomorphic to \verb|[a1]| or \verb|[a2]|.

We have frequently given a proof like this because it is so brief.  As a
rule, when we have found a short proof that executes quickly, we use it,
even if we have also found a longer (but in some sense more direct) proof.

The last (two line) command (``\verb|status|'') merely summarizes some
information (in this case) already known to the program.  Its main purpose
is to facilitate the rapid scanning of large program files by {\tt Split}.

\midhead{Example 2 (from \S\ref{table27-section})}

\vspace{-0.1in}

\begin{svb}
psheadx(80)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
EX_psnext
n=27, k >= 2: 18, 15, 14, 13, 12, 12, 10, 10,  9,  8,  8,  8,  7,  6,  6,  5,  4,  4,  4; EX_sn
n=28, k >= 2: 18, 16, 14, 14, 12EX_coderef(baumert mceliece), 12, 11EX_coderef(dodunekov manev 1985), 10, 10,  EX_newd()8,  8,  8,  8,  EX_newd()6,  6,  6,  5,  4,  4; EX_sn
n=29, k >= 2: 19, 16, 15, 14, 13, 12, 12, 11, 10,  EX_newd()9,  EX_newd()8,  8,  8,  EX_newd()7,  EX_newd()6,  6,  6,  5,  4; EX_sn
n=30, k >= 2: 20, 16, 16, 15, 14, 12, 12, 12, 11, 10,  EX_newd()9,  8,  8,  8,  EX_newd()7,  EX_newd()6,  6,  6,  5;
pstail

The first line is a comment.  Each of the following lines (starting with
``\verb|n=|'') are commands.  For example, the {\tt n=27} line instructs
the program to (try to) show that there exists a $[27,2,18]$ code, but
no $[27,2,19]$ code, that there exists a $[27,3,15]$ code, but no
$[27,3,16]$ code, and so forth.  There are some annotations, present
in this document, but not in the file which is fed to {\tt Split}: the 
numbers in brackets as superscripts give credit for
upper bounds, and the diamond subscripts point to new upper bounds.  (This
paper contains no new lower bounds.)  {\tt Split}
proves the upper bounds by successive applications of split linear programming,
and by using whatever facts have been accumulated prior to the execution of
the {\tt n=27} line.

\midhead{Example 3 (from \S\ref{18_9_6-section})}
\begin{svb}
[18_9_6] type [18,9,6];
[a] := Paley(17) # {1} + check;
...
at type [18_9_6];
EX_CLASSIFICATION_OF([base], [17_8_6->a], [a])
EX_STATUS_UNIQUE_WE( 1 + 102t^6 + 153t^8 + 153t^10 + 102t^12 + t^18 )
\end{svb}

\vspace{0.1in}

This example is much like example 1, but there is one key difference.
Instead of building a subcode by successive applications of split
linear programming, we directly incorporate a subcode, namely the unique
$[17,8,6]$ code.

\midhead{Example 4 (from \S\ref{29_8-section})}
\begin{svb}
[29_8_12] type [29,8,12];
kill y29, y28 by x_11_1, y26 by (x_11_3,x_12_2,x_13_1,x_13_3,x_12_0);
show (joint:0) y13 = 0, y17 = 0, y21 = 0;
EX_CYCLIC_WE([a], 29, 8, 1000010011100110110111, 1 + 113t^12 + 122t^16 + 19t^20 + t^24)
EX_CYCLIC_WE([b], 29, 8, 1001001101110111000011, 1 + 114t^12 + 119t^16 + 22t^20)
EX_WECAT2(![[c] := Cyclic( {12,6,6,3}, 29, 8, 00111111000000010100110101,]!,
     ![00011110100100100101111100111)]!, 1 + 118t^12 + 111t^16 + 26t^20)
EX_CLASSIFICATION_OF([base], ![[25_5_12->{a1..6,b,c}]]!, ![[a!], [b!], [c!]]!)
\end{svb}

\vspace{0.1in}

In this example it is shown that exactly three weight enumerators occur
amongst the $[29,8,12]$ codes.  First the ``{\tt kill}'' and ``{\tt show}''
commands are used to eliminate many weights.  For example, the fact that no 
word of weight $28$ occurs is accomplished by the ``\verb|y28 by x_11_1|'' part
of the ``{\tt kill}'' command, which proceeds by considering the split linear
programming problem associated to a two-dimensional code having a word of
weight $28$ and a word of weight $12$, meeting along $11$ bits.  Linear 
programming based on the joint weight enumerator is used to show that there
are no words of weights $13$, $17$, or $21$.

The three {\tt cyclic} commands define codes labelled {\tt [a]}, {\tt [b]},
and {\tt [c]}.  These commands also create ``configurations'' (labelled
{\tt [a!]}, {\tt [b!]}, and {\tt [c!]}), which represent all $[29,8,12]$ codes
having the weight enumerators $1 + 113t^{12} + 122t^{16} + 19t^{20} + t^{24}$,
$1 + 114t^{12} + 119t^{16} + 22t^{20}$, and 
$1 + 118t^{12} + 111t^{16} + 26t^{20}$, 
respectively.  The ``{\tt classification}'' command then proceeds roughly
as in example 3, but verifies only that all $[29,8,12]$ codes have one of 
these three weight enumerators.  One could in a similar way enumerate 
{\it all\/} $[29,8,12]$ codes (up to isomorphism), but there are over $70$ of
them.

\block{What is to be done}

First, we would like to find new methods for classifying codes with given
parameters.  At the very least, one would like to be able to carry out
certain calculations (such as the $[28,10,10]$ calculation) faster.  But
one can also hope that there exist completely different (search-free)
methods for deducing certain facts.  For example, can one give search-free
proofs of the nonexistence of $[29,11,10]$ codes, or of the fact that 
$[29,8,12]$ codes are all doubly even?

Second, we would like to explain those codes that do exist, by giving nice
constructions for them.  A case in point are the eleven $[28,10,10]$ codes, 
which (with two exceptions) we have been able to describe only by giving
generator matrices.  Similarly, for the unique $[24,14,6]$ code, we have nothing
to offer at present but a generator matrix.  We would like to find general 
constructions which yield at least some of these codes, and also other optimal 
(but longer) codes.

\vspace{0.25in}
\addcontentsline{toc}{part}{II\kern7pt Results on specific codes}
\par\noindent{\LARGE\bf Part II: Results on specific codes}
\def\wpost#1#2#3{\par\vspace{0.1in}\hbox{\vbox to #1bp{\vss%
    \special{" 0 #2 translate 0.2 setlinewidth #3 }}}\vspace{0.1in}}
\begin{svb}
data_comment(![\section[\boxitTable\ for codes up to length $13$]%
{Table for codes up to length \mbox{\boldmath$13$}}
Each section labelled ``{\bf Table}$\ldots$'' contains a table, surrounded
by miscellaneous (often trivial) results about various codes.  Some of these
are special cases of more general results about codes at the 
Griesmer bound, due to van Tilborg [.tilborg griesmer 1980.].
]!)

[6_3_3] type [6,3,3];
[a] config from x_3|x12|x0111;
classification of [base]: [a];
STATUS_UNIQUE_WE( 1 + 4t^3 + 3t^4 )

[8_4_4] type [8,4,4];
[a] := ReedMuller(1,3);
CLASSIFICATION_OF([base], x8|x4|x22, [a])
STATUS_UNIQUE_WE( 1 + 14t^4 + t^8 )

[12_4_6] type [12,4,6];
[a] := AntiCode( 4, {{1,2}} );
CLASSIFICATION_OF([base], x6|x24|x0222, [a])
STATUS_UNIQUE_WE( 1 + 12t^6 + 3t^8 )

[14_4_7] type [14,4,7];
[a] := P( [6_3_3.a] );
classification of [base]: [a];
STATUS_UNIQUE_WE( 1 + 8t^7 + 7t^8 )

type [10,5,4];   status: weights = {4,5,6,8,10};

[11_6_4] type [11,6,4];
CYCLIC_WE([a], 11, 6, 100111, 1 + 25t^4 + 27t^6 + 10t^8 + t^10)
CYCLIC_WE([b], 11, 6, 101101, 1 + 26t^4 + 24t^6 + 13t^8)
CLASSIFICATION_OF([base], x4|x04|x220, ![[a], [b]]!)
status: classified, weights = 4_2;

[12_7_4] type [12,7,4];
[a1..2] := PertTwo( Dual( Even(3) # Even(4) ) );
CLASSIFICATION_OF([base], x_4|x04|x022, ![[a1..2]]!)
status: classified, weights = 4_2;

psheadx(150)
// k =         2   3   4   5   6   7   8   9  10  11  12
psnext
n=3, k >= 2:   2; sn
n=4, k >= 2:   2,  2; sn
n=5, k >= 2:   3,  2,  2; sn
n=6, k >= 2:   4,  3,  2,  2; sn
n=7, k >= 2:   4,  4,  3,  2,  2; sn
n=8, k >= 2:   5,  4,  4,  2,  2,  2; sn
n=9, k >= 2:   6,  4,  4,  3,  2,  2,  2; sn
n=10, k >= 2:  6,  5,  4,  4,  3,  2,  2,  2; sn
n=11, k >= 2:  7,  6,  5,  4,  4,  3,  2,  2,  2; sn
n=12, k >= 2:  8,  6,  6,  4coderef(fontaine peterson),  4,  4,  3,  2,  2,  2; sn
n=13, k >= 2:  8,  7,  6,  5,  4,  4,  4,  3,  2,  2,  2;
pstailx
type [14,9,4_2]; status: weights = 4_2 - {14};

[16_5_8] type [16,5,8];
[a] := ReedMuller(1,4);
CLASSIFICATION_OF([base], x_16|x8|x44, [a])
STATUS_UNIQUE_WE(1 + 30t^8 + t^16)

[15_5_7] type [15,5,7];
[a] := [16_5_8.a] - column;
CLASSIFICATION_OF([base], x_15|x_7|x34|x1222, [a])
STATUS_UNIQUE_WE( 1 + 15t^7 + 15t^8 + t^15 )

[16_11_4] type [16,11,4];
[a] := Dual( [16_5_8.a] );
CLASSIFICATION_OF([base], x_16|x4|x04|x004|x0022|x220000|x11111111, [a])
STATUS_UNIQUE_WE(1 + 140t^4 + 448t^6 + 870t^8 + 448t^10 + 140t^12 + t^16)
data_comment( ![ PBLOCK( ![Classification of [14,5,6], [15,6,6], [16,7,6], 
    [17,8,6], and [18,9,6] codes]! )\label{18_9_6-section} ]! )

[18_9_6] type [18,9,6];
CREDIT(uniqueness due to Simonis, simonis 1896 unique)
[a] := Paley(17) # {1} + check;

[14_5_6] type [14,5,6];
[a1..5] := PertTwo( [18_9_6.a] ~ column ~ column ~ column ~ column );
CYCLIC_WE([b], 14, 5, 1001111011, 1 + 7t^6 + 16t^7 + 7t^8 + t^14)
CLASSIFICATION_OF([base], x_6|x24, ![[a1..5], [b]]!)
status: classified, weights = {6,7,8,10,12,14};

[15_6_6] type [15,6,6];
[a1..5] := PertTwo( [18_9_6.a] ~ column ~ column ~ column );
CLASSIFICATION_OF([base], x_10|x51|x2211, ![[a1..5]]!)
status: classified, weights = 6_2;

[16_7_6] type [16,7,6];
CREDIT(classification due to Kostova and Manev, kostova manev)
NOTE(![These codes have also been classified by 
     Simonis [.simonis 1676 description.], [.simonis semilinear.].]!)
[a1..3] := PertTwo( [18_9_6.a] ~ column ~ column );
CLASSIFICATION_OF([base], [12_4_6->a], ![[a1..3]]!)
status: classified, weights = 6_2, constraints = {44 <= y6 <= 48, 
     30 <= y8 <= 45, 28 <= y10 <= 48, y12 <= 10};

DHIDE( ![ DC1#, D2#, D3#(6.1% of orbit 1) done for ]! )
[17_8_6] type [17,8,6];
CREDIT(uniqueness due to Simonis, simonis 1896 unique)
[a] := [18_9_6.a] ~ column;
CLASSIFICATION_OF([base], x6|x06|x033|x20112|x02001111, [a])
STATUS_UNIQUE_WE(1 + 68t^6 + 85t^8 + 68t^10 + 34t^12)

at type [18_9_6];
CLASSIFICATION_OF([base], [17_8_6->a], [a])
STATUS_UNIQUE_WE( 1 + 102t^6 + 153t^8 + 153t^10 + 102t^12 + t^18 )
data_comment( ![ PBLOCK( ![Classification of [20,4,10] and [21,5,10] codes]! )
    ]! )

[21_5_10] type [21,5,10];
CREDIT(classification due to van Tilborg, tilborg griesmer 1980)
WECAT([a] := AntiCode( 5, {{1,2,3},{4,5}} ), 1 + 21t^10 + 7t^12 + 3t^14)
CYCLIC_WE([b], 21, 5, 10010110100011111, 1 + 20t^10 + 10t^12 + t^16)
CLASSIFICATION_OF([base], ![x_10|x55|x2233]!, ![[a], [b]]!)
status: classified, weights = {10,12,14,16},
     constraints = {20 <= y10 <= 21, 7 <= y12 <= 10, y14 <= 3, y16 <= 1};

[20_4_10] type [20,4,10];
[a1..3] := [21_5_10.{a,b}] ~ column;
CLASSIFICATION_OF([base], x_10|x46, ![[a1..3]]!)
status: classified, weights = {10,12,14,16};
data_comment( ![ PBLOCK( ![Classification of [17,5,8], [18,6,8], $\ldots$,
[23,11,8], and [24,12,8] codes]! ) ]! )

[17_5_8] type [17,5,8];
[a1..2] := PertTwo( [16_5_8.a] | {0} );
CYCLIC_WE([c], 17, 5, 1000101111011, 1 + 25t^8 + 6t^12)
WECAT(![[d] := Cyclic( {15}, 17, 5, 00110111000010111 )]!, 1 + 15t^8 + 15t^9 + t^17)
WECAT(![[e] := Cyclic( {8,8}, 17, 5, 01111000011010011 )]!, 1 + 14t^8 + 16t^9 + t^16)
CLASSIFICATION_OF([base], x_8|x44|x2222, ![[a1..2], [c], [d], [e]]!)
status: classified, weights = {8,9,10,12,16,17},
     constraints = {y8 <= 30, y10 <= 8, y12 <= 6};

[18_6_8] type [18,6,8];
CREDITX(![classification due to Dodunekov and Encheva
     [.golay subcodes 1993.] (cf.{\ }[.encheva 1992 report.]) and
     [.golay subcodes 1988.]]!)
WECAT(![[a] := Cyclic( {8,8}, 18, 6, 000110110111110111 )]!, 1 + 46t^8 + 16t^12 + t^16)
CYCLIC_WE([b], 18, 6, 1000110111101, 1 + 45t^8 + 18t^12)
CLASSIFICATION_OF([base], ![[17_5_8->{a1..2,c,d,e}]]!, ![[a], [b]]!)
status: classified, weights = {8,12,16},
     constraints = {45 <= y8 <= 46, 16 <= y12 <= 18};

[19_7_8] type [19,7,8];
CREDITX(![uniqueness due to Dodunekov and Encheva
     [.golay subcodes 1993.] (cf.{\ }[.encheva 1992 report.]) and
     [.golay subcodes 1988.]]!)
[a] := Cyclic(1, 19, 7, 1010010011111);
CLASSIFICATION_OF([base], ![[18_6_8->{a,b}]]!, [a])
STATUS_UNIQUE_WE( 1 + 78t^8 + 48t^12 + t^16 )

[20_8_8] type [20,8,8];
CREDITX(![uniqueness due to Dodunekov and Encheva
     [.golay subcodes 1993.] (cf.{\ }[.encheva 1992 report.]) and
     [.golay subcodes 1988.]]!)
[a] := Cyclic(1, 20, 8, 1010010011111);
CLASSIFICATION_OF([base], [19_7_8->a], [a])
STATUS_UNIQUE_WE( 1 + 130t^8 + 120t^12 + 5t^16 )

[21_9_8] type [21,9,8];
CREDITX(![uniqueness due to Dodunekov and Encheva
     [.golay subcodes 1993.] (cf.{\ }[.encheva 1992 report.]) and
     [.golay subcodes 1988.]]!)
[a] := Cyclic(1, 21, 9, 1010010011111);
CLASSIFICATION_OF([base], [19_7_8->a], [a])
STATUS_UNIQUE_WE( 1 + 210t^8 + 280t^12 + 21t^16 )

[22_10_8] type [22,10,8];
CREDITX(![uniqueness due to Dodunekov and Encheva
     [.golay subcodes 1993.] (cf.{\ }[.encheva 1992 report.]) and
     [.golay subcodes 1988.]]!)
[a] := Cyclic(1, 22, 10, 1010010011111);
CLASSIFICATION_OF([base], [19_7_8->a], [a])
STATUS_UNIQUE_WE( 1 + 330t^8 + 616t^12 + 77t^16 )

[23_11_8] type [23,11,8];
CREDITX(![uniqueness due to Dodunekov and Encheva
     [.golay subcodes 1993.] (cf.{\ }[.encheva 1992 report.]) and
     [.golay subcodes 1988.]]!)
[a] := Cyclic(1, 23, 11, 1010010011111);
CLASSIFICATION_OF([base], [19_7_8->a], [a])
STATUS_UNIQUE_WE( 1 + 506t^8 + 1288t^12 + 253t^16 )

[24_12_8] type [24,12,8];
CREDITX(![existence due to Golay [.golay digital coding.],
uniqueness due to Snover [.snover.]]!)
NOTE(![Delsarte, Goethals, Pless also gave uniqueness proofs.
     See [.macwilliams sloane book.] pp. 646, 649.]!)
[a] := Paley(23) # {1} + check;
CLASSIFICATION_OF([base], [19_7_8->a], [a])
STATUS_UNIQUE_WE( 1 + 759t^8 + 2576t^12 + 759t^16 + t^24 )

data_comment(![\section[\boxitTable\ for codes of length $14$ through $21$]%
{Table for codes of length $14$ through $21$}]!)

type [20,10,6];   status: weights = 6_1 - {19};

psheadx(120)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=14, k >= 2:  9,  8,  7,  6,  5,  4,  4,  4,  3,  2,  2,  2; sn
n=15, k >= 2: 10,  8,  8,  7,  6,  5,  4,  4,  4,  3,  2,  2,  2; sn
n=16, k >= 2: 10,  8,  8,  8,  6,  6,  5,  4,  4,  4,  2,  2,  2,  2; sn
n=17, k >= 2: 11,  9,  8,  8,  7,  6,  6,  5,  4,  4,  3,  2,  2,  2,  2; sn
n=18, k >= 2: 12, 10,  8,  8,  8,  7,  6,  6,  4,  4,  4,  3,  2,  2,  2,  2; sn
n=19, k >= 2: 12, 10,  9,  8,  8,  8,  7,  6,  5,  4,  4,  4,  3,  2,  2,  2,  2; sn
n=20, k >= 2: 13, 11, 10,  9,  8,  8,  8,  7,  6,  5,  4,  4,  4,  3,  2,  2,  2,  2; sn
n=21, k >= 2: 14, 12, 10, 10,  8,  8,  8,  8,  7,  6,  5,  4,  4,  4,  3,  2,  2,  2,  2;
pstail
\vspace{0.12in}
\begin{svb}
data_comment( ![ PBLOCK( ![Classification of even [20,7,8], [21,8,8], and 
[22,9,8] codes]! ) ]! )

type [19,6,8];    status: weights = {8,9,10,12,13,14,16,17,18};
type [20,7,8];    status: weights = {8,9,10,12,13,14,16,17,18,20};

[20_7_8] type [20,7,8_2];
[a1..21] := PertTwo( [19_7_8.a] | {0} );
[b] := Cyclic( {12,6}, 20, 7, 01001011111100011011 );
CLASSIFICATION_OF([base], x_8|x26|x0242, ![[a1..21], [b]]!)
status: classified;

[21_8_8] type [21,8,8_2];
[a1..7] := PertTwo( Cyclic( 1, 21, 8, 10111001100011 ) );
CYCLIC_WE([b], 21, 8, 10000101101111, 1 + 102t^8 + 144t^12 + 9t^16)
WECAT(![[c] := Cyclic(1, 21, 8, 011011100001000011000)]!, 1 + 106t^8 + 136t^12 + 13t^16)
CLASSIFICATION_OF([base], ![[20_7_8->{a*,b}]]!, ![[a1..7],[b],[c]]!)
status: classified, weights = {8,10,12,14,16,18}, constraints = 
     {82 <= y8 <= 130, y10 <= 64, 72 <= y12 <= 144, y14 <= 32, 4 <= y16 <= 13};

[22_9_8] type [22,9,8_2];
[a1..5] := PertTwo( Cyclic( 1, 22, 9, 10001001111101 ) );
CYCLIC_WE([b], 22, 9, 10000101101111, 1 + 162t^8 + 312t^12 + 37t^16)
RCYCLIC_WE([c], 2, 22, 9, 100011100001110001, 1 + 170t^8 + 296t^12 + 45t^16)
CLASSIFICATION_OF([base], ![[21_8_8->{a1..7,b,c}]]!, ![[a1..5,b,c]]!)
status: classified, weights = 8_2 - {20,22}, constraints = {142 <= y8 <= 210};
data_comment( ![ PBLOCK( ![Classification of [23,6,10], [24,7,10], and 
[25,8,10] codes]! ) ]! )

DHIDE( ![ DE1.7#, O(26).7# done for [24_7_10.*] ]! )
[24_7_10] type [24,7,10];
CREDIT(existence due to Hashim and Pozdniakov, hashim pozdniakov)
CREDITX( ![classification due to (independently) Jaffe 
[.jaffe optimal binary 30.] and Kapralov [.kapralov fifth enumeration.]]! )
WECAT2(![[a] := Cyclic( {6,3,6,6,2}, 24, 7, 1110011001000000111111, ]!,
     ![ 001100001010100010100111 )]!, 
     1 + 50t^10 + 40t^12 + 21t^14 + 15t^16 + t^22)
[b1..3] := PertTwo( Un( Off( Col(1,2) | Col(3,4) | Col(5,6) | Col(7,8) ) ) );
WECAT2B(![[e] := {111111111111111111000000,000000111111111111111111,
     111110111111110000111110,110000111100000000111001,001000110011001000111100,
     100000001110100100110110,000100101001001010100111}]!,
     1 + 51t^10 + 40t^12 + 18t^14 + 15t^16 + 3t^18)
WECAT2(![[f] := Cyclic( {6,6,3,6,2}, 24, 7, 0001010101100100011011, ]!,
     ![011000011010011011010011 )]!,
     1 + 51t^10 + 40t^12 + 18t^14 + 15t^16 + 3t^18)

[23_6_10] type [23,6,10];
[a1..29] := PertTwo( [24_7_10.b1] ~ column ) :: {!};
CLASSIFICATION_OF([base], x_10|x_4_6, ![[a1..29]]!)
status: classified, weights = {10,12,14,16,18,20,22};

at type [24_7_10];
CLASSIFICATION_OF([base], ![[23_6_10->a1..29]]!, ![[a], [b1..3], [e], [f]]!)
status: classified, weights = {10,12,14,16,18,22}, 
     constraints = {48 <= y10 <= 54, 28 <= y12 <= 44, 18 <= y14 <= 36, 
     3 <= y16 <= 15, y18 <= 8};

type [25,8,10_2];
CREDITX(![nonexistence due to Ytrehus, Helleseth [.ytrehus helleseth 1990.], 
and Kostova and Manev [.kostova manev.]]!)
CLASSIFICATION_OF([base], ![[21_5_10->{a,b}]]!, )
no [25,8,10];
data_comment( ![ PBLOCK( ![There is a unique [24,14,6] code, but no [25,15,6] 
code]! ) ]! )

[24_14_6] type [24,14,6];
CREDITX(![existence due to Wagner [.wagner group codes.],
uniqueness due to Simonis [.simonis wagner unique.]]!)

kill y9,y11,y13,y15,y17,y19,y21,y23;

[mu6] config 24 ::: {mu6 != 0};
CLASSIFICATION_OF([mu6], [18_9_6->a], )
@[base] infer mu6 = 0;

[mu7] config 24 ::: {mu7 != 0};
CLASSIFICATION_OF([mu7], [17_8_6->a], )
@[base] infer mu7 = 0;

[a] := {101010101010000000000000,100110011001000000000000,
        111111000000000000000000,001100011000110000000000,
        110010100000101000000000,100100101000100100000000,
        110000111100000000000000,000000111000100011000000,
        001010011000000010100000,001110101000100010010000,
        010010001000100010001000,010100110000000010000100,
        011100000000100010000010,111000010000000010000001};

CLASSIFICATION_OF([base], ![[16_7_6->a1..3]]!, [a])
STATUS_UNIQUE_WE(1 + 336t^6 + 1335t^8 + 3888t^10 + 5264t^12 + 3888t^14 +
     1335t^16 + 336t^18 + t^24)

type [25,15,6];
CREDITX(![nonexistence due to Simonis [.simonis 1987 25_15_6.]]!)
CLASSIFICATION_OF([base], [24_14_6->a], )
no [25,15,6];
data_comment( ![ PBLOCK( ![Classification of [25,5,12], [26,6,12], and 
[27,7,12] codes]! )\label{26_6_12-section} ]! )

[27_7_12] type [27,7,12];
CREDIT(uniqueness due to Brouwer, brouwer 27 7 12 preprint)
WECAT(![[a] := Cyclic(1, 27, 7, 100101101100011110011)]!, 1 + 82t^12 + 39t^16 + 6t^20)
CLASSIFICATION_OF([base], x_20|x66|x1551|x0226200|x01111331100, [a])
STATUS_UNIQUE_WE(1 + 82t^12 + 39t^16 + 6t^20)

[26_6_12] type [26,6,12];
[a1..2] := [27_7_12.a] ~ column;
CLASSIFICATION_OF([base], x_12|x66|x2244, ![[a1..2]]!)
status: classified, weights = {12,16,20},
     constraints = {45 <= y12 <= 46, 15 <= y16 <= 17, 1 <= y20 <= 2};

[25_5_12] type [25,5,12];
[a1..6] := PertTwo( [27_7_12.a] ~ column ~ column );
CYCLIC_WE([b], 25, 5, 100011001010110111111, 1 + 14t^12 + 14t^13 + t^16 + 2t^17)
CYCLIC_WE([c], 25, 5, 100011101001011011111, 1 + 12t^12 + 16t^13 + 3t^16)
CLASSIFICATION_OF([base], x_12|x66|x2244, ![[a1..6], [b], [c]]!)
status: classified, weights = {12,13,14,16,17,18,20};
data_comment( ![ PBLOCK( ![There are exactly eleven [28,10,10] codes, but no 
[29,11,10] code]! ) ]! )

[26_8_10] type [26,8,10_2];
[26] config 26 ::: {y26 >= 1};
show (joint:5) mu2 = 0;
show y10 = 67, y12 = 60, y14 = 60, y16 = 67, mu4 != 0;
=[mu4] config 22,4 :: {01} : {y26 >= 1};
{    [22_5_10_16max] type [22,5,{10,12,14,16}];
     classification of [base]: x_10|x46 --> [x#];
     at type [26_8_10];
     [22_5_10_16max] incorporate [22_5_10_16max] below [mu4] via sub10;
     via extension [22_5_10_16max->x*] implies     };
classification of [26]: ;
@[base] infer y26 = 0;
status: weights = 10_2 - {26};
type [26,8,10]; status: weights = 10_1 - {25,26};

type [27,9,10]; status: weights = 10_1 - {25..27};

[28_10_10] type [28,10,10];
CREDIT(existence due to Piret, piret 1980)

WECAT2B(![[a] := {1010010100010111101000000000,0011100111010100100100000000,
    0111001110110001000010000000,0110101101001110000001000000,
    0111110000111100000000100000,1000001111111100000000010000,
    1111111111111111110000000000,0010101001110011000000001100,
    1001111100011000000000001010,1100111010010111000000001001}]!,
    1 + 140t^10 + 287t^12 + 168t^14 + 287t^16 + 140t^18 + t^28)
WECAT2B(![[b] := {1010010100010111101000000000,0011100111010100100100000000,
    0111001110110001000010000000,0110101101001110000001000000,
    0111110000111100000000100000,1000001111111100000000010000,
    1111111111111111110000000000,0000110100111001100000001100,
    1001001000011101100000001010,1110010011011000000000001001}]!,
    1 + 148t^10 + 255t^12 + 216t^14 + 255t^16 + 148t^18 + t^28)
WECAT2B(![[c] := {0010101010101110101000000000,1001010110000111100100000000,
    0111101100010101000010000000,1110011100001110000001000000,
    1101100011001110000000100000,0000011111111100000000010000,
    1111111111111111110000000000,0001011011001011000000001100,
    0110000001101111000000001010,1100110001110011100000001001}]!,
    1 + 152t^10 + 235t^12 + 239t^14 + 273t^16 + 102t^18 + 19t^20 + 3t^22)
WECAT2B(![[d1] := {0111110000011000111000000000,1111111111000000000000000000,
     0100001100010110110110000000,0101011010001100010101000000,
     0110100110111010100100100000,1111000000111111000000000000,
     0001101110110000010000011000,1011010110111100110000010100,
     1101101000011000000100010010,1110111010110110100000010001}]!,
     1 + 153t^10 + 227t^12 + 260t^14 + 249t^16 + 113t^18 + 19t^20 + 2t^22)
WECAT2B(![[d2] := {0111110000011000111000000000,1111111111000000000000000000,
     0100001100010110110110000000,0101011010001100010101000000,
     0110100110111010100100100000,1111000000111111000000000000,
     0001001010101110100000011000,0010010100111110010100010100,
     1001110000101100000100010010,1110010010001010010000010001}]!,
     1 + 153t^10 + 227t^12 + 260t^14 + 249t^16 + 113t^18 + 19t^20 + 2t^22)
WECAT2B(![[e1] := {0111110000011000111000000000,1111111111000000000000000000,
     0100001100010110110110000000,0101011010001100010101000000,
     0110100110111010100100100000,1111000000111111000000000000,
     0001111000110000010100011000,0110111110100100110100010100,
     1100110110101010010000010010,1111100100000010110100010001}]!,
     1 + 153t^10 + 228t^12 + 255t^14 + 259t^16 + 103t^18 + 24t^20 + t^22)
WECAT2B(![[e2] := {0111110000011000111000000000,1111111111000000000000000000,
     0100001100010110110110000000,0101011010001100010101000000,
     0110100110111010100100100000,1111000000111111000000000000,
     0000000010111110010100011000,1000011100101010010000010100,
     1101110110110100110000010010,1110011110001110100100010001}]!,
     1 + 153t^10 + 228t^12 + 255t^14 + 259t^16 + 103t^18 + 24t^20 + t^22)
WECAT2B(![[e3] := {0111110000011000111000000000,1111111111000000000000000000,
     0100001100010110110110000000,0101011010001100010101000000,
     0110100110111010100100100000,1111000000111111000000000000,
     0001101100001100110000011000,0101010100100110100000010100,
     1000010010110100100100010010,1001110010001010010000010001}]!,
     1 + 153t^10 + 228t^12 + 255t^14 + 259t^16 + 103t^18 + 24t^20 + t^22)
WECAT2B(![[f] := {0111110000011000111000000000,1111111111000000000000000000,
    0100001100010110110110000000,0101011010001100010101000000,
    0110100110111010100100100000,1111000000111111000000000000,
    0001101000100110010100011000,0100011110100000100100010100,
    1000100100111010010000010010,1011101010001010110000010001}]!,
    1 + 154t^10 + 222t^12 + 270t^14 + 239t^16 + 118t^18 + 18t^20 + 2t^22)
WECAT2B(![[g1] := Cyclic( {9,9,9}, 28, 10, 001100011011001000001000101, 
     0011000001000110010110000011 )]!,
     1 + 155t^10 + 219t^12 + 270t^14 + 249t^16 + 103t^18 + 27t^20)
WECAT2B(![[g2] := Cyclic( {9,9,9}, 28, 10, 0000011110110110010111000011, 
     0000101011000101100100100001 )]!,
     1 + 155t^10 + 219t^12 + 270t^14 + 249t^16 + 103t^18 + 27t^20)

config 28 ::: {div2 <= 512};
kill y28, y24, y22;
via lp (joint:0) [current] = ;
@[base] infer div2 = 1024;

[mu4x] config 28 ::: {mu4 != 0};
CLASSIFICATION_OF([mu4x], ![[24_7_10->{a,b1..3,e,f}]]!, ![[a], [b], [c]]!)

[mu5] config 28 ::: {mu4 = 0};
show (joint:0) mu5 != 0;
show (joint:5) y28 = 0 <precision = 2>;

[24] config 24,4 : {10} :: {mu4 = 0};
{    [24_6_10u] type [24,6,10_2]{y24 = 1};
     classification of [base]: x_24|x_10|x46 --> [x#];
     at type [28_10_10];
     [24_6_10u] incorporate [24_6_10u] below [24] via sub10;
     via extension [24_6_10u->x*] implies ;
     classification of [24]:    };
@[mu5] infer y24 = 0;

=config 23,5 :: {01} : {mu4 = 0};
[23_6_10] incorporate [23_6_10] below [current] via sub10;

via lp [23_6_10->{a4!,a6!,a8!,a11!,a14!,a20!,a22!,a28!}] = ;

data_comment( ![ The following line takes $115$ hours to execute. 
\vspace{0.1in} ]! )
via extension [23_6_10->{a1..3,a5,a7,a9..10,a12..13,a15..19,a21,a23..27,a29}]
     implies [a],[b],[c],[d*],[e*],[f],[g*];

via variable split [base] = [mu4x] or [mu5];
classification of [base]: [a],[b],[c],[d1],[d2],[e1],[e2],[e3],[f],[g1],[g2];

status: classified, weights = {10,12,14,16,18,20,22,28},
     constraints = {140 <= y10 <= 155, 219 <= y12 <= 287, 168 <= y14 <= 270,
     239 <= y16 <= 287, 102 <= y18 <= 148, y20 <= 27, y22 <= 3};

type [29,11,10_2];
CLASSIFICATION_OF([base], ![[28_10_10->{a,b,c,d*,e*,f,g*}]]!, )
no [29,11,10];
data_comment( ![ PBLOCK( ![There is a unique [28,14,8] code, but no [29,15,8] 
code]! )\label{section-29-15-8} ]! )

[28_14_8] type [28,14,8];
CREDIT(existence due to Karlin, karlin circulants)
[a] := Cyclic(2, 28, 14, 011010110000000011111);

at [base];
kill y27, y15, y25, y23, y19, y21 by (x27, x67, x_10_7), y9, y13, y17;
show (joint:0) mu8 != 0;
CLASSIFICATION_OF([base], ![[20_7_8->{a*,b}]!], [a])
STATUS_UNIQUE_WE(1 + 546t^8 + 1456t^10 + 3549t^12 + 5280t^14 + 
     3549t^16 + 1456t^18 + 546t^20 + t^28)

type [29,15,8_2];
CLASSIFICATION_OF([base], ![[28_14_8->a]]!, )
no [29,15,8];
data_comment(![\section[\boxitTable\ for codes of length $22$ through $26$]%
{Table for codes of length $22$ through $26$}]!)

[24_5_12] type [24,5,12];
[a] := AntiCode( 5, {{1,2,3}} );
CLASSIFICATION_OF([base], x_12|x66|x2244, [a])
STATUS_UNIQUE_WE( 1 + 28t^12 + 3t^16 )

[33_22_6] type [33,22,6];
[1] := Cyclic(1, 33, 22, 101001100101);
status: realizable;

psheadx(80)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=22, k >= 2: 14, 12, 11, 10,  9,  8,  8,  8,  8,  7,  6,  5,  4,  4,  4,  3,  2,  2,  2; sn
n=23, k >= 2: 15, 12, 12, 11, 10,  9,  8,  8,  8,  8,  7,  6,  5,  4,  4,  4,  3,  2,  2; sn
n=24, k >= 2: 16, 13, 12, 12, 10, 10,  8,  8,  8,  8,  8,  6,  6,  4,  4,  4,  4,  3,  2; sn
n=25, k >= 2: 16, 14, 12, 12, 11, 10,  9coderef(ytrehus helleseth 1990),  8,  8,  8,  8,  6,  6,  5coderef(simonis 1987 25_15_6),  4,  4,  4,  4,  3; sn
n=26, k >= 2: 17, 14, 13, 12, 12, 11, 10,  9,  8,  8,  8,  7,  6,  6,  5,  4,  4,  4,  4;
pstail

pshead(70)
// k =        21  22  23  24  25
psnext
n=22, k >=21:  2; sn
n=23, k >=21:  2,  2; sn
n=24, k >=21:  2,  2,  2; sn
n=25, k >=21:  2,  2,  2,  2; sn
n=26, k >=21:  3,  2,  2,  2,  2;
pstailx
data_comment( ![ PBLOCK( ![Classification of [30,9,12], [31,10,12], and 
[32,11,12] codes]! )\label{29_8-section} ]! )

data_comment(![ We also consider the $[29,8,12]$ codes, but only include a
classification up to weight enumerator, because of space considerations. ]! )

DHIDE( ![ DC1P#, D3G#, O(29/5,10)# done for [a] ]! )
[32_11_12] type [32,11,12_4];
[a] := BCH(5, 31, 1..7) + check;
[b] := Cyclic(1, 31, 11, 000110100011100101000100001001) + check;

type [28,7,12]; status: weights = 12_1 - {15,19,23,25,27};

[29_8_12] type [29,8,12];
kill y29, y28 by x_11_1, y26 by (x_11_3,x_12_2,x_13_1,x_13_3,x_12_0);
show (joint:0) y13 = 0, y17 = 0, y21 = 0;
CYCLIC_WE([a], 29, 8, 1000010011100110110111, 1 + 113t^12 + 122t^16 + 19t^20 + t^24)
CYCLIC_WE([b], 29, 8, 1001001101110111000011, 1 + 114t^12 + 119t^16 + 22t^20)
WECAT2(![[c] := Cyclic( {12,6,6,3}, 29, 8, 00111111000000010100110101,]!,
     ![00011110100100100101111100111 )]!, 1 + 118t^12 + 111t^16 + 26t^20)
CLASSIFICATION_OF([base], ![[25_5_12->{a1..6,b,c}]]!, ![[a!], [b!], [c!]]!)
status: weights = {12,16,20,24}, constraints = 
     {113 <= y12 <= 118, 111 <= y16 <= 122, 19 <= y20 <= 26};

[30_9_12] type [30,9,12];

[x1] := {100000000000011111110000011110,010000000001110100101000111101,
     001001000101110010011100101000,000101000100011001111011001000,
     000011000001111000111111110011,000000100101010111100110001001,
     000000010100101111101001000101,000000001100011110001100110011,
     000000000011100001110011001111};
[x2] := {100000000000011111110000011110,010000000001110100101000111101,
     001000000100110111010010100101,000100000101011100110101000101,
     000010010000110101000101010111,000001010001001101111010100100,
     000000110001111000001111001100,000000001100011110001100110011,
     000000000011100001110011001111};
[x3] := {100000000000011111110000011110,010000000100100010110110110110,
     001001000001101100001000011111,000101000101010001110001110100,
     000011000001111000111111110011,000000100000101101010101110101,
     000000010001010101011010111001,000000001100011110001100110011,
     000000000011100001110011001111};
[x4] := {100000000000011111110000011110,010000000100100010110110110110,
     001001000001001111101001110000,000101000101110010010000011011,
     000011000001111000111111110011,000000100000101101010101110101,
     000000010001010101011010111001,000000001100011110001100110011,
     000000000011100001110011001111};
[x5] := [32_11_12.a] ~ column ~ column;
[x6] := [32_11_12.b] ~ column ~ column;
[x7] := Cyclic( {9,9,9,3}, 30, 9, 0010111000101000000111110001 );
[x8] := Cyclic( {9,9,9,3}, 30, 9, 00110100000101000001011101101 );
[x9] := {100000001101010101010100011100,010000000101111100011000010011,
     001000001100010100100111100101,000100000000011111110000110101,
     000010000100110010010110111001,000001001100011000011101101010,
     000000101100101111000000111010,000000011101110011111011011010,
     000000000010101011011011101100};

STATUS_WE(1 + 190t^12 + 255t^16 + 66t^20)
CLASSIFICATION_OF([base], ![[26_6_12->a1..2]!], ![[x1..9]]!)
status: classified;

[31_10_12] type [31,10,12];
[a] := [32_11_12.a] ~ column;
[b] := [32_11_12.b] ~ column;
CLASSIFICATION_OF([base], ![[30_9_12->x1..9]]!, ![[a], [b]]!)
STATUS_CLASS_WE(1 + 310t^12 + 527t^16 + 186t^20)

at type [32_11_12];
STATUS_WE(1 + 496t^12 + 1054t^16 + 496t^20 + t^32)
CLASSIFICATION_OF([base], ![[31_10_12->{a,b}]]!, ![[a], [b]]!)
status: classified;
data_comment(![ PBLOCK( ![Classification of [29,5,14] and [30,6,14] codes]! )
    ]! )

[30_6_14] type [30,6,14];
NOTE(![The uniqueness of the even [30,6,14] code was proved in
[.helleseth ytrehus 33_8_14.].  Cf.{\ }[.heijnen.], Ch.\ 5.]!)
status: weights = {14,15,16,30};
[a1] := AntiCode( 6, { {1..5}, {1,6} } );
[a2] := AntiCode( 6, { {1..5}, {1,6}, {2,6} } ) + check;
CLASSIFICATION_OF([base], x_30|x_14|x68|x2444|x02222222, ![[a1..2]]!)
status: classified, weights = {14..16,30}, constraints = {y30 = 1};

[29_5_14] type [29,5,14];
[a1..8] := PertTwo( [30_6_14.a1..2] ~ column );
CYCLIC_WE([b], 29, 5, 1000010011100111101011011, 1 + 22t^14 + 7t^16 + 2t^22)
CLASSIFICATION_OF([base], x_14|x68|x2444, ![[a1..8],[b]]!)
status: classified, weights = {14..18,20,22};
data_comment(![\section[\boxitTable\ for codes of length $27$ through $30$]%
{Table for codes of length $27$ through $30$}\label{table27-section}]!)

[28_5_14] type [28,5,14];
[a] := AntiCode( 5, {{1,2}} );
CLASSIFICATION_OF([base], x_14|x77|x3344, [a])
STATUS_UNIQUE_WE( 1 + 24t^14 + 7t^16 )

[27_4_14] type [27,4,14];
[a] := [28_5_14.a] ~ column;
CLASSIFICATION_OF([base], x_16|x88, [a])
STATUS_UNIQUE_WE( 1 + 12t^14 + 3t^16 )

[31_5_16] type [31,5,16];
[a] := Simp(5);
CLASSIFICATION_OF([base], x_16|x88|x4444, [a])
STATUS_UNIQUE_WE( 1 + 31t^16 )

[31_13_9] type [31,13,9];
credit: existence due to J. B. Shearer;
[a] := {1010101001010010011000000000000,0101010100101001010100000000000,
     1111000001111100000000000000000,0101011000110010000011000000000,
     1100110001100011100000000000000,0110001100101010000000110000000,
     0111001101110000010010101000000,0001101001101001010010100100000,
     1111111110000000000000000000000,1011011100111000010000000011000,
     1001101100001011000010000010100,0111110100110011010000100010010,
     0100100101010010010010100010001};
status: realizable;

[32_17_8] type [32,17,8];
CREDIT(existence due to Cheng and Sloane, cheng sloane)
[a] := {10101010101001010000000000000000,01101010111000010000011010100000,
     00110000000100010000011000000101,00010001000001100000010100110000,
     00001010011001010100010000000110,00000110001000010010010000001100,
     00000011000100010110111110100000,00000000101010101010010100000000,
     00000000010101011010010100000000,00000000001111000101101001100110,
     00000000000101110001010000100001,00000000000011110110011000110011,
     00000000000000001111111100000000,00000000000000000101010101011010,
     00000000000000000011001101100110,00000000000000000000111100001111,
     00000000000000000000000011111111};
status: realizable;
psheadx(80)
// k =         2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
psnext
n=27, k >= 2: 18, 15, 14, 13, 12, 12, 10, 10,  9,  8,  8,  8,  7,  6,  6,  5,  4,  4,  4; sn
n=28, k >= 2: 18, 16, 14, 14, 12coderef(baumert mceliece), 12, 11coderef(dodunekov manev 1985), 10, 10,  newd()8,  8,  8,  8,  newd()6,  6,  6,  5,  4,  4; sn
n=29, k >= 2: 19, 16, 15, 14, 13, 12, 12, 11, 10,  newd()9,  newd()8,  8,  8,  newd()7,  newd()6,  6,  6,  5,  4; sn
n=30, k >= 2: 20, 16, 16, 15, 14, 12, 12, 12, 11, 10,  newd()9,  8,  8,  8,  newd()7,  newd()6,  6,  6,  5;
pstail

pshead(60)
// k =        21  22  23  24  25  26  27  28  29
psnext
n=27, k >=21:  4,  3,  2,  2,  2,  2; sn
n=28, k >=21:  4,  4,  3,  2,  2,  2,  2; sn
n=29, k >=21:  4,  4,  4,  3,  2,  2,  2,  2; sn
n=30, k >=21:  4,  4,  4,  4,  3,  2,  2,  2,  2;
pstailx

|-> tex/code.tex1
\end{svb}

\section*{References}
\addtocontents{toc}{\protect\vspace*{2.25em}}
\addcontentsline{toc}{special}{References}
\ \par\noindent\vspace*{-0.25in}
\hfuzz 8pt
.[]
\end{document}

|-> tex/run_tex1
#
# This is not yet usable by anyone except me.
setkeyx
tr %  < code.tex1 > tempx
tibline
echo \\documentstyle\[amssymb,12pt\]\{invent\} > t.tex
tr  % < t.tex0 | cat -s | sed -f sed.in > t.tex1
# The following awk command corrects for a bug in tib which (at least on my
# machine) causes the first author's name in the bibliography to be replaced
# by an underline.  This command was kindly provided by Alois Steindl.  If your
# installation of tib does not have this bug, you should replace the awk 
# command by "cat t.tex1 >> t.tex".
awk 'BEGIN {found=0} \
    {if ($1 ~ /\\def\\Astr\{\\Underlinemark\}\%/) \
    {if (found) {print} else {found=1}} else {print}}' < t.tex1 >> t.tex
if ($status != 0) goto fail
latex t | tail +8
endif
fail:
/bin/rm -f tempx t.tex0 t.tex1 temp >& /dev/null