Как создать ограничение на побитовый оператор сдвига вправо в Circom

Как сгенерировать ограничение на побитовый оператор сдвига вправо в язык обходных цепей?

Я пытаюсь сделать следующее:

прагма цирком 2.0.0;

шаблон ГЛАВНЫЙ() {

    сигнальный вход v;
    тип выхода сигнала;

    введите <== v >> 5;
}

компонент main = MAIN();

Я получаю следующую ошибку:

error[T3001]: Неквадратичные ограничения не допускаются!
   ââ "/Users/ilia/compiling/main-circom/main.circom":68:5
   ✓
68 — тип <== v >> 5;
   ★ ^^^^^^^^^^^^^^^^ найдено здесь
   ✓
   = трассировка вызова:
     -> ГЛАВНЫЙ

Я думаю, это связано с тем, что v >> 5 выражение не может быть повторно выражено как квадратное выражение с помощью компилятор circom.

Я изо всех сил пытаюсь переписать выражение, чтобы оно было квадратичным. Это может включать в себя запись присваивания и ограничения как двух отдельных операций, но я не уверен, что правильное ограничение проверки будет для сдвига вправо.

Что касается тестовых случаев, я ожидаю тип быть $5$ когда в является $168$ Например.

circomlib/схемы/sha256/shift.circom имеет ШР компонент, который выполняет сдвиг вправо.

    вар InputBits = 8;
    вар РезультатБитс = 3;

    // преобразовать v в биты
    компонент n2b = Num2Bits(InputBits);
    n2b.in <== v;

    // сдвиг
    компонент shr = ShR(InputBits, 5); // v >> 5
    for (var i = 0; i < InputBits; i++) {
        shr.in[i] <== n2b.out[i];
    }

    // преобразовать обратно в число
    компонент b2n = Bits2Num(ResultBits);
    for (var i = 0; i < ResultBits; i++) {
        b2n.in[i] <== shr.out[i];
    }
    введите <== b2n.out;

РЕДАКТИРОВАТЬ: Это недостаточно проверяет операцию сдвига. Вместо этого смотрите ответ @meshcollider.

Хорошо, я не совсем уверен, что это правильно, но это то, что я придумал.

прагма цирком 2.0.0;

шаблон ГЛАВНЫЙ() {

    сигнальный вход v;
    тип выхода сигнала;

    // присваиваем сигнал `type`
    // сдвигаем 0bXXXYYYYY на 0b00000XXX
    // v — доверенный сигнал
    введите <-- v >> 5;

    // подготовим проверку ограничений для `type`
    сигнал three_upper_bits;
    // 0b11100000 = 0xE0
    // v доверенный сигнал
    three_upper_bits <-- v & 0xE0; // 3 старших бита v (0bXXX00000). v может быть только 8 бит.

    // должно_only_be_lower_bits равно 0b000YYYYY
    // получаем 0bXXXYYYYY - 0bXXX00000, чтобы получить 0b000YYYYY
    var should_only_be_lower_bits = v - three_upper_bits;
    // мы проверяем, что must_only_be_lower_bits может быть только МЕНЬШЕ 32 (0b00011111)
    // что подтверждает, что three_upper_bits нетронуты и не испорчены.
    // если бы кто-то возился с three_upper_bits, то should_only_be_lower_bits содержал бы старшие биты
    // и быть больше 32 (0b00011111).
    // тем самым мы криптографически утверждаем, что should_only_be_lower_bits имеет вид 0b000YYYYY
    сигнал upper_bit_1;
    сигнал upper_bit_2;
    сигнал upper_bit_3;
    upper_bit_1 <-- should_only_be_lower_bits & 0x80; // 0b10000000. Этот сигнал может быть 0bX0000000
    upper_bit_2 <-- should_only_be_lower_bits & 0x40; // 0b01000000. Этот сигнал может быть 0b0X000000
    upper_bit_3 <-- should_only_be_lower_bits & 0x20; // 0b00100000. Этот сигнал может быть 0b00X00000
    верхний_бит_1 === 0; // Утверждаем, что 0bX0000000 равно 0b00000000
    верхний_бит_2 === 0; // Утверждаем, что 0b0X000000 равно 0b00000000
    верхний_бит_3 === 0; // Утверждаем, что 0b00X00000 равно 0b00000000

    // генерируем ограничение для типа signal
    // 2^5 = 32
    введите * 32 === three_upper_bits;
}

компонент main = MAIN();

Комментарии проходят через мое мышление, но по существу я проверяю назначения сигналов с ограничениями вычитания/умножения.