Core Package

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.zetas.abstract_zeta.AbstractZeta(*args, **kwargs)

TODO.

__call__(s, nMax)

Compute the values of the abstract zeta function on an input vector.

Parameters:

• s (Union[complex, ndarray[Any, dtype[complex128]]]) – vector of inputs in the complex plane

• nMax (int) – cutoff in the cycle expansion

Returns:

ndarray[Any, dtype[complex128]] – function values of the zeta function

abstract calcA(s, nMax)

Compute the base step in the iterative process of Bell polynomial construction.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex points to evaluate the zeta function on

• nMax (int) – the maximal order to use in the cycle expansion

Returns:

ndarray[Any, dtype[complex128]] – array of shape (len(s), nMax)

calcD(s, nMax)

Compute the actual steps in the iterative process of Bell polynomial construction.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex points to evaluate the zeta function on

• nMax (int) – the maximal order to use in the cycle expansion

Returns:

ndarray[Any, dtype[complex128]] – array of shape (len(s), nMax)

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.zetas.abstract_wzeta.AbstractWeightedZeta(*args, **kwargs)

Abstract base for dynamical determinants and weighted zeta functions.

calcDynamicalDeterminant(s, nMax, dMax)

TODO.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex points to evaluate the zeta function on

• nMax (int) – maximal summation order to use in the cycle expansion

• dMax (int) – maximal number of s-derivatives to calculate

Returns:

ndarray[Any, dtype[complex128]] – array of shape (len(s), dMax+1, 2, shape(weights))

abstract calcWeightedA(s, nMax, dMax)

Compute the base step in the iterative process of Bell polynomial construction with weight functions.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex points to evaluate the zeta function on

• nMax (int) – maximal summation order to use in the cycle expansion

• dMax (int) – maximal number of s-derivatives to calculate

Returns:

ndarray[Any, dtype[complex128]] – array of shape (len(s), nMax, dMax+1, 2, shape(weights))

calcWeightedD(s, nMax, dMax)

Compute the actual steps in the iterative process of Bell polynomial construction with weight functions.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex points to evaluate the zeta function on

• nMax (int) – maximal summation order to use in the cycle expansion

• dMax (int) – maximal number of s-derivatives to calculate

Returns:

ndarray[Any, dtype[complex128]] – array of shape (len(s), nMax+1, dMax+1, 2, shape(weights))

calcWeightedZeta(s, nMax)

TODO.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex points to evaluate the zeta function on

• nMax (int) – maximal summation order to use in the cycle expansion

• dMax – maximal number of s-derivatives to calculate

Returns:

ndarray[Any, dtype[complex128]] – array of shape (len(s), dMax+1, 2, shape(weights))

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.zetas.selberg_zeta.SelbergZeta(*, functionSystem, systemInitArgs)

TODO.

__init__(*, functionSystem, systemInitArgs)

TODO.

calcA(s, nMax)

Compute the base step in the iterative process of Bell polynomial construction.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex points to evaluate the zeta function on

• nMax (int) – the maximal order to use in the cycle expansion

Returns:

ndarray[Any, dtype[complex128]] – array of shape (len(s), nMax)

Non-symmetry reduced implementation of the abstract weighted zeta interface.

Authors:

• Philipp Schuette

class pyzeta.core.zetas.wzeta.WeightedZeta(*, mapSystem, systemInitArgs, integralType, integralInitArgs)

Class representing non-reduced weighted zetas and dynamical determinants.

__init__(*, mapSystem, systemInitArgs, integralType, integralInitArgs)

TODO.

calcA(s, nMax)

Compute the base step in the iterative process of Bell polynomial construction.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex points to evaluate the zeta function on

• nMax (int) – the maximal order to use in the cycle expansion

Returns:

ndarray[Any, dtype[complex128]] – array of shape (len(s), nMax)

calcWeightedA(s, nMax, dMax)

Compute the basis step in the iterative process of computing Bell Polynomials with weights.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – Values entered in the zeta function

