Más información sobre Lasso+Jolt

1. Introducción

Los blogs de prefacio son:

• Singularidad de lazo, sacudida y búsqueda - Parte 1
• Singularidad de lazo, sacudida y búsqueda - Parte 2

Para artículos relacionados ver:

• Srinath Setty (Centro de investigación de Microsoft), Justin Thaler (Centro de investigación de criptografía a16z y Universidad de Georgetown), Riad Wahby (Universidad Carnegie Mellon) Artículo de 2023 " Desbloquear la singularidad de búsqueda con Lasso "
• Arasu Arun (Universidad de Nueva York), Srinath Setty (Centro de investigación de Microsoft), Justin Thaler (Centro de investigación de criptografía a16z y Universidad de Georgetown) Artículo de 2023 "Jolt: SNARKs para máquinas virtuales mediante búsquedas "

Para conocer la implementación del código fuente abierto correspondiente, consulte:

• https://github.com/a16z/Lasso (óxido)

La estructura general de este artículo es:

• ¿Qué son los argumentos de búsqueda?
• ¿Qué es Lasso/Jolt?
• Detalles del lazo
• Detalles de sacudida
• ¿Cómo pensar en Lasso como una herramienta?
  • ¿Y cuál es el escenario de aplicación del argumento de búsqueda fuera de zkVM?

2. ¿Qué son los argumentos de búsqueda?

Los argumentos de búsqueda se pueden dividir en:

• 1）Argumento de búsqueda no indexado：
  • 为 prueba de relación de subconjunto, 即, prueba de membresía de conjunto por lotes—— $una$ mesa$Un\; cierto\; subconjunto\; de\; t$ .
• 2) Argumento de búsqueda indexada: [Lasso y Jolt usan un argumento de búsqueda indexada]
  • Para leer desde la memoria de sólo lectura. puede ser $t$ se considera memoria,$a_{}=t\left[{segundo}_{}\right]$ significa leer$b_{}$El valor en la celda de memoria.

Tomando como ejemplo la verificación de rango, el argumento de búsqueda se refiere a:

• 1）令$t=(0,1,2,3,\cdots ,2^{128}-1)$ por tener$Un\; vector\; de\; N$ elementos de tabla (es decir,$t$为 tabla predeterminada）。
• 2）令$a\in F^m$ es una lista de valores que deben incluirse en la tabla anterior.
• 3）Verificador $V$ conocido:aaValor de compromiso de$un$$cm{\_}_{}$。
• 4）Probador $P$ afirma:aaTodos los elementos en$a$$en\; t$ .
  Probador$P$ dice saber$cm{\_}_{}$apertura $a$ , tal que:
  • Para cada $i=0,\cdots ,metro-1$ , existe un índice$b_{}\in \{0,1,\cdots ,norte-1\}$ , usando$a_{}=t\left[{segundo}_{}\right]$。
• 5) Este argumento de búsqueda generalmente se denomina argumento de búsqueda no indexado.

