mutourend

Polygon zkEVM中的常量多项式

1. 引言

具体见：

https://github.com/0xPolygonHermez/zkevm-proverjs/blob/main/pil/l

2. Global.pil中的常量多项式

Polygon zkEVM全局多项式Global.pil中包含3个constant多项式：

1）L1 constant多项式
2）BYTE constant多项式
3）BYTE2 constant多项式

namespace Global(%N);
pol constant L1;    // 1, 0, 0, 0, 0,
pol constant BYTE;
pol constant BYTE2;

这些全局constant多项式的基本赋值情况为：

module.exports.buildConstants = async function (pols) {

    const F = new F1Field("0xFFFFFFFF00000001");

    const N = pols.BYTE.length;
    buidBYTE(pols.BYTE, F, N);
    buidBYTE2(pols.BYTE2, F, N);
    buildL1(pols.L1, F, N);

};

function buidBYTE2(pol, F, N) {
    const m = 1<<16;
    if (N<m) throw new Error("GLOBAL.BYTE does not fit");
    for (let i=0; i<m; i++) {
        pol[i] = BigInt(i);
    }

    for (let i=m; i<N; i++) {
        pol[i] = 0n;
    }
}

function buidBYTE(pol, F, N) {
    if (N<256) throw new Error("GLOBAL.BYTE does not fit");

    for (let i=0; i<256; i++) {
        pol[i] = BigInt(i);
    }

    for (let i=256; i<N; i++) {
        pol[i] = 0n;
    }
}

function buildL1(pol, F, N) {
    pol[0] = 1n;
    for ( let i=1; i<N; i++) pol[i] = 0n;
}

以 $N=2^{31}$ 为例，这些全局常量多项式的具体赋值为：

index	L1	BYTE	BYTE2
0	1	0	0
1	0	1	1
2	0	2	2
3	0	3	3
$\vdots$	$\vdots$	$\vdots$	$\vdots$
254	0	254	254
255	0	255	255
256	0	0	256
257	0	0	257
$\vdots$	$\vdots$	$\vdots$	$\vdots$
$2^{16}-1$	0	0	$2^{16}-1$
$2^{16}$	0	0	0
$2^{16}+1$	0	0	0
$\vdots$	$\vdots$	$\vdots$	$\vdots$
$2^{21}-1$	0	0	0

3. main.pil中的常量多项式

main.pil中包含一个常量多项式STEP：【注意，在zkasm.js中，将STEP定义为只读寄存器。】

/// Constant Polynomials
pol constant STEP;  // 0, 1, 2, 3, .......

相应的赋值为：

module.exports = async function (pols) {

    const N = pols.STEP.length;

    for ( let i=0; i<N; i++) {
        pols.STEP[i] = BigInt(i);
    }
}

以 $N=2^{31}$ 为例，该常量多项式的具体赋值为：

index	STEP
0	0
1	1
2	2
3	3
$\vdots$	$\vdots$
$2^{21}-1$	$2^{21}-1$

4. rom.pil中的常量多项式

rom.pil中包含的常量多项式有：

namespace Rom(%N);

    pol constant CONST0;
    pol constant CONST1;
    pol constant CONST2;
    pol constant CONST3;
    pol constant CONST4;
    pol constant CONST5;
    pol constant CONST6;
    pol constant CONST7;
    pol constant offset;
    pol constant inA, inB, inC, inROTL_C, inD, inE, inSR, inFREE, inCTX, inSP, inPC, inGAS, inMAXMEM, inHASHPOS, inSTEP, inRR;
    pol constant setA, setB, setC, setD, setE, setSR, setCTX, setSP, setPC, setGAS, setMAXMEM, setHASHPOS, JMP, JMPN, JMPC, setRR;
    pol constant incStack, incCode;
    pol constant isStack;
    pol constant isCode;
    pol constant isMem;
    pol constant ind, indRR;
    pol constant useCTX;
    pol constant mOp, mWR;
    pol constant sWR, sRD;
    pol constant arith;
    pol constant arithEq0;
    pol constant arithEq1;
    pol constant arithEq2;
    pol constant arithEq3;
    pol constant memAlign, memAlignWR, memAlignWR8;
    pol constant hashK, hashKLen, hashKDigest;
    pol constant hashP, hashPLen, hashPDigest;
    pol constant bin;
    pol constant binOpcode;
    pol constant assert;

    pol constant line;

不过，rom.pil中的常量多项式的值不是固定的，而是根据zkasm编译出的json文件来设定：

