Remove comments with old code #65

Author: ETatuzova

include/nil/blueprint/transpiler/templates/recursive_verifier.hpp

@@ -794,131 +794,6 @@ typedef __attribute__((ext_vector_type(2)))
         __builtin_assigner_exit_check(interpolant == y[1]);
 	}
     return true;
-
-/*
-    std::array<std::array<pallas::base_field_type::value_type, 4>, unique_points> V;
-    std::array<std::array<pallas::base_field_type::value_type, 3>, poly_num> U;
-    std::array<std::array<pallas::base_field_type::value_type, 3>, unique_points> combined_U;
-    std::size_t z_ind = points_num - 1;
-    pallas::base_field_type::value_type theta_acc(1);
-    std::array<pallas::base_field_type::value_type, 3> tmp;
-
-    for(std::size_t u = 0; u < unique_points; u++){
-        combined_U[u][0] = pallas::base_field_type::value_type(0);
-        combined_U[u][1] = pallas::base_field_type::value_type(0);
-        combined_U[u][2] = pallas::base_field_type::value_type(0);
-    }
-
-    std::array<std::array<typename pallas::base_field_type::value_type, 3>, D0_log> res;
-    std::size_t round_proof_ind = 0;
-    std::size_t initial_proof_ind = 0;
-    std::size_t initial_proof_hash_ind = 0;
-    pallas::base_field_type::value_type interpolant;
-    std::size_t cur_val = 0;
-    std::size_t round_proof_hash_ind = 0;
-
-    for(std::size_t i = 0; i < lambda; i++){
-        __builtin_assigner_fri_cosets(res.data(), D0_log, D0_omega, challenges.fri_x_indices[i]);
-
-        pallas::base_field_type::value_type hash_state;
-        for(std::size_t b = 0; b < batches_num; b++){
-            pallas::base_field_type::value_type hash_state(0);
-            if(res[0][2] == pallas::base_field_type::value_type(0)){
-                hash_state = calculate_leaf_hash(proof.initial_proof_values, cur_val, batches_amount_list[b] *2);
-            } else if(res[0][2] == pallas::base_field_type::value_type(1)){
-                hash_state = calculate_reversed_leaf_hash(proof.initial_proof_values, cur_val, batches_amount_list[b] *2);
-            }
-            cur_val += batches_amount_list[b] *2;
-            for(std::size_t r = i * initial_merkle_proofs_position_num/lambda; r < (i + 1)* initial_merkle_proofs_position_num/lambda ; r++){
-                if(proof.initial_proof_positions[r] == 1){
-                    hash_state = __builtin_assigner_poseidon_pallas_base({0, hash_state, proof.initial_proof_hashes[initial_proof_hash_ind]})[2];
-                } else{
-                    hash_state = __builtin_assigner_poseidon_pallas_base({0, proof.initial_proof_hashes[initial_proof_hash_ind], hash_state})[2];
-                }
-                initial_proof_hash_ind ++;
-            }
-            if(b == 0)
-                __builtin_assigner_exit_check(hash_state == vk[1]);
-            else
-                __builtin_assigner_exit_check(hash_state == proof.commitments[b-1]);
-        }
-
-        std::array<pallas::base_field_type::value_type, 2> y;
-        y[0] = pallas::base_field_type::value_type(0);
-        y[1] = pallas::base_field_type::value_type(0);
-		std::array<std::array<pallas::base_field_type::value_type, 2>, unique_points> V_evals;
-        std::size_t ind = 0;
-		pallas::base_field_type::value_type theta_acc(1);
-
-		for(std::size_t u = 0; u < unique_points; u++){
-			V_evals[u][0] = pallas::base_field_type::value_type(1) / eval4(V[u], res[0][0]);
-			V_evals[u][1] = pallas::base_field_type::value_type(1) / eval4(V[u], res[0][1]);
-			y[0] = y[0] - eval3(combined_U[u], res[0][0]) * V_evals[u][0];
-			y[1] = y[1] - eval3(combined_U[u], res[0][1]) * V_evals[u][1];
-		}
-
-        initial_proof_ind = initial_proof_ind + poly_num * 2;
-        std::size_t in = initial_proof_ind - 1;
-		for(int k = poly_num; k > 0;){
-            k--;
-			y[0] = y[0] + theta_acc * proof.initial_proof_values[in-1] * V_evals[point_ids[k]][0];
-			y[1] = y[1] + theta_acc * proof.initial_proof_values[in] * V_evals[point_ids[k]][1];
-            in -= 2;
-			theta_acc = theta_acc * challenges.lpc_theta;
-		}
-
-        std::size_t D = D0_log - 1;
-        pallas::base_field_type::value_type rhash;
-        for(std::size_t j = 0; j < fri_rounds; j++){
-            if(res[j][2] == pallas::base_field_type::value_type(0)){
-                rhash = __builtin_assigner_poseidon_pallas_base({0, y[0], y[1]})[2];
-            } else {
-                rhash = __builtin_assigner_poseidon_pallas_base({0, y[1], y[0]})[2];
-            }
-            for( std::size_t d = 0; d < D; d++){
-                if(proof.round_merkle_proof_positions[round_proof_hash_ind] == 1){
-                    rhash = __builtin_assigner_poseidon_pallas_base({0, rhash, proof.round_proof_hashes[round_proof_hash_ind]})[2];
-                } else {
-                    rhash = __builtin_assigner_poseidon_pallas_base({0, proof.round_proof_hashes[round_proof_hash_ind], rhash})[2];
-                }
-                round_proof_hash_ind++;
-            }
-            __builtin_assigner_exit_check(rhash == proof.fri_roots[j]);
-            D--;
-
-            interpolant = __builtin_assigner_fri_lin_inter(
-                res[j][0],
-                y[0],
-                y[1],
-                challenges.fri_alphas[j]
-            );
-            __builtin_assigner_exit_check(interpolant == proof.round_proof_values[round_proof_ind]);
-            y[0] = proof.round_proof_values[round_proof_ind];
-            y[1] = proof.round_proof_values[round_proof_ind + 1];
-
-            pallas::base_field_type::value_type rhash;
-            round_proof_ind += 2;
-        }
-
-        interpolant = pallas::base_field_type::value_type(0);
-        pallas::base_field_type::value_type x = res[fri_rounds][0];
-        pallas::base_field_type::value_type factor = pallas::base_field_type::value_type(1);
-        for(std::size_t j = 0; j < final_polynomial_size; j++){
-            interpolant = interpolant + proof.final_polynomial[j] * factor;
-            factor = factor * x;
-        }
-        __builtin_assigner_exit_check(interpolant == y[0]);
-
-        interpolant = pallas::base_field_type::value_type(0);
-        x = res[fri_rounds][1];
-        factor = pallas::base_field_type::value_type(1);
-        for(std::size_t j = 0; j < final_polynomial_size; j++){
-            interpolant = interpolant + proof.final_polynomial[j] * factor;
-            factor = factor * x;
-        }
-        __builtin_assigner_exit_check(interpolant == y[1]);
-    }*/
-    return true;
 }
 
 }