|
|
from sympy.concrete.products import Product |
|
|
from sympy.concrete.summations import Sum |
|
|
from sympy.core.basic import Basic |
|
|
from sympy.core.function import Lambda |
|
|
from sympy.core.numbers import (I, pi) |
|
|
from sympy.core.singleton import S |
|
|
from sympy.core.symbol import Dummy |
|
|
from sympy.functions.elementary.complexes import Abs |
|
|
from sympy.functions.elementary.exponential import exp |
|
|
from sympy.functions.special.gamma_functions import gamma |
|
|
from sympy.integrals.integrals import Integral |
|
|
from sympy.matrices.expressions.matexpr import MatrixSymbol |
|
|
from sympy.matrices.expressions.trace import Trace |
|
|
from sympy.tensor.indexed import IndexedBase |
|
|
from sympy.core.sympify import _sympify |
|
|
from sympy.stats.rv import _symbol_converter, Density, RandomMatrixSymbol, is_random |
|
|
from sympy.stats.joint_rv_types import JointDistributionHandmade |
|
|
from sympy.stats.random_matrix import RandomMatrixPSpace |
|
|
from sympy.tensor.array import ArrayComprehension |
|
|
|
|
|
__all__ = [ |
|
|
'CircularEnsemble', |
|
|
'CircularUnitaryEnsemble', |
|
|
'CircularOrthogonalEnsemble', |
|
|
'CircularSymplecticEnsemble', |
|
|
'GaussianEnsemble', |
|
|
'GaussianUnitaryEnsemble', |
|
|
'GaussianOrthogonalEnsemble', |
|
|
'GaussianSymplecticEnsemble', |
|
|
'joint_eigen_distribution', |
|
|
'JointEigenDistribution', |
|
|
'level_spacing_distribution' |
|
|
] |
|
|
|
|
|
@is_random.register(RandomMatrixSymbol) |
|
|
def _(x): |
|
|
return True |
|
|
|
|
|
|
|
|
class RandomMatrixEnsembleModel(Basic): |
|
|
""" |
|
|
Base class for random matrix ensembles. |
|
|
It acts as an umbrella and contains |
|
|
the methods common to all the ensembles |
|
|
defined in sympy.stats.random_matrix_models. |
|
|
""" |
|
|
def __new__(cls, sym, dim=None): |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
if dim.is_integer == False: |
|
|
raise ValueError("Dimension of the random matrices must be " |
|
|
"integers, received %s instead."%(dim)) |
|
|
return Basic.__new__(cls, sym, dim) |
|
|
|
|
|
symbol = property(lambda self: self.args[0]) |
|
|
dimension = property(lambda self: self.args[1]) |
|
|
|
|
|
def density(self, expr): |
|
|
return Density(expr) |
|
|
|
|
|
def __call__(self, expr): |
|
|
return self.density(expr) |
|
|
|
|
|
class GaussianEnsembleModel(RandomMatrixEnsembleModel): |
|
|
""" |
|
|
Abstract class for Gaussian ensembles. |
|
|
Contains the properties common to all the |
|
|
gaussian ensembles. |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles |
|
|
.. [2] https://arxiv.org/pdf/1712.07903.pdf |
|
|
""" |
|
|
def _compute_normalization_constant(self, beta, n): |
|
|
""" |
|
|
Helper function for computing normalization |
|
|
constant for joint probability density of eigen |
|
|
values of Gaussian ensembles. |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Selberg_integral#Mehta's_integral |
|
|
""" |
|
|
n = S(n) |
|
|
prod_term = lambda j: gamma(1 + beta*S(j)/2)/gamma(S.One + beta/S(2)) |
|
|
j = Dummy('j', integer=True, positive=True) |
|
|
term1 = Product(prod_term(j), (j, 1, n)).doit() |
|
|
term2 = (2/(beta*n))**(beta*n*(n - 1)/4 + n/2) |
|
|
term3 = (2*pi)**(n/2) |
|
|
return term1 * term2 * term3 |
|
|
|
|
|
def _compute_joint_eigen_distribution(self, beta): |
|
|
""" |
|
|
Helper function for computing the joint |
|
|
probability distribution of eigen values |
|
|
of the random matrix. |
|
|
""" |
|
|
n = self.dimension |
|
|
Zbn = self._compute_normalization_constant(beta, n) |
|
|
l = IndexedBase('l') |
|
|
i = Dummy('i', integer=True, positive=True) |
|
|
j = Dummy('j', integer=True, positive=True) |
|
|
k = Dummy('k', integer=True, positive=True) |
|
|
term1 = exp((-S(n)/2) * Sum(l[k]**2, (k, 1, n)).doit()) |
|
|
sub_term = Lambda(i, Product(Abs(l[j] - l[i])**beta, (j, i + 1, n))) |
|
|
term2 = Product(sub_term(i).doit(), (i, 1, n - 1)).doit() |
|
|
syms = ArrayComprehension(l[k], (k, 1, n)).doit() |
|
|
return Lambda(tuple(syms), (term1 * term2)/Zbn) |
|
|
|
|
|
class GaussianUnitaryEnsembleModel(GaussianEnsembleModel): |
|
|
@property |
|
|
def normalization_constant(self): |
|
|
n = self.dimension |
|
|
return 2**(S(n)/2) * pi**(S(n**2)/2) |
|
|
|
|
|
def density(self, expr): |
|
|
n, ZGUE = self.dimension, self.normalization_constant |
|
|
h_pspace = RandomMatrixPSpace('P', model=self) |
|
|
H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) |
|
|
return Lambda(H, exp(-S(n)/2 * Trace(H**2))/ZGUE)(expr) |
|
|
|
|
|
def joint_eigen_distribution(self): |
|
|
return self._compute_joint_eigen_distribution(S(2)) |
|
|
|
|
|
def level_spacing_distribution(self): |
|
|
s = Dummy('s') |
|
|
f = (32/pi**2)*(s**2)*exp((-4/pi)*s**2) |
|
|
return Lambda(s, f) |
|
|
|
|
|
class GaussianOrthogonalEnsembleModel(GaussianEnsembleModel): |
|
|
@property |
|
|
def normalization_constant(self): |
|
|
n = self.dimension |
|
|
_H = MatrixSymbol('_H', n, n) |
|
|
return Integral(exp(-S(n)/4 * Trace(_H**2))) |
|
|
|
|
|
def density(self, expr): |
|
|
n, ZGOE = self.dimension, self.normalization_constant |
|
|
h_pspace = RandomMatrixPSpace('P', model=self) |
|
|
H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) |
|
|
return Lambda(H, exp(-S(n)/4 * Trace(H**2))/ZGOE)(expr) |
|
|
|
|
|
def joint_eigen_distribution(self): |
|
|
return self._compute_joint_eigen_distribution(S.One) |
|
|
|
|
|
def level_spacing_distribution(self): |
|
|
s = Dummy('s') |
|
|
f = (pi/2)*s*exp((-pi/4)*s**2) |
|
|
return Lambda(s, f) |
|
|
|
|
|
class GaussianSymplecticEnsembleModel(GaussianEnsembleModel): |
|
|
@property |
|
|
def normalization_constant(self): |
|
|
n = self.dimension |
|
|
_H = MatrixSymbol('_H', n, n) |
|
|
return Integral(exp(-S(n) * Trace(_H**2))) |
|
|
|
|
|
def density(self, expr): |
|
|
n, ZGSE = self.dimension, self.normalization_constant |
|
|
h_pspace = RandomMatrixPSpace('P', model=self) |
|
|
H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) |
|
|
return Lambda(H, exp(-S(n) * Trace(H**2))/ZGSE)(expr) |
|
|
|
|
|
def joint_eigen_distribution(self): |
|
|
return self._compute_joint_eigen_distribution(S(4)) |
|
|
|
|
|
def level_spacing_distribution(self): |
|
|
s = Dummy('s') |
|
|
f = ((S(2)**18)/((S(3)**6)*(pi**3)))*(s**4)*exp((-64/(9*pi))*s**2) |
|
|
return Lambda(s, f) |
|
|
|
|
|
def GaussianEnsemble(sym, dim): |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
model = GaussianEnsembleModel(sym, dim) |
|
|
rmp = RandomMatrixPSpace(sym, model=model) |
|
|
return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) |
|
|
|
|
|
def GaussianUnitaryEnsemble(sym, dim): |
|
|
""" |
|
|
Represents Gaussian Unitary Ensembles. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import GaussianUnitaryEnsemble as GUE, density |
|
|
>>> from sympy import MatrixSymbol |
|
|
>>> G = GUE('U', 2) |
|
|
>>> X = MatrixSymbol('X', 2, 2) |
|
|
>>> density(G)(X) |
|
|
exp(-Trace(X**2))/(2*pi**2) |
|
|
""" |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
model = GaussianUnitaryEnsembleModel(sym, dim) |
|
|
rmp = RandomMatrixPSpace(sym, model=model) |
|
|
return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) |
|
|
|
|
|
def GaussianOrthogonalEnsemble(sym, dim): |
|
|
""" |
|
|
Represents Gaussian Orthogonal Ensembles. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import GaussianOrthogonalEnsemble as GOE, density |
|
|
>>> from sympy import MatrixSymbol |
|
|
>>> G = GOE('U', 2) |
|
|
>>> X = MatrixSymbol('X', 2, 2) |
|
|
>>> density(G)(X) |
|
|
exp(-Trace(X**2)/2)/Integral(exp(-Trace(_H**2)/2), _H) |
|
|
""" |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
model = GaussianOrthogonalEnsembleModel(sym, dim) |
|
|
rmp = RandomMatrixPSpace(sym, model=model) |
|
|
return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) |
|
|
|
|
|
def GaussianSymplecticEnsemble(sym, dim): |
|
|
""" |
|
|
Represents Gaussian Symplectic Ensembles. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import GaussianSymplecticEnsemble as GSE, density |
|
|
>>> from sympy import MatrixSymbol |
|
|
>>> G = GSE('U', 2) |
|
|
>>> X = MatrixSymbol('X', 2, 2) |
|
|
>>> density(G)(X) |
|
|
exp(-2*Trace(X**2))/Integral(exp(-2*Trace(_H**2)), _H) |
|
|
""" |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
model = GaussianSymplecticEnsembleModel(sym, dim) |
|
|
rmp = RandomMatrixPSpace(sym, model=model) |
|
|
return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) |
|
|
|
|
|
class CircularEnsembleModel(RandomMatrixEnsembleModel): |
|
|
""" |
|
|
Abstract class for Circular ensembles. |
|
|
Contains the properties and methods |
|
|
common to all the circular ensembles. |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Circular_ensemble |
|
|
""" |
|
|
def density(self, expr): |
|
|
|
|
|
|
|
|
raise NotImplementedError("Support for Haar measure hasn't been " |
|
|
"implemented yet, therefore the density of " |
|
|
"%s cannot be computed."%(self)) |
|
|
|
|
|
def _compute_joint_eigen_distribution(self, beta): |
|
|
""" |
|
|
Helper function to compute the joint distribution of phases |
|
|
of the complex eigen values of matrices belonging to any |
|
|
circular ensembles. |
|
|
""" |
|
|
n = self.dimension |
|
|
Zbn = ((2*pi)**n)*(gamma(beta*n/2 + 1)/S(gamma(beta/2 + 1))**n) |
|
|
t = IndexedBase('t') |
|
|
i, j, k = (Dummy('i', integer=True), Dummy('j', integer=True), |
|
|
Dummy('k', integer=True)) |
|
|
syms = ArrayComprehension(t[i], (i, 1, n)).doit() |
|
|
f = Product(Product(Abs(exp(I*t[k]) - exp(I*t[j]))**beta, (j, k + 1, n)).doit(), |
|
|
(k, 1, n - 1)).doit() |
|
|
return Lambda(tuple(syms), f/Zbn) |
|
|
|
|
|
class CircularUnitaryEnsembleModel(CircularEnsembleModel): |
|
|
def joint_eigen_distribution(self): |
|
|
return self._compute_joint_eigen_distribution(S(2)) |
|
|
|
|
|
class CircularOrthogonalEnsembleModel(CircularEnsembleModel): |
|
|
def joint_eigen_distribution(self): |
|
|
return self._compute_joint_eigen_distribution(S.One) |
|
|
|
|
|
class CircularSymplecticEnsembleModel(CircularEnsembleModel): |
|
|
def joint_eigen_distribution(self): |
|
|
return self._compute_joint_eigen_distribution(S(4)) |
|
|
|
|
|
def CircularEnsemble(sym, dim): |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
model = CircularEnsembleModel(sym, dim) |
|
|
rmp = RandomMatrixPSpace(sym, model=model) |
|
|
return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) |
|
|
|
|
|
def CircularUnitaryEnsemble(sym, dim): |
|
|
""" |
|
|
Represents Circular Unitary Ensembles. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import CircularUnitaryEnsemble as CUE |
|
|
>>> from sympy.stats import joint_eigen_distribution |
|
|
>>> C = CUE('U', 1) |
|
|
>>> joint_eigen_distribution(C) |
|
|
Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**2, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) |
|
|
|
|
|
Note |
|
|
==== |
|
|
|
|
|
As can be seen above in the example, density of CiruclarUnitaryEnsemble |
|
|
is not evaluated because the exact definition is based on haar measure of |
|
|
unitary group which is not unique. |
|
|
""" |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
model = CircularUnitaryEnsembleModel(sym, dim) |
|
|
rmp = RandomMatrixPSpace(sym, model=model) |
|
|
return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) |
|
|
|
|
|
def CircularOrthogonalEnsemble(sym, dim): |
|
|
""" |
|
|
Represents Circular Orthogonal Ensembles. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import CircularOrthogonalEnsemble as COE |
|
|
>>> from sympy.stats import joint_eigen_distribution |
|
|
>>> C = COE('O', 1) |
|
|
>>> joint_eigen_distribution(C) |
|
|
Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k])), (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) |
|
|
|
|
|
Note |
|
|
==== |
|
|
|
|
|
As can be seen above in the example, density of CiruclarOrthogonalEnsemble |
|
|
is not evaluated because the exact definition is based on haar measure of |
|
|
unitary group which is not unique. |
|
|
""" |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
model = CircularOrthogonalEnsembleModel(sym, dim) |
|
|
rmp = RandomMatrixPSpace(sym, model=model) |
|
|
return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) |
|
|
|
|
|
def CircularSymplecticEnsemble(sym, dim): |
|
|
""" |
|
|
Represents Circular Symplectic Ensembles. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import CircularSymplecticEnsemble as CSE |
|
|
>>> from sympy.stats import joint_eigen_distribution |
|
|
>>> C = CSE('S', 1) |
|
|
>>> joint_eigen_distribution(C) |
|
|
Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**4, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) |
|
|
|
|
|
Note |
|
|
==== |
|
|
|
|
|
As can be seen above in the example, density of CiruclarSymplecticEnsemble |
|
|
is not evaluated because the exact definition is based on haar measure of |
|
|
unitary group which is not unique. |
|
|
""" |
|
|
sym, dim = _symbol_converter(sym), _sympify(dim) |
|
|
model = CircularSymplecticEnsembleModel(sym, dim) |
|
|
rmp = RandomMatrixPSpace(sym, model=model) |
|
|
return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) |
|
|
|
|
|
def joint_eigen_distribution(mat): |
|
|
""" |
|
|
For obtaining joint probability distribution |
|
|
of eigen values of random matrix. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
mat: RandomMatrixSymbol |
|
|
The matrix symbol whose eigen values are to be considered. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
Lambda |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import GaussianUnitaryEnsemble as GUE |
|
|
>>> from sympy.stats import joint_eigen_distribution |
|
|
>>> U = GUE('U', 2) |
|
|
>>> joint_eigen_distribution(U) |
|
|
Lambda((l[1], l[2]), exp(-l[1]**2 - l[2]**2)*Product(Abs(l[_i] - l[_j])**2, (_j, _i + 1, 2), (_i, 1, 1))/pi) |
|
|
""" |
|
|
if not isinstance(mat, RandomMatrixSymbol): |
|
|
raise ValueError("%s is not of type, RandomMatrixSymbol."%(mat)) |
|
|
return mat.pspace.model.joint_eigen_distribution() |
|
|
|
|
|
def JointEigenDistribution(mat): |
|
|
""" |
|
|
Creates joint distribution of eigen values of matrices with random |
|
|
expressions. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
mat: Matrix |
|
|
The matrix under consideration. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
JointDistributionHandmade |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import Normal, JointEigenDistribution |
|
|
>>> from sympy import Matrix |
|
|
>>> A = [[Normal('A00', 0, 1), Normal('A01', 0, 1)], |
|
|
... [Normal('A10', 0, 1), Normal('A11', 0, 1)]] |
|
|
>>> JointEigenDistribution(Matrix(A)) |
|
|
JointDistributionHandmade(-sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2 |
|
|
+ A00/2 + A11/2, sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2 + A00/2 + A11/2) |
|
|
|
|
|
""" |
|
|
eigenvals = mat.eigenvals(multiple=True) |
|
|
if not all(is_random(eigenval) for eigenval in set(eigenvals)): |
|
|
raise ValueError("Eigen values do not have any random expression, " |
|
|
"joint distribution cannot be generated.") |
|
|
return JointDistributionHandmade(*eigenvals) |
|
|
|
|
|
def level_spacing_distribution(mat): |
|
|
""" |
|
|
For obtaining distribution of level spacings. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
mat: RandomMatrixSymbol |
|
|
The random matrix symbol whose eigen values are |
|
|
to be considered for finding the level spacings. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
Lambda |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.stats import GaussianUnitaryEnsemble as GUE |
|
|
>>> from sympy.stats import level_spacing_distribution |
|
|
>>> U = GUE('U', 2) |
|
|
>>> level_spacing_distribution(U) |
|
|
Lambda(_s, 32*_s**2*exp(-4*_s**2/pi)/pi**2) |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Random_matrix#Distribution_of_level_spacings |
|
|
""" |
|
|
return mat.pspace.model.level_spacing_distribution() |
|
|
|
