/*
* Load an entire array of scalars. Useful when there are multiple functions in
* the prover.
*
* Vectors will be stored with the following name:
* f<num_func>_<suffix>
* num_func is an integer in [0, n).
*/
void load_scalar_array(int n, mpz_t *scalars, const char *suffix, char *folder_name) {
char vec_name[BUFLEN];
for (int i = 0; i < n; i++) {
snprintf(vec_name, sizeof(vec_name), "f%d_%s", i, suffix);
load_scalar(scalars[i], vec_name, folder_name);
}
}
bool MatrixCubicVerifier::run_correction_and_circuit_tests(uint32_t beta) {
bool result = true;
bool lin;
for (int rho=0; rho<num_repetitions; rho++) {
for (int i=0; i<NUM_REPS_LIN; i++) {
int base = i*NUM_LIN_QUERIES;
lin = v->lin_test(f_answers[rho*num_lin_pcp_queries + base + Q1],
f_answers[rho*num_lin_pcp_queries + base + Q2],
f_answers[rho*num_lin_pcp_queries + base + Q3],
prime);
#if VERBOSE == 1
if (false == lin)
cout<<"LOG: F failed the linearity test"<<endl;
else
cout<<"LOG: F passed the linearity test"<<endl;
#endif
result = result & lin;
}
// Quad Correction test and Circuit test
mpz_set_ui(temp, 1);
mpz_t ans;
mpz_init_set_ui(ans, 0);
snprintf(scratch_str, BUFLEN-1, "corr_answer_b_%d_r_%d", beta, rho);
load_scalar(ans, scratch_str);
bool cor1 = v->corr_test(ans /*f2_answers[rho*NUM_LIN_PCP_QUERIES + Q1]*/, temp,
f_answers[rho*num_lin_pcp_queries + Q6],
f_answers[rho*num_lin_pcp_queries + Q1], prime);
#if VERBOSE == 1
if (false == cor1)
cout<<"LOG: F1, F2 failed the correction test"<<endl;
else
cout<<"LOG: F1, F2 passed correction test"<<endl;
#endif
result &= cor1;
mpz_set(ckt_answers[0], f_answers[rho*num_lin_pcp_queries + Q7]);
mpz_set(ckt_answers[1], f_answers[rho*num_lin_pcp_queries + Q1]);
bool ckt2 = v->ckt_test(2, ckt_answers,
c_values[beta * num_repetitions + rho], prime);
#if VERBOSE == 1
if (false == ckt2)
cout <<"LOG: F1 failed the circuit test"<<endl;
else
cout <<"LOG: F1 passed the circuit test"<<endl;
#endif
result &= ckt2;
}
return result;
}
/*
* This is the main function for dumping any node.
*/
SV *
load_node(perl_yaml_loader_t *loader)
{
/* Get the next parser event */
if (!yaml_parser_parse(&loader->parser, &loader->event))
goto load_error;
/* Return NULL when we hit the end of a scope */
if (loader->event.type == YAML_DOCUMENT_END_EVENT ||
loader->event.type == YAML_MAPPING_END_EVENT ||
loader->event.type == YAML_SEQUENCE_END_EVENT) return NULL;
/* Handle loading a mapping */
if (loader->event.type == YAML_MAPPING_START_EVENT) {
SV *hash_ref;
char *tag = (char *)loader->event.data.mapping_start.tag;
/* Handle mapping tagged as a Perl hard reference */
if (tag && strEQ(tag, TAG_PERL_REF))
return load_scalar_ref(loader);
/* Handle mapping tagged as a Perl typeglob */
if (tag && strEQ(tag, TAG_PERL_GLOB))
return load_glob(loader);
/* Load the mapping into a hash ref and return it */
return load_mapping(loader, NULL);
}
/* Handle loading a sequence into an array */
if (loader->event.type == YAML_SEQUENCE_START_EVENT)
return load_sequence(loader);
/* Handle loading a scalar */
if (loader->event.type == YAML_SCALAR_EVENT)
return load_scalar(loader);
/* Handle loading an alias node */
if (loader->event.type == YAML_ALIAS_EVENT)
return load_alias(loader);
/* Some kind of error occurred */
if (loader->event.type == YAML_NO_EVENT)
croak(loader_error_msg(loader, NULL));
croak(ERRMSG "Invalid event '%d' at top level", (int) loader->event.type);
load_error:
croak(loader_error_msg(loader, NULL));
}
/*
* This is the main function for dumping any node.
*/
SV *
load_node(perl_yaml_loader_t *loader)
{
SV* return_sv = NULL;
/* This uses stack, but avoids (severe!) memory leaks */
yaml_event_t uplevel_event;
uplevel_event = loader->event;
/* Get the next parser event */
if (!yaml_parser_parse(&loader->parser, &loader->event))
goto load_error;
/* These events don't need yaml_event_delete */
/* Some kind of error occurred */
if (loader->event.type == YAML_NO_EVENT)
goto load_error;
/* Return NULL when we hit the end of a scope */
if (loader->event.type == YAML_DOCUMENT_END_EVENT ||
loader->event.type == YAML_MAPPING_END_EVENT ||
loader->event.type == YAML_SEQUENCE_END_EVENT) {
/* restore the uplevel event, so it can be properly deleted */
loader->event = uplevel_event;
return return_sv;
}
/* The rest all need cleanup */
switch (loader->event.type) {
char *tag;
/* Handle loading a mapping */
case YAML_MAPPING_START_EVENT:
tag = (char *)loader->event.data.mapping_start.tag;
/* Handle mapping tagged as a Perl hard reference */
if (tag && strEQ(tag, TAG_PERL_REF)) {
return_sv = load_scalar_ref(loader);
break;
}
/* Handle mapping tagged as a Perl typeglob */
if (tag && strEQ(tag, TAG_PERL_GLOB)) {
return_sv = load_glob(loader);
break;
}
return_sv = load_mapping(loader, NULL);
break;
/* Handle loading a sequence into an array */
case YAML_SEQUENCE_START_EVENT:
return_sv = load_sequence(loader);
break;
/* Handle loading a scalar */
case YAML_SCALAR_EVENT:
return_sv = load_scalar(loader);
break;
/* Handle loading an alias node */
case YAML_ALIAS_EVENT:
return_sv = load_alias(loader);
break;
default:
croak("%sInvalid event '%d' at top level", ERRMSG, (int) loader->event.type);
}
yaml_event_delete(&loader->event);
/* restore the uplevel event, so it can be properly deleted */
loader->event = uplevel_event;
return return_sv;
load_error:
croak("%s", loader_error_msg(loader, NULL));
}
void Verifier::prepare_answers(int beta) {
#if NONINTERACTIVE == 1
prepare_noninteractive_answers(beta);
#else
#if VERBOSE == 1
cout << endl << "LOG: Batch " << beta << endl;
#endif
FILE *fp = NULL;
if (optimize_answers) {
char f_name[BUFLEN];
snprintf(f_name, BUFLEN - 1, "answers_%d", beta + 1);
snprintf(f_name, BUFLEN - 1, "%s/answers_%d",
FOLDER_STATE, beta + 1);
fp = fopen(f_name, "rb");
if (fp == NULL) {
printf("Failed to open %s file for reading.", f_name);
exit(1);
}
}
// only one commitment answer and one consistency answer
string commitment_answer_str = "f_commitment_answer_b_%d";
snprintf(scratch_str, BUFLEN - 1, commitment_answer_str.c_str(), beta);
load_vector(expansion_factor, temp_arr_ptrs[0], scratch_str);
if (!optimize_answers) {
string consistency_answer_str = "f_consistency_answer_b_%d";
snprintf(scratch_str, BUFLEN - 1, consistency_answer_str.c_str(), beta);
load_scalar(a, scratch_str);
} else {
size_t bytes = mpz_inp_raw(a, fp);
fseek(fp, bytes, SEEK_CUR);
}
for (uint32_t j=0; j<num_repetitions*num_lin_pcp_queries; j++)
mpz_set_ui(f_answers[j], 0);
std::list<string> files = get_files_in_dir((char *)FOLDER_STATE);
for (int rho = 0; rho < num_repetitions; rho++) {
if (!optimize_answers) {
char *file_exp = (char *)"_qquery_answer_b_%d_r_%d";
snprintf(scratch_str, BUFLEN-1, file_exp, beta, rho);
std::list<string>::const_iterator it = files.begin();
for (; it != files.end(); it++) {
string file_name = *it;
size_t b_index = file_name.find(scratch_str);
if (b_index != string::npos) {
int q_num = atoi(file_name.substr(file_name.find("q") + 1, b_index).c_str());
load_scalar(f_answers[rho * num_lin_pcp_queries + Q_list[q_num - 1]],
(char*)file_name.c_str());
}
}
} else {
for (uint32_t q = 0; q < Q_list.size(); q++) {
size_t bytes =
mpz_inp_raw(f_answers[rho * num_lin_pcp_queries + Q_list[q]], fp);
fseek(fp, bytes, SEEK_CUR);
}
}
//populate_answers(f_answers, rho, num_repetitions, beta);
}
snprintf(scratch_str, BUFLEN-1, "input_b_%d", beta);
load_vector(size_input, input, scratch_str);
snprintf(scratch_str, BUFLEN-1, "output_b_%d", beta);
load_vector(size_output, output, scratch_str);
if (output_q != NULL) {
snprintf(scratch_str, BUFLEN-1, "output_q_b_%d", beta);
load_vector(size_output, output_q, scratch_str);
if (verify_conversion_to_z(size_output, output, output_q, prime) == false) {
cout<<"LOG: Prover presented two different versions of output"<<endl;
exit(1);
}
}
if (fp != NULL)
fclose(fp);
#endif
}
