old.txt

func InnerArithmeticCircuitProtocol(public *ACPublic, private *AcPrivate, r, n, l [][]*big.Int, C []*bn256.G1) {
	rl := r[0] // 8
	rr := r[1] // 8
	ro := r[2] // 8

	ll := l[0] // Nv
	lr := l[1] // Nv
	lo := l[2] // Nv

	nl := n[0] // Nm
	nr := n[1] // Nm
	no := n[2] // Nm

	Cl := C[0]
	Cr := C[1]
	Co := C[2]

	// Send Cl, Cr, Co to verifier

	// Verifier generates challenges and sends to prover
	ch_ro := values(1)[0]
	ch_lambda := values(1)[0]
	ch_beta := values(1)[0]
	ch_delta := values(1)[0]

	// Prover and Verifier computes

	var MlnL [][]*big.Int // Nl * Nm
	for i := 0; i < public.Nl; i++ {
		MlnL = append(MlnL, public.Wl[i][:public.Nm])
	}

	var MmnL [][]*big.Int // Nm * Nm
	for i := 0; i < public.Nm; i++ {
		MmnL = append(MmnL, public.Wm[i][:public.Nm])
	}

	var MlnR [][]*big.Int // Nl*Nm
	for i := 0; i < public.Nl; i++ {
		MlnR = append(MlnR, public.Wl[i][public.Nm:public.Nm*2])
	}

	var MmnR [][]*big.Int // Nm*Nm
	for i := 0; i < public.Nm; i++ {
		MmnR = append(MmnR, public.Wm[i][public.Nm:public.Nm*2])
	}

	var WlO [][]*big.Int // Nl*No
	for i := 0; i < public.Nl; i++ {
		WlO = append(WlO, public.Wl[i][public.Nm*2:])
	}

	var WmO [][]*big.Int // Nm*No
	for i := 0; i < public.Nm; i++ {
		WmO = append(WmO, public.Wm[i][public.Nm*2:])
	}

	//ManO, a = {l,m}

	var MlnO [][]*big.Int // Nl*Nm
	for i := 0; i < public.Nl; i++ {
		MlnO = append(MlnO, make([]*big.Int, public.Nm))

		for j := 0; j < public.Nm; j++ {
			MlnO[i][j] = big.NewInt(0)

			if j_ := private.f(4, j); j_ != nil {
				MlnO[i][j].Set(WlO[i][*j_])
			}
		}
	}

	var MmnO [][]*big.Int // Nm*Nm
	for i := 0; i < public.Nm; i++ {
		MmnO = append(MmnO, make([]*big.Int, public.Nm))

		for j := 0; j < public.Nm; j++ {
			MmnO[i][j] = big.NewInt(0)

			if j_ := private.f(4, j); j_ != nil {
				MmnO[i][j].Set(WmO[i][*j_])
			}
		}
	}

	// MalX, a = {l,m}, X = {L,R,O}

	// L
	var MllL [][]*big.Int // Nl*Nv
	for i := 0; i < public.Nl; i++ {
		MllL = append(MllL, make([]*big.Int, public.Nv))

		for j := 0; j < public.Nv; j++ {
			MllL[i][j] = big.NewInt(0)

			if j_ := private.f(2, j); j_ != nil {
				MllL[i][j].Set(WlO[i][*j_])
			}
		}
	}

	var MmlL [][]*big.Int // Nm*Nv
	for i := 0; i < public.Nm; i++ {
		MmlL = append(MmlL, make([]*big.Int, public.Nv))

		for j := 0; j < public.Nv; j++ {
			MmlL[i][j] = big.NewInt(0)

			if j_ := private.f(2, j); j_ != nil {
				MmlL[i][j].Set(WmO[i][*j_])
			}
		}
	}

	// R
	var MllR [][]*big.Int // Nl*Nv
	for i := 0; i < public.Nl; i++ {
		MllR = append(MllR, make([]*big.Int, public.Nv))

		for j := 0; j < public.Nv; j++ {
			MllR[i][j] = big.NewInt(0)

			if j_ := private.f(3, j); j_ != nil {
				MllR[i][j].Set(WlO[i][*j_])
			}
		}
	}

	var MmlR [][]*big.Int // Nm*Nv
	for i := 0; i < public.Nm; i++ {
		MmlR = append(MmlR, make([]*big.Int, public.Nv))

		for j := 0; j < public.Nv; j++ {
			MmlR[i][j] = big.NewInt(0)

			if j_ := private.f(3, j); j_ != nil {
				MmlR[i][j].Set(WmO[i][*j_])
			}
		}
	}

	// O
	var MllO [][]*big.Int // Nl*Nv
	for i := 0; i < public.Nl; i++ {
		MllO = append(MllO, make([]*big.Int, public.Nv))

		for j := 0; j < public.Nv; j++ {
			MllO[i][j] = big.NewInt(0)

			if j_ := private.f(1, j); j_ != nil {
				MllO[i][j].Set(WlO[i][*j_])
			}
		}
	}

	var MmlO [][]*big.Int // Nm*Nv
	for i := 0; i < public.Nm; i++ {
		MmlO = append(MmlO, make([]*big.Int, public.Nv))

		for j := 0; j < public.Nv; j++ {
			MmlO[i][j] = big.NewInt(0)

			if j_ := private.f(1, j); j_ != nil {
				MmlO[i][j].Set(WmO[i][*j_])
			}
		}
	}

	{
		// Check M martix calculated ok
		Wlw := vectorAdd(matrixMulOnVector(lo, MllO), matrixMulOnVector(no, MlnO))
		Wlw = vectorAdd(Wlw, vectorAdd(matrixMulOnVector(ll, MllL), matrixMulOnVector(nl, MlnL)))
		Wlw = vectorAdd(Wlw, vectorAdd(matrixMulOnVector(lr, MllR), matrixMulOnVector(nr, MlnR)))
		fmt.Println("Wl*w =", Wlw)

		Wmw := vectorAdd(matrixMulOnVector(lo, MmlO), matrixMulOnVector(no, MmnO))
		Wmw = vectorAdd(Wmw, vectorAdd(matrixMulOnVector(ll, MmlL), matrixMulOnVector(nl, MmnL)))
		Wmw = vectorAdd(Wmw, vectorAdd(matrixMulOnVector(lr, MmlR), matrixMulOnVector(nr, MmnR)))
		fmt.Println("Wm*w =", Wmw)
	}

	ch_mu := mul(ch_ro, ch_ro)

	lcomb := func(i int) *big.Int {
		return add(
			mul(bbool(public.Fl), pow(ch_lambda, mul(bint(public.Nv), bint(i)))),
			mul(bbool(public.Fm), pow(ch_mu, add(mul(bint(public.Nv), bint(i)), bint(1)))),
		)
	}

	// Calculate linear combination of V

	var V_ *bn256.G1 = new(bn256.G1).ScalarBaseMult(bint(0)) // set infinite

	for i := 0; i < public.K; i++ {
		V_ = V_.Add(V_, new(bn256.G1).ScalarMult(
			public.V[i],
			lcomb(i),
		))
	}

	V_.ScalarMult(V_, bint(2))

	// Calculate lambda vector (nl == nv * k)
	e_lambda_nl := powvector(ch_lambda, public.Nl)

	e_lambda_nv := powvector(ch_lambda, public.Nv)
	e_mu_nv := powvector(ch_mu, public.Nv)

	ch_mu_nv := pow(ch_mu, bint(public.Nv))
	ch_lambda_nv := pow(ch_lambda, bint(public.Nv))

	e_mu_nv_k := powvector(ch_mu_nv, public.K)
	e_lambda_nv_k := powvector(ch_lambda_nv, public.K)

	lambda := vectorAdd(
		vectorTensorMul(vectorMulOnScalar(e_lambda_nv, ch_mu), e_mu_nv_k),
		vectorTensorMul(e_mu_nv, e_lambda_nv_k),
	)

	lambda = vectorMulOnScalar(lambda, bbool(public.Fl && public.Fm))
	lambda = vectorSub(e_lambda_nl, lambda) //Nl

	// Calculate mu vector
	e_mu_nm := powvector(ch_mu, public.Nm)
	mu := vectorMulOnScalar(e_mu_nm, ch_mu) // Nm

	muDiagInv := diagInv(ch_mu, public.Nm) // Nm*Nm

	// Calculate coefficients clX, X = {L,R,O}
	cnL := vectorMulOnMatrix(vectorAdd(vectorMulOnMatrix(lambda, MlnL), vectorMulOnMatrix(mu, MmnL)), muDiagInv) // Nm
	cnR := vectorMulOnMatrix(vectorAdd(vectorMulOnMatrix(lambda, MlnR), vectorMulOnMatrix(mu, MmnR)), muDiagInv) // Nm
	cnO := vectorMulOnMatrix(vectorAdd(vectorMulOnMatrix(lambda, MlnO), vectorMulOnMatrix(mu, MmnO)), muDiagInv) // Nm

	clL := vectorAdd(vectorMulOnMatrix(lambda, MllL), vectorMulOnMatrix(mu, MmlL)) // Nv
	clR := vectorAdd(vectorMulOnMatrix(lambda, MllR), vectorMulOnMatrix(mu, MmlR)) // Nv
	clO := vectorAdd(vectorMulOnMatrix(lambda, MllO), vectorMulOnMatrix(mu, MmlO)) // Nv

	// Define pn(T) and ps(T) as vector of polynom coefficient
	pnT := map[int][]*big.Int{ // 4 * Nm
		0: zeros(public.Nm),                      // * T^0
		1: cnR,                                   // * T^1
		2: cnL,                                   // * T^2
		3: vectorMulOnScalar(cnO, inv(ch_delta)), // * T^3
	}

	psT := polyAdd(polyVectorMulWeight(pnT, pnT, ch_mu), map[int]*big.Int{ // 4
		0: bint(0),
		1: bint(0),
		2: bint(0),
		3: add(vectorMul(mu, public.Am), vectorMul(lambda, public.Al)),
	})

	// Prover computes
	ls := values(public.Nv) // Nv
	ns := values(public.Nm) // Nm

	// Calc linear combination of v[][0]
	var v_ = bint(0)

	for i := 0; i < public.K; i++ {
		v_ = add(v_, mul(
			private.v[i][0],
			lcomb(i),
		))
	}

	v_ = mul(v_, bint(2))

	cl_T := map[int][]*big.Int{ // 4
		0: zeros(public.Nv),
		1: vectorMulOnScalar(clR, bint(2)),
		2: vectorMulOnScalar(clL, bint(2)),
		3: vectorMulOnScalar(clO, mul(inv(ch_delta), bint(2))),
	}

	if public.Fm {
		cl_T[0] = vectorAdd(cl_T[0], append(vectorMulOnScalar(powvector(ch_mu, public.Nv)[1:], ch_mu), bint(0)))
	}

	if public.Fl {
		cl_T[0] = vectorAdd(cl_T[0], append(powvector(ch_lambda, public.Nv)[1:], bint(0)))
	}

	l_T := map[int][]*big.Int{ // 5*Nv
		-1: ls,
		0:  vectorMulOnScalar(lo, ch_delta),
		1:  ll,
		2:  lr,
	}

	// Calc l_T for T^3
	l_T[3] = func() []*big.Int {
		l_T3 := zeros(public.Nv - 1)

		for i := 0; i < public.K; i++ {
			l_T3 = vectorAdd(l_T3, vectorMulOnScalar(
				private.v[i][1:],
				lcomb(i),
			))
		}

		l_T3 = vectorMulOnScalar(l_T3, bint(2))

		return append(l_T3, bint(0))
	}()

	n_T := map[int][]*big.Int{ // 4 * Nm
		-1: ns,
		0:  vectorMulOnScalar(no, ch_delta),
		1:  nl,
		2:  nr,
	}

	nT := polyVectorAdd(pnT, n_T)

	f_T := polySub(psT, polyVectorMulWeight(nT, nT, ch_mu)) // 8
	f_T = polySub(f_T, polyVectorMul(cl_T, l_T))            // TODO maybe add instead of sub
	f_T[3] = add(f_T[3], v_)

	fmt.Println("f'(T) =", f_T)
	fmt.Println("f'(T)[3] =", f_T[3])

	rv := zeros(8)            // 8
	rv[0] = func() *big.Int { // TODO maybe 0 instead of 1
		rv1 := bint(0)

		for i := 0; i < public.K; i++ {
			rv1 = add(rv1, mul(
				private.sv[i],
				lcomb(i),
			))
		}

		return mul(rv1, bint(2))
	}()

	// Check V_ correctness
	{

		// Calc linear combination of v[][0]
		var v_vec = zeros(1)

		for i := 0; i < public.K; i++ {
			v_vec = vectorAdd(v_vec, vectorMulOnScalar(
				private.v[i][1:],
				lcomb(i),
			))
		}

		v_vec = vectorMulOnScalar(v_vec, bint(2))

		check := new(bn256.G1).ScalarMult(public.G, v_)
		check.Add(check, vectorPointScalarMul(public.HVec, append(rv, v_vec...)))
		fmt.Println("V_ =", V_)
		fmt.Println("Check V_=", check)
	}

	sr := []*big.Int{
		mul(ch_beta, mul(ch_delta, ro[1])),
		bint(0),
		add(mul(inv(ch_beta), mul(ch_delta, ro[0])), rl[1]),
		add(add(mul(ch_delta, ro[2]), mul(inv(ch_beta), rl[0])), rr[1]),
		add(add(add(mul(ch_delta, ro[3]), rl[2]), rv[1]), mul(inv(ch_beta), rr[0])),
		add(rl[4], rr[3]),
		add(mul(ch_delta, ro[5]), rr[4]),
		add(mul(ch_delta, ro[6]), rl[5]),
	}

	f_ := []*big.Int{f_T[-1], f_T[-2], f_T[0], f_T[1], f_T[2], f_T[4], f_T[5], f_T[6]}

	rs := vectorSub( // 8
		append([]*big.Int{f_[0]}, vectorMulOnScalar(f_[1:], inv(ch_beta))...),
		sr,
	)

	Cs := new(bn256.G1).ScalarMult(public.G, rs[0])
	Cs.Add(Cs, vectorPointScalarMul(public.HVec, append(rs[1:], ls...)))
	Cs.Add(Cs, vectorPointScalarMul(public.GVec, ns))

	// Prover sends Cs to verifier

	// Verifier selects random t and sends to Prover
	t := values(1)[0]

	// Prover computes

	tinv := inv(t)
	t2 := mul(t, t)
	t3 := mul(t2, t)

	//rT := vectorMulOnScalar(rs, tinv) // 7
	//rT = vectorAdd(rT, vectorMulOnScalar(ro, ch_delta))
	//rT = vectorAdd(rT, vectorMulOnScalar(rl, t))
	//rT = vectorAdd(rT, vectorMulOnScalar(rr, t2))
	//
	//rT = vectorAdd(rT, vectorMulOnScalar(rv, t3))

	r0 := mul(rs[0], tinv)
	r0 = add(r0, mul(ro[0], ch_delta))
	r0 = add(r0, mul(rl[0], t))
	r0 = add(r0, mul(rr[0], t2))

	vT := polyCalc(psT, t) // will not be used by prover
	vT = add(vT, mul(v_, t3))
	vT = add(vT, r0) // TODO maybe - instead of +

	fmt.Println("Should be WNLA secret: ", vT)

	v_1plus := func() []*big.Int {
		v1 := zeros(public.Nv - 1)

		for i := 0; i < public.K; i++ {
			v1 = vectorAdd(v1, vectorMulOnScalar(
				private.v[i][1:],
				lcomb(i),
			))
		}

		v1 = vectorMulOnScalar(v1, bint(2))

		return v1
	}()

	lT := vectorMulOnScalar(append(rs[1:], ls...), tinv)
	lT = vectorAdd(lT, vectorMulOnScalar(append(ro[1:], lo...), ch_delta))
	lT = vectorAdd(lT, vectorMulOnScalar(append(rl[1:], ll...), t))
	lT = vectorAdd(lT, vectorMulOnScalar(append(rr[1:], lr...), t2))
	lT = vectorAdd(lT, vectorMulOnScalar(append(rv, v_1plus...), t3))

	//lT := append(rT[1:], polyVectorCalc(l_T, t)...)

	// Prover and verifier computes
	PT := new(bn256.G1).ScalarMult(public.G, polyCalc(psT, t))
	PT.Add(PT, vectorPointScalarMul(public.GVec, polyVectorCalc(pnT, t)))

	cr_T := []*big.Int{
		bint(1),
		mul(ch_beta, tinv),
		mul(ch_beta, t),
		mul(ch_beta, t2),
		mul(ch_beta, t3),
		mul(ch_beta, mul(t2, t3)),
		mul(ch_beta, mul(t3, t3)),
		mul(ch_beta, mul(mul(t3, t), t3)),
	} // 8

	cT := append(cr_T[1:], polyVectorCalc(cl_T, t)...)

	CT := new(bn256.G1).Add(PT, new(bn256.G1).ScalarMult(Cs, tinv))
	CT.Add(CT, new(bn256.G1).ScalarMult(Co, ch_delta))
	CT.Add(CT, new(bn256.G1).ScalarMult(Cl, t))
	CT.Add(CT, new(bn256.G1).ScalarMult(Cr, t2))
	CT.Add(CT, new(bn256.G1).ScalarMult(V_, t3))

	fmt.Println("C =", CT)

	CTPrv := new(bn256.G1).ScalarMult(public.G, vT)
	CTPrv.Add(CTPrv, vectorPointScalarMul(public.HVec, lT))
	CTPrv.Add(CTPrv, vectorPointScalarMul(public.GVec, polyVectorCalc(nT, t)))

	fmt.Println("C =", CTPrv)

	{
		CLeft := new(bn256.G1).ScalarMult(Cs, tinv)
		CLeft.Add(CLeft, new(bn256.G1).ScalarMult(Co, ch_delta))
		CLeft.Add(CLeft, new(bn256.G1).ScalarMult(Cl, t))
		CLeft.Add(CLeft, new(bn256.G1).ScalarMult(Cr, t2))
		CLeft.Add(CLeft, new(bn256.G1).ScalarMult(V_, t3))

		fmt.Println("45 Check:", CLeft)

		r0 := mul(rs[0], tinv)
		r0 = add(r0, mul(ro[0], ch_delta))
		r0 = add(r0, mul(rl[0], t))
		r0 = add(r0, mul(rr[0], t2))

		CTRight := new(bn256.G1).ScalarMult(public.G, add(mul(v_, t3), r0))
		CTRight.Add(CTRight, vectorPointScalarMul(public.HVec, lT))
		CTRight.Add(CTRight, vectorPointScalarMul(public.GVec, polyVectorCalc(n_T, t)))
		fmt.Println("45 Check:", CTRight)
	}

	wnla(public.G, public.GVec, public.HVec, cT, CT, ch_ro, ch_mu, lT, polyVectorCalc(nT, t))
}