• nMax (int) – Maximal word length in the iterative approximation

• dMax (int) – Maximal order of s-derivates included

Returns:

ndarray[Any, dtype[complex128]] – first step in iterative Bell polynomial calculation

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.dynamics.symbolic_dynamics.abstract_dynamics.AbstractSymbolicDynamics(*args, **kwargs)

Abstract class representation of symbolic dynamics. Concrete implementations can hook into this template by implementing the various word filtering methods.

abstract wordGenerator(maxWordLength, prime=False, permFree=False, cyclRed=False)

Return a generator that yields all symbolic words up to a maximal word length and satisfying certain given properties together with associated group elements. Implementations may choose to return an empty array of symmetries effectively reducing the symmetry to the trivial one-element group.

Parameters:

• maxWordLength (int) – maximal word length before the generator expires

• prime (bool) – flag indicating if non-prime words are filtered (default: False)

• permFree (bool) – flag indicating if permutations of words are filtered (default: False)

• cyclRed (bool) – flag indicating if non-cyclically reduced words are (default: False) filtered

Returns:

Iterator[Tuple[ndarray[Any, dtype[uint8]], ndarray[Any, dtype[str_]]]] – a generator of parallel arrays of words and symmetries

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.dynamics.symbolic_dynamics.symbolic_dynamics.SymbolicDynamics(adjacencyMatrix)

Class representation of a plain (without reduction) symbolic dynamics.

__init__(adjacencyMatrix)

Initialize a new symbolic dynamics instance from a given adjacency relation.

Parameters:

adjacencyMatrix (ndarray[Any, dtype[bool_]]) – square adjacency matrix of the dynamics

getSymbolicWords(wordLength, givenWords=None, *, prime=False, permFree=False, cyclRed=False, periodic=False)

Generate all words of length wordLength satisfying (a combination of) various attributes.

If an array of givenWords is passed then the resulting words are constructed by appending to them. Therefore usually givenWords should contain all possible words of some length <wordLength.

Parameters:

• wordLength (int) – Length of words to be generated

• givenWords (Optional[ndarray[Any, dtype[uint8]]]) – Array of starting words of length <wordLength (default: None)

• prime (bool) – generate only prime words (default: False)

• permFree (bool) – exclude permutations of words (default: False)

• cyclRed (bool) – generate only cyclically reduced words (default: False)

• periodic (bool) – generate only periodic words (default: False)

Returns:

ndarray[Any, dtype[uint8]] – Array of words of length wordLength with given properties

Raises:

ValueError – raised if givenWords have length >`wordLength`

wordGenerator(maxWordLength, prime=False, permFree=False, cyclRed=False)

Return a generator that yields all symbolic words up to a maximal word length and satisfying certain given properties together with associated group elements. Implementations may choose to return an empty array of symmetries effectively reducing the symmetry to the trivial one-element group.

Parameters:

• maxWordLength (int) – maximal word length before the generator expires

• prime (bool) – flag indicating if non-prime words are filtered (default: False)

• permFree (bool) – flag indicating if permutations of words are filtered (default: False)

• cyclRed (bool) – flag indicating if non-cyclically reduced words are (default: False) filtered

Returns:

Iterator[Tuple[ndarray[Any, dtype[uint8]], ndarray[Any, dtype[str_]]]] – a generator of parallel arrays of words and symmetries

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.dynamics.function_systems.function_system.FunctionSystem(*args, **kwargs)

Abstract representation of an (iterated 1d) function system.

abstract property adjacencyMatrix: ndarray[Any, dtype[bool_]]

Return the adjacency matrix of the given function system.

Returns:

adjacency matrix

abstract getStabilities(words)

Return the stabilities (i.e. derivatives of function iterates at fixed points) associated with an array of symbolic words.

Parameters:

words (ndarray[Any, dtype[uint8]]) – array of symbolic words determining the function iterates

Returns:

