class_docstr: Finite field of prime order :ref:`GF(p)`
  
  A :ref:`GF(p)` domain represents a `finite field`_ `\mathbb{F}_p` of prime
  order as :py:class:`~.Domain` in the domain system (see
  :ref:`polys-domainsintro`).
  
  A :py:class:`~.Poly` created from an expression with integer
  coefficients will have the domain :ref:`ZZ`. However, if the ``modulus=p``
  option is given then the domain will be a finite field instead.
  
  >>> from sympy import Poly, Symbol
  >>> x = Symbol('x')
  >>> p = Poly(x**2 + 1)
  >>> p
  Poly(x**2 + 1, x, domain='ZZ')
  >>> p.domain
  ZZ
  >>> p2 = Poly(x**2 + 1, modulus=2)
  >>> p2
  Poly(x**2 + 1, x, modulus=2)
  >>> p2.domain
  GF(2)
  
  It is possible to factorise a polynomial over :ref:`GF(p)` using the
  modulus argument to :py:func:`~.factor` or by specifying the domain
  explicitly. The domain can also be given as a string.
  
  >>> from sympy import factor, GF
  >>> factor(x**2 + 1)
  x**2 + 1
  >>> factor(x**2 + 1, modulus=2)
  (x + 1)**2
  >>> factor(x**2 + 1, domain=GF(2))
  (x + 1)**2
  >>> factor(x**2 + 1, domain='GF(2)')
  (x + 1)**2
  
  It is also possible to use :ref:`GF(p)` with the :py:func:`~.cancel`
  and :py:func:`~.gcd` functions.
  
  >>> from sympy import cancel, gcd
  >>> cancel((x**2 + 1)/(x + 1))
  (x**2 + 1)/(x + 1)
  >>> cancel((x**2 + 1)/(x + 1), domain=GF(2))
  x + 1
  >>> gcd(x**2 + 1, x + 1)
  1
  >>> gcd(x**2 + 1, x + 1, domain=GF(2))
  x + 1
  
  When using the domain directly :ref:`GF(p)` can be used as a constructor
  to create instances which then support the operations ``+,-,*,**,/``
  
  >>> from sympy import GF
  >>> K = GF(5)
  >>> K
  GF(5)
  >>> x = K(3)
  >>> y = K(2)
  >>> x
  3 mod 5
  >>> y
  2 mod 5
  >>> x * y
  1 mod 5
  >>> x / y
  4 mod 5
  
  Notes
  =====
  
  It is also possible to create a :ref:`GF(p)` domain of **non-prime**
  order but the resulting ring is **not** a field: it is just the ring of
  the integers modulo ``n``.
  
  >>> K = GF(9)
  >>> z = K(3)
  >>> z
  3 mod 9
  >>> z**2
  0 mod 9
  
  It would be good to have a proper implementation of prime power fields
  (``GF(p**n)``) but these are not yet implemented in SymPY.
  
  .. _finite field: https://en.wikipedia.org/wiki/Finite_field
docstr: Returns True if ``a`` is negative. 
code: def is_negative(self, a):
      """Returns True if ``a`` is negative."""
      return False
  
imports: from sympy.external.gmpy import GROUND_TYPES
  from sympy.core.numbers import int_valued
  from sympy.polys.domains.field import Field
  from sympy.polys.domains.modularinteger import ModularIntegerFactory
  from sympy.polys.domains.simpledomain import SimpleDomain
  from sympy.polys.galoistools import gf_zassenhaus, gf_irred_p_rabin
  from sympy.polys.polyerrors import CoercionFailed
  from sympy.utilities import public
  from sympy.polys.domains.groundtypes import SymPyInteger
label_desc: Use image node_id 13 for calling the FiniteField obj's underlying member method code with example usage: obj.is_negative(a) and returns: False