### Navigation

- index
- modules |
- next |
- previous |
- Basic Structures »

# Factorizations

The `Factorization` class provides a structure for holding quite general lists of objects with integer multiplicities. These may hold the results of an arithmetic or algebraic factorization, where the objects may be primes or irreducible polynomials and the multiplicities are the (non-zero) exponents in the factorization. For other types of examples, see below.

`Factorization` class objects contain a `list`, so can be printed nicely and be manipulated like a list of prime-exponent pairs, or easily turned into a plain list. For example, we factor the integer \(-45\):

    sage: F = factor(-45)

This returns an object of type `Factorization`:

    sage: type(F)
    <class 'sage.structure.factorization_integer.IntegerFactorization'>

It prints in a nice factored form:

    sage: F
    -1 * 3^2 * 5

There is an underlying list representation, emph{which ignores the unit part}:

    sage: list(F)
    [(3, 2), (5, 1)]

A `Factorization` is not actually a list:

    sage: isinstance(F, list)
    False

However, we can access the `Factorization` F itself as if it were a list:

    sage: F[0]
    (3, 2)
    sage: F[1]
    (5, 1)

To get at the unit part, use the `Factorization.unit()` function:

    sage: F.unit()
    -1

All factorizations are immutable, up to ordering with `sort()` and simplifying with `simplify()`. Thus if you write a function that returns a cached version of a factorization, you do not have to return a copy.

    sage: F = factor(-12); F
    -1 * 2^2 * 3
    sage: F[0] = (5,4)
    Traceback (most recent call last):
    ...
    TypeError: 'Factorization' object does not support item assignment

EXAMPLES:

This more complicated example involving polynomials also illustrates that the unit part is not discarded from factorizations:

    sage: x = QQ['x'].0
    sage: f = -5*(x-2)*(x-3)
    sage: f
    -5*x^2 + 25*x - 30
    sage: F = f.factor(); F
    (-5) * (x - 3) * (x - 2)
    sage: F.unit()
    -5
    sage: F.value()
    -5*x^2 + 25*x - 30

The underlying list is the list of pairs \((p_i, e_i)\), where each \(p_i\) is a ‘prime’ and each \(e_i\) is an integer. The unit part is discarded by the list:

    sage: list(F)
    [(x - 3, 1), (x - 2, 1)]
    sage: len(F)
    2
    sage: F[1]
    (x - 2, 1)

In the ring \(\ZZ[x]\), the integer \(-5\) is not a unit, so the factorization has three factors:

    sage: x = ZZ['x'].0
    sage: f = -5*(x-2)*(x-3)
    sage: f
    -5*x^2 + 25*x - 30
    sage: F = f.factor(); F
    (-1) * 5 * (x - 3) * (x - 2)
    sage: F.universe()
    Univariate Polynomial Ring in x over Integer Ring
    sage: F.unit()
    -1
    sage: list(F)
    [(5, 1), (x - 3, 1), (x - 2, 1)]
    sage: F.value()
    -5*x^2 + 25*x - 30
    sage: len(F)
    3

On the other hand, -1 is a unit in \(\ZZ\), so it is included in the unit:

    sage: x = ZZ['x'].0
    sage: f = -1*(x-2)*(x-3)
    sage: F = f.factor(); F
    (-1) * (x - 3) * (x - 2)
    sage: F.unit()
    -1
    sage: list(F)
    [(x - 3, 1), (x - 2, 1)]

Factorizations can involve fairly abstract mathematical objects:

    sage: F = ModularSymbols(11,4).factorization()
    sage: F
    (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 6 for Gamma_0(11) of weight 4 with sign 0 over Rational Field) *
    (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 6 for Gamma_0(11) of weight 4 with sign 0 over Rational Field) *
    (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 6 for Gamma_0(11) of weight 4 with sign 0 over Rational Field)
    sage: type(F)
    <class 'sage.structure.factorization.Factorization'>

    sage: K.<a> = NumberField(x^2 + 3); K
    Number Field in a with defining polynomial x^2 + 3
    sage: f = K.factor(15); f
    (Fractional ideal (-a))^2 * (Fractional ideal (5))
    sage: f.universe()
    Monoid of ideals of Number Field in a with defining polynomial x^2 + 3
    sage: f.unit()
    Fractional ideal (1)
    sage: g=K.factor(9); g
    (Fractional ideal (-a))^4
    sage: f.lcm(g)
    (Fractional ideal (-a))^4 * (Fractional ideal (5))
    sage: f.gcd(g)
    (Fractional ideal (-a))^2
    sage: f.is_integral()
    True