ndarray[Any, dtype[complex128]] – stabilities of the (symbolically given) periodic orbits

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.dynamics.function_systems.map_system.HyperbolicMapSystem(*args, **kwargs)

Abstract representation of a hyperbolic (n-dimensional) map system.

abstract property adjacencyMatrix: ndarray[Any, dtype[bool_]]

Return the adjacency matrix of the given system of maps. The size of this matrix must fit the underlying alphabet of the map system.

Returns:

adjacency matrix

abstract property fundamentalIntervals: Tuple[Tuple[float, float], ...]

Return the (real) domains of the maps making up the system. Domains are bounded, connected subsets of the real line which in turn are represented as pairs of floats.

Returns:

intervals of definition of the map system

abstract getPeriodicPoints(words)

Return the periodic points (i.e. fixed points of map iterates) associated with an array of symbolic words.

Parameters:

words (ndarray[Any, dtype[uint8]]) – array of symbolic words determining the map iterates

Returns:

Tuple[ndarray[Any, dtype[complex128]], ndarray[Any, dtype[complex128]]] – fixed points of the (symbolically given) iterates

abstract getStabilities(words)

Return the stabilities (i.e. derivatives of map iterates at fixed points) associated with an array of symbolic words. Stabilities are guaranteed to be sorted as (contracting, expanding)!

Parameters:

words (ndarray[Any, dtype[uint8]]) – array of symbolic words determining the map iterates

Returns:

Tuple[ndarray[Any, dtype[complex128]], ndarray[Any, dtype[complex128]]] – stabilities of the (symbolically given) periodic orbits

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.dynamics.function_systems.integral_provider.IntegralProvider

Abstract base realizing the potentials used in weighted zeta functions.

abstract getOrbitIntegrals(words)

Calculate an array of 2d grids containing orbit integrals parallel to a given array of symbolic words.

Parameters:

words (ndarray[Any, dtype[uint8]]) – array of symbolic words to calculate orbit integrals for

Returns:

ndarray[Any, dtype[float64]] – array of orbit integrals on a 2d grid

abstract property integralShape: Tuple[int, int]

Return the shape of individual orbit integrals as calculated by the given provider instance. Usually this returns (n, n) for square and (n, m) for non-square arrays of integral values.

Returns:

shape of individual arrays of calculated integrals

Module containing specializations of the abstract base classes FunctionSystem and HyperbolicMapSystem to the case of the underlying functions/mappings being given by Moebius transformations (i.e. real 2x2 matrices with unit determinant acting on the upper half plane).

Authors:

• Philipp Schuette

class pyzeta.core.dynamics.function_systems.moebius_system.MoebiusFunctionSystem(generators, adjacencyMatrix)

Abstract representation of an (iterated) function system the functions of which are given by Moebius transformations.

__init__(generators, adjacencyMatrix)

Initialize an iterated function system which is more concretely given by iteration of Moebius transformations on the upper half plane.

Parameters:

• generators (ndarray[Any, dtype[float64]]) – array of real 2x2 matrices of non-null determinants

• matrix (adjacency) – boolean matrix determining legal transitions

property adjacencyMatrix: ndarray[Any, dtype[bool_]]

Return the adjacency matrix of the given function system.

Returns:

adjacency matrix

getStabilities(words)

Return the stabilities (i.e. derivatives of function iterates at fixed points) associated with an array of symbolic words.

Parameters:

words (ndarray[Any, dtype[uint8]]) – array of symbolic words determining the function iterates

Returns:

ndarray[Any, dtype[complex128]] – stabilities of the (symbolically given) periodic orbits

class pyzeta.core.dynamics.function_systems.moebius_system.MoebiusMapSystem(functionSystem)

Abstract representation of a hyperbolic map system which is basically given by the inclusion of an additional dimension in a Moebius transformation based iterated function system.

__init__(functionSystem)

Initialize a hyperbolic map system which delegates most work to an associated Moebius function system. The only required property for subclasses to implement is fundamentalIntervals.

Parameters:

