Cum se generează constrângere pe operatorul de deplasare la dreapta pe biți în Circom

Cum se generează constrângere pe operatorul de deplasare la dreapta pe biți în limbajul circuitului circom?

Încerc să fac următoarele:

pragma circom 2.0.0;

template MAIN() {

    semnal de intrare v;
    tipul de ieșire a semnalului;

    tip <== v >> 5;
}

component principal = MAIN();

Primesc următoarea eroare:

eroare[T3001]: Constrângerile non-patratice nu sunt permise!
   ââ "/Utilizatori/ilia/compiling/main-circom/main.circom":68:5
   â
68 â tip <== v >> 5;
   â ^^^^^^^^^^^^^^^ găsit aici
   â
   = urmărirea apelurilor:
     ->PRINCIPALA

Cred că asta are de-a face cu faptul că v >> 5 expresia nu poate fi re-exprimată ca o expresie pătratică prin compilatorul circom.

Mă străduiesc să rescriu expresia să fie pătratică. Ar putea implica scrierea atribuirii și constrângerii ca două operațiuni separate, dar nu sunt sigur ce ar fi o constrângere de validare adecvată pentru o schimbare la dreapta.

În ceea ce privește cazurile de testare, mă aștept tip a fi $5$ când v este $168$ de exemplu.

EDIT: Acest lucru nu verifică suficient funcționarea schimburilor. Vedeți în schimb răspunsul lui @meshcollider.

Ok, nu sunt pe deplin sigur dacă acest lucru este corect, dar asta este ceea ce am venit.

pragma circom 2.0.0;

template MAIN() {

    semnal de intrare v;
    tipul de ieșire a semnalului;

    // atribuie semnalul `tip`
    // mutați 0bXXXYYYYY la 0b00000XXX
    // v este un semnal de încredere
    tip <-- v >> 5;

    // pregătește verificarea constrângerii pentru `type`
    semnal trei_biți_superiori;
    // 0b11100000 = 0xE0
    // v este un semnal de încredere
    trei_biți_superiori <-- v & 0xE0; // 3 biți superiori ai v (0bXXX00000). v poate avea doar 8 biți.

    // should_only_be_lower_bits este 0b000YYYYY
    // îl obținem cu 0bXXXYYYYY - 0bXXX00000 pentru a obține 0b000YYYYY
    var should_only_be_lower_bits = v - three_upper_bits;
    // verificăm că should_only_be_lower_bits poate fi doar MAI MAI DE 32 (0b00011111)
    // care verifică că trei_biți_superiori sunt curați și nu au fost încurcați.
    // dacă cineva s-ar încurca cu trei_biți_superiori, should_only_be_lower_bits ar conține biți mai mari
    // și să fie mai mare de 32 (0b00011111).
    // făcând asta, afirmăm criptografic că should_only_be_lower_bits este sub forma 0b000YYYYY
    semnal upper_bit_1;
    semnal upper_bit_2;
    semnal upper_bit_3;
    upper_bit_1 <-- should_only_be_lower_bits & 0x80; // 0b10000000. Acest semnal poate fi 0bX0000000
    upper_bit_2 <-- should_only_be_lower_bits & 0x40; // 0b01000000. Acest semnal poate fi 0b0X000000
    upper_bit_3 <-- should_only_be_lower_bits & 0x20; // 0b00100000. Acest semnal poate fi 0b00X00000
    upper_bit_1 === 0; // Afirmați că 0bX0000000 este 0b00000000
    upper_bit_2 === 0; // Afirmați că 0b0X000000 este 0b00000000
    upper_bit_3 === 0; // Afirmați că 0b00X00000 este 0b00000000

    // generează constrângere pentru semnal de tip
    // 2^5 = 32
    tip * 32 === trei_biți_superiori;
}

component principal = MAIN();

Comentariile îmi trec prin gândire, dar în esență verific atribuirile de semnal cu constrângeri de scădere/multiplicare.

circomlib/circuits/sha256/shift.circom are o ShR componentă care efectuează schimbarea la dreapta.

    var InputBits = 8;
    var ResultBits = 3;

    // convertiți v în biți
    componenta n2b = Num2Bits(InputBits);
    n2b.in <== v;

    // schimb
    componenta shr = ShR(InputBits, 5); // v >> 5
    pentru (var i = 0; i < InputBits; i++) {
        shr.in[i] <== n2b.out[i];
    }

    // convertiți înapoi în număr
    componenta b2n = Bits2Num(ResultBits);
    pentru (var i = 0; i < ResultBits; i++) {
        b2n.in[i] <== shr.out[i];
    }
    tip <== b2n.out;