mirror of
https://github.com/luxfhe/torus.git
synced 2026-10-30 17:07:26 +00:00
zeekay
b832ba2c39
Forked from upstream concrete (BSD-3-Clause-Clear, © 2024 ZAMA) at HEAD
ecb729bb. Modifications copyright © 2026 Lux Industries Inc.
Rebranding scope:
- Python module concrete → torus (across frontends/torus-python)
- Rust module concrete-* → torus-* (across frontends/torus-rust)
- MLIR dialect concretelang → toruslang (across compilers/torus-compiler)
- Compiler optimizer concrete-optimizer → torus-optimizer
- Backend concrete-cpu / concrete-cuda → torus-cpu / torus-cuda
- Wire protocol concrete-protocol → torus-protocol
- Parameter-curves concrete-security-curves-* → torus-security-curves-*
- Public symbols concretelib → toruslib, ConcreteLang → TorusLang
- URLs github.com/zama-ai/concrete → github.com/luxfhe/torus
- URLs docs.zama.ai/concrete → docs.luxfhe.com/torus
Legal compliance:
- LICENSE.txt retains original Copyright © 2024 ZAMA verbatim (§1-§2)
- LICENSE.txt adds modifications copyright © 2026 Lux Industries Inc.
- §3 endorsement clause: Torus is marketed exclusively as a Lux product;
no Zama name used in README, docs, or marketing
- NOTICE file provides factual attribution per legal best practice
(not endorsement; required by upstream BSD-3-Clause-Clear)
README + NOTICE rewritten from scratch with Lux brand:
- Quick-start in Python (torus.fhe)
- Architecture diagram showing the gen-1 vtbl integration path
(luxcpp/gpu → lux-private/gpu-kernels for CUDA/Metal/WebGPU)
- Scheme coverage table: TFHE (luxfi/fhe), CKKS/BGV/BFV (luxfi/lattice)
- Lux FHE family table: Torus / TorusVM / TorusEVM / TorusML / TorusNet
Known limitations (phase-2A scope):
- PyPI package torus-fhe not yet published; the torus Python module
is renamed structurally but pip-installable distribution is a
follow-up (Phase 2A.1)
- MLIR dialect rename is text-level; the compiler-internal LLVM
rebuild (concrete-compiler-internal-llvm-project submodule) is
structural and works; tablegen files renamed concrete→torus but the
generated .inc files in the source tree will regenerate at build
time
- backends/torus-cuda/implementation/ is an upstream submodule
pointer to the tfhe-rs source (not fetched in the staging clone);
the CUDA backend body is delivered out-of-tree
- ~100 test-fixture variable names like concrete_encoded_sample
retain "concrete" as a math term (vs symbolic); these are inside
tests/, not the public API; cleanup is a follow-up commit
- 295 Python `from concrete import ...` residuals in luxfhe/ml-sdk
consumer remain; that repo's import update is Phase 2B
This commit is the seed for the luxfhe/torus repo. Push as the first
commit to a fresh GitHub repo; do not re-import upstream Zama git
history.
1062 lines
42 KiB
Python
1062 lines
42 KiB
Python
"""
|
|
Tests of execution of dynamic indexing operation.
|
|
"""
|
|
|
|
import random
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
from torus import fhe
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"encryption_status,function,inputset",
|
|
[
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3], lambda _: np.random.randint(0, 3)),
|
|
id="x[y] where x.shape == (3,) | 0 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3], lambda _: np.random.randint(-3, 3)),
|
|
id="x[y] where x.shape == (3,) | -3 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 31], lambda _: np.random.randint(0, 3)),
|
|
id="x[y] where x.shape == (31,) | 0 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 31], lambda _: np.random.randint(-3, 3)),
|
|
id="x[y] where x.shape == (31,) | -3 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 0],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(0, 3)),
|
|
id="x[y, 0] where x.shape == (3, 4) | 0 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 0],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(-3, 3)),
|
|
id="x[y, 0] where x.shape == (3, 4) | -3 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1, y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(0, 4)),
|
|
id="x[1, y] where x.shape == (3, 4) | 0 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1, y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(-4, 4)),
|
|
id="x[1, y] where x.shape == (3, 4) | -4 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4],
|
|
lambda _: np.random.randint(0, 3),
|
|
lambda _: np.random.randint(0, 4),
|
|
),
|
|
id="x[y, z] where x.shape == (3, 4) | 0 < y < 3 | 0 < z < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4],
|
|
lambda _: np.random.randint(0, 3),
|
|
lambda _: np.random.randint(-4, 4),
|
|
),
|
|
id="x[y, z] where x.shape == (3, 4) | 0 < y < 3 | -4 < z < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4],
|
|
lambda _: np.random.randint(-3, 3),
|
|
lambda _: np.random.randint(0, 4),
|
|
),
|
|
id="x[y, z] where x.shape == (3, 4) | -3 < y < 3 | 0 < z < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4],
|
|
lambda _: np.random.randint(-3, 3),
|
|
lambda _: np.random.randint(-4, 4),
|
|
),
|
|
id="x[y, z] where x.shape == (3, 4) | -3 < y < 3 | -4 < z < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(0, 3)),
|
|
id="x[y] where x.shape == (3, 4) | 0 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(-3, 3)),
|
|
id="x[y] where x.shape == (3, 4) | -3 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[:, y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(0, 4)),
|
|
id="x[:, y] where x.shape == (3, 4) | 0 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[:, y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(-4, 4)),
|
|
id="x[:, y] where x.shape == (3, 4) | -4 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 2],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(0, 3)),
|
|
id="x[y, 2] where x.shape == (3, 4) | 0 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 2],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(-3, 3)),
|
|
id="x[y, 2] where x.shape == (3, 4) | -3 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, -2],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(0, 3)),
|
|
id="x[y, -2] where x.shape == (3, 4) | 0 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, -2],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(-3, 3)),
|
|
id="x[y, -2] where x.shape == (3, 4) | -3 < y < 3",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1, y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(0, 4)),
|
|
id="x[1, y] where x.shape == (3, 4) | 0 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1, y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(-4, 4)),
|
|
id="x[1, y] where x.shape == (3, 4) | -4 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[-1, y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(0, 4)),
|
|
id="x[-1, y] where x.shape == (3, 4) | 0 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[-1, y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 3, 4], lambda _: np.random.randint(-4, 4)),
|
|
id="x[-1, y] where x.shape == (3, 4) | -4 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, 4:6],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 10, 9, 8], lambda _: np.random.randint(0, 9)),
|
|
id="x[1:3, y, 4:6] where x.shape == (10, 9, 8) | 0 < y < 9",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, 4:6],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 10, 9, 8], lambda _: np.random.randint(-9, 9)),
|
|
id="x[1:3, y, 4:6] where x.shape == (10, 9, 8) | -9 < y < 9",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, 0, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 10, 9, 8],
|
|
lambda _: np.random.randint(0, 10),
|
|
lambda _: np.random.randint(0, 8),
|
|
),
|
|
id="x[y, 0, z] where x.shape == (10, 9, 8) | 0 < y < 10 | 0 < z < 8",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, 0, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 10, 9, 8],
|
|
lambda _: np.random.randint(0, 10),
|
|
lambda _: np.random.randint(-8, 8),
|
|
),
|
|
id="x[y, 0, z] where x.shape == (10, 9, 8) | 0 < y < 10 | -8 < z < 8",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, 0, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 10, 9, 8],
|
|
lambda _: np.random.randint(-10, 10),
|
|
lambda _: np.random.randint(0, 8),
|
|
),
|
|
id="x[y, 0, z] where x.shape == (10, 9, 8) | -10 < y < 10 | 0 < z < 8",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, 0, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 10, 9, 8],
|
|
lambda _: np.random.randint(-10, 10),
|
|
lambda _: np.random.randint(-8, 8),
|
|
),
|
|
id="x[y, 0, z] where x.shape == (10, 9, 8) | -10 < y < 10 | -8 < z < 8",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 5], lambda _: np.random.randint(0, 5, size=(3,))),
|
|
id="x[y] where x.shape == (5,) | 0 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 5], lambda _: np.random.randint(-5, 5, size=(3,))),
|
|
id="x[y] where x.shape == (5,) | -5 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 5], lambda _: np.random.randint(0, 5, size=(3, 2))),
|
|
id="x[y] where x.shape == (5,) | 0 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y],
|
|
fhe.inputset(fhe.tensor[fhe.uint4, 5], lambda _: np.random.randint(-5, 5, size=(3, 2))),
|
|
id="x[y] where x.shape == (5,) | -5 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=(3,)),
|
|
),
|
|
id="x[y, 1] where x.shape == (5, 3) | 0 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(-5, 5, size=(3,)),
|
|
),
|
|
id="x[y, 1] where x.shape == (5, 3) | -5 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=(3, 2)),
|
|
),
|
|
id="x[y, 1] where x.shape == (5, 3) | -5 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=(3, 2)),
|
|
),
|
|
id="x[y, 1] where x.shape == (5, 3) | -5 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, [2, 0]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=()),
|
|
),
|
|
id="x[y, [2, 0]] where x.shape == (5, 3) | 0 < y < 5",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, [2, 0]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(-5, 5, size=()),
|
|
),
|
|
id="x[y, [2, 0]] where x.shape == (5, 3) | -5 < y < 5",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, [2, 0]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=(2,)),
|
|
),
|
|
id="x[y, [2, 0]] where x.shape == (5, 3) | 0 < y < 5 where y.shape == (2,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, [2, 0]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(-5, 5, size=(2,)),
|
|
),
|
|
id="x[y, [2, 0]] where x.shape == (5, 3) | -5 < y < 5 where y.shape == (2,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=(2,)),
|
|
lambda _: np.random.randint(0, 3, size=(2,)),
|
|
),
|
|
id=(
|
|
"x[y, z] where x.shape == (5, 3) "
|
|
"| 0 < y < 5 where y.shape == (2,) "
|
|
"| 0 < z < 3 where z.shape == (2,)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=(2,)),
|
|
lambda _: np.random.randint(-3, 3, size=(2,)),
|
|
),
|
|
id=(
|
|
"x[y, z] where x.shape == (5, 3)"
|
|
"| 0 < y < 5 where y.shape == (2,) "
|
|
"| -3 < z < 3 where z.shape == (2,)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(-5, 5, size=(2,)),
|
|
lambda _: np.random.randint(0, 3, size=(2,)),
|
|
),
|
|
id=(
|
|
"x[y, z] where x.shape == (5, 3)"
|
|
"| -5 < y < 5 where y.shape == (2,) "
|
|
"| 0 < z < 3 where z.shape == (2,)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(-5, 5, size=(2,)),
|
|
lambda _: np.random.randint(-3, 3, size=(2,)),
|
|
),
|
|
id=(
|
|
"x[y, z] where x.shape == (5, 3) "
|
|
"| -5 < y < 5 where y.shape == (2,) "
|
|
"| -3 < z < 3 where z.shape == (2,)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=(3, 2)),
|
|
lambda _: np.random.randint(0, 3, size=(3, 2)),
|
|
),
|
|
id=(
|
|
"x[y, z] where x.shape == (5, 3) | 0 < y < 5 where y.shape == (3, 2) "
|
|
"| 0 < z < 3 where z.shape == (3, 2)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(0, 5, size=(3, 2)),
|
|
lambda _: np.random.randint(-3, 3, size=(3, 2)),
|
|
),
|
|
id=(
|
|
"x[y, z] where x.shape == (5, 3) "
|
|
"| 0 < y < 5 where y.shape == (3, 2) "
|
|
"| -3 < z < 3 where z.shape == (3, 2)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(-5, 5, size=(3, 2)),
|
|
lambda _: np.random.randint(0, 3, size=(3, 2)),
|
|
),
|
|
id=(
|
|
"x[y, z] where x.shape == (5, 3) "
|
|
"| -5 < y < 5 where y.shape == (3, 2) "
|
|
"| 0 < z < 3 where z.shape == (3, 2)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 3],
|
|
lambda _: np.random.randint(-5, 5, size=(3, 2)),
|
|
lambda _: np.random.randint(-3, 3, size=(3, 2)),
|
|
),
|
|
id=(
|
|
"x[y, z] where x.shape == (5, 3) "
|
|
"| -5 < y < 5 where y.shape == (3, 2) "
|
|
"| -3 < z < 3 where z.shape == (3, 2)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 6],
|
|
lambda _: np.random.randint(0, 5, size=(3,)),
|
|
),
|
|
id="x[y, 2:4] where x.shape == (5, 6) | 0 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5, size=(3,)),
|
|
),
|
|
id="x[y, 2:4] where x.shape == (5, 6) | -5 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[3, y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 5, size=(3,)),
|
|
),
|
|
id="x[3, y, 2:4] where x.shape == (4, 5, 6) | 0 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[3, y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5, size=(3,)),
|
|
),
|
|
id="x[3, y, 2:4] where x.shape == (4, 5, 6) | -5 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, 4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 5, size=(3,)),
|
|
),
|
|
id="x[1:3, y, 4] where x.shape == (4, 5, 6) | 0 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, 4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5, size=(3,)),
|
|
),
|
|
id="x[1:3, y, 4] where x.shape == (4, 5, 6) | -5 < y < 5 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 3, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 4, size=(3,)),
|
|
),
|
|
id="x[y, 3, 2:4] where x.shape == (4, 5, 6) | 0 < y < 4 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 3, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-4, 4, size=(3,)),
|
|
),
|
|
id="x[y, 3, 2:4] where x.shape == (4, 5, 6) | -4 < y < 4 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1:3, 4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 4, size=(3,)),
|
|
),
|
|
id="x[y, 1:3, 4] where x.shape == (4, 5, 6) | 0 < y < 4 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1:3, 4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-4, 4, size=(3,)),
|
|
),
|
|
id="x[y, 1:3, 4] where x.shape == (4, 5, 6) | -4 < y < 4 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1, 2:4, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 6, size=(3,)),
|
|
),
|
|
id="x[1, 2:4, y] where x.shape == (4, 5, 6) | 0 < y < 6 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1, 2:4, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-6, 6, size=(3,)),
|
|
),
|
|
id="x[1, 2:4, y] where x.shape == (4, 5, 6) | -6 < y < 6 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[0:2, 3, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 6, size=(3,)),
|
|
),
|
|
id="x[0:2, 3, y] where x.shape == (4, 5, 6) | 0 < y < 6 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[0:2, 3, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-6, 6, size=(3,)),
|
|
),
|
|
id="x[0:2, 3, y] where x.shape == (4, 5, 6) | -6 < y < 6 where y.shape == (3,)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[[3, 1], y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 5),
|
|
),
|
|
id="x[[3, 1], y, 2:4] where x.shape == (4, 5, 6) | 0 < y < 5",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[[3, 1], y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5),
|
|
),
|
|
id="x[[3, 1], y, 2:4] where x.shape == (4, 5, 6) | -5 < y < 5",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, [4, 2]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 5),
|
|
),
|
|
id="x[1:3, y, [4, 2]] where x.shape == (4, 5, 6) | 0 < y < 5",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, [4, 2]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5),
|
|
),
|
|
id="x[1:3, y, [4, 2]] where x.shape == (4, 5, 6) | -5 < y < 5",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, [3, 1], 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 4),
|
|
),
|
|
id="x[y, [3, 1], 2:4] where x.shape == (4, 5, 6) | 0 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, [3, 1], 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-4, 4),
|
|
),
|
|
id="x[y, [3, 1], 2:4] where x.shape == (4, 5, 6) | -4 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1:3, [4, 2]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 4),
|
|
),
|
|
id="x[y, 1:3, [4, 2]] where x.shape == (4, 5, 6) | 0 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1:3, [4, 2]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-4, 4),
|
|
),
|
|
id="x[y, 1:3, [4, 2]] where x.shape == (4, 5, 6) | -4 < y < 4",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[[1, 0], 2:4, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 6),
|
|
),
|
|
id="x[[1, 0], 2:4, y] where x.shape == (4, 5, 6) | 0 < y < 6",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[[1, 0], 2:4, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-6, 6),
|
|
),
|
|
id="x[[1, 0], 2:4, y] where x.shape == (4, 5, 6) | -6 < y < 6",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[0:2, [4, 2], y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 6),
|
|
),
|
|
id="x[0:2, [4, 2], y] where x.shape == (4, 5, 6) | 0 < y < 6",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[0:2, [4, 2], y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-6, 6),
|
|
),
|
|
id="x[0:2, [4, 2], y] where x.shape == (4, 5, 6) | -6 < y < 6",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[3, y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 5, size=(3, 2)),
|
|
),
|
|
id="x[3, y, 2:4] where x.shape == (4, 5, 6) | 0 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[3, y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5, size=(3, 2)),
|
|
),
|
|
id="x[3, y, 2:4] where x.shape == (4, 5, 6) | -5 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, 4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 5, size=(3, 2)),
|
|
),
|
|
id="x[1:3, y, 4] where x.shape == (4, 5, 6) | 0 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, 4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5, size=(3, 2)),
|
|
),
|
|
id="x[1:3, y, 4] where x.shape == (4, 5, 6) | -5 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 3, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 4, size=(3, 2)),
|
|
),
|
|
id="x[y, 3, 2:4] where x.shape == (4, 5, 6) | 0 < y < 4 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 3, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-4, 4, size=(3, 2)),
|
|
),
|
|
id="x[y, 3, 2:4] where x.shape == (4, 5, 6) | -4 < y < 4 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1:3, 4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 4, size=(3, 2)),
|
|
),
|
|
id="x[y, 1:3, 4] where x.shape == (4, 5, 6) | 0 < y < 4 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1:3, 4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-4, 4, size=(3, 2)),
|
|
),
|
|
id="x[y, 1:3, 4] where x.shape == (4, 5, 6) | -4 < y < 4 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1, 2:4, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 6, size=(3, 2)),
|
|
),
|
|
id="x[1, 2:4, y] where x.shape == (4, 5, 6) | 0 < y < 6 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1, 2:4, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-6, 6, size=(3, 2)),
|
|
),
|
|
id="x[1, 2:4, y] where x.shape == (4, 5, 6) | -6 < y < 6 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[0:2, 3, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 6, size=(3, 2)),
|
|
),
|
|
id="x[0:2, 3, y] where x.shape == (4, 5, 6) | 0 < y < 6 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[0:2, 3, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-6, 6, size=(3, 2)),
|
|
),
|
|
id="x[0:2, 3, y] where x.shape == (4, 5, 6) | -6 < y < 6 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[[3, 1], y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 5, size=(3, 2)),
|
|
),
|
|
id="x[[3, 1], y, 2:4] where x.shape == (4, 5, 6) | 0 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[[3, 1], y, 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5, size=(3, 2)),
|
|
),
|
|
id="x[[3, 1], y, 2:4] where x.shape == (4, 5, 6) | -5 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, [4, 2]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 5, size=(3, 2)),
|
|
),
|
|
id="x[1:3, y, [4, 2]] where x.shape == (4, 5, 6) | 0 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[1:3, y, [4, 2]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-5, 5, size=(3, 2)),
|
|
),
|
|
id="x[1:3, y, [4, 2]] where x.shape == (4, 5, 6) | -5 < y < 5 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, [3, 1], 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 4, size=(3, 2)),
|
|
),
|
|
id="x[y, [3, 1], 2:4] where x.shape == (4, 5, 6) | 0 < y < 4 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, [3, 1], 2:4],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-4, 4, size=(3, 2)),
|
|
),
|
|
id="x[y, [3, 1], 2:4] where x.shape == (4, 5, 6) | -4 < y < 4 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1:3, [4, 2]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 4, size=(3, 2)),
|
|
),
|
|
id="x[y, 1:3, [4, 2]] where x.shape == (4, 5, 6) | 0 < y < 4 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[y, 1:3, [4, 2]],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-4, 4, size=(3, 2)),
|
|
),
|
|
id="x[y, 1:3, [4, 2]] where x.shape == (4, 5, 6) | -4 < y < 4 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[[1, 0], 2:4, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 6, size=(3, 2)),
|
|
),
|
|
id="x[[1, 0], 2:4, y] where x.shape == (4, 5, 6) | 0 < y < 6 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[[1, 0], 2:4, y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-6, 6, size=(3, 2)),
|
|
),
|
|
id="x[[1, 0], 2:4, y] where x.shape == (4, 5, 6) | -6 < y < 6 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[0:2, [4, 2], y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(0, 6, size=(3, 2)),
|
|
),
|
|
id="x[0:2, [4, 2], y] where x.shape == (4, 5, 6) | 0 < y < 6 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[0:2, [4, 2], y],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 4, 5, 6],
|
|
lambda _: np.random.randint(-6, 6, size=(3, 2)),
|
|
),
|
|
id="x[0:2, [4, 2], y] where x.shape == (4, 5, 6) | -6 < y < 6 where y.shape == (3, 2)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear"},
|
|
lambda x, y: x[:, y, :],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 10, 20, 30],
|
|
lambda _: np.random.randint(0, 20, size=(2, 3, 4)),
|
|
),
|
|
id="x[:, y, :] where x.shape == (10, 20, 30) | 0 < y < 20 where y.shape == (2, 3, 4)",
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[:, y, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 4, size=(2, 3, 4)),
|
|
lambda _: np.random.randint(0, 5, size=(3, 4)),
|
|
),
|
|
id=(
|
|
"x[:, y, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 4 where y.shape == (2, 3, 4) "
|
|
"| 0 < z < 5 where z.shape == (3, 4)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[:, y, :, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 4, size=(2, 3, 4)),
|
|
lambda _: np.random.randint(0, 6, size=(3, 4)),
|
|
),
|
|
id=(
|
|
"x[:, y, :, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 4 where y.shape == (2, 3, 4) "
|
|
"| 0 < z < 6 where z.shape == (3, 4)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, :, :, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 3, size=(2, 3, 4)),
|
|
lambda _: np.random.randint(0, 6, size=(3, 4)),
|
|
),
|
|
id=(
|
|
"x[y, :, :, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 3 where y.shape == (2, 3, 4) "
|
|
"| 0 < z < 6 where z.shape == (3, 4)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, 2:, [3, 1, 0, 4], :3, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 3, size=(2, 3, 4)),
|
|
lambda _: np.random.randint(0, 7, size=(3, 4)),
|
|
),
|
|
id=(
|
|
"x[y, 2:, [3, 1, 0, 4], :3, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 3 where y.shape == (2, 3, 4) "
|
|
"| 0 < z < 7 where z.shape == (3, 4)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[1:, y, [3, 1, 0, 4], :3, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 4, size=(2, 3, 4)),
|
|
lambda _: np.random.randint(0, 7, size=(3, 4)),
|
|
),
|
|
id=(
|
|
"x[1:, y, [3, 1, 0, 4], :3, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 4 where y.shape == (2, 3, 4) "
|
|
"| 0 < z < 7 where z.shape == (3, 4)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, 2:, [3, 1, 0, 4], :3, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 3),
|
|
lambda _: np.random.randint(0, 7, size=(3, 4)),
|
|
),
|
|
id=(
|
|
"x[y, 2:, [3, 1, 0, 4], :3, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 3 "
|
|
"| 0 < z < 7 where z.shape == (3, 4)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[1:, y, [3, 1, 0, 4], :3, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 4),
|
|
lambda _: np.random.randint(0, 7, size=(3, 4)),
|
|
),
|
|
id=(
|
|
"x[1:, y, [3, 1, 0, 4], :3, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 4 "
|
|
"| 0 < z < 7 where z.shape == (3, 4)"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, 2:, [3, 1, 0, 4], :3, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 3, size=(2, 3, 4)),
|
|
lambda _: np.random.randint(0, 7),
|
|
),
|
|
id=(
|
|
"x[y, 2:, [3, 1, 0, 4], :3, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 3 where y.shape == (2, 3, 4) "
|
|
"| 0 < z < 7"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[1:, y, [3, 1, 0, 4], :3, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 4, size=(2, 3, 4)),
|
|
lambda _: np.random.randint(0, 7),
|
|
),
|
|
id=(
|
|
"x[1:, y, [3, 1, 0, 4], :3, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 4 where y.shape == (2, 3, 4) "
|
|
"| 0 < z < 7 "
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[y, 2:, [3, 1, 0, 4], :3, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 3),
|
|
lambda _: np.random.randint(0, 7),
|
|
),
|
|
id=(
|
|
"x[y, 2:, [3, 1, 0, 4], :3, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 3 "
|
|
"| 0 < z < 7"
|
|
),
|
|
),
|
|
pytest.param(
|
|
{"x": "encrypted", "y": "clear", "z": "clear"},
|
|
lambda x, y, z: x[1:, y, [3, 1, 0, 4], :3, z],
|
|
fhe.inputset(
|
|
fhe.tensor[fhe.uint4, 3, 4, 5, 6, 7],
|
|
lambda _: np.random.randint(0, 4),
|
|
lambda _: np.random.randint(0, 7),
|
|
),
|
|
id=(
|
|
"x[1:, y, [3, 1, 0, 4], :3, z] where x.shape == (3, 4, 5, 6, 7) "
|
|
"| 0 < y < 4 "
|
|
"| 0 < z < 7 "
|
|
),
|
|
),
|
|
],
|
|
)
|
|
def test_dynamic_indexing(encryption_status, function, inputset, helpers):
|
|
"""
|
|
Test dynamic indexing.
|
|
"""
|
|
|
|
configuration = helpers.configuration()
|
|
|
|
compiler = fhe.Compiler(function, encryption_status)
|
|
circuit = compiler.compile(inputset, configuration)
|
|
|
|
for sample in random.sample(inputset, 8):
|
|
helpers.check_execution(circuit, function, list(sample))
|