On Friday, June 19, 2020 at 2:24:55 AM UTC-7, Dima Pasechnik wrote:
>
> My problem is that if a group acts on itself, conjugation actions (be 
> it h|->ghg^-1 or h|->g^-1 hg) 
> are vastly different from regular actions (left or right). 
>
> How are you going to use '^' for both? 
>
> I think in mathematics this problem does not usually arise: Groups have a 
left- and right- coset action on their underlying sets, but that's not an 
action that respects the group structure. They also have a left- and 
right-conjugation action on themselves which does respect the group 
operation. So you can tell from the category which action is being 
considered.

We already have left- and right-multiplication to denote the coset actions 
(because that's where the action comes from!)

Hence, the choice in mathematics to use exponentiation for (right) 
conjugation a^s=s^(-1)*a*s. Left conjugation is a little harder to denote, 
because we don't have a convenient way of writing "presuperscripts", but 
that's an area where also in math notation you need to get careful. The 
obvious way would be to define left: G->Aut(G) and write left(s)(a) [or in 
math probably left_s(a)] 

I don't think the discussion here is to abolish all multiplicatively 
written actions. I'm pretty sure people don't want to start writing scalar 
multiplication as exponentiation. I read it more are an exploration of what 
tools are/should be available for denoting actions that aren't conveniently 
denoted multiplicatively. It looks to me like there is a significant 
consensus (and prior art) that function application (for left action) and 
exponentiation (for right action) are reasonable options, and that it's 
slightly unfortunate that there's no convenient notation in python for 
applying functions from the right, but that any "fix" of that is worse than 
the problem.

If we were to use method notation, then there's a ridiculous asymmetry: for 
right actions, acted-upon elements would need to know about the action:

a.right_action(s)

and for left-actions, the group elements would have to know how to act:

s.left_action(a)

All this disappears once we are happy using functions with two parameters 
as "action operation":

left = G.acting_on_the_left_on(M) # or left = M.left_action_by(G)

left(g,m)

left = G.acting_on_the_right_on(M) # or left = M.right_action_by(G)

right(m,g)

in cases where we're running out of action notations, I'd far prefer seeing 
this explicitly labelled notation.


-- 
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 view this discussion on the web visit 
https://groups.google.com/d/msgid/sage-devel/9adf6643-5aab-4db7-a9b8-5660f1c37947o%40googlegroups.com.

Reply via email to