module.exports.buildConstants = async function buildConstants(pols, rom) {

    const F = new F1Field("0xFFFFFFFF00000001");

    const N = pols.inA.length;

    const twoTo31 = Scalar.e(0x80000000);
    const maxInt = 2147483647;
    const minInt = -2147483648;
    const maxUInt = 0xFFFFFFFF;
    const minUInt = 0;

    if (rom.program.length>N) throw new Error("Rom is too big for this N");

    for (let i=0; i<rom.program.length; i++) {

        if (rom.program[i].CONST) {
            if (rom.program[i].CONSTL) throw new Error("Program mixed with long and short constants");
            pols.CONST0[i] = rom.program[i].CONST ? F.e(rom.program[i].CONST) : F.zero;
            pols.CONST1[i] = F.zero;
            pols.CONST2[i] = F.zero;
            pols.CONST3[i] = F.zero;
            pols.CONST4[i] = F.zero;
            pols.CONST5[i] = F.zero;
            pols.CONST6[i] = F.zero;
            pols.CONST7[i] = F.zero;
        } else if (rom.program[i].CONSTL) {
            [
                pols.CONST0[i],
                pols.CONST1[i],
                pols.CONST2[i],
                pols.CONST3[i],
                pols.CONST4[i],
                pols.CONST5[i],
                pols.CONST6[i],
                pols.CONST7[i],
            ] = scalar2fea(F, BigInt(rom.program[i].CONSTL));
        } else {
            pols.CONST0[i] = F.zero;
            pols.CONST1[i] = F.zero;
            pols.CONST2[i] = F.zero;
            pols.CONST3[i] = F.zero;
            pols.CONST4[i] = F.zero;
            pols.CONST5[i] = F.zero;
            pols.CONST6[i] = F.zero;
            pols.CONST7[i] = F.zero;
        }
        pols.offset[i] = rom.program[i].offset ? BigInt(rom.program[i].offset) : 0n;

        pols.inA[i] = rom.program[i].inA ? F.e(rom.program[i].inA) : F.zero;
        pols.inB[i] = rom.program[i].inB ? F.e(rom.program[i].inB) : F.zero;
        pols.inC[i] = rom.program[i].inC ? F.e(rom.program[i].inC) : F.zero;
        pols.inD[i] = rom.program[i].inD ? F.e(rom.program[i].inD) : F.zero;
        pols.inE[i] = rom.program[i].inE ? F.e(rom.program[i].inE) : F.zero;
        pols.inSR[i] = rom.program[i].inSR ? F.e(rom.program[i].inSR) : F.zero;
        pols.inCTX[i] = rom.program[i].inCTX ? F.e(rom.program[i].inCTX) : F.zero;
        pols.inSP[i] = rom.program[i].inSP ? F.e(rom.program[i].inSP) : F.zero;
        pols.inPC[i] = rom.program[i].inPC ? F.e(rom.program[i].inPC) : F.zero;
        pols.inMAXMEM[i] = rom.program[i].inMAXMEM ? F.e(rom.program[i].inMAXMEM) : F.zero;
        pols.inSTEP[i] = rom.program[i].inSTEP ? F.e(rom.program[i].inSTEP) : F.zero;
        pols.inFREE[i] = rom.program[i].inFREE ? F.e(rom.program[i].inFREE) : F.zero;
        pols.inGAS[i] = rom.program[i].inGAS ? F.e(rom.program[i].inGAS) : F.zero;
        pols.inRR[i] = rom.program[i].inRR ? F.e(rom.program[i].inRR) : F.zero;
        pols.inHASHPOS[i] = rom.program[i].inHASHPOS ? F.e(rom.program[i].inHASHPOS) : F.zero;
        pols.inROTL_C[i] = rom.program[i].inROTL_C ? F.e(rom.program[i].inROTL_C) : F.zero;

        pols.setA[i] = rom.program[i].setA ? 1n : 0n;
        pols.setB[i] = rom.program[i].setB ? 1n : 0n;
        pols.setC[i] = rom.program[i].setC ? 1n : 0n;
        pols.setD[i] = rom.program[i].setD ? 1n : 0n;
        pols.setE[i] = rom.program[i].setE ? 1n : 0n;
        pols.setSR[i] = rom.program[i].setSR ? 1n : 0n;
        pols.setCTX[i] = rom.program[i].setCTX ? 1n : 0n;
        pols.setSP[i] = rom.program[i].setSP ? 1n : 0n;
        pols.setPC[i] = rom.program[i].setPC ? 1n : 0n;
        pols.setGAS[i] = rom.program[i].setGAS ? 1n : 0n;
        pols.setMAXMEM[i] = rom.program[i].setMAXMEM ? 1n : 0n;
        pols.setRR[i] = rom.program[i].setRR ? 1n : 0n;
        pols.setHASHPOS[i] = rom.program[i].setHASHPOS ? 1n : 0n;

        pols.JMP[i] = rom.program[i].JMP ? 1n : 0n;
        pols.JMPC[i] = rom.program[i].JMPC ? 1n : 0n;
        pols.JMPN[i] = rom.program[i].JMPN ? 1n : 0n;

        pols.incStack[i] = rom.program[i].incStack ? BigInt(rom.program[i].incStack) : 0n;
        pols.incCode[i] = rom.program[i].incCode ? BigInt(rom.program[i].incCode) : 0n;

        pols.isStack[i] = rom.program[i].isStack ? 1n : 0n;
        pols.isCode[i] = rom.program[i].isCode ? 1n : 0n;
        pols.isMem[i] = rom.program[i].isMem ? 1n : 0n;
        pols.ind[i] = rom.program[i].ind ? 1n : 0n;
        pols.indRR[i] = rom.program[i].indRR ? 1n : 0n;
        pols.useCTX[i] = rom.program[i].useCTX ? 1n : 0n;

        pols.mOp[i] = rom.program[i].mOp ? 1n : 0n;
        pols.mWR[i] = rom.program[i].mWR ? 1n : 0n;
        pols.sRD[i] = rom.program[i].sRD ? 1n : 0n;
        pols.sWR[i] = rom.program[i].sWR ? 1n : 0n;
        pols.arith[i] = rom.program[i].arith ? 1n : 0n;
        pols.arithEq0[i] = rom.program[i].arithEq0 ? 1n : 0n;
        pols.arithEq1[i] = rom.program[i].arithEq1 ? 1n : 0n;
        pols.arithEq2[i] = rom.program[i].arithEq2 ? 1n : 0n;
        pols.arithEq3[i] = rom.program[i].arithEq3 ? 1n : 0n;
        pols.memAlign[i] = rom.program[i].memAlign ? 1n : 0n;
        pols.memAlignWR[i] = rom.program[i].memAlignWR ? 1n : 0n;
        pols.memAlignWR8[i] = rom.program[i].memAlignWR8 ? 1n : 0n;
        pols.hashK[i] = rom.program[i].hashK ? 1n : 0n;
        pols.hashKLen[i] = rom.program[i].hashKLen ? 1n : 0n;
        pols.hashKDigest[i] = rom.program[i].hashKDigest ? 1n : 0n;
        pols.hashP[i] = rom.program[i].hashP ? 1n : 0n;
        pols.hashPLen[i] = rom.program[i].hashPLen ? 1n : 0n;
        pols.hashPDigest[i] = rom.program[i].hashPDigest ? 1n : 0n;
        pols.bin[i] = rom.program[i].bin ? 1n : 0n;
        pols.binOpcode[i] = rom.program[i].binOpcode ? BigInt(rom.program[i].binOpcode) : 0n;
        pols.assert[i] = rom.program[i].assert ? 1n : 0n;


        pols.line[i] = BigInt(i);

    }

    for (let i= rom.program.length; i<N; i++) {
        pols.CONST0[i] = F.zero;
        pols.CONST1[i] = F.zero;
        pols.CONST2[i] = F.zero;
        pols.CONST3[i] = F.zero;
        pols.CONST4[i] = F.zero;
        pols.CONST5[i] = F.zero;
        pols.CONST6[i] = F.zero;
        pols.CONST7[i] = F.zero;
        pols.offset[i] = F.zero;

        pols.inA[i] = F.zero;
        pols.inB[i] = F.zero;
        pols.inC[i] = F.zero;
        pols.inD[i] = F.zero;
        pols.inE[i] = F.zero;
        pols.inSR[i] = F.zero;
        pols.inCTX[i] = F.zero;
        pols.inSP[i] = F.zero;
        pols.inPC[i] = F.zero;
        pols.inMAXMEM[i] = F.zero;
        pols.inSTEP[i] = F.zero;
        pols.inFREE[i] = F.zero;
        pols.inGAS[i] = F.zero;
        pols.inRR[i] = F.zero;
        pols.inHASHPOS[i] = F.zero;
        pols.inROTL_C[i] = F.zero;

        pols.setA[i] = F.zero;
        pols.setB[i] = F.zero;
        pols.setC[i] = F.zero;
        pols.setD[i] = F.zero;
        pols.setE[i] = F.zero;
        pols.setSR[i] = F.zero;
        pols.setCTX[i] = F.zero;
        pols.setSP[i] = F.zero;
        pols.setPC[i] = F.zero;
        pols.setGAS[i] = F.zero;
        pols.setMAXMEM[i] = F.zero;
        pols.setRR[i] = F.zero;
        pols.setHASHPOS[i] = F.zero;

        pols.JMP[i] = F.zero;
        pols.JMPC[i] = F.zero;
        pols.JMPN[i] = F.zero;

        pols.incStack[i] = F.zero;
        pols.incCode[i] = F.zero;

        pols.isStack[i] = F.zero;
        pols.isCode[i] = F.zero;
        pols.isMem[i] = F.zero;
        pols.ind[i] = F.zero;
        pols.indRR[i] = F.zero;
        pols.useCTX[i] = F.zero;

        pols.mOp[i] = F.zero;
        pols.mWR[i] = F.zero;
        pols.sRD[i] = F.zero;
        pols.sWR[i] = F.zero;
        pols.arith[i] = F.zero;
        pols.arithEq0[i] = F.zero;
        pols.arithEq1[i] = F.zero;
        pols.arithEq2[i] = F.zero;
        pols.arithEq3[i] = F.zero;
        pols.memAlign[i] = F.zero;
        pols.memAlignWR[i] = F.zero;
        pols.memAlignWR8[i] = F.zero;
        pols.hashK[i] = F.zero;
        pols.hashKLen[i] = F.zero;
        pols.hashKDigest[i] = F.zero;
        pols.hashP[i] = F.zero;
        pols.hashPLen[i] = F.zero;
        pols.hashPDigest[i] = F.zero;
        pols.bin[i] = F.zero;
        pols.binOpcode[i] = F.zero;
        pols.assert[i] = F.zero;

        pols.line[i] = BigInt(i);
    }

}

4.1 以arith.zkasm示例对应的rom常量多项式

以zkevm-proverjs/test/zkasm/counters/arith.zkasm为例：

start:

        STEP => A
        0 :ASSERT

        0 => A
        CNT_ARITH :ASSERT
        CNT_BINARY :ASSERT
        CNT_KECCAK_F: ASSERT
        CNT_MEM_ALIGN :ASSERT
        CNT_POSEIDON_G :ASSERT
        CNT_PADDING_PG :ASSERT

        0 => A,B,C,D    :ARITH

        CNT_ARITH => A
        1               :ASSERT

        CNT_ARITH => A
        1               :ASSERT

        0x2000000000000000000000000000000000000000000000000000000000000001n => A
        0x100    => B
        0x73     => C
        0x20    => D
        0x173   :ARITH


        2 => A
        CNT_ARITH :ASSERT

        0 => A
        CNT_KECCAK_F: ASSERT
        CNT_MEM_ALIGN :ASSERT
        CNT_POSEIDON_G :ASSERT
        CNT_PADDING_PG :ASSERT

end:
       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR

finalWait:
        ${beforeLast()}  : JMPN(finalWait)

                         : JMP(start)
opINVALID:

经const rom = await zkasm.compile(path.join(__dirname, "zkasm", zkasmFile)); zkasmcom 编译后的结果为：

