Documentation

MIPRE.Tailored.AnsRed.Pcp

The PCP of the answer reduction: its blocks, its checks, and Schwartz–Zippel #

Paper II's degree-d PCP for the combined succinct 6-decoupled SAT and 5-decoupled linear system (Definitions defn:blocks_of_vars_circuit and defn:PCP_of_V_n_satisfied, II:8939–9013; the checks of Observation obs:satisfiability_vs_PCP). Its variables are the wires of the circuit C that describes the output indicator through three windows (lem:ar-window-describer): the window A (a parity wire, then the ℓ bits of a cell of the first readable answer), the window B (likewise for the second), the window C (a parity wire, then the 2ℓ + 3◇ + 6 bits of an index of the table O), the three witness indices, the six signs, and the gates. The index of O is itself the paper's S₀: the bits of the two linear answers' cells, of the three copies, and the six signs of the decoupled system (the layout of MIPRE.Tailored.AnsRed.indTable).

Two departures from the paper's text. The windows of the describer hold tape encodings (0 ↦ 00, 1 ↦ 01), so the literal of a window at (π, u) is π · g(u) for the polynomial g of the raw table: the tape encoding is affine in the table, and the paper's raw-table assignments are kept. And a literal of the repository's clauses is true when its variable equals its sign (Lit.pos), so its factor is g - sign where the paper writes g + ε + 1 with ε the negated sign (fact:polynomial_condition_for_satisfiability). The certificates X_i (1 - X_i) are the paper's zero_X, X (X + 1) in characteristic 2.

The blocks #

The sizes of the PCP: the exponents ℓ of the table size and ◇ of the copy size, the width r of the witness indices, and the number s of gates of the circuit.

