Finite Homogeneous Sequences - Parents and Elements

Skip to content
Back to top
View this page
Edit this page

# Finite Homogeneous Sequences

A mutable sequence of elements with a common guaranteed category, which can be set immutable.

Sequence derives from list, so has all the functionality of lists and can be used wherever lists are used. When a sequence is created without explicitly given the common universe of the elements, the constructor coerces the first and second element to some canonical common parent, if possible, then the second and third, etc. If this is possible, it then coerces everything into the canonical parent at the end. (Note that canonical coercion is very restrictive.) The sequence then has a function `universe()` which returns either the common canonical parent (if the coercion succeeded), or the category of all objects (Objects()). So if you have a list \(v\) and type:

Sage

    sage: v = [1, 2/3, 5]
    sage: w = Sequence(v)
    sage: w.universe()
    Rational Field

Python

    >>> from sage.all import *
    >>> v = [Integer(1), Integer(2)/Integer(3), Integer(5)]
    >>> w = Sequence(v)
    >>> w.universe()
    Rational Field

then since `w.universe()` is \(\QQ\), you’re guaranteed that all elements of \(w\) are rationals:

Sage

    sage: v[0].parent()
    Integer Ring
    sage: w[0].parent()
    Rational Field

[Python]

    >>> from sage.all import *
    >>> v[Integer(0)].parent()
    Integer Ring
    >>> w[Integer(0)].parent()
    Rational Field

If you do assignment to \(w\) this property of being rationals is guaranteed to be preserved:

Sage

    sage: w[0] = 2
    sage: w[0].parent()
    Rational Field
    sage: w[0] = 'hi'
    Traceback (most recent call last):
    ...
    TypeError: unable to convert 'hi' to a rational

Python

    >>> from sage.all import *
    >>> w[Integer(0)] = Integer(2)
    >>> w[Integer(0)].parent()
    Rational Field
    >>> w[Integer(0)] = 'hi'
    Traceback (most recent call last):
    ...
    TypeError: unable to convert 'hi' to a rational

However, if you do `w = Sequence(v)` and the resulting universe is `Objects()`, the elements are not guaranteed to have any special parent. This is what should happen, e.g., with finite field elements of different characteristics:

Sage

    sage: v = Sequence([GF(3)(1), GF(7)(1)])
    sage: v.universe()
    Category of objects

[Python]

    >>> from sage.all import *
    >>> v = Sequence([GF(Integer(3))(Integer(1)), GF(Integer(7))(Integer(1))])
    >>> v.universe()
    Category of objects

You can make a list immutable with `v.freeze()`. Assignment is never again allowed on an immutable list.

Creation of a sequence involves making a copy of the input list, and substantial coercions. It can be greatly sped up by explicitly specifying the universe of the sequence:

Sage

    sage: v = Sequence(range(10000), universe=ZZ)

Python

    >>> from sage.all import *
    >>> v = Sequence(range(Integer(10000)), universe=ZZ)

