Merge pull request #130 from Huelse/update

Update deps and forward wrapper

Author: Huelse

AGENTS.md

@@ -0,0 +1,33 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- `src/wrapper.cpp`: pybind11 bindings that expose Microsoft SEAL C++ APIs as the Python module `seal`.
+- `SEAL/`: Microsoft SEAL submodule source and CMake build output (`SEAL/build/...`).
+- `pybind11/`: pybind11 submodule headers used by the extension build.
+- `examples/`: runnable Python usage samples (for example `4_bgv_basics.py`, `7_serialization.py`).
+- Root build files: `setup.py`, `pyproject.toml`, `Dockerfile`, and `README.md`.
+
+## Build, Test, and Development Commands
+- `git submodule update --init --recursive`: fetch SEAL and pybind11 submodules.
+- `cmake -S SEAL -B SEAL/build -DSEAL_USE_MSGSL=OFF -DSEAL_USE_ZLIB=OFF -DSEAL_USE_ZSTD=OFF && cmake --build SEAL/build`: build static SEAL libraries used by the Python extension.
+- `python3 setup.py build_ext -i`: build `seal` extension in-place for local development.
+- `python3 setup.py install`: install the module into the active environment.
+- `cp seal.*.so examples && python3 examples/4_bgv_basics.py`: smoke-test a Linux/macOS build with an example.
+- `docker build -t seal-python -f Dockerfile .`: build reproducible container environment.
+
+## Coding Style & Naming Conventions
+- Python: follow PEP 8, 4-space indentation, `snake_case` for functions/variables.
+- C++ bindings: keep existing style in `wrapper.cpp` (4-space indentation, grouped bindings by SEAL header/domain).
+- Exposed Python symbols should match upstream SEAL naming where practical (for API familiarity).
+- Prefer adding small, focused binding blocks rather than large mixed edits.
+
+## Testing Guidelines
+- No formal `tests/` suite is currently checked in; use example scripts as regression checks.
+- For binding changes, run at least one arithmetic flow (`examples/4_bgv_basics.py`) and one serialization flow (`examples/7_serialization.py`).
+- If adding new behavior, include a minimal runnable example in `examples/` named after the feature.
+
+## Commit & Pull Request Guidelines
+- Recent history favors short imperative subjects (for example: `Update deps`, `Update README.md`, `Update SEAL`).
+- Keep commit titles under ~72 characters and focused on one change.
+- PRs should include: purpose, build/test commands run, platform used, and any API surface changes.
+- Link related issues and include sample output when behavior changes are user-visible.

SEAL

@@ -0,0 +1,54 @@
+from seal import *
+from seal_helper import print_example_banner, print_parameters
+
+
+def bfv_basics():
+    print_example_banner("Example: BFV Basics")
+
+    parms = EncryptionParameters(scheme_type.bfv)
+    poly_modulus_degree = 8192
+    parms.set_poly_modulus_degree(poly_modulus_degree)
+    parms.set_coeff_modulus(CoeffModulus.BFVDefault(poly_modulus_degree))
+    parms.set_plain_modulus(1024)
+
+    context = SEALContext(parms)
+    print_parameters(context)
+    print(f"parameter validation: {context.parameter_error_message()}")
+
+    keygen = KeyGenerator(context)
+    secret_key = keygen.secret_key()
+    public_key = keygen.create_public_key()
+    relin_keys = keygen.create_relin_keys()
+
+    encryptor = Encryptor(context, public_key)
+    evaluator = Evaluator(context)
+    decryptor = Decryptor(context, secret_key)
+
+    x = 6
+    x_plain = Plaintext(str(x))
+    x_encrypted = encryptor.encrypt(x_plain)
+    print(f"fresh ciphertext size: {x_encrypted.size()}")
+    print(f"fresh noise budget: {decryptor.invariant_noise_budget(x_encrypted)} bits")
+
+    x_squared = evaluator.square(x_encrypted)
+    evaluator.relinearize_inplace(x_squared, relin_keys)
+
+    one = Plaintext("1")
+    x_sq_plus_one = evaluator.add_plain(x_squared, one)
+
+    x_plus_one = evaluator.add_plain(x_encrypted, one)
+    x_plus_one_sq = evaluator.square(x_plus_one)
+    evaluator.relinearize_inplace(x_plus_one_sq, relin_keys)
+
+    four = Plaintext("4")
+    evaluator.multiply_plain_inplace(x_sq_plus_one, four)
+    encrypted_result = evaluator.multiply(x_sq_plus_one, x_plus_one_sq)
+    evaluator.relinearize_inplace(encrypted_result, relin_keys)
+
+    plain_result = decryptor.decrypt(encrypted_result)
+    print("decrypted 4(x^2+1)(x+1)^2 (hex):", plain_result.to_string())
+    print(f"result noise budget: {decryptor.invariant_noise_budget(encrypted_result)} bits")
+
+
+if __name__ == "__main__":
+    bfv_basics()