functionSystem (MoebiusFunctionSystem) – the backing function system

property adjacencyMatrix: ndarray[Any, dtype[bool_]]

Return the adjacency matrix of the given system of maps. The size of this matrix must fit the underlying alphabet of the map system.

Returns:

adjacency matrix

getGenerators(indices)

Convenience method used to retrieve an array of generators of the Moebius transformation based map system. Used in orbit integral calculation.

Parameters:

indices (ndarray[Any, dtype[uint8]]) – array of indices into the underlying Moebius trafos

Returns:

ndarray[Any, dtype[float64]] – array of 2x2 matrices representing Moebius trafos

getPeriodicPoints(words)

Return the periodic points (i.e. fixed points of map iterates) associated with an array of symbolic words.

Parameters:

words (ndarray[Any, dtype[uint8]]) – array of symbolic words determining the map iterates

Returns:

Tuple[ndarray[Any, dtype[complex128]], ndarray[Any, dtype[complex128]]] – fixed points of the (symbolically given) iterates

getStabilities(words)

Return the stabilities (i.e. derivatives of map iterates at fixed points) associated with an array of symbolic words. Stabilities are guaranteed to be sorted as (contracting, expanding)!

Parameters:

words (ndarray[Any, dtype[uint8]]) – array of symbolic words determining the map iterates

Returns:

Tuple[ndarray[Any, dtype[complex128]], ndarray[Any, dtype[complex128]]] – stabilities of the (symbolically given) periodic orbits

Module containing a subclass of MoebiusFunctionSystem representing Schottky surface function dynamics. The subclass provides the concrete adjacency matrix of Schottky groups and complements an array of generators with their inverses to complete the requirements for symbolic dynamics.

Authors:

• Philipp Schuette

class pyzeta.core.dynamics.function_systems.schottky_system.SchottkyFunctionSystem(generators)

Class representation of the geodesic flow dynamics on Schottky surfaces.

__init__(generators)

Generators are assumed to be in \(\mathrm{SL}(2, \mathbb{R})\).

Parameters:

generators (ndarray[Any, dtype[float64]]) – array of 2x2 generators without their inverses

class pyzeta.core.dynamics.function_systems.schottky_system.SchottkyMapSystem(functionSystem)

Class representing Schottky surface dynamics as hyperbolic map systems.

__init__(functionSystem)

Initialize a hyperbolic map system which delegates most work to an associated Schottky function system. Subclasses should only override the constructor.

Parameters:

functionSystem (SchottkyFunctionSystem) – the backing function system

property fundamentalIntervals: Tuple[Tuple[float, float], ...]

Return the (real) domains of the maps making up the system. Domains are bounded, connected subsets of the real line which in turn are represented as pairs of floats.

Returns:

intervals of definition of the map system

Abstract base class for invariant Ruelle distributions.

Authors:

• Philipp Schuette

class pyzeta.core.distributions.abstract_ruelle.AbstractRuelleDistribution(*args, **kwargs)

Abstract class representation of Ruelle distributions.

abstract __call__(s, nMax)

Calculate an approximation of the distribution with nMax summands on a two-dimensional grid.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex values to evaluate the distribution on

• nMax (int) – number of summands used to approximate the distribution

Returns:

ndarray[Any, dtype[float64]] – array of two-dimensional arrays of distribution evaluations parallel to the input array s

Core module containing a concrete implementation of the abstract base class AbstractRuelleDistribution based on Moebius hyperbolic map systems.

Authors:

• Philipp Schuette

class pyzeta.core.distributions.ruelle_distribution.RuelleDistribution(mapSystem, systemInitArgs, integralType, sigma, numSupportPts, refinementLevel=0, *, minusIndices=None, plusIndices=None)

Class representation of Ruelle distributions on hyperbolic map systems.

__call__(s, nMax)

Calculate an approximation of the distribution with nMax summands on a two-dimensional grid.

Parameters:

• s (ndarray[Any, dtype[complex128]]) – array of complex values to evaluate the distribution on