{
 "program": [
  {
   "inSTEP": "1",
   "setA": 1,
   "line": 3,
   "fileName": "arith.zkasm",
   "lineStr": "        STEP => A"
  },
  {
   "CONST": "0",
   "assert": 1,
   "line": 4,
   "fileName": "arith.zkasm",
   "lineStr": "        0 :ASSERT"
  },
  {
   "CONST": "0",
   "setA": 1,
   "line": 6,
   "fileName": "arith.zkasm",
   "lineStr": "        0 => A"
  },
  {
   "inCntArith": "1",
   "assert": 1,
   "line": 7,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_ARITH :ASSERT"
  },
  {
   "inCntBinary": "1",
   "assert": 1,
   "line": 8,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_BINARY :ASSERT"
  },
  {
   "inCntKeccakF": "1",
   "assert": 1,
   "line": 9,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_KECCAK_F: ASSERT"
  },
  {
   "inCntMemAlign": "1",
   "assert": 1,
   "line": 10,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_MEM_ALIGN :ASSERT"
  },
  {
   "inCntPoseidonG": "1",
   "assert": 1,
   "line": 11,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_POSEIDON_G :ASSERT"
  },
  {
   "inCntPaddingPG": "1",
   "assert": 1,
   "line": 12,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_PADDING_PG :ASSERT"
  },
  {
   "CONST": "0",
   "setA": 1,
   "setB": 1,
   "setC": 1,
   "setD": 1,
   "arith": 1,
   "arithEq0": 1,
   "line": 14,
   "fileName": "arith.zkasm",
   "lineStr": "        0 => A,B,C,D    :ARITH"
  },
  {
   "inCntArith": "1",
   "setA": 1,
   "line": 16,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_ARITH => A"
  },
  {
   "CONST": "1",
   "assert": 1,
   "line": 17,
   "fileName": "arith.zkasm",
   "lineStr": "        1               :ASSERT"
  },
  {
   "inCntArith": "1",
   "setA": 1,
   "line": 19,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_ARITH => A"
  },
  {
   "CONST": "1",
   "assert": 1,
   "line": 20,
   "fileName": "arith.zkasm",
   "lineStr": "        1               :ASSERT"
  },
  {
  # CONSTL为0x2000000000000000000000000000000000000000000000000000000000000001n，以8个寄存器CONST0~CONST7表示，对应CONST7值为0x20000000=536870912,CONST0=1。
   "CONSTL": "14474011154664524427946373126085988481658748083205070504932198000989141204993",
   "setA": 1,
   "line": 22,
   "fileName": "arith.zkasm",
   "lineStr": "        0x2000000000000000000000000000000000000000000000000000000000000001n => A"
  },
  {
   "CONST": "256",
   "setB": 1,
   "line": 23,
   "fileName": "arith.zkasm",
   "lineStr": "        0x100    => B"
  },
  {
   "CONST": "115",
   "setC": 1,
   "line": 24,
   "fileName": "arith.zkasm",
   "lineStr": "        0x73     => C"
  },
  {
   "CONST": "32",
   "setD": 1,
   "line": 25,
   "fileName": "arith.zkasm",
   "lineStr": "        0x20    => D"
  },
  {
   "CONST": "371",
   "arith": 1,
   "arithEq0": 1,
   "line": 26,
   "fileName": "arith.zkasm",
   "lineStr": "        0x173   :ARITH"
  },
  {
   "CONST": "2",
   "setA": 1,
   "line": 29,
   "fileName": "arith.zkasm",
   "lineStr": "        2 => A"
  },
  {
   "inCntArith": "1",
   "assert": 1,
   "line": 30,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_ARITH :ASSERT"
  },
  {
   "CONST": "0",
   "setA": 1,
   "line": 32,
   "fileName": "arith.zkasm",
   "lineStr": "        0 => A"
  },
  {
   "inCntKeccakF": "1",
   "assert": 1,
   "line": 33,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_KECCAK_F: ASSERT"
  },
  {
   "inCntMemAlign": "1",
   "assert": 1,
   "line": 34,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_MEM_ALIGN :ASSERT"
  },
  {
   "inCntPoseidonG": "1",
   "assert": 1,
   "line": 35,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_POSEIDON_G :ASSERT"
  },
  {
   "inCntPaddingPG": "1",
   "assert": 1,
   "line": 36,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_PADDING_PG :ASSERT"
  },
  {
   "CONST": "0",
   "setA": 1,
   "setB": 1,
   "setC": 1,
   "setD": 1,
   "setE": 1,
   "setCTX": 1,
   "setSP": 1,
   "setPC": 1,
   "setGAS": 1,
   "setMAXMEM": 1,
   "setSR": 1,
   "line": 39,
   "fileName": "arith.zkasm",
   "lineStr": "       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR"
  },
  {
   "freeInTag": {
    "op": "functionCall",
    "funcName": "beforeLast",
    "params": []
   },
   "inFREE": "1",
   "JMPC": 0,
   "JMPN": 1,
   "offset": 27,
   "line": 42,
   "offsetLabel": "finalWait",
   "fileName": "arith.zkasm",
   "lineStr": "        ${beforeLast()}  : JMPN(finalWait)"
  },
  {
   "JMP": 1,
   "JMPC": 0,
   "JMPN": 0,
   "offset": 0,
   "line": 44,
   "offsetLabel": "start",
   "fileName": "arith.zkasm",
   "lineStr": "                         : JMP(start)"
  }
 ],
 "labels": {
  "start": 0,
  "end": 26,
  "finalWait": 27,
  "opINVALID": 29
 }
}

对应的各常量多项式的赋值为：

index	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	offset	incStack	incCode	isStack	isCode	isMem	ind	indPR	useCTX	mOp	mWR	sWR	sRD	arith	arithEq0	arithEq1	arithEq2	arithEq3	memAlign	memAlignWR	memAlignWR8	hashK	hashKLen	hashDigest	hashP	hashPLen	hashPDigest	bin	binOpcode	assert	line	inA	inB	inC	inROTL_C	inD	inE	inSR	inFREE	inCTX	inSP	inPC	inGAS	inMAXMEM	inHASHPOS	inSTEP	inPR	setA	setB	setC	setD	setE	setSR	setCTX	setSP	setPC	setGAS	setMAXMEM	setHASHPOS	JMP	JMPN	JMPC	setPR
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	2	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	3	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
4	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	4	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
5	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	5	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
6	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	6	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
7	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	7	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
8	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	8	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
9	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	9	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1	0	0	0	0	0	0	0	0	0	0	0	0
10	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	10	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
11	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	11	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
12	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	12	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
13	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	13	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
14	1	0	0	0	0	0	0	536870912	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	14	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
15	256	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	15	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0
16	115	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	16	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0
17	32	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	17	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0
18	371	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	18	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
19	2	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	19	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
20	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	20	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
21	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	21	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
22	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	22	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
23	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	23	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
24	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	24	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
25	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	25	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
26	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	26	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1	1	1	1	1	1	1	1	0	0	0	0	0
27	0	0	0	0	0	0	0	0	27	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	27	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0
28	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	28	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0
29	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	29	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$
$2^{21}-1$	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	$2^{21}-1$	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0

5. byte4.pil中的常量多项式

byte4.pil主要用于构建任意32-bit（4字节）数字，其具有常量多项式SET——奇数行为1，偶数行为0。

/*
This state machine is able to builds any number of 4 bytes (32 bits)


Example for building numbers: 0x00030007, 0x12345678, 0x00050009 and 0
        SET     freeIN  out        out'
w^0     1       3       0          3
w^1     0       7       3          0x00030007
w^2     1       0x1234  0x00030007 0x1234
w^3     0       0x5678  0x1234     0x12345678
w^4     1       5       0x12345678 5
w^5     0       9       5          0x50009
w^6     1       0       0x50009    0
w^7     0       0       0          0

*/

include "global.pil";

namespace Byte4(%N);
    /// Constant Polynomials
    pol constant SET;    // 1, 0, 1, 0, 1, 0 ......

    /// State Polynomials
    pol commit freeIN;
    pol commit out;

    freeIN in Global.BYTE2;  // 0, 1, 2,       , 65535

    out' = SET*freeIN +
           (1-SET)*(out * 2**16 + freeIN);

6. padding_kk.pil中的常量多项式

padding_kk.pil中的常量多项式有：

	/* Read Data output
        crLatch * crValid {addr, crOffset - crLen -1, crLen, crV0C, crV1C, crV2C, crV3C, crV4C, crV5C, crV6C, crV7C}
    */

    /* Read Len output
        lastHashLatch {addr, len}
    */

    /* Read Len digest
        lastHashLatch { addr, hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7 }
    */

namespace PaddingKK(%N);

    // Polynomials that are used to compute a hash chunk
    pol constant r8Id;
	
	pol constant lastBlock;
    pol constant lastBlockLatch;
    pol constant r8valid;
	
	pol constant sOutId;
	
	pol constant forceLastHash;
	
	pol constant k_crOffset, k_crF0, k_crF1, k_crF2, k_crF3, k_crF4, k_crF5, k_crF6, k_crF7;
	
	pol constant crValid;

具体的赋值逻辑为：

const BYTESPERBLOCK = 136;
const BlockSize = 158418;