examples/1_bfv_basics.py

@@ -0,0 +1,74 @@
+import numpy as np
+from seal import *
+from seal_helper import print_example_banner, print_parameters, print_vector
+
+
+def bfv_batch_encoder_example():
+    print_example_banner("Example: Encoders / BFV Batching")
+
+    parms = EncryptionParameters(scheme_type.bfv)
+    poly_modulus_degree = 8192
+    parms.set_poly_modulus_degree(poly_modulus_degree)
+    parms.set_coeff_modulus(CoeffModulus.BFVDefault(poly_modulus_degree))
+    parms.set_plain_modulus(PlainModulus.Batching(poly_modulus_degree, 20))
+
+    context = SEALContext(parms)
+    print_parameters(context)
+
+    keygen = KeyGenerator(context)
+    encryptor = Encryptor(context, keygen.create_public_key())
+    evaluator = Evaluator(context)
+    decryptor = Decryptor(context, keygen.secret_key())
+    batch_encoder = BatchEncoder(context)
+
+    slot_count = batch_encoder.slot_count()
+    pod_matrix = [0] * slot_count
+    pod_matrix[0:8] = [0, 1, 2, 3, 4, 5, 6, 7]
+
+    plain_matrix = batch_encoder.encode(pod_matrix)
+    encrypted_matrix = encryptor.encrypt(plain_matrix)
+
+    pod_matrix2 = [((i & 1) + 1) for i in range(slot_count)]
+    plain_matrix2 = batch_encoder.encode(pod_matrix2)
+
+    encrypted_matrix = evaluator.add_plain(encrypted_matrix, plain_matrix2)
+    evaluator.square_inplace(encrypted_matrix)
+    evaluator.relinearize_inplace(encrypted_matrix, keygen.create_relin_keys())
+
+    plain_result = decryptor.decrypt(encrypted_matrix)
+    pod_result = batch_encoder.decode(plain_result)
+    print_vector(pod_result.astype(np.float64), 8, 0)
+
+
+def ckks_encoder_example():
+    print_example_banner("Example: Encoders / CKKS")
+
+    parms = EncryptionParameters(scheme_type.ckks)
+    poly_modulus_degree = 8192
+    parms.set_poly_modulus_degree(poly_modulus_degree)
+    parms.set_coeff_modulus(CoeffModulus.Create(poly_modulus_degree, [40, 40, 40, 40, 40]))
+    context = SEALContext(parms)
+
+    encoder = CKKSEncoder(context)
+    keygen = KeyGenerator(context)
+    encryptor = Encryptor(context, keygen.create_public_key())
+    evaluator = Evaluator(context)
+    decryptor = Decryptor(context, keygen.secret_key())
+    relin_keys = keygen.create_relin_keys()
+
+    input_vec = [0.0, 1.1, 2.2, 3.3]
+    scale = 2.0 ** 30
+    plain = encoder.encode(input_vec, scale)
+    encrypted = encryptor.encrypt(plain)
+
+    evaluator.square_inplace(encrypted)
+    evaluator.relinearize_inplace(encrypted, relin_keys)
+
+    output_plain = decryptor.decrypt(encrypted)
+    output = encoder.decode(output_plain)
+    print_vector(output, 4, 4)
+
+
+if __name__ == "__main__":
+    bfv_batch_encoder_example()
+    ckks_encoder_example()

