diff --git a/ecc/bls12-377/fr/iop/expressions.go b/ecc/bls12-377/fr/iop/expressions.go
index f9699e0af8..346b6db894 100644
--- a/ecc/bls12-377/fr/iop/expressions.go
+++ b/ecc/bls12-377/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bls12-377/fr/iop/expressions_test.go b/ecc/bls12-377/fr/iop/expressions_test.go
index 738b8dc61b..9b19051818 100644
--- a/ecc/bls12-377/fr/iop/expressions_test.go
+++ b/ecc/bls12-377/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bls12-377/fr/iop/polynomial.go b/ecc/bls12-377/fr/iop/polynomial.go
index 170a23c424..6854dcb6f9 100644
--- a/ecc/bls12-377/fr/iop/polynomial.go
+++ b/ecc/bls12-377/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bls12-377/fr/iop/polynomial_test.go b/ecc/bls12-377/fr/iop/polynomial_test.go
index 1233ddb6c2..11a661934c 100644
--- a/ecc/bls12-377/fr/iop/polynomial_test.go
+++ b/ecc/bls12-377/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bls12-377/fr/iop/quotient.go b/ecc/bls12-377/fr/iop/quotient.go
index 4cbd393346..0d1bfba0c7 100644
--- a/ecc/bls12-377/fr/iop/quotient.go
+++ b/ecc/bls12-377/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bls12-377/fr/iop/quotient_test.go b/ecc/bls12-377/fr/iop/quotient_test.go
index 835e8c0e2f..4c8018a19b 100644
--- a/ecc/bls12-377/fr/iop/quotient_test.go
+++ b/ecc/bls12-377/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bls12-377/fr/iop/ratios.go b/ecc/bls12-377/fr/iop/ratios.go
index f607d831cd..e76f18ced9 100644
--- a/ecc/bls12-377/fr/iop/ratios.go
+++ b/ecc/bls12-377/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bls12-377/fr/iop/ratios_test.go b/ecc/bls12-377/fr/iop/ratios_test.go
index 145c0f6c90..b278f39c61 100644
--- a/ecc/bls12-377/fr/iop/ratios_test.go
+++ b/ecc/bls12-377/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/ecc/bls12-378/fr/iop/expressions.go b/ecc/bls12-378/fr/iop/expressions.go
index 584e678e52..09158e4d7d 100644
--- a/ecc/bls12-378/fr/iop/expressions.go
+++ b/ecc/bls12-378/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bls12-378/fr/iop/expressions_test.go b/ecc/bls12-378/fr/iop/expressions_test.go
index 4bb30c062f..d5dc5decc7 100644
--- a/ecc/bls12-378/fr/iop/expressions_test.go
+++ b/ecc/bls12-378/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bls12-378/fr/iop/polynomial.go b/ecc/bls12-378/fr/iop/polynomial.go
index f7488998b6..e8bf79b9ca 100644
--- a/ecc/bls12-378/fr/iop/polynomial.go
+++ b/ecc/bls12-378/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bls12-378/fr/iop/polynomial_test.go b/ecc/bls12-378/fr/iop/polynomial_test.go
index 81fe25e178..cf0c780633 100644
--- a/ecc/bls12-378/fr/iop/polynomial_test.go
+++ b/ecc/bls12-378/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bls12-378/fr/iop/quotient.go b/ecc/bls12-378/fr/iop/quotient.go
index 11df5a974a..aa9990c0f6 100644
--- a/ecc/bls12-378/fr/iop/quotient.go
+++ b/ecc/bls12-378/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bls12-378/fr/iop/quotient_test.go b/ecc/bls12-378/fr/iop/quotient_test.go
index 2faf0a124d..caa5de693c 100644
--- a/ecc/bls12-378/fr/iop/quotient_test.go
+++ b/ecc/bls12-378/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bls12-378/fr/iop/ratios.go b/ecc/bls12-378/fr/iop/ratios.go
index 06004f6701..180bb69c4c 100644
--- a/ecc/bls12-378/fr/iop/ratios.go
+++ b/ecc/bls12-378/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bls12-378/fr/iop/ratios_test.go b/ecc/bls12-378/fr/iop/ratios_test.go
index c66fc20648..7be18b3dd0 100644
--- a/ecc/bls12-378/fr/iop/ratios_test.go
+++ b/ecc/bls12-378/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/ecc/bls12-381/fr/iop/expressions.go b/ecc/bls12-381/fr/iop/expressions.go
index 22c7f46529..d877634651 100644
--- a/ecc/bls12-381/fr/iop/expressions.go
+++ b/ecc/bls12-381/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bls12-381/fr/iop/expressions_test.go b/ecc/bls12-381/fr/iop/expressions_test.go
index 7808f8e7e7..12e3c4891c 100644
--- a/ecc/bls12-381/fr/iop/expressions_test.go
+++ b/ecc/bls12-381/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bls12-381/fr/iop/polynomial.go b/ecc/bls12-381/fr/iop/polynomial.go
index f742800b47..8c21a96e40 100644
--- a/ecc/bls12-381/fr/iop/polynomial.go
+++ b/ecc/bls12-381/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bls12-381/fr/iop/polynomial_test.go b/ecc/bls12-381/fr/iop/polynomial_test.go
index b3dc44c0e4..23f1db3805 100644
--- a/ecc/bls12-381/fr/iop/polynomial_test.go
+++ b/ecc/bls12-381/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bls12-381/fr/iop/quotient.go b/ecc/bls12-381/fr/iop/quotient.go
index 5bd999bc9b..85bcf9372c 100644
--- a/ecc/bls12-381/fr/iop/quotient.go
+++ b/ecc/bls12-381/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bls12-381/fr/iop/quotient_test.go b/ecc/bls12-381/fr/iop/quotient_test.go
index 536110a391..92c5bdce29 100644
--- a/ecc/bls12-381/fr/iop/quotient_test.go
+++ b/ecc/bls12-381/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bls12-381/fr/iop/ratios.go b/ecc/bls12-381/fr/iop/ratios.go
index 1f387f67d2..02297e8b0e 100644
--- a/ecc/bls12-381/fr/iop/ratios.go
+++ b/ecc/bls12-381/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bls12-381/fr/iop/ratios_test.go b/ecc/bls12-381/fr/iop/ratios_test.go
index 07181a539f..5ba2458600 100644
--- a/ecc/bls12-381/fr/iop/ratios_test.go
+++ b/ecc/bls12-381/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/ecc/bls24-315/fr/iop/expressions.go b/ecc/bls24-315/fr/iop/expressions.go
index 32966a1970..fb5bdfad34 100644
--- a/ecc/bls24-315/fr/iop/expressions.go
+++ b/ecc/bls24-315/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bls24-315/fr/iop/expressions_test.go b/ecc/bls24-315/fr/iop/expressions_test.go
index 9b15f749dd..d3cc11eecd 100644
--- a/ecc/bls24-315/fr/iop/expressions_test.go
+++ b/ecc/bls24-315/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bls24-315/fr/iop/polynomial.go b/ecc/bls24-315/fr/iop/polynomial.go
index ac1bea75a3..372d5d69c6 100644
--- a/ecc/bls24-315/fr/iop/polynomial.go
+++ b/ecc/bls24-315/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bls24-315/fr/iop/polynomial_test.go b/ecc/bls24-315/fr/iop/polynomial_test.go
index fc43b7f9f0..f592ce643c 100644
--- a/ecc/bls24-315/fr/iop/polynomial_test.go
+++ b/ecc/bls24-315/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bls24-315/fr/iop/quotient.go b/ecc/bls24-315/fr/iop/quotient.go
index 7e8cbb3530..96bee3dc3e 100644
--- a/ecc/bls24-315/fr/iop/quotient.go
+++ b/ecc/bls24-315/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bls24-315/fr/iop/quotient_test.go b/ecc/bls24-315/fr/iop/quotient_test.go
index 1e064d552a..ed29c3394e 100644
--- a/ecc/bls24-315/fr/iop/quotient_test.go
+++ b/ecc/bls24-315/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bls24-315/fr/iop/ratios.go b/ecc/bls24-315/fr/iop/ratios.go
index ab66c762dd..b0a507f020 100644
--- a/ecc/bls24-315/fr/iop/ratios.go
+++ b/ecc/bls24-315/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bls24-315/fr/iop/ratios_test.go b/ecc/bls24-315/fr/iop/ratios_test.go
index e36f9ba03c..fda4495177 100644
--- a/ecc/bls24-315/fr/iop/ratios_test.go
+++ b/ecc/bls24-315/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/ecc/bls24-317/fr/iop/expressions.go b/ecc/bls24-317/fr/iop/expressions.go
index aac3e2e54e..300bca47cc 100644
--- a/ecc/bls24-317/fr/iop/expressions.go
+++ b/ecc/bls24-317/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bls24-317/fr/iop/expressions_test.go b/ecc/bls24-317/fr/iop/expressions_test.go
index cb042fa7c6..da0a938a43 100644
--- a/ecc/bls24-317/fr/iop/expressions_test.go
+++ b/ecc/bls24-317/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bls24-317/fr/iop/polynomial.go b/ecc/bls24-317/fr/iop/polynomial.go
index 99334a8397..d3593ecc9b 100644
--- a/ecc/bls24-317/fr/iop/polynomial.go
+++ b/ecc/bls24-317/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bls24-317/fr/iop/polynomial_test.go b/ecc/bls24-317/fr/iop/polynomial_test.go
index 9ae3a4fd2e..1698d2b45c 100644
--- a/ecc/bls24-317/fr/iop/polynomial_test.go
+++ b/ecc/bls24-317/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bls24-317/fr/iop/quotient.go b/ecc/bls24-317/fr/iop/quotient.go
index d28e4ae9e9..8bea304b5f 100644
--- a/ecc/bls24-317/fr/iop/quotient.go
+++ b/ecc/bls24-317/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bls24-317/fr/iop/quotient_test.go b/ecc/bls24-317/fr/iop/quotient_test.go
index ed56262040..93c59198c0 100644
--- a/ecc/bls24-317/fr/iop/quotient_test.go
+++ b/ecc/bls24-317/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bls24-317/fr/iop/ratios.go b/ecc/bls24-317/fr/iop/ratios.go
index 20d4d5209e..d8ab9de31b 100644
--- a/ecc/bls24-317/fr/iop/ratios.go
+++ b/ecc/bls24-317/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bls24-317/fr/iop/ratios_test.go b/ecc/bls24-317/fr/iop/ratios_test.go
index 2ec550c132..1eeb16cc4e 100644
--- a/ecc/bls24-317/fr/iop/ratios_test.go
+++ b/ecc/bls24-317/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/ecc/bn254/fr/iop/expressions.go b/ecc/bn254/fr/iop/expressions.go
index 29b538ae74..5d15967945 100644
--- a/ecc/bn254/fr/iop/expressions.go
+++ b/ecc/bn254/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bn254/fr/iop/expressions_test.go b/ecc/bn254/fr/iop/expressions_test.go
index 8344dcd688..343a0b9c44 100644
--- a/ecc/bn254/fr/iop/expressions_test.go
+++ b/ecc/bn254/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bn254/fr/iop/polynomial.go b/ecc/bn254/fr/iop/polynomial.go
index 84e06fc169..ed8e971c4b 100644
--- a/ecc/bn254/fr/iop/polynomial.go
+++ b/ecc/bn254/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bn254/fr/iop/polynomial_test.go b/ecc/bn254/fr/iop/polynomial_test.go
index 6ba60bf1a9..f633acaa44 100644
--- a/ecc/bn254/fr/iop/polynomial_test.go
+++ b/ecc/bn254/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bn254/fr/iop/quotient.go b/ecc/bn254/fr/iop/quotient.go
index b862a8aae0..b857cf8dc5 100644
--- a/ecc/bn254/fr/iop/quotient.go
+++ b/ecc/bn254/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bn254/fr/iop/quotient_test.go b/ecc/bn254/fr/iop/quotient_test.go
index 7c3086aea4..7557641dc9 100644
--- a/ecc/bn254/fr/iop/quotient_test.go
+++ b/ecc/bn254/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bn254/fr/iop/ratios.go b/ecc/bn254/fr/iop/ratios.go
index 720f092b33..b196057e81 100644
--- a/ecc/bn254/fr/iop/ratios.go
+++ b/ecc/bn254/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bn254/fr/iop/ratios_test.go b/ecc/bn254/fr/iop/ratios_test.go
index 73ce0814db..bbaf3cbe90 100644
--- a/ecc/bn254/fr/iop/ratios_test.go
+++ b/ecc/bn254/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/ecc/bw6-633/fr/iop/expressions.go b/ecc/bw6-633/fr/iop/expressions.go
index 390c57c18a..da961d8e0f 100644
--- a/ecc/bw6-633/fr/iop/expressions.go
+++ b/ecc/bw6-633/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bw6-633/fr/iop/expressions_test.go b/ecc/bw6-633/fr/iop/expressions_test.go
index 269c95c278..105bc1ab04 100644
--- a/ecc/bw6-633/fr/iop/expressions_test.go
+++ b/ecc/bw6-633/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bw6-633/fr/iop/polynomial.go b/ecc/bw6-633/fr/iop/polynomial.go
index 09fc2cc3e2..81ceca17b7 100644
--- a/ecc/bw6-633/fr/iop/polynomial.go
+++ b/ecc/bw6-633/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bw6-633/fr/iop/polynomial_test.go b/ecc/bw6-633/fr/iop/polynomial_test.go
index bfc3ad47b1..b2734df2ce 100644
--- a/ecc/bw6-633/fr/iop/polynomial_test.go
+++ b/ecc/bw6-633/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bw6-633/fr/iop/quotient.go b/ecc/bw6-633/fr/iop/quotient.go
index dff99713c0..290a6fcb82 100644
--- a/ecc/bw6-633/fr/iop/quotient.go
+++ b/ecc/bw6-633/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bw6-633/fr/iop/quotient_test.go b/ecc/bw6-633/fr/iop/quotient_test.go
index b85eaa24e7..5c84626848 100644
--- a/ecc/bw6-633/fr/iop/quotient_test.go
+++ b/ecc/bw6-633/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bw6-633/fr/iop/ratios.go b/ecc/bw6-633/fr/iop/ratios.go
index ad5dc48e91..a3791a556e 100644
--- a/ecc/bw6-633/fr/iop/ratios.go
+++ b/ecc/bw6-633/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bw6-633/fr/iop/ratios_test.go b/ecc/bw6-633/fr/iop/ratios_test.go
index bd19cc647f..2e64ef32c5 100644
--- a/ecc/bw6-633/fr/iop/ratios_test.go
+++ b/ecc/bw6-633/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/ecc/bw6-756/fr/iop/expressions.go b/ecc/bw6-756/fr/iop/expressions.go
index 4041cf0839..f7a4a999c5 100644
--- a/ecc/bw6-756/fr/iop/expressions.go
+++ b/ecc/bw6-756/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bw6-756/fr/iop/expressions_test.go b/ecc/bw6-756/fr/iop/expressions_test.go
index a303adf5a9..7b07d2691b 100644
--- a/ecc/bw6-756/fr/iop/expressions_test.go
+++ b/ecc/bw6-756/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bw6-756/fr/iop/polynomial.go b/ecc/bw6-756/fr/iop/polynomial.go
index bdd697082b..449d4dbd7e 100644
--- a/ecc/bw6-756/fr/iop/polynomial.go
+++ b/ecc/bw6-756/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bw6-756/fr/iop/polynomial_test.go b/ecc/bw6-756/fr/iop/polynomial_test.go
index 964db099cd..d5ccc5dac2 100644
--- a/ecc/bw6-756/fr/iop/polynomial_test.go
+++ b/ecc/bw6-756/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bw6-756/fr/iop/quotient.go b/ecc/bw6-756/fr/iop/quotient.go
index 711ede84f5..90cde7f57a 100644
--- a/ecc/bw6-756/fr/iop/quotient.go
+++ b/ecc/bw6-756/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bw6-756/fr/iop/quotient_test.go b/ecc/bw6-756/fr/iop/quotient_test.go
index ac8e1d86a9..6331233636 100644
--- a/ecc/bw6-756/fr/iop/quotient_test.go
+++ b/ecc/bw6-756/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bw6-756/fr/iop/ratios.go b/ecc/bw6-756/fr/iop/ratios.go
index 346ceb6ab1..f0c9c1a8b2 100644
--- a/ecc/bw6-756/fr/iop/ratios.go
+++ b/ecc/bw6-756/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bw6-756/fr/iop/ratios_test.go b/ecc/bw6-756/fr/iop/ratios_test.go
index aceed099dc..3be5c98e41 100644
--- a/ecc/bw6-756/fr/iop/ratios_test.go
+++ b/ecc/bw6-756/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/ecc/bw6-761/fr/iop/expressions.go b/ecc/bw6-761/fr/iop/expressions.go
index 1752c0fe3d..d89685a2a2 100644
--- a/ecc/bw6-761/fr/iop/expressions.go
+++ b/ecc/bw6-761/fr/iop/expressions.go
@@ -68,7 +68,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/ecc/bw6-761/fr/iop/expressions_test.go b/ecc/bw6-761/fr/iop/expressions_test.go
index d8998b7279..5f6a5389a5 100644
--- a/ecc/bw6-761/fr/iop/expressions_test.go
+++ b/ecc/bw6-761/fr/iop/expressions_test.go
@@ -44,9 +44,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/ecc/bw6-761/fr/iop/polynomial.go b/ecc/bw6-761/fr/iop/polynomial.go
index 2ab1a4e817..cda824d57a 100644
--- a/ecc/bw6-761/fr/iop/polynomial.go
+++ b/ecc/bw6-761/fr/iop/polynomial.go
@@ -80,11 +80,11 @@ type Polynomial struct {
 // A Polynomial can be seen as a "shared pointer" on a list of coefficients.
 // It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -130,8 +130,8 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
@@ -183,11 +183,11 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
@@ -195,19 +195,19 @@ func (p *Polynomial) GetCoeff(i int) fr.Element {
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -218,10 +218,10 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients: &newCoeffs,
+		coefficients: newCoeffs,
 		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
@@ -236,13 +236,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -256,7 +256,7 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
@@ -267,7 +267,7 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -280,20 +280,20 @@ func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -311,16 +311,16 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -331,7 +331,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -342,18 +342,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -397,8 +397,7 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
diff --git a/ecc/bw6-761/fr/iop/polynomial_test.go b/ecc/bw6-761/fr/iop/polynomial_test.go
index 52e696d974..01203d63ad 100644
--- a/ecc/bw6-761/fr/iop/polynomial_test.go
+++ b/ecc/bw6-761/fr/iop/polynomial_test.go
@@ -63,13 +63,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -79,7 +79,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -275,12 +275,12 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])) {
+		if !p[i].Equal(&q[i]) {
 			return false
 		}
 	}
