cirq.Rx/Ry/Rz(pi) has confusing QASM output since these are not gates on their own.

[balopat]

as cirq.Rx() is just an XPowGate instantiation, Rx(pi) becomes x. This is just true up to a global phase, but also might be surprising for users. Also Rx(0) is not id, so it is not consistent.

Recommendations:

• cirq.Rx/Ry/Rx would become proper subclasses of XPowGate instead of just methods and override the _qasm_ to keep the rx(<angle>) q; QASM output form.
• XPowGate._qasm_ should handle the identity case when _exponent == 0

[Strilanc]

Now that we have cirq.GlobalPhaseOperation, I think we should consider removing global_shift from EigenGate resulting in splitting RxGate out of XPowGate.

[mpharrigan]

That's a pretty big change

[Strilanc]

Yeah, there's no particular rush on making it. We could start by perhaps extracting RxGate as a child class of XPowGate.

[balopat]

As this is QasmOutput related there might be other ways around it - i.e we could handle known gates in the Qasm protocol, this way this Qasm specific structure doesn't have to force anything on the Cirq representation - there are other places where this is an issue, namely the S and T gates (and maybe CH, CY could be supported too?):

Code generating QASM

import cirq
import numpy as np 

a, b, c, d = cirq.LineQubit.range(4)

ops = [
# these have a "differing" qasm output
cirq.Rx(np.pi).on(a),
cirq.Ry(np.pi).on(b),
cirq.Rz(np.pi).on(b),
cirq.S.on(a),
cirq.T.on(b),
cirq.S.on(c)**-1,
cirq.T.on(d)**-1,
cirq.ControlledGate(cirq.Y).on(c,d),
cirq.ControlledGate(cirq.H).on(b,c),
    
# these are okay
cirq.Rx(np.pi / 2).on(a),
cirq.Ry(np.pi / 2).on(b),
cirq.Rz(np.pi / 2).on(b),
cirq.Rx(0).on(a),
cirq.Ry(0).on(b),
cirq.Rz(0).on(b),
cirq.X.on(a),
cirq.Y.on(b),
cirq.Z.on(c),
cirq.H.on(d),
cirq.CSWAP.on(d, a, b),
cirq.SWAP.on(c, d),
cirq.CX.on(a,b),
cirq.CZ.on(a,b),
cirq.IdentityGate(1).on(c),
cirq.circuits.qasm_output.QasmUGate(1.0, 2.0, 3.0).on(d)
] 

for op in ops: 
    c = cirq.Circuit.from_ops(op)
    print(c)
    print('qasm: {}'.format(cirq.qasm(c).splitlines()[-1]))
    print()

QASM output

0: ───Rx(π)───
qasm: x q[0];

1: ───Ry(π)───
qasm: y q[0];

1: ───Rz(π)───
qasm: z q[0];

0: ───S───
qasm: rz(pi*0.5) q[0];

1: ───T───
qasm: rz(pi*0.25) q[0];

2: ───S^-1───
qasm: rz(pi*-0.5) q[0];

3: ───T^-1───
qasm: rz(pi*-0.25) q[0];

2: ───@───
      │
3: ───Y───
qasm: u3(pi*0.25,pi*1.0,pi*0.5) q[1];

1: ───@───
      │
2: ───H───
qasm: u3(pi*0.9775301667,pi*1.5,pi*1.5) q[1];

0: ───Rx(0.5π)───
qasm: rx(pi*0.5) q[0];

1: ───Ry(0.5π)───
qasm: ry(pi*0.5) q[0];

1: ───Rz(0.5π)───
qasm: rz(pi*0.5) q[0];

0: ───Rx(0.0π)───
qasm: rx(0) q[0];

1: ───Ry(0.0π)───
qasm: ry(0) q[0];

1: ───Rz(0.0π)───
qasm: rz(0) q[0];

0: ───X───
qasm: x q[0];

1: ───Y───
qasm: y q[0];

2: ───Z───
qasm: z q[0];

3: ───H───
qasm: h q[0];

0: ───×───
      │
1: ───×───
      │
3: ───@───
qasm: cswap q[2],q[0],q[1];

2: ───×───
      │
3: ───×───
qasm: swap q[0],q[1];

0: ───@───
      │
1: ───X───
qasm: cx q[0],q[1];

0: ───@───
      │
1: ───@───
qasm: cz q[0],q[1];

2: ───I───
qasm: id q[0];

3: ───cirq.QasmUGate(1.0, 0.0, 1.0)───
qasm: u3(pi*1.0,0,pi*1.0) q[0];