• nMax (int) – number of summands used to approximate the distribution

Returns:

ndarray[Any, dtype[float64]] – array of two-dimensional arrays of distribution evaluations parallel to the input array s

__init__(mapSystem, systemInitArgs, integralType, sigma, numSupportPts, refinementLevel=0, *, minusIndices=None, plusIndices=None)

Initialize a new invariant Ruelle distribution for a given hyperbolic map system and integral provider.

TODO.

Module containing an abstract base for discrete symmetry groups of iterated function and hyperbolic map systems. Implementations of this interface should be table driven to allow simple implementations without much additional boilerplate code.

Authors:

• Philipp Schuette

class pyzeta.core.symmetries.symmetry_group.SymmetryGroup

Abstract base for discrete groups of symmetries of function systems.

__len__()

Return the cardinality of the group.

Returns:

int – cardinality (number of elements) of the discrete group

abstract applyLetterArray(elemArray, letterArray)

Calculate the action of an array of group elements on a parallel array of letters from the alphabet that the group acts on.

Parameters:

• elemArray (ndarray[Any, dtype[str_]]) – array of group elements to act with

• letterArray (ndarray[Any, dtype[uint8]]) – array of alphabet letters to act on

Returns:

ndarray[Any, dtype[uint8]] – array of alphabet letters resulting from the action

abstract applyWord(elem, word)

Apply a group element to a symbolic word over the alphabet that the symmetry group is acting on.

Parameters:

• elem (str_) – group element to act with

• word (ndarray[Any, dtype[uint8]]) – symbolic word to act on

Returns:

ndarray[Any, dtype[uint8]] – symbolic word that results from the action

abstract character(irrRepr, elems)

Evaluate the group character corresponding to the irreducible representation irrRepr at the array of group elements elems.

Parameters:

• irrRepr (str) – irreducible representation whose character to return

• elems (ndarray[Any, dtype[str_]]) – array of group elements to evaluate the character on

Returns:

ndarray[Any, dtype[complex128]] – vector of character evaluations

abstract compose(elem1, elem2)

Calculate the composition (product) elem1 x elem2 of two group elements elem1 and elem2.

Parameters:

• elem1 (str_) – first product component

• elem2 (str_) – second product component

Returns:

str_ – product of the components

abstract conjugate(elem1, elem2)

Calculate the conjugation of elem1 by elem2 within the given discrete symmetry group, i.e. elem2 x elem1 x elem2^(-1).

Parameters:

• elem1 (str_) – group element to conjugate

• elem2 (str_) – group element to conjugate by

Returns:

str_ – conjugation by second element applied to first element

abstract elementPower(baseArray, exponent)

Calculate the element-wise powers of an array of group elements.

Parameters:

• baseArray (ndarray[Any, dtype[str_]]) – group elements to exponentiate

• exponent (int) – uniform exponent for each array entry

Returns:

ndarray[Any, dtype[str_]] – array of exponentiated group elements

abstract getDimension(irrRepr)

Return the dimension of the irreducible representation irrRepr of the given group.

Parameters:

irrRepr (str) – irreducible representation whose dimension to return

Returns:

int – dimension of the given irreducible representation

abstract getElements()

Return the elements of a discrete symmetry group.

Returns:

Tuple[str_, ...] – tuple containing the group elements

abstract order(elem)

Return the order of a given group element, i.e. the cardinality of the cyclic subgroup generated by the element.

Parameters:

elem (str_) – group element whose order to return

Returns:

int – the order of the element

abstract shiftAction(word, elem)

Calculate the shift action on a pair consisting of a symbolic word and its closing group element.

Parameters:

• word (ndarray[Any, dtype[uint8]]) – symbolic word to shift

• elem (str_) – group element closing the symbolic word

Returns:

ndarray[Any, dtype[uint8]] – shifted symbolic word

abstract wordPower(word, elem, exponent)

Calculate an integer power of a pair consisting of a symbolic word and its closing group element.

