# Matmul operation does not always give correct result

**URL:** <https://openfhe.discourse.group/t/matmul-operation-does-not-always-give-correct-result/2332>\
**Category:** OpenFHE-NumPy\
**Created:** [June 11, 2026, 4:00pm UTC](https://openfhe.discourse.group/t/matmul-operation-does-not-always-give-correct-result/2332 "2026-06-11T16:00:36Z")\
**Posts on this page:** 2\
**Page:** 1

<div class="post-metadata">

**Author:** ![nbui](https://avatars.discourse-cdn.com/v4/letter/n/b2d939/32.png) [@nbui](https://openfhe.discourse.group/u/nbui)\
**Post date:** [June 11, 2026, 4:00pm UTC](https://openfhe.discourse.group/t/matmul-operation-does-not-always-give-correct-result/2332/1 "2026-06-11T16:00:36Z")

</div>

Depending on how the CTArray is initialized, the result of matrix multiplication may be incorrect (does not match the result from numpy matmul). Is this by design, or is this a bug?

```auto
Batch size: 16384
Starting matrix A:
[[1 2]
 [3 4]]
Decrypted result of A @ A:
Mode 'zero':
[[7.00000000e+00 8.00000000e+00]
 [1.20000000e+01 -3.38833803e-13]]
Mode 'tile':
[[7. 10.]
 [15. 22.]]
Mode 'tile' with batch_size = 4:
[[7.00000000e+00 8.00000000e+00]
 [1.20000000e+01 -5.02535914e-13]]
Mode 'tile' with batch_size = 16:
[[7. 10.]
 [15. 22.]]
Expected result:
[[7 10]
 [15 22]]

```

I have included the code to reproduce my result here:

```python
import numpy as np
from openfhe import *
import openfhe_numpy as onp

# Initialize CKKS context
params = CCParamsCKKSRNS()
params.SetMultiplicativeDepth(5)
params.SetScalingModSize(59)
params.SetFirstModSize(60)
params.SetScalingTechnique(FIXEDAUTO)
params.SetSecretKeyDist(UNIFORM_TERNARY)

# Initialize FHE Context
cc = GenCryptoContext(params)
cc.Enable(PKESchemeFeature.PKE)
cc.Enable(PKESchemeFeature.LEVELEDSHE)
cc.Enable(PKESchemeFeature.ADVANCEDSHE)

# Generate keys
keys = cc.KeyGen()
cc.EvalMultKeyGen(keys.secretKey)
cc.EvalSumKeyGen(keys.secretKey)

ring_dim = cc.GetRingDimension()
batch_size = ring_dim // 2
print("Batch size:", batch_size)

# Create matrix and encrypt it
A = np.array([[1, 2], [3, 4]])
print("Starting matrix A:")
print(A)

# Encrypt with OpenFHE-NumPy
# Encrypt mode 'zero'
ctm_Az = onp.array(
      cc=cc,
      data=A,
      batch_size=batch_size,
      order=onp.ROW_MAJOR,
      fhe_type="C",
      mode="zero",
      public_key=keys.publicKey,
   )

# Encrypt mode 'tile'
ctm_At = onp.array(
      cc=cc,
      data=A,
      batch_size=batch_size,
      order=onp.ROW_MAJOR,
      fhe_type="C",
      mode="tile",
      public_key=keys.publicKey,
   )

# Encrypt mode 'tile' with batch_size = A.size = 4
ctm_Atb = onp.array(
      cc=cc,
      data=A,
      batch_size=A.size,
      order=onp.ROW_MAJOR,
      fhe_type="C",
      mode="tile",
      public_key=keys.publicKey,
   )

# Encrypt mode 'tile' with batch_size **2 = A.size** 2 = 16
ctm_Atb2 = onp.array(
      cc=cc,
      data=A,
      batch_size=A.size ** 2,
      order=onp.ROW_MAJOR,
      fhe_type="C",
      mode="tile",
      public_key=keys.publicKey,
   )

# Generate keys
assert ctm_Az.ncols == ctm_At.ncols
assert ctm_At.ncols == ctm_Atb.ncols
onp.EvalSquareMatMultRotateKeyGen(keys.secretKey, ctm_Az.ncols)

# Perform encrypted operations
product_Az = ctm_Az @ ctm_Az
product_At = ctm_At @ ctm_At
product_Atb = ctm_Atb @ ctm_Atb
product_Atb2 = ctm_Atb2 @ ctm_Atb2

# Decrypt results
decrypted_Az = product_Az.decrypt(keys.secretKey, unpack_type="original")
decrypted_At = product_At.decrypt(keys.secretKey, unpack_type="original")
decrypted_Atb = product_Atb.decrypt(keys.secretKey, unpack_type="original")
decrypted_Atb2 = product_Atb2.decrypt(keys.secretKey, unpack_type="original")

print("Decrypted result of A @ A:")

# Incorrect result
print("Mode 'zero':")
print(decrypted_Az)

# Correct result
print("Mode 'tile':")
print(decrypted_At)

# Incorrect result
print("Mode 'tile' with batch_size = 4:")
print(decrypted_Atb)

# Correct result
print("Mode 'tile' with batch_size = 16:")
print(decrypted_Atb2)

# Expected result from numpy
print("Expected result:")
print(A @ A)

```

---

<div class="post-metadata">

**Author:** ![yuki](https://avatars.discourse-cdn.com/v4/letter/y/8edcca/32.png) [@yuki](https://openfhe.discourse.group/u/yuki)\
**Post date:** [June 25, 2026, 10:40am UTC](https://openfhe.discourse.group/t/matmul-operation-does-not-always-give-correct-result/2332/2 "2026-06-25T10:40:48Z")

</div>

Thank you. In the current version, matrix multiplication supports only certain packing styles. However, we have updated this in the next version, which will be released soon.