diff --git a/ecc/bw6-761/fr/iop/quotient.go b/ecc/bw6-761/fr/iop/quotient.go
index 0a081b4fc2..0045f6c628 100644
--- a/ecc/bw6-761/fr/iop/quotient.go
+++ b/ecc/bw6-761/fr/iop/quotient.go
@@ -44,7 +44,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
@@ -53,7 +53,7 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
diff --git a/ecc/bw6-761/fr/iop/quotient_test.go b/ecc/bw6-761/fr/iop/quotient_test.go
index 3267e542e3..8d832aa75f 100644
--- a/ecc/bw6-761/fr/iop/quotient_test.go
+++ b/ecc/bw6-761/fr/iop/quotient_test.go
@@ -38,7 +38,7 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
 func TestDivideByXMinusOne(t *testing.T) {
diff --git a/ecc/bw6-761/fr/iop/ratios.go b/ecc/bw6-761/fr/iop/ratios.go
index 653762b268..0cdf7914af 100644
--- a/ecc/bw6-761/fr/iop/ratios.go
+++ b/ecc/bw6-761/fr/iop/ratios.go
@@ -126,7 +126,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -223,7 +223,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/ecc/bw6-761/fr/iop/ratios_test.go b/ecc/bw6-761/fr/iop/ratios_test.go
index b2ca066c49..a12e3aef5d 100644
--- a/ecc/bw6-761/fr/iop/ratios_test.go
+++ b/ecc/bw6-761/fr/iop/ratios_test.go
@@ -199,7 +199,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])
diff --git a/internal/generator/iop/template/expressions.go.tmpl b/internal/generator/iop/template/expressions.go.tmpl
index 1dbae21b88..901b8671b8 100644
--- a/internal/generator/iop/template/expressions.go.tmpl
+++ b/internal/generator/iop/template/expressions.go.tmpl
@@ -16,7 +16,7 @@ type Expression func(x ...fr.Element) fr.Element
 // The Shift field of the result is 0.
 func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 	if len(x) == 0 {
-		return nil, errors.New("need at lest one input") 
+		return nil, errors.New("need at lest one input")
 	}
 
 	// check that the sizes are consistent
