วิธีสร้างข้อจำกัดในตัวดำเนินการ bitwise shift ขวาใน ภาษาวงจร circom?
ฉันกำลังพยายามทำสิ่งต่อไปนี้:
ปรากมา circom 2.0.0;
แม่แบบ MAIN() {
อินพุตสัญญาณ v;
ประเภทเอาต์พุตสัญญาณ
พิมพ์ <== v >> 5;
}
ส่วนประกอบหลัก = MAIN();
ฉันได้รับข้อผิดพลาดต่อไปนี้:
ข้อผิดพลาด [T3001]: ไม่อนุญาตให้ใช้ข้อจำกัดที่ไม่ใช่กำลังสอง!
ââ "/Users/ilia/compiling/main-circom/main.circom":68:5
â
68 â พิมพ์ <== v >> 5;
â ^^^^^^^^^^^^^^^ พบที่นี่
â
= ติดตามการโทร:
-> หลัก
ฉันคิดว่าสิ่งนี้เกี่ยวข้องกับข้อเท็จจริงที่ว่า v >> 5 นิพจน์ไม่สามารถแสดงซ้ำเป็นนิพจน์กำลังสองโดย คอมไพเลอร์ circom.
ฉันพยายามเขียนนิพจน์ใหม่ให้เป็นกำลังสอง อาจเกี่ยวข้องกับการเขียนการมอบหมายและข้อ จำกัด เป็นสองการดำเนินการแยกกัน แต่ฉันไม่แน่ใจว่าข้อ จำกัด การตรวจสอบความถูกต้องที่เหมาะสมสำหรับการเปลี่ยนแปลงที่ถูกต้องคืออะไร
ในแง่ของกรณีทดสอบฉันคาดหวัง พิมพ์ เป็น $5$ เมื่อไร โวลต์ เป็น $168$ ตัวอย่างเช่น.
วิธีแก้ปัญหาโดยใช้ตัวเปรียบเทียบ LessThan จาก วงรอบ:
//... นำเข้าเครื่องเปรียบเทียบจาก circumlib ...
แม่แบบ MAIN() {
อินพุตสัญญาณ v;
ประเภทเอาต์พุตสัญญาณ
ตรวจสอบสัญญาณ _v;
องค์ประกอบน้อยกว่า = LessThan (8);
พิมพ์ <-- v >> 5;
check_v <== พิมพ์*32;
// ใช้ circomlib LessThan เพื่อตรวจสอบว่า (v - check_v) < 32
lessThan.in[0] <== v - check_v;
lessThan.in[1] <== 32;
lessThan.out === 1;
}
ส่วนประกอบหลัก = MAIN();
```
แก้ไข: สิ่งนี้ไม่เพียงพอในการตรวจสอบการดำเนินการกะ ดูคำตอบของ @meshcollider แทน
ตกลง ฉันไม่แน่ใจว่าถูกต้องหรือไม่ แต่นี่คือสิ่งที่ฉันคิดขึ้นมาได้
ปรากมา circom 2.0.0;
แม่แบบ MAIN() {
อินพุตสัญญาณ v;
ประเภทเอาต์พุตสัญญาณ
// กำหนดสัญญาณ `type`
// เปลี่ยน 0bXXXYYYYY เป็น 0b00000XXX
// v เป็นสัญญาณที่เชื่อถือได้
พิมพ์ <-- v >> 5;
// เตรียมการตรวจสอบข้อจำกัดสำหรับ `type`
สัญญาณ three_upper_bits;
// 0b11100000 = 0xE0
// v เป็นสัญญาณที่เชื่อถือได้
three_upper_bits <-- v & 0xE0; // 3 บิตบนของ v (0bXXX00000) v เป็นได้แค่ 8 บิต
// should_only_be_lower_bits คือ 0b000YYYYY
// เราได้รับจาก 0bXXXYYYYY - 0bXXX00000 เพื่อรับ 0b000YYYYY
var should_only_be_lower_bits = v - three_upper_bits;
// เรากำลังตรวจสอบว่า should_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
upper_bit_1 === 0; // ยืนยันว่า 0bX0000000 คือ 0b00000000
upper_bit_2 === 0; // ยืนยันว่า 0b0X000000 คือ 0b00000000
upper_bit_3 === 0; // ยืนยันว่า 0b00X00000 คือ 0b00000000
// สร้างข้อจำกัดสำหรับสัญญาณประเภท
// 2^5 = 32
พิมพ์ * 32 === three_upper_bits;
}
ส่วนประกอบหลัก = MAIN();
ความคิดเห็นผ่านความคิดของฉัน แต่โดยพื้นฐานแล้วฉันตรวจสอบการกำหนดสัญญาณด้วยข้อจำกัดการลบ/การคูณ
circomlib/circuits/sha256/shift.circom มี ช ส่วนประกอบที่ทำกะขวา
var InputBits = 8;
var ResultBits = 3;
// แปลง v เป็นบิต
ส่วนประกอบ n2b = Num2Bits (InputBits);
n2b.in <== v;
// กะ
ส่วนประกอบ shr = ShR (InputBits, 5); //วี>>5
สำหรับ (var i = 0; i < InputBits; i++) {
shr.in[i] <== n2b.out[i];
}
// แปลงกลับเป็นตัวเลข
ส่วนประกอบ b2n = Bits2Num (ResultBits);
สำหรับ (var i = 0; i <ResultBits; i++) {
b2n.in[i] <== shr.out[i];
}
พิมพ์ <== b2n.out;
คนส่วนใหญ่ไม่เข้าใจว่าการถามคำถามมากมายจะปลดล็อกการเรียนรู้และปรับปรุงความสัมพันธ์ระหว่างบุคคล ตัวอย่างเช่น ในการศึกษาของ Alison แม้ว่าผู้คนจะจำได้อย่างแม่นยำว่ามีคำถามกี่ข้อที่ถูกถามในการสนทนา แต่พวกเขาไม่เข้าใจความเชื่อมโยงระหว่างคำถามและความชอบ จากการศึกษาทั้ง 4 เรื่องที่ผู้เข้าร่วมมีส่วนร่วมในการสนทนาด้วยตนเองหรืออ่านบันทึกการสนทนาของผู้อื่น ผู้คนมักไม่ตระหนักว่าการถามคำถามจะมีอิทธิพลหรือมีอิทธิพลต่อระดับมิตรภาพระหว่างผู้สนทนา
