X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=06f6f531ac46305da59ec2b4290ba808602cea50;hb=0fd07263cc543e345f3cd7668938f8a0de70641f;hp=362b03a6695a00061034cb9168ba76021a9e2daf;hpb=a7cf81951d0cb51ea40d9362a75385204596df42;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 362b03a..06f6f53 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -5,65 +5,37 @@ are used in optimization, and have some additional nice methods beyond what can be supported in a general Jordan Algebra. """ -from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra import FiniteDimensionalAlgebra from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra -from sage.categories.finite_dimensional_algebras_with_basis import FiniteDimensionalAlgebrasWithBasis +from sage.categories.magmatic_algebras import MagmaticAlgebras +from sage.combinat.free_module import CombinatorialFreeModule from sage.matrix.constructor import matrix from sage.misc.cachefunc import cached_method from sage.misc.prandom import choice -from sage.modules.free_module import VectorSpace +from sage.misc.table import table +from sage.modules.free_module import FreeModule, VectorSpace from sage.rings.integer_ring import ZZ from sage.rings.number_field.number_field import QuadraticField from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing from sage.rings.rational_field import QQ from sage.structure.element import is_Matrix -from sage.structure.category_object import normalize_names from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement -from mjo.eja.eja_utils import _vec2mat, _mat2vec - -class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): - @staticmethod - def __classcall_private__(cls, - field, - mult_table, - rank, - names='e', - assume_associative=False, - category=None, - natural_basis=None): - n = len(mult_table) - mult_table = [b.base_extend(field) for b in mult_table] - for b in mult_table: - b.set_immutable() - if not (is_Matrix(b) and b.dimensions() == (n, n)): - raise ValueError("input is not a multiplication table") - mult_table = tuple(mult_table) - - cat = FiniteDimensionalAlgebrasWithBasis(field) - cat.or_subcategory(category) - if assume_associative: - cat = cat.Associative() - - names = normalize_names(n, names) - - fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls) - return fda.__classcall__(cls, - field, - mult_table, - rank, - assume_associative=assume_associative, - names=names, - category=cat, - natural_basis=natural_basis) +from mjo.eja.eja_utils import _mat2vec +class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): + # This is an ugly hack needed to prevent the category framework + # from implementing a coercion from our base ring (e.g. the + # rationals) into the algebra. First of all -- such a coercion is + # nonsense to begin with. But more importantly, it tries to do so + # in the category of rings, and since our algebras aren't + # associative they generally won't be rings. + _no_generic_basering_coercion = True def __init__(self, field, mult_table, rank, - names='e', - assume_associative=False, + prefix='e', category=None, natural_basis=None): """ @@ -85,12 +57,93 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): """ self._rank = rank self._natural_basis = natural_basis - self._multiplication_table = mult_table + + if category is None: + category = MagmaticAlgebras(field).FiniteDimensional() + category = category.WithBasis().Unital() + fda = super(FiniteDimensionalEuclideanJordanAlgebra, self) fda.__init__(field, - mult_table, - names=names, + range(len(mult_table)), + prefix=prefix, category=category) + self.print_options(bracket='') + + # The multiplication table we're given is necessarily in terms + # of vectors, because we don't have an algebra yet for + # anything to be an element of. However, it's faster in the + # long run to have the multiplication table be in terms of + # algebra elements. We do this after calling the superclass + # constructor so that from_vector() knows what to do. + self._multiplication_table = [ map(lambda x: self.from_vector(x), ls) + for ls in mult_table ] + + + def _element_constructor_(self, elt): + """ + Construct an element of this algebra from its natural + representation. + + This gets called only after the parent element _call_ method + fails to find a coercion for the argument. + + SETUP:: + + sage: from mjo.eja.eja_algebra import (JordanSpinEJA, + ....: RealCartesianProductEJA, + ....: RealSymmetricEJA) + + EXAMPLES: + + The identity in `S^n` is converted to the identity in the EJA:: + + sage: J = RealSymmetricEJA(3) + sage: I = matrix.identity(QQ,3) + sage: J(I) == J.one() + True + + This skew-symmetric matrix can't be represented in the EJA:: + + sage: J = RealSymmetricEJA(3) + sage: A = matrix(QQ,3, lambda i,j: i-j) + sage: J(A) + Traceback (most recent call last): + ... + ArithmeticError: vector is not in free module + + TESTS: + + Ensure that we can convert any element of the two non-matrix + simple algebras (whose natural representations are their usual + vector representations) back and forth faithfully:: + + sage: set_random_seed() + sage: J = RealCartesianProductEJA(5) + sage: x = J.random_element() + sage: J(x.to_vector().column()) == x + True + sage: J = JordanSpinEJA(5) + sage: x = J.random_element() + sage: J(x.to_vector().column()) == x + True + + """ + if elt == 0: + # The superclass implementation of random_element() + # needs to be able to coerce "0" into the algebra. + return self.zero() + + natural_basis = self.natural_basis() + if elt not in natural_basis[0].matrix_space(): + raise ValueError("not a naturally-represented algebra element") + + # Thanks for nothing! Matrix spaces aren't vector + # spaces in Sage, so we have to figure out its + # natural-basis coordinates ourselves. + V = VectorSpace(elt.base_ring(), elt.nrows()*elt.ncols()) + W = V.span_of_basis( _mat2vec(s) for s in natural_basis ) + coords = W.coordinate_vector(_mat2vec(elt)) + return self.from_vector(coords) def _repr_(self): @@ -106,14 +159,16 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): Ensure that it says what we think it says:: sage: JordanSpinEJA(2, field=QQ) - Euclidean Jordan algebra of degree 2 over Rational Field + Euclidean Jordan algebra of dimension 2 over Rational Field sage: JordanSpinEJA(3, field=RDF) - Euclidean Jordan algebra of degree 3 over Real Double Field + Euclidean Jordan algebra of dimension 3 over Real Double Field """ - fmt = "Euclidean Jordan algebra of degree {} over {}" - return fmt.format(self.degree(), self.base_ring()) + fmt = "Euclidean Jordan algebra of dimension {} over {}" + return fmt.format(self.dimension(), self.base_ring()) + def product_on_basis(self, i, j): + return self._multiplication_table[i][j] def _a_regular_element(self): """ @@ -152,8 +207,13 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): determinant). """ z = self._a_regular_element() - V = self.vector_space() - V1 = V.span_of_basis( (z**k).vector() for k in range(self.rank()) ) + # Don't use the parent vector space directly here in case this + # happens to be a subalgebra. In that case, we would be e.g. + # two-dimensional but span_of_basis() would expect three + # coordinates. + V = VectorSpace(self.base_ring(), self.vector_space().dimension()) + basis = [ (z**k).to_vector() for k in range(self.rank()) ] + V1 = V.span_of_basis( basis ) b = (V1.basis() + V1.complement().basis()) return V.span_of_basis(b) @@ -204,14 +264,40 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): r = self.rank() n = self.dimension() - # Construct a new algebra over a multivariate polynomial ring... - names = ['X' + str(i) for i in range(1,n+1)] + # Turn my vector space into a module so that "vectors" can + # have multivatiate polynomial entries. + names = tuple('X' + str(i) for i in range(1,n+1)) R = PolynomialRing(self.base_ring(), names) - J = FiniteDimensionalEuclideanJordanAlgebra(R, - self._multiplication_table, - r) - idmat = matrix.identity(J.base_ring(), n) + # Using change_ring() on the parent's vector space doesn't work + # here because, in a subalgebra, that vector space has a basis + # and change_ring() tries to bring the basis along with it. And + # that doesn't work unless the new ring is a PID, which it usually + # won't be. + V = FreeModule(R,n) + + # Now let x = (X1,X2,...,Xn) be the vector whose entries are + # indeterminates... + x = V(names) + + # And figure out the "left multiplication by x" matrix in + # that setting. + lmbx_cols = [] + monomial_matrices = [ self.monomial(i).operator().matrix() + for i in range(n) ] # don't recompute these! + for k in range(n): + ek = self.monomial(k).to_vector() + lmbx_cols.append( + sum( x[i]*(monomial_matrices[i]*ek) + for i in range(n) ) ) + Lx = matrix.column(R, lmbx_cols) + + # Now we can compute powers of x "symbolically" + x_powers = [self.one().to_vector(), x] + for d in range(2, r+1): + x_powers.append( Lx*(x_powers[-1]) ) + + idmat = matrix.identity(R, n) W = self._charpoly_basis_space() W = W.change_ring(R.fraction_field()) @@ -231,18 +317,10 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): # We want the middle equivalent thing in our matrix, but use # the first equivalent thing instead so that we can pass in # standard coordinates. - x = J(W(R.gens())) - - # Handle the zeroth power separately, because computing - # the unit element in J is mathematically suspect. - x0 = W.coordinates(self.one().vector()) - l1 = [ matrix.column(x0) ] - l1 += [ matrix.column(W.coordinates((x**k).vector())) - for k in range(1,r) ] - l2 = [idmat.column(k-1).column() for k in range(r+1, n+1)] - A_of_x = matrix.block(R, 1, n, (l1 + l2)) - xr = W.coordinates((x**r).vector()) - return (A_of_x, x, xr, A_of_x.det()) + x_powers = [ W.coordinate_vector(xp) for xp in x_powers ] + l2 = [idmat.column(k-1) for k in range(r+1, n+1)] + A_of_x = matrix.column(R, n, (x_powers[:r] + l2)) + return (A_of_x, x, x_powers[r], A_of_x.det()) @cached_method @@ -271,7 +349,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): sage: J = JordanSpinEJA(3) sage: p = J.characteristic_polynomial(); p X1^2 - X2^2 - X3^2 + (-2*t)*X1 + t^2 - sage: xvec = J.one().vector() + sage: xvec = J.one().to_vector() sage: p(*xvec) t^2 - 2*t + 1 @@ -337,6 +415,63 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return x.trace_inner_product(y) + def is_trivial(self): + """ + Return whether or not this algebra is trivial. + + A trivial algebra contains only the zero element. + + SETUP:: + + sage: from mjo.eja.eja_algebra import ComplexHermitianEJA + + EXAMPLES:: + + sage: J = ComplexHermitianEJA(3) + sage: J.is_trivial() + False + sage: A = J.zero().subalgebra_generated_by() + sage: A.is_trivial() + True + + """ + return self.dimension() == 0 + + + def multiplication_table(self): + """ + Return a visual representation of this algebra's multiplication + table (on basis elements). + + SETUP:: + + sage: from mjo.eja.eja_algebra import JordanSpinEJA + + EXAMPLES:: + + sage: J = JordanSpinEJA(4) + sage: J.multiplication_table() + +----++----+----+----+----+ + | * || e0 | e1 | e2 | e3 | + +====++====+====+====+====+ + | e0 || e0 | e1 | e2 | e3 | + +----++----+----+----+----+ + | e1 || e1 | e0 | 0 | 0 | + +----++----+----+----+----+ + | e2 || e2 | 0 | e0 | 0 | + +----++----+----+----+----+ + | e3 || e3 | 0 | 0 | e0 | + +----++----+----+----+----+ + + """ + M = list(self._multiplication_table) # copy + for i in range(len(M)): + # M had better be "square" + M[i] = [self.monomial(i)] + M[i] + M = [["*"] + list(self.gens())] + M + return table(M, header_row=True, header_column=True, frame=True) + + def natural_basis(self): """ Return a more-natural representation of this algebra's basis. @@ -359,7 +494,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): sage: J = RealSymmetricEJA(2) sage: J.basis() - Family (e0, e1, e2) + Finite family {0: e0, 1: e1, 2: e2} sage: J.natural_basis() ( [1 0] [0 1] [0 0] @@ -370,7 +505,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): sage: J = JordanSpinEJA(2) sage: J.basis() - Family (e0, e1) + Finite family {0: e0, 1: e1} sage: J.natural_basis() ( [1] [0] @@ -379,7 +514,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): """ if self._natural_basis is None: - return tuple( b.vector().column() for b in self.basis() ) + return tuple( b.to_vector().column() for b in self.basis() ) else: return self._natural_basis @@ -400,7 +535,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): sage: J.one() e0 + e1 + e2 + e3 + e4 - TESTS:: + TESTS: The identity element acts like the identity:: @@ -442,7 +577,16 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): # Now if there's an identity element in the algebra, this should work. coeffs = A.solve_right(b) - return self.linear_combination(zip(coeffs,self.gens())) + return self.linear_combination(zip(self.gens(), coeffs)) + + + def random_element(self): + # Temporary workaround for https://trac.sagemath.org/ticket/28327 + if self.is_trivial(): + return self.zero() + else: + s = super(FiniteDimensionalEuclideanJordanAlgebra, self) + return s.random_element() def rank(self): @@ -520,7 +664,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): Vector space of dimension 3 over Rational Field """ - return self.zero().vector().parent().ambient_vector_space() + return self.zero().to_vector().parent().ambient_vector_space() Element = FiniteDimensionalEuclideanJordanAlgebraElement @@ -558,19 +702,21 @@ class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: e2*e2 e2 + TESTS: + + We can change the generator prefix:: + + sage: RealCartesianProductEJA(3, prefix='r').gens() + (r0, r1, r2) + """ - @staticmethod - def __classcall_private__(cls, n, field=QQ): - # The FiniteDimensionalAlgebra constructor takes a list of - # matrices, the ith representing right multiplication by the ith - # basis element in the vector space. So if e_1 = (1,0,0), then - # right (Hadamard) multiplication of x by e_1 picks out the first - # component of x; and likewise for the ith basis element e_i. - Qs = [ matrix(field, n, n, lambda k,j: 1*(k == j == i)) - for i in xrange(n) ] - - fdeja = super(RealCartesianProductEJA, cls) - return fdeja.__classcall_private__(cls, field, Qs, rank=n) + def __init__(self, n, field=QQ, **kwargs): + V = VectorSpace(field, n) + mult_table = [ [ V.gen(i)*(i == j) for j in range(n) ] + for i in range(n) ] + + fdeja = super(RealCartesianProductEJA, self) + return fdeja.__init__(field, mult_table, rank=n, **kwargs) def inner_product(self, x, y): return _usual_ip(x,y) @@ -609,7 +755,7 @@ def random_eja(): TESTS:: sage: random_eja() - Euclidean Jordan algebra of degree... + Euclidean Jordan algebra of dimension... """ @@ -741,10 +887,7 @@ def _multiplication_table_from_matrix_basis(basis): multiplication on the right is matrix multiplication. Given a basis for the underlying matrix space, this function returns a multiplication table (obtained by looping through the basis - elements) for an algebra of those matrices. A reordered copy - of the basis is also returned to work around the fact that - the ``span()`` in this function will change the order of the basis - from what we think it is, to... something else. + elements) for an algebra of those matrices. """ # In S^2, for example, we nominally have four coordinates even # though the space is of dimension three only. The vector space V @@ -755,30 +898,15 @@ def _multiplication_table_from_matrix_basis(basis): dimension = basis[0].nrows() V = VectorSpace(field, dimension**2) - W = V.span( _mat2vec(s) for s in basis ) - - # Taking the span above reorders our basis (thanks, jerk!) so we - # need to put our "matrix basis" in the same order as the - # (reordered) vector basis. - S = tuple( _vec2mat(b) for b in W.basis() ) - - Qs = [] - for s in S: - # Brute force the multiplication-by-s matrix by looping - # through all elements of the basis and doing the computation - # to find out what the corresponding row should be. BEWARE: - # these multiplication tables won't be symmetric! It therefore - # becomes REALLY IMPORTANT that the underlying algebra - # constructor uses ROW vectors and not COLUMN vectors. That's - # why we're computing rows here and not columns. - Q_rows = [] - for t in S: - this_row = _mat2vec((s*t + t*s)/2) - Q_rows.append(W.coordinates(this_row)) - Q = matrix(field, W.dimension(), Q_rows) - Qs.append(Q) - - return (Qs, S) + W = V.span_of_basis( _mat2vec(s) for s in basis ) + n = len(basis) + mult_table = [[W.zero() for j in range(n)] for i in range(n)] + for i in range(n): + for j in range(n): + mat_entry = (basis[i]*basis[j] + basis[j]*basis[i])/2 + mult_table[i][j] = W.coordinate_vector(_mat2vec(mat_entry)) + + return mult_table def _embed_complex_matrix(M): @@ -1009,7 +1137,7 @@ def _unembed_quaternion_matrix(M): # The usual inner product on R^n. def _usual_ip(x,y): - return x.vector().inner_product(y.vector()) + return x.to_vector().inner_product(y.to_vector()) # The inner product used for the real symmetric simple EJA. # We keep it as a separate function because e.g. the complex @@ -1043,12 +1171,12 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra): TESTS: - The degree of this algebra is `(n^2 + n) / 2`:: + The dimension of this algebra is `(n^2 + n) / 2`:: sage: set_random_seed() sage: n = ZZ.random_element(1,5) sage: J = RealSymmetricEJA(n) - sage: J.degree() == (n^2 + n)/2 + sage: J.dimension() == (n^2 + n)/2 True The Jordan multiplication is what we think it is:: @@ -1067,18 +1195,22 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: J(expected) == x*y True + We can change the generator prefix:: + + sage: RealSymmetricEJA(3, prefix='q').gens() + (q0, q1, q2, q3, q4, q5) + """ - @staticmethod - def __classcall_private__(cls, n, field=QQ): + def __init__(self, n, field=QQ, **kwargs): S = _real_symmetric_basis(n, field=field) - (Qs, T) = _multiplication_table_from_matrix_basis(S) + Qs = _multiplication_table_from_matrix_basis(S) - fdeja = super(RealSymmetricEJA, cls) - return fdeja.__classcall_private__(cls, - field, - Qs, - rank=n, - natural_basis=T) + fdeja = super(RealSymmetricEJA, self) + return fdeja.__init__(field, + Qs, + rank=n, + natural_basis=S, + **kwargs) def inner_product(self, x, y): return _matrix_ip(x,y) @@ -1097,12 +1229,12 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): TESTS: - The degree of this algebra is `n^2`:: + The dimension of this algebra is `n^2`:: sage: set_random_seed() sage: n = ZZ.random_element(1,5) sage: J = ComplexHermitianEJA(n) - sage: J.degree() == n^2 + sage: J.dimension() == n^2 True The Jordan multiplication is what we think it is:: @@ -1121,18 +1253,23 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: J(expected) == x*y True + We can change the generator prefix:: + + sage: ComplexHermitianEJA(2, prefix='z').gens() + (z0, z1, z2, z3) + """ - @staticmethod - def __classcall_private__(cls, n, field=QQ): + def __init__(self, n, field=QQ, **kwargs): S = _complex_hermitian_basis(n) - (Qs, T) = _multiplication_table_from_matrix_basis(S) + Qs = _multiplication_table_from_matrix_basis(S) + + fdeja = super(ComplexHermitianEJA, self) + return fdeja.__init__(field, + Qs, + rank=n, + natural_basis=S, + **kwargs) - fdeja = super(ComplexHermitianEJA, cls) - return fdeja.__classcall_private__(cls, - field, - Qs, - rank=n, - natural_basis=T) def inner_product(self, x, y): # Since a+bi on the diagonal is represented as @@ -1158,12 +1295,12 @@ class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): TESTS: - The degree of this algebra is `n^2`:: + The dimension of this algebra is `n^2`:: sage: set_random_seed() sage: n = ZZ.random_element(1,5) sage: J = QuaternionHermitianEJA(n) - sage: J.degree() == 2*(n^2) - n + sage: J.dimension() == 2*(n^2) - n True The Jordan multiplication is what we think it is:: @@ -1182,18 +1319,22 @@ class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: J(expected) == x*y True + We can change the generator prefix:: + + sage: QuaternionHermitianEJA(2, prefix='a').gens() + (a0, a1, a2, a3, a4, a5) + """ - @staticmethod - def __classcall_private__(cls, n, field=QQ): + def __init__(self, n, field=QQ, **kwargs): S = _quaternion_hermitian_basis(n) - (Qs, T) = _multiplication_table_from_matrix_basis(S) + Qs = _multiplication_table_from_matrix_basis(S) - fdeja = super(QuaternionHermitianEJA, cls) - return fdeja.__classcall_private__(cls, - field, - Qs, - rank=n, - natural_basis=T) + fdeja = super(QuaternionHermitianEJA, self) + return fdeja.__init__(field, + Qs, + rank=n, + natural_basis=S, + **kwargs) def inner_product(self, x, y): # Since a+bi+cj+dk on the diagonal is represented as @@ -1240,27 +1381,34 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra): sage: e2*e3 0 + We can change the generator prefix:: + + sage: JordanSpinEJA(2, prefix='B').gens() + (B0, B1) + """ - @staticmethod - def __classcall_private__(cls, n, field=QQ): - Qs = [] - id_matrix = matrix.identity(field, n) - for i in xrange(n): - ei = id_matrix.column(i) - Qi = matrix.zero(field, n) - Qi.set_row(0, ei) - Qi.set_column(0, ei) - Qi += matrix.diagonal(n, [ei[0]]*n) - # The addition of the diagonal matrix adds an extra ei[0] in the - # upper-left corner of the matrix. - Qi[0,0] = Qi[0,0] * ~field(2) - Qs.append(Qi) + def __init__(self, n, field=QQ, **kwargs): + V = VectorSpace(field, n) + mult_table = [[V.zero() for j in range(n)] for i in range(n)] + for i in range(n): + for j in range(n): + x = V.gen(i) + y = V.gen(j) + x0 = x[0] + xbar = x[1:] + y0 = y[0] + ybar = y[1:] + # z = x*y + z0 = x.inner_product(y) + zbar = y0*xbar + x0*ybar + z = V([z0] + zbar.list()) + mult_table[i][j] = z # The rank of the spin algebra is two, unless we're in a # one-dimensional ambient space (because the rank is bounded by # the ambient dimension). - fdeja = super(JordanSpinEJA, cls) - return fdeja.__classcall_private__(cls, field, Qs, rank=min(n,2)) + fdeja = super(JordanSpinEJA, self) + return fdeja.__init__(field, mult_table, rank=min(n,2), **kwargs) def inner_product(self, x, y): return _usual_ip(x,y)