# Is there a reason why with symmetric padding, the inverse wavelet transform is not the adjoint of the wavelet transform?

I recently stumbled upon a bothering fact when using the pywavelet library in Python. When we use the default "symmetric" padding, the inverse wavelet transform is not the adjoint of the wavelet transform (and it's not the mathematical inverse of the wavelet transform, "only in one direction").

However, if you use the "zero" padding the adjoint property is verified (not the inverse property). And if you use the "periodization" padding then all the properties are verified.

I wanted to know if there was a theoretical reason behind why the padding has such a big influence on these properties or if it was down to implementation.

You can find a code below highlighting the said issue:


import numpy as np
import pywt

wavelet_type = "db4"
level = 4
mode = "symmetric"

coeffs_tpl = pywt.wavedecn(data=np.zeros((512, 512)), wavelet=wavelet_type, mode=mode, level=level)
coeffs_1d, coeff_slices, coeff_shapes = pywt.ravel_coeffs(coeffs_tpl)
coeffs_tpl_rec = pywt.unravel_coeffs(coeffs_1d, coeff_slices, coeff_shapes)
_ = pywt.waverecn(coeffs_tpl_rec, wavelet=wavelet_type, mode=mode)

def py_W(im):
alpha = pywt.wavedecn(data=im, wavelet=wavelet_type, mode=mode, level=level)
alpha, _, _ = pywt.ravel_coeffs(alpha)
return alpha

def py_Ws(alpha):
coeffs = pywt.unravel_coeffs(alpha, coeff_slices, coeff_shapes)
im = pywt.waverecn(coeffs, wavelet=wavelet_type, mode=mode)
return im

x_example = np.random.rand(*coeffs_1d.shape)
y_example = np.random.rand(512, 512)
T_x_y = np.dot(py_Ws(x_example).flatten(), np.conjugate(y_example.flatten()))
print("\n Inverse from image to image:")
print(np.allclose(py_Ws(py_W(y_example)), y_example))
print("\n Inverse from coefficients to coefficients:")
print(np.allclose(py_W(py_Ws(x_example)), x_example))



EDIT: When reading the documentation about the different paddings, I could see that the problematic paddings compute a redundant representation of the original image (for example you have more coefficients than pixels in your original image). Therefore, it's normal that the inverse property is not verified from coefficients to coefficients (if taken at random without structure). However, this doesn't explain why the adjoint property is not verified.

Also I don't know whether this redundance is theoretical to ensure perfect reconstruction or is an implementation choice.