sage.structure.sequence.Sequence(x, universe=None, check=True, immutable=False, cr=False, cr_str=None, use_sage_types=False)

  A mutable list of elements with a common guaranteed universe, which can be set immutable.

  A universe is either an object that supports coercion (e.g., a parent), or a category.

  INPUT:

  - `x` – list or tuple instance

  - `universe` – (default: `None`) the universe of elements; if `None` determined using canonical coercions and the entire list of elements. If list is empty, is category `Objects()` of all objects.

  - `check` – boolean (default: `True`); whether to coerce the elements of x into the universe

  - `immutable` – boolean (default: `True`); whether or not this sequence is immutable

  - `cr` – boolean (default: `False`); if `True`, then print a carriage return after each comma when calling `repr()` on this sequence (see note below)

  - `cr_str` – boolean (default: same as `cr`); if `True`, then print a carriage return after each comma when calling `str()` on this sequence (see note below)

  - `use_sage_types` – boolean (default: `False`); if `True`, coerce the built-in Python numerical types int, float, complex to the corresponding Sage types (this makes functions like `vector()` more flexible)

  OUTPUT: a sequence

  EXAMPLES:

  Sage

      sage: v = Sequence(range(10))
      sage: v.universe()
      <class 'int'>
      sage: v
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  Python

      >>> from sage.all import *
      >>> v = Sequence(range(Integer(10)))
      >>> v.universe()
      <class 'int'>
      >>> v
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  We can request that the built-in Python numerical types be coerced to Sage objects:

  Sage

      sage: v = Sequence(range(10), use_sage_types=True)
      sage: v.universe()
      Integer Ring
      sage: v
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  [Python]

      >>> from sage.all import *
      >>> v = Sequence(range(Integer(10)), use_sage_types=True)
      >>> v.universe()
      Integer Ring
      >>> v
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  You can also use seq for “Sequence”, which is identical to using Sequence:

  Sage

      sage: v = seq([1,2,1/1]); v
      [1, 2, 1]
      sage: v.universe()
      Rational Field

  Python

      >>> from sage.all import *
      >>> v = seq([Integer(1),Integer(2),Integer(1)/Integer(1)]); v
      [1, 2, 1]
      >>> v.universe()
      Rational Field

  Note that assignment coerces if possible,:

  Sage

      sage: v = Sequence(range(10), ZZ)
      sage: a = QQ(5)
      sage: v[3] = a
      sage: parent(v[3])
      Integer Ring
      sage: parent(a)
      Rational Field
      sage: v[3] = 2/3
      Traceback (most recent call last):
      ...
      TypeError: no conversion of this rational to integer

  [Python]

      >>> from sage.all import *
      >>> v = Sequence(range(Integer(10)), ZZ)
      >>> a = QQ(Integer(5))
      >>> v[Integer(3)] = a
      >>> parent(v[Integer(3)])
      Integer Ring
      >>> parent(a)
      Rational Field
      >>> v[Integer(3)] = Integer(2)/Integer(3)
      Traceback (most recent call last):
      ...
      TypeError: no conversion of this rational to integer

  Sequences can be used absolutely anywhere lists or tuples can be used:

  Sage

      sage: isinstance(v, list)
      True

  Python

      >>> from sage.all import *
      >>> isinstance(v, list)
      True

  Sequence can be immutable, so entries can’t be changed:

  Sage

      sage: v = Sequence([1,2,3], immutable=True)
      sage: v.is_immutable()
      True
      sage: v[0] = 5
      Traceback (most recent call last):
      ...
      ValueError: object is immutable; please change a copy instead.

  [Python]

      >>> from sage.all import *
      >>> v = Sequence([Integer(1),Integer(2),Integer(3)], immutable=True)
      >>> v.is_immutable()
      True
      >>> v[Integer(0)] = Integer(5)
      Traceback (most recent call last):
      ...
      ValueError: object is immutable; please change a copy instead.

  Only immutable sequences are hashable (unlike Python lists), though the hashing is potentially slow, since it first involves conversion of the sequence to a tuple, and returning the hash of that.:

  Sage

      sage: v = Sequence(range(10), ZZ, immutable=True)
      sage: hash(v) == hash(tuple(range(10)))
      True

  Python

      >>> from sage.all import *
      >>> v = Sequence(range(Integer(10)), ZZ, immutable=True)
      >>> hash(v) == hash(tuple(range(Integer(10))))
      True

  If you really know what you are doing, you can circumvent the type checking (for an efficiency gain):

  Sage

      sage: list.__setitem__(v, int(1), 2/3)        # bad circumvention
      sage: v
      [0, 2/3, 2, 3, 4, 5, 6, 7, 8, 9]
      sage: list.__setitem__(v, int(1), int(2))     # not so bad circumvention

  [Python]

      >>> from sage.all import *
      >>> list.__setitem__(v, int(Integer(1)), Integer(2)/Integer(3))        # bad circumvention
      >>> v
      [0, 2/3, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> list.__setitem__(v, int(Integer(1)), int(Integer(2)))     # not so bad circumvention

  You can make a sequence with a new universe from an old sequence.:

  Sage

      sage: w = Sequence(v, QQ)
      sage: w
      [0, 2, 2, 3, 4, 5, 6, 7, 8, 9]
      sage: w.universe()
      Rational Field
      sage: w[1] = 2/3
      sage: w
      [0, 2/3, 2, 3, 4, 5, 6, 7, 8, 9]

  Python

      >>> from sage.all import *
      >>> w = Sequence(v, QQ)
      >>> w
      [0, 2, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> w.universe()
      Rational Field
      >>> w[Integer(1)] = Integer(2)/Integer(3)
      >>> w
      [0, 2/3, 2, 3, 4, 5, 6, 7, 8, 9]

  The default universe for any sequence, if no compatible parent structure can be found, is the universe of all Sage objects.

  This example illustrates how every element of a list is taken into account when constructing a sequence.:

  Sage

      sage: v = Sequence([1, 7, 6, GF(5)(3)]); v
      [1, 2, 1, 3]
      sage: v.universe()
      Finite Field of size 5

  [Python]

      >>> from sage.all import *
      >>> v = Sequence([Integer(1), Integer(7), Integer(6), GF(Integer(5))(Integer(3))]); v
      [1, 2, 1, 3]
      >>> v.universe()
      Finite Field of size 5

  Note

  `cr` and `cr_str` is not recommended (because IPython’s pretty printer is used); nevertheless it is kept for backwards compatibility.

  By default `Sequence` are printed using IPython’s pretty printer, so `cr` and `cr_str` are not taken into account at all:

  Sage

      sage: Sequence([1, 2, 3], cr=False)
      [1, 2, 3]
      sage: Sequence([1, 2, 3], cr=True)
      [1, 2, 3]

  Python

      >>> from sage.all import *
      >>> Sequence([Integer(1), Integer(2), Integer(3)], cr=False)
      [1, 2, 3]
      >>> Sequence([Integer(1), Integer(2), Integer(3)], cr=True)
      [1, 2, 3]

  Nevertheless, before the pretty printer exists, `repr()` is used. Now `cr` and `cr_str` still affects the behavior of `repr()` and `str()`:

  Sage

      sage: repr(Sequence([1, 2, 3], cr=False))
      '[1, 2, 3]'
      sage: repr(Sequence([1, 2, 3], cr=True))
      '[\n1,\n2,\n3\n]'

  [Python]

      >>> from sage.all import *
      >>> repr(Sequence([Integer(1), Integer(2), Integer(3)], cr=False))
      '[1, 2, 3]'
      >>> repr(Sequence([Integer(1), Integer(2), Integer(3)], cr=True))
      '[\n1,\n2,\n3\n]'

  In any case, this behavior should probably not be relied upon.

class sage.structure.sequence.Sequence_generic(x, universe=None, check=True, immutable=False, cr=False, cr_str=None, use_sage_types=False)

  Bases: `SageObject`, `list`

  A mutable list of elements with a common guaranteed universe, which can be set immutable.

  A universe is either an object that supports coercion (e.g., a parent), or a category.

  INPUT:

  - `x` – list or tuple instance

  - `universe` – (default: `None`) the universe of elements; if `None` determined using canonical coercions and the entire list of elements. If list is empty, is category `Objects()` of all objects.

  - `check` – boolean (default: `True`); whether to coerce the elements of x into the universe

  - `immutable` – boolean (default: `True`); whether or not this sequence is immutable

  - `cr`, `cr_str` – see `Sequence()`

  - `use_sage_types` – boolean (default: `False`); if `True`, coerce the built-in Python numerical types int, float, complex to the corresponding Sage types (this makes functions like `vector()` more flexible)

  OUTPUT: a sequence

  EXAMPLES:

  Sage

      sage: v = Sequence(range(10))
      sage: v.universe()
      <class 'int'>
      sage: v
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  Python

      >>> from sage.all import *
      >>> v = Sequence(range(Integer(10)))
      >>> v.universe()
      <class 'int'>
      >>> v
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  We can request that the built-in Python numerical types be coerced to Sage objects:

  Sage

      sage: v = Sequence(range(10), use_sage_types=True)
      sage: v.universe()
      Integer Ring
      sage: v
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  [Python]

      >>> from sage.all import *
      >>> v = Sequence(range(Integer(10)), use_sage_types=True)
      >>> v.universe()
      Integer Ring
      >>> v
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  You can also use seq for “Sequence”, which is identical to using Sequence:

  Sage

      sage: v = seq([1,2,1/1]); v
      [1, 2, 1]
      sage: v.universe()
      Rational Field

  Python

      >>> from sage.all import *
      >>> v = seq([Integer(1),Integer(2),Integer(1)/Integer(1)]); v
      [1, 2, 1]
      >>> v.universe()
      Rational Field

  Note that assignment coerces if possible,

  Sage

      sage: v = Sequence(range(10), ZZ)
      sage: a = QQ(5)
      sage: v[3] = a
      sage: parent(v[3])
      Integer Ring
      sage: parent(a)
      Rational Field
      sage: v[3] = 2/3
      Traceback (most recent call last):
      ...
      TypeError: no conversion of this rational to integer

  [Python]

      >>> from sage.all import *
      >>> v = Sequence(range(Integer(10)), ZZ)
      >>> a = QQ(Integer(5))
      >>> v[Integer(3)] = a
      >>> parent(v[Integer(3)])
      Integer Ring
      >>> parent(a)
      Rational Field
      >>> v[Integer(3)] = Integer(2)/Integer(3)
      Traceback (most recent call last):
      ...
      TypeError: no conversion of this rational to integer

  Sequences can be used absolutely anywhere lists or tuples can be used:

  Sage

      sage: isinstance(v, list)
      True

  Python

      >>> from sage.all import *
      >>> isinstance(v, list)
      True

  Sequence can be immutable, so entries can’t be changed:

  Sage

      sage: v = Sequence([1,2,3], immutable=True)
      sage: v.is_immutable()
      True
      sage: v[0] = 5
      Traceback (most recent call last):
      ...
      ValueError: object is immutable; please change a copy instead.

  [Python]

      >>> from sage.all import *
      >>> v = Sequence([Integer(1),Integer(2),Integer(3)], immutable=True)
      >>> v.is_immutable()
      True
      >>> v[Integer(0)] = Integer(5)
      Traceback (most recent call last):
      ...
      ValueError: object is immutable; please change a copy instead.

  Only immutable sequences are hashable (unlike Python lists), though the hashing is potentially slow, since it first involves conversion of the sequence to a tuple, and returning the hash of that.

  Sage

      sage: v = Sequence(range(10), ZZ, immutable=True)
      sage: hash(v) == hash(tuple(range(10)))
      True

  Python

      >>> from sage.all import *
      >>> v = Sequence(range(Integer(10)), ZZ, immutable=True)
      >>> hash(v) == hash(tuple(range(Integer(10))))
      True

  If you really know what you are doing, you can circumvent the type checking (for an efficiency gain):

  Sage

      sage: list.__setitem__(v, int(1), 2/3)        # bad circumvention
      sage: v
      [0, 2/3, 2, 3, 4, 5, 6, 7, 8, 9]
      sage: list.__setitem__(v, int(1), int(2))     # not so bad circumvention

  [Python]

      >>> from sage.all import *
      >>> list.__setitem__(v, int(Integer(1)), Integer(2)/Integer(3))        # bad circumvention
      >>> v
      [0, 2/3, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> list.__setitem__(v, int(Integer(1)), int(Integer(2)))     # not so bad circumvention

  You can make a sequence with a new universe from an old sequence.

  Sage

      sage: w = Sequence(v, QQ)
      sage: w
      [0, 2, 2, 3, 4, 5, 6, 7, 8, 9]
      sage: w.universe()
      Rational Field
      sage: w[1] = 2/3
      sage: w
      [0, 2/3, 2, 3, 4, 5, 6, 7, 8, 9]

  Python

      >>> from sage.all import *
      >>> w = Sequence(v, QQ)
      >>> w
      [0, 2, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> w.universe()
      Rational Field
      >>> w[Integer(1)] = Integer(2)/Integer(3)
      >>> w
      [0, 2/3, 2, 3, 4, 5, 6, 7, 8, 9]

  The default universe for any sequence, if no compatible parent structure can be found, is the universe of all Sage objects.

  This example illustrates how every element of a list is taken into account when constructing a sequence.

  Sage

      sage: v = Sequence([1, 7, 6, GF(5)(3)]); v
      [1, 2, 1, 3]
      sage: v.universe()
      Finite Field of size 5

  [Python]

      >>> from sage.all import *
      >>> v = Sequence([Integer(1), Integer(7), Integer(6), GF(Integer(5))(Integer(3))]); v
      [1, 2, 1, 3]
      >>> v.universe()
      Finite Field of size 5

  append(x)

    EXAMPLES:

    Sage

        sage: v = Sequence([1,2,3,4], immutable=True)
        sage: v.append(34)
        Traceback (most recent call last):
        ...
        ValueError: object is immutable; please change a copy instead.
        sage: v = Sequence([1/3,2,3,4])
        sage: v.append(4)
        sage: type(v[4])
        <class 'sage.rings.rational.Rational'>

    Python

        >>> from sage.all import *
        >>> v = Sequence([Integer(1),Integer(2),Integer(3),Integer(4)], immutable=True)
        >>> v.append(Integer(34))
        Traceback (most recent call last):
        ...
        ValueError: object is immutable; please change a copy instead.
        >>> v = Sequence([Integer(1)/Integer(3),Integer(2),Integer(3),Integer(4)])
        >>> v.append(Integer(4))
        >>> type(v[Integer(4)])
        <class 'sage.rings.rational.Rational'>

  extend(iterable)

    Extend list by appending elements from the iterable.

    EXAMPLES:

    Sage

        sage: B = Sequence([1,2,3])
        sage: B.extend(range(4))
        sage: B
        [1, 2, 3, 0, 1, 2, 3]

    Python

        >>> from sage.all import *
        >>> B = Sequence([Integer(1),Integer(2),Integer(3)])
        >>> B.extend(range(Integer(4)))
        >>> B
        [1, 2, 3, 0, 1, 2, 3]

  insert(index, object)

    Insert object before index.

    EXAMPLES:

    Sage

        sage: B = Sequence([1,2,3])
        sage: B.insert(10, 5)
        sage: B
        [1, 2, 3, 5]

    Python

        >>> from sage.all import *
        >>> B = Sequence([Integer(1),Integer(2),Integer(3)])
        >>> B.insert(Integer(10), Integer(5))
        >>> B
        [1, 2, 3, 5]

  is_immutable()

    Return `True` if this object is immutable (can not be changed) and `False` if it is not.

    To make this object immutable use `set_immutable()`.

    EXAMPLES:

    Sage

        sage: v = Sequence([1, 2, 3, 4/5])
        sage: v[0] = 5
        sage: v
        [5, 2, 3, 4/5]
        sage: v.is_immutable()
        False
        sage: v.set_immutable()
        sage: v.is_immutable()
        True

    Python

        >>> from sage.all import *
        >>> v = Sequence([Integer(1), Integer(2), Integer(3), Integer(4)/Integer(5)])
        >>> v[Integer(0)] = Integer(5)
        >>> v
        [5, 2, 3, 4/5]
        >>> v.is_immutable()
        False
        >>> v.set_immutable()
        >>> v.is_immutable()
        True

  is_mutable()

    EXAMPLES:

    Sage

        sage: a = Sequence([1, 2/3, -2/5])
        sage: a.is_mutable()
        True
        sage: a[0] = 100
        sage: type(a[0])
        <class 'sage.rings.rational.Rational'>
        sage: a.set_immutable()
        sage: a[0] = 50
        Traceback (most recent call last):
        ...
        ValueError: object is immutable; please change a copy instead.
        sage: a.is_mutable()
        False

    Python

        >>> from sage.all import *
        >>> a = Sequence([Integer(1), Integer(2)/Integer(3), -Integer(2)/Integer(5)])
        >>> a.is_mutable()
        True
        >>> a[Integer(0)] = Integer(100)
        >>> type(a[Integer(0)])
        <class 'sage.rings.rational.Rational'>
        >>> a.set_immutable()
        >>> a[Integer(0)] = Integer(50)
        Traceback (most recent call last):
        ...
        ValueError: object is immutable; please change a copy instead.
        >>> a.is_mutable()
        False

  pop(index=-1)

    Remove and return item at index `index` (default: last).

    EXAMPLES:

    Sage

        sage: B = Sequence([1,2,3])
        sage: B.pop(1)
        2
        sage: B
        [1, 3]

    Python

        >>> from sage.all import *
        >>> B = Sequence([Integer(1),Integer(2),Integer(3)])
        >>> B.pop(Integer(1))
        2
        >>> B
        [1, 3]

  remove(value)

    Remove first occurrence of `value`.

    EXAMPLES:

    Sage

        sage: B = Sequence([1,2,3])
        sage: B.remove(2)
        sage: B
        [1, 3]

    Python

        >>> from sage.all import *
        >>> B = Sequence([Integer(1),Integer(2),Integer(3)])
        >>> B.remove(Integer(2))
        >>> B
        [1, 3]

  reverse()

    Reverse the elements of self, in place.

    EXAMPLES:

    Sage

        sage: B = Sequence([1,2,3])
        sage: B.reverse(); B
        [3, 2, 1]

    Python

        >>> from sage.all import *
        >>> B = Sequence([Integer(1),Integer(2),Integer(3)])
        >>> B.reverse(); B
        [3, 2, 1]

  set_immutable()

    Make this object immutable, so it can never again be changed.

    EXAMPLES:

    Sage

        sage: v = Sequence([1, 2, 3, 4/5])
        sage: v[0] = 5
        sage: v
        [5, 2, 3, 4/5]
        sage: v.set_immutable()
        sage: v[3] = 7
        Traceback (most recent call last):
        ...
        ValueError: object is immutable; please change a copy instead.

    Python

        >>> from sage.all import *
        >>> v = Sequence([Integer(1), Integer(2), Integer(3), Integer(4)/Integer(5)])
        >>> v[Integer(0)] = Integer(5)
        >>> v
        [5, 2, 3, 4/5]
        >>> v.set_immutable()
        >>> v[Integer(3)] = Integer(7)
        Traceback (most recent call last):
        ...
        ValueError: object is immutable; please change a copy instead.

  sort(key=None, reverse=False)

    Sort this list IN PLACE.

    INPUT:

    - `key` – see Python `list sort`

    - `reverse` – see Python `list sort`

    EXAMPLES:

    Sage

        sage: B = Sequence([3,2,1/5])
        sage: B.sort()
        sage: B
        [1/5, 2, 3]
        sage: B.sort(reverse=True); B
        [3, 2, 1/5]

    Python

        >>> from sage.all import *
        >>> B = Sequence([Integer(3),Integer(2),Integer(1)/Integer(5)])
        >>> B.sort()
        >>> B
        [1/5, 2, 3]
        >>> B.sort(reverse=True); B
        [3, 2, 1/5]

  universe()

    Return the universe of the sequence.

    EXAMPLES:

    Sage

        sage: Sequence([1, 2/3, -2/5]).universe()
        Rational Field
        sage: Sequence([1, 2/3, '-2/5']).universe()
        Category of objects

    Python

        >>> from sage.all import *
        >>> Sequence([Integer(1), Integer(2)/Integer(3), -Integer(2)/Integer(5)]).universe()
        Rational Field
        >>> Sequence([Integer(1), Integer(2)/Integer(3), '-2/5']).universe()
        Category of objects

sage.structure.sequence.seq(x, universe=None, check=True, immutable=False, cr=False, cr_str=None, use_sage_types=False)

  alias of `Sequence()`.