TESTS:

    sage: F = factor(-20); F
    -1 * 2^2 * 5
    sage: G = loads(dumps(F)); G
    -1 * 2^2 * 5
    sage: G == F
    True
    sage: G is F
    False

AUTHORS:

- William Stein (2006-01-22): added unit part as suggested by David Kohel.
- William Stein (2008-01-17): wrote much of the documentation and fixed a couple of bugs.
- Nick Alexander (2008-01-19): added support for non-commuting factors.
- John Cremona (2008-08-22): added division, lcm, gcd, is_integral and universe functions

class `sage.structure.factorization.``Factorization`(x, unit=None, cr=False, sort=True, simplify=True)

  Bases: `sage.structure.sage_object.SageObject`

  A formal factorization of an object.

  EXAMPLES:

      sage: N = 2006
      sage: F = N.factor(); F
      2 * 17 * 59
      sage: F.unit()
      1
      sage: F = factor(-2006); F
      -1 * 2 * 17 * 59
      sage: F.unit()
      -1
      sage: loads(F.dumps()) == F
      True
      sage: F = Factorization([(x,1/3)])
      Traceback (most recent call last):
      ...
      TypeError: exponents of factors must be integers

  `base_change`(U)

    Return the factorization self, with its factors (including the unit part) coerced into the universe \(U\).

    EXAMPLES:

        sage: F = factor(2006)
        sage: F.universe()
        Integer Ring
        sage: P.<x> = ZZ[]
        sage: F.base_change(P).universe()
        Univariate Polynomial Ring in x over Integer Ring

    This method will return a TypeError if the coercion is not possible:

        sage: g = x^2 - 1
        sage: F = factor(g); F
        (x - 1) * (x + 1)
        sage: F.universe()
        Univariate Polynomial Ring in x over Integer Ring
        sage: F.base_change(ZZ)
        Traceback (most recent call last):
        ...
        TypeError: Impossible to coerce the factors of (x - 1) * (x + 1) into Integer Ring

  `expand`()

    Return the product of the factors in the factorization, multiplied out.

    EXAMPLES:

        sage: F = factor(-2006); F
        -1 * 2 * 17 * 59
        sage: F.value()
        -2006

        sage: R.<x,y> = FreeAlgebra(ZZ, 2)
        sage: F = Factorization([(x,3), (y, 2), (x,1)]); F
        x^3 * y^2 * x
        sage: F.value()
        x^3*y^2*x

  `gcd`(other)

    Return the gcd of two factorizations.

    If the two factorizations have different universes, this method will attempt to find a common universe for the gcd. A TypeError is raised if this is impossible.

    EXAMPLES:

        sage: factor(-30).gcd(factor(-160))
        2 * 5
        sage: factor(gcd(-30,160))
        2 * 5

        sage: R.<x> = ZZ[]
        sage: (factor(-20).gcd(factor(5*x+10))).universe()
        Univariate Polynomial Ring in x over Integer Ring

  `is_commutative`()

    Return True if my factors commute.

    EXAMPLES:

        sage: F = factor(2006)
        sage: F.is_commutative()
        True
        sage: K = QuadraticField(23, 'a')
        sage: F = K.factor(13)
        sage: F.is_commutative()
        True
        sage: R.<x,y,z> = FreeAlgebra(QQ, 3)
        sage: F = Factorization([(z, 2)], 3)
        sage: F.is_commutative()
        False
        sage: (F*F^-1).is_commutative()
        False

  `is_integral`()

    Return True iff all exponents of this Factorization are non-negative.

    EXAMPLES:

        sage: F = factor(-10); F
        -1 * 2 * 5
        sage: F.is_integral()
        True

        sage: F = factor(-10) / factor(16); F
        -1 * 2^-3 * 5
        sage: F.is_integral()
        False

  `lcm`(other)

    Return the lcm of two factorizations.

    If the two factorizations have different universes, this method will attempt to find a common universe for the lcm. A TypeError is raised if this is impossible.

    EXAMPLES:

        sage: factor(-10).lcm(factor(-16))
        2^4 * 5
        sage: factor(lcm(-10,16))
        2^4 * 5

        sage: R.<x> = ZZ[]
        sage: (factor(-20).lcm(factor(5*x+10))).universe()
        Univariate Polynomial Ring in x over Integer Ring

  `prod`()

    Return the product of the factors in the factorization, multiplied out.

    EXAMPLES:

        sage: F = factor(-2006); F
        -1 * 2 * 17 * 59
        sage: F.value()
        -2006

        sage: R.<x,y> = FreeAlgebra(ZZ, 2)
        sage: F = Factorization([(x,3), (y, 2), (x,1)]); F
        x^3 * y^2 * x
        sage: F.value()
        x^3*y^2*x

  `radical`()

    Return the factorization of the radical of the value of self.

    First, check that all exponents in the factorization are positive, raise ValueError otherwise. If all exponents are positive, return self with all exponents set to 1 and with the unit set to 1.

    EXAMPLES:

        sage: F = factor(-100); F
        -1 * 2^2 * 5^2
        sage: F.radical()
        2 * 5
        sage: factor(1/2).radical()
        Traceback (most recent call last):
        ...
        ValueError: All exponents in the factorization must be positive.

  `radical_value`()

    Return the product of the prime factors in self.

    First, check that all exponents in the factorization are positive, raise ValueError otherwise. If all exponents are positive, return the product of the prime factors in self. This should be functionally equivalent to self.radical().value()

    EXAMPLES:

        sage: F = factor(-100); F
        -1 * 2^2 * 5^2
        sage: F.radical_value()
        10
        sage: factor(1/2).radical_value()
        Traceback (most recent call last):
        ...
        ValueError: All exponents in the factorization must be positive.

  `simplify`()

    Combine adjacent products as much as possible.

    TESTS:

        sage: R.<x,y> = FreeAlgebra(ZZ, 2)
        sage: F = Factorization([(x,3), (y, 2), (y,2)], simplify=False); F
        x^3 * y^2 * y^2
        sage: F.simplify(); F
        x^3 * y^4
        sage: F * Factorization([(y, -2)], 2)
        (2) * x^3 * y^2

  `sort`(_cmp=None)

    Sort the factors in this factorization.

    INPUT:

    - `_cmp` - (default: None) comparison function

    OUTPUT:

    - changes this factorization to be sorted

    If _cmp is None, we determine the comparison function as follows: If the prime in the first factor has a dimension method, then we sort based first on dimension then on the exponent. If there is no dimension method, we next attempt to sort based on a degree method, in which case, we sort based first on degree, then exponent to break ties when two factors have the same degree, and if those match break ties based on the actual prime itself. If there is no degree method, we sort based on dimension.

    EXAMPLES:

    We create a factored polynomial:

        sage: x = polygen(QQ,'x')
        sage: F = factor(x^3 + 1); F
        (x + 1) * (x^2 - x + 1)

    Then we sort it but using the negated version of the standard Python cmp function:

        sage: F.sort(_cmp = lambda x,y: -cmp(x,y))
        sage: F
        (x^2 - x + 1) * (x + 1)

  `unit`()

    Return the unit part of this factorization.

    EXAMPLES:

    We create a polynomial over the real double field and factor it:

        sage: x = polygen(RDF, 'x')
        sage: F = factor(-2*x^2 - 1); F
        (-2.0) * (x^2 + 0.5000000000000001)

    Note that the unit part of the factorization is \(-2.0\):

        sage: F.unit()
        -2.0

        sage: F = factor(-2006); F
        -1 * 2 * 17 * 59
        sage: F.unit()
        -1

  `universe`()

    Return the parent structure of my factors.

    Note

    This used to be called `base_ring`, but the universe of a factorization need not be a ring.

    EXAMPLES:

        sage: F = factor(2006)
        sage: F.universe()
        Integer Ring

        sage: R.<x,y,z> = FreeAlgebra(QQ, 3)
        sage: F = Factorization([(z, 2)], 3)
        sage: (F*F^-1).universe()
        Free Algebra on 3 generators (x, y, z) over Rational Field

        sage: F = ModularSymbols(11,4).factorization()
        sage: F.universe()

  `value`()

    Return the product of the factors in the factorization, multiplied out.

    EXAMPLES:

        sage: F = factor(-2006); F
        -1 * 2 * 17 * 59
        sage: F.value()
        -2006

        sage: R.<x,y> = FreeAlgebra(ZZ, 2)
        sage: F = Factorization([(x,3), (y, 2), (x,1)]); F
        x^3 * y^2 * x
        sage: F.value()
        x^3*y^2*x

### Navigation

- index
- modules |
- next |
- previous |
- Basic Structures »