Still quite rough and lots of bugs

Simplified in recent commit microsoft@b28aaf7

Also add docs to README

1. Add documentation and test for spartan/polynomial.rs.
- EqPolynomial: $\tilde{eq}$
- MultilinearPolynomial: multilinear polynomial
- SparsePolynomial

2. Remove duplicate get_bits in SparsePolynomial::evaluate.

Also add some comments

Makes some operations easier

…n point

This updates and makes compile the `n_rows`/`n_cols` fns of
SparseMatrix.
It also updates `is_valid` which is transfromed from a closure into an
associated fn for SparseMatrix.

This commit:
- Removes attribute duplicity from `CCSShape`.
- Fixes the reversed naming for col&row number.
- Removes leftover comments that no longer apply.
- Update the `CCSShape::new` to use `is_valid` on the new format as well
  as remove useless checks & update to new `CCSSape` format.

This removes the annoying results that were not needed from
ops implementations and replaces them by leaving the "necessary"
sanity-checks as assertions.

The impl gets cleaner and also easier to update later.

This prevents having issues as shown in the tests now failing for MLE
conversions. The issue is that empty rows/columns at the end of the
matrixes cause the algorithms to actually fail. As we have a sense of
the matrix dimensions only when we are in the context of CCS. But we
don't when we're outside of it.

This solves some minor errors & issues with the CCS methods as well as
updates the SparseMatrix calls to the new API/params used.

This helps to reduce the complexity of the implementation while at the
same time removing the possibility of handling a boolean hypercube with
coefficients which is not needed now at all.

We can always bring this back later.

Matrix prod outp len

- BooleanHypercube iterator was reversing the bit representation
- bound_poly_var_top is not fixing first variables but fixing last variables (=Espresso/hyperplonk's fix_last_variables method)
- fix method fix_one_variable_helper

Add also a couple of notes regarding sparse_vec_to_mle & bound_poly_var_top methods.

Note: the title of this commit is in reference to the commit message of 22b3f6f

…ence compute_q & compute_Q now work fine

This method was part of CCCS associated methods. But it doesn't make
sense as LCCCS also requires it aside from other standalone functions.

Hence, it is moved to a util module.

This adds a test for the `compute_all_sum_Mz_evals` fn and fixes it by
reversing the order of iteration over `r_x` so that it matches the
expectancies from Spartan/Polynomial lib impl.

Includes fns to compute thetas & sigmas, C from thetas and sigmans and
computation of `g` poly.

It also includes tests for g computation.

This fixes the endianness of `r_x_prime` which was the issue that
prevented the `test_compute_sigmas_and_thetas` to pass.

Was using wrong witness. Also change z order and make variables more more eplicit.

Should be the same according to current logic and multifolding-poc. Also change to to_cccs.

Fix variable order and make used variables more explicit to correspond to multifolding-poc

Replace with local allow unused, works with hypernova flag on and off

Hacky solution with feature flag for experimental hypernova for now, need to adjust test case to fix better

Opening WIP PR to make diff more clear

Targets #13

This merges the multifolding-poc porting into the Nova codebase

Addresses #32

Addresses microsoft#175 (comment)

As seen in previous CI runs:
- 4ae0cf7
- cde23f3
- ca55e73

The clippy job is causing the CI to fail due to missing fixes on the
code.
This gets up to speed the codebase with Clippy recommendations and
leaves the Uppercase warning disabled.

- Move bit_decompose into hypercube.rs which is closer conceptually and
  only used there (except for a VirtualPolynomial test)
- Remove unused bit_decompose imports from other files

)

Fixes additional clippy errors I see when I upgraded my Rust toolchain
(had some issues with clippy and Homebrew)

```
error: use of `default` to create a unit struct
   --> src/ccs/util/virtual_poly.rs:120:29
    |
120 |         phantom: PhantomData::default(),
    |                             ^^^^^^^^^^^ help: remove this call to `default`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#default_constructed_unit_structs
note: the lint level is defined here
```

Addresses #34

Should cover all files

This is a proposal for the new API of the Hypernova/multifolding current
impl.

The idea is that the API is
[NIMFS](https://github.com/privacy-scaling-explorations/Nova/blob/change%2FNIMFS_centric_API/src/ccs/multifolding.rs#L39-L44)-centric.
That means, the end user only needs to deal for now with `CCS`(this can
be prevented) and the `NIMFS` object.

The rest of interactions with `CCCS` & `LCCCS` have been "masked" or at
the very least, is not necessary to import these structs to have full
functionallity.

The current workflow that this API brings can be clearly seen here: 
```rust
let ccs = CCS::<G>::from_r1cs(r1cs_shape);
  let mles = ccs.matrix_mles();
  let mut nimfs = NIMFS::init(
    &mut rng,
    ccs,
    mles,
    // Note we constructed z on the fly with the previously-used witness.
    vec![
      G::Scalar::ONE,
      G::Scalar::from(3u64),
      G::Scalar::from(35u64),
    ],
  );

  // Now, the NIMFS should satisfy correctly as we have inputed valid starting inpuits for the first LCCCS contained instance:
  assert!(nimfs.is_sat().is_ok());

  // Now let's create a valid CCCS instance and fold it:
  let valid_cccs = nimfs.gen_cccs(vec![
    G::Scalar::ONE,
    G::Scalar::from(2u64),
    G::Scalar::from(15u64),
  ]);
  nimfs.fold(&mut rng, valid_cccs);

  // Since the instance was correct, the NIMFS should still be satisfied.
  assert!(nimfs.is_sat().is_ok());

  // Now let's create am invalid CCCS instance and fold it:
  let invalid_cccs = nimfs.gen_cccs(vec![
    G::Scalar::ONE,
    G::Scalar::from(5u64),
    G::Scalar::from(55u64),
  ]);
  nimfs.fold(&mut rng, invalid_cccs);

  // Since the instance was wrong, the NIMFS should not be satisfied correctly.
  assert!(nimfs.is_sat().is_err());
```

This is part of a test, located in
https://github.com/privacy-scaling-explorations/Nova/blob/change%2FNIMFS_centric_API/tests/nimfs.rs

The idea is that the user needs to type as less as possible in order to
get a fold done.

- Remove custom eq_poly and use EqPolynomial instead
- Update polynomial docs
- Ensures order of evaluation is consistent between for VirtualPoly and
EqPolynomial
- Remove old build_eq_x_r_vec and build_eq_x_r_helper
- Tests around boolean hypercube and other introduced functions to make
endianness explicit etc

Addresses #19

The PR introduces usage from the associated trait/type of `Group` called
`TranscriptEngineTrait` to perform the Fiat-Shamir inside the
multifolding for the Sigmas and Thetas computations as well as gammas.

This should be rebased on the top of `main` once #41 is merged and then
reviewed. As there could be places where FS should be applied but it
isn't.