polynomial Division, SolPolynomials, DivisorPolynomial

r1csqapFloat/r1csqapFloat.go

@@ -1,8 +1,6 @@
 package r1csqapFloat
 
-import (
-	"math/big"
-)
+import "math/big"
 
 func Transpose(matrix [][]*big.Float) [][]*big.Float {
 	var r [][]*big.Float
@@ -37,6 +35,22 @@ func PolMul(a, b []*big.Float) []*big.Float {
 	return r
 }
 
+func PolDiv(a, b []*big.Float) ([]*big.Float, []*big.Float) {
+	// https://en.wikipedia.org/wiki/Division_algorithm
+	r := ArrayOfBigZeros(len(a) - len(b) + 1)
+	rem := a
+	for len(rem) >= len(b) {
+		l := new(big.Float).Quo(rem[len(rem)-1], b[len(b)-1])
+		pos := len(rem) - len(b)
+		r[pos] = l
+		aux := ArrayOfBigZeros(pos)
+		aux1 := append(aux, l)
+		aux2 := PolSub(rem, PolMul(b, aux1))
+		rem = aux2[:len(aux2)-1]
+	}
+	return r, rem
+}
+
 func max(a, b int) int {
 	if a > b {
 		return a
@@ -143,3 +157,29 @@ func R1CSToQAP(a, b, c [][]*big.Float) ([][]*big.Float, [][]*big.Float, [][]*big
 	}
 	return alpha, beta, gamma, z
 }
+
+func SolPolynomials(r []*big.Float, ap, bp, cp [][]*big.Float) ([]*big.Float, []*big.Float, []*big.Float, []*big.Float) {
+	var alpha []*big.Float
+	for i := 0; i < len(r); i++ {
+		m := PolMul([]*big.Float{r[i]}, ap[i])
+		alpha = PolAdd(alpha, m)
+	}
+	var beta []*big.Float
+	for i := 0; i < len(r); i++ {
+		m := PolMul([]*big.Float{r[i]}, bp[i])
+		beta = PolAdd(beta, m)
+	}
+	var gamma []*big.Float
+	for i := 0; i < len(r); i++ {
+		m := PolMul([]*big.Float{r[i]}, cp[i])
+		gamma = PolAdd(gamma, m)
+	}
+
+	px := PolSub(PolMul(alpha, beta), gamma)
+	return alpha, beta, gamma, px
+}
+
+func DivisorPolinomial(px, z []*big.Float) []*big.Float {
+	quo, _ := PolDiv(px, z)
+	return quo
+}

r1csqapFloat/r1csqapFloat_test.go

@@ -84,7 +84,12 @@ func TestLagrangeInterpolation(t *testing.T) {
 func TestR1CSToQAP(t *testing.T) {
 	b0 := big.NewFloat(float64(0))
 	b1 := big.NewFloat(float64(1))
+	b3 := big.NewFloat(float64(3))
 	b5 := big.NewFloat(float64(5))
+	b9 := big.NewFloat(float64(9))
+	b27 := big.NewFloat(float64(27))
+	b30 := big.NewFloat(float64(30))
+	b35 := big.NewFloat(float64(35))
 	a := [][]*big.Float{
 		[]*big.Float{b0, b1, b0, b0, b0, b0},
 		[]*big.Float{b0, b0, b0, b1, b0, b0},
@@ -103,10 +108,21 @@ func TestR1CSToQAP(t *testing.T) {
 		[]*big.Float{b0, b0, b0, b0, b0, b1},
 		[]*big.Float{b0, b0, b1, b0, b0, b0},
 	}
-	alpha, beta, gamma, z := R1CSToQAP(a, b, c)
+	ap, bp, cp, z := R1CSToQAP(a, b, c)
+	fmt.Println(ap)
+	fmt.Println(bp)
+	fmt.Println(cp)
+	fmt.Println(z)
+	zexpected := []*big.Float{big.NewFloat(float64(24)), big.NewFloat(float64(-50)), big.NewFloat(float64(35)), big.NewFloat(float64(-10)), big.NewFloat(float64(1))}
+	assert.Equal(t, z, zexpected)
+
+	w := []*big.Float{b1, b3, b35, b9, b27, b30}
+	alpha, beta, gamma, px := SolPolynomials(w, ap, bp, cp)
 	fmt.Println(alpha)
 	fmt.Println(beta)
 	fmt.Println(gamma)
-	fmt.Println(z)
+	fmt.Println(px)
 
+	h := DivisorPolinomial(px, z)
+	fmt.Println(h)
 }