Correction of formula to restore q-modular hints

Sec5.2_validation/prediction_verifications.sage

         if T_hints == "Q-Modular":
             dbdd.integrate_q_modular_hint(vv, dbdd.leak(vv) % q,
                                         q, estimate=False)
-            dbdd_p.integrate_q_modular_hint(vv, dbdd_p.leak(vv) % modulus,
+            dbdd_p.integrate_q_modular_hint(vv, dbdd_p.leak(vv) % q,
                                           q, estimate=False)
 
     dbdd_p.integrate_q_vectors(q, indices=range(20))
 
 dic = {" ": None}
 
+def get_stats(data, N_tests):
+    avg = RR(sum(data)) / N_tests
+    var = abs(RR(sum([r**2 for r in data])) / N_tests - avg**2)
+    return (avg, var)
 
 def validation_prediction(N_tests, N_hints, T_hints):
     # Estimation
     import datetime
     ttt = datetime.datetime.now()
     res = map_drop(N_tests, threads, one_experiment, (N_hints, T_hints))
-    beta_real = RR(sum([r[0] for r in res])) / N_tests
-    beta_pred_full = RR(sum([r[1] for r in res])) / N_tests
-    beta_pred_light = RR(sum([r[2] for r in res])) / N_tests
+    beta_real, vbeta_real = get_stats([r[0] for r in res], N_tests)
+    beta_pred_full, vbeta_pred_full = get_stats([r[1] for r in res], N_tests)
+    beta_pred_light, vbeta_pred_light = get_stats([r[2] for r in res], N_tests)
 
     print("%d,\t %.3f,\t %.3f,\t %.3f \t\t" %
           (N_hints, beta_real, beta_pred_full, beta_pred_light), end=" \t")
     print("Time:", datetime.datetime.now() - ttt)
     
     if saving_results:
-        vbeta_real = RR(sum([r[0]**2 for r in res])) / N_tests - beta_real
-        beta_pred_full = RR(sum([r[0]**2 for r in res])) / N_tests - beta_pred_full
-        beta_pred_light = RR(sum([r[0]**2 for r in res])) / N_tests - beta_pred_light
-    
-        with open('results.csv') as _file:
+        with open('results.csv', 'a') as _file:
             _file.write(f'{T_hints};{N_hints};{N_tests};{datetime.datetime.now() - ttt};')
             _file.write(f'{beta_real};{beta_pred_full};{beta_pred_light};')
             _file.write(f'{vbeta_real};{vbeta_pred_full};{vbeta_pred_light};')
     beta_pred = validation_prediction(N_tests, h, "Modular")  # Line 0
     if beta_pred < 3:
         break
-
-print("\n \n Approx")
-
-print("hints,\t real,\t pred_full, \t pred_light,")
-for h in range(4, 200, 4):
-    beta_pred = validation_prediction(N_tests, h, "Approx")  # Line 0
-    if beta_pred < 3:
-        break
         
 print("\n \n Q-Modular")
 
     beta_pred = validation_prediction(N_tests, h, "Q-Modular")  # Line 0
     if beta_pred < 3:
         break
+
+print("\n \n Approx")
+
+print("hints,\t real,\t pred_full, \t pred_light,")
+for h in range(4, 200, 4):
+    beta_pred = validation_prediction(N_tests, h, "Approx")  # Line 0
+    if beta_pred < 3:
+        break

framework/DBDD.sage

     def integrate_short_vector_hint(self, v):
         V = concatenate(v, 0)
 
-        if V.dimensions()[1] > self._dim:
+        if V.dimensions()[1] > self.Pi.nrows(): # Cannot use self._dim here
             V = V * self.Pi.T # Reduction
-        assert V.dimensions()[1] == self._dim
+        assert V.dimensions()[1] == self.Pi.nrows()
         V -= V * self.PP
 
         if scal((V * self.S) * V.T) == 0:
                 if instruc_type == SUBSTITUTION:
                     pass
                 elif instruc_type == QMODULUS_SUBSTITUTION:
-                    solution += data['w'] * round(solution[0].inner_product(data['v'][0])/data['q'])
+                    w, v, q = data['w'], data['v'], data['q']
+                    w_norm2 = w[0].inner_product(w[0])
+                    projection_of_s = solution - w * (solution[0].inner_product(w[0]) / w_norm2)
+                    solution += w * round(projection_of_s[0].inner_product(v[0])/q)
                 else:
-                    solution += data['w'] * data['func'](solution)
+                    w, func = data['w'], data['func']
+                    w_norm2 = w[0].inner_product(w[0])
+                    projection_of_s = solution - w * (solution[0].inner_product(w[0]) / w_norm2)
+                    solution += w * func(projection_of_s)
             
             if not self.check_solution(solution):
                 continue

framework/DBDD_generic.sage

                 self.logging("[...%d]" % report_every, newline=False)
             Sd = self.S_diag()
             L = [(Sd[i], i) for i in indices if i not in I]
+            if len(L) == 0:
+                break
             _, i = max(L)
             I += [i]
             try: