passagemath-modules 10.6.31rc3__cp314-cp314-musllinux_1_2_aarch64.whl

sage/coding/databases.py

@@ -0,0 +1,316 @@
+# sage_setup: distribution = sagemath-modules
+# sage.doctest: needs sage.modules sage.rings.finite_rings
+r"""
+Access functions to online databases for coding theory
+"""
+from sage.misc.lazy_import import lazy_import
+
+# Import the following function so that it is available as
+# - sage.coding.databases.self_dual_binary_codes
+# - codes.databases.self_dual_binary_codes (which functions as a catalog).
+lazy_import('sage.coding.self_dual_codes', 'self_dual_binary_codes')
+
+del lazy_import
+
+# Do not put any global imports here since this module is accessible as
+# - sage.coding.databases.<tab>
+# - codes.databases.<tab>
+
+
+def best_linear_code_in_guava(n, k, F):
+    r"""
+    Return 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 :func:`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_package_guava
+        [10, 5] linear code over GF(2)
+        sage: libgap.LoadPackage('guava')                              # long time; optional - gap_package_guava
+        ...
+        sage: libgap.BestKnownLinearCode(10,5,libgap.GF(2))            # long time; optional - gap_package_guava
+        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.
+    """
+    from sage.features.gap import GapPackage
+    from .linear_code import LinearCode
+    GapPackage('guava', spkg='gap_packages').require()
+    from sage.libs.gap.libgap import libgap
+    libgap.load_package('guava')
+    C = libgap.BestKnownLinearCode(n, k, F)
+    return LinearCode(C.GeneratorMat()._matrix_(F))
+
+
+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_package_guava
+        sage: gap_rec.Display()                                                          # optional - gap_package_guava
+        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 := ... )
+    """
+    from sage.features.gap import GapPackage
+    GapPackage('guava', spkg='gap_packages').require()
+    from sage.libs.gap.libgap import libgap
+    libgap.load_package('guava')
+    return libgap.BoundsMinimumDistance(n, k, F)
+
+
+def best_linear_code_in_codetables_dot_de(n, k, F, verbose=False):
+    r"""
+    Return the best linear code and its construction as per the web database
+    http://www.codetables.de/
+
+    INPUT:
+
+    - ``n`` -- integer; the length of the code
+
+    - ``k`` -- integer; the dimension of the code
+
+    - ``F`` -- finite field, of order 2, 3, 4, 5, 7, 8, or 9
+
+    - ``verbose`` -- boolean (default: ``False``)
+
+    OUTPUT: an unparsed text explaining the construction of the code
+
+    EXAMPLES::
+
+        sage: L = codes.databases.best_linear_code_in_codetables_dot_de(72, 36, GF(2))    # optional - internet
+        sage: print(L)                                                                    # optional - internet
+        Construction of a linear code
+        [72,36,15] over GF(2):
+        [1]:  [73, 36, 16] Cyclic Linear Code over GF(2)
+             CyclicCode of length 73 with generating polynomial x^37 + x^36 + x^34 +
+        x^33 + x^32 + x^27 + x^25 + x^24 + x^22 + x^21 + x^19 + x^18 + x^15 + x^11 +
+        x^10 + x^8 + x^7 + x^5 + x^3 + 1
+        [2]:  [72, 36, 15] Linear Code over GF(2)
+             Puncturing of [1] at 1
+        <BLANKLINE>
+        last modified: 2002-03-20
+
+    This function raises an :exc:`IOError` if an error occurs downloading data or
+    parsing it. It raises a :exc:`ValueError` if the ``q`` input is invalid.
+
+    AUTHORS:
+
+    - Steven Sivek (2005-11-14)
+    - David Joyner (2008-03)
+    """
+    from urllib.request import urlopen
+    from sage.cpython.string import bytes_to_str
+    q = F.order()
+    if q not in [2, 3, 4, 5, 7, 8, 9]:
+        raise ValueError("q (=%s) must be in [2,3,4,5,7,8,9]" % q)
+    n = int(n)
+    k = int(k)
+
+    param = ("?q=%s&n=%s&k=%s" % (q, n, k)).replace('L', '')
+
+    url = "http://www.codetables.de/" + "BKLC/BKLC.php" + param
+    if verbose:
+        print("Looking up the bounds at %s" % url)
+    with urlopen(url) as f:
+        s = f.read()
+
+    s = bytes_to_str(s)
+    i = s.find("<PRE>")
+    j = s.find("</PRE>")
+    if i == -1 or j == -1:
+        raise OSError("Error parsing data (missing pre tags).")
+    return s[i+5:j].strip()
+
+
+def self_orthogonal_binary_codes(n, k, b=2, parent=None, BC=None, equal=False,
+    in_test=None):
+    """
+    Return a Python iterator which generates a complete set of
+    representatives of all permutation equivalence classes of
+    self-orthogonal binary linear codes of length in ``[1..n]`` and
+    dimension in ``[1..k]``.
+
+    INPUT:
+
+    - ``n`` -- integer; maximal length
+
+    - ``k`` -- integer; maximal dimension
+
+    - ``b`` -- integer; requires that the generators all have weight divisible
+      by ``b`` (if ``b=2``, all self-orthogonal codes are generated, and if
+      ``b=4``, all doubly even codes are generated). Must be an even positive
+      integer.
+
+    - ``parent`` -- used in recursion (default: ``None``)
+
+    - ``BC`` -- used in recursion (default: ``None``)
+
+    - ``equal`` -- if ``True``, generates only [n, k] codes (default: ``False``)
+
+    - ``in_test`` -- used in recursion (default: ``None``)
+
+    EXAMPLES:
+
+    Generate all self-orthogonal codes of length up to 7 and dimension up
+    to 3::
+
+        sage: # needs sage.groups
+        sage: for B in codes.databases.self_orthogonal_binary_codes(7,3):
+        ....:    print(B)
+        [2, 1] linear code over GF(2)
+        [4, 2] linear code over GF(2)
+        [6, 3] linear code over GF(2)
+        [4, 1] linear code over GF(2)
+        [6, 2] linear code over GF(2)
+        [6, 2] linear code over GF(2)
+        [7, 3] linear code over GF(2)
+        [6, 1] linear code over GF(2)
+
+    Generate all doubly-even codes of length up to 7 and dimension up
+    to 3::
+
+        sage: # needs sage.groups
+        sage: for B in codes.databases.self_orthogonal_binary_codes(7,3,4):
+        ....:    print(B); print(B.generator_matrix())
+        [4, 1] linear code over GF(2)
+        [1 1 1 1]
+        [6, 2] linear code over GF(2)
+        [1 1 1 1 0 0]
+        [0 1 0 1 1 1]
+        [7, 3] linear code over GF(2)
+        [1 0 1 1 0 1 0]
+        [0 1 0 1 1 1 0]
+        [0 0 1 0 1 1 1]
+
+    Generate all doubly-even codes of length up to 7 and dimension up
+    to 2::
+
+        sage: # needs sage.groups
+        sage: for B in codes.databases.self_orthogonal_binary_codes(7,2,4):
+        ....:    print(B); print(B.generator_matrix())
+        [4, 1] linear code over GF(2)
+        [1 1 1 1]
+        [6, 2] linear code over GF(2)
+        [1 1 1 1 0 0]
+        [0 1 0 1 1 1]
+
+    Generate all self-orthogonal codes of length equal to 8 and
+    dimension equal to 4::
+
+        sage: # needs sage.groups
+        sage: for B in codes.databases.self_orthogonal_binary_codes(8, 4, equal=True):
+        ....:     print(B); print(B.generator_matrix())
+        [8, 4] linear code over GF(2)
+        [1 0 0 1 0 0 0 0]
+        [0 1 0 0 1 0 0 0]
+        [0 0 1 0 0 1 0 0]
+        [0 0 0 0 0 0 1 1]
+        [8, 4] linear code over GF(2)
+        [1 0 0 1 1 0 1 0]
+        [0 1 0 1 1 1 0 0]
+        [0 0 1 0 1 1 1 0]
+        [0 0 0 1 0 1 1 1]
+
+    Since all the codes will be self-orthogonal, b must be divisible by
+    2::
+
+        sage: list(codes.databases.self_orthogonal_binary_codes(8, 4, 1, equal=True))
+        Traceback (most recent call last):
+        ...
+        ValueError: b (1) must be a positive even integer.
+    """
+    from sage.rings.finite_rings.finite_field_constructor import FiniteField
+    from sage.matrix.constructor import Matrix
+
+    d = int(b)
+    if d != b or d % 2 == 1 or d <= 0:
+        raise ValueError("b (%s) must be a positive even integer." % b)
+    from .linear_code import LinearCode
+    from .binary_code import BinaryCode, BinaryCodeClassifier
+    if k < 1 or n < 2:
+        return
+    if equal:
+        in_test = lambda M: (M.ncols() - M.nrows()) <= (n-k)
+        out_test = lambda C: (C.dimension() == k) and (C.length() == n)
+    else:
+        in_test = lambda M: True
+        out_test = lambda C: True
+    if BC is None:
+        BC = BinaryCodeClassifier()
+    if parent is None:
+        for j in range(d, n+1, d):
+            M = Matrix(FiniteField(2), [[1]*j])
+            if in_test(M):
+                for N in self_orthogonal_binary_codes(n, k, d, M, BC, in_test=in_test):
+                    if out_test(N):
+                        yield N
+    else:
+        C = LinearCode(parent)
+        if out_test(C):
+            yield C
+        if k == parent.nrows():
+            return
+        for nn in range(parent.ncols()+1, n+1):
+            if in_test(parent):
+                for child in BC.generate_children(BinaryCode(parent), nn, d):
+                    for N in self_orthogonal_binary_codes(n, k, d, child, BC, in_test=in_test):
+                        if out_test(N):
+                            yield N

sage/coding/decoder.py

@@ -0,0 +1,373 @@
+# sage_setup: distribution = sagemath-modules
+# sage.doctest: needs sage.modules sage.rings.finite_rings
+r"""
+Decoders
+
+Representation of an error-correction algorithm for a code.
+
+AUTHORS:
+
+- David Joyner (2009-02-01): initial version
+
+- David Lucas (2015-06-29): abstract class version
+"""
+#*****************************************************************************
+#       Copyright (C) 2009 David Joyner <wdjoyner@gmail.com>
+#                     2015 David Lucas <david.lucas@inria.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or later (at your preference).
+#
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.misc.abstract_method import abstract_method
+from sage.structure.sage_object import SageObject
+
+
+class Decoder(SageObject):
+    r"""
+    Abstract top-class for :class:`Decoder` objects.
+
+    Every decoder class for linear codes (of any metric) should inherit from
+    this abstract class.
+
+    To implement a decoder, you need to:
+
+    - inherit from :class:`Decoder`
+
+    - call ``Decoder.__init__`` in the subclass constructor.
+      Example: ``super().__init__(code, input_space, connected_encoder_name)``.
+      By doing that, your subclass will have all the parameters described above initialized.
+
+    - Then, you need to override one of decoding methods, either :meth:`decode_to_code` or
+      :meth:`decode_to_message`. You can also override the optional method :meth:`decoding_radius`.
+
+    - By default, comparison of :class:`Decoder` (using methods ``__eq__`` and ``__ne__`` ) are
+      by memory reference: if you build the same decoder twice, they will be different. If you
+      need something more clever, override ``__eq__`` and ``__ne__`` in your subclass.
+
+    - As :class:`Decoder` is not designed to be instantiated, it does not have any representation
+      methods. You should implement ``_repr_`` and ``_latex_`` methods in the subclass.
+    """
+
+    @classmethod
+    def decoder_type(cls):
+        r"""
+        Return the set of types of ``self``.
+
+        This method can be called on both an uninstantiated decoder class,
+        or on an instance of a decoder class.
+
+        The types of a decoder are a set of labels commonly associated with
+        decoders which describe the nature and behaviour of the decoding
+        algorithm. It should be considered as an informal descriptor but
+        can be coarsely relied upon for e.g. program logic.
+
+        The following are the most common types and a brief definition:
+
+        ======================  ================================================
+        Decoder type            Definition
+        ======================  ================================================
+        always-succeed          The decoder always returns a closest codeword if
+                                the number of errors is up to the decoding
+                                radius.
+        bounded-distance        Any vector with Hamming distance at most
+                                ``decoding_radius()`` to a codeword is
+                                decodable to some codeword. If ``might-fail`` is
+                                also a type, then this is not a guarantee but an
+                                expectancy.
+        complete                The decoder decodes every word in the ambient
+                                space of the code.
+        dynamic                 Some of the decoder's types will only be
+                                determined at construction time
+                                (depends on the parameters).
+        half-minimum-distance   The decoder corrects up to half the minimum
+                                distance, or a specific lower bound thereof.
+        hard-decision           The decoder uses no information on which
+                                positions are more likely to be in error or not.
+        list-decoder            The decoder outputs a list of likely codewords,
+                                instead of just a single codeword.
+        might-fail              The decoder can fail at decoding even within its
+                                usual promises, e.g. bounded distance.
+        not-always-closest      The decoder does not guarantee to always return a
+                                closest codeword.
+        probabilistic           The decoder has internal randomness which can affect
+                                running time and the decoding result.
+        soft-decision           As part of the input, the decoder takes
+                                reliability information on which positions are
+                                more likely to be in error. Such a decoder only
+                                works for specific channels.
+        ======================  ================================================
+
+        EXAMPLES:
+
+        We call it on a class::
+
+            sage: codes.decoders.LinearCodeSyndromeDecoder.decoder_type()
+            {'dynamic', 'hard-decision'}
+
+        We can also call it on a instance of a :class:`Decoder` class::
+
+            sage: G = Matrix(GF(2), [[1, 0, 0, 1], [0, 1, 1, 1]])
+            sage: C = LinearCode(G)
+            sage: D = C.decoder()
+            sage: D.decoder_type()
+            {'complete', 'hard-decision', 'might-error'}
+        """
+        return cls._decoder_type
+
+    def _instance_decoder_type(self):
+        r"""
+        See the documentation of :meth:`decoder_type`.
+
+        EXAMPLES:
+
+        Test to satisfy the doc-testing framework::
+
+            sage: G = Matrix(GF(2), [[1, 0, 0, 1], [0, 1, 1, 1]])
+            sage: C = LinearCode(G)
+            sage: D = C.decoder()
+            sage: D.decoder_type() #indirect doctest
+            {'complete', 'hard-decision', 'might-error'}
+        """
+        return self._decoder_type
+
+    def __init__(self, code, input_space, connected_encoder_name):
+        r"""
+        Initialize mandatory parameters for :class:`Decoder` objects.
+
+        This method only exists for inheritance purposes as it initializes
+        parameters that need to be known by every decoder. An abstract
+        decoder object should never be created.
+
+        INPUT:
+
+        - ``code`` -- the associated code of ``self``
+
+        - ``input_space`` -- the input space of ``self``, which is the ambient space
+          of ``self``'s ``code``
+
+        - ``connected_encoder_name`` -- the associated encoder, which will be
+          used by ``self`` to recover elements from the message space
+
+        EXAMPLES:
+
+        We first create a new :class:`Decoder` subclass::
+
+            sage: from sage.coding.decoder import Decoder
+            sage: class DecoderExample(Decoder):
+            ....:   def __init__(self, code):
+            ....:       in_space = code.ambient_space()
+            ....:       connected_enc = "GeneratorMatrix"
+            ....:       super().__init__(code, in_space, connected_enc)
+
+        We now create a member of our brand new class::
+
+            sage: G = Matrix(GF(2), [[1, 0, 0, 1], [0, 1, 1, 1]])
+            sage: C = LinearCode(G)
+            sage: D = DecoderExample(C)
+
+        We can check its parameters::
+
+            sage: D.input_space()
+            Vector space of dimension 4 over Finite Field of size 2
+            sage: D.connected_encoder()
+            Generator matrix-based encoder for [4, 2] linear code over GF(2)
+            sage: D.code()
+            [4, 2] linear code over GF(2)
+        """
+        self.decoder_type = self._instance_decoder_type
+        self._code = code
+        self._input_space = input_space
+        self._connected_encoder_name = connected_encoder_name
+
+    def __hash__(self):
+        r"""
+        Return the hash value of ``self``.
+
+        This is a generic implementation which should be overwritten on decoders
+        with extra arguments.
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0],[1,0,0,1,1,0,0],[0,1,0,1,0,1,0],[1,1,0,1,0,0,1]])
+            sage: C = LinearCode(G)
+            sage: D = C.decoder()
+            sage: hash(D) #random
+            7575380076354998465
+        """
+        C = self.code()
+        Str = str(C)
+        return hash((C, Str)) ^ hash(Str) ^ hash(C)
+
+    def __ne__(self, other):
+        r"""
+        Test inequality of ``self`` and ``other``.
+
+        This is a generic implementation, which returns the inverse of
+        ``__eq__`` for ``self``.
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0],[1,0,0,1,1,0,0],[0,1,0,1,0,1,0],[1,1,0,1,0,0,1]])
+            sage: D1 = LinearCode(G).decoder()
+            sage: D2 = LinearCode(G).decoder()
+            sage: D1 != D2
+            False
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0],[1,0,0,1,1,0,0],[0,1,0,1,0,1,0],[1,1,0,1,0,1,1]])
+            sage: D2 = LinearCode(G).decoder()
+            sage: D1 != D2
+            True
+        """
+        return not self == other
+
+    def decode_to_code(self, r):
+        r"""
+        Correct the errors in ``r`` and return a codeword.
+
+        This is a default implementation which assumes that the method
+        :meth:`decode_to_message` has been implemented, else it returns an exception.
+
+        INPUT:
+
+        - ``r`` -- a element of the input space of ``self``
+
+        OUTPUT: a vector of :meth:`code`
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0], [1,0,0,1,1,0,0],
+            ....:                    [0,1,0,1,0,1,0], [1,1,0,1,0,0,1]])
+            sage: C = LinearCode(G)
+            sage: word = vector(GF(2), (1, 1, 0, 0, 1, 1, 0))
+            sage: word in C
+            True
+            sage: w_err = word + vector(GF(2), (1, 0, 0, 0, 0, 0, 0))
+            sage: w_err in C
+            False
+            sage: D = C.decoder()
+            sage: D.decode_to_code(w_err)
+            (1, 1, 0, 0, 1, 1, 0)
+        """
+        if hasattr(self, "defaulting_decode_to_message"):
+            raise NotImplementedError
+        else:
+            word = self.decode_to_message(r)
+            return self.connected_encoder().encode(word)
+
+    def connected_encoder(self):
+        r"""
+        Return the connected encoder of ``self``.
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0], [1,0,0,1,1,0,0],
+            ....:                    [0,1,0,1,0,1,0], [1,1,0,1,0,0,1]])
+            sage: C = LinearCode(G)
+            sage: D = C.decoder()
+            sage: D.connected_encoder()
+            Generator matrix-based encoder for [7, 4] linear code over GF(2)
+        """
+        return self.code().encoder(encoder_name=self._connected_encoder_name)
+
+    def decode_to_message(self, r):
+        r"""
+        Decode ``r`` to the message space of :meth:`connected_encoder`.
+
+        This is a default implementation, which assumes that the
+        method :meth:`decode_to_code` has been implemented, else it
+        returns an exception.
+
+        INPUT:
+
+        - ``r`` -- a element of the input space of ``self``
+
+        OUTPUT: a vector of :meth:`message_space`
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0], [1,0,0,1,1,0,0],
+            ....:                    [0,1,0,1,0,1,0], [1,1,0,1,0,0,1]])
+            sage: C = LinearCode(G)
+            sage: word = vector(GF(2), (1, 1, 0, 0, 1, 1, 0))
+            sage: w_err = word + vector(GF(2), (1, 0, 0, 0, 0, 0, 0))
+            sage: D = C.decoder()
+            sage: D.decode_to_message(w_err)
+            (0, 1, 1, 0)
+        """
+        self.defaulting_decode_to_message = True
+        return self.code().unencode(self.decode_to_code(r))
+
+    def code(self):
+        r"""
+        Return the code for this :class:`Decoder`.
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0], [1,0,0,1,1,0,0],
+            ....:                    [0,1,0,1,0,1,0], [1,1,0,1,0,0,1]])
+            sage: C = LinearCode(G)
+            sage: D = C.decoder()
+            sage: D.code()
+            [7, 4] linear code over GF(2)
+        """
+        return self._code
+
+    def message_space(self):
+        r"""
+        Return the message space of ``self``'s :meth:`connected_encoder`.
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0], [1,0,0,1,1,0,0],
+            ....:                    [0,1,0,1,0,1,0], [1,1,0,1,0,0,1]])
+            sage: C = LinearCode(G)
+            sage: D = C.decoder()
+            sage: D.message_space()
+            Vector space of dimension 4 over Finite Field of size 2
+        """
+        return self.connected_encoder().message_space()
+
+    def input_space(self):
+        r"""
+        Return the input space of ``self``.
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0], [1,0,0,1,1,0,0],
+            ....:                    [0,1,0,1,0,1,0], [1,1,0,1,0,0,1]])
+            sage: C = LinearCode(G)
+            sage: D = C.decoder()
+            sage: D.input_space()
+            Vector space of dimension 7 over Finite Field of size 2
+        """
+        if hasattr(self, "_input_space"):
+            return self._input_space
+        else:
+            raise NotImplementedError("Decoder does not have an _input_space parameter")
+
+    @abstract_method(optional=True)
+    def decoding_radius(self, **kwargs):
+        r"""
+        Return the maximal number of errors that ``self`` is able to correct.
+
+        This is an abstract method and it should be implemented in subclasses.
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(2), [[1,1,1,0,0,0,0], [1,0,0,1,1,0,0],
+            ....:                    [0,1,0,1,0,1,0], [1,1,0,1,0,0,1]])
+            sage: C = LinearCode(G)
+            sage: D = codes.decoders.LinearCodeSyndromeDecoder(C)
+            sage: D.decoding_radius()
+            1
+        """
+        raise NotImplementedError
+
+
+class DecodingError(Exception):
+    r"""
+    Special exception class to indicate an error during decoding.
+    """
+    pass