implementing ror32 concisely?

[Geremia]

I'm trying to implement a 32 bit rotation:

module ror32(out o, in shift, in word)
  o ^= ((word >> shift) | (word << (32 - shift)))

But it gives:

line 2:17 no viable alternative at input '((word >> shift'
"-- line 2 col 17: no viable alternative at input '((word >> shift'"

Is there a way to implement it more concisely than doing something like the following?

ror32 with tons of if statements

module ror32(out o, in shift, in word)
  if (shift = 1) then
    o ^= ((word >> 1) | (word << 30))
  else
  if (shift = 2) then
    o ^= ((word >> 2) | (word << 29))
  else
  if (shift = 3) then
    o ^= ((word >> 3) | (word << 28))
  else
  if (shift = 4) then
    o ^= ((word >> 4) | (word << 27))
  else
  if (shift = 5) then
    o ^= ((word >> 5) | (word << 26))
  else
  if (shift = 6) then
    o ^= ((word >> 6) | (word << 25))
  else
  if (shift = 7) then
    o ^= ((word >> 7) | (word << 24))
  else
  if (shift = 8) then
    o ^= ((word >> 8) | (word << 23))
  else
  if (shift = 9) then
    o ^= ((word >> 9) | (word << 22))
  else
  if (shift = 10) then
    o ^= ((word >> 10) | (word << 21))
  else
  if (shift = 11) then
    o ^= ((word >> 11) | (word << 20))
  else
  if (shift = 12) then
    o ^= ((word >> 12) | (word << 19))
  else
  if (shift = 13) then
    o ^= ((word >> 13) | (word << 18))
  else
  if (shift = 14) then
    o ^= ((word >> 14) | (word << 17))
  else
  if (shift = 15) then
    o ^= ((word >> 15) | (word << 16))
  else
  if (shift = 16) then
    o ^= ((word >> 16) | (word << 15))
  else
  if (shift = 17) then
    o ^= ((word >> 17) | (word << 14))
  else
  if (shift = 18) then
    o ^= ((word >> 18) | (word << 13))
  else
  if (shift = 19) then
    o ^= ((word >> 19) | (word << 12))
  else
  if (shift = 20) then
    o ^= ((word >> 20) | (word << 11))
  else
  if (shift = 21) then
    o ^= ((word >> 21) | (word << 10))
  else
  if (shift = 22) then
    o ^= ((word >> 22) | (word << 9))
  else
  if (shift = 23) then
    o ^= ((word >> 23) | (word << 8))
  else
  if (shift = 24) then
    o ^= ((word >> 24) | (word << 7))
  else
  if (shift = 25) then
    o ^= ((word >> 25) | (word << 6))
  else
  if (shift = 26) then
    o ^= ((word >> 26) | (word << 5))
  else
  if (shift = 27) then
    o ^= ((word >> 27) | (word << 4))
  else
  if (shift = 28) then
    o ^= ((word >> 28) | (word << 3))
  else
  if (shift = 29) then
    o ^= ((word >> 29) | (word << 2))
  else
  if (shift = 30) then
    o ^= ((word >> 30) | (word << 1))
  else
  if (shift = 31) then
    o ^= (word >> 31)
  else
    o ^= word
  fi (shift = 31)
  fi (shift = 30)
  fi (shift = 29)
  fi (shift = 28)
  fi (shift = 27)
  fi (shift = 26)
  fi (shift = 25)
  fi (shift = 24)
  fi (shift = 23)
  fi (shift = 22)
  fi (shift = 21)
  fi (shift = 20)
  fi (shift = 19)
  fi (shift = 18)
  fi (shift = 17)
  fi (shift = 16)
  fi (shift = 15)
  fi (shift = 14)
  fi (shift = 13)
  fi (shift = 12)
  fi (shift = 11)
  fi (shift = 10)
  fi (shift = 9)
  fi (shift = 8)
  fi (shift = 7)
  fi (shift = 6)
  fi (shift = 5)
  fi (shift = 4)
  fi (shift = 3)
  fi (shift = 2)
  fi (shift = 1)

[TooMuchDakka]

Since the value of the shift amount must be known during synthesis, a more concise equivalent of your ror32 SyReC module could look like this:

module ror32(out o(32), in shift(5), in word(32))
 // TODO: Define maximum shift amount as upper bound of loop (i.e. as 2^(#shift))
 for $i = 0 to 32 do 
   if ($i = shift) then
    // Perform 'shift' logical shift of qubits [shift, #word - 1] of 'word' qubits and store result in 'o'
    for $l = 0 to (#word - $i) do
     o.$l ^= word.($i + $l)
    rof;
   // Perform circular shift of qubits [0, shift - 1) of 'word' qubits and store result in 'o'
    for $r = 0 to $i do
     o.((#word - $i) + $r) ^= word.$r
    rof
   else
    skip
   fi ($i = shift)
 rof

Based on the potential values of the shift parameter I am assuming that the bitwidth of the parameters o and word is equal to 32. Please note that I only tested a few state combinations to verify the solution so bugs could still be present.

Comparing the costs of the two circuits the proposed solution here would be the cheaper one:

ORIGINAL:
Number Of quantum operations :  5688
Number Of qubits             :  3167
Number Of input qubits       :  69
Number Of ancilla qubits     :  3098
Number of output qubits      :  69
Number of garbage qubits     :  37

PROPOSED:
Number Of quantum operations :  1840
Number Of qubits             :  261
Number Of input qubits       :  69
Number Of ancilla qubits     :  192
Number of output qubits      :  69
Number of garbage qubits     :  37

[Geremia]

@TooMuchDakka I get:

User defined bitrange start value '32' was not within the valid range [0, 32] in bitrange access on variable o
User defined bitrange start value '32' was not within the valid range [0, 32] in bitrange access on variable o

[TooMuchDakka]

Are you using the latest commit from the main branch that contains a bugfix for the iteration range of a ForStatement (see #483)? Otherwise, the version of the ror32 SyReC module from my answer cannot be synthesized without errors.

[Geremia]

@TooMuchDakka Thanks. That bugfix helped.