Error-correcting Code VS Lattice-based Crypto I'm not an expert in PQ-crypto, but as I understand error-correcting code and lattice-based crypto, the cryptographic assumptions are very similar. The key difference for me is the nature of the noise. In one case, the noise is inspired by the &quot;physical noise,&quot; in the other, it's more mathematical and considers a more complex distance (Euclidean distance instead of Hamming distance).
Intuitively, this reason makes sense because every application I know involving lattice-based crypto is more efficient than those based on
error-correcting crypto.

Does my intuition seem correct to you?

If yes, is there a theorem that certifies that every cryptographic protocol based on an error-correcting-code assumption could be transformed into a more efficient lattice-based protocol (i.e., with the same level of security and based on a weaker lattice assumption)?

If no, is there a more informal claim of available research which considers this question? Or it just doesn't make sense to compare these two families of assumptions?
Broadly speaking, it's true that the main difference between &quot;code-based cryptography&quot; assumptions and &quot;lattice-based&quot; assumptions is the noise distribution.
There are of course exceptions, e.g. code-based cryptosystems using the rank metric, or binary LPN, where the noise can be described as either small Hamming weight or small Euclidean distance.

In one case the noise is inspired of the &quot;physical noise&quot;, and in the other one, it's more mathematical and consider a more complex distance (euclidean distance instead hamming distance).

I'm not sure about these analogies of &quot;physical&quot; and &quot;mathematical&quot; noise. Both types of noise may be useful mathematical models in different physical scenarios, e.g. low Hamming weight noise can model bits flipped during transmission, while Gaussian noise can model small perturbations in an image from a noisy sensor. In any case, these analogies aren't really relevant to cryptography.

is there a theorem which certify that every cryptographic protocol based on an error-correcting code assumption could be transformed in a more efficient protocol based on lattice (i.e with the same level of security and based on a weaker lattice assumption)?

I don't know of any general theorems like this. While lattice-based protocols are often more efficient, this is not always the case and it very much depends on the cryptographic application.
A natural example where lattices beat codes is key exchange. Here, lattice-based protocols such as Kyber are much simpler and faster than their code-based analogues like BIKE, largely due to an expensive error-correction step in the code-based setting, compared with cheap rounding techniques to correct errors in the lattice setting.
Another example is the challenge of constructing linearly homomorphic encryption schemes. This is quite straightforward using lattices, but still an unsolved problem from code-based assumptions. There is even evidence that this is impossible to achieve using natural &quot;arithmetic&quot; techniques - see the paper of Applebaum, Avron and Brzuska; this work only looks at specific applications, but may contain the types of theorems you are interested in.
On the other hand, there are cases where small-Hamming-weight noise can give efficiency benefits. A fairly recent example is when generating private, correlated randomness (e.g. multiplication triples or random oblivious transfers) for use in secure multi-party computation protocols. Using code-based assumptions, there are efficient techniques for compressing the correlated randomness down to much shorter seeds, which can be later expanded. This compression technique crucially relies on the sparse noise distribution, and analogous methods in the lattice setting are much more expensive. (See for instance, these works)