Parameters:

• word (ndarray[Any, dtype[uint8]]) – symbolic word to exponentiate

• elem (str_) – group element closing the symbolic word

Returns:

Tuple[ndarray[Any, dtype[uint8]], str_] – pair consisting of the exponentiated word and group element

TODO.

Authors:

• Philipp Schuette

class pyzeta.core.symmetries.trivial_group.TrivialGroup

Class representation of the trivial symmetry group. This group can be used in conjunction with every Schottky group but does not provide a non-trivial symmetry decomposition.

__init__()

Initialize the unique instance of this symmetry group.

static __new__(cls, *args, **kwargs)

Override __new__ to implement singleton behaviour.

Return type:

TrivialGroup

applyLetterArray(elemArray, letterArray)

Calculate the action of an array of group elements on a parallel array of letters from the alphabet that the group acts on.

Parameters:

• elemArray (ndarray[Any, dtype[str_]]) – array of group elements to act with

• letterArray (ndarray[Any, dtype[uint8]]) – array of alphabet letters to act on

Returns:

ndarray[Any, dtype[uint8]] – array of alphabet letters resulting from the action

applyWord(elem, word)

Apply a group element to a symbolic word over the alphabet that the symmetry group is acting on.

Parameters:

• elem (str_) – group element to act with

• word (ndarray[Any, dtype[uint8]]) – symbolic word to act on

Returns:

ndarray[Any, dtype[uint8]] – symbolic word that results from the action

character(irrRepr, elems)

Evaluate the group character corresponding to the irreducible representation irrRepr at the array of group elements elems.

Parameters:

• irrRepr (str) – irreducible representation whose character to return

• elems (ndarray[Any, dtype[str_]]) – array of group elements to evaluate the character on

Returns:

ndarray[Any, dtype[complex128]] – vector of character evaluations

compose(elem1, elem2)

Calculate the composition (product) elem1 x elem2 of two group elements elem1 and elem2.

Parameters:

• elem1 (str_) – first product component

• elem2 (str_) – second product component

Returns:

str_ – product of the components

conjugate(elem1, elem2)

Calculate the conjugation of elem1 by elem2 within the given discrete symmetry group, i.e. elem2 x elem1 x elem2^(-1).

Parameters:

• elem1 (str_) – group element to conjugate

• elem2 (str_) – group element to conjugate by

Returns:

str_ – conjugation by second element applied to first element

elementPower(baseArray, exponent)

Calculate the element-wise powers of an array of group elements.

Parameters:

• baseArray (ndarray[Any, dtype[str_]]) – group elements to exponentiate

• exponent (int) – uniform exponent for each array entry

Returns:

ndarray[Any, dtype[str_]] – array of exponentiated group elements

getDimension(irrRepr)

Return the dimension of the irreducible representation irrRepr of the given group.

Parameters:

irrRepr (str) – irreducible representation whose dimension to return

Returns:

int – dimension of the given irreducible representation

getElements()

Return the elements of a discrete symmetry group.

Returns:

Tuple[str_, ...] – tuple containing the group elements

order(elem)

Return the order of a given group element, i.e. the cardinality of the cyclic subgroup generated by the element.

Parameters:

elem (str_) – group element whose order to return

Returns:

int – the order of the element

shiftAction(word, elem)

Calculate the shift action on a pair consisting of a symbolic word and its closing group element.

Parameters:

• word (ndarray[Any, dtype[uint8]]) – symbolic word to shift

• elem (str_) – group element closing the symbolic word

Returns:

ndarray[Any, dtype[uint8]] – shifted symbolic word

wordPower(word, elem, exponent)

Calculate an integer power of a pair consisting of a symbolic word and its closing group element.

Parameters:

• word (ndarray[Any, dtype[uint8]]) – symbolic word to exponentiate

• elem (str_) – group element closing the symbolic word

Returns:

Tuple[ndarray[Any, dtype[uint8]], str_] – pair consisting of the exponentiated word and group element