module.exports.buildConstants = async function (pols) {
    const poseidon = await buildPoseidon();
    const F = poseidon.F;

    const N = pols.lastBlock.length;

    const nBlocks = 9*Math.floor((N-1)/BlockSize);

    let p =0;

    pols.k_crF = [];
    for (let i=0; i<8; i++) {
        pols.k_crF[i] = pols[`k_crF${i}`];
    }

    for (let i=0; i<nBlocks; i++) {
        const bytesBlock = 136;
        for (let j=0; j<bytesBlock; j++) {
            pols.lastBlock[p] = (j == bytesBlock-1) ? 1n : 0n;
            pols.lastBlockLatch[p] = (j == bytesBlock-1) ? 1n : 0n;
            pols.crValid[p] = F.one;
            pols.r8Id[p] = F.e(p);
            pols.sOutId[p] =  (j == bytesBlock-1) ? F.e(i) : F.zero;
            pols.forceLastHash[p] = ((j == bytesBlock-1)&&(i==nBlocks-1)) ? F.one : F.zero;
            pols.r8valid[p] = F.one;
            p += 1;
        }
    }

    for (let i=p; i<N; i++) {
        pols.crValid[i] = F.zero;
        pols.r8Id[i] = F.zero;    // Must repeat the first byte
        pols.lastBlock[i] = i<N-1 ? F.zero : F.one;
        pols.lastBlockLatch[i] = F.zero;
        pols.sOutId[i] =  F.zero;
        pols.forceLastHash[i] = i==N-1 ? F.one : F.zero;
        pols.r8valid[i] = F.zero;
    }

    for (let i=0; i<32; i++) {
        pols.k_crOffset[i] = BigInt(i);
        const acci = Math.floor(i / 4);
        const sh = BigInt((i % 4)*8);
        for (let k=0; k<8; k++) {
            pols.k_crF[k][i] = (k == acci) ? BigInt(1n << sh) : 0n;
        }
    }

    for (let i=32; i<N; i++) {
        pols.k_crOffset[i] = pols.k_crOffset[0];
        for (let k=0; k<8; k++) {
            pols.k_crF[k][i] =  pols.k_crF[k][0]
        }
    }

}

7. arith.pil中的常量多项式

arith.pil中的常量多项式有：

namespace Arith(%N);

    pol constant BYTE2_BIT19;
    pol constant SEL_BYTE2_BIT19;
    pol constant GL_SIGNED_4BITS_C0;
    pol constant GL_SIGNED_4BITS_C1;
    pol constant GL_SIGNED_4BITS_C2;
    pol constant GL_SIGNED_18BITS;
    pol constant CLK[32];      // 1 if CLK==0 and 0 if CLK!=0

相应的赋值逻辑为：

module.exports.buildConstants = async function (pols) {
    const N = pols.CLK[0].length;

    buildClocks(pols, N, 32);
    buildByte2Bits16(pols, N);
    buildRange(pols, N, 'GL_SIGNED_4BITS_C0', -16n, 16n);
    buildRange(pols, N, 'GL_SIGNED_4BITS_C1', -16n, 16n, 33);
    buildRange(pols, N, 'GL_SIGNED_4BITS_C2', -16n, 16n, 33*33);
    buildRange(pols, N, 'GL_SIGNED_18BITS', -(2n**18n), (2n**18n));
}

function buildByte2Bits16(pols, N) {
    const modB1 = (2 ** 16);
    const modB2 = (2 ** 19);
    const modBase = modB1 + modB2
    for (let i = 0; i < N; i++) {
        const value = i % modBase;
        pols.SEL_BYTE2_BIT19[i] = (i < modB1 ? 0n:1n);
        pols.BYTE2_BIT19[i] = BigInt(value);
    }
}

function buildClocks(pols, N, clocksByCycle) {
    for (let i = 0; i < clocksByCycle; i++) {
        for (let j = 0; j < N; ++j) {
            pols.CLK[i][j] = ((j + (clocksByCycle - i)) % clocksByCycle) == 0 ? 1n : 0n;
        }
    }
}

function buildRange(pols, N, name, fromValue, toValue, steps = 1) {
    let value = fromValue;
    let csteps = steps;
    for (let i = 0; i < N; i++) {
        pols[name][i] = value;
        csteps -= 1;
        if (csteps <= 0) {
            csteps = steps;
            if (value === toValue) value = fromValue;
            else value += 1n;
        }
    }
}

其中CLK[0]~CLK[31]常量多项式的赋值为：【对角线值为1，以32行为一个周期，循环重复】

index	CLK[0]	CLK[1]	CLK[2]	$\cdots$	CLK[31]
0	1	0	0	$\cdots$	0
1	0	1	0	$\cdots$	0
2	0	0	1	$\cdots$	0
$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$
31	0	0	0	$\cdots$	1
32	1	0	0	$\cdots$	0
33	0	1	0	$\cdots$	0
34	0	0	1	$\cdots$	0
$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$
63	0	0	0	$\cdots$	1
$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$

SEL_BYTE2_BIT19常量多项式的取值为：

当 $i<2^{16}$ ，SEL_BYTE2_BIT19 $[i]$ =0；
当 $i\geq 2^{16}$ ，SEL_BYTE2_BIT19 $[i]$ =1。

BYTE2_BIT19常量多项式的取值为：

BYTE2_BIT19 $i]=i\ \% \ (2^{16}+2^{19})$ 。

GL_SIGNED_4BITS_C0常量多项式的取值为：buildRange(pols, N, 'GL_SIGNED_4BITS_C0', -16n, 16n);

依次赋值： $-16,-15,-14,-13,\cdots,-1,0,1,2,\cdots,15, 16$ ，不断重复该赋值。

GL_SIGNED_4BITS_C1常量多项式的取值为：buildRange(pols, N, 'GL_SIGNED_4BITS_C1', -16n, 16n, 33);

依次赋值：33个 $- 16$ ，33个 $- 15$ ，……，33个 $0$ ，……，33个 $15$ ，33个 $16$ 。这 $33 * 33$ 个数之后，重复该赋值。

GL_SIGNED_4BITS_C2常量多项式的取值为：buildRange(pols, N, 'GL_SIGNED_4BITS_C2', -16n, 16n, 33*33);

依次赋值： $33 * 33$ 个 $- 16$ ， $33 * 33$ 个 $- 15$ ，……， $33 * 33$ 个 $0$ ，……， $33 * 33$ 个 $15$ ， $33 * 33$ 个 $16$ 。这 $33 * 33 * 33$ 个数之后，重复该赋值。

GL_SIGNED_18BITS常量多项式的取值为：buildRange(pols, N, 'GL_SIGNED_18BITS', -(2n**18n), (2n**18n));

依次赋值： $-2^{18},-2^{18}+1,-2^{18}+2,-2^{18}+3,\cdots,-1,0,1,2,\cdots,2^{18}-1,2^{18}$ ，不断重复该赋值。

8. binary.pil中的常量多项式

binary.pil中的常量多项式有：

	//  ##############################################################
    //  CONSTANT POLINOMIALS
    //  ##############################################################
    //  Plockup polinomials
    //  ==============================================================
    //  ==== IN ====
    //  P_OPCODE    (3  bits) Operation code
    //  P_CIN       (1  bits) Carry in
    //  P_LAST      (1  bits) Last byte
    //  P_A         (8  bits) Input A
    //  P_B         (8  bits) Input B
    //  ==== OUT ======
    //  P_C         (8 bits) Output C
    //  P_COUT      (1  bits) Carry out
    //  P_USE_CARRY (1  bits) Carry out
    //  ==== TOTAL ====
    //  3 + 1 + 1 + 8 + 8 = 21 bits
    //  ==============================================================
    //  NAME    | 0 | 1 | 2 | 3 | ... | 32 |
    //  ==============================================================
    //  RESET   | 1 | 0 | 0 | 0 | ... |  1 |
    //  FACTOR0 | 0x1 | 0x100 | 0x10000 | 0x1000000 | 0x0 | 0x0   | ... | 0x0 | 0x0   | 0x0     | 0x0       |
    //  FACTOR1 | 0x0 | 0x0   | 0x0     | 0x0       | 0x1 | 0x100 | ... | 0x0 | 0x0   | 0x0     | 0x0       |
    //  ...
    //  FACTOR7 | 0x0 | 0x0   | 0x0     | 0x0       | 0x0 | 0x0   | ... | 0x1 | 0x100 | 0x10000 | 0x1000000 |
    pol constant P_OPCODE, P_A, P_B, P_CIN, P_LAST, P_USE_CARRY;
    pol constant P_C, P_COUT;

    pol constant RESET;
    pol constant FACTOR[8];

Polygon zkEVM的Binary状态机中的运算是基于byte运行的，每个256-bit数字需以8个32-bit（4-byte）寄存器来表示。【let REGISTERS_NUM = 8; let BYTES_PER_REGISTER = 4;】
每32 cycle结束时，通过RESET寄存器来重置寄存器值，并使用FACTOR寄存器来进行正确更新，如：a0' = a0 * (1 - RESET) + freeInA * FACTOR[0];。
FACTOR[0]-FACTOR[7]常量多项式赋值为：

