Array Indexing - How to safely access (set/get) a secret 2D array using a forloop?

[drakstik]

Basically, the code below in a define function for a circuit.
The final 3 lines are the important bit, I'm (a) iterating over y & x, and (b) accessing pixels at locations [newXFr.(int)][newYFr.(int)], to (c) set the individual RGB values.

Similarly, I'm accessing a 2D array at this line: currentPixel := oldImage.Pixels[x][y]
FYI "oldImage" and cropArea are both secret variables.

My question is: In general, or using this example, does it make sense in a circuit's define function to access a 2D array (i.e. the 2D array of pixels in this context) using a forloop like this? How would I go about setting/getting pixels in a 2D array, in an iterative manner? Thanks in advance!

    for y := 0; y < N; y++ {
	for x := 0; x < N; x++ {
	        xFr := frontend.Variable(x)
		yFr := frontend.Variable(y)

		currentPixel := oldImage.Pixels[x][y]

		inCropArea := InCropArea(api, xFr, yFr, cropArea)

		newXFr := api.Sub(xFr, cropArea.topLeft.X)
		newYFr := api.Sub(xFr, cropArea.topLeft.Y)

		inBounds := InBoundArea(api, newXFr, newYFr, imageBounds)

		newImage.Pixels[newXFr.(int)][newYFr.(int)].R = api.Select(inBounds, api.Select(inCropArea, currentPixel.R, blackPixel.R), blackPixel.R)
		newImage.Pixels[newXFr.(int)][newYFr.(int)].G = api.Select(inBounds, api.Select(inCropArea, currentPixel.G, blackPixel.G), blackPixel.G)
		newImage.Pixels[newXFr.(int)][newYFr.(int)].B = api.Select(inBounds, api.Select(inCropArea, currentPixel.B, blackPixel.B), blackPixel.B)
            }
    }

Here's some extra context, please let me know if you need more info about this:

const (
N = 16
)
type CropCircuit struct {
PublicKey eddsa.PublicKey gnark:",public"
ImageSignature eddsa.Signature gnark:",public" // Digital signature as eddsa.Signature
ImageBytes frontend.Variable // z_in as Big Endian
FrImage myImage.FrontendImage // z_in as a FrontendImage
CroppedImage_in myImage.FrontendImage // Cropped previous image as a FrontendImage
Params CropParams // Crop transformation parameters
}

type ImageArea struct {
topLeft FrLocation
bottomRight FrLocation
}

type FrLocation struct {
X frontend.Variable
Y frontend.Variable
}

// An image with frontend pixels
type FrontendImage struct {
Pixels [N][N]FrontendPixel
}

// Frontend pixels are made up of frontend.Variable instead of uint8.
// These pixels can be manipulated in a PCD circuit.
type FrontendPixel struct {
R frontend.Variable
G frontend.Variable
B frontend.Variable
}

[ivokub]

It does make sense! In your case it is simpler because you already define the size of the picture in the circuit definition Pixels [N][N]FrontendPixel where I assume N is a constant.

I haven't run your example, but for now it looks good to me. If there is a compile/solver error, then it would help if you have a full running example which I could try out.

[drakstik]

Thank you for the response. Really appreciate all your work.

I've tried running with this logic and I'm having issues generating the proving/verifying key.
My question is how do I turn a frontend.Variable into an int within the define function?

In the Define() function, I have a line that says newX := newXFr.(int).
Where newXFr is calculated using cropArea.
cropArea is populated from the circuit.Params, which is a secret field.
I want to change newXFr into an integer newX, so I can actually use it as an index to access a 2D array of pixels (i.e. an image).

I've updated my repo, so you should be able to run the main.go in https://github.com/drakstik/PhotoGnark. Here is the error you would get when generating the proving/verifying keys:

22:26:18 ERR parsing circuit error="interface conversion: frontend.Variable is expr.LinearExpression, not int\nfrontend.parseCircuit.func2\n\tcompile.go:118\nruntime.panicdottypeE\n\tiface.go:275\ntransformations.(*CropCircuit).CropFrontendImage\n\tcrop_transformation.go:120\ntransformations.(*CropCircuit).Define\n\tcrop_transformation.go:48\n" parse circuit: interface conversion: frontend.Variable is expr.LinearExpression, not int

