# \`IVC\` struct

Check [#ivc](https://docs.snarkify.io/terminologies#ivc "mention") first

### Example

```rust
// Create IVC
// The zero step will be executed internally
let mut ivc = IVC::new(
    &public_params,
    &primary,
    primary_initial_z_in,
    &secondary,
    secondary_initial_z_in,
    false,
)
.expect("Error while create IVC");
                                                                                               
// Performs the folding steps
//
// Inside the synthesis circuit will be called multiple times and therefore the state will
// change outside `fold_step`
//
// Also there must be a continuity of steps within the step-circuit, it must take into account
// that the next step `z_in` will be `z_out` from the previous step
for _ in 1..5 {
    primary.update(input);
    secondary.update(input);
                                                                                               
    ivc.fold_step(&public_params, &primary, &secondary)
        .expect("Error while fold step");
}

// Verify that the folding was successful.                                                                                           
ivc.verify(&public_params).expect("Error while verify");
```

### Create IVC

#### Public Params 

Please check [publicparams-struct](https://docs.snarkify.io/sirius-folding/sirius-folding-apis/publicparams-struct "mention") 

#### Primary & Secondary Circuit

IVC uses two step-circuits. Each of them is wrapped inside into a regular \`StepFoldingCircuit' and in addition to the step-circuit synthesis logic, the folding of the paired circuit is verified (secondary verifies the folding of primary and vice versa).

Therefore, the second circuit can always be a `sirius::step_circuit::trivial::Circuit` and have no payload whatsoever.

#### \`z\_in\` & \`z\_out\`

Each step-circuit has an input and an output at each step. Only the first input is specified in `IVC::new`, the others are chained `z_out` of step `n` is transmitted as `z_in` on step `n+1`

#### Debug Mode

In order to get a detailed error, you can enable `debug_mode`, then at each `fold_step` the `MockProver` from the halo2 library will be enabled and check your circuit. Otherwise, any error will only occur at the `verify` step.

### Fold Step IVC

Each folding step synthesizes primary & secondary circuits and performs off-circuit calculations to fold the plonk structure & witness. The developer's task here, between steps, is to modify the circuits (over which he retains ownership), also keeping in mind the `z_in` & `z_out` continuity.

### Verify

This step verifies that the constraint system is correct. If you started IVC not in `debug_mode` mode, in this case, only at the moment of `verify` call it is possible to detect violations of the constraint system at any of the steps.