2863

Committed 05 Nov 2024 06:20PM UTC coverage: 30.754% (-16.6%) from 47.311%

Build # 2863

Build Type

push

buildkite

Committed by

web-flow

Commit Message

Merge pull request #16296 from MinaProtocol/dkijania/more_multi_jobs

more multi jobs in CI

Run Details

20276 of 65930 relevant lines covered (30.75%)

8631.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

3.51

/src/lib/pickles/wrap_deferred_values.ml

module SC = Scalar_challenge
open Core_kernel
open Pickles_types
open Common
open Import
open Backend

(* TODO: Just stick this in plonk_checks.ml *)
module Plonk_checks = struct
  include Plonk_checks
  module Type1 =
    Plonk_checks.Make (Shifted_value.Type1) (Plonk_checks.Scalars.Tick)
end

let expand_deferred (type n most_recent_width) ~zk_rows
    ~(evals :
       ( Backend.Tick.Field.t
       , Backend.Tick.Field.t array )
       Pickles_types.Plonk_types.All_evals.t )
    ~(old_bulletproof_challenges :
       ( Challenge.Constant.t Scalar_challenge.Stable.Latest.t
         Bulletproof_challenge.t
         Step_bp_vec.t
       , most_recent_width )
       Pickles_types.Vector.t )
    ~(proof_state :
       ( Challenge.Constant.t
       , Challenge.Constant.t Scalar_challenge.t
       , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t
       , bool
       , n Pickles__.Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t
       , Digest.Constant.t
       , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t
         Step_bp_vec.t
       , Branch_data.t )
       Composition_types.Wrap.Proof_state.Minimal.Stable.V1.t ) :
    _ Types.Wrap.Proof_state.Deferred_values.t =
  let module Tick_field = Backend.Tick.Field in
  let tick_field : _ Plonk_checks.field = (module Tick_field) in
  Timer.start __LOC__ ;
  let open Types.Wrap.Proof_state in
  let sc = SC.to_field_constant tick_field ~endo:Endo.Wrap_inner_curve.scalar in
  Timer.clock __LOC__ ;
  let plonk0 = proof_state.deferred_values.plonk in
  let { Deferred_values.Minimal.branch_data; bulletproof_challenges; _ } =
    Deferred_values.Minimal.map_challenges ~f:Challenge.Constant.to_tick_field
      ~scalar:sc proof_state.deferred_values
  in
  let zeta = sc plonk0.zeta in
  let alpha = sc plonk0.alpha in
  let step_domain = Branch_data.domain branch_data in
  let w =
    Tick.Field.domain_generator ~log2_size:(Domain.log2_size step_domain)
  in
  let zetaw = Tick.Field.mul zeta w in
  let tick_plonk_minimal :
      _ Composition_types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t =
    let chal = Challenge.Constant.to_tick_field in
    { zeta
    ; alpha
    ; beta = chal plonk0.beta
    ; gamma = chal plonk0.gamma
    ; joint_combiner = Option.map ~f:sc plonk0.joint_combiner
    ; feature_flags = plonk0.feature_flags
    }
  in
  let tick_combined_evals =
    Plonk_checks.evals_of_split_evals
      (module Tick.Field)
      evals.evals.evals ~rounds:(Nat.to_int Tick.Rounds.n) ~zeta ~zetaw
    |> Plonk_types.Evals.to_in_circuit
  in
  let tick_domain =
    Plonk_checks.domain
      (module Tick.Field)
      step_domain ~shifts:Common.tick_shifts
      ~domain_generator:Backend.Tick.Field.domain_generator
  in
  let tick_env =
    let module Env_bool = struct
      type t = bool

      let true_ = true

      let false_ = false

      let ( &&& ) = ( && )

      let ( ||| ) = ( || )

      let any = List.exists ~f:Fn.id
    end in
    let module Env_field = struct
      include Tick.Field

      type bool = Env_bool.t

      let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()
    end in
    Plonk_checks.scalars_env
      (module Env_bool)
      (module Env_field)
      ~endo:Endo.Step_inner_curve.base ~mds:Tick_field_sponge.params.mds
      ~srs_length_log2:Common.Max_degree.step_log2 ~zk_rows
      ~field_of_hex:(fun s ->
        Kimchi_pasta.Pasta.Bigint256.of_hex_string s
        |> Kimchi_pasta.Pasta.Fp.of_bigint )
      ~domain:tick_domain tick_plonk_minimal tick_combined_evals
  in
  let plonk =
    let p =
      let module Field = struct
        include Tick.Field
      end in
      Plonk_checks.Type1.derive_plonk
        (module Field)
        ~shift:Shifts.tick1 ~env:tick_env tick_plonk_minimal tick_combined_evals
    in
    { p with
      zeta = plonk0.zeta
    ; alpha = plonk0.alpha
    ; beta = plonk0.beta
    ; gamma = plonk0.gamma
    ; joint_combiner = plonk0.joint_combiner
    }
  in
  Timer.clock __LOC__ ;
  let absorb, squeeze =
    let open Tick_field_sponge.Bits in
    let sponge =
      let s = create Tick_field_sponge.params in
      absorb s
        (Digest.Constant.to_tick_field
           proof_state.sponge_digest_before_evaluations ) ;
      s
    in
    let squeeze () =
      let underlying =
        Challenge.Constant.of_bits
          (squeeze sponge ~length:Challenge.Constant.length)
      in
      Scalar_challenge.create underlying
    in
    (absorb sponge, squeeze)
  in
  let old_bulletproof_challenges =
    Vector.map ~f:Ipa.Step.compute_challenges old_bulletproof_challenges
  in
  (let challenges_digest =
     let open Tick_field_sponge.Field in
     let sponge = create Tick_field_sponge.params in
     Vector.iter old_bulletproof_challenges ~f:(Vector.iter ~f:(absorb sponge)) ;
     squeeze sponge
   in
   absorb challenges_digest ;
   absorb evals.ft_eval1 ;
   let xs = Plonk_types.Evals.to_absorption_sequence evals.evals.evals in
   let x1, x2 = evals.evals.public_input in
   Array.iter ~f:absorb x1 ;
   Array.iter ~f:absorb x2 ;
   List.iter xs ~f:(fun (x1, x2) ->
       Array.iter ~f:absorb x1 ; Array.iter ~f:absorb x2 ) ) ;
  let xi_chal = squeeze () in
  let xi = sc xi_chal in
  let r_chal = squeeze () in
  let r = sc r_chal in
  Timer.clock __LOC__ ;
  (* TODO: The deferred values "bulletproof_challenges" should get routed
     into a "batch dlog Tick acc verifier" *)
  let actual_proofs_verified = Vector.length old_bulletproof_challenges in
  Timer.clock __LOC__ ;
  let combined_inner_product_actual =
    Wrap.combined_inner_product ~env:tick_env ~plonk:tick_plonk_minimal
      ~domain:tick_domain ~ft_eval1:evals.ft_eval1
      ~actual_proofs_verified:(Nat.Add.create actual_proofs_verified)
      evals.evals ~old_bulletproof_challenges ~r ~xi ~zeta ~zetaw
  in
  Timer.clock __LOC__ ;
  let bulletproof_challenges =
    Ipa.Step.compute_challenges bulletproof_challenges
  in
  Timer.clock __LOC__ ;
  let b_actual =
    let challenge_poly =
      unstage
        (Wrap.challenge_polynomial (Vector.to_array bulletproof_challenges))
    in
    Tick.Field.(challenge_poly zeta + (r * challenge_poly zetaw))
  in
  let to_shifted =
    Shifted_value.Type1.of_field (module Tick.Field) ~shift:Shifts.tick1
  in
  { xi = xi_chal
  ; plonk
  ; combined_inner_product = to_shifted combined_inner_product_actual
  ; branch_data
  ; bulletproof_challenges
  ; b = to_shifted b_actual
  }

1	module SC = Scalar_challenge	10✔
2	open Core_kernel
3	open Pickles_types
4	open Common
5	open Import
6	open Backend
7
8	(* TODO: Just stick this in plonk_checks.ml *)
9	module Plonk_checks = struct
10	include Plonk_checks
11	module Type1 =
12	Plonk_checks.Make (Shifted_value.Type1) (Plonk_checks.Scalars.Tick)
13	end
14
15	let expand_deferred (type n most_recent_width) ~zk_rows
16	~(evals :
17	( Backend.Tick.Field.t
18	, Backend.Tick.Field.t array )
19	Pickles_types.Plonk_types.All_evals.t )
20	~(old_bulletproof_challenges :
21	( Challenge.Constant.t Scalar_challenge.Stable.Latest.t
22	Bulletproof_challenge.t
23	Step_bp_vec.t
24	, most_recent_width )
25	Pickles_types.Vector.t )
26	~(proof_state :
27	( Challenge.Constant.t
28	, Challenge.Constant.t Scalar_challenge.t
29	, Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t
30	, bool
31	, n Pickles__.Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t
32	, Digest.Constant.t
33	, Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t
34	Step_bp_vec.t
35	, Branch_data.t )
36	Composition_types.Wrap.Proof_state.Minimal.Stable.V1.t ) :
37	_ Types.Wrap.Proof_state.Deferred_values.t =
38	let module Tick_field = Backend.Tick.Field in	×
39	let tick_field : _ Plonk_checks.field = (module Tick_field) in
40	Timer.start __LOC__ ;
41	let open Types.Wrap.Proof_state in	×
42	let sc = SC.to_field_constant tick_field ~endo:Endo.Wrap_inner_curve.scalar in
43	Timer.clock __LOC__ ;	×
44	let plonk0 = proof_state.deferred_values.plonk in	×
45	let { Deferred_values.Minimal.branch_data; bulletproof_challenges; _ } =
46	Deferred_values.Minimal.map_challenges ~f:Challenge.Constant.to_tick_field
47	~scalar:sc proof_state.deferred_values
48	in
49	let zeta = sc plonk0.zeta in	×
50	let alpha = sc plonk0.alpha in	×
51	let step_domain = Branch_data.domain branch_data in	×
52	let w =	×
53	Tick.Field.domain_generator ~log2_size:(Domain.log2_size step_domain)	×
54	in
55	let zetaw = Tick.Field.mul zeta w in
56	let tick_plonk_minimal :	×
57	_ Composition_types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t =
58	let chal = Challenge.Constant.to_tick_field in
59	{ zeta
60	; alpha
61	; beta = chal plonk0.beta	×
62	; gamma = chal plonk0.gamma	×
63	; joint_combiner = Option.map ~f:sc plonk0.joint_combiner	×
64	; feature_flags = plonk0.feature_flags
65	}
66	in
67	let tick_combined_evals =
68	Plonk_checks.evals_of_split_evals	×
69	(module Tick.Field)
70	evals.evals.evals ~rounds:(Nat.to_int Tick.Rounds.n) ~zeta ~zetaw	×
71	\|> Plonk_types.Evals.to_in_circuit
72	in
73	let tick_domain =	×
74	Plonk_checks.domain
75	(module Tick.Field)
76	step_domain ~shifts:Common.tick_shifts
77	~domain_generator:Backend.Tick.Field.domain_generator
78	in
79	let tick_env =	×
80	let module Env_bool = struct
81	type t = bool
82
83	let true_ = true
84
85	let false_ = false
86
87	let ( &&& ) = ( && )
88
89	let ( \|\|\| ) = ( \|\| )
90
91	let any = List.exists ~f:Fn.id
92	end in
93	let module Env_field = struct
94	include Tick.Field
95
96	type bool = Env_bool.t
97
98	let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()	×
99	end in
100	Plonk_checks.scalars_env	×
101	(module Env_bool)
102	(module Env_field)
103	~endo:Endo.Step_inner_curve.base ~mds:Tick_field_sponge.params.mds
104	~srs_length_log2:Common.Max_degree.step_log2 ~zk_rows
105	~field_of_hex:(fun s ->
106	Kimchi_pasta.Pasta.Bigint256.of_hex_string s	×
107	\|> Kimchi_pasta.Pasta.Fp.of_bigint )
108	~domain:tick_domain tick_plonk_minimal tick_combined_evals
109	in
110	let plonk =
111	let p =
112	let module Field = struct
113	include Tick.Field
114	end in
115	Plonk_checks.Type1.derive_plonk	×
116	(module Field)
117	~shift:Shifts.tick1 ~env:tick_env tick_plonk_minimal tick_combined_evals
118	in
119	{ p with
120	zeta = plonk0.zeta
121	; alpha = plonk0.alpha
122	; beta = plonk0.beta
123	; gamma = plonk0.gamma
124	; joint_combiner = plonk0.joint_combiner
125	}
126	in
127	Timer.clock __LOC__ ;
128	let absorb, squeeze =	×
129	let open Tick_field_sponge.Bits in
130	let sponge =
131	let s = create Tick_field_sponge.params in
132	absorb s	×
133	(Digest.Constant.to_tick_field	×
134	proof_state.sponge_digest_before_evaluations ) ;
135	s	×
136	in
137	let squeeze () =
138	let underlying =	×
139	Challenge.Constant.of_bits
140	(squeeze sponge ~length:Challenge.Constant.length)	×
141	in
142	Scalar_challenge.create underlying	×
143	in
144	(absorb sponge, squeeze)	×
145	in
146	let old_bulletproof_challenges =
147	Vector.map ~f:Ipa.Step.compute_challenges old_bulletproof_challenges
148	in
149	(let challenges_digest =	×
150	let open Tick_field_sponge.Field in
151	let sponge = create Tick_field_sponge.params in
152	Vector.iter old_bulletproof_challenges ~f:(Vector.iter ~f:(absorb sponge)) ;	×
153	squeeze sponge	×
154	in
155	absorb challenges_digest ;
156	absorb evals.ft_eval1 ;	×
157	let xs = Plonk_types.Evals.to_absorption_sequence evals.evals.evals in	×
158	let x1, x2 = evals.evals.public_input in	×
159	Array.iter ~f:absorb x1 ;
160	Array.iter ~f:absorb x2 ;	×
161	List.iter xs ~f:(fun (x1, x2) ->	×
162	Array.iter ~f:absorb x1 ; Array.iter ~f:absorb x2 ) ) ;	×
163	let xi_chal = squeeze () in
164	let xi = sc xi_chal in	×
165	let r_chal = squeeze () in	×
166	let r = sc r_chal in	×
167	Timer.clock __LOC__ ;	×
168	(* TODO: The deferred values "bulletproof_challenges" should get routed
169	into a "batch dlog Tick acc verifier" *)
170	let actual_proofs_verified = Vector.length old_bulletproof_challenges in	×
171	Timer.clock __LOC__ ;	×
172	let combined_inner_product_actual =	×
173	Wrap.combined_inner_product ~env:tick_env ~plonk:tick_plonk_minimal
174	~domain:tick_domain ~ft_eval1:evals.ft_eval1
175	~actual_proofs_verified:(Nat.Add.create actual_proofs_verified)	×
176	evals.evals ~old_bulletproof_challenges ~r ~xi ~zeta ~zetaw
177	in
178	Timer.clock __LOC__ ;	×
179	let bulletproof_challenges =	×
180	Ipa.Step.compute_challenges bulletproof_challenges
181	in
182	Timer.clock __LOC__ ;	×
183	let b_actual =	×
184	let challenge_poly =
185	unstage
186	(Wrap.challenge_polynomial (Vector.to_array bulletproof_challenges))	×
187	in
188	Tick.Field.(challenge_poly zeta + (r * challenge_poly zetaw))	×
189	in
190	let to_shifted =
191	Shifted_value.Type1.of_field (module Tick.Field) ~shift:Shifts.tick1
192	in
193	{ xi = xi_chal	×
194	; plonk
195	; combined_inner_product = to_shifted combined_inner_product_actual	×
196	; branch_data
197	; bulletproof_challenges
198	; b = to_shifted b_actual	×
199	}	20✔

MinaProtocol / mina / 2863

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous