Week 15 - 2024 Write up proof construction and submission doco for Web3 gaming. Based on trustless-browser-sandbox. Write up doco for React app interface to zkWasm-sercie-helper. Discuss the api, and availablity on the explorer, credit etc. Proof tasks and wasm.cloud prover After gameplay has finished the player can submit a proof task to via Delphinus Labs zkWasm prover and a smart contract can be verified on chain. The "Create Proof" invocation is usualy triggered by a button on the Main App or could be triggered by a callback from the game state controller - this is left up to the View (Main app) / gamplay UI designer. Either way a triggered create proof loads a modal card with information about the movements played in the game etc (see below). Selection_041

Week 11 Weekly task: write sketch for documentation for Web3 gaming development with Wasm & zkWasm proving service. Understand componets for build a web3 game application backed by Delphinus Infra. zk Provable WASM-Based browser Application Sketch build documentation from components:

Week 3 Working on understand the opencl fft code and optimizing do_fft_core let deg = cmp::min(max_deg, log_n - log_p); let n = 1u32 << log_n; let local_work_size = 1 << cmp::min(deg - 1, max_log2_local_work_size); let global_work_size = n >> deg; let kernel_name = format!("{}_radix_fft", "Bn256_Fr"); let kernel = program.create_kernel(

Week 2 Working on understand he patch for halo2_proofs doing some bench & understnadign whats going on with the cache mechanics For a ProveExpressionUnit (in evaluation.rs) patch goes, From: let es = es.into_iter().map(|e| {

Week 1 work topics for Jan: deal with montgomery to normal representation from cuda gpu code. get radix-2 cuda working finish, bench against current cl impl. write extended split radix-2/8 algorithm in cuda, bench against above and current cl. understand diff to evaluation_gpu from better-polyeval understand and document fft.cl and Xin testing Montgomery investigation from gpu fft:

Week 51 - December/EoY wrap up summary. Thoughout Q4 of 2023 I have been stuudying polynomial evaluation and fft within the scope of halo2 and the codebase of the halo2-gpu-specific With the objective of improving the time (reducing) of the polynomial evaluation in proof generation. small review: -------------------------------- prover.rs --> pub fn create_proof() | | -------------------------------- evaluation.rs

Week 50, notes. Still working on understand the fft algorithm against two test fields. One of prime order $p = 18446744069414584321$ and agaisnt BN256. In order to understand how fft is calculated in the field, we have to understand how the twiddles are calculated. Working on understanding the calcualtion of the primitive roots of unity. /// Returns a primitive root of unity of order $2^{order}$. fn get_primitive_root_of_unity<F: IsFFTField>( order: u64,

Week 49 Debugging cuda/fft field code: Using BN256 Scalar field for fft calculations, (changes from lastweek). Still trying to get the cuda code to return values that are consistent with teh cpu code. Unfortunately this week has mostly been spent debugging and going through the code. #[derive(Clone, Debug, Hash, Copy)] pub struct MontgomeryConfigBN256PrimeField; impl IsModulus<U256> for MontgomeryConfigBN256PrimeField { const MODULUS: U256 = // U256::from_hex_unchecked("30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47"); // Base

Week 48 notes/report still working on optimization and benching of the poly eval and fft kernel. FFT Development Radix-2 Decimate-In-Time $$ \begin{aligned} X(k) = \sum_{n=0}^{N-1} x(n)W_{N}^{kn} ;;;;; k =0,1,2,\dots,N-1 ;;;;;; W_N = e^{-j2\pi / N} \end{aligned}

Week 47 Notes/Report Still on poly eval in gpu. working on benching (continued work next week), working on the split-radix fft algo and any adjustments to it. basic bench on a simple circuit produces the number of 30% of time spent in fft main --> which is the format!("{}_radix_fft", "Bn256_Fr" kernel. General notes and basic bench below. This is heavily being changed and worked on in the next week. fft in evaluation_gpu.rs in --> pub(crate) fn do_extended_fft<F: FieldExt, C: CurveAffine<ScalarExt = F>>(...) |

Rings, Fields notes Rings a ring over the set $\mathbb{R}$ is given as $(\mathbb{R}, +, \cdot)$, which has two binary operations, denoted by $+$ and $\cdot$ such that: $\mathbb{R}$ is an abelian group (commutative group) with respect to +. $\cdot$ is associative. i.e., $(a\cdot b)\cdot c = a\cdot (b\cdot c)$ for all $a,b,c \in \mathbb{R}$. The distributive laws hold. i.e., for all $a,b,c \in \mathbb{R}$ we have $a\cdot (b+ c) = (a\cdot b + b\cdot c$ and $(b+ c)\cdot a = b\cdot a + c\cdot a$. We use $0$ (the zero element) to denote the identity element of the abelian group $\mathbb{R}$ with respect to addition. The additive inverse of $a$ is denoted by $-a$, also $a+(-b)$ is abbreviated by $a-b$.

Notes/Report 46 Revision of fields, field ext, pairing, https://hackmd.io/l6_TauMHSvS1eqym3CiU-g Still understanding gpu poly eval. Multiexp revising algorithmms for multiexp, i.e., evaluating

Working on understanding the fft evaluation gpu code, kernels and any math behind it. General poly eval notes: There are two was to represent polynomials: Coefficient representation: $\sum_k c_k*x^k$ Easy to do addition & subtraction, however it is difficult to do multiplication & division Evaluation representation:

EvaluationDomain Notes notes

Notes/Report week 44 Woking on understanding kernel, fft, ifft. Poly commitments, NTT, MSM, Montgomery. code pull apart understand multiexp.rs from ec-gpu (The Filecoin version) so far, before moving on to bones multiexp_bound_and_ifft() etc --------------------------------------- test.rs --> let gpu = multiexp_gpu(&pool, (g.clone(), 0), FullDensity, v.clone(), &mut kern).unwrap();

Notes for Oscar: we will start from here. Requirements of proof system: $V$ --> verifier. $P$ --> prover. $C$ --> the circuit. Completeness: If i run a computation, I can compute a proof that the output is correct.

Notes on SNARK's/Plonk and Halo2 Requirements of proof system: $V$ --> verifier. $P$ --> prover. $C$ --> the circuit. Completeness: If i run a computation, I can compute a proof that the output is correct. $\forall, x, w; C(x,w) = 0$ that is:

Week 43 Notes/Report Working on gpu evaluation this week which included but wasnt limited to understanding the evaluation_gpu code in addition to the prover and reading up on acceleration techniques for Plonk using GPU. Looking more into the ec_gpu repo. Working on understanding the running stucture of the kernel w.r.t evaluation_gpu and ec_gpu. evaluate_h looking into the Evaluation x.gpu_eval() retouching some stuff from week41

Working on zkWasm's halo2 gpu specific impl. with --features = gpu Working on understanding: ProveExpression::Op(l, r, op) ProveExpression::Y(ys) ProveExpression::Unit(u) ProveExpression::Scale(l, ys) and the GPU evaluation mechics.

Working on understanding the impl for ProveExpression in evaluation_gpu.rs particularly _eval_gpu() within it. Working on understanding Evaluator and particularly evaluate_h() within it, in evaluation.rs. This is stillvery much a WIP to fully understand and document the evaluation using GPU kernel, modify and improve the running time for poly_h. Evaluator Inside evaluation.rs: L275 impl<C: CurveAffine> Evaluator<C> { new(); add_rotation();