examples/2_encoders.py

@@ -0,0 +1,44 @@
+from seal import *
+from seal_helper import print_example_banner, print_parameters
+
+
+def levels_example():
+    print_example_banner("Example: Levels")
+
+    parms = EncryptionParameters(scheme_type.bfv)
+    poly_modulus_degree = 8192
+    parms.set_poly_modulus_degree(poly_modulus_degree)
+    parms.set_coeff_modulus(CoeffModulus.Create(poly_modulus_degree, [50, 30, 30, 50, 50]))
+    parms.set_plain_modulus(PlainModulus.Batching(poly_modulus_degree, 20))
+
+    context = SEALContext(parms)
+    print_parameters(context)
+
+    context_data = context.key_context_data()
+    print("modulus switching chain:")
+    while context_data is not None:
+        print(f"  chain index: {context_data.chain_index()}, coeff modulus count: {len(context_data.parms().coeff_modulus())}")
+        context_data = context_data.next_context_data()
+
+    keygen = KeyGenerator(context)
+    encryptor = Encryptor(context, keygen.create_public_key())
+    evaluator = Evaluator(context)
+    decryptor = Decryptor(context, keygen.secret_key())
+
+    plain = Plaintext("1x^3 + 2x^2 + 3x^1 + 4")
+    encrypted = encryptor.encrypt(plain)
+
+    print("noise budget while switching levels:")
+    while True:
+        print(f"  {decryptor.invariant_noise_budget(encrypted)} bits")
+        try:
+            evaluator.mod_switch_to_next_inplace(encrypted)
+        except ValueError:
+            break
+
+    decrypted = decryptor.decrypt(encrypted)
+    print("decrypted after switching:", decrypted.to_string())
+
+
+if __name__ == "__main__":
+    levels_example()

examples/3_levels.py

@@ -0,0 +1,62 @@
+import math
+from seal import *
+from seal_helper import print_example_banner, print_parameters, print_vector
+
+
+def ckks_basics():
+    print_example_banner("Example: CKKS Basics")
+
+    parms = EncryptionParameters(scheme_type.ckks)
+    poly_modulus_degree = 8192
+    parms.set_poly_modulus_degree(poly_modulus_degree)
+    parms.set_coeff_modulus(CoeffModulus.Create(poly_modulus_degree, [60, 40, 40, 60]))
+
+    context = SEALContext(parms)
+    print_parameters(context)
+
+    encoder = CKKSEncoder(context)
+    keygen = KeyGenerator(context)
+    encryptor = Encryptor(context, keygen.create_public_key())
+    evaluator = Evaluator(context)
+    decryptor = Decryptor(context, keygen.secret_key())
+    relin_keys = keygen.create_relin_keys()
+
+    scale = 2.0 ** 40
+    input_vec = [0.0, 0.4, 0.8, 1.2]
+    x_plain = encoder.encode(input_vec, scale)
+    x1_encrypted = encryptor.encrypt(x_plain)
+    x2_encrypted = evaluator.square(x1_encrypted)
+    evaluator.relinearize_inplace(x2_encrypted, relin_keys)
+    evaluator.rescale_to_next_inplace(x2_encrypted)
+
+    plain_coeff3 = encoder.encode(3.14159265, scale)
+    plain_coeff1 = encoder.encode(0.4, scale)
+    plain_coeff0 = encoder.encode(1.0, scale)
+
+    evaluator.mod_switch_to_inplace(plain_coeff3, x2_encrypted.parms_id())
+    x3_encrypted = evaluator.multiply_plain(x2_encrypted, plain_coeff3)
+    evaluator.rescale_to_next_inplace(x3_encrypted)
+
+    x1_encrypted_linear = evaluator.multiply_plain(x1_encrypted, plain_coeff1)
+    evaluator.rescale_to_next_inplace(x1_encrypted_linear)
+    evaluator.mod_switch_to_inplace(x1_encrypted_linear, x3_encrypted.parms_id())
+
+    evaluator.mod_switch_to_inplace(plain_coeff0, x3_encrypted.parms_id())
+
+    x3_encrypted.scale(scale)
+    x1_encrypted_linear.scale(scale)
+    encrypted_result = evaluator.add(x3_encrypted, x1_encrypted_linear)
+    encrypted_result = evaluator.add_plain(encrypted_result, plain_coeff0)
+
+    plain_result = decryptor.decrypt(encrypted_result)
+    result = encoder.decode(plain_result)
+
+    expected = [3.14159265 * (x * x) + 0.4 * x + 1.0 for x in input_vec]
+    print("expected:")
+    print_vector(expected, 4, 6)
+    print("computed:")
+    print_vector(result, 4, 6)
+
+
+if __name__ == "__main__":
+    ckks_basics()

examples/5_ckks_basics.py

@@ -0,0 +1,65 @@
+from seal import *
+from seal_helper import print_example_banner, print_parameters, print_vector
+
+
+def bfv_rotation():
+    print_example_banner("Example: Rotation / BFV")
+
+    parms = EncryptionParameters(scheme_type.bfv)
+    poly_modulus_degree = 8192
+    parms.set_poly_modulus_degree(poly_modulus_degree)
+    parms.set_coeff_modulus(CoeffModulus.BFVDefault(poly_modulus_degree))
+    parms.set_plain_modulus(PlainModulus.Batching(poly_modulus_degree, 20))
+
+    context = SEALContext(parms)
+    print_parameters(context)
+
+    keygen = KeyGenerator(context)
+    encryptor = Encryptor(context, keygen.create_public_key())
+    evaluator = Evaluator(context)
+    decryptor = Decryptor(context, keygen.secret_key())
+    batch_encoder = BatchEncoder(context)
+    galois_keys = keygen.create_galois_keys()
+
+    slot_count = batch_encoder.slot_count()
+    pod_matrix = [0] * slot_count
+    pod_matrix[0:8] = [0, 1, 2, 3, 4, 5, 6, 7]
+
+    plain_matrix = batch_encoder.encode(pod_matrix)
+    encrypted_matrix = encryptor.encrypt(plain_matrix)
+
+    evaluator.rotate_rows_inplace(encrypted_matrix, 3, galois_keys)
+    print_vector(batch_encoder.decode(decryptor.decrypt(encrypted_matrix)).astype(float), 8, 0)
+
+    evaluator.rotate_columns_inplace(encrypted_matrix, galois_keys)
+    print_vector(batch_encoder.decode(decryptor.decrypt(encrypted_matrix)).astype(float), 8, 0)
+
+
+def ckks_rotation():
+    print_example_banner("Example: Rotation / CKKS")
+
+    parms = EncryptionParameters(scheme_type.ckks)
+    poly_modulus_degree = 8192
+    parms.set_poly_modulus_degree(poly_modulus_degree)
+    parms.set_coeff_modulus(CoeffModulus.Create(poly_modulus_degree, [60, 40, 40, 60]))
+
+    context = SEALContext(parms)
+    encoder = CKKSEncoder(context)
+    keygen = KeyGenerator(context)
+    encryptor = Encryptor(context, keygen.create_public_key())
+    evaluator = Evaluator(context)
+    decryptor = Decryptor(context, keygen.secret_key())
+    galois_keys = keygen.create_galois_keys()
+
+    input_vec = [float(i) for i in range(8)]
+    plain = encoder.encode(input_vec, 2.0 ** 40)
+    encrypted = encryptor.encrypt(plain)
+
+    rotated = evaluator.rotate_vector(encrypted, 2, galois_keys)
+    result = encoder.decode(decryptor.decrypt(rotated))
+    print_vector(result, 8, 3)
+
+
+if __name__ == "__main__":
+    bfv_rotation()
+    ckks_rotation()