### Navigation

- index
- modules |
- next |
- previous |
- Modules »

# Elements of finitely generated modules over a PID

AUTHOR:
  - William Stein, 2009

class `sage.modules.fg_pid.fgp_element.``FGP_Element`(parent, x, check=True)

  Bases: `sage.structure.element.ModuleElement`

  An element of a finitely generated module over a PID.

  INPUT:

  - `parent` – parent module M
  - `x` – element of M.V()

  EXAMPLES:

      sage: V = span([[1/2,1,1],[3/2,2,1],[0,0,1]],ZZ); W = V.span([2*V.0+4*V.1, 9*V.0+12*V.1, 4*V.2])
      sage: Q = V/W
      sage: x = Q(V.0-V.1); x #indirect doctest
      (0, 3)
      sage: isinstance(x, sage.modules.fg_pid.fgp_element.FGP_Element)
      True
      sage: type(x)
      <class 'sage.modules.fg_pid.fgp_element.FGP_Module_class_with_category.element_class'>
      sage: x is Q(x)
      True
      sage: x.parent() is Q
      True

  TESTS:

      sage: V = span([[1/2,1,1],[3/2,2,1],[0,0,1]],ZZ); W = V.span([2*V.0+4*V.1, 9*V.0+12*V.1, 4*V.2]); Q = V/W
      sage: loads(dumps(Q.0)) == Q.0
      True

  `additive_order`()

    Return the additive order of this element.

    EXAMPLES:

        sage: V = span([[1/2,1,1],[3/2,2,1],[0,0,1]],ZZ); W = V.span([2*V.0+4*V.1, 9*V.0+12*V.1, 4*V.2])
        sage: Q = V/W; Q
        Finitely generated module V/W over Integer Ring with invariants (4, 12)
        sage: Q.0.additive_order()
        4
        sage: Q.1.additive_order()
        12
        sage: (Q.0+Q.1).additive_order()
        12
        sage: V = span([[1/2,1,1],[3/2,2,1],[0,0,1]],ZZ); W = V.span([2*V.0+4*V.1, 9*V.0+12*V.1])
        sage: Q = V/W; Q
        Finitely generated module V/W over Integer Ring with invariants (12, 0)
        sage: Q.0.additive_order()
        12
        sage: type(Q.0.additive_order())
        <type 'sage.rings.integer.Integer'>
        sage: Q.1.additive_order()
        +Infinity

  `lift`()

    Lift self to an element of V, where the parent of self is the quotient module V/W.

    EXAMPLES:

        sage: V = span([[1/2,0,0],[3/2,2,1],[0,0,1]],ZZ); W = V.span([2*V.0+4*V.1, 9*V.0+12*V.1, 4*V.2])
        sage: Q = V/W; Q
        Finitely generated module V/W over Integer Ring with invariants (4, 12)
        sage: Q.0
        (1, 0)
        sage: Q.1
        (0, 1)
        sage: Q.0.lift()
        (0, 0, 1)
        sage: Q.1.lift()
        (0, 2, 0)
        sage: x = Q(V.0); x
        (0, 4)
        sage: x.lift()
        (1/2, 0, 0)
        sage: x == 4*Q.1
        True
        sage: x.lift().parent() == V
        True

    A silly version of the integers modulo 100:

        sage: A = (ZZ^1)/span([[100]], ZZ); A
        Finitely generated module V/W over Integer Ring with invariants (100)
        sage: x = A([5]); x
        doctest:...: DeprecationWarning: The default behaviour changed!
         If you *really* want a linear combination of smith generators,
         use .linear_combination_of_smith_form_gens.
        See http://trac.sagemath.org/16261 for details.
        (5)
        sage: v = x.lift(); v
        (5)
        sage: v.parent()
        Ambient free module of rank 1 over the principal ideal domain Integer Ring

  `vector`()

    EXAMPLES:

        sage: V = span([[1/2,0,0],[3/2,2,1],[0,0,1]],ZZ); W = V.span([2*V.0+4*V.1, 9*V.0+12*V.1, 4*V.2])
        sage: Q = V/W; Q
        Finitely generated module V/W over Integer Ring with invariants (4, 12)
        sage: x = Q.0 + 3*Q.1; x
        (1, 3)
        sage: x.vector()
        (1, 3)
        sage: tuple(x)
        (1, 3)
        sage: list(x)
        [1, 3]
        sage: x.vector().parent()
        Ambient free module of rank 2 over the principal ideal domain Integer Ring

### Navigation

- index
- modules |
- next |
- previous |
- Modules »