@@ -38,7 +38,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		idx = func(i int) int {
 			return int(bits.Reverse64(uint64(i)) >> nn)
 		}
-	} 
+	}
 
 	parallel.Execute(n, func(start, end int) {
 		vx := make([]fr.Element, m)
@@ -50,8 +50,7 @@ func Evaluate(f Expression, form Form, x ...*Polynomial) (*Polynomial, error) {
 		}
 	})
 
-
-	res := NewPolynomial(&r, form)
+	res := NewPolynomial(r, form)
 	res.size = x[0].size
 	res.blindedSize = x[0].size
 	res.shift = 0
diff --git a/internal/generator/iop/template/expressions.test.go.tmpl b/internal/generator/iop/template/expressions.test.go.tmpl
index eb1d5765e0..e4832f1061 100644
--- a/internal/generator/iop/template/expressions.test.go.tmpl
+++ b/internal/generator/iop/template/expressions.test.go.tmpl
@@ -26,9 +26,9 @@ func TestEvaluate(t *testing.T) {
 		r[i].SetUint64(uint64(3 * (i + 1)))
 	}
 	form := Form{Layout: Regular, Basis: Canonical}
-	wu := NewPolynomial(&u, form)
-	wv := NewPolynomial(&v, form)
-	ww := NewPolynomial(&w, form)
+	wu := NewPolynomial(u, form)
+	wv := NewPolynomial(v, form)
+	ww := NewPolynomial(w, form)
 
 	rr, err := Evaluate(f, form, wu, wv, ww)
 	if err != nil {
diff --git a/internal/generator/iop/template/polynomial.go.tmpl b/internal/generator/iop/template/polynomial.go.tmpl
index 318210258f..f461c8c2ab 100644
--- a/internal/generator/iop/template/polynomial.go.tmpl
+++ b/internal/generator/iop/template/polynomial.go.tmpl
@@ -25,7 +25,6 @@ const (
 	BitReverse
 )
 
-
 // Form describes the form of a polynomial.
 // TODO should be a regular enum?
 type Form struct {
@@ -33,19 +32,17 @@ type Form struct {
 	Layout Layout
 }
 
-
 // enum of the possible Form values for type-safe switches
 // in this package
 var (
-	canonicalRegular = Form{Canonical, Regular}
-	canonicalBitReverse = Form{Canonical, BitReverse}
-	lagrangeRegular = Form{Lagrange, Regular}
-	lagrangeBitReverse = Form{Lagrange, BitReverse}
-	lagrangeCosetRegular = Form{LagrangeCoset, Regular}
+	canonicalRegular        = Form{Canonical, Regular}
+	canonicalBitReverse     = Form{Canonical, BitReverse}
+	lagrangeRegular         = Form{Lagrange, Regular}
+	lagrangeBitReverse      = Form{Lagrange, BitReverse}
+	lagrangeCosetRegular    = Form{LagrangeCoset, Regular}
 	lagrangeCosetBitReverse = Form{LagrangeCoset, BitReverse}
 )
 
-
 // Polynomial wraps a polynomial so that it is
 // interpreted as P'(X)=P(\omega^{shift}X).
 // Size is the real size of the polynomial (seen as a vector).
@@ -62,14 +59,14 @@ type Polynomial struct {
 }
 
 // NewPolynomial returned a Polynomial from the provided coefficients in the given form.
-// A Polynomial can be seen as a "shared pointer" on a list of coefficients. 
-// It is the responsibility of the user to call the Clone method if the coefficients 
+// A Polynomial can be seen as a "shared pointer" on a list of coefficients.
+// It is the responsibility of the user to call the Clone method if the coefficients
 // shouldn't be mutated.
-func NewPolynomial(coeffs *[]fr.Element, form Form) *Polynomial {
+func NewPolynomial(coeffs []fr.Element, form Form) *Polynomial {
 	return &Polynomial{
 		polynomial:  newPolynomial(coeffs, form),
-		size:        len(*coeffs),
-		blindedSize: len(*coeffs),
+		size:        len(coeffs),
+		blindedSize: len(coeffs),
 	}
 }
 
@@ -86,7 +83,6 @@ func (p *Polynomial) BlindedSize() int {
 	return p.blindedSize
 }
 
-
 // Blind blinds a polynomial q by adding Q(X)*(X^{n}-1),
 // where deg Q = blindingOrder and Q is random, and n is the
 // size of q. Sets the result to p and returns it.
@@ -116,15 +112,14 @@ func (p *Polynomial) Blind(blindingOrder int) *Polynomial {
 
 	for i := 0; i <= blindingOrder; i++ {
 		r.SetRandom()
-		(*p.coefficients)[i].Sub(&(*p.coefficients)[i], &r)
-		(*p.coefficients)[i+p.size].Add(&(*p.coefficients)[i+p.size], &r)
+		p.coefficients[i].Sub(&p.coefficients[i], &r)
+		p.coefficients[i+p.size].Add(&p.coefficients[i+p.size], &r)
 	}
 	p.blindedSize = newSize
 
 	return p
 }
 
-
 // Evaluate evaluates p at x.
 // The code panics if the function is not in canonical form.
 func (p *Polynomial) Evaluate(x fr.Element) fr.Element {
@@ -148,7 +143,7 @@ func (p *Polynomial) Evaluate(x fr.Element) fr.Element {
 	return p.polynomial.evaluate(x)
 }
 
-// Clone returns a deep copy of p. The underlying polynomial is cloned; 
+// Clone returns a deep copy of p. The underlying polynomial is cloned;
 // see also ShallowClone to perform a ShallowClone on the underlying polynomial.
 // If capacity is provided, the new coefficient slice capacity will be set accordingly.
 func (p *Polynomial) Clone(capacity ...int) *Polynomial {
@@ -164,39 +159,37 @@ func (p *Polynomial) ShallowClone() *Polynomial {
 	return &res
 }
 
-
 // GetCoeff returns the i-th entry of p, taking the layout in account.
 func (p *Polynomial) GetCoeff(i int) fr.Element {
 
 	n := p.coefficients.Len()
 	rho := n / p.size
 	if p.polynomial.Form.Layout == Regular {
-		return (*p.coefficients)[(i+rho*p.shift)%n]
+		return p.coefficients[(i+rho*p.shift)%n]
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		iRev := bits.Reverse64(uint64((i+rho*p.shift)%n)) >> nn
-		return (*p.coefficients)[iRev]
+		return p.coefficients[iRev]
 	}
 
 }
 
-
 // polynomial represents a polynomial, the vector of coefficients
 // along with the basis and the layout.
 type polynomial struct {
-	coefficients *fr.Vector
+	coefficients fr.Vector
 	Form
 }
 
 // Coefficients returns a slice on the underlying data structure.
 func (p *polynomial) Coefficients() []fr.Element {
-	return (*p.coefficients)
+	return p.coefficients
 }
 
 // newPolynomial creates a new polynomial. The slice coeff NOT copied
 // but directly assigned to the new polynomial.
-func newPolynomial(coeffs *[]fr.Element, form Form) *polynomial {
-	return &polynomial{coefficients: (*fr.Vector)(coeffs), Form: form}
+func newPolynomial(coeffs []fr.Element, form Form) *polynomial {
+	return &polynomial{coefficients: fr.Vector(coeffs), Form: form}
 }
 
 // clone returns a deep copy of the underlying data structure.
@@ -207,14 +200,13 @@ func (p *polynomial) clone(capacity ...int) *polynomial {
 	}
 	newCoeffs := make(fr.Vector, p.coefficients.Len(), c)
 	r := &polynomial{
-		coefficients:&newCoeffs,
-		Form: p.Form,
+		coefficients: newCoeffs,
+		Form:         p.Form,
 	}
-	copy((*r.coefficients), (*p.coefficients))
+	copy(r.coefficients, p.coefficients)
 	return r
 }
 
-
 // evaluate evaluates p at x.
 // The code panics if the function is not in canonical form.
 func (p *polynomial) evaluate(x fr.Element) fr.Element {
@@ -226,13 +218,13 @@ func (p *polynomial) evaluate(x fr.Element) fr.Element {
 
 	if p.Layout == Regular {
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[i])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[i])
 		}
 	} else {
 		nn := uint64(64 - bits.TrailingZeros(uint(p.coefficients.Len())))
 		for i := p.coefficients.Len() - 1; i >= 0; i-- {
 			iRev := bits.Reverse64(uint64(i)) >> nn
-			r.Mul(&r, &x).Add(&r, &(*p.coefficients)[iRev])
+			r.Mul(&r, &x).Add(&r, &p.coefficients[iRev])
 		}
 	}
 
@@ -246,19 +238,18 @@ func (p *Polynomial) ToRegular() *Polynomial {
 	if p.Layout == Regular {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = Regular
 	return p
 }
 
-
 // ToBitReverse changes the layout of p to BitReverse.
 // Leaves p unchanged if p's layout was already BitReverse.
 func (p *Polynomial) ToBitReverse() *Polynomial {
 	if p.Layout == BitReverse {
 		return p
 	}
-	fft.BitReverse((*p.coefficients))
+	fft.BitReverse(p.coefficients)
 	p.Layout = BitReverse
 	return p
 }
@@ -266,25 +257,25 @@ func (p *Polynomial) ToBitReverse() *Polynomial {
 // ToLagrange converts p to Lagrange form.
 // Leaves p unchanged if p was already in Lagrange form.
 func (p *Polynomial) ToLagrange(d *fft.Domain) *Polynomial {
-	id := p.Form 
+	id := p.Form
 	p.grow(int(d.Cardinality))
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFT((p.coefficients), fft.DIF)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT)
-	case lagrangeRegular,lagrangeBitReverse:
+		d.FFT((p.coefficients), fft.DIT)
+	case lagrangeRegular, lagrangeBitReverse:
 		return p
 	case lagrangeCosetRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
-		d.FFT((*p.coefficients), fft.DIT)
+		d.FFTInverse((p.coefficients), fft.DIF, true)
+		d.FFT((p.coefficients), fft.DIT)
 	case lagrangeCosetBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
-		d.FFT((*p.coefficients), fft.DIF)
+		d.FFTInverse((p.coefficients), fft.DIT, true)
+		d.FFT((p.coefficients), fft.DIF)
 	default:
 		panic("unknown ID")
 	}
@@ -298,20 +289,20 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 	id := p.Form
 	p.grow(int(d.Cardinality))
 	switch id {
-	case canonicalRegular,canonicalBitReverse:
+	case canonicalRegular, canonicalBitReverse:
 		return p
 	case lagrangeRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF)
+		d.FFTInverse(p.coefficients, fft.DIF)
 	case lagrangeBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT)
+		d.FFTInverse(p.coefficients, fft.DIT)
 	case lagrangeCosetRegular:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIF, true)
 	case lagrangeCosetBitReverse:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIT, true)
 	default:
 		panic("unknown ID")
 	}
@@ -322,7 +313,7 @@ func (p *Polynomial) ToCanonical(d *fft.Domain) *Polynomial {
 func (p *polynomial) grow(newSize int) {
 	offset := newSize - p.coefficients.Len()
 	if offset > 0 {
-		(*p.coefficients) = append((*p.coefficients), make(fr.Vector, offset)...)
+		p.coefficients = append(p.coefficients, make(fr.Vector, offset)...)
 	}
 }
 
@@ -333,18 +324,18 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	switch id {
 	case canonicalRegular:
 		p.Layout = BitReverse
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case canonicalBitReverse:
 		p.Layout = Regular
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeRegular:
 		p.Layout = Regular
-		d.FFTInverse((*p.coefficients), fft.DIF)
-		d.FFT((*p.coefficients), fft.DIT, true)
+		d.FFTInverse(p.coefficients, fft.DIF)
+		d.FFT(p.coefficients, fft.DIT, true)
 	case lagrangeBitReverse:
 		p.Layout = BitReverse
-		d.FFTInverse((*p.coefficients), fft.DIT)
-		d.FFT((*p.coefficients), fft.DIF, true)
+		d.FFTInverse(p.coefficients, fft.DIT)
+		d.FFT(p.coefficients, fft.DIF, true)
 	case lagrangeCosetRegular, lagrangeCosetBitReverse:
 		return p
 	default:
@@ -355,14 +346,12 @@ func (p *Polynomial) ToLagrangeCoset(d *fft.Domain) *Polynomial {
 	return p
 }
 
-
-
-// WriteTo implements io.WriterTo 
+// WriteTo implements io.WriterTo
 func (p *Polynomial) WriteTo(w io.Writer) (int64, error) {
-	// encode coefficients 
+	// encode coefficients
 	n, err := p.polynomial.coefficients.WriteTo(w)
 	if err != nil {
-		return n, err 
+		return n, err
 	}
 
 	// encode Form.Basis, Form.Layout, shift, size & blindedSize as uint32
@@ -390,12 +379,11 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 		p.polynomial = new(polynomial)
 	}
 	if p.polynomial.coefficients == nil {
-		v := make(fr.Vector, 0)
-		p.polynomial.coefficients = &v
+		p.polynomial.coefficients = make(fr.Vector, 0)
 	}
 	n, err := p.polynomial.coefficients.ReadFrom(r)
 	if err != nil {
-		return n, err 
+		return n, err
 	}
 
 	// decode Form.Basis, Form.Layout, shift, size & blindedSize as uint32
@@ -416,5 +404,5 @@ func (p *Polynomial) ReadFrom(r io.Reader) (int64, error) {
 	p.size = int(data[3])
 	p.blindedSize = int(data[4])
 
-    return n, nil 
-}
\ No newline at end of file
+	return n, nil
+}
diff --git a/internal/generator/iop/template/polynomial.test.go.tmpl b/internal/generator/iop/template/polynomial.test.go.tmpl
index 9388cce53e..798969fc53 100644
--- a/internal/generator/iop/template/polynomial.test.go.tmpl
+++ b/internal/generator/iop/template/polynomial.test.go.tmpl
@@ -45,13 +45,13 @@ func TestEvaluation(t *testing.T) {
 
 }
 
-func randomVector(size int) *[]fr.Element {
+func randomVector(size int) []fr.Element {
 
 	r := make([]fr.Element, size)
 	for i := 0; i < size; i++ {
 		r[i].SetRandom()
 	}
-	return &r
+	return r
 }
 
 func TestGetCoeff(t *testing.T) {
@@ -61,7 +61,7 @@ func TestGetCoeff(t *testing.T) {
 	for i := 0; i < size; i++ {
 		v[i].SetUint64(uint64(i))
 	}
-	wp := NewPolynomial(&v, Form{Layout: Regular, Basis: Canonical})
+	wp := NewPolynomial(v, Form{Layout: Regular, Basis: Canonical})
 	wsp := wp.ShallowClone().Shift(1)
 
 	var aa, bb fr.Element
@@ -100,7 +100,6 @@ func TestGetCoeff(t *testing.T) {
 
 }
 
-
 func TestRoundTrip(t *testing.T) {
 	assert := require.New(t)
 	var buf bytes.Buffer
@@ -109,7 +108,7 @@ func TestRoundTrip(t *testing.T) {
 	d := fft.NewDomain(uint64(8))
 	blindingOrder := 2
 
-	p := NewPolynomial(randomVector(size), Form{Basis:Lagrange, Layout: Regular}).ToCanonical(d).ToRegular()
+	p := NewPolynomial(randomVector(size), Form{Basis: Lagrange, Layout: Regular}).ToCanonical(d).ToRegular()
 	p.Blind(blindingOrder)
 
 	// serialize
@@ -123,7 +122,7 @@ func TestRoundTrip(t *testing.T) {
 
 	assert.Equal(read, written, "number of bytes written != number of bytes read")
 
-	// compare 
+	// compare
 	assert.Equal(p.Basis, reconstructed.Basis)
 	assert.Equal(p.Layout, reconstructed.Layout)
 	assert.Equal(p.shift, reconstructed.shift)
@@ -142,7 +141,7 @@ func TestBlinding(t *testing.T) {
 	// generate a random polynomial in Lagrange form for the moment
 	// to check that an error is raised when the polynomial is not
 	// in canonical form.
-	wp := NewPolynomial(randomVector(size), Form{Basis:Lagrange, Layout: Regular})
+	wp := NewPolynomial(randomVector(size), Form{Basis: Lagrange, Layout: Regular})
 
 	// checks the blinding is correct: the evaluation of the blinded polynomial
 	// should be the same as the original on d's domain
@@ -258,13 +257,13 @@ func fromLagrange(p *Polynomial, d *fft.Domain) *Polynomial {
 	}
 }
 
-func cmpCoefficents(p, q *fr.Vector) bool {
+func cmpCoefficents(p, q fr.Vector) bool {
 	if p.Len() != q.Len() {
 		return false
 	}
 	for i := 0; i < p.Len(); i++ {
-		if !((*p)[i].Equal(&(*q)[i])){
-			return false 
+		if !p[i].Equal(&q[i]) {
+			return false
 		}
 	}
 	return true
diff --git a/internal/generator/iop/template/quotient.go.tmpl b/internal/generator/iop/template/quotient.go.tmpl
index aacb3283e8..d8e0bc1e50 100644
--- a/internal/generator/iop/template/quotient.go.tmpl
+++ b/internal/generator/iop/template/quotient.go.tmpl
@@ -26,20 +26,19 @@ func DivideByXMinusOne(a *Polynomial, domains [2]*fft.Domain) (*Polynomial, erro
 	nbElmts := a.coefficients.Len()
 
 	coeffs := make([]fr.Element, a.coefficients.Len())
-	res := NewPolynomial(&coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
+	res := NewPolynomial(coeffs, Form{Layout: BitReverse, Basis: LagrangeCoset})
 	res.size = a.size
 	res.blindedSize = a.blindedSize
 
 	nn := uint64(64 - bits.TrailingZeros(uint(nbElmts)))
-	parallel.Execute(a.coefficients.Len(), func(start, end int){
+	parallel.Execute(a.coefficients.Len(), func(start, end int) {
 		for i := start; i < end; i++ {
 			iRev := bits.Reverse64(uint64(i)) >> nn
 			c := a.GetCoeff(i)
-			(*res.coefficients)[iRev].
+			res.coefficients[iRev].
 				Mul(&c, &xnMinusOneInverseLagrangeCoset[i%rho])
 		}
 	})
-	
 
 	res.ToCanonical(domains[1])
 
diff --git a/internal/generator/iop/template/quotient.test.go.tmpl b/internal/generator/iop/template/quotient.test.go.tmpl
index 8e3b3e2e4b..548b69b673 100644
--- a/internal/generator/iop/template/quotient.test.go.tmpl
+++ b/internal/generator/iop/template/quotient.test.go.tmpl
@@ -20,10 +20,9 @@ func computex3(x []fr.Element) fr.Element {
 
 func buildPoly(size int, form Form) *Polynomial {
 	v := make([]fr.Element, size)
-	return NewPolynomial(&v, form)
+	return NewPolynomial(v, form)
 }
 
-
 func TestDivideByXMinusOne(t *testing.T) {
 
 	f := func(x ...fr.Element) fr.Element {
@@ -123,4 +122,4 @@ func TestDivideByXMinusOne(t *testing.T) {
 	if !qx.Equal(&hx) {
 		t.Fatal("error computing quotient")
 	}
-}
\ No newline at end of file
+}
diff --git a/internal/generator/iop/template/ratios.go.tmpl b/internal/generator/iop/template/ratios.go.tmpl
index 2cc251509d..2e90b34ed7 100644
--- a/internal/generator/iop/template/ratios.go.tmpl
+++ b/internal/generator/iop/template/ratios.go.tmpl
@@ -34,7 +34,6 @@ var (
 // (Π_{k<j}Π_{i<m}(β-Pᵢ(ωᵏ)))/(β-Qᵢ(ωᵏ))
 func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Element, expectedForm Form, domain *fft.Domain) (*Polynomial, error) {
 
-
 	// check that len(numerator)=len(denominator)
 	if len(numerator) != len(denominator) {
 		return nil, ErrNumberPolynomials
@@ -109,7 +108,7 @@ func BuildRatioShuffledVectors(numerator, denominator []*Polynomial, beta fr.Ele
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
@@ -131,7 +130,6 @@ func BuildRatioCopyConstraint(
 	expectedForm Form,
 	domain *fft.Domain) (*Polynomial, error) {
 
-
 	nbPolynomials := len(entries)
 
 	// check that the sizes are consistent
@@ -163,40 +161,39 @@ func BuildRatioCopyConstraint(
 	coeffs[0].SetOne()
 	t[0].SetOne()
 
-	parallel.Execute(n-1, func(start, end int){
+	parallel.Execute(n-1, func(start, end int) {
 		var a, b, c, d fr.Element
 		nn := uint64(64 - bits.TrailingZeros(uint(n)))
 		for i := start; i < end; i++ {
 			b.SetOne()
 			d.SetOne()
-	
+
 			iRev := int(bits.Reverse64(uint64(i)) >> nn)
-	
+
 			for j, p := range entries {
 				idx := i
 				if p.Layout == BitReverse {
 					idx = iRev
 				}
-	
+
 				a.Mul(&beta, &evaluationIDSmallDomain[i+j*n]).
 					Add(&a, &gamma).
 					Add(&a, &p.Coefficients()[idx])
-	
+
 				b.Mul(&b, &a)
-	
+
 				c.Mul(&beta, &evaluationIDSmallDomain[permutation[i+j*n]]).
 					Add(&c, &gamma).
 					Add(&c, &p.Coefficients()[idx])
 				d.Mul(&d, &c)
 			}
-	
+
 			// b = Πⱼ(Pⱼ(ωⁱ)+β*ωⁱνʲ+γ)
 			// d = Πⱼ(Qⱼ(ωⁱ)+β*σ(j*n+i)+γ)
 			coeffs[i+1].Set(&b)
 			t[i+1].Set(&d)
 		}
 	})
-	
 
 	for i := 0; i < n-1; i++ {
 		coeffs[i+1].Mul(&coeffs[i+1], &coeffs[i])
@@ -208,7 +205,7 @@ func BuildRatioCopyConstraint(
 		coeffs[i].Mul(&coeffs[i], &t[i])
 	}
 
-	res := NewPolynomial(&coeffs, expectedForm)
+	res := NewPolynomial(coeffs, expectedForm)
 	// at this stage the result is in Lagrange form, Regular layout
 	putInExpectedForm(*res, domain, expectedForm)
 
diff --git a/internal/generator/iop/template/ratios.test.go.tmpl b/internal/generator/iop/template/ratios.test.go.tmpl
index 0b9fd46922..7e50d893ee 100644
--- a/internal/generator/iop/template/ratios.test.go.tmpl
+++ b/internal/generator/iop/template/ratios.test.go.tmpl
@@ -26,7 +26,7 @@ func getPermutedPolynomials(sizePolynomials, nbPolynomials int) ([]*Polynomial,
 
 	numerator := make([]*Polynomial, nbPolynomials)
 	for i := 0; i < nbPolynomials; i++ {
-		numerator[i] = NewPolynomial(randomVector(sizePolynomials), Form{Basis:Lagrange, Layout:Regular})
+		numerator[i] = NewPolynomial(randomVector(sizePolynomials), Form{Basis: Lagrange, Layout: Regular})
 	}
 
 	// get permutation
@@ -36,7 +36,7 @@ func getPermutedPolynomials(sizePolynomials, nbPolynomials int) ([]*Polynomial,
 	// concatenated
 	denominator := make([]*Polynomial, nbPolynomials)
 	for i := 0; i < nbPolynomials; i++ {
-		denominator[i] = NewPolynomial(randomVector(sizePolynomials), Form{Basis:Lagrange, Layout:Regular})
+		denominator[i] = NewPolynomial(randomVector(sizePolynomials), Form{Basis: Lagrange, Layout: Regular})
 	}
 	for i := 0; i < len(sigma); i++ {
 		id := int(sigma[i] / sizePolynomials)
@@ -181,7 +181,7 @@ func getInvariantEntriesUnderPermutation(sizePolynomials, nbPolynomials int) ([]
 	form := Form{Layout: Regular, Basis: Lagrange}
 	for i := 0; i < nbPolynomials; i++ {
 		v := make([]fr.Element, sizePolynomials)
-		res[i] = NewPolynomial(&v, form)
+		res[i] = NewPolynomial(v, form)
 		for j := 0; j < sizePolynomials/2; j++ {
 			res[i].Coefficients()[2*j].SetRandom()
 			res[i].Coefficients()[2*j+1].Set(&res[i].Coefficients()[2*j])