The code I'm talking about can be found here: https://github.com/drakstik/PhotoGnark/blob/master/src/transformations/crop_transformation.go)
Here's a snippet of the code that I'm talking about, where you can find the specific line 120 newX := newXFr.(int):

// CropFrontendImage crops and translates the FrontendImage using frontend.API and Compiler.
func (circuit *CropCircuit) CropFrontendImage(api frontend.API) myImage.FrontendImage {
	// Create constants for comparison (0, 1 & N) using Compiler
	zero, _ := api.Compiler().ConstantValue(0)
	one, _ := api.Compiler().ConstantValue(1)
	N := frontend.Variable(circuit.Params.N)
	N_minus_one := api.Sub(N, one)
	blackPixel := myImage.FrontendPixel{R: zero, G: zero, B: zero}

	oldImage := circuit.FrImage         // The previous image
	newImage := myImage.FrontendImage{} // The new image, to be set to transformed pixels

	// Area to crop,
	// {(X0,Y0), (X1, Y1)}
	cropArea := Fr_SquareArea{
		topLeft:     Fr_Location{X: circuit.Params.X0, Y: circuit.Params.Y0},
		bottomRight: Fr_Location{X: circuit.Params.X1, Y: circuit.Params.Y1},
	}

	// Area to bound pixels in,
	// {(0,0), (N-1, N-1)}
	imageBounds := Fr_SquareArea{
		topLeft:     Fr_Location{X: zero, Y: zero},
		bottomRight: Fr_Location{X: N_minus_one, Y: N_minus_one},
	}

	// Iterate over the entire N x N matrix

	for y := 0; y < (myImage.N - 1); y++ {
		for x := 0; x < (myImage.N - 1); x++ {
			xFr := frontend.Variable(x)
			yFr := frontend.Variable(y)

			// any pixels outside area should return false
			inCropArea := InArea(api, xFr, yFr, cropArea)

			// Calculate the new location
			newXFr := api.Sub(xFr, cropArea.topLeft.X)
			newX := newXFr.(int)

			newYFr := api.Sub(xFr, cropArea.topLeft.Y)
			newY := newYFr.(int)

			// any pixels outisde area should return false
			inBounds := InArea(api, newXFr, newYFr, imageBounds)

			// Get the current pixel
			currentPixel := oldImage.Pixels[x][y]

			// This essentially translates to:
			// 		if inBoundArea(newX, newY):
			//			if inCropArea(currentX, currentY):
			//				SELECT currentPixel
			//			else: SELECT blackPixel
			//		else: SELECT blackPixel
			//
			//	Where CropArea{(X0, Y1), (X1, Y1)} and BoundArea{(0,0), (N-1, N-1)}
			newImage.Pixels[newX][newY].R = api.Select(
				inBounds,
				api.Select(
					inCropArea,
					currentPixel.R,
					blackPixel.R,
				),
				blackPixel.R,
			)
			newImage.Pixels[newXFr.(int)][newYFr.(int)].G = api.Select(
				inBounds,
				api.Select(
					inCropArea,
					currentPixel.G,
					blackPixel.G,
				),
				blackPixel.G,
			)
			newImage.Pixels[newXFr.(int)][newYFr.(int)].B = api.Select(
				inBounds,
				api.Select(
					inCropArea,
					currentPixel.B,
					blackPixel.B,
				),
				blackPixel.B,
			)
		}
	}

	// TODO: Metadata updates for width and height
	// Update metadata to reflect the new dimensions of the cropped area
	// img.M["width"] = cropWidth
	// img.M["height"] = cropHeight

	return newImage
}

[ivokub]

This is unfortunately directly not possible - the frontend.Variable is a variable in circuit which can take any value during proof creation time (depending on the witness provided to the solver). Thus, you cannot use it to index a Go slice (where the slice index needs to be an integer known at Go program run time).

Instead, you would need to use something which allows to perform lookups based on a frontend.Variable. Fortunately - gnark already has a lookup table implemented, see https://pkg.go.dev/github.com/consensys/[email protected]/std/lookup/logderivlookup#example-package. I think it should work.