|
|
"""Hilbert spaces for quantum mechanics. |
|
|
|
|
|
Authors: |
|
|
* Brian Granger |
|
|
* Matt Curry |
|
|
""" |
|
|
|
|
|
from functools import reduce |
|
|
|
|
|
from sympy.core.basic import Basic |
|
|
from sympy.core.singleton import S |
|
|
from sympy.core.sympify import sympify |
|
|
from sympy.sets.sets import Interval |
|
|
from sympy.printing.pretty.stringpict import prettyForm |
|
|
from sympy.physics.quantum.qexpr import QuantumError |
|
|
|
|
|
|
|
|
__all__ = [ |
|
|
'HilbertSpaceError', |
|
|
'HilbertSpace', |
|
|
'TensorProductHilbertSpace', |
|
|
'TensorPowerHilbertSpace', |
|
|
'DirectSumHilbertSpace', |
|
|
'ComplexSpace', |
|
|
'L2', |
|
|
'FockSpace' |
|
|
] |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class HilbertSpaceError(QuantumError): |
|
|
pass |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class HilbertSpace(Basic): |
|
|
"""An abstract Hilbert space for quantum mechanics. |
|
|
|
|
|
In short, a Hilbert space is an abstract vector space that is complete |
|
|
with inner products defined [1]_. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.physics.quantum.hilbert import HilbertSpace |
|
|
>>> hs = HilbertSpace() |
|
|
>>> hs |
|
|
H |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Hilbert_space |
|
|
""" |
|
|
|
|
|
def __new__(cls): |
|
|
obj = Basic.__new__(cls) |
|
|
return obj |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
"""Return the Hilbert dimension of the space.""" |
|
|
raise NotImplementedError('This Hilbert space has no dimension.') |
|
|
|
|
|
def __add__(self, other): |
|
|
return DirectSumHilbertSpace(self, other) |
|
|
|
|
|
def __radd__(self, other): |
|
|
return DirectSumHilbertSpace(other, self) |
|
|
|
|
|
def __mul__(self, other): |
|
|
return TensorProductHilbertSpace(self, other) |
|
|
|
|
|
def __rmul__(self, other): |
|
|
return TensorProductHilbertSpace(other, self) |
|
|
|
|
|
def __pow__(self, other, mod=None): |
|
|
if mod is not None: |
|
|
raise ValueError('The third argument to __pow__ is not supported \ |
|
|
for Hilbert spaces.') |
|
|
return TensorPowerHilbertSpace(self, other) |
|
|
|
|
|
def __contains__(self, other): |
|
|
"""Is the operator or state in this Hilbert space. |
|
|
|
|
|
This is checked by comparing the classes of the Hilbert spaces, not |
|
|
the instances. This is to allow Hilbert Spaces with symbolic |
|
|
dimensions. |
|
|
""" |
|
|
if other.hilbert_space.__class__ == self.__class__: |
|
|
return True |
|
|
else: |
|
|
return False |
|
|
|
|
|
def _sympystr(self, printer, *args): |
|
|
return 'H' |
|
|
|
|
|
def _pretty(self, printer, *args): |
|
|
ustr = '\N{LATIN CAPITAL LETTER H}' |
|
|
return prettyForm(ustr) |
|
|
|
|
|
def _latex(self, printer, *args): |
|
|
return r'\mathcal{H}' |
|
|
|
|
|
|
|
|
class ComplexSpace(HilbertSpace): |
|
|
"""Finite dimensional Hilbert space of complex vectors. |
|
|
|
|
|
The elements of this Hilbert space are n-dimensional complex valued |
|
|
vectors with the usual inner product that takes the complex conjugate |
|
|
of the vector on the right. |
|
|
|
|
|
A classic example of this type of Hilbert space is spin-1/2, which is |
|
|
``ComplexSpace(2)``. Generalizing to spin-s, the space is |
|
|
``ComplexSpace(2*s+1)``. Quantum computing with N qubits is done with the |
|
|
direct product space ``ComplexSpace(2)**N``. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import symbols |
|
|
>>> from sympy.physics.quantum.hilbert import ComplexSpace |
|
|
>>> c1 = ComplexSpace(2) |
|
|
>>> c1 |
|
|
C(2) |
|
|
>>> c1.dimension |
|
|
2 |
|
|
|
|
|
>>> n = symbols('n') |
|
|
>>> c2 = ComplexSpace(n) |
|
|
>>> c2 |
|
|
C(n) |
|
|
>>> c2.dimension |
|
|
n |
|
|
|
|
|
""" |
|
|
|
|
|
def __new__(cls, dimension): |
|
|
dimension = sympify(dimension) |
|
|
r = cls.eval(dimension) |
|
|
if isinstance(r, Basic): |
|
|
return r |
|
|
obj = Basic.__new__(cls, dimension) |
|
|
return obj |
|
|
|
|
|
@classmethod |
|
|
def eval(cls, dimension): |
|
|
if len(dimension.atoms()) == 1: |
|
|
if not (dimension.is_Integer and dimension > 0 or dimension is S.Infinity |
|
|
or dimension.is_Symbol): |
|
|
raise TypeError('The dimension of a ComplexSpace can only' |
|
|
'be a positive integer, oo, or a Symbol: %r' |
|
|
% dimension) |
|
|
else: |
|
|
for dim in dimension.atoms(): |
|
|
if not (dim.is_Integer or dim is S.Infinity or dim.is_Symbol): |
|
|
raise TypeError('The dimension of a ComplexSpace can only' |
|
|
' contain integers, oo, or a Symbol: %r' |
|
|
% dim) |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
return self.args[0] |
|
|
|
|
|
def _sympyrepr(self, printer, *args): |
|
|
return "%s(%s)" % (self.__class__.__name__, |
|
|
printer._print(self.dimension, *args)) |
|
|
|
|
|
def _sympystr(self, printer, *args): |
|
|
return "C(%s)" % printer._print(self.dimension, *args) |
|
|
|
|
|
def _pretty(self, printer, *args): |
|
|
ustr = '\N{LATIN CAPITAL LETTER C}' |
|
|
pform_exp = printer._print(self.dimension, *args) |
|
|
pform_base = prettyForm(ustr) |
|
|
return pform_base**pform_exp |
|
|
|
|
|
def _latex(self, printer, *args): |
|
|
return r'\mathcal{C}^{%s}' % printer._print(self.dimension, *args) |
|
|
|
|
|
|
|
|
class L2(HilbertSpace): |
|
|
"""The Hilbert space of square integrable functions on an interval. |
|
|
|
|
|
An L2 object takes in a single SymPy Interval argument which represents |
|
|
the interval its functions (vectors) are defined on. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Interval, oo |
|
|
>>> from sympy.physics.quantum.hilbert import L2 |
|
|
>>> hs = L2(Interval(0,oo)) |
|
|
>>> hs |
|
|
L2(Interval(0, oo)) |
|
|
>>> hs.dimension |
|
|
oo |
|
|
>>> hs.interval |
|
|
Interval(0, oo) |
|
|
|
|
|
""" |
|
|
|
|
|
def __new__(cls, interval): |
|
|
if not isinstance(interval, Interval): |
|
|
raise TypeError('L2 interval must be an Interval instance: %r' |
|
|
% interval) |
|
|
obj = Basic.__new__(cls, interval) |
|
|
return obj |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
return S.Infinity |
|
|
|
|
|
@property |
|
|
def interval(self): |
|
|
return self.args[0] |
|
|
|
|
|
def _sympyrepr(self, printer, *args): |
|
|
return "L2(%s)" % printer._print(self.interval, *args) |
|
|
|
|
|
def _sympystr(self, printer, *args): |
|
|
return "L2(%s)" % printer._print(self.interval, *args) |
|
|
|
|
|
def _pretty(self, printer, *args): |
|
|
pform_exp = prettyForm('2') |
|
|
pform_base = prettyForm('L') |
|
|
return pform_base**pform_exp |
|
|
|
|
|
def _latex(self, printer, *args): |
|
|
interval = printer._print(self.interval, *args) |
|
|
return r'{\mathcal{L}^2}\left( %s \right)' % interval |
|
|
|
|
|
|
|
|
class FockSpace(HilbertSpace): |
|
|
"""The Hilbert space for second quantization. |
|
|
|
|
|
Technically, this Hilbert space is a infinite direct sum of direct |
|
|
products of single particle Hilbert spaces [1]_. This is a mess, so we have |
|
|
a class to represent it directly. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.physics.quantum.hilbert import FockSpace |
|
|
>>> hs = FockSpace() |
|
|
>>> hs |
|
|
F |
|
|
>>> hs.dimension |
|
|
oo |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Fock_space |
|
|
""" |
|
|
|
|
|
def __new__(cls): |
|
|
obj = Basic.__new__(cls) |
|
|
return obj |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
return S.Infinity |
|
|
|
|
|
def _sympyrepr(self, printer, *args): |
|
|
return "FockSpace()" |
|
|
|
|
|
def _sympystr(self, printer, *args): |
|
|
return "F" |
|
|
|
|
|
def _pretty(self, printer, *args): |
|
|
ustr = '\N{LATIN CAPITAL LETTER F}' |
|
|
return prettyForm(ustr) |
|
|
|
|
|
def _latex(self, printer, *args): |
|
|
return r'\mathcal{F}' |
|
|
|
|
|
|
|
|
class TensorProductHilbertSpace(HilbertSpace): |
|
|
"""A tensor product of Hilbert spaces [1]_. |
|
|
|
|
|
The tensor product between Hilbert spaces is represented by the |
|
|
operator ``*`` Products of the same Hilbert space will be combined into |
|
|
tensor powers. |
|
|
|
|
|
A ``TensorProductHilbertSpace`` object takes in an arbitrary number of |
|
|
``HilbertSpace`` objects as its arguments. In addition, multiplication of |
|
|
``HilbertSpace`` objects will automatically return this tensor product |
|
|
object. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.physics.quantum.hilbert import ComplexSpace, FockSpace |
|
|
>>> from sympy import symbols |
|
|
|
|
|
>>> c = ComplexSpace(2) |
|
|
>>> f = FockSpace() |
|
|
>>> hs = c*f |
|
|
>>> hs |
|
|
C(2)*F |
|
|
>>> hs.dimension |
|
|
oo |
|
|
>>> hs.spaces |
|
|
(C(2), F) |
|
|
|
|
|
>>> c1 = ComplexSpace(2) |
|
|
>>> n = symbols('n') |
|
|
>>> c2 = ComplexSpace(n) |
|
|
>>> hs = c1*c2 |
|
|
>>> hs |
|
|
C(2)*C(n) |
|
|
>>> hs.dimension |
|
|
2*n |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Hilbert_space#Tensor_products |
|
|
""" |
|
|
|
|
|
def __new__(cls, *args): |
|
|
r = cls.eval(args) |
|
|
if isinstance(r, Basic): |
|
|
return r |
|
|
obj = Basic.__new__(cls, *args) |
|
|
return obj |
|
|
|
|
|
@classmethod |
|
|
def eval(cls, args): |
|
|
"""Evaluates the direct product.""" |
|
|
new_args = [] |
|
|
recall = False |
|
|
|
|
|
for arg in args: |
|
|
if isinstance(arg, TensorProductHilbertSpace): |
|
|
new_args.extend(arg.args) |
|
|
recall = True |
|
|
elif isinstance(arg, (HilbertSpace, TensorPowerHilbertSpace)): |
|
|
new_args.append(arg) |
|
|
else: |
|
|
raise TypeError('Hilbert spaces can only be multiplied by \ |
|
|
other Hilbert spaces: %r' % arg) |
|
|
|
|
|
comb_args = [] |
|
|
prev_arg = None |
|
|
for new_arg in new_args: |
|
|
if prev_arg is not None: |
|
|
if isinstance(new_arg, TensorPowerHilbertSpace) and \ |
|
|
isinstance(prev_arg, TensorPowerHilbertSpace) and \ |
|
|
new_arg.base == prev_arg.base: |
|
|
prev_arg = new_arg.base**(new_arg.exp + prev_arg.exp) |
|
|
elif isinstance(new_arg, TensorPowerHilbertSpace) and \ |
|
|
new_arg.base == prev_arg: |
|
|
prev_arg = prev_arg**(new_arg.exp + 1) |
|
|
elif isinstance(prev_arg, TensorPowerHilbertSpace) and \ |
|
|
new_arg == prev_arg.base: |
|
|
prev_arg = new_arg**(prev_arg.exp + 1) |
|
|
elif new_arg == prev_arg: |
|
|
prev_arg = new_arg**2 |
|
|
else: |
|
|
comb_args.append(prev_arg) |
|
|
prev_arg = new_arg |
|
|
elif prev_arg is None: |
|
|
prev_arg = new_arg |
|
|
comb_args.append(prev_arg) |
|
|
if recall: |
|
|
return TensorProductHilbertSpace(*comb_args) |
|
|
elif len(comb_args) == 1: |
|
|
return TensorPowerHilbertSpace(comb_args[0].base, comb_args[0].exp) |
|
|
else: |
|
|
return None |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
arg_list = [arg.dimension for arg in self.args] |
|
|
if S.Infinity in arg_list: |
|
|
return S.Infinity |
|
|
else: |
|
|
return reduce(lambda x, y: x*y, arg_list) |
|
|
|
|
|
@property |
|
|
def spaces(self): |
|
|
"""A tuple of the Hilbert spaces in this tensor product.""" |
|
|
return self.args |
|
|
|
|
|
def _spaces_printer(self, printer, *args): |
|
|
spaces_strs = [] |
|
|
for arg in self.args: |
|
|
s = printer._print(arg, *args) |
|
|
if isinstance(arg, DirectSumHilbertSpace): |
|
|
s = '(%s)' % s |
|
|
spaces_strs.append(s) |
|
|
return spaces_strs |
|
|
|
|
|
def _sympyrepr(self, printer, *args): |
|
|
spaces_reprs = self._spaces_printer(printer, *args) |
|
|
return "TensorProductHilbertSpace(%s)" % ','.join(spaces_reprs) |
|
|
|
|
|
def _sympystr(self, printer, *args): |
|
|
spaces_strs = self._spaces_printer(printer, *args) |
|
|
return '*'.join(spaces_strs) |
|
|
|
|
|
def _pretty(self, printer, *args): |
|
|
length = len(self.args) |
|
|
pform = printer._print('', *args) |
|
|
for i in range(length): |
|
|
next_pform = printer._print(self.args[i], *args) |
|
|
if isinstance(self.args[i], (DirectSumHilbertSpace, |
|
|
TensorProductHilbertSpace)): |
|
|
next_pform = prettyForm( |
|
|
*next_pform.parens(left='(', right=')') |
|
|
) |
|
|
pform = prettyForm(*pform.right(next_pform)) |
|
|
if i != length - 1: |
|
|
if printer._use_unicode: |
|
|
pform = prettyForm(*pform.right(' ' + '\N{N-ARY CIRCLED TIMES OPERATOR}' + ' ')) |
|
|
else: |
|
|
pform = prettyForm(*pform.right(' x ')) |
|
|
return pform |
|
|
|
|
|
def _latex(self, printer, *args): |
|
|
length = len(self.args) |
|
|
s = '' |
|
|
for i in range(length): |
|
|
arg_s = printer._print(self.args[i], *args) |
|
|
if isinstance(self.args[i], (DirectSumHilbertSpace, |
|
|
TensorProductHilbertSpace)): |
|
|
arg_s = r'\left(%s\right)' % arg_s |
|
|
s = s + arg_s |
|
|
if i != length - 1: |
|
|
s = s + r'\otimes ' |
|
|
return s |
|
|
|
|
|
|
|
|
class DirectSumHilbertSpace(HilbertSpace): |
|
|
"""A direct sum of Hilbert spaces [1]_. |
|
|
|
|
|
This class uses the ``+`` operator to represent direct sums between |
|
|
different Hilbert spaces. |
|
|
|
|
|
A ``DirectSumHilbertSpace`` object takes in an arbitrary number of |
|
|
``HilbertSpace`` objects as its arguments. Also, addition of |
|
|
``HilbertSpace`` objects will automatically return a direct sum object. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.physics.quantum.hilbert import ComplexSpace, FockSpace |
|
|
|
|
|
>>> c = ComplexSpace(2) |
|
|
>>> f = FockSpace() |
|
|
>>> hs = c+f |
|
|
>>> hs |
|
|
C(2)+F |
|
|
>>> hs.dimension |
|
|
oo |
|
|
>>> list(hs.spaces) |
|
|
[C(2), F] |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Hilbert_space#Direct_sums |
|
|
""" |
|
|
def __new__(cls, *args): |
|
|
r = cls.eval(args) |
|
|
if isinstance(r, Basic): |
|
|
return r |
|
|
obj = Basic.__new__(cls, *args) |
|
|
return obj |
|
|
|
|
|
@classmethod |
|
|
def eval(cls, args): |
|
|
"""Evaluates the direct product.""" |
|
|
new_args = [] |
|
|
recall = False |
|
|
|
|
|
for arg in args: |
|
|
if isinstance(arg, DirectSumHilbertSpace): |
|
|
new_args.extend(arg.args) |
|
|
recall = True |
|
|
elif isinstance(arg, HilbertSpace): |
|
|
new_args.append(arg) |
|
|
else: |
|
|
raise TypeError('Hilbert spaces can only be summed with other \ |
|
|
Hilbert spaces: %r' % arg) |
|
|
if recall: |
|
|
return DirectSumHilbertSpace(*new_args) |
|
|
else: |
|
|
return None |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
arg_list = [arg.dimension for arg in self.args] |
|
|
if S.Infinity in arg_list: |
|
|
return S.Infinity |
|
|
else: |
|
|
return reduce(lambda x, y: x + y, arg_list) |
|
|
|
|
|
@property |
|
|
def spaces(self): |
|
|
"""A tuple of the Hilbert spaces in this direct sum.""" |
|
|
return self.args |
|
|
|
|
|
def _sympyrepr(self, printer, *args): |
|
|
spaces_reprs = [printer._print(arg, *args) for arg in self.args] |
|
|
return "DirectSumHilbertSpace(%s)" % ','.join(spaces_reprs) |
|
|
|
|
|
def _sympystr(self, printer, *args): |
|
|
spaces_strs = [printer._print(arg, *args) for arg in self.args] |
|
|
return '+'.join(spaces_strs) |
|
|
|
|
|
def _pretty(self, printer, *args): |
|
|
length = len(self.args) |
|
|
pform = printer._print('', *args) |
|
|
for i in range(length): |
|
|
next_pform = printer._print(self.args[i], *args) |
|
|
if isinstance(self.args[i], (DirectSumHilbertSpace, |
|
|
TensorProductHilbertSpace)): |
|
|
next_pform = prettyForm( |
|
|
*next_pform.parens(left='(', right=')') |
|
|
) |
|
|
pform = prettyForm(*pform.right(next_pform)) |
|
|
if i != length - 1: |
|
|
if printer._use_unicode: |
|
|
pform = prettyForm(*pform.right(' \N{CIRCLED PLUS} ')) |
|
|
else: |
|
|
pform = prettyForm(*pform.right(' + ')) |
|
|
return pform |
|
|
|
|
|
def _latex(self, printer, *args): |
|
|
length = len(self.args) |
|
|
s = '' |
|
|
for i in range(length): |
|
|
arg_s = printer._print(self.args[i], *args) |
|
|
if isinstance(self.args[i], (DirectSumHilbertSpace, |
|
|
TensorProductHilbertSpace)): |
|
|
arg_s = r'\left(%s\right)' % arg_s |
|
|
s = s + arg_s |
|
|
if i != length - 1: |
|
|
s = s + r'\oplus ' |
|
|
return s |
|
|
|
|
|
|
|
|
class TensorPowerHilbertSpace(HilbertSpace): |
|
|
"""An exponentiated Hilbert space [1]_. |
|
|
|
|
|
Tensor powers (repeated tensor products) are represented by the |
|
|
operator ``**`` Identical Hilbert spaces that are multiplied together |
|
|
will be automatically combined into a single tensor power object. |
|
|
|
|
|
Any Hilbert space, product, or sum may be raised to a tensor power. The |
|
|
``TensorPowerHilbertSpace`` takes two arguments: the Hilbert space; and the |
|
|
tensor power (number). |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy.physics.quantum.hilbert import ComplexSpace, FockSpace |
|
|
>>> from sympy import symbols |
|
|
|
|
|
>>> n = symbols('n') |
|
|
>>> c = ComplexSpace(2) |
|
|
>>> hs = c**n |
|
|
>>> hs |
|
|
C(2)**n |
|
|
>>> hs.dimension |
|
|
2**n |
|
|
|
|
|
>>> c = ComplexSpace(2) |
|
|
>>> c*c |
|
|
C(2)**2 |
|
|
>>> f = FockSpace() |
|
|
>>> c*f*f |
|
|
C(2)*F**2 |
|
|
|
|
|
References |
|
|
========== |
|
|
|
|
|
.. [1] https://en.wikipedia.org/wiki/Hilbert_space#Tensor_products |
|
|
""" |
|
|
|
|
|
def __new__(cls, *args): |
|
|
r = cls.eval(args) |
|
|
if isinstance(r, Basic): |
|
|
return r |
|
|
return Basic.__new__(cls, *r) |
|
|
|
|
|
@classmethod |
|
|
def eval(cls, args): |
|
|
new_args = args[0], sympify(args[1]) |
|
|
exp = new_args[1] |
|
|
|
|
|
if exp is S.One: |
|
|
return args[0] |
|
|
|
|
|
if exp is S.Zero: |
|
|
return S.One |
|
|
|
|
|
if len(exp.atoms()) == 1: |
|
|
if not (exp.is_Integer and exp >= 0 or exp.is_Symbol): |
|
|
raise ValueError('Hilbert spaces can only be raised to \ |
|
|
positive integers or Symbols: %r' % exp) |
|
|
else: |
|
|
for power in exp.atoms(): |
|
|
if not (power.is_Integer or power.is_Symbol): |
|
|
raise ValueError('Tensor powers can only contain integers \ |
|
|
or Symbols: %r' % power) |
|
|
return new_args |
|
|
|
|
|
@property |
|
|
def base(self): |
|
|
return self.args[0] |
|
|
|
|
|
@property |
|
|
def exp(self): |
|
|
return self.args[1] |
|
|
|
|
|
@property |
|
|
def dimension(self): |
|
|
if self.base.dimension is S.Infinity: |
|
|
return S.Infinity |
|
|
else: |
|
|
return self.base.dimension**self.exp |
|
|
|
|
|
def _sympyrepr(self, printer, *args): |
|
|
return "TensorPowerHilbertSpace(%s,%s)" % (printer._print(self.base, |
|
|
*args), printer._print(self.exp, *args)) |
|
|
|
|
|
def _sympystr(self, printer, *args): |
|
|
return "%s**%s" % (printer._print(self.base, *args), |
|
|
printer._print(self.exp, *args)) |
|
|
|
|
|
def _pretty(self, printer, *args): |
|
|
pform_exp = printer._print(self.exp, *args) |
|
|
if printer._use_unicode: |
|
|
pform_exp = prettyForm(*pform_exp.left(prettyForm('\N{N-ARY CIRCLED TIMES OPERATOR}'))) |
|
|
else: |
|
|
pform_exp = prettyForm(*pform_exp.left(prettyForm('x'))) |
|
|
pform_base = printer._print(self.base, *args) |
|
|
return pform_base**pform_exp |
|
|
|
|
|
def _latex(self, printer, *args): |
|
|
base = printer._print(self.base, *args) |
|
|
exp = printer._print(self.exp, *args) |
|
|
return r'{%s}^{\otimes %s}' % (base, exp) |
|
|
|