/*  =========
    FACTORS
    =========
    FACTOR0 => 0x1  0x100   0x10000 0x01000000  0x0  0x0    0x0     0x0         ... 0x0  0x0    0x0     0x0         0x1 0x100   0x10000 0x01000000  0x0  ...
    FACTOR1 => 0x0  0x0     0x0     0x0         0x1  0x100  0x10000 0x01000000  ... 0x0  0x0    0x0     0x0         0x0 0x0     0x0     0x0         0x0  ...
    ...
    FACTOR7 => 0x0  0x0     0x0     0x0         0x0  0x0     0x0     0x0        ... 0x1  0x100  0x10000 0x01000000  0x0 0x0     0x0     0x0         0x0  ...
*/

RESET常量多项式的赋值为：【第0、255、511……n*256-1 位置处的值为1，其它位置均为0】

/*  =========
    RESET
    =========
    1 0 0 ... { REGISTERS_NUM * BYTES_PER_REGISTER } ... 0 1 0 ... { REGISTERS_NUM * BYTES_PER_REGISTER } 0
    1 0 0 ... { REGISTERS_NUM * BYTES_PER_REGISTER } ... 0 1 0 ... { REGISTERS_NUM * BYTES_PER_REGISTER } 0
    ...
    1 0 0 ... { REGISTERS_NUM * BYTES_PER_REGISTER } ... 0 1 0 ... { REGISTERS_NUM * BYTES_PER_REGISTER } 0
*/

P_A常量多项式赋值为：【 $2^8*2^8$ 个0， $2^8*2^8$ 个1，……， $2^8*2^8$ 个15；然后一共重复该过程 $N/(2^8*2^8)$ 次。】

/*  ============
    A
    =========
    0 .. {size} .. 0 1 .. {size} .. 1 ... {size} ... 15 ... {size} ... 15 (size * size)
    0 .. {size} .. 0 1 .. {size} .. 1 ... {size} ... 15 ... {size} ... 15
    ...
    0 .. {size} .. 0 1 .. {size} .. 1 ... {size} ... 15 ... {size} ... 15
*/

P_B常量多项式赋值为：【0-15，重复 $2^8$ 次；再重复 $N/(2^8*2^8)$ 次。】

/*  =========
    B
    =========
    0 1 2 .. {size} .. 15 0 1 2 .. {size} .. 15 0 1 2 .. {size} .. 15 0 1 2 ... {size} ... 15 (size * size)
    0 1 2 .. {size} .. 15 0 1 2 .. {size} .. 15 0 1 2 .. {size} .. 15 0 1 2 ... {size} ... 15 (size * size)
    ...
    0 1 2 .. {size} .. 15 0 1 2 .. {size} .. 15 0 1 2 .. {size} .. 15 0 1 2 ... {size} ... 15 (size * size)
 */

P_CIN常量多项式赋值为：【 $2^8*2^8$ 个0， $2^8*2^8$ 个1；重复该过程 $N/(2*2^8*2^8)$ 次。】

/*
    =========
    CIN
    =========
    0 0 0 ... {AccumulatedSize} ... 0 0 0 1 1 1 ... {AccumulatedSize} ... 1 1 1
    0 0 0 ... {AccumulatedSize} ... 0 0 0 1 1 1 ... {AccumulatedSize} ... 1 1 1
    ...
    0 0 0 ... {AccumulatedSize} ... 0 0 0 1 1 1 ... {AccumulatedSize} ... 1 1 1
 */

P_OPCODE常量多项式赋值为：【其中current_size为 $2^8*2^8*2^1*2^1$ 】

/*
    =========
    OPCODE
    =========
    0 0 0 ... {current_size} ... 0 0 0
    1 1 1 ... {current_size} ... 1 1 1
    2 2 2 ... {current_size} ... 2 2 2
    ...
 */

P_LAST常量多项式赋值为：【accumulated_size个0，accumulated_size个1；重复该过程N/(accumulated_size*2)次。其中accumulated_size为 $2^8*2^8*2^1$ 。】

P_C、P_COUT、P_USE_CARRY常量多项式赋值为：【其本质是为所支持的所有运算构建相应的plookup table。有约束：{last, opcode, freeInA, freeInB , cIn, useCarry ,freeInC, cOut} in {P_LAST, P_OPCODE, P_A, P_B, P_CIN, P_USE_CARRY, P_C, P_COUT};】

 	buildP_C_P_COUT_P_USE_CARRY(
        pols.P_A,
        pols.P_B,
        pols.P_CIN,
        pols.P_LAST,
        pols.P_OPCODE,
        pols.P_USE_CARRY,
        pols.P_C,
        pols.P_COUT,
        N);
/*
    =========
    C & COUT
    =========
    1 => ADD
        * Extract less signative byte -> C
        * Get the carry out -> COUT
    0 => AND
        * A & B -> C
        * 0 -> COUT (AND doesn't have carry)
    。。。。。。
    default
        * 0 -> C
        * 0 -> COUT
 */

9. mem.pil中的常量多项式

mem.pil中的常量多项式有：

pol constant INCS; // 1......N
pol constant ISNOTLAST; // 1, 1, 1, .........1, 1, 0

具体的赋值为：
$\texttt{INCS} = (\underbrace{1, 2, 3, \dots,N-1, N}_{N})$
$\texttt{ISNOTLAST} = (\underbrace{1, 1, 1, \dots,1, 0}_{N})$

10. mem_align.pil中的常量多项式

mem_align.pil中的常量多项式有：

	// BYTE2A = 0 (x256), 1 (x256), 2 (x256), ..., 255 (x256)
    pol constant BYTE2A;

    // BYTE2B = 0, 1, 2, 4, **, 255, 0, 1, ..., 255
    pol constant BYTE2B;

    pol constant BYTE_C3072;

    // FACTOR was same for all combinations of offset, wr8, wr256 is a f(step)
    // FACTOR[7] = 2**24, 2**16, 2**8, 1, 0 (x60)
    // FACTOR[6] = 0, 0, 0, 0, 2**24, 2**16, 2**8, 1, 0 (x56)
    // FACTOR[5] = 0, 0, 0, 0, 0, 0, 0, 0, 2**24, 2**16, 2**8, 1, 0 (x52)
    // :
    // FACTOR[0] = 0 (x28), 2**24, 2**16, 2**8, 1, 0 (x32)
    pol constant FACTOR[8];

    // FACTOR change according the combinations of offset, wr8, wr256 and step.
    pol constant FACTORV[8];

    // STEP = 0,1,2,...,62,63,0,1,2,...
    pol constant STEP;

    // STEP
    //    0 - 1023  WR256 = 0 WR8 = 0
    // 1024 - 2047  WR256 = 1 WR8 = 0
    // 2048 - 3071  WR256 = 0 WR8 = 1
    pol constant WR256;
    pol constant WR8;

    // OFFSET = 0 (x64), 1 (x64), ... , 31 (x64), 32 (x64), 0 (x64), 1 (x64), ...
    pol constant OFFSET; // 0 - 31

    // RESET = 1, 0 (x63), 1, 0 (x63)
    pol constant RESET;

    pol constant SELM1;

附录：Polygon Hermez 2.0 zkEVM系列博客

ZK-Rollups工作原理
Polygon zkEVM——Hermez 2.0简介
Polygon zkEVM网络节点
Polygon zkEVM 基本概念
Polygon zkEVM Prover
Polygon zkEVM工具——PIL和CIRCOM
Polygon zkEVM节点代码解析
Polygon zkEVM的pil-stark Fibonacci状态机初体验
Polygon zkEVM的pil-stark Fibonacci状态机代码解析
Polygon zkEVM PIL编译器——pilcom 代码解析
Polygon zkEVM Arithmetic状态机

你可能感兴趣的:(zkVM,零知识证明)

