phantom-zone/src/bool/mp_api.rs
src/bool/mp_api.rsRaw
1use std::{cell::RefCell, sync::OnceLock};
2
3use crate::{
4 backend::{ModularOpsU64, ModulusPowerOf2},
5 ntt::NttBackendU64,
6 random::{DefaultSecureRng, NewWithSeed},
7 utils::{Global, WithLocal},
8};
9
10use super::{evaluator::InteractiveMultiPartyCrs, keys::*, parameters::*, ClientKey};
11
12pub(crate) type BoolEvaluator = super::evaluator::BoolEvaluator<
13 Vec<Vec<u64>>,
14 NttBackendU64,
15 ModularOpsU64<CiphertextModulus<u64>>,
16 ModulusPowerOf2<CiphertextModulus<u64>>,
17 ShoupServerKeyEvaluationDomain<Vec<Vec<u64>>>,
18>;
19
20thread_local! {
21 static BOOL_EVALUATOR: RefCell<Option<BoolEvaluator>> = RefCell::new(None);
22
23}
24static BOOL_SERVER_KEY: OnceLock<ShoupServerKeyEvaluationDomain<Vec<Vec<u64>>>> = OnceLock::new();
25
26static MULTI_PARTY_CRS: OnceLock<InteractiveMultiPartyCrs<[u8; 32]>> = OnceLock::new();
27
28pub enum ParameterSelector {
29 InteractiveLTE2Party,
30 InteractiveLTE4Party,
31 InteractiveLTE8Party,
32}
33
34/// Select Interactive multi-party parameter variant
35pub fn set_parameter_set(select: ParameterSelector) {
36 match select {
37 ParameterSelector::InteractiveLTE2Party => {
38 BOOL_EVALUATOR.with_borrow_mut(|v| *v = Some(BoolEvaluator::new(I_2P)));
39 }
40 ParameterSelector::InteractiveLTE4Party => {
41 BOOL_EVALUATOR.with_borrow_mut(|v| *v = Some(BoolEvaluator::new(I_4P)));
42 }
43 ParameterSelector::InteractiveLTE8Party => {
44 BOOL_EVALUATOR.with_borrow_mut(|v| *v = Some(BoolEvaluator::new(I_8P_LB_SR)));
45 }
46 _ => {
47 panic!("Paramerter not supported")
48 }
49 }
50}
51
52/// Set application specific interactive multi-party common reference string
53pub fn set_common_reference_seed(seed: [u8; 32]) {
54 assert!(
55 MULTI_PARTY_CRS
56 .set(InteractiveMultiPartyCrs { seed: seed })
57 .is_ok(),
58 "Attempted to set MP SEED twice."
59 )
60}
61
62/// Generate client key for interactive multi-party protocol
63pub fn gen_client_key() -> ClientKey {
64 BoolEvaluator::with_local(|e| e.client_key())
65}
66
67/// Generate client's share for collective public key, i.e round 1 share, in
68/// round 1 of the 2 round protocol
69pub fn interactive_multi_party_round1_share(
70 ck: &ClientKey,
71) -> CommonReferenceSeededCollectivePublicKeyShare<Vec<u64>, [u8; 32], BoolParameters<u64>> {
72 BoolEvaluator::with_local(|e| {
73 let pk_share = e.multi_party_public_key_share(InteractiveMultiPartyCrs::global(), ck);
74 pk_share
75 })
76}
77
78/// Generate clients share for collective server key, i.e. round 2, of the
79/// protocol
80pub fn gen_mp_keys_phase2<R, ModOp>(
81 ck: &ClientKey,
82 user_id: usize,
83 total_users: usize,
84 pk: &PublicKey<Vec<Vec<u64>>, R, ModOp>,
85) -> CommonReferenceSeededInteractiveMultiPartyServerKeyShare<
86 Vec<Vec<u64>>,
87 BoolParameters<u64>,
88 InteractiveMultiPartyCrs<[u8; 32]>,
89> {
90 BoolEvaluator::with_local_mut(|e| {
91 let server_key_share = e.gen_interactive_multi_party_server_key_share(
92 user_id,
93 total_users,
94 InteractiveMultiPartyCrs::global(),
95 pk.key(),
96 ck,
97 );
98 server_key_share
99 })
100}
101
102/// Aggregate public key shares from all parties.
103///
104/// Public key shares are generated per client in round 1. Aggregation of public
105/// key shares marks the end of round 1.
106pub fn aggregate_public_key_shares(
107 shares: &[CommonReferenceSeededCollectivePublicKeyShare<
108 Vec<u64>,
109 [u8; 32],
110 BoolParameters<u64>,
111 >],
112) -> PublicKey<Vec<Vec<u64>>, DefaultSecureRng, ModularOpsU64<CiphertextModulus<u64>>> {
113 PublicKey::from(shares)
114}
115
116/// Aggregate server key shares
117pub fn aggregate_server_key_shares(
118 shares: &[CommonReferenceSeededInteractiveMultiPartyServerKeyShare<
119 Vec<Vec<u64>>,
120 BoolParameters<u64>,
121 InteractiveMultiPartyCrs<[u8; 32]>,
122 >],
123) -> SeededInteractiveMultiPartyServerKey<
124 Vec<Vec<u64>>,
125 InteractiveMultiPartyCrs<[u8; 32]>,
126 BoolParameters<u64>,
127> {
128 BoolEvaluator::with_local(|e| e.aggregate_interactive_multi_party_server_key_shares(shares))
129}
130
131impl
132 SeededInteractiveMultiPartyServerKey<
133 Vec<Vec<u64>>,
134 InteractiveMultiPartyCrs<<DefaultSecureRng as NewWithSeed>::Seed>,
135 BoolParameters<u64>,
136 >
137{
138 /// Sets the server key as a global reference for circuit evaluation
139 pub fn set_server_key(&self) {
140 assert!(
141 BOOL_SERVER_KEY
142 .set(ShoupServerKeyEvaluationDomain::from(
143 ServerKeyEvaluationDomain::<_, _, DefaultSecureRng, NttBackendU64>::from(self),
144 ))
145 .is_ok(),
146 "Attempted to set server key twice."
147 );
148 }
149}
150
151// MULTIPARTY CRS //
152impl Global for InteractiveMultiPartyCrs<[u8; 32]> {
153 fn global() -> &'static Self {
154 MULTI_PARTY_CRS
155 .get()
156 .expect("Multi Party Common Reference String not set")
157 }
158}
159
160// BOOL EVALUATOR //
161impl WithLocal for BoolEvaluator {
162 fn with_local<F, R>(func: F) -> R
163 where
164 F: Fn(&Self) -> R,
165 {
166 BOOL_EVALUATOR.with_borrow(|s| func(s.as_ref().expect("Parameters not set")))
167 }
168
169 fn with_local_mut<F, R>(func: F) -> R
170 where
171 F: Fn(&mut Self) -> R,
172 {
173 BOOL_EVALUATOR.with_borrow_mut(|s| func(s.as_mut().expect("Parameters not set")))
174 }
175
176 fn with_local_mut_mut<F, R>(func: &mut F) -> R
177 where
178 F: FnMut(&mut Self) -> R,
179 {
180 BOOL_EVALUATOR.with_borrow_mut(|s| func(s.as_mut().expect("Parameters not set")))
181 }
182}
183
184pub(crate) type RuntimeServerKey = ShoupServerKeyEvaluationDomain<Vec<Vec<u64>>>;
185impl Global for RuntimeServerKey {
186 fn global() -> &'static Self {
187 BOOL_SERVER_KEY.get().expect("Server key not set!")
188 }
189}
190
191mod impl_enc_dec {
192 use crate::{
193 bool::evaluator::BoolEncoding,
194 multi_party::{
195 multi_party_aggregate_decryption_shares_and_decrypt, multi_party_decryption_share,
196 },
197 pbs::{sample_extract, PbsInfo},
198 rgsw::public_key_encrypt_rlwe,
199 utils::TryConvertFrom1,
200 Encryptor, Matrix, MatrixEntity, MultiPartyDecryptor, RowEntity,
201 };
202 use itertools::Itertools;
203 use num_traits::{ToPrimitive, Zero};
204
205 use super::*;
206
207 type Mat = Vec<Vec<u64>>;
208
209 impl<Rng, ModOp> Encryptor<[bool], Vec<Mat>> for PublicKey<Mat, Rng, ModOp> {
210 fn encrypt(&self, m: &[bool]) -> Vec<Mat> {
211 BoolEvaluator::with_local(|e| {
212 DefaultSecureRng::with_local_mut(|rng| {
213 let parameters = e.parameters();
214 let ring_size = parameters.rlwe_n().0;
215
216 let rlwe_count = ((m.len() as f64 / ring_size as f64).ceil())
217 .to_usize()
218 .unwrap();
219
220 // encrypt `m` into ceil(len(m)/N) RLWE ciphertexts
221 let rlwes = (0..rlwe_count)
222 .map(|index| {
223 let mut message = vec![<Mat as Matrix>::MatElement::zero(); ring_size];
224 m[(index * ring_size)..std::cmp::min(m.len(), (index + 1) * ring_size)]
225 .iter()
226 .enumerate()
227 .for_each(|(i, v)| {
228 if *v {
229 message[i] = parameters.rlwe_q().true_el()
230 } else {
231 message[i] = parameters.rlwe_q().false_el()
232 }
233 });
234
235 // encrypt message
236 let mut rlwe_out =
237 <Mat as MatrixEntity>::zeros(2, parameters.rlwe_n().0);
238
239 public_key_encrypt_rlwe::<_, _, _, _, i32, _>(
240 &mut rlwe_out,
241 self.key(),
242 &message,
243 e.pbs_info().modop_rlweq(),
244 e.pbs_info().nttop_rlweq(),
245 rng,
246 );
247
248 rlwe_out
249 })
250 .collect_vec();
251 rlwes
252 })
253 })
254 }
255 }
256
257 impl<Rng, ModOp> Encryptor<bool, <Mat as Matrix>::R> for PublicKey<Mat, Rng, ModOp> {
258 fn encrypt(&self, m: &bool) -> <Mat as Matrix>::R {
259 let m = vec![*m];
260 let rlwe = &self.encrypt(m.as_slice())[0];
261 BoolEvaluator::with_local(|e| {
262 let mut lwe = <Mat as Matrix>::R::zeros(e.parameters().rlwe_n().0 + 1);
263 sample_extract(&mut lwe, rlwe, e.pbs_info().modop_rlweq(), 0);
264 lwe
265 })
266 }
267 }
268
269 impl<K> MultiPartyDecryptor<bool, <Mat as Matrix>::R> for K
270 where
271 K: InteractiveMultiPartyClientKey,
272 <Mat as Matrix>::R:
273 TryConvertFrom1<[K::Element], CiphertextModulus<<Mat as Matrix>::MatElement>>,
274 {
275 type DecryptionShare = <Mat as Matrix>::MatElement;
276
277 fn gen_decryption_share(&self, c: &<Mat as Matrix>::R) -> Self::DecryptionShare {
278 BoolEvaluator::with_local(|e| {
279 DefaultSecureRng::with_local_mut(|rng| {
280 multi_party_decryption_share(
281 c,
282 self.sk_rlwe().as_slice(),
283 e.pbs_info().modop_rlweq(),
284 rng,
285 )
286 })
287 })
288 }
289
290 fn aggregate_decryption_shares(
291 &self,
292 c: &<Mat as Matrix>::R,
293 shares: &[Self::DecryptionShare],
294 ) -> bool {
295 BoolEvaluator::with_local(|e| {
296 let noisy_m = multi_party_aggregate_decryption_shares_and_decrypt(
297 c,
298 shares,
299 e.pbs_info().modop_rlweq(),
300 );
301
302 e.pbs_info().rlwe_q().decode(noisy_m)
303 })
304 }
305 }
306}
307
308#[cfg(test)]
309mod tests {
310 use itertools::Itertools;
311 use rand::{thread_rng, Rng, RngCore};
312
313 use crate::{
314 bool::{
315 evaluator::BoolEncoding,
316 keys::tests::{ideal_sk_rlwe, measure_noise_lwe},
317 BooleanGates,
318 },
319 Encryptor, MultiPartyDecryptor, SampleExtractor,
320 };
321
322 use super::*;
323
324 #[test]
325 fn multi_party_bool_gates() {
326 set_parameter_set(ParameterSelector::InteractiveLTE2Party);
327 let mut seed = [0u8; 32];
328 thread_rng().fill_bytes(&mut seed);
329 set_common_reference_seed(seed);
330
331 let parties = 2;
332 let cks = (0..parties).map(|_| gen_client_key()).collect_vec();
333
334 // round 1
335 let pk_shares = cks
336 .iter()
337 .map(|k| interactive_multi_party_round1_share(k))
338 .collect_vec();
339
340 // collective pk
341 let pk = aggregate_public_key_shares(&pk_shares);
342
343 // round 2
344 let server_key_shares = cks
345 .iter()
346 .enumerate()
347 .map(|(user_id, k)| gen_mp_keys_phase2(k, user_id, parties, &pk))
348 .collect_vec();
349
350 // server key
351 let server_key = aggregate_server_key_shares(&server_key_shares);
352 server_key.set_server_key();
353
354 let mut m0 = false;
355 let mut m1 = true;
356
357 let mut ct0 = pk.encrypt(&m0);
358 let mut ct1 = pk.encrypt(&m1);
359
360 let ideal_sk_rlwe = ideal_sk_rlwe(&cks);
361 let parameters = BoolEvaluator::with_local(|e| e.parameters().clone());
362 let rlwe_modop = parameters.default_rlwe_modop();
363
364 for _ in 0..500 {
365 let now = std::time::Instant::now();
366 let ct_out =
367 BoolEvaluator::with_local_mut(|e| e.nand(&ct0, &ct1, RuntimeServerKey::global()));
368 println!("Time: {:?}", now.elapsed());
369
370 let m_expected = !(m0 && m1);
371
372 let decryption_shares = cks
373 .iter()
374 .map(|k| k.gen_decryption_share(&ct_out))
375 .collect_vec();
376 let m_out = cks[0].aggregate_decryption_shares(&ct_out, &decryption_shares);
377
378 assert!(m_out == m_expected, "Expected {m_expected}, got {m_out}");
379 {
380 let m_expected_el = if m_expected == true {
381 parameters.rlwe_q().true_el()
382 } else {
383 parameters.rlwe_q().false_el()
384 };
385 let noise = measure_noise_lwe(&ct_out, m_expected_el, &ideal_sk_rlwe, &rlwe_modop);
386 println!("NAND Noise: {noise}");
387 }
388
389 m1 = m0;
390 m0 = m_expected;
391
392 ct1 = ct0;
393 ct0 = ct_out;
394 }
395
396 for _ in 0..500 {
397 let ct_out =
398 BoolEvaluator::with_local_mut(|e| e.xnor(&ct0, &ct1, RuntimeServerKey::global()));
399
400 let m_expected = !(m0 ^ m1);
401
402 let decryption_shares = cks
403 .iter()
404 .map(|k| k.gen_decryption_share(&ct_out))
405 .collect_vec();
406 let m_out = cks[0].aggregate_decryption_shares(&ct_out, &decryption_shares);
407
408 assert!(m_out == m_expected, "Expected {m_expected}, got {m_out}");
409
410 m1 = m0;
411 m0 = m_expected;
412
413 ct1 = ct0;
414 ct0 = ct_out;
415 }
416 }
417
418 #[test]
419 fn batched_fhe_u8s_extract_works() {
420 set_parameter_set(ParameterSelector::InteractiveLTE2Party);
421 let mut seed = [0u8; 32];
422 thread_rng().fill_bytes(&mut seed);
423 set_common_reference_seed(seed);
424
425 let parties = 2;
426 let cks = (0..parties).map(|_| gen_client_key()).collect_vec();
427
428 // round 1
429 let pk_shares = cks
430 .iter()
431 .map(|k| interactive_multi_party_round1_share(k))
432 .collect_vec();
433
434 // collective pk
435 let pk = aggregate_public_key_shares(&pk_shares);
436
437 let parameters = BoolEvaluator::with_local(|e| e.parameters().clone());
438
439 let batch_size = parameters.rlwe_n().0 * 3 + 123;
440 let m = (0..batch_size)
441 .map(|_| thread_rng().gen::<u8>())
442 .collect_vec();
443
444 let seeded_ct = pk.encrypt(m.as_slice());
445
446 let m_back = (0..batch_size)
447 .map(|i| {
448 let ct = seeded_ct.extract_at(i);
449 cks[0].aggregate_decryption_shares(
450 &ct,
451 &cks.iter()
452 .map(|k| k.gen_decryption_share(&ct))
453 .collect_vec(),
454 )
455 })
456 .collect_vec();
457
458 assert_eq!(m, m_back);
459 }
460
461 mod sp_api {
462 use num_traits::ToPrimitive;
463
464 use crate::{
465 bool::impl_bool_frontend::FheBool, pbs::PbsInfo, rgsw::seeded_secret_key_encrypt_rlwe,
466 Decryptor,
467 };
468
469 use super::*;
470
471 pub(crate) fn set_single_party_parameter_sets(parameter: BoolParameters<u64>) {
472 BOOL_EVALUATOR.with_borrow_mut(|e| *e = Some(BoolEvaluator::new(parameter)));
473 }
474
475 // SERVER KEY EVAL (/SHOUP) DOMAIN //
476 impl SeededSinglePartyServerKey<Vec<Vec<u64>>, BoolParameters<u64>, [u8; 32]> {
477 pub fn set_server_key(&self) {
478 assert!(
479 BOOL_SERVER_KEY
480 .set(
481 ShoupServerKeyEvaluationDomain::from(ServerKeyEvaluationDomain::<
482 _,
483 _,
484 DefaultSecureRng,
485 NttBackendU64,
486 >::from(
487 self
488 ),)
489 )
490 .is_ok(),
491 "Attempted to set server key twice."
492 );
493 }
494 }
495
496 pub(crate) fn gen_keys() -> (
497 ClientKey,
498 SeededSinglePartyServerKey<Vec<Vec<u64>>, BoolParameters<u64>, [u8; 32]>,
499 ) {
500 super::BoolEvaluator::with_local_mut(|e| {
501 let ck = e.client_key();
502 let sk = e.single_party_server_key(&ck);
503
504 (ck, sk)
505 })
506 }
507
508 impl<K: SinglePartyClientKey<Element = i32>> Encryptor<bool, Vec<u64>> for K {
509 fn encrypt(&self, m: &bool) -> Vec<u64> {
510 BoolEvaluator::with_local(|e| e.sk_encrypt(*m, self))
511 }
512 }
513
514 impl<K: SinglePartyClientKey<Element = i32>> Decryptor<bool, Vec<u64>> for K {
515 fn decrypt(&self, c: &Vec<u64>) -> bool {
516 BoolEvaluator::with_local(|e| e.sk_decrypt(c, self))
517 }
518 }
519
520 impl<K: SinglePartyClientKey<Element = i32>, C> Encryptor<bool, FheBool<C>> for K
521 where
522 K: Encryptor<bool, C>,
523 {
524 fn encrypt(&self, m: &bool) -> FheBool<C> {
525 FheBool {
526 data: self.encrypt(m),
527 }
528 }
529 }
530
531 impl<K: SinglePartyClientKey<Element = i32>, C> Decryptor<bool, FheBool<C>> for K
532 where
533 K: Decryptor<bool, C>,
534 {
535 fn decrypt(&self, c: &FheBool<C>) -> bool {
536 self.decrypt(c.data())
537 }
538 }
539
540 impl<K> Encryptor<[bool], (Vec<Vec<u64>>, [u8; 32])> for K
541 where
542 K: SinglePartyClientKey<Element = i32>,
543 {
544 fn encrypt(&self, m: &[bool]) -> (Vec<Vec<u64>>, [u8; 32]) {
545 BoolEvaluator::with_local(|e| {
546 DefaultSecureRng::with_local_mut(|rng| {
547 let parameters = e.parameters();
548 let ring_size = parameters.rlwe_n().0;
549
550 let rlwe_count = ((m.len() as f64 / ring_size as f64).ceil())
551 .to_usize()
552 .unwrap();
553
554 let mut seed = <DefaultSecureRng as NewWithSeed>::Seed::default();
555 rng.fill_bytes(&mut seed);
556 let mut prng = DefaultSecureRng::new_seeded(seed);
557
558 let sk_u = self.sk_rlwe();
559
560 // encrypt `m` into ceil(len(m)/N) RLWE ciphertexts
561 let rlwes = (0..rlwe_count)
562 .map(|index| {
563 let mut message = vec![0; ring_size];
564 m[(index * ring_size)
565 ..std::cmp::min(m.len(), (index + 1) * ring_size)]
566 .iter()
567 .enumerate()
568 .for_each(|(i, v)| {
569 if *v {
570 message[i] = parameters.rlwe_q().true_el()
571 } else {
572 message[i] = parameters.rlwe_q().false_el()
573 }
574 });
575
576 // encrypt message
577 let mut rlwe_out = vec![0u64; parameters.rlwe_n().0];
578 seeded_secret_key_encrypt_rlwe(
579 &message,
580 &mut rlwe_out,
581 &sk_u,
582 e.pbs_info().modop_rlweq(),
583 e.pbs_info().nttop_rlweq(),
584 &mut prng,
585 rng,
586 );
587
588 rlwe_out
589 })
590 .collect_vec();
591
592 (rlwes, seed)
593 })
594 })
595 }
596 }
597
598 #[test]
599 #[cfg(feature = "interactive_mp")]
600 fn all_uint8_apis() {
601 use num_traits::Euclid;
602
603 use crate::{div_zero_error_flag, FheBool};
604
605 set_single_party_parameter_sets(SP_TEST_BOOL_PARAMS);
606
607 let (ck, sk) = gen_keys();
608 sk.set_server_key();
609
610 for i in 0..=255 {
611 for j in 0..=255 {
612 let m0 = i;
613 let m1 = j;
614 let c0 = ck.encrypt(&m0);
615 let c1 = ck.encrypt(&m1);
616
617 assert!(ck.decrypt(&c0) == m0);
618 assert!(ck.decrypt(&c1) == m1);
619
620 // Arithmetic
621 {
622 {
623 // Add
624 let c_add = &c0 + &c1;
625 let m0_plus_m1 = ck.decrypt(&c_add);
626 assert_eq!(
627 m0_plus_m1,
628 m0.wrapping_add(m1),
629 "Expected {} but got {m0_plus_m1} for
630 {i}+{j}",
631 m0.wrapping_add(m1)
632 );
633 }
634 {
635 // Sub
636 let c_sub = &c0 - &c1;
637 let m0_sub_m1 = ck.decrypt(&c_sub);
638 assert_eq!(
639 m0_sub_m1,
640 m0.wrapping_sub(m1),
641 "Expected {} but got {m0_sub_m1} for
642 {i}-{j}",
643 m0.wrapping_sub(m1)
644 );
645 }
646
647 {
648 // Mul
649 let c_m0m1 = &c0 * &c1;
650 let m0m1 = ck.decrypt(&c_m0m1);
651 assert_eq!(
652 m0m1,
653 m0.wrapping_mul(m1),
654 "Expected {} but got {m0m1} for {i}x{j}",
655 m0.wrapping_mul(m1)
656 );
657 }
658
659 // Div & Rem
660 {
661 let (c_quotient, c_rem) = c0.div_rem(&c1);
662 let m_quotient = ck.decrypt(&c_quotient);
663 let m_remainder = ck.decrypt(&c_rem);
664 if j != 0 {
665 let (q, r) = i.div_rem_euclid(&j);
666 assert_eq!(
667 m_quotient, q,
668 "Expected {} but got {m_quotient} for
669 {i}/{j}",
670 q
671 );
672 assert_eq!(
673 m_remainder, r,
674 "Expected {} but got {m_remainder} for
675 {i}%{j}",
676 r
677 );
678 } else {
679 assert_eq!(
680 m_quotient, 255,
681 "Expected 255 but got {m_quotient}. Case
682 div by zero"
683 );
684 assert_eq!(
685 m_remainder, i,
686 "Expected {i} but got {m_remainder}. Case
687 div by zero"
688 );
689
690 let div_by_zero = ck.decrypt(&div_zero_error_flag().unwrap());
691 assert_eq!(
692 div_by_zero, true,
693 "Expected true but got {div_by_zero}"
694 );
695 }
696 }
697 }
698
699 // // Comparisons
700 {
701 {
702 let c_eq = c0.eq(&c1);
703 let is_eq = ck.decrypt(&c_eq);
704 assert_eq!(
705 is_eq,
706 i == j,
707 "Expected {} but got {is_eq} for {i}=={j}",
708 i == j
709 );
710 }
711
712 {
713 let c_gt = c0.gt(&c1);
714 let is_gt = ck.decrypt(&c_gt);
715 assert_eq!(
716 is_gt,
717 i > j,
718 "Expected {} but got {is_gt} for {i}>{j}",
719 i > j
720 );
721 }
722
723 {
724 let c_lt = c0.lt(&c1);
725 let is_lt = ck.decrypt(&c_lt);
726 assert_eq!(
727 is_lt,
728 i < j,
729 "Expected {} but got {is_lt} for {i}<{j}",
730 i < j
731 );
732 }
733
734 {
735 let c_ge = c0.ge(&c1);
736 let is_ge = ck.decrypt(&c_ge);
737 assert_eq!(
738 is_ge,
739 i >= j,
740 "Expected {} but got {is_ge} for {i}>={j}",
741 i >= j
742 );
743 }
744
745 {
746 let c_le = c0.le(&c1);
747 let is_le = ck.decrypt(&c_le);
748 assert_eq!(
749 is_le,
750 i <= j,
751 "Expected {} but got {is_le} for {i}<={j}",
752 i <= j
753 );
754 }
755 }
756
757 // mux
758 {
759 let selector = thread_rng().gen_bool(0.5);
760 let selector_enc: FheBool = ck.encrypt(&selector);
761 let mux_out = ck.decrypt(&c0.mux(&c1, &selector_enc));
762 let want_mux_out = if selector { m0 } else { m1 };
763 assert_eq!(mux_out, want_mux_out);
764 }
765 }
766 }
767 }
768
769 #[test]
770 #[cfg(feature = "interactive_mp")]
771 fn all_bool_apis() {
772 use crate::FheBool;
773
774 set_single_party_parameter_sets(SP_TEST_BOOL_PARAMS);
775
776 let (ck, sk) = gen_keys();
777 sk.set_server_key();
778
779 for _ in 0..100 {
780 let a = thread_rng().gen_bool(0.5);
781 let b = thread_rng().gen_bool(0.5);
782
783 let c_a: FheBool = ck.encrypt(&a);
784 let c_b: FheBool = ck.encrypt(&b);
785
786 let c_out = &c_a & &c_b;
787 let out = ck.decrypt(&c_out);
788 assert_eq!(out, a & b, "Expected {} but got {out}", a & b);
789
790 let c_out = &c_a | &c_b;
791 let out = ck.decrypt(&c_out);
792 assert_eq!(out, a | b, "Expected {} but got {out}", a | b);
793
794 let c_out = &c_a ^ &c_b;
795 let out = ck.decrypt(&c_out);
796 assert_eq!(out, a ^ b, "Expected {} but got {out}", a ^ b);
797
798 let c_out = !(&c_a);
799 let out = ck.decrypt(&c_out);
800 assert_eq!(out, !a, "Expected {} but got {out}", !a);
801 }
802 }
803 }
804}