El argumento de búsqueda indexada significa que se agrega un valor de índice al elemento que se va a verificar, y el argumento de búsqueda indexada se define como: [El verificador sabe que la tabla ttdescripción sucinta de$t\; .$】

• 1）令$t\in F^n$ es con$Un\; vector\; de\; N$ elementos de tabla (es decir,$t$为 tabla predeterminada）。
• 2）Probador PPVector de par$P$$(({un}_{},b_{}),\cdots ,({un}_{},b_{}))$ comprometerse.
• 3）Probador $P$ afirma que para$i=1,\cdots ,m$，有$a_{}=t\left[{segundo}_{}\right]$ . [Inmediato$a_{}$为 valor, $b_{}$Correspondiente a la tabla ttNúmero índice de$t$$P$ afirmaaaTodos los elementos en$a$ existen en ttEl índice correspondiente en$t\; .$】

3. ¿Qué es Lasso/Jolt?

Lazo: para un conjunto de argumentos de búsqueda (indexados):

• Probador de lazo $P$ es un orden de magnitud más rápido que el esquema anterior.
  • Probador $El\; cuello\; de\; botella\; clave\; de\; P$ es: gastos generales de compromiso.
• Probador de lazo $P$ confirma menos elementos de campo y todos los elementos de campo a confirmar son pequeños.
• Sin compromiso con $No\; es$ necesario para muchas mesas. [Para una gran cantidad de tablas de búsqueda (obligatorias en Jolt), no es necesario que una parte honesta confirme y preprocese la tabla. El Verificador basado en Lasso puede procesar una tabla enorme por sí solo (solo se requieren alrededor de 50/100/200 operaciones de campo), en lugar de recibir el valor prometido de la tabla. 】
• Soporte para tablas enormes (descomponibles o estructuradas LDE):
  • Probador PPLa sobrecarga de compromiso para$P$$O\left(c\right(metro+{norte}^{1/c}))$elementos de campo.
  • La descomposición de la tabla tiene principalmente dos aspectos de la sobrecarga de Prover, generalmente $C=6$ para equilibrar estos dos aspectos de los gastos generales:
    • Solo depende de la sobrecarga del tamaño de la mesa.
    • Sólo depende de la sobrecarga de los tiempos de búsqueda.

Jolt: Para la nueva tecnología zkVM:

• Probador de sacudidas $Los\; gastos\; generales\; de\; compromiso\; de\; P$ son mucho más bajos que los del esquema anterior.
• La instrucción primitiva se realiza mediante una búsqueda de toda la tabla de evaluación de una sola instrucción.

4. Detalles del lazo

4.1 Detalles generales del lazo

Para talla $N$ , con parámetro$La\; tabla\; de\; c$ , do$m$ orden de búsqueda indexada:

• Probador de lazo $P$ arriba es: para$3cm\_\_+c{norte}^{1/c}$ elementos de campo para confirmación.
  • Todos los elementos del campo son pequeños, es decir, en el conjunto $\{0,1,\cdots ,metro\}$ en:
    • Esquema de compromiso polinomial basado en MSM, Lasso Prover $Para\; cada\; elemento\; de\; campo\; comprometido\; (pequeño),\; P$ solo necesita realizar aproximadamente 1 operación de grupo.
      Los esquemas de compromiso polinomiales actuales basados ​​en HSH son:
      • Esquema de compromiso polinómico basado en KZG
      • Esquema de compromiso polinómico IPA/Bulletproofs
      • Esquema de compromiso polinomial de Hyrax
      • Esquema de compromiso polinomial de Dory
• Verificador de lazo $El$ costo V es:
  • $O(log\_m)$ Operaciones de campo y evaluaciones de hash (de Fiat-Shamir).
  • ＋ 1个 prueba de evaluación para un polinomio comprometido de tamaño ${norte}^{1/c}$ .
  • A través de composición/recursión, el Lasso Verifier $Los\; gastos\; generales\; de\; V$ se reducen aún más.

Cuando $C=1$ , correspondiente al caso especial de Lasso - Basic-Lasso:

• Probador de lazo básico $P$ a$metro+Se\; confirman\; N$ elementos de campo.
• Este $metro+Muchos\; de\; los\; N$ elementos del campo son 0. En el esquema de compromiso polinómico basado en MSM, el costo de comprometer un valor de 0 también es 0, es decir, "gratis".
• Este $metro+Entre\; los\; N$ elementos de campo, hay como máximo$2m$ son valores distintos de cero:
  • Si se lee una celda de tabla diferente cada vez, hay $Los\; m$ elementos del campo son 1 y los demás son 0.

4.2 Utilice Lasso para mesa enorme: $C>1$

De hecho, la mayoría de las tablas de búsqueda grandes se pueden descomponer :

• El tamaño grande se puede configurar en $Una\; búsqueda\; de\; la\; tabla\; de\; N$ , descompuesta en${norte}^{1/\; la\; tabla\; dec}$ es de aproximadamente$búsqueda\; de\; c$ veces y luego "cotejo" el$Los\; resultados\; de\; las\; búsquedas\; de\; c$ :
  • Lasso utiliza el protocolo de verificación de suma para "clasificar" el $Los\; resultados\; de\; las\; búsquedas\; de\; c$ . Entonces a Lasso Prover$P$ , no hay gastos generales de compromiso adicionales.

Lasso puede considerarse como $C>1.$ Para la búsqueda de una única tabla grande y descomponible, la reducción es$c$ búsquedas:

• Para tablas pequeñas, se puede utilizar cualquier argumento de búsqueda.
  • Para tablas pequeñas, el esquema de argumentos de búsqueda Basic-Lasso se utiliza en Lasso.
• Nota adicional: el argumento de búsqueda de tabla pequeña debe estar indexado.
• Soluciones conocidas actualmente para convertir un argumento de búsqueda no indexado en un argumento de búsqueda indexado.
  • Sin embargo, estos esquemas conocidos no logran preservar la "pequeñez" de las entradas de la tabla o no logran preservar la capacidad de descomposición de las tablas grandes; la razón es que estos esquemas "empaquetan" índices y valores en un solo elemento de campo.

[El tamaño de la prueba no depende del número de tablas diferentes, ni del tamaño de la tabla pequeña. El Verificador necesita evaluar el polinomio de extensión multilineal de cada tabla pequeña en un punto aleatorio. El aumento en el número de tablas pequeñas aumentará el tiempo del Verificador, pero estas son operaciones de campo. En comparación con otras operaciones criptográficas, esto no lo será. convertirse en el cuello de botella de Verifier.
Hay alrededor de 45 subtablas diferentes en Jolt.
】

4.3 Antecedentes: argumentos del gran producto

Todos los argumentos de búsqueda conocidos toman el argumento del gran producto :

• El argumento del gran producto es un esquema SNARK para demostrar que $El\; producto\; de\; n$ valores comprometidos.
• El gran argumento popular de hoy en día sobre el producto: su Prover $P$ necesita un par extra dennSe comprometen$N\; valores\; (productos\; parciales).$
• Esto es innecesario.
• En el artículo T13: Se proporciona la versión optimizada del protocolo GKR (el llamado protocolo GKR es una prueba interactiva basada en verificación de suma para la evaluación de circuitos): [El circuito similar al árbol binario de puertas de multiplicación está optimizado. 】
  • Probador $P$ Sin gastos generales de compromiso.
  • Probador $P$ realiza operaciones de campo de orden lineal.
  • Tamaño de prueba/Verificador $V$ tiempo为$O\left(\log \right(n)\_{}^2)$Operaciones de campo (y evaluaciones de hash de Fiat-Shamir):
    • Mucho menos que el tamaño de prueba/Verificador VV de FRI$V$ tiempo。
    • [Lee, Setty 2019]中将Verificador $La$ sobrecarga de V se reduce aún más a aproximadamente$O\left(\log \right(n))$$,$ solo aumenta ProverPPUn pequeño gasto de compromiso para$P.$

4.4 Puntos clave de Basic-Lasso

• Para muchos argumentos de búsqueda existentes, si se cambia el argumento del gran producto invocado por T13, Prover $P$ solo necesita comprometer pequeños elementos de campo.
  • Para obtener más información, consulte las búsquedas logUp-Multivariate de Ulrich Hab¨ock basadas en derivadas logarítmicas : con la ayuda de derivadas logarítmicas, el argumento del gran producto se convierte en un argumento de gran suma.
  • Más complicado que un simple intercambio de un gran argumento de producto.
• Lasso/Jolt necesita utilizar un argumento de búsqueda indexada para "cotejar" los resultados de búsqueda de tablas pequeñas en resultados de tablas grandes.
• Punto de venta técnico: la comunidad actual todavía no está utilizando plenamente el potencial de la verificación de suma para evitar Prover $P$ por encima.
• Para conocer el principio de funcionamiento de Basic-Lasso, consulte:
  • Singularidad de lazo, sacudida y búsqueda - Parte 2

5. Detalles de la sacudida

Front-end de la ejecución actual de VM:

• Probador $P$ afirma ejecutar un programa de computadora para$m$ pasos:
  • El programa está escrito en el lenguaje ensamblador de una VM.
  • Las máquinas virtuales orientadas a objetivos populares son: RISC-V, Ethereum Virtual Machine (EVM).
• Actualmente, el front-end genera un circuito para cada paso de cálculo:
  • Paso 1: Señale qué instrucción debe ejecutarse en este paso.
  • Paso 2: ejecuta el comando.
• Y Lasso reemplaza el paso 2 anterior con una única búsqueda:
  • Para cada instrucción, la tabla de evaluación completa para esa instrucción se almacena en esta tabla .
  • Si el comando $f$ tiene 2 entradas de 64 bits, entonces para cada par de entradas de 64 bits$(x,y)$ , la tabla de búsqueda almacenará todos$f(x,y)$ :
    • El tamaño de la tabla de búsqueda es $2^{128}$ .
    • Como se muestra en Jolt, todas las instrucciones RISC-V son descomponibles.

La imagen general de Jolt es:

Se espera que Jolt haga realidad la visión de Singularidad de búsqueda de Barry Whitehat :

• Tiene las ventajas de una fácil auditoría, simplificación y escalabilidad.
• ventaja de rendimiento
• Maneras esencialmente diferentes de construir zkVM:
  • Hay muchas similitudes con lo que la gente está haciendo ahora.
  • La visión de la gente es convertir funciones de cálculo como AND bit a bit en búsquedas múltiples en tablas pequeñas y combinar los resultados.
  • Las diferencias clave del Jolt son:
    • a) El nuevo argumento de búsqueda de tabla pequeña tiene un Jolt Prover $P.$ _
    • b) El nuevo argumento de búsqueda en tabla pequeña está indexado de forma natural.
    • c）Probador de sacudidas $P$ tiene una técnica de clasificación mucho más rápida:
      • La multiplicación y suma "gratis" se pueden realizar en resultados de búsqueda de tablas pequeñas.
  • Estas diferencias de Jolt hacen posible utilizar la búsqueda para realizar casi todo en la emulación de VM .

5.1 Ejemplo 1 de descomposición de sacudidas: Y bit a bit

Para dos entradas de 64 bits $x,$El ácido crudo AND bit a bit de$y\; ,\; su\; idea\; de\; descomposición\; es\; la\; siguiente:$

• 将$x,y$ se descompone en$C=8$ trozos, cada trozo tiene 8 bits.
• Calcule el AND bit a bit de cada fragmento
• Concatene los resultados de cada fragmento, la salida es:
  ${\sum }_{yo=1}^{}{8}^{yo-1}\cdot \text{bit a bitAND}(x_{},y_{})$

Para evitar la necesidad de que una parte honesta confirme la subtabla:

• $\text{bit a bitAND}(x_{},y_{})={\sum }_{j=1}^{}{2}^{j-1}\cdot X_{}\cdot y_{}$Es un polinomio multilineal, que puede evaluarse con menos de 25 operaciones de campo.
• Verificador de lazo $V$ necesita conocer la subtabla y solo necesita conocer una evaluación del polinomio.

5.2 Ejemplo 2 de descomposición de sacudidas: adición de RISC-V

Para dos números de 64 bits $x,En$ resumen, RISC-V estipula que la suma es correcta e ignora cualquier "bit de desbordamiento".

Jolt (al agregar una restricción al R1CS auxiliar) calcula $z=X+y$ , y luego use la búsqueda para identificar el bit de desbordamiento correspondiente; si hay un bit de desbordamiento, ajuste el resultado correspondiente en consecuencia.

• Probador de sacudidas $P$，对elemento de campo$z=X+y$的“descomposición de extremidades”$({segundo}_{},\cdots ,b_{})$ comprometerse.
• Sea $METRO=2^{64/c}$ es el máximo por extremidad.
• Agregue una restricción a R1CS para confirmar:
  • Paso 1: $z={\sum }_{j=1}^{}{METRO}^{j-1}\cdot b_{}$
  • Paso 2: Y para cada $b_{}$Almacene $\{0,\cdots ,METRO-1\}$ subtabla para realizar la verificación de rango.
• A través del paso 1 y el paso 2 de las restricciones anteriores, se puede garantizar que $b_{},\cdots ,b_{}$de hecho para zzLa descomposición de extremidades prescrita de$z\; .$
• Para identificar el bit de desbordamiento, solo es necesario realizar una búsqueda en el índice $b_{}$, en una mesa cuyo $La\; i$ 'ésima entrada escupe el bit de orden superior relevante de$yo$ .

5.3 Ejemplo 2 de descomposición de sacudidas: MENOS QUE SIN FIRMAR

Para 2 entradas de 64 bits $x,y$ hace menos que la operación:

• 将$x,y$ se descompone en$C=8$ trozos, cada trozo tiene 8 bits.
• Calcule MENOS QUE (LT) e IGUALDAD (EQ) de cada fragmento
• Ejemplo: ${\sum }_{yo=1}^{}{2}^{yo-1}\cdot \text{LT}(x_{},y_{}){\prod }_{j=yo+1}^{}\text{Ecualizador}(x_{},y_{})$

Para evitar cometer 2 subtablas:

• $\text{Ecualizador}(x_{},y_{})={\prod }_{k=1}^{}(x_{j,}{y}_{j,}+(1-X_{j,}\left)\right(1-y_{j,}))$
• $\text{LT}(x_{},y_{})={\sum }_{k=1}^{}(1-X_{})y_{}{\prod }_{z=k}^{}(x_{yo,}{y}_{yo,}+(1-X_{yo,}\left)\right(1-y_{yo,}))$
• Se trata de polinomios multilineales, que pueden evaluarse en menos de 50 operaciones archivadas.

6. ¿Cómo pensar en Lasso como herramienta? ¿Y cuál es el escenario de aplicación del argumento de búsqueda fuera de zkVM?

6.1 Intuición de Lasso como herramienta

• Lasso admite operaciones simples en descomposición de bits de elementos de campo sin Lasso Prover $P$ confirma cada bit.
• Las subtablas tienen una extensión multilineal rápidamente evaluable, si cada subtabla corresponde a una función simple en los (bits de) los índices de la tabla:
  • Esto garantiza que la parte honesta no necesite confirmar estas subtablas durante el preprocesamiento.
• El valor de 2 elementos de campo es $\{0,1,\cdots ,2^{64}-1\}$ 's operación AND bit a bit, en comparación con la sobrecarga de cada puerta de suma o multiplicación en Plonk, Lasso Prover tiene una sobrecarga menor.
• Nota: Los argumentos de búsqueda son economías de escala. Bueno para realizar muchas búsquedas en una tabla (es decir, múltiples llamadas a la misma función).

6.2 Trate los argumentos de búsqueda indexados como el esquema SNARK de evaluación de funciones repetidas

Se han realizado muchos estudios sobre "SNARK para evaluación de funciones repetidas" antes:

• Basado en muchas entradas diferentes $X_{},\cdots ,X_{}$, calculando la misma función $F.$ _
• Piense en ello como una cantidad "polinómica" de paralelismo de datos:
  • Si la función $La\; longitud\; de\; entrada\; de\; f$ es$n$ , entonces el número de entradas diferentes es$metro=\text{poli}\left(n\right)$。
• Todavía se requiere el probador $P$ evaluar$f$ de una manera muy específica:
  • Ejecutar un circuito específico para calcular $F.$ _

Una nueva perspectiva sobre los argumentos de búsqueda:

• Piense en la tabla de búsqueda como si almacenara una función ffTodas las evaluaciones de$f$
• argumento de búsqueda: un SNARK para una evaluación muy repetida de $F$ :
  • Según Prover, vector comprometido $(({un}_{},f({un}_{})),\cdots ,({un}_{},f({un}_{})))$ , contiene la entrada diferente$a_{},\cdots ,a_{}$el ff correcto$f$ evaluaciones。
• Probador de lazo $La\; sobrecarga\; de\; P$ es$O\left(c\right(metro+{norte}^{1/c}))$, cuando la búsqueda multiplica por$m$ no es mayor que el tamaño de la mesa$N$ , cuando es demasiado pequeño, Lasso Prover$P$ es eficiente:
  • es decir, correr $El\; grado\; de\; f$ debe ser exponencial en el tamaño de entrada de$F.$ _

7. Resumen

• Lasso es adecuado para escenarios donde la misma función se evalúa muchas veces.
• zkVM es solo uno de los escenarios de aplicación de Lasso:
  • Por definición, la abstracción VM representa el cálculo de la ejecución repetida de instrucciones primitivas.
  • La implementación de la abstracción de VM suele tener una sobrecarga de rendimiento significativa.
• Direcciones futuras de interés:
  • Otras formas mejores de aislar estructuras repetidas en cálculos
  • Ejemplos de trabajos son:
    • corte de bits
    • evaluar la función hash o el cifrado de bloque (como SHA/AES) para construir un circuito booleano CC con 64 entradas diferentes$C$ para calcular:
      • Empaque el primer bit de cada entrada en un único elemento de campo, el segundo bit de cada entrada en un único elemento de campo, y así sucesivamente.
      • circuito CCPara cada puerta AND en$C$ , reemplácela con AND bit a bit; reemplace el circuito CCCada puerta OR en$C\; ,\; reemplazada\; por\; OR\; bit\; a\; bit\; y\; así\; sucesivamente.$
      • alrededor de $La\; salida\; de\; cada\; puerta\; en\; C$ es un bit de las 64 evaluaciones de SHA/AES.
      • circuito $C$ usa Lazo.

Referencias

[1] Justin Thaler compartió zkStudyClub - Lasso/Jolt (Justin Thaler, Georgetown University/a16z) en zkStudyClub en agosto de 2023

Serie de blogs de Justin Thaler

• Diseño SNARK
• El paisaje SNARK del proyecto Rollup
• Ejemplo de principio SNARK
• Rendimiento y seguridad de SNARK - Prover
• Rendimiento y seguridad de SNARK——Verificador
• protocolo de verificación de suma en zkproof
• Análisis profundo del protocolo de verificación de suma
• Singularidad de lazo, sacudida y búsqueda - Parte 1
• Singularidad de lazo, sacudida y búsqueda - Parte 2

blog de la serie de búsqueda

• BUSCAR
• Análisis de código de búsqueda
• Esquemas de compromiso de polinomios eficientes para puntos múltiples y notas de estudio de polinomios
• PLONK + BUSCAR
• PlonKup: Conciliar PlonK con plookup
• PLONK: permutaciones sobre bases de Lagrange para argumentos ecuménicos no interactivos de conocimiento Notas de estudio
• Análisis de código Plonk
• RapidUp: notas de estudio del protocolo de permutación multidominio para tablas de búsqueda
• Descripción general de los argumentos de búsqueda
• Notas de estudio de Halo2: argumento de búsqueda del sistema de diseño de prueba (1)
• logUp-Búsquedas multivariadas basadas en derivadas logarítmicas
• cq: argumento de búsqueda rápida
• Optimización del rendimiento del argumento de búsqueda: Caulk
• Aspectos destacados de ZK Hack y ZK Summit en 2023
• Día de la investigación 2023: los últimos avances de Succinct ZKP
• Singularidad de lazo, sacudida y búsqueda - Parte 1
• Singularidad de lazo, sacudida y búsqueda - Parte 2