In Circom, what's the difference between variable and signal, and between function and template?

Question

This might be a newbie question:

From the doc, it says that signals are part of the circuit while variables are similar to variables in other programming language. But for verifiable computation, I'd assume that the computations done on variables would also be verified and therefore be part of the circuit. In this sense, can I see signals as the interface of the template while the variables as the internal states? If so, what are the differences between internal signals and variables?

Or when should one use variable and when should one use signal?

I have the same questions for functions v.s. templates. Why do we need both instead of one? When should one use function and when should one use template?

My fundamental confusion is that I thought circom would produce a circuit encapsulating everything defined in the circom files. But the language defined two types of constructs (variable/function vs signal/template) with one being more restrictive than the other, and it cites "being part of the circuit" as the reason for signal/template to be more restrictive, making it sounds like variables/functions are not part of the circuit.

Thanks!

Answer 1

I think I can answer my own question now. (with help from this post https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56#:~:text=For%20instance%2C%20Circom%20only%20allows,be%20the%20set%20of%20constraints.)

Apparently I thought that the entirety of the program will be verified, but in reality circom let the programmer decide *which part of the program will be verified. The circom file has 1. the execution portion "<--" and 2. the verification portion "===". Execution is not automatically verified unless coupled with verification specifications.

This allows the programmer to write complex executions that are not verified and put verification at the interface to verify the relation between the inputs and the outputs.

I'm still trying to wrap my head around why this is a good idea. It opens up the possibility of under-constrained computation and makes the computation less trustworthy, it is also harder to write because now I need to think hard on how to write the constraints. The benefit of this is that the program is more expressive.

Would love to know how this design choice affect the technology's effectiveness in large projects. Is it easy to avoid under-constrained computation in large project, what's the dev experience in writing two programs (execution + verification) at once for large projects, etc.

Answer 2

It seems like you are trying to understand the concept of signals and variables, and functions and templates in the context of circom, a language for programming circuits.

In circuit computation, the basic components are the signals. These are the equivalent of the wires in an electronic digital circuit. Signals can be seen as the interface of the template, connecting various components and making them interact or interrelate.

On the other hand, variables in circom are more like variables in standard programming languages. While variables also hold values like signals do, they are not part by themselves. Variables are used inside functions or computations but they are part of the circuit. This is why the documentation suggests they are.

When use variables and when to use signals? As an analogy, if you are creating a regular software program, you can consider signals as your public functions and variables as your private functions. Signals are the public interface for your circuit, they are what circuits will connect to. Variables, however, are used within your hence the term "internal states". Other circuits cannot see or connect to them directly.

When it comes to functions vs templates, think in terms of OOP (Object-Oriented Programming). A template can be seen as a class, defining a type of object with certain properties and methods(signals). A function, on the other hand, is like a method inside that class.

The reason for having both is to provide good code organization and re-usability. Functions are used when the operation should be abstracted away and can be used multiple times, while templates encapsulate circuit data and functionality together, can be used to create multiple instances of that circuit.

Remember, the primary goal of circom is not creating a software program but a mathematical proof circuit. This is why some aspects of the language might seem counter intuitive or restrictive compared to traditional programming languages.