零知识证明-公钥分发方案DH(（六） yunteng521 区块链零知识证明算法区块链密钥分发 DH
前言椭圆曲线配对，是各种加密构造方法(包括确定性阀值签名、zk-SNARKs以及相似的零知识证明)的关键元素之一。椭圆曲线配对(也叫“双线性映射”)有了30年的应用历史，然而最近这些年才把它应用在密码学领域。配对带来了一种“加密乘法”的形式，这很大的拓展了椭圆曲线协议的应用范围。本文的目的是详细介绍椭圆曲线配对，并大致解释它的内部原理先了解DH协议Diffie-Hellman协议简称DH，是一种公
零知识证明：哈希函数-Poseidon2代码解析与benchmark HIT夜枭零知识证明零知识证明哈希算法区块链
1、哈希函数(HashFunction)与Poseidon在密码学中，哈希函数是一种将任意大小的数据映射到固定大小的输出的函数。哈希函数的输出称为哈希值或哈希码。哈希函数具有单向性和抗碰撞性。一些常见的哈希函数包括MD5、SHA-1、SHA-256和SHA-3。例如，假设您要验证一个文件的完整性。您可以使用哈希函数来计算该文件的哈希值。然后，您可以将该哈希值与文件的预期哈希值进行比较。如果两个哈希
零知识证明框架：gnark 孙绿如叶～零知识证明(ZKP)密码学
一.zkSNARKs的一般构造流程首先将一个NP问题拍平（Flatten）构成电路（若干个乘法门/加法门构成），在电路的基础上构造约束，也就是R1CS，有了约束就可以把NP问题抽象成QAP问题。有了QAP问题的描述，就可以在QAP上构建zkSNARKs。二.gnarkgnark是consenSys开发的一个zkSARNK实现，采用Go语言，目前支持groth16，github地址：https://
实践指南：构建一个零知识证明 DApp [译] 扣3039046426 区块链
实践指南：构建一个零知识证明DApp[译]零知识证明DAppcircomsnarkjs本文将构建一个zk-dApp（零知识证明DApp），以证明用户是否属于某个特定组，而无需透露用户具体是谁。阅读本文前，最好先对以下内容有所了解：public-keycryptographycircom及snarkjs使用truffle使用ethers连接合约前言在过去的几个月中，我在以太坊eth上利用了零知识证明
Zcash-草稿歌白梨
Zcash，也叫大零币，从zerocoin发展而来，是使用零知识证明机制的区块链系统，通过完全匿名交易特性在区块链的生态中独树一帜。现在，Zcash市值是41.10亿。2016年10月28日，ZEC从比特币代码库0.11上分叉，所以他可以算比特币的一个克隆体，与比特币一样，Zcash（ZEC）的总量是2100万，采用PoW共识机制。与比特币不同的是，为了防止矿霸的产生，ZEC的加密不是通过SHA2
SP1：基于Plonky3构建的zkVM mutourend zkVM zkVM
1.引言SP1为SuccictLab开源的，基于Plonky3构建的zkVM。开源代码见：https://github.com/succinctlabs/sp1（Rust）当前暂未实现onchain-verifier，但会采用标准的STARK->SNARKverifier。SP1zkVM基于的指令集为：riscv32im（与RISCZero的指令集一样）在SP1zkVM中运行某程序之前，需将该程序
金融科技力 nightluo 基础学习金融科技
金融科技区块链二级目录三级目录区块链区块链安全：保密性、完整性、可用性最重要的点：保密性零知识证明：1、完整性（真的假不了）2、可靠性（假的真不了）3、零知识性（知道真的，但是不需要知道内容）共识算法安全：抗崩溃性与容错性确定性终结与概率终结FLP不可能性：在完全异步消息系统中如果单个节点发生故障，则不可能达成共识安全性与活性CAP定理：只能得到三个中的两个去中心化、可扩展性和安全三角“参数永远是
如何在JavaScript项目中使用 zk-SNARK chinadefi javascript rust 开发语言
如何在JavaScript项目中使用zk-SNARK[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4fQgcXkV-1675312908395)(https://tva1.sinaimg.cn/large/e6c9d24ely1gzmazs79m1g20tr04ojug.gif)]MariaCappelli在Unsplash上上传的照片零知识证明技术，尤其是zk-S
链化未来技术系列分享(1) - 零知识证明区块奇点
11月29日，链化未来在杭州举办主题为“区块链硬核技术揭密——零知识证明及跨链深度解读”线下活动内容分享。本文为零知识证明篇相关PPT内容。目录>什么是零知识证明>链化未来零知识证明组件>实践,跨链,资产交易摘要内容本次活动，密码学家王虎森介绍了链化未来零知识证明组件在技术上相对以太坊的优势，以及在具体业务如跨链、资产转移、个人数据隐私保护方面的应用。相比以太坊，链化未来的零知识证明组件在成本、可
OSDI 2023: LVMT: An Efficient Authenticated Storage for Blockchain 结构化文摘区块链分层架构共识存储结构
我们使用以下6个分类标准对本文的研究选题进行分析：1.研究方向:区块链可扩展性:提高交易吞吐量和减少确认时间的研究，例如零知识证明、分片和状态通道。密码学技术:开发或改进用于区块链应用的新密码原语，例如椭圆曲线、承诺方案和累加器。区块链存储和效率:优化区块链上的数据存储和检索，例如认证存储、Patricia树和数据压缩。共识机制:设计新的共识协议，例如拜占庭容错算法，用于更快速、更安全的区块验证。
什么是零知识证明？慎思知行 BlockChain 零知识证明区块链
Web3的核心原则之一——透明度，也可能是其最大的缺点之一。没有人希望他们的所有在线活动（从金融交易到个人身份数据）都可供任何人公开查看。为了使区块链能够扩展并变得更容易访问，隐私必须成为首要任务。零知识证明能够改变我们保护、管理和共享个人数据的方式。它们允许人们在不泄露信息本身的情况下证明陈述的真实性，从而为涉及敏感、机密信息的交易带来了新的隐私级别。什么是零知识证明？零知识证明（通常缩写为“Z
探析零知识证明高能发展路径：走向更安全、私密且可扩展的 Web3 新时代 TinTin Land Web3 前沿零知识证明安全 web3
原文：https://www.coinbase.com/blog/understanding-the-zero-knowledge-landscape作者：JonathanKing｜CoinbaseVentures编译：TinTinLand本文核心观点2023年，零知识技术吸引了逾4亿美元的投资，主要关注以太坊L1/L2协议层的可扩展性，以及新兴的基础设施和开发者工具。零知识证明（Zero-Kno
解读ALEO-继FIL后又一个由A16Z和软银领投过亿美元的隐私公链项目米斯特鞏软银 FIL 隐私保护 rust 哈希算法 p2p 网络协议
自从今年2月份ALEO融资了由软银领投，三星、老虎环球基金等众多机构跟投的2亿美元后，市场逐渐开始关注ALEO，目前从官方的公开资料看没有太多华丽的介绍，基本都是较专业的内容，今天我从几个方面综合概述一下ALEO的特性，从中也能发现ALEO的真正价值：1、模块化区块链：可组合性，可扩展性2、隐私：zkp零知识证明技术主要解决隐私和可扩展性问题3、兼容以太坊：生态兼容性好4、posw共识机制：基于比
Aleo项目详细介绍-一个兼顾隐私和可编程性的隐私公链慎思知行区块链
Aleo上线在即，整理一篇项目的详细介绍，喜欢的收藏。有计划做aleo节点的可交流。一、项目简介Aleo最初是在2016年构思的，旨在研究可编程零知识。公司由HowardWu、MichaelBeller、CollinChin和RaymondChu于2019年正式成立。Aleo是第一个采用零知识证明（ZKP）技术，提供私有、开源的Layer1区块链。Aleo开发了一个默认交易隐私的应用程序构建平台，
区块链精进手册 | 021 | 大师的投资思想（2）马烈视界
1.一种通证：ZECZEC是Zcash区块链网络中的通证，中文常备成为“零币”。ZEC发行总量恒定，为2100万枚，现已发行433余万枚，总市值达6.66亿，排行第21位。由于比特币的非匿名性，但实际货币有着匿名性需求，Zerocoin团队在比特币0.11.2的版本上修改了代码，添加了“零知识证明”技术，想让比特币更具匿名性。比特币团队拒绝在原链上升级，原开发者团队成立了ZerocoinElect
NuLink介绍二晨酱
4.NuLink主要使用技术4.1确保密文形式的数据的可用性。这里使用的加密技术主要是零知识证明。4.2隐私保护的数据共享。使用到的基本方法是对数据进行加密，让数据所有者控制对它的访问。这些技术包括去中心化加密存储、代理重加密、基于身份的加密和基于属性的加密等。4.3隐私保护数据的计算，这部分会将某些隐私计算能力集成到智能合约中。使用的技术包括多方安全计算(multi-partysecurecom
零知识证明学习 Ameame- 学习
文档，测试claimPK.zokimport"hashes/sha256/512bitPadded.zok"assha256;import"utils/pack/u32/nonStrictUnpack256.zok"asunpack256;import"utils/pack/u32/unpack128.zok"asunpack128;import"utils/pack/u32/pack128.zo
零知识证明的最新发展和应用 PrimiHub 零知识证明区块链密码学可信计算技术同态加密 github
PrimiHub一款由密码学专家团队打造的开源隐私计算平台，专注于分享数据安全、密码学、联邦学习、同态加密等隐私计算领域的技术和内容。当企业收集大量客户数据去审查、改进产品和服务以及将数据资产货币化时，他们容易受到网络攻击威胁，造成数据泄露。数据泄露的损失每年都在上升，每次泄露平均造成损失420万美元，如下图所示，它们严重损害了企业的声誉和可信度。数据泄露的成本零知识证明(ZKPs)等隐私增强技术
2022-02-05 Aaron阿酷
NuLink介绍（四）7.解决方案详细说明 7.1数据可用性作为一个专注于数据隐私的平台，我们首先需要解决的就是数据可用性问题。这个问题往往分为两部分:第一是消费者在购买前如何确定卖家是否有自己需要的数据，第二是如何验证在密文状态下的数据是否真实。在NuLink网络中，这两个问题可以通过零知识证明技术来解决:数据所有者需要在数据授权前提供零知识证明。事实上，密文状态下的证明方法与明文状态下的证
Web3.0会带来哪些机遇？ Aix17
NuLink的零知识证明介绍作者简介：作为NuLinkTechnology的研究员，Rookie是一位激情的创新者，他专注于密码学和区块链技术。翻译：Reversing作为NuLink项目的高级研究员，我一直致力于密码学和隐私保护的研究。多年来，这个领域一直有一个有趣的话题，那就是ZKP（ZeroKnowledgeProof，零知识证明）。最近它在社区中引起了很多关注，因为有很多有趣的场景可以讨论
零知识证明（zk-SNARK）- groth16（一） Amire0x 密码学-隐私计算零知识证明区块链
全称为Zero-KnowledgeSuccinctNon-InteractiveArgumentofKnowledge，简洁非交互式零知识证明，简洁性使得运行该协议时，即便statement非常大，它的proof大小也仅有几百个bytes，并且验证一个proof的时间可以达到毫秒级别。这是一个通用的零知识证明协议，可以用作各种证明，如范围证明。核心方法是通过R1CS，QAP等方法将计算难题变为多项
RISC Zero zkVM Host & Guest 101 mutourend zkVM zkVM
1.引言在RISCZerozkVM应用程序中，host为运行RISCZerozkVM的机器（或系统）。host为不可信agent，负责设置zkVM环境和处理执行过程中的输入输出。host程序（代码），是指：zkVM应用中的host-native、不可信的部分。负责加载guest程序，并为guest程序提供必要的输入。若基于Bonsai构建，则无需编写host代码。zkVM应用中，host负责构建并
2023海内外零知识证明学习资料汇总（一）（故事中的零知识证明篇）滕王阁配黑马打火机零知识证明区块链 web3 学习
工欲善其事,必先利其器Web3开发中，各种工具、教程、社区、语言框架.。。。种类繁多，是否有一个包罗万象的工具专注与Web3开发和相关资讯能毕其功于一役？参见另一篇博文2024最全面且有知识深度的web3开发工具、web3学习项目资源平台本文收集了关于零知识证明的一些学习资料（包括科普文章，论文，开源仓库及相关学习网站等），并对这些资源进行了整理分析，希望能对大家有所帮助。本文收集了关于零知识证明
2023海内外零知识证明学习资料汇总（二）（深入理解零知识证明篇）滕王阁配黑马打火机零知识证明区块链 web3 学习
工欲善其事,必先利其器Web3开发中，各种工具、教程、社区、语言框架.。。。种类繁多，是否有一个包罗万象的工具专注与Web3开发和相关资讯能毕其功于一役？参见另一篇博文2024最全面且有知识深度的web3开发工具、web3学习项目资源平台本文收集了关于零知识证明的一些学习资料（包括科普文章，论文，开源仓库及相关学习网站等），并对这些资源进行了整理分析，希望能对大家有所帮助。书接上篇，器欲尽其能,必
2022-02-24 Aaron阿酷
通过集成一流的技术，我们正在建立强大的技术基础。1.保证密文形式数据的可用性。这里使用的加密技术主要包括零知识证明。2.隐私保护数据共享。一般的方法是对数据进行加密，让数据所有者控制对它的访问。技术包括去中心化加密存储、代理重加密、基于身份的加密和基于属性的加密等。3.隐私数据计算，涉及将某些隐私计算能力集成到智能合约中。使用的技术包括多方安全计算、同态加密等。这三种技术方案可以在很多应用领域提供
区块链在未来企业中将会是什么样的角色？徽纯正
如今区块链的技术引发太多的讨论。区块链在企业中的角色是什么?越来越多的公司正在测试区块链的力量，通过分布式记账技术来做交易和追踪资产。以下是区块链今后的趋势预测:图片发自App1区块链将从试点转移到生产。区块链在世界各地都出现了试点项目。随着这些试点和概念验证的成熟，它们将被抛弃，然后将会向生产系统前进。这一过程将成为一个必要的调整。2零知识证明的使用将会提高。区块链将成为企业间交易的平台。这个平
dalek-cryptography/zkp——基于merlin的Schnorr零知识证明 mutourend
zkp为使用merlin的Schnorr零知识证明工具包，基于ristrettogroup做的实例化。【ristretto为对cofactor>1曲线的抽象，ristretto对外表现为将non-prime-order的曲线抽象为aprime-ordergroup。具体的细节可参见博客1ristretto对cofactor>1的椭圆曲线(如Curve25519等)的兼容（含Curve25519co
NuLink介绍一晨酱
1.NuLink介绍NuLink网络是一种为开发隐私保护APP的技术人员们提供最佳操作方案的去中心化解决方案，且是同类型中最优质的安全和隐私保护方案。NuLink平台提供端点加密和密码访问控制，任何敏感数据都可以从其他用户平台非常安全地共享到云端或者去中心化的储存设备，并根据代理重加密和属性加密协议，自动授权对云端或设备中敏感数据的访问。另一方面，零知识证明可以帮助验证数据的来源。在更多的高级隐私
密码极客分享：4个被知名机构投资的项目 CryptoGeek 区块链区块链比特币 CODA MakerDAO Coinbase
1CodaCoda是第一个具有简洁区块链的加密货币协议，是一种将区块链数据通过零知识证明压缩到固定字节大小的新型数字货币。当前的加密货币（如比特币和以太坊）存储数百GB的数据，随着时间的流逝，其区块链的大小只会增加。但是，对于Coda，无论使用量增长多少，区块链始终保持相同的大小-约20KB（几条推文的大小）。这意味着无论执行多少交易，验证区块链仍然很便捷，并且每个人都可以访问，更可以将加密货币无
ZK*FM：RISC Zero zkVM的形式化验证 mutourend zkVM zkVM
1.引言开源代码见：https://github.com/risc0/risc0-lean4（Lean和Rust）ZK*FM为RISCZerozkVM的形式化验证：ZK：Thecomputerrantherightprogram。FM：Theprogramdidtherightthing。ZK*FM：Thecomputerdidtherightthing。可使用FM来证明RISCZero的ZKto
戴尔笔记本win8系统改装win7系统 sophia天雪 win7 戴尔改装系统 win8
戴尔win8 系统改装win7 系统详述第一步：使用U盘制作虚拟光驱： 1）下载安装UltraISO：注册码可以在网上搜索。 2）启动UltraISO，点击“文件”—》“打开”按钮，打开已经准备好的ISO镜像文
BeanUtils.copyProperties使用笔记 bylijinnan java
BeanUtils.copyProperties VS PropertyUtils.copyProperties 两者最大的区别是： BeanUtils.copyProperties会进行类型转换，而PropertyUtils.copyProperties不会。既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProp
MyEclipse中文乱码问题 0624chenhong MyEclipse
一、设置新建常见文件的默认编码格式，也就是文件保存的格式。在不对MyEclipse进行设置的时候，默认保存文件的编码，一般跟简体中文操作系统（如windows2000，windowsXP）的编码一致，即GBK。在简体中文系统下，ANSI 编码代表 GBK编码;在日文操作系统下，ANSI 编码代表 JIS 编码。 Window-->Preferences-->General -
发送邮件不懂事的小屁孩 send email
import org.apache.commons.mail.EmailAttachment; import org.apache.commons.mail.EmailException; import org.apache.commons.mail.HtmlEmail; import org.apache.commons.mail.MultiPartEmail;
动画合集换个号韩国红果果 html css
动画指一种样式变为另一种样式 keyframes应当始终定义0 100 过程 1 transition 制作鼠标滑过图片时的放大效果 css .wrap{ width: 340px;height: 340px; position: absolute; top: 30%; left: 20%; overflow: hidden; bor
网络最常见的攻击方式竟然是SQL注入蓝儿唯美 sql注入
NTT研究表明，尽管SQL注入（SQLi）型攻击记录详尽且为人熟知，但目前网络应用程序仍然是SQLi攻击的重灾区。信息安全和风险管理公司NTTCom Security发布的《2015全球智能威胁风险报告》表明，目前黑客攻击网络应用程序方式中最流行的，要数SQLi攻击。报告对去年发生的60亿攻击行为进行分析，指出SQLi攻击是最常见的网络应用程序攻击方式。全球网络应用程序攻击中，SQLi攻击占
java笔记2 a-john java
类的封装： 1，java中，对象就是一个封装体。封装是把对象的属性和服务结合成一个独立的的单位。并尽可能隐藏对象的内部细节（尤其是私有数据） 2，目的：使对象以外的部分不能随意存取对象的内部数据（如属性），从而使软件错误能够局部化，减少差错和排错的难度。 3，简单来说，“隐藏属性、方法或实现细节的过程”称为——封装。 4，封装的特性： 4.1设置
[Andengine]Error：can't creat bitmap form path “gfx/xxx.xxx” aijuans 学习Android遇到的错误
最开始遇到这个错误是很早以前了，以前也没注意，只当是一个不理解的bug，因为所有的texture，textureregion都没有问题，但是就是提示错误。昨天和美工要图片，本来是要背景透明的png格式，可是她却给了我一个jpg的。说明了之后她说没法改，因为没有png这个保存选项。我就看了一下，和她要了psd的文件，还好我有一点
自己写的一个繁体到简体的转换程序 asialee java 转换繁体 filter 简体
今天调研一个任务，基于java的filter实现繁体到简体的转换，于是写了一个demo，给各位博友奉上，欢迎批评指正。实现的思路是重载request的调取参数的几个方法，然后做下转换。
android意图和意图监听器技术百合不是茶 android 显示意图隐式意图意图监听器
Intent是在activity之间传递数据;Intent的传递分为显示传递和隐式传递显式意图：调用Intent.setComponent() 或 Intent.setClassName() 或 Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。隐式意图;不指明调用的名称,根据设
spring3中新增的@value注解 bijian1013 java spring @Value
在spring 3.0中，可以通过使用@value，对一些如xxx.properties文件中的文件，进行键值对的注入，例子如下： 1.首先在applicationContext.xml中加入： <beans xmlns="http://www.springframework.
Jboss启用CXF日志 sunjing log jboss CXF
1. 在standalone.xml配置文件中添加system-properties： <system-properties> <property name="org.apache.cxf.logging.enabled" value=&
【Hadoop三】Centos7_x86_64部署Hadoop集群之编译Hadoop源代码 bit1129 centos
编译必需的软件 Firebugs3.0.0 Maven3.2.3 Ant JDK1.7.0_67 protobuf-2.5.0 Hadoop 2.5.2源码包 Firebugs3.0.0 http://sourceforge.jp/projects/sfnet_findbug
struts2验证框架的使用和扩展白糖_ 框架 xml bean struts 正则表达式
struts2能够对前台提交的表单数据进行输入有效性校验，通常有两种方式： 1、在Action类中通过validatexx方法验证，这种方式很简单，在此不再赘述； 2、通过编写xx-validation.xml文件执行表单验证，当用户提交表单请求后，struts会优先执行xml文件，如果校验不通过是不会让请求访问指定action的。本文介绍一下struts2通过xml文件进行校验的方法并说
记录-感悟 braveCS 感悟
再翻翻以前写的感悟，有时会发现自己很幼稚，也会让自己找回初心。 2015-1-11 1. 能在工作之余学习感兴趣的东西已经很幸福了； 2. 要改变自己，不能这样一直在原来区域，要突破安全区舒适区，才能提高自己，往好的方面发展； 3. 多反省多思考；要会用工具，而不是变成工具的奴隶； 4. 一天内集中一个定长时间段看最新资讯和偏流式博
编程之美-数组中最长递增子序列 bylijinnan 编程之美
import java.util.Arrays; import java.util.Random; public class LongestAccendingSubSequence { /** * 编程之美数组中最长递增子序列 * 书上的解法容易理解 * 另一方法书上没有提到的是，可以将数组排序（由小到大）得到新的数组， * 然后求排序后的数组与原数
读书笔记5 chengxuyuancsdn 重复提交 struts2的token验证
1、重复提交 2、struts2的token验证 3、用response返回xml时的注意 1、重复提交 (1)应用场景 (1-1)点击提交按钮两次。 (1-2)使用浏览器后退按钮重复之前的操作，导致重复提交表单。 (1-3)刷新页面 (1-4)使用浏览器历史记录重复提交表单。 (1-5)浏览器重复的 HTTP 请求。 (2)解决方法 (2-1)禁掉提交按钮 (2-2)
[时空与探索]全球联合进行第二次费城实验的可能性 comsci
二次世界大战前后,由爱因斯坦参加的一次在海军舰艇上进行的物理学实验 -费城实验至今给我们大家留下很多迷团..... 关于费城实验的详细过程,大家可以在网络上搜索一下,我这里就不详细描述了在这里,我的意思是,现在
easy connect 之 ORA-12154: TNS: 无法解析指定的连接标识符 daizj oracle ORA-12154
用easy connect连接出现“tns无法解析指定的连接标示符”的错误，如下： C:\Users\Administrator>sqlplus username/[email protected]:1521/orcl SQL*Plus: Release 10.2.0.1.0 – Production on 星期一 5月 21 18:16:20 2012 Copyright (c) 198
简单排序:归并排序 dieslrae 归并排序
public void mergeSort(int[] array){ int temp = array.length/2; if(temp == 0){ return; } int[] a = new int[temp]; int
C语言中字符串的\0和空格 dcj3sjt126com c
\0 为字符串结束符，比如说： abcd (空格)cdefg；存入数组时，空格作为一个字符占有一个字节的空间，我们
解决Composer国内速度慢的办法 dcj3sjt126com Composer
用法：有两种方式启用本镜像服务： 1 将以下配置信息添加到 Composer 的配置文件 config.json 中（系统全局配置）。见“例1” 2 将以下配置信息添加到你的项目的 composer.json 文件中（针对单个项目配置）。见“例2” 为了避免安装包的时候都要执行两次查询，切记要添加禁用 packagist 的设置，如下 1 2 3 4 5
高效可伸缩的结果缓存 shuizhaosi888 高效可伸缩的结果缓存
/** * 要执行的算法，返回结果v */ public interface Computable<A, V> { public V comput(final A arg); } /** * 用于缓存数据 */ public class Memoizer<A, V> implements Computable<A,
三点定位的算法 haoningabc c 算法
三点定位，已知a,b,c三个顶点的x,y坐标和三个点都z坐标的距离，la，lb,lc 求z点的坐标原理就是围绕a,b,c 三个点画圆，三个圆焦点的部分就是所求但是，由于三个点的距离可能不准，不一定会有结果，所以是三个圆环的焦点，环的宽度开始为0，没有取到则加1 运行 gcc -lm test.c test.c代码如下 #include "stdi
epoll使用详解 jimmee c linux 服务端编程 epoll
epoll - I/O event notification facility在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linu
Hibernate对Enum的映射的基本使用方法 linzx0212 enum Hibernate
枚举 /** * 性别枚举 */ public enum Gender { MALE(0), FEMALE(1), OTHER(2); private Gender(int i) { this.i = i; } private int i; public int getI
第10章高级事件（下） onestopweb 事件
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
孙子兵法 roadrunners 孙子兵法
始计第一孙子曰：兵者，国之大事，死生之地，存亡之道，不可不察也。故经之以五事，校之以计，而索其情：一曰道，二曰天，三曰地，四曰将，五曰法。道者，令民于上同意，可与之死，可与之生，而不危也；天者，阴阳、寒暑、时制也；地者，远近、险易、广狭、死生也；将者，智、信、仁、勇、严也；法者，曲制、官道、主用也。凡此五者，将莫不闻，知之者胜，不知之者不胜。故校之以计，而索其情，曰
MySQL双向复制 tomcat_oracle mysql
本文包括: 主机配置从机配置建立主-从复制建立双向复制背景按照以下简单的步骤: 参考一下：在机器A配置主机(192.168.1.30) 在机器B配置从机(192.168.1.29) 我们可以使用下面的步骤来实现这一点步骤1：机器A设置主机在主机中打开配置文件 ,
zoj 3822 Domination(dp) 阿尔萨斯 Mina
题目链接：zoj 3822 Domination 题目大意：给定一个N∗M的棋盘，每次任选一个位置放置一枚棋子，直到每行每列上都至少有一枚棋子，问放置棋子个数的期望。解题思路：大白书上概率那一张有一道类似的题目，但是因为时间比较久了，还是稍微想了一下。dp[i][j][k]表示i行j列上均有至少一枚棋子，并且消耗k步的概率（k≤i∗j）,因为放置在i+1~n上等价与放在i+1行上，同理