Cách tạo ràng buộc đối với toán tử bitwise dịch chuyển phải trong Circcom

Làm cách nào để tạo ràng buộc đối với toán tử bitwise dịch phải trong ngôn ngữ mạch vòng?

Tôi đang cố gắng làm như sau:

thực dụng khoảng 2.0.0;

mẫu MAIN() {

    đầu vào tín hiệu v;
    loại đầu ra tín hiệu;

    gõ <== v >> 5;
}

thành phần chính = MAIN();

Tôi nhận được lỗi sau:

lỗi [T3001]: Không cho phép các ràng buộc không bậc hai!
   ââ "/Users/ilia/compiling/main-circom/main.circom":68:5
   â
68 â gõ <== v >> 5;
   â ^^^^^^^^^^^^^^^ tìm thấy ở đây
   â
   = dấu vết cuộc gọi:
     -> CHÍNH

Tôi nghĩ rằng điều này có liên quan đến thực tế là v >> 5 biểu thức không thể được biểu diễn lại dưới dạng biểu thức bậc hai bởi trình biên dịch vòng tròn.

Tôi đấu tranh để viết lại biểu thức thành bậc hai. Nó có thể liên quan đến việc viết bài tập và ràng buộc dưới dạng hai thao tác riêng biệt, nhưng tôi không chắc ràng buộc xác thực hợp lệ sẽ là gì đối với một ca làm việc đúng.

Về các trường hợp thử nghiệm, tôi mong đợi loại được $5$ khi nào v Là $168$ Ví dụ.

CHỈNH SỬA: Điều này không xác minh đầy đủ thao tác thay đổi. Thay vào đó, hãy xem câu trả lời của @meshcollider.

Ok, tôi không hoàn toàn chắc chắn nếu điều này đúng, nhưng đây là những gì tôi nghĩ ra.

thực dụng khoảng 2.0.0;

mẫu MAIN() {

    đầu vào tín hiệu v;
    loại đầu ra tín hiệu;

    // gán tín hiệu `loại`
    // dịch chuyển 0bXXXYYYYY thành 0b00000XXX
    // v là tín hiệu đáng tin cậy
    gõ <- v >> 5;

    // chuẩn bị kiểm tra ràng buộc cho `type`
    tín hiệu ba_upper_bits;
    // 0b11100000 = 0xE0
    // v là tín hiệu đáng tin cậy
    three_upper_bits <-- v & 0xE0; // 3 bit trên của v(0bXXX00000). v chỉ có thể là 8 bit.

    // should_only_be_lower_bits là 0b000YYYYY
    // chúng tôi nhận được nó bằng cách 0bXXXYYYYY - 0bXXX00000 để nhận được 0b000YYYYY
    var should_only_be_lower_bits = v - three_upper_bits;
    // chúng tôi đang kiểm tra xem should_only_be_lower_bits chỉ có thể DÍNH HƠN 32 (0b00011111)
    // xác minh rằng three_upper_bits là nguyên bản và không bị xáo trộn.
    // nếu ai đó gây rối với three_upper_bits, thì should_only_be_lower_bits sẽ chứa các bit cao hơn
    // và lớn hơn 32 (0b00011111).
    // bằng cách đó, chúng tôi xác nhận bằng mật mã rằng should_only_be_lower_bits ở dạng 0b000YYYYY
    tín hiệu trên_bit_1;
    tín hiệu trên_bit_2;
    tín hiệu trên_bit_3;
    upper_bit_1 <- should_only_be_lower_bits & 0x80; // 0b10000000. Tín hiệu này có thể là 0bX0000000
    upper_bit_2 <- should_only_be_lower_bits & 0x40; // 0b01000000. Tín hiệu này có thể là 0b0X000000
    upper_bit_3 <- should_only_be_lower_bits & 0x20; // 0b00100000. Tín hiệu này có thể là 0b00X00000
    top_bit_1 === 0; // Khẳng định rằng 0bX0000000 là 0b00000000
    top_bit_2 === 0; // Khẳng định rằng 0b0X000000 là 0b00000000
    top_bit_3 === 0; // Khẳng định rằng 0b00X00000 là 0b00000000

    // tạo ràng buộc cho tín hiệu loại
    // 2^5 = 32
    gõ *32===ba_upper_bits;
}

thành phần chính = MAIN();

Các nhận xét đi qua suy nghĩ của tôi, nhưng về cơ bản, tôi xác minh các phép gán tín hiệu với các ràng buộc phép trừ/nhân.

circomlib/mạch/sha256/shift.circom có một ShR thành phần thực hiện dịch chuyển phải.

    var InputBits = 8;
    var Kết quảBits = 3;

    // chuyển đổi v thành bit
    thành phần n2b = Num2Bits(InputBits);
    n2b.in <== v;

    // sự thay đổi
    thành phần shr = ShR(InputBits, 5); // v >> 5
    for (var i = 0; i < InputBits; i++) {
        shr.in[i] <== n2b.out[i];
    }

    // chuyển về số
    thành phần b2n = Bits2Num(ResultBits);
    for (var i = 0; i < ResultBits; i++) {
        b2n.in[i] <== shr.out[i];
    }
    gõ <== b2n.out;