BubbleSort/BubbleSort1 电路能实现冒泡排序吗？会有什么安全隐患？

[readygo67]

pragma circom 2.1.4;

include "circomlib/comparators.circom";

template Swap(nBits){
    signal input in[2];
    signal output out[2];

    signal gt <== GreaterThan(nBits)([in[0], in[1]]);
    out[0] <== (in[1] - in[0])*gt + in[0];
    out[1] <== (in[0] - in[1])*gt + in[1];
}

template BubbleSort(n, nBits){
    signal input in[n];
    signal output out[n];
    signal tmp[n][n][n]; //[round][step][element]

    component swap[n-1][n-1];

    tmp[0][0][0] <== in[0];
    tmp[0][0][1] <== in[1];

    for (var j=2;j<n;j++){
        tmp[0][j-1][j] <== in[j]; 
    }

    // (i-1)round, the ith round has (n-i-1) step.
    for (var i=0; i<n-1;i++){
        for (var j=0;j < n -i -1;j++){   
            swap[i][j] = Swap(nBits);
            swap[i][j].in[0] <== tmp[i][j][j];
            swap[i][j].in[1] <== tmp[i][j][j+1];

            tmp[i][j+1][j] <== swap[i][j].out[0];
            tmp[i][j+1][j+1] <== swap[i][j].out[1];
        }
        
        //prepare data for the next round 
        tmp[i+1][0][0] <== tmp[i][1][0];
        for (var k=1;k< n-i-1;k++){
            tmp[i+1][k-1][k] <== tmp[i][k+1][k]; 
        }
    }
    
    //pickup output
    out[0] <== tmp[n-2][1][0];
    out[1] <== tmp[n-2][1][1];

    for (var i=2;i<=n-1;i++){
        out[i] <== tmp[n-1-i][i][i];
    }
}
//BubbleSort的tmp 是signal，只能被赋值一次，BubbleSort1的tmp是var，可以重复被赋值
template BubbleSort1(n, nBits){
    signal input in[n];
    signal output out[n];
    var tmp[n];  //

    component swap[n-1][n-1];

    for (var j=0;j<n;j++){
        tmp[j] = in[j]; 
        tmp[j] === in[j];
    }

    // (i-1)round, the ith round has (n-i-1) step.
    for (var i=0; i<n-1;i++){
        for (var j=0;j < n -i -1;j++){   
            swap[i][j]= Swap(nBits);
            swap[i][j].in[0] <== tmp[j];
            swap[i][j].in[1] <== tmp[j+1];

            tmp[j] = swap[i][j].out[0];
            tmp[j+1] = swap[i][j].out[1];

            tmp[j] === swap[i][j].out[0];
            tmp[j+1] === swap[i][j].out[1];
        }
    }

    for (var j=0;j<n;j++){
        out[j] <== tmp[j];
    }
}

component main = BubbleSort1(16, 252);

/* INPUT = {
    "in": ["9","16","7","25","4","3","34","1","0","5","100","20","200","1","18","8"]
} */

[wizicer]

这里是我写的版本，供参考：

include "node_modules/circomlib/circuits/comparators.circom";

template Compare() {
    signal input in[2];
    signal output out[2];
    component g = GreaterEqThan(20); // bits length

    g.in[0] <== in[0];
    g.in[1] <== in[1];

    g.out * (1 - g.out) === 0;

    out[0] <== (in[0] - in[1]) * g.out + in[1];
    out[1] <== (in[1] - in[0]) * g.out + in[0];
}

template BubbleSort(N) {
    signal input in[N];
    signal output out[N];

    component c[N][N + 1];

    for (var l = 0; l < N-1; l++){
        for (var j = 0; j < N-l-1; j++) {

            c[l][j] = Compare();
            if (j == 0) {
                if (l == 0) {
                    c[l][j].in[0] <== in[0];
                    c[l][j].in[1] <== in[1];
                } else {
                    c[l][j].in[0] <== c[l-1][j].out[0];
                    c[l][j].in[1] <== c[l-1][j+1].out[0];
                }
            } else {
                if (l == 0) {
                    c[l][j].in[0] <== c[0][j-1].out[1];
                    c[l][j].in[1] <== in[j+1];
                } else {
                    c[l][j].in[0] <== c[l][j-1].out[1];
                    c[l][j].in[1] <== c[l-1][j+1].out[0];
                }
            }
        }
    }

    for (var j = 1; j < N; j++){
        out[j] <== c[N-1-j][j-1].out[1];
    }

    out[0] <== c[N-2][0].out[0];
}

component main = BubbleSort(6);