Instances For

    The width 2ℓ + 3◇ + 6 of an index of the table O, the paper's |S₀|.

    Equations
    Instances For

      The number of the circuit's inputs: three windows, three witness indices, six signs.

      Equations
      Instances For

        The number of variables of the PCP, the circuit's wires.

        Equations
        Instances For

          The parity wire of the window A.

          Equations
          Instances For

            The cell wires of the window A.

            Equations
            Instances For

              The parity wire of the window B.

              Equations
              Instances For

                The cell wires of the window B.

                Equations
                Instances For

                  The parity wire of the window C.

                  Equations
                  Instances For

                    The wires of an index of O, after the parity wire of the window C.

                    Equations
                    Instances For
                      def MIPRE.Tailored.AnsRed.PcpDims.vW (L : PcpDims) (k : Fin 3) (j : Fin L.r) :
                      Fin L.m

                      The wires of the k-th witness index.

                      Equations
                      Instances For

                        The six sign wires, in the order of the windows and witness blocks: A, B, C, w₁, w₂, w₃.

                        Equations
                        Instances For

                          Inside an index of O: the cell of the first linear answer.

                          Equations
                          Instances For

                            Inside an index of O: the cell of the second linear answer.

                            Equations
                            Instances For
                              def MIPRE.Tailored.AnsRed.PcpDims.oL (L : PcpDims) (k : Fin 3) (j : Fin L.dm) :

                              Inside an index of O: the cell of the k-th copy.

                              Equations
                              Instances For

                                Inside an index of O: the six signs of the equation, ε_A, ε_B, ε₁, ε₂, ε₃, ε₀.

                                Equations
                                Instances For
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_vA (L : PcpDims) (j : Fin L.ℓ) :
                                  ↑(L.vA j) = 1 + ↑j
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_vB (L : PcpDims) (j : Fin L.ℓ) :
                                  ↑(L.vB j) = L.ℓ + 1 + 1 + ↑j
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_πC (L : PcpDims) :
                                  ↑L.πC = L.ℓ + 1 + (L.ℓ + 1)
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_vO (L : PcpDims) (j : Fin L.oW) :
                                  ↑(L.vO j) = L.ℓ + 1 + (L.ℓ + 1) + 1 + ↑j
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_vW (L : PcpDims) (k : Fin 3) (j : Fin L.r) :
                                  ↑(L.vW k j) = L.ℓ + 1 + (L.ℓ + 1) + (L.oW + 1) + ↑k * L.r + ↑j
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_sgn (L : PcpDims) (k : Fin 6) :
                                  ↑(L.sgn k) = L.ℓ + 1 + (L.ℓ + 1) + (L.oW + 1) + 3 * L.r + ↑k
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_oA (L : PcpDims) (j : Fin L.ℓ) :
                                  ↑(L.oA j) = ↑j
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_oB (L : PcpDims) (j : Fin L.ℓ) :
                                  ↑(L.oB j) = L.ℓ + ↑j
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_oL (L : PcpDims) (k : Fin 3) (j : Fin L.dm) :
                                  ↑(L.oL k j) = L.ℓ + L.ℓ + ↑k * L.dm + ↑j
                                  @[simp]
                                  theorem MIPRE.Tailored.AnsRed.PcpDims.val_oSgn (L : PcpDims) (k : Fin 6) :
                                  ↑(L.oSgn k) = L.ℓ + L.ℓ + 3 * L.dm + ↑k

                                  The proof #

                                  structure MIPRE.Tailored.AnsRed.Pcp (L : PcpDims) (F : Type u_1) [CommRing F] :
                                  Type u_1

                                  A PCP (Definition defn:PCP_of_V_n_satisfied): the eleven assignments and the helpers. The readable part is gA, gB, gO, gW, αR, βA, βB, βO, βW; the linear part is gLa, gLb, gL, αL, βLa, βLb, βL.

                                  Instances For

                                    The checks #

                                    def MIPRE.Tailored.AnsRed.AssignCheck {F : Type u_1} [CommRing F] {k : ℕ} (g : MvPolynomial (Fin k) F) (β : Fin k → MvPolynomial (Fin k) F) (x : Fin k → F) :

                                    An assignment check (eq:PCP_condition_1, eq:PCP_condition_2): g (1 - g) is the certificate sum at the point x of its block.

                                    Equations
                                    Instances For
                                      def MIPRE.Tailored.AnsRed.FormulaCheck {F : Type u_1} [CommRing F] {L : PcpDims} (T : MvPolynomial (Fin L.m) F) (P : Pcp L F) (p : Fin L.m → F) :

                                      The formula check (eq:Tseitin_satisfiable_induced) at the point p, against the Tseitin polynomial T of the circuit: T times the six literal factors — the window literals the parity times the table polynomial — is the certificate sum.

                                      Equations
                                      • One or more equations did not get rendered due to their size.
                                      Instances For
                                        def MIPRE.Tailored.AnsRed.SystemCheck {F : Type u_1} [CommRing F] {L : PcpDims} (P : Pcp L F) (x : Fin L.oW → F) :

                                        The system check (eq:induced_system_is_satisfied) at the point x of the index space of O: O times the equation ε_A g_{La} + ε_B g_{Lb} + Σ ε_i g_{L,i} - ε₀ is the certificate sum.

                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For
                                          def MIPRE.Tailored.AnsRed.Pcp.Passes {F : Type u_1} [CommRing F] {L : PcpDims} (T : MvPolynomial (Fin L.m) F) (P : Pcp L F) (p : Fin L.m → F) :

                                          The thirteen checks at a point (Definition defn:PCP_of_V_n_satisfied, Observation obs:satisfiability_vs_PCP): the formula check, the system check at the point's index of O, and the eleven assignment checks at the point's blocks.

                                          Equations
                                          • One or more equations did not get rendered due to their size.
                                          Instances For
                                            def MIPRE.Tailored.AnsRed.Pcp.Identities {F : Type u_1} [CommRing F] {L : PcpDims} (T : MvPolynomial (Fin L.m) F) (P : Pcp L F) :

                                            The thirteen checks as identities: each holds at every point of its own space — what the honest PCP satisfies (the completeness of prop:completeness_and_soundness_of_PCP_for_V_n) and what a PCP passing often enough must satisfy (its soundness).

                                            Equations
                                            • One or more equations did not get rendered due to their size.
                                            Instances For
                                              theorem MIPRE.Tailored.AnsRed.Pcp.Identities.passes {F : Type u_1} [CommRing F] {L : PcpDims} {T : MvPolynomial (Fin L.m) F} {P : Pcp L F} (h : Identities T P) (p : Fin L.m → F) :
                                              Passes T P p

                                              A PCP satisfying the identities passes the checks at every point.

                                              The checks as polynomials #

                                              noncomputable def MIPRE.Tailored.AnsRed.chkAssign {F : Type u_2} [CommRing F] {L : PcpDims} {k : ℕ} (v : Fin k → Fin L.m) (g : MvPolynomial (Fin k) F) (β : Fin k → MvPolynomial (Fin k) F) :

                                              The polynomial of an assignment check, on the variables of the PCP through the embedding v of its block.

                                              Equations
                                              Instances For
                                                noncomputable def MIPRE.Tailored.AnsRed.chkSystemO {F : Type u_2} [CommRing F] {L : PcpDims} (P : Pcp L F) :

                                                The polynomial of the system check, on the index space of O.

                                                Equations
                                                • One or more equations did not get rendered due to their size.
                                                Instances For
                                                  noncomputable def MIPRE.Tailored.AnsRed.chkFormula {F : Type u_2} [CommRing F] {L : PcpDims} (T : MvPolynomial (Fin L.m) F) (P : Pcp L F) :

                                                  The polynomial of the formula check.

                                                  Equations
                                                  • One or more equations did not get rendered due to their size.
                                                  Instances For
                                                    theorem MIPRE.Tailored.AnsRed.assignCheck_iff {F : Type u_2} [CommRing F] {L : PcpDims} {k : ℕ} (v : Fin k → Fin L.m) (g : MvPolynomial (Fin k) F) (β : Fin k → MvPolynomial (Fin k) F) (p : Fin L.m → F) :
                                                    AssignCheck g β (p ∘ v) ↔ (MvPolynomial.eval p) (chkAssign v g β) = 0
                                                    theorem MIPRE.Tailored.AnsRed.systemCheck_iff {F : Type u_2} [CommRing F] {L : PcpDims} (P : Pcp L F) (x : Fin L.oW → F) :
                                                    theorem MIPRE.Tailored.AnsRed.formulaCheck_iff {F : Type u_2} [CommRing F] {L : PcpDims} (T : MvPolynomial (Fin L.m) F) (P : Pcp L F) (p : Fin L.m → F) :
                                                    noncomputable def MIPRE.Tailored.AnsRed.chkPolys {F : Type u_2} [CommRing F] {L : PcpDims} (T : MvPolynomial (Fin L.m) F) (P : Pcp L F) :

                                                    The thirteen polynomials of the checks, on the variables of the PCP.

                                                    Equations
                                                    • One or more equations did not get rendered due to their size.
                                                    Instances For
                                                      theorem MIPRE.Tailored.AnsRed.passes_iff {F : Type u_2} [CommRing F] {L : PcpDims} (T : MvPolynomial (Fin L.m) F) (P : Pcp L F) (p : Fin L.m → F) :
                                                      Pcp.Passes T P p ↔ ∀ c ∈ chkPolys T P, (MvPolynomial.eval p) c = 0

                                                      The checks pass at a point exactly when the thirteen polynomials vanish there.

                                                      Degrees #

                                                      theorem MIPRE.Tailored.AnsRed.degreeOf_rename_le_of_injective {F : Type u_2} [CommRing F] {k n : ℕ} {f : Fin k → Fin n} (hf : Function.Injective f) {p : MvPolynomial (Fin k) F} {d : ℕ} (hp : ∀ (i : Fin k), MvPolynomial.degreeOf i p ≤ d) (j : Fin n) :
                                                      theorem MIPRE.Tailored.AnsRed.degreeOf_certSum_le {F : Type u_2} [CommRing F] [Nontrivial F] {n d : ℕ} (c : Fin n → MvPolynomial (Fin n) F) (hc : ∀ (i j : Fin n), MvPolynomial.degreeOf j (c i) ≤ d) (j : Fin n) :

                                                      A certificate sum Σ_i X_i (1 - X_i) c_i has degree at most d + 2 in each variable.

                                                      def MIPRE.Tailored.AnsRed.Pcp.IndDeg {F : Type u_2} [CommRing F] {L : PcpDims} (P : Pcp L F) (d : ℕ) :

                                                      Every polynomial of the PCP has degree at most d in each variable.

                                                      Equations
                                                      • One or more equations did not get rendered due to their size.
                                                      Instances For

                                                        The degree bound of the thirteen check polynomials, for a PCP of degree d and a circuit polynomial of degree dT: each of the six literal factors counted separately.

                                                        Equations
                                                        Instances For
                                                          theorem MIPRE.Tailored.AnsRed.degreeOf_chkAssign_le {F : Type u_2} [CommRing F] [Nontrivial F] {L : PcpDims} {k d dT : ℕ} {v : Fin k → Fin L.m} (hv : Function.Injective v) {g : MvPolynomial (Fin k) F} {β : Fin k → MvPolynomial (Fin k) F} (hg : ∀ (i : Fin k), MvPolynomial.degreeOf i g ≤ d) (hβ : ∀ (j i : Fin k), MvPolynomial.degreeOf i (β j) ≤ d) (i : Fin L.m) :
                                                          theorem MIPRE.Tailored.AnsRed.degreeOf_chkSystemO_le {F : Type u_2} [CommRing F] [Nontrivial F] {L : PcpDims} {d : ℕ} {P : Pcp L F} (hP : P.IndDeg d) (i : Fin L.oW) :

                                                          A factor X_π · g ∘ v - X_ε or g ∘ v - X_ε of the formula check has degree at most d + 1 in each variable.

                                                          theorem MIPRE.Tailored.AnsRed.degreeOf_chkFormula_le {F : Type u_2} [CommRing F] [Nontrivial F] {L : PcpDims} {d dT : ℕ} {T : MvPolynomial (Fin L.m) F} {P : Pcp L F} (hT : ∀ (i : Fin L.m), MvPolynomial.degreeOf i T ≤ dT) (hP : P.IndDeg d) (i : Fin L.m) :
                                                          theorem MIPRE.Tailored.AnsRed.degreeOf_chkPolys_le {F : Type u_2} [CommRing F] [Nontrivial F] {L : PcpDims} {d dT : ℕ} {T : MvPolynomial (Fin L.m) F} {P : Pcp L F} (hT : ∀ (i : Fin L.m), MvPolynomial.degreeOf i T ≤ dT) (hP : P.IndDeg d) (c : MvPolynomial (Fin L.m) F) :
                                                          c ∈ chkPolys T P → ∀ (i : Fin L.m), MvPolynomial.degreeOf i c ≤ chkDeg dT d

                                                          The thirteen check polynomials have degree at most chkDeg dT d in each variable, for a PCP of degree d and a circuit polynomial of degree dT.

                                                          Soundness by Schwartz–Zippel #

                                                          theorem MIPRE.Tailored.AnsRed.chkPolys_eq_zero {F : Type u_2} [Field F] [Fintype F] [DecidableEq F] {L : PcpDims} {d dT : ℕ} {T : MvPolynomial (Fin L.m) F} {P : Pcp L F} (hT : ∀ (i : Fin L.m), MvPolynomial.degreeOf i T ≤ dT) (hP : P.IndDeg d) (S : Finset (Fin L.m → F)) (hS : ∀ p ∈ S, Pcp.Passes T P p) (hdens : ↑L.m * ↑(chkDeg dT d) / ↑(Fintype.card F) < ↑S.card / ↑(Fintype.card F) ^ L.m) (c : MvPolynomial (Fin L.m) F) :
                                                          c ∈ chkPolys T P → c = 0

                                                          The check polynomials of a PCP passing often are zero (prop:completeness_and_soundness_of_PCP_for_V_n, soundness, by Schwartz–Zippel): a PCP of degree d passing the thirteen checks at every point of a set of density more than m · chkDeg / q has all thirteen check polynomials zero.

                                                          theorem MIPRE.Tailored.AnsRed.assignCheck_of_chkAssign_eq_zero {F : Type u_2} [Field F] {L : PcpDims} {k : ℕ} {v : Fin k → Fin L.m} (hv : Function.Injective v) {g : MvPolynomial (Fin k) F} {β : Fin k → MvPolynomial (Fin k) F} (h : chkAssign v g β = 0) (x : Fin k → F) :
                                                          theorem MIPRE.Tailored.AnsRed.identities_of_chkPolys_eq_zero {F : Type u_2} [Field F] {L : PcpDims} {T : MvPolynomial (Fin L.m) F} {P : Pcp L F} (h : ∀ c ∈ chkPolys T P, c = 0) :

                                                          The checks hold identically when their polynomials vanish.

                                                          theorem MIPRE.Tailored.AnsRed.identities_of_dense {F : Type u_2} [Field F] [Fintype F] [DecidableEq F] {L : PcpDims} {d dT : ℕ} {T : MvPolynomial (Fin L.m) F} {P : Pcp L F} (hT : ∀ (i : Fin L.m), MvPolynomial.degreeOf i T ≤ dT) (hP : P.IndDeg d) (S : Finset (Fin L.m → F)) (hS : ∀ p ∈ S, Pcp.Passes T P p) (hdens : ↑L.m * ↑(chkDeg dT d) / ↑(Fintype.card F) < ↑S.card / ↑(Fintype.card F) ^ L.m) :

                                                          The soundness of the PCP, first step (prop:completeness_and_soundness_of_PCP_for_V_n): a PCP of degree d passing the thirteen checks on a set of points of density more than m · chkDeg / q satisfies them identically.