if else

[infinite-pursuits]

Hi there,
I use the following code in my circuit.

temp_act_code := []frontend.Variable{}
var postrelu [24]frontend.Variable

if api.Cmp(biassum[i], 0) != -1 {
postrelu[i] = biassum[i]
temp_act_code = append(temp_act_code, 1)
} else {
postrelu[i] = 0
temp_act_code = append(temp_act_code, 0)
}

where biassum is a [24]frontend.Variable.

I thought if else statements are not allowed in circuits.. But the circuit complies and gets verified without error. How is that possible?

[ivokub]

Every circuit is a Go program. So, technically you may be able to define a circuit with if-clause, but the control flow may not be as you expect. In this case, you perform check api.Cmp(biassum[i], 0) != -1 which looking at it seems always to be false (api.Cmp returns an internal variable represented as uint64). So even if you have an if clause you always take the else path in the code.

A correct way to rewrite this code is approximately:

postrelu[i] = api.Select(biassum[i], biassum[i], 0)
temp_act_code[i] = api.Select(biassum[i], biassum[i], 1, 0)

[infinite-pursuits]

Hi Ivo, I changed my code to what you suggested

biassum := AddVecf(api, dotpdtvec, allbiases[hidden_layer])
postrelu[i] = api.Select(biassum[i], biassum[i], frontend.Variable(0))
temp_act_code[i] = api.Select(biassum[i], frontend.Variable(1), frontend.Variable(0))

The signature of AddVecf function is as follows :

func AddVecf(api frontend.API, v1 [24]frontend.Variable, v2 [24]frontend.Variable) [24]frontend.Variable

After adding api.Println statements, I see the following

Printing biassum:  {_0: -29, _1: 10, _2: 6, _3: -3, _4: 0, _5: 0, _6: 0, _7: 0, _8: 0, _9: 0, _10: 0, _11: 0, _12: 0, _13: 0, _14: 0, _15: 0, _16: 0, _17: 0, _18: 0, _19: 0, _20: 0, _21: 0, _22: 0, _23: 0}

Printing postrelu:  {_0: <unsolved>, _1: <unsolved>, _2: <unsolved>, _3: <unsolved>, _4: <unsolved>, _5: <unsolved>, _6: <unsolved>, _7: <unsolved>, _8: <unsolved>, _9: <unsolved>, _10: <unsolved>, _11: 0, _12: 0, _13: 0, _14: 0, _15: 0, _16: 0, _17: 0, _18: 0, _19: 0, _20: 0, _21: 0, _22: 0, _23: 0}

and type of biassum is expr.LinearExpression.

I am running a for loop three times. For the first 2, I see unsolved for all 0-23. but for the last one I see some unsolved and some zeros. Cannot figure out what is going wrong.

[ivokub]

It is difficult to understand this way. Maybe it is possible to construct a minimal circuit where this problem occurs and post here (with witness assignment and which backend you run)?

[infinite-pursuits]

type verifyactivationcode struct {
	Callweights        [3][24][24]frontend.Variable `gnark:"allweights"`
	Callbiases         [3][24]frontend.Variable     `gnark:"allbiases"`
	Cx                 [24]frontend.Variable        `gnark:"Cx"`
	Chidden_layer_size [3]frontend.Variable         `gnark:"chidden_layer_size"`
	Actcodearray       [3][24]frontend.Variable     `gnark:",public"`
}

func (circuit *verifyactivationcode) Define(api frontend.API) error {
	var x [24]frontend.Variable
	var allweights [3][24][24]frontend.Variable
	var allbiases [3][24]frontend.Variable
	var activation_code_array [3][24]frontend.Variable
	var tempinp [24]frontend.Variable

	allweights = circuit.Callweights
	allbiases = circuit.Callbiases
	x = circuit.Cx
	tempinp = x

	for hidden_layer := 0; hidden_layer < 3; hidden_layer++ {

		var temp_act_code [24]frontend.Variable
		var dotpdtvec [24]frontend.Variable
		var biassum [24]frontend.Variable
		var postrelu [24]frontend.Variable

		dotpdtvec = MulVecf(api, allweights[hidden_layer], tempinp)
		biassum = AddVecf(api, dotpdtvec, allbiases[hidden_layer])

		for i := 0; i < 24; i++ {

			postrelu[i] = api.Select(biassum[i], biassum[i], frontend.Variable(0))
			temp_act_code[i] = api.Select(biassum[i], frontend.Variable(1), frontend.Variable(0))

		}
		tempinp = postrelu
	}
	
	for i := 0; i < 3; i++ {
		for j := 0; j < 24; j++ {
			api.AssertIsEqual(circuit.Actcodearray[i][j], activation_code_array[i][j])
		}
	}
	api.Mul(circuit.Chidden_layer_size[0], circuit.Chidden_layer_size[1], circuit.Chidden_layer_size[2])
	return nil
}


func dotpdtf(api frontend.API, v1 [24]frontend.Variable, v2 [24]frontend.Variable) frontend.Variable {
	var tempsum frontend.Variable
	tempsum = 0
	l := len(v1)
	for i := 0; i < l; i++ {
		tempsum = api.Add(api.Mul(v1[i], v2[i]), tempsum)
	}
	return tempsum
}

func MulVecf(api frontend.API, matrix [24][24]frontend.Variable, v [24]frontend.Variable) [24]frontend.Variable {
	var dpdtvec [24]frontend.Variable
	for i, vec := range matrix {
		dpdtvec[i] = dotpdtf(api, vec, v)
	}
	return dpdtvec
}

func AddVecf(api frontend.API, v1 [24]frontend.Variable, v2 [24]frontend.Variable) [24]frontend.Variable {
	var sumvec [24]frontend.Variable
	for i := 0; i < len(v1); i++ {
		sumvec[i] = api.Add(v1[i], v2[i])
	}
	return sumvec
}

Here is the circuit. Please let me know if you see any bugs. As mentioned before, I am seeing some values as unresolved.