Repository: mhostetter/galois

Issue:
Rename `display` to `repr`
Using `repr` seems more consistent with `repr_table()`. And "repr" is short for representation, and we are changing the element representation...

### Current

```python
In [1]: import galois

In [2]: GF = galois.GF(3**2, display="poly")

In [3]: x = GF.Random(4); x
Out[3]: GF([ α + 1, 2α + 1, 2α + 1,     2α], order=3^2)

In [4]: GF.display("power");

In [5]: x
Out[5]: GF([α^2, α^3, α^3, α^5], order=3^2)
```

### Future

```python
In [1]: import galois

In [2]: GF = galois.GF(3**2, repr="poly")

In [3]: x = GF.Random(4); x
Out[3]: GF([ α + 1, 2α + 1, 2α + 1,     2α], order=3^2)

In [4]: GF.repr("power");

In [5]: x
Out[5]: GF([α^2, α^3, α^3, α^5], order=3^2)
```

Discussion:
codecov[bot]: # [Codecov](https://codecov.io/gh/mhostetter/galois/pull/436?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter) Report
Base: **96.40**% // Head: **96.40**% // No change to project coverage :thumbsup:
> Coverage data is based on head [(`d8649d8`)](https://codecov.io/gh/mhostetter/galois/pull/436?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter) compared to base [(`3676b4c`)](https://codecov.io/gh/mhostetter/galois/commit/3676b4cac6707c7715f240e406f3720b69c76ce3?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter).
> Patch coverage: 96.77% of modified lines in pull request are covered.

<details><summary>Additional details and impacted files</summary>


```diff
@@              Coverage Diff               @@
##           release/0.2.x     #436   +/-   ##
==============================================
  Coverage          96.40%   96.40%           
==============================================
  Files                 42       42           
  Lines               5501     5501           
==============================================
  Hits                5303     5303           
  Misses               198      198           
```


| [Impacted Files](https://codecov.io/gh/mhostetter/galois/pull/436?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter) | Coverage Δ | |
|---|---|---|
| [src/galois/\_fields/\_primitive\_element.py](https://codecov.io/gh/mhostetter/galois/pull/436/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter#diff-c3JjL2dhbG9pcy9fZmllbGRzL19wcmltaXRpdmVfZWxlbWVudC5weQ==) | `91.78% <ø> (ø)` | |
| [src/galois/\_options.py](https://codecov.io/gh/mhostetter/galois/pull/436/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter#diff-c3JjL2dhbG9pcy9fb3B0aW9ucy5weQ==) | `100.00% <ø> (ø)` | |
| [src/galois/\_fields/\_factory.py](https://codecov.io/gh/mhostetter/galois/pull/436/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter#diff-c3JjL2dhbG9pcy9fZmllbGRzL19mYWN0b3J5LnB5) | `96.49% <91.66%> (ø)` | |
| [src/galois/\_domains/\_array.py](https://codecov.io/gh/mhostetter/galois/pull/436/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter#diff-c3JjL2dhbG9pcy9fZG9tYWlucy9fYXJyYXkucHk=) | `96.89% <100.00%> (ø)` | |
| [src/galois/\_domains/\_meta.py](https://codecov.io/gh/mhostetter/galois/pull/436/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter#diff-c3JjL2dhbG9pcy9fZG9tYWlucy9fbWV0YS5weQ==) | `96.73% <100.00%> (ø)` | |
| [src/galois/\_fields/\_array.py](https://codecov.io/gh/mhostetter/galois/pull/436/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter#diff-c3JjL2dhbG9pcy9fZmllbGRzL19hcnJheS5weQ==) | `99.12% <100.00%> (ø)` | |
| [src/galois/\_fields/\_meta.py](https://codecov.io/gh/mhostetter/galois/pull/436/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter#diff-c3JjL2dhbG9pcy9fZmllbGRzL19tZXRhLnB5) | `100.00% <100.00%> (ø)` | |
| [src/galois/\_polys/\_conversions.py](https://codecov.io/gh/mhostetter/galois/pull/436/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter#diff-c3JjL2dhbG9pcy9fcG9seXMvX2NvbnZlcnNpb25zLnB5) | `99.09% <100.00%> (ø)` | |

Help us with your feedback. Take ten seconds to tell us [how you rate us](https://about.codecov.io/nps?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter). Have a feature suggestion? [Share it here.](https://app.codecov.io/gh/feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter)

</details>

[:umbrella: View full report at Codecov](https://codecov.io/gh/mhostetter/galois/pull/436?src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter).   
:loudspeaker: Do you have feedback about the report comment? [Let us know in this issue](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Matt+Hostetter).


Patch:
diff --git a/README.md b/README.md
index f8e9982df..b27c300be 100644
--- a/README.md
+++ b/README.md
@@ -150,28 +150,28 @@ See [Array Creation](https://mhostetter.github.io/galois/latest/basic-usage/arra
 
 ### Change the element representation
 
-The display representation of finite field elements can be set to either the integer (`"int"`), polynomial (`"poly"`),
-or power (`"power"`) representation. The default representation is the integer representation since that is natural when
+The representation of finite field elements can be set to either the integer (`"int"`), polynomial (`"poly"`),
+or power (`"power"`) representation. The default representation is the integer representation since integers are natural when
 working with integer NumPy arrays.
 
-Set the display mode by passing the `display` keyword argument to `galois.GF()` or by calling the `display()` classmethod.
-Choose whichever element representation is most convenient for you.
+Set the element representation by passing the `repr` keyword argument to `galois.GF()` or by calling the `repr()`
+classmethod. Choose whichever element representation is most convenient.
 
 ```python
-# The default representation is the integer representation
+# The default is the integer representation
 In [12]: x
 Out[12]: GF([236,  87,  38, 112], order=3^5)
 
-In [13]: GF.display("poly"); x
+In [13]: GF.repr("poly"); x
 Out[13]: 
 GF([2α^4 + 2α^3 + 2α^2 + 2,               α^4 + 2α,
              α^3 + α^2 + 2,      α^4 + α^3 + α + 1], order=3^5)
 
-In [14]: GF.display("power"); x
+In [14]: GF.repr("power"); x
 Out[14]: GF([α^204,  α^16, α^230,  α^34], order=3^5)
 
 # Reset to the integer representation
-In [15]: GF.display("int");
+In [15]: GF.repr("int");
 ```
 
 See [Element Representation](https://mhostetter.github.io/galois/latest/basic-usage/element-representation/) for more details.
diff --git a/docs/basic-usage/element-representation.rst b/docs/basic-usage/element-representation.rst
index f5696a0bf..65c8e9ec4 100644
--- a/docs/basic-usage/element-representation.rst
+++ b/docs/basic-usage/element-representation.rst
@@ -1,61 +1,56 @@
 Element Representation
 ======================
 
-The display representation of finite field elements can be set to either their integer (`"int"`), polynomial (`"poly"`),
+The representation of finite field elements can be set to either their integer (`"int"`), polynomial (`"poly"`),
 or power (`"power"`) representation.
 
 In prime fields :math:`\mathrm{GF}(p)`, elements are integers in :math:`\{0, 1, \dots, p-1\}`. Their two useful representations
 are the integer and power representation.
 
 In extension fields :math:`\mathrm{GF}(p^m)`, elements are polynomials over :math:`\mathrm{GF}(p)` with degree less than :math:`m`.
-All display representations are useful. The polynomial representation allows *proper* representation of the element as a polynomial
+All element representations are useful. The polynomial representation allows *proper* representation of the element as a polynomial
 over its prime subfield. However, the integer representation is more compact for displaying large arrays.
 
-Set the display mode
---------------------
+Set the element representation
+------------------------------
 
-The field element display mode can be set during :obj:`~galois.FieldArray` subclass creation by passing the `display` keyword
+The field element representation can be set during :obj:`~galois.FieldArray` subclass creation by passing the `repr` keyword
 argument to the :func:`~galois.GF` class factory.
 
 .. ipython:: python
 
-    GF = galois.GF(3**5, display="poly")
+    GF = galois.GF(3**5, repr="poly")
     x = GF([17, 4])
     x
     print(x)
 
-.. note::
-
-    Notice :func:`~galois.FieldArray.__repr__` displays `GF([...], order=p^m)` where :func:`~galois.FieldArray.__str__` only displays
-    `[...]`. This is designed to be consistent with NumPy's use of `repr()` and `str()`.
-
-The current display mode is accessed with the :obj:`~galois.FieldArray.display_mode` class property.
+The current element representation is accessed with the :obj:`~galois.FieldArray.element_repr` class property.
 
 .. ipython:: python
 
-    GF.display_mode
+    GF.element_repr
 
-The display mode can be temporarily changed using the :func:`~galois.FieldArray.display` classmethod as a context manager.
+The element representation can be temporarily changed using the :func:`~galois.FieldArray.repr` classmethod as a context manager.
 
 .. ipython:: python
 
     # Inside the context manager, x prints using the power representation
-    with GF.display("power"):
+    with GF.repr("power"):
         print(x)
 
     # Outside the context manager, x prints using the previous representation
     print(x)
 
-The display mode can be permanently changed using the :func:`~galois.FieldArray.display` method.
+The element representation can be permanently changed using the :func:`~galois.FieldArray.repr` method.
 
 .. ipython:: python
 
-    # The old polynomial display mode
+    # The old polynomial representation
     x
 
-    GF.display("int");
+    GF.repr("int");
 
-    # The new integer display mode
+    # The new integer representation
     x
 
 .. _int-repr:
@@ -63,7 +58,7 @@ The display mode can be permanently changed using the :func:`~galois.FieldArray.
 Integer representation
 ----------------------
 
-The integer display mode (the default) displays all finite field elements as integers in :math:`\{0, 1, \dots, p^m-1\}`.
+The integer representation (the default) displays all finite field elements as integers in :math:`\{0, 1, \dots, p^m-1\}`.
 
 In prime fields, the integer representation is simply the integer element in :math:`\{0, 1, \dots, p-1\}`.
 
@@ -89,14 +84,14 @@ coefficient as the most-significant digit and zero-degree coefficient as the lea
 Polynomial representation
 -------------------------
 
-The polynomial display mode displays all finite field elements as polynomials over their prime subfield with degree less than :math:`m`.
+The polynomial representation displays all finite field elements as polynomials over their prime subfield with degree less than :math:`m`.
 
-In prime fields, :math:`m = 1` and, therefore, the polynomial representation is equivalent to the integer representation because the
+In prime fields :math:`m = 1`, therefore the polynomial representation is equivalent to the integer representation because the
 polynomials all have degree 0.
 
 .. ipython:: python
 
-    GF = galois.GF(31, display="poly")
+    GF = galois.GF(31, repr="poly")
     GF(11)
 
 In extension fields, the polynomial representation displays the elements naturally as polynomials over their prime subfield.
@@ -104,7 +99,7 @@ This is useful, however it can become cluttered for large arrays.
 
 .. ipython:: python
 
-    GF = galois.GF(3**5, display="poly")
+    GF = galois.GF(3**5, repr="poly")
     GF(17)
     GF("x^2 + 2x + 2")
     # Integer/polynomial equivalence
@@ -121,24 +116,24 @@ This is useful, however it can become cluttered for large arrays.
 Power representation
 --------------------
 
-The power display mode represents the elements as powers of the finite field's primitive element :math:`\alpha`.
+The power representation displays all finite field elements as powers of the field's primitive element :math:`\alpha`.
 
 .. danger::
 
     To display elements in the power representation, :obj:`galois` must compute the discrete logarithm of each element displayed.
     For large fields (or fields using :ref:`explicit calculation <explicit-calculation>`), this process can take a while. However, when
-    using :ref:`lookup tables <lookup-tables>` this display mode is just as fast as the others.
+    using :ref:`lookup tables <lookup-tables>` this representation is just as fast as the others.
 
 In prime fields, the elements are displayed as :math:`\{0, 1, \alpha, \alpha^2, \dots, \alpha^{p-2}\}`.
 
 .. ipython:: python
 
-    GF = galois.GF(31, display="power")
+    GF = galois.GF(31, repr="power")
     GF(11)
 
 .. ipython:: python
 
-    GF.display("int");
+    GF.repr("int");
     alpha = GF.primitive_element; alpha
     alpha ** 23
 
@@ -146,26 +141,26 @@ In extension fields, the elements are displayed as :math:`\{0, 1, \alpha, \alpha
 
 .. ipython:: python
 
-    GF = galois.GF(3**5, display="power")
+    GF = galois.GF(3**5, repr="power")
     GF(17)
 
 .. ipython:: python
 
-    GF.display("int");
+    GF.repr("int");
     alpha = GF.primitive_element; alpha
     alpha ** 222
 
 Vector representation
 ---------------------
 
-The vector representation, while not a proper display mode of :func:`~galois.FieldArray.display`, represents finite field elements
+The vector representation, while not a valid input to :func:`~galois.FieldArray.repr`, represents finite field elements
 as vectors of their polynomial coefficients.
 
 The vector representation is accessed using the :func:`~galois.FieldArray.vector` method.
 
 .. ipython:: python
 
-    GF = galois.GF(3**5, display="poly")
+    GF = galois.GF(3**5, repr="poly")
     GF("x^2 + 2x + 2")
     GF("x^2 + 2x + 2").vector()
 
@@ -197,7 +192,7 @@ With the default line width, the array is quite difficult to read.
 
 .. ipython:: python
 
-    GF = galois.GF(3**5, display="poly")
+    GF = galois.GF(3**5, repr="poly")
     x = GF.Random((5, 5)); x
 
 The readability is improved by increasing the line width using :func:`numpy.set_printoptions`.
@@ -211,12 +206,12 @@ The readability is improved by increasing the line width using :func:`numpy.set_
     @suppress
     np.set_printoptions(linewidth=width)
     @suppress
-    GF.display("int");
+    GF.repr("int");
 
 Representation comparisons
 --------------------------
 
-For any finite field, each of the four representations can be easily compared using the :func:`~galois.FieldArray.repr_table` classmethod.
+For any finite field, each of the four element representations can be easily compared using the :func:`~galois.FieldArray.repr_table` classmethod.
 
 .. ipython:: python
 
diff --git a/docs/basic-usage/poly.rst b/docs/basic-usage/poly.rst
index 51feb14b2..8a2dda93b 100644
--- a/docs/basic-usage/poly.rst
+++ b/docs/basic-usage/poly.rst
@@ -34,7 +34,7 @@ Element representation
 ----------------------
 
 As with :obj:`~galois.FieldArray` instances, the finite field element representation of the polynomial coefficients may be changed
-by setting the `display` keyword argument of :func:`~galois.GF` or using the :func:`~galois.FieldArray.display` classmethod.
+by setting the `repr` keyword argument of :func:`~galois.GF` or using the :func:`~galois.FieldArray.repr` classmethod.
 
 .. ipython:: python
 
@@ -44,12 +44,12 @@ by setting the `display` keyword argument of :func:`~galois.GF` or using the :fu
    f = galois.Poly([13, 0, 4, 2], field=GF); print(f)
 
    # Display f(x) using the polynomial representation
-   GF.display("poly"); print(f)
+   GF.repr("poly"); print(f)
 
    # Display f(x) using the power representation
-   GF.display("power"); print(f)
+   GF.repr("power"); print(f)
 
-   GF.display("int");
+   GF.repr("int");
 
 See :doc:`element-representation` for more details.
 
diff --git a/docs/getting-started.rst b/docs/getting-started.rst
index 238bf648a..7ed3168bc 100644
--- a/docs/getting-started.rst
+++ b/docs/getting-started.rst
@@ -72,21 +72,21 @@ See :doc:`/basic-usage/array-creation` for more details.
 Change the element representation
 ---------------------------------
 
-The display representation of finite field elements can be set to either the integer (`"int"`), polynomial (`"poly"`),
-or power (`"power"`) representation. The default representation is the integer representation since that is natural when
+The representation of finite field elements can be set to either the integer (`"int"`), polynomial (`"poly"`),
+or power (`"power"`) representation. The default representation is the integer representation since integers are natural when
 working with integer NumPy arrays.
 
-Set the display mode by passing the `display` keyword argument to :func:`~galois.GF` or by calling the :func:`~galois.FieldArray.display`
-classmethod. Choose whichever element representation is most convenient for you.
+Set the element representation by passing the `repr` keyword argument to :func:`~galois.GF` or by calling the :func:`~galois.FieldArray.repr`
+classmethod. Choose whichever element representation is most convenient.
 
 .. ipython:: python
 
-   # The default representation is the integer representation
+   # The default is the integer representation
    x
-   GF.display("poly"); x
-   GF.display("power"); x
+   GF.repr("poly"); x
+   GF.repr("power"); x
    # Reset to the integer representation
-   GF.display("int");
+   GF.repr("int");
 
 See :doc:`/basic-usage/element-representation` for more details.
 
diff --git a/docs/ipython_with_reprs.py b/docs/ipython_with_reprs.py
index 626d08c02..57714585d 100644
--- a/docs/ipython_with_reprs.py
+++ b/docs/ipython_with_reprs.py
@@ -1,5 +1,5 @@
 """
-Sphinx extension that adds `ipython-with-reprs` directive.
+Sphinx extension that adds `ipython-with-element_reprs` directive.
 """
 from typing import List
 
@@ -11,7 +11,7 @@ import sphinx.util.logging
 
 logger = sphinx.util.logging.getLogger(__name__)
 
-DISPLAY_MODE_TO_TITLE = {
+ELEMENT_REPR_TO_TITLE = {
     "int": "Integer",
     "poly": "Polynomial",
     "power": "Power",
@@ -31,8 +31,8 @@ class IPythonWithReprsDirective(sphinx.util.docutils.SphinxDirective):
         self.assert_has_content()
 
         # Parse input parameters
-        display_modes = self.arguments[0].split(",")
-        titles = [DISPLAY_MODE_TO_TITLE[mode] for mode in display_modes]
+        element_reprs = self.arguments[0].split(",")
+        titles = [ELEMENT_REPR_TO_TITLE[element_repr] for element_repr in element_reprs]
         field = self.options.get("name", "GF")
 
         ws = "    "
@@ -41,7 +41,7 @@ class IPythonWithReprsDirective(sphinx.util.docutils.SphinxDirective):
             ""
         ]
 
-        for mode, title in zip(display_modes, titles):
+        for element_repr, title in zip(element_reprs, titles):
             new_lines += [
                 f"{ws}.. md-tab-item:: {title}",
                 "",
@@ -49,16 +49,16 @@ class IPythonWithReprsDirective(sphinx.util.docutils.SphinxDirective):
                 "",
             ]
 
-            # Set the Galois field display mode
+            # Set the Galois field element representation
             first_code_line = self.content[0]
             if first_code_line.startswith(f"{field} = "):
-                assert "display=" not in first_code_line
-                if mode == "int":
+                assert "repr=" not in first_code_line
+                if element_repr == "int":
                     new_first_code_line = first_code_line
                 else:
                     items = first_code_line.rsplit(")", 1)
                     assert len(items) == 2
-                    items.insert(1, f", display=\"{mode}\")")
+                    items.insert(1, f", repr=\"{element_repr}\")")
                     new_first_code_line = "".join(items)
                 new_lines += [
                     f"{ws}{ws}{ws}{new_first_code_line}",
@@ -66,7 +66,7 @@ class IPythonWithReprsDirective(sphinx.util.docutils.SphinxDirective):
             else:
                 new_lines += [
                     f"{ws}{ws}{ws}@suppress",
-                    f"{ws}{ws}{ws}{field}.display(\"{mode}\")",
+                    f"{ws}{ws}{ws}{field}.repr(\"{element_repr}\")",
                     f"{ws}{ws}{ws}{first_code_line}",
                 ]
 
@@ -76,10 +76,10 @@ class IPythonWithReprsDirective(sphinx.util.docutils.SphinxDirective):
                     f"{ws}{ws}{ws}{code_line}",
                 ]
 
-            # Reset the Galois field display mode
+            # Reset the element representation
             new_lines += [
                 f"{ws}{ws}{ws}@suppress",
-                f"{ws}{ws}{ws}{field}.display()",
+                f"{ws}{ws}{ws}{field}.repr()",
                 ""
             ]
 
diff --git a/src/galois/_domains/_array.py b/src/galois/_domains/_array.py
index 95cc75922..d0727ce1a 100644
--- a/src/galois/_domains/_array.py
+++ b/src/galois/_domains/_array.py
@@ -370,45 +370,45 @@ class Array(LinalgFunctionMixin, FunctionMixin, UFuncMixin, np.ndarray, metaclas
     ###############################################################################
 
     @classmethod
-    def display(cls, mode: Literal["int", "poly", "power"] = "int") -> Generator[None, None, None]:
+    def repr(cls, element_repr: Literal["int", "poly", "power"] = "int") -> Generator[None, None, None]:
         r"""
-        Sets the display mode for all arrays from this :obj:`~galois.FieldArray` subclass.
+        Sets the element representation for all arrays from this :obj:`~galois.FieldArray` subclass.
 
-        The display mode can be set to either the integer representation, polynomial representation, or power
-        representation. See :doc:`/basic-usage/element-representation` for a further discussion.
+        The element representation can be set to either the integer, polynomial, or power representation.
+        See :doc:`/basic-usage/element-representation` for a further discussion.
 
-        This function updates :obj:`~galois.FieldArray.display_mode`.
+        This function updates :obj:`~galois.FieldArray.element_repr`.
 
-        Warning
-        -------
-        For the power representation, :func:`numpy.log` is computed on each element. So for large fields without lookup
-        tables, displaying arrays in the power representation may take longer than expected.
+        .. danger::
+
+            For the power representation, :func:`numpy.log` is computed on each element. So for large fields without lookup
+            tables, displaying arrays in the power representation may take longer than expected.
 
         Parameters
         ----------
-        mode
+        element_repr
             The field element representation.
 
-            - `"int"`: Sets the display mode to the :ref:`integer representation <int-repr>`.
-            - `"poly"`: Sets the display mode to the :ref:`polynomial representation <poly-repr>`.
-            - `"power"`: Sets the display mode to the :ref:`power representation <power-repr>`.
+            - `"int"` (default): Sets the representation to the :ref:`integer representation <int-repr>`.
+            - `"poly"`: Sets the representation to the :ref:`polynomial representation <poly-repr>`.
+            - `"power"`: Sets the representation to the :ref:`power representation <power-repr>`.
 
         Returns
         -------
         :
-            A context manager for use in a `with` statement. If permanently setting the display mode, disregard the
+            A context manager for use in a `with` statement. If permanently setting the element representation, disregard the
             return value.
 
         Examples
         --------
-        The default display mode is the integer representation.
+        The default element representation is the integer representation.
 
         .. ipython:: python
 
             GF = galois.GF(3**2)
             x = GF.elements; x
 
-        Permanently set the display mode by calling :func:`display`.
+        Permanently set the element representation by calling :func:`repr`.
 
         .. md-tab-set::
 
@@ -416,19 +416,19 @@ class Array(LinalgFunctionMixin, FunctionMixin, UFuncMixin, np.ndarray, metaclas
 
                 .. ipython:: python
 
-                    GF.display("poly");
+                    GF.repr("poly");
                     x
 
             .. md-tab-item:: Power
 
                 .. ipython:: python
 
-                    GF.display("power");
+                    GF.repr("power");
                     x
                     @suppress
-                    GF.display()
+                    GF.repr()
 
-        Temporarily modify the display mode by using :func:`display` as a context manager.
+        Temporarily modify the element representation by using :func:`repr` as a context manager.
 
         .. md-tab-set::
 
@@ -437,9 +437,9 @@ class Array(LinalgFunctionMixin, FunctionMixin, UFuncMixin, np.ndarray, metaclas
                 .. ipython:: python
 
                     print(x)
-                    with GF.display("poly"):
+                    with GF.repr("poly"):
                         print(x)
-                    # Outside the context manager, the display mode reverts to its previous value
+                    # Outside the context manager, the element representation reverts to its previous value
                     print(x)
 
             .. md-tab-item:: Power
@@ -447,27 +447,27 @@ class Array(LinalgFunctionMixin, FunctionMixin, UFuncMixin, np.ndarray, metaclas
                 .. ipython:: python
 
                     print(x)
-                    with GF.display("power"):
+                    with GF.repr("power"):
                         print(x)
-                    # Outside the context manager, the display mode reverts to its previous value
+                    # Outside the context manager, the element representation reverts to its previous value
                     print(x)
                     @suppress
-                    GF.display()
+                    GF.repr()
         """
-        verify_literal(mode, ["int", "poly", "power"])
+        verify_literal(element_repr, ["int", "poly", "power"])
 
-        prev_mode = cls.display_mode
-        cls._display_mode = mode  # Set the new display mode
+        prev_element_repr = cls.element_repr
+        cls._element_repr = element_repr
 
-        # Return a context manager for optional use in a `with` statement that will reset the display mode
+        # Return a context manager for optional use in a `with` statement that will reset the element representation
         # to its original value
-        return cls._display_context_manager(prev_mode)
+        return cls._repr_context_manager(prev_element_repr)
 
     @classmethod
     @contextlib.contextmanager
-    def _display_context_manager(cls, mode):
+    def _repr_context_manager(cls, element_repr: Literal["int", "poly", "power"]):
         yield
-        cls._display_mode = mode
+        cls._element_repr = element_repr
 
     ###############################################################################
     # Override getters/setters and type conversion functions
diff --git a/src/galois/_domains/_meta.py b/src/galois/_domains/_meta.py
index 13b5dc48a..2501854db 100644
--- a/src/galois/_domains/_meta.py
+++ b/src/galois/_domains/_meta.py
@@ -57,7 +57,7 @@ class ArrayMeta(abc.ABCMeta):
         cls._ZECH_E = 0
 
         # Class variables needed when displaying elements with fixed width
-        cls._display_mode = kwargs.get("display", "int")  # TODO: Do this here?
+        cls._element_repr = kwargs.get("repr", "int")  # TODO: Do this here?
         cls._element_fixed_width = None
         cls._element_fixed_width_counter = 0
 
@@ -173,11 +173,11 @@ class ArrayMeta(abc.ABCMeta):
         return cls._dtypes
 
     @property
-    def display_mode(cls) -> Literal["int", "poly", "power"]:
+    def element_repr(cls) -> Literal["int", "poly", "power"]:
         """
         The current element representation of the Galois field or Galois ring.
         """
-        return cls._display_mode
+        return cls._element_repr
 
     @property
     def ufunc_mode(cls) -> Literal["jit-lookup", "jit-calculate", "python-calculate"]:
diff --git a/src/galois/_fields/_array.py b/src/galois/_fields/_array.py
index 0d39f365c..37247e6ae 100644
--- a/src/galois/_fields/_array.py
+++ b/src/galois/_fields/_array.py
@@ -566,7 +566,7 @@ class FieldArray(Array, metaclass=FieldArrayMeta):
         if not operation in ["+", "-", "*", "/"]:
             raise ValueError(f"Argument 'operation' must be in ['+', '-', '*', '/'], not {operation!r}.")
 
-        if cls.display_mode == "power":
+        if cls.element_repr == "power":
             # Order elements by powers of the primitive element
             x_default = np.concatenate((np.atleast_1d(cls(0)), cls.primitive_element**np.arange(0, cls.order - 1, dtype=cls.dtypes[-1])))
         else:
@@ -586,9 +586,9 @@ class FieldArray(Array, metaclass=FieldArrayMeta):
         else:
             Z = X / Y
 
-        if cls.display_mode == "int":
+        if cls.element_repr == "int":
             print_element = cls._print_int
-        elif cls.display_mode == "poly":
+        elif cls.element_repr == "poly":
             print_element = cls._print_poly
         else:
             print_element = cls._print_power
@@ -883,7 +883,7 @@ class FieldArray(Array, metaclass=FieldArrayMeta):
             x = GF.elements; x
             x.is_square()
             @suppress
-            GF.display()
+            GF.repr()
 
         In :math:`\mathrm{GF}(11)`, the characteristic is greater than 2 so only half of the elements have square
         roots.
@@ -1650,11 +1650,11 @@ class FieldArray(Array, metaclass=FieldArrayMeta):
         """
         formatter = {}
 
-        if cls.display_mode == "poly" and cls.is_extension_field:
-            # The "poly" display mode for prime field's is the same as the integer representation
+        if cls.element_repr == "poly" and cls.is_extension_field:
+            # The polynomial representation for prime fields is the same as the integer representation
             formatter["int"] = cls._print_poly
             formatter["object"] = cls._print_poly
-        elif cls.display_mode == "power":
+        elif cls.element_repr == "power":
             formatter["int"] = cls._print_power
             formatter["object"] = cls._print_power
         elif array.dtype == np.object_:
diff --git a/src/galois/_fields/_factory.py b/src/galois/_fields/_factory.py
index 101e37ef5..ba8f10e18 100644
--- a/src/galois/_fields/_factory.py
+++ b/src/galois/_fields/_factory.py
@@ -27,7 +27,7 @@ def GF(
     primitive_element: int | PolyLike | None = None,  # pylint: disable=redefined-outer-name
     verify: bool = True,
     compile: Literal["auto", "jit-lookup", "jit-calculate", "python-calculate"] | None = None,  # pylint: disable=redefined-builtin
-    display: Literal["int", "poly", "power"] | None = None
+    repr: Literal["int", "poly", "power"] | None = None,  # pylint: disable=redefined-builtin
 ) -> Type[FieldArray]:
     r"""
     Creates a :obj:`~galois.FieldArray` subclass for :math:`\mathrm{GF}(p^m)`.
@@ -74,15 +74,15 @@ def GF(
         - `"python-calculate"`: Uses pure-Python ufuncs with explicit calculation. This is reserved for fields whose elements cannot be
           represented with :obj:`numpy.int64` and instead use :obj:`numpy.object_` with Python :obj:`int` (which has arbitrary precision).
 
-    display
-        The field element display representation. This can be modified after class construction with the :func:`~galois.FieldArray.display` method.
+    repr
+        The field element representation. This can be modified after class construction with the :func:`~galois.FieldArray.repr` method.
         See :doc:`/basic-usage/element-representation` for a further discussion.
 
         - `None` (default): For a newly-created :obj:`~galois.FieldArray` subclass, `None` corresponds to `"int"`. If the
-          :obj:`~galois.FieldArray` subclass already exists, `None` does not modify its current display mode.
-        - `"int"`: Sets the display mode to the :ref:`integer representation <int-repr>`.
-        - `"poly"`: Sets the display mode to the :ref:`polynomial representation <poly-repr>`.
-        - `"power"`: Sets the display mode to the :ref:`power representation <power-repr>`.
+          :obj:`~galois.FieldArray` subclass already exists, `None` does not modify its current element representation.
+        - `"int"`: Sets the element representation to the :ref:`integer representation <int-repr>`.
+        - `"poly"`: Sets the element representation to the :ref:`polynomial representation <poly-repr>`.
+        - `"power"`: Sets the element representation to the :ref:`power representation <power-repr>`.
 
     Returns
     -------
@@ -198,7 +198,7 @@ def GF(
     verify_isinstance(order, int)
     verify_isinstance(verify, bool)
     verify_isinstance(compile, str, optional=True)
-    verify_isinstance(display, str, optional=True)
+    verify_isinstance(repr, str, optional=True)
 
     p, e = factors(order)
     if not len(p) == len(e) == 1:
@@ -206,17 +206,17 @@ def GF(
         raise ValueError(f"Argument 'order' must be a prime power, not {order} = {s}.")
     if not compile in [None, "auto", "jit-lookup", "jit-calculate", "python-calculate"]:
         raise ValueError(f"Argument 'compile' must be in ['auto', 'jit-lookup', 'jit-calculate', 'python-calculate'], not {compile!r}.")
-    if not display in [None, "int", "poly", "power"]:
-        raise ValueError(f"Argument 'display' must be in ['int', 'poly', 'power'], not {display!r}.")
+    if not repr in [None, "int", "poly", "power"]:
+        raise ValueError(f"Argument 'repr' must be in ['int', 'poly', 'power'], not {repr!r}.")
 
     p, m = p[0], e[0]
 
     if m == 1:
         if not irreducible_poly is None:
             raise ValueError(f"Argument 'irreducible_poly' can only be specified for extension fields, not the prime field GF({p}).")
-        return _GF_prime(p, alpha=primitive_element, verify=verify, compile=compile, display=display)
+        return _GF_prime(p, alpha=primitive_element, verify=verify, compile=compile, repr=repr)
     else:
-        return _GF_extension(p, m, irreducible_poly_=irreducible_poly, alpha=primitive_element, verify=verify, compile=compile, display=display)
+        return _GF_extension(p, m, irreducible_poly_=irreducible_poly, alpha=primitive_element, verify=verify, compile=compile, repr=repr)
 
 
 @export
@@ -226,14 +226,14 @@ def Field(
     primitive_element: int | PolyLike | None = None,  # pylint: disable=redefined-outer-name
     verify: bool = True,
     compile: Literal["auto", "jit-lookup", "jit-calculate", "python-calculate"] | None = None,  # pylint: disable=redefined-builtin
-    display: Literal["int", "poly", "power"] | None = None
+    repr: Literal["int", "poly", "power"] | None = None,  # pylint: disable=redefined-builtin
 ) -> Type[FieldArray]:
     """
     Alias of :func:`~galois.GF`.
 
     :group: galois-fields
     """
-    return GF(order, irreducible_poly=irreducible_poly, primitive_element=primitive_element, verify=verify, compile=compile, display=display)
+    return GF(order, irreducible_poly=irreducible_poly, primitive_element=primitive_element, verify=verify, compile=compile, repr=repr)
 
 
 def _GF_prime(
@@ -241,7 +241,7 @@ def _GF_prime(
     alpha: int | None = None,
     verify: bool = True,
     compile: Literal["auto", "jit-lookup", "jit-calculate", "python-calculate"] | None = None,  # pylint: disable=redefined-builtin
-    display: Literal["int", "poly", "power"] | None = None
+    repr: Literal["int", "poly", "power"] | None = None,  # pylint: disable=redefined-builtin
 ) -> Type[FieldArray]:
     """
     Class factory for prime fields GF(p).
@@ -261,8 +261,8 @@ def _GF_prime(
         field = _GF_prime._classes[key]
         if compile is not None:
             field.compile(compile)
-        if display is not None:
-            field.display(display)
+        if repr is not None:
+            field.repr(repr)
         return field
 
     if verify and not is_primitive_root(alpha, p):
@@ -285,9 +285,9 @@ def _GF_prime(
     field.__module__ = __name__
     setattr(sys.modules[__name__], name, field)
 
-    # Since this is a new class, compile the ufuncs and set the display mode
+    # Since this is a new class, compile the ufuncs and set the element representation
     field.compile("auto" if compile is None else compile)
-    field.display("int" if display is None else display)
+    field.repr("int" if repr is None else repr)
 
     field._is_primitive_poly = field._irreducible_poly(field._primitive_element, field=field) == 0
 
@@ -306,7 +306,7 @@ def _GF_extension(
     alpha: PolyLike | None = None,
     verify: bool = True,
     compile: Literal["auto", "jit-lookup", "jit-calculate", "python-calculate"] | None = None,  # pylint: disable=redefined-builtin
-    display: Literal["int", "poly", "power"] | None = None
+    repr: Literal["int", "poly", "power"] | None = None,  # pylint: disable=redefined-builtin
 ) -> Type[FieldArray]:
     """
     Class factory for extension fields GF(p^m).
@@ -352,8 +352,8 @@ def _GF_extension(
         field = _GF_extension._classes[key]
         if compile is not None:
             field.compile(compile)
-        if display is not None:
-            field.display(display)
+        if repr is not None:
+            field.repr(repr)
         return field
 
     if verify_poly and not irreducible_poly_.is_irreducible():
@@ -378,9 +378,9 @@ def _GF_extension(
     field.__module__ = __name__
     setattr(sys.modules[__name__], name, field)
 
-    # Since this is a new class, compile the ufuncs and set the display mode
+    # Since this is a new class, compile the ufuncs and set the element representation
     field.compile("auto" if compile is None else compile)
-    field.display("int" if display is None else display)
+    field.repr("int" if repr is None else repr)
 
     if is_primitive_poly is not None:
         field._is_primitive_poly = is_primitive_poly
diff --git a/src/galois/_fields/_meta.py b/src/galois/_fields/_meta.py
index fe025e1ac..dfef93b35 100644
--- a/src/galois/_fields/_meta.py
+++ b/src/galois/_fields/_meta.py
@@ -64,7 +64,7 @@ class FieldArrayMeta(ArrayMeta):
             GF = galois.GF(7**5)
             print(GF.properties)
         """
-        with cls.prime_subfield.display("int"):
+        with cls.prime_subfield.repr("int"):
             irreducible_poly_str = str(cls._irreducible_poly)
 
         string = "Galois Field:"
@@ -442,33 +442,33 @@ class FieldArrayMeta(ArrayMeta):
         return super().dtypes
 
     @property
-    def display_mode(cls) -> Literal["int", "poly", "power"]:
+    def element_repr(cls) -> Literal["int", "poly", "power"]:
         r"""
-        The current finite field element representation. This can be changed with :func:`~galois.FieldArray.display`.
+        The current finite field element representation. This can be changed with :func:`~galois.FieldArray.repr`.
 
         See :doc:`/basic-usage/element-representation` for a further discussion.
 
         Examples
         --------
-        The default display mode is the integer representation.
+        The default element representation is the integer representation.
 
         .. ipython:: python
 
             GF = galois.GF(3**2)
             x = GF.elements; x
-            GF.display_mode
+            GF.element_repr
 
-        Permanently modify the display mode by calling :func:`~galois.FieldArray.display`.
+        Permanently modify the element representation by calling :func:`~galois.FieldArray.repr`.
 
         .. ipython:: python
 
-            GF.display("poly");
+            GF.repr("poly");
             x
-            GF.display_mode
+            GF.element_repr
             @suppress
-            GF.display()
+            GF.repr()
         """
-        return super().display_mode
+        return super().element_repr
 
     @property
     def ufunc_mode(cls) -> Literal["jit-lookup", "jit-calculate", "python-calculate"]:
diff --git a/src/galois/_fields/_primitive_element.py b/src/galois/_fields/_primitive_element.py
index a0250dfaa..03a323b6c 100644
--- a/src/galois/_fields/_primitive_element.py
+++ b/src/galois/_fields/_primitive_element.py
@@ -128,7 +128,7 @@ def primitive_element(irreducible_poly: Poly, method: Literal["min", "max", "ran
     .. ipython:: python
 
         f = galois.irreducible_poly(7, 5, method="max"); f
-        GF = galois.GF(7**5, irreducible_poly=f, display="poly")
+        GF = galois.GF(7**5, irreducible_poly=f, repr="poly")
         print(GF.properties)
 
     Find the smallest primitive element for the degree-5 extension of :math:`\mathrm{GF}(7)` with irreducible polynomial
@@ -161,7 +161,7 @@ def primitive_element(irreducible_poly: Poly, method: Literal["min", "max", "ran
         g = GF(int(g)); g
         g.multiplicative_order() == GF.order - 1
         @suppress
-        GF.display()
+        GF.repr()
     """
     verify_isinstance(irreducible_poly, Poly)
     if not irreducible_poly.degree > 1:
@@ -234,7 +234,7 @@ def primitive_elements(irreducible_poly: Poly) -> list[Poly]:
     .. ipython:: python
 
         f = galois.irreducible_poly(3, 4, method="max"); f
-        GF = galois.GF(3**4, irreducible_poly=f, display="poly")
+        GF = galois.GF(3**4, irreducible_poly=f, repr="poly")
         print(GF.properties)
 
     Find all primitive elements for the degree-4 extension of :math:`\mathrm{GF}(3)`.
@@ -258,7 +258,7 @@ def primitive_elements(irreducible_poly: Poly) -> list[Poly]:
         g = GF([int(gi) for gi in g]); g
         np.all(g.multiplicative_order() == GF.order - 1)
         @suppress
-        GF.display()
+        GF.repr()
     """
     # Find one primitive element first
     element = primitive_element(irreducible_poly)
diff --git a/src/galois/_options.py b/src/galois/_options.py
index e74bb7561..f186573f9 100644
--- a/src/galois/_options.py
+++ b/src/galois/_options.py
@@ -33,7 +33,7 @@ def set_printoptions(
 
     .. ipython:: python
 
-        GF = galois.GF(3**5, display="poly")
+        GF = galois.GF(3**5, repr="poly")
         a = GF([109, 83]); a
         f = galois.Poly([3, 0, 5, 2], field=galois.GF(7)); f
 
@@ -45,7 +45,7 @@ def set_printoptions(
         a
         f
         @suppress
-        GF.display()
+        GF.repr()
         @suppress
         galois.set_printoptions()
 
@@ -116,7 +116,7 @@ def printoptions(**kwargs) -> Generator[None, None, None]:
 
     .. ipython:: python
 
-        GF = galois.GF(3**5, display="poly")
+        GF = galois.GF(3**5, repr="poly")
         a = GF([109, 83])
         f = galois.Poly([3, 0, 5, 2], field=galois.GF(7))
 
@@ -129,7 +129,7 @@ def printoptions(**kwargs) -> Generator[None, None, None]:
             print(a); print(f)
         print(a); print(f)
         @suppress
-        GF.display()
+        GF.repr()
 
     :group: config
     """
diff --git a/src/galois/_polys/_conversions.py b/src/galois/_polys/_conversions.py
index 1c5ac30d0..5ff808c6e 100644
--- a/src/galois/_polys/_conversions.py
+++ b/src/galois/_polys/_conversions.py
@@ -89,8 +89,8 @@ def sparse_poly_to_str(degrees: list[int], coeffs: list[int], poly_var: str = "x
     """
     x = []
 
-    # Use brackets around coefficients only when using the "poly" or "power" display mode
-    brackets = hasattr(type(coeffs), "_display_mode") and getattr(type(coeffs), "_display_mode") in ["poly", "power"]
+    # Use brackets around coefficients only when using the "poly" or "power" element representation
+    brackets = hasattr(type(coeffs), "_element_repr") and getattr(type(coeffs), "_element_repr") in ["poly", "power"]
 
     for degree, coeff in zip(degrees, coeffs):
         if coeff == 0:
@@ -113,7 +113,7 @@ def sparse_poly_to_str(degrees: list[int], coeffs: list[int], poly_var: str = "x
                 c = f"{coeff!s}"
             s = f"{c}{poly_var}"
         else:
-            # Use () around 0-degree term only if it has a + separator in it ("poly" display mode)
+            # Use () around 0-degree term only if it has a + separator in it ("poly" element representation)
             if "+" in str(coeff):
                 s = f"({coeff!s})"
             else:


Test patch:
diff --git a/tests/fields/test_classes.py b/tests/fields/test_classes.py
index f62ba0a0d..b67f8f6c7 100644
--- a/tests/fields/test_classes.py
+++ b/tests/fields/test_classes.py
@@ -64,8 +64,7 @@ ATTRIBUTES = [
     "name", "characteristic", "degree", "order",
     "irreducible_poly", "is_primitive_poly", "primitive_element", "primitive_elements",
     "is_prime_field", "is_extension_field", "prime_subfield",
-    "dtypes", "display_mode",
-    "ufunc_mode", "ufunc_modes",
+    "dtypes", "element_repr", "ufunc_mode", "ufunc_modes",
 ]
 
 @pytest.mark.parametrize("attribute", ATTRIBUTES)
diff --git a/tests/fields/test_factory.py b/tests/fields/test_factory.py
index d676ba5b2..1605dede7 100644
--- a/tests/fields/test_factory.py
+++ b/tests/fields/test_factory.py
@@ -40,29 +40,29 @@ def test_can_modify_ufunc_mode():
     assert GF.ufunc_mode == "jit-lookup"
 
 
-def test_defaults_dont_modify_display_mode():
+def test_defaults_dont_modify_element_repr():
     """
-    Ensures display=None (the default) doesn't modify the current display mode.
+    Ensures repr=None (the default) doesn't modify the current element representation.
     """
     GF = galois.GF(2**8)
-    GF.display()  # Reset to default
-    assert GF.display_mode == "int"
-    GF.display("poly")
-    assert GF.display_mode == "poly"
+    GF.repr()  # Reset to default
+    assert GF.element_repr == "int"
+    GF.repr("poly")
+    assert GF.element_repr == "poly"
     GF = galois.GF(2**8)
-    assert GF.display_mode == "poly"
-    GF.display()    # Reset to default
-    assert GF.display_mode == "int"
+    assert GF.element_repr == "poly"
+    GF.repr()  # Reset to default
+    assert GF.element_repr == "int"
 
 
-def test_can_modify_display_mode():
+def test_can_modify_element_repr():
     GF = galois.GF(2**8)
-    GF.display()  # Reset to default
-    assert GF.display_mode == "int"
-    GF = galois.GF(2**8, display="poly")
-    assert GF.display_mode == "poly"
-    GF.display()    # Reset to default
-    assert GF.display_mode == "int"
+    GF.repr()  # Reset to default
+    assert GF.element_repr == "int"
+    GF = galois.GF(2**8, repr="poly")
+    assert GF.element_repr == "poly"
+    GF.repr()  # Reset to default
+    assert GF.element_repr == "int"
 
 
 def test_basic_exceptions():
@@ -73,14 +73,14 @@ def test_basic_exceptions():
     with pytest.raises(TypeError):
         galois.GF(2**8, compile=True)
     with pytest.raises(TypeError):
-        galois.GF(2**8, display=True)
+        galois.GF(2**8, repr=True)
 
     with pytest.raises(ValueError):
         galois.GF(2**3 * 5**3)
     with pytest.raises(ValueError):
         galois.GF(2**8, compile="invalid-argument")
     with pytest.raises(ValueError):
-        galois.GF(2**8, display="invalid-argument")
+        galois.GF(2**8, repr="invalid-argument")
 
 
 def test_irreducible_poly_exceptions():
diff --git a/tests/fields/test_methods.py b/tests/fields/test_methods.py
index eca0f9bb1..719fa6c62 100644
--- a/tests/fields/test_methods.py
+++ b/tests/fields/test_methods.py
@@ -18,21 +18,21 @@ def test_repr():
     assert repr(GF(2)) == "GF(2, order=2^3)"
     assert repr(GF([1, 0, 5, 2])) == "GF([1, 0, 5, 2], order=2^3)"
 
-    GF.display("poly")
+    GF.repr("poly")
     assert repr(GF(1)) == "GF(1, order=2^3)"
     assert repr(GF(0)) == "GF(0, order=2^3)"
     assert repr(GF(5)) == "GF(α^2 + 1, order=2^3)"
     assert repr(GF(2)) == "GF(α, order=2^3)"
     assert repr(GF([1, 0, 5, 2])) == "GF([      1,       0, α^2 + 1,       α], order=2^3)"
 
-    GF.display("power")
+    GF.repr("power")
     assert repr(GF(1)) == "GF(1, order=2^3)"
     assert repr(GF(0)) == "GF(0, order=2^3)"
     assert repr(GF(5)) == "GF(α^6, order=2^3)"
     assert repr(GF(2)) == "GF(α, order=2^3)"
     assert repr(GF([1, 0, 5, 2])) == "GF([  1,   0, α^6,   α], order=2^3)"
 
-    GF.display()
+    GF.repr()
     assert repr(GF(1)) == "GF(1, order=2^3)"
     assert repr(GF(0)) == "GF(0, order=2^3)"
     assert repr(GF(5)) == "GF(5, order=2^3)"
@@ -49,21 +49,21 @@ def test_str():
     assert str(GF(2)) == "2"
     assert str(GF([1, 0, 5, 2])) == "[1 0 5 2]"
 
-    GF.display("poly")
+    GF.repr("poly")
     assert str(GF(1)) == "1"
     assert str(GF(0)) == "0"
     assert str(GF(5)) == "α^2 + 1"
     assert str(GF(2)) == "α"
     assert str(GF([1, 0, 5, 2])) == "[      1       0 α^2 + 1       α]"
 
-    GF.display("power")
+    GF.repr("power")
     assert str(GF(1)) == "1"
     assert str(GF(0)) == "0"
     assert str(GF(5)) == "α^6"
     assert str(GF(2)) == "α"
     assert str(GF([1, 0, 5, 2])) == "[  1   0 α^6   α]"
 
-    GF.display()
+    GF.repr()
     assert str(GF(1)) == "1"
     assert str(GF(0)) == "0"
     assert str(GF(5)) == "5"
@@ -71,18 +71,18 @@ def test_str():
     assert str(GF([1, 0, 5, 2])) == "[1 0 5 2]"
 
 
-def test_display_context_manager():
+def test_repr_context_manager():
     GF = galois.GF(2**3)
     a = GF([1, 0, 5, 2])
 
     assert repr(a) == "GF([1, 0, 5, 2], order=2^3)"
     assert str(a) == "[1 0 5 2]"
 
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert repr(a) == "GF([      1,       0, α^2 + 1,       α], order=2^3)"
         assert str(a) == "[      1       0 α^2 + 1       α]"
 
-    with GF.display("power"):
+    with GF.repr("power"):
         assert repr(a) == "GF([  1,   0, α^6,   α], order=2^3)"
         assert str(a) == "[  1   0 α^6   α]"
 
@@ -90,12 +90,12 @@ def test_display_context_manager():
     assert str(a) == "[1 0 5 2]"
 
 
-def test_display_exceptions():
+def test_repr_exceptions():
     GF = galois.GF(2**3)
     a = GF([1, 0, 5, 2])
 
     with pytest.raises(ValueError):
-        GF.display("invalid-display-type")
+        GF.repr("invalid-display-type")
 
 
 def test_arithmetic_table_exceptions():
@@ -106,17 +106,17 @@ def test_arithmetic_table_exceptions():
 
 def test_arithmetic_table():
     GF = galois.GF(2**3)
-    with GF.display("int"):
+    with GF.repr("int"):
         assert GF.arithmetic_table("+") == "x + y | 0  1  2  3  4  5  6  7 \n------|------------------------\n    0 | 0  1  2  3  4  5  6  7 \n    1 | 1  0  3  2  5  4  7  6 \n    2 | 2  3  0  1  6  7  4  5 \n    3 | 3  2  1  0  7  6  5  4 \n    4 | 4  5  6  7  0  1  2  3 \n    5 | 5  4  7  6  1  0  3  2 \n    6 | 6  7  4  5  2  3  0  1 \n    7 | 7  6  5  4  3  2  1  0 "
         assert GF.arithmetic_table("-") == "x - y | 0  1  2  3  4  5  6  7 \n------|------------------------\n    0 | 0  1  2  3  4  5  6  7 \n    1 | 1  0  3  2  5  4  7  6 \n    2 | 2  3  0  1  6  7  4  5 \n    3 | 3  2  1  0  7  6  5  4 \n    4 | 4  5  6  7  0  1  2  3 \n    5 | 5  4  7  6  1  0  3  2 \n    6 | 6  7  4  5  2  3  0  1 \n    7 | 7  6  5  4  3  2  1  0 "
         assert GF.arithmetic_table("*") == "x * y | 0  1  2  3  4  5  6  7 \n------|------------------------\n    0 | 0  0  0  0  0  0  0  0 \n    1 | 0  1  2  3  4  5  6  7 \n    2 | 0  2  4  6  3  1  7  5 \n    3 | 0  3  6  5  7  4  1  2 \n    4 | 0  4  3  7  6  2  5  1 \n    5 | 0  5  1  4  2  7  3  6 \n    6 | 0  6  7  1  5  3  2  4 \n    7 | 0  7  5  2  1  6  4  3 "
         assert GF.arithmetic_table("/") == "x / y | 1  2  3  4  5  6  7 \n------|---------------------\n    0 | 0  0  0  0  0  0  0 \n    1 | 1  5  6  7  2  3  4 \n    2 | 2  1  7  5  4  6  3 \n    3 | 3  4  1  2  6  5  7 \n    4 | 4  2  5  1  3  7  6 \n    5 | 5  7  3  6  1  4  2 \n    6 | 6  3  2  4  7  1  5 \n    7 | 7  6  4  3  5  2  1 "
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert GF.arithmetic_table("+") == "      x + y |           0            1            α        α + 1          α^2      α^2 + 1      α^2 + α  α^2 + α + 1 \n------------|--------------------------------------------------------------------------------------------------------\n          0 |           0            1            α        α + 1          α^2      α^2 + 1      α^2 + α  α^2 + α + 1 \n          1 |           1            0        α + 1            α      α^2 + 1          α^2  α^2 + α + 1      α^2 + α \n          α |           α        α + 1            0            1      α^2 + α  α^2 + α + 1          α^2      α^2 + 1 \n      α + 1 |       α + 1            α            1            0  α^2 + α + 1      α^2 + α      α^2 + 1          α^2 \n        α^2 |         α^2      α^2 + 1      α^2 + α  α^2 + α + 1            0            1            α        α + 1 \n    α^2 + 1 |     α^2 + 1          α^2  α^2 + α + 1      α^2 + α            1            0        α + 1            α \n    α^2 + α |     α^2 + α  α^2 + α + 1          α^2      α^2 + 1            α        α + 1            0            1 \nα^2 + α + 1 | α^2 + α + 1      α^2 + α      α^2 + 1          α^2        α + 1            α            1            0 "
         assert GF.arithmetic_table("-") == "      x - y |           0            1            α        α + 1          α^2      α^2 + 1      α^2 + α  α^2 + α + 1 \n------------|--------------------------------------------------------------------------------------------------------\n          0 |           0            1            α        α + 1          α^2      α^2 + 1      α^2 + α  α^2 + α + 1 \n          1 |           1            0        α + 1            α      α^2 + 1          α^2  α^2 + α + 1      α^2 + α \n          α |           α        α + 1            0            1      α^2 + α  α^2 + α + 1          α^2      α^2 + 1 \n      α + 1 |       α + 1            α            1            0  α^2 + α + 1      α^2 + α      α^2 + 1          α^2 \n        α^2 |         α^2      α^2 + 1      α^2 + α  α^2 + α + 1            0            1            α        α + 1 \n    α^2 + 1 |     α^2 + 1          α^2  α^2 + α + 1      α^2 + α            1            0        α + 1            α \n    α^2 + α |     α^2 + α  α^2 + α + 1          α^2      α^2 + 1            α        α + 1            0            1 \nα^2 + α + 1 | α^2 + α + 1      α^2 + α      α^2 + 1          α^2        α + 1            α            1            0 "
         assert GF.arithmetic_table("*") == "      x * y |           0            1            α        α + 1          α^2      α^2 + 1      α^2 + α  α^2 + α + 1 \n------------|--------------------------------------------------------------------------------------------------------\n          0 |           0            0            0            0            0            0            0            0 \n          1 |           0            1            α        α + 1          α^2      α^2 + 1      α^2 + α  α^2 + α + 1 \n          α |           0            α          α^2      α^2 + α        α + 1            1  α^2 + α + 1      α^2 + 1 \n      α + 1 |           0        α + 1      α^2 + α      α^2 + 1  α^2 + α + 1          α^2            1            α \n        α^2 |           0          α^2        α + 1  α^2 + α + 1      α^2 + α            α      α^2 + 1            1 \n    α^2 + 1 |           0      α^2 + 1            1          α^2            α  α^2 + α + 1        α + 1      α^2 + α \n    α^2 + α |           0      α^2 + α  α^2 + α + 1            1      α^2 + 1        α + 1            α          α^2 \nα^2 + α + 1 |           0  α^2 + α + 1      α^2 + 1            α            1      α^2 + α          α^2        α + 1 "
         assert GF.arithmetic_table("/") == "      x / y |           1            α        α + 1          α^2      α^2 + 1      α^2 + α  α^2 + α + 1 \n------------|-------------------------------------------------------------------------------------------\n          0 |           0            0            0            0            0            0            0 \n          1 |           1      α^2 + 1      α^2 + α  α^2 + α + 1            α        α + 1          α^2 \n          α |           α            1  α^2 + α + 1      α^2 + 1          α^2      α^2 + α        α + 1 \n      α + 1 |       α + 1          α^2            1            α      α^2 + α      α^2 + 1  α^2 + α + 1 \n        α^2 |         α^2            α      α^2 + 1            1        α + 1  α^2 + α + 1      α^2 + α \n    α^2 + 1 |     α^2 + 1  α^2 + α + 1        α + 1      α^2 + α            1          α^2            α \n    α^2 + α |     α^2 + α        α + 1            α          α^2  α^2 + α + 1            1      α^2 + 1 \nα^2 + α + 1 | α^2 + α + 1      α^2 + α          α^2        α + 1      α^2 + 1            α            1 "
-    with GF.display("power"):
+    with GF.repr("power"):
         assert GF.arithmetic_table("+") == "x + y |   0    1    α  α^2  α^3  α^4  α^5  α^6 \n------|----------------------------------------\n    0 |   0    1    α  α^2  α^3  α^4  α^5  α^6 \n    1 |   1    0  α^3  α^6    α  α^5  α^4  α^2 \n    α |   α  α^3    0  α^4    1  α^2  α^6  α^5 \n  α^2 | α^2  α^6  α^4    0  α^5    α  α^3    1 \n  α^3 | α^3    α    1  α^5    0  α^6  α^2  α^4 \n  α^4 | α^4  α^5  α^2    α  α^6    0    1  α^3 \n  α^5 | α^5  α^4  α^6  α^3  α^2    1    0    α \n  α^6 | α^6  α^2  α^5    1  α^4  α^3    α    0 "
         assert GF.arithmetic_table("-") == "x - y |   0    1    α  α^2  α^3  α^4  α^5  α^6 \n------|----------------------------------------\n    0 |   0    1    α  α^2  α^3  α^4  α^5  α^6 \n    1 |   1    0  α^3  α^6    α  α^5  α^4  α^2 \n    α |   α  α^3    0  α^4    1  α^2  α^6  α^5 \n  α^2 | α^2  α^6  α^4    0  α^5    α  α^3    1 \n  α^3 | α^3    α    1  α^5    0  α^6  α^2  α^4 \n  α^4 | α^4  α^5  α^2    α  α^6    0    1  α^3 \n  α^5 | α^5  α^4  α^6  α^3  α^2    1    0    α \n  α^6 | α^6  α^2  α^5    1  α^4  α^3    α    0 "
         assert GF.arithmetic_table("*") == "x * y |   0    1    α  α^2  α^3  α^4  α^5  α^6 \n------|----------------------------------------\n    0 |   0    0    0    0    0    0    0    0 \n    1 |   0    1    α  α^2  α^3  α^4  α^5  α^6 \n    α |   0    α  α^2  α^3  α^4  α^5  α^6    1 \n  α^2 |   0  α^2  α^3  α^4  α^5  α^6    1    α \n  α^3 |   0  α^3  α^4  α^5  α^6    1    α  α^2 \n  α^4 |   0  α^4  α^5  α^6    1    α  α^2  α^3 \n  α^5 |   0  α^5  α^6    1    α  α^2  α^3  α^4 \n  α^6 |   0  α^6    1    α  α^2  α^3  α^4  α^5 "
diff --git a/tests/polys/test_conversions.py b/tests/polys/test_conversions.py
index 49277ac27..edea92a13 100644
--- a/tests/polys/test_conversions.py
+++ b/tests/polys/test_conversions.py
@@ -59,7 +59,7 @@ def test_sparse_poly_to_str():
     assert galois._polys._conversions.sparse_poly_to_str([3, 1, 0], [1, 1, 1], poly_var="y") == "y^3 + y + 1"
 
     GF = galois.GF(2**8)
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert galois._polys._conversions.sparse_poly_to_str([0], GF([0])) == "0"
         assert galois._polys._conversions.sparse_poly_to_str([3, 1, 0], GF([1, 2, 3])) == "x^3 + (α)x + (α + 1)"
 
diff --git a/tests/polys/test_operations.py b/tests/polys/test_operations.py
index 541634d71..2ca93d93b 100644
--- a/tests/polys/test_operations.py
+++ b/tests/polys/test_operations.py
@@ -66,25 +66,25 @@ def test_repr():
     GF = galois.GF2
     poly = galois.Poly([1, 0, 1, 1])
     assert repr(poly) == "Poly(x^3 + x + 1, GF(2))"
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert repr(poly) == "Poly(x^3 + x + 1, GF(2))"
-    with GF.display("power"):
+    with GF.repr("power"):
         assert repr(poly) == "Poly(x^3 + x + 1, GF(2))"
 
     GF = galois.GF(7)
     poly = galois.Poly([5, 0, 3, 1], field=GF)
     assert repr(poly) == "Poly(5x^3 + 3x + 1, GF(7))"
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert repr(poly) == "Poly((5)x^3 + (3)x + 1, GF(7))"
-    with GF.display("power"):
+    with GF.repr("power"):
         assert repr(poly) == "Poly((α^5)x^3 + (α)x + 1, GF(7))"
 
     GF = galois.GF(2**3)
     poly = galois.Poly([2, 0, 3, 1], field=GF)
     assert repr(poly) == "Poly(2x^3 + 3x + 1, GF(2^3))"
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert repr(poly) == "Poly((α)x^3 + (α + 1)x + 1, GF(2^3))"
-    with GF.display("power"):
+    with GF.repr("power"):
         assert repr(poly) == "Poly((α)x^3 + (α^3)x + 1, GF(2^3))"
 
 
@@ -92,25 +92,25 @@ def test_str():
     GF = galois.GF2
     poly = galois.Poly([1, 0, 1, 1])
     assert str(poly) == "x^3 + x + 1"
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert str(poly) == "x^3 + x + 1"
-    with GF.display("power"):
+    with GF.repr("power"):
         assert str(poly) == "x^3 + x + 1"
 
     GF = galois.GF(7)
     poly = galois.Poly([5, 0, 3, 1], field=GF)
     assert str(poly) == "5x^3 + 3x + 1"
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert str(poly) == "(5)x^3 + (3)x + 1"
-    with GF.display("power"):
+    with GF.repr("power"):
         assert str(poly) == "(α^5)x^3 + (α)x + 1"
 
     GF = galois.GF(2**3)
     poly = galois.Poly([2, 0, 3, 5], field=GF)
     assert str(poly) == "2x^3 + 3x + 5"
-    with GF.display("poly"):
+    with GF.repr("poly"):
         assert str(poly) == "(α)x^3 + (α + 1)x + (α^2 + 1)"
-    with GF.display("power"):
+    with GF.repr("power"):
         assert str(poly) == "(α)x^3 + (α^3)x + α^6"
 
 
diff --git a/tests/test_options.py b/tests/test_options.py
index 2db8915de..302c6696f 100644
--- a/tests/test_options.py
+++ b/tests/test_options.py
@@ -22,7 +22,7 @@ def test_set_exceptions():
 
 
 def test_set_coeffs():
-    GF = galois.GF(3**5, display="poly")
+    GF = galois.GF(3**5, repr="poly")
     a = GF(83)
     f = galois.Poly([3, 0, 5, 2], field=galois.GF(7))
 
@@ -41,7 +41,7 @@ def test_set_coeffs():
 
 
 def test_context_manager():
-    GF = galois.GF(3**5, display="poly")
+    GF = galois.GF(3**5, repr="poly")
     a = GF(83)
     f = galois.Poly([3, 0, 5, 2], field=galois.GF(7))
     galois.set_printoptions()  # Ensure the default options are set