Hi Dinakar,

It makes more sense to post it on sage-devel as it concerns Sage
development and not a question you have about Sage. So I did the
forward.

Vincent

---------- Forwarded message ----------
From: Dinakar Muthiah <dmuth...@gmail.com>
Date: Sun, 12 Oct 2014 11:51:56 -0700 (PDT)
Subject: [sage-support] A mathematical mistake in root_lattice_realizations.py
To: sage-supp...@googlegroups.com

I claim there is currently a mathematical mistake in the way the
"is_real_root" method in the file root_lattice_realizations.py is
implemented. There is also a parallel mistake in "is_imaginary_root". Let
me illustrate with an example:

sage: R = RootSystem(["A",2,1]).weight_lattice()
sage: alpha = R.simple_roots()
sage: alpha[0].is_real_root()
True
sage: b = 2*alpha[0]
sage: b.is_real_root()
True

b.is_real_root() should return false because 2*alpha[0] is not a real root.
In particular, 2*alpha[0] is not a root.

Looking at the implementation of "is_real_root()", it is easy to see why
this isn't working properly.

        def is_real_root(self):
            r"""
            Return ``True`` if ``self`` is a real root.

            A root `\alpha` is real if it is `W` conjugate to a simple
            root where `W` is the corresponding Weyl group.

            EXAMPLES::

                sage: Q = RootSystem(['B',2,1]).root_lattice()
                sage: alpha = Q.simple_roots()
                sage: alpha[0].is_real_root()
                True
                sage: elt = alpha[0] + alpha[1] + 2*alpha[2]
                sage: elt.is_real_root()
                False
            """
            return self.norm_squared() > 0

self.norm_squared() is not the way to check whether an element of the root
space or weight_space is a real root.

The problem is that there is no check to see whether self is a root. In
affine types, the following should work:

return (self.norm_squared() > 0) and self.is_root()

where is_root() would be a method that checks whether self is a root. But
this isn't currently implemented, and I don't know what would be the most
intelligent way to implement this. In affine types, this is fairly straight
forward assuming you have a test for checking whether something is a root
in the finite root system, but I don't know for general Cartan types.

What do people think about this? I have not contributed to sage in the
past, but I am interested in implementing the fix.

Also, is there a better place for me to post this bug. I looked
here: http://wiki.sagemath.org/support/ReportingBugs, and it suggested I
post on sage-support since I don't have experience developing sage or using
trac.

Best,
Dinakar

-- 
You received this message because you are subscribed to the Google Groups 
"sage-devel" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to sage-devel+unsubscr...@googlegroups.com.
To post to this group, send email to sage-devel@googlegroups.com.
Visit this group at http://groups.google.com/group/sage-devel.
For more options, visit https://groups.google.com/d/optout.

Reply via email to