Weight Enumerators

CompleteWeightEnumerator(C): Code -> RngMPolElt

Let \(C\) be a code over a finite ring \(R\) of cardinality \(q\), and suppose that the elements of \(R\) are ordered in some way. Then for a codeword \(v \in C\) and the \(i\)-th element \(a \in R\), let \(s_i(v)\) denote the number of components of \(v\) equal to \(a\).

This function returns the complete weight enumerator \({\cal W}_C(X_0, X_1, \ldots, X_{q-1})\) of \(C\), which is defined by:

\[{\cal W}_C(X_0, X_1, \ldots, X_{q-1}) = \sum_{v \in C}{{X_0}^{s_0(v)}{X_1}^{s_1(v)}\cdots{X_{q-1}}^{s_{q-1}(v)}}.\]

See [Wan97, p. 9] for more information. The result will lie in a global multivariate polynomial ring over \({\mathbb{Z}}\) with q variables. The angle-bracket notation may be used to assign names to the indeterminates.

SymmetricWeightEnumerator(C): Code -> RngMPolElt

Suppose \(C\) is a \({\mathbb{Z}}_4\)-code. This function returns the symmetric weight enumerator \(\hbox{swe}_C(X_0, X_1, X_2)\) of \(C\), which is defined by:

\[\hbox{swe}_C(X_0, X_1, X_2) = {\cal W}_C(X_0, X_1, X_2, X_1),\]

where \({\cal W}_C\) is the complete weight enumerator, defined above. See [Wan97, p. 14] for more information. The result will lie in a global multivariate polynomial ring over \({\mathbb{Z}}\) with three variables. The angle-bracket notation may be used to assign names to the indeterminates.

WeightEnumerator(C): Code -> RngMPolElt

HammingWeightEnumerator(C): Code -> RngMPolElt

Suppose \(C\) is a code over some finite ring \(R\). This function returns the Hamming weight enumerator \(\hbox{Ham}_C(X, Y)\) of \(C\), which is defined by:

\[\hbox{Ham}_C(X, Y) = \sum_{v \in C}{X^{n-w_H(v)}Y^{w_H(v)}},\]

where \(w_H(v)\) is the Hamming weight function. The result will lie in a global multivariate polynomial ring over \({\mathbb{Z}}\) with two variables. The angle-bracket notation may be used to assign names to the indeterminates.

LeeWeightEnumerator(C): Code -> RngMPolElt

Suppose \(C\) is a \({\mathbb{Z}}_4\)-code. This function returns the Lee weight enumerator \(\hbox{Lee}_C(X, Y)\) of \(C\), which is defined by:

\[\hbox{Lee}_C(X, Y) = \sum_{v \in C}{X^{2*n-w_L(v)}Y^{w_L(v)}},\]

where \(w_L(v)\) is the Lee weight function, defined in Section Lee Weight. The result will lie in a global multivariate polynomial ring over \({\mathbb{Z}}\) with two variables. The angle-bracket notation may be used to assign names to the indeterminates.

EuclideanWeightEnumerator(C): Code -> RngMPolElt

Suppose \(C\) is a \({\mathbb{Z}}_4\)-code. This function returns the Euclidean weight enumerator \(\hbox{Euclidean}_C(X, Y)\) of \(C\), which is defined by:

\[\hbox{Euclidean}_C(X, Y) = \sum_{v \in C}{X^{4*n-w_E(v)}Y^{w_E(v)}},\]

where \(w_E(v)\) is the Euclidean weight function, defined in Section Euclidean Weight. The result will lie in a global multivariate polynomial ring over \({\mathbb{Z}}\) with two variables. The angle-bracket notation may be used to assign names to the indeterminates.

Example: Weight Enumerators of the Octacode (ex-92ee64)

Run in calculator (opens in a new tab)Copy input

Several different weight enumerators are calculated for the octacode. To ensure the polynomials print out nicely, names are assigned to the polynomial ring indeterminates in each case. These names will persist if further calls to these functions (over \({\mathbb{Z}}_4\)) are made.

> Z4 := IntegerRing(4);
> O8 := LinearCode<Z4, 8 |
>     [1,0,0,0,3,1,2,1],
>     [0,1,0,0,1,2,3,1],
>     [0,0,1,0,3,3,3,2],
>     [0,0,0,1,2,3,1,1]>;
> #O8;
256
> CWE<X0,X1,X2,X3> := CompleteWeightEnumerator(O8);
> CWE;
X0^8 + 14*X0^4*X2^4 + 56*X0^3*X1^3*X2*X3 + 56*X0^3*X1*X2*X3^3 +
    56*X0*X1^3*X2^3*X3 + 56*X0*X1*X2^3*X3^3 + X1^8 + 14*X1^4*X3^4 +
    X2^8 + X3^8
> SWE<X0,X1,X2> := SymmetricWeightEnumerator(O8);
> SWE;
X0^8 + 14*X0^4*X2^4 + 112*X0^3*X1^4*X2 + 112*X0*X1^4*X2^3 + 16*X1^8 +
    X2^8
> HWE<X,Y> := HammingWeightEnumerator(O8);
> HWE;
X^8 + 14*X^4*Y^4 + 112*X^3*Y^5 + 112*X*Y^7 + 17*Y^8
> LeeWeightEnumerator(O8);
X^16 + 112*X^10*Y^6 + 30*X^8*Y^8 + 112*X^6*Y^10 + Y^16
> EuclideanWeightEnumerator(O8);
X^32 + 128*X^24*Y^8 + 126*X^16*Y^16 + Y^32

Run in calculator (opens in a new tab)Copy input