Skip to content

zorch.spartan.pcs_glue

Separately deployable roles for the terminal witness-opening reduction.

WitnessOpeningClaim dataclass

Public terminal claim closed by opening the committed witness.

Source code in zorch/spartan/pcs_glue.py 
29
30
31
32
33
34
35
36
37
@dataclass(frozen=True)
class WitnessOpeningClaim:
    """Public terminal claim closed by opening the committed witness."""

    commitment: Array
    point: Array
    product_value: Array
    matrix_value: Array
    public_value: Array

WitnessOpeningWitness dataclass

Private PCS opening state for WitnessOpeningClaim.

Source code in zorch/spartan/pcs_glue.py 
40
41
42
43
44
@dataclass(frozen=True)
class WitnessOpeningWitness:
    """Private PCS opening state for ``WitnessOpeningClaim``."""

    prover_data: Any

WitnessOpenProof dataclass

Witness evaluation and the underlying PCS opening proof.

Source code in zorch/spartan/pcs_glue.py 
47
48
49
50
51
52
@dataclass(frozen=True)
class WitnessOpenProof:
    """Witness evaluation and the underlying PCS opening proof."""

    values: Array
    pcs_proof: Any

WitnessOpenProver

Bases: ProverStage[WitnessOpeningClaim, WitnessOpeningWitness, TrivialClaim, WitnessOpenProof]

Prove a committed-witness opening; owns only the PCS prover capability.

Source code in zorch/spartan/pcs_glue.py 
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
class WitnessOpenProver(
    ProverStage[
        WitnessOpeningClaim, WitnessOpeningWitness, TrivialClaim, WitnessOpenProof
    ]
):
    """Prove a committed-witness opening; owns only the PCS prover capability."""

    def __init__(
        self,
        pcs_prover: ProverStage[
            OpeningClaim[Any], OpeningWitness[Any], TrivialClaim, OpeningProof[Any]
        ],
    ) -> None:
        self.pcs_prover = pcs_prover

    def prove(
        self,
        claim: WitnessOpeningClaim,
        witness: WitnessOpeningWitness,
        transcript: Transcript,
    ) -> ProveResult[TrivialClaim, WitnessOpenProof]:
        opened = self.pcs_prover.prove(
            OpeningClaim(claim.commitment, [claim.point[1:]]),
            OpeningWitness(witness.prover_data),
            transcript,
        )
        inner = opened.reduction_proof
        return ProveResult(
            TrivialClaim(),
            WitnessOpenProof(inner.values, inner.proof),
            opened.transcript,
        )

WitnessOpenVerifier

Bases: VerifierStage[WitnessOpeningClaim, TrivialClaim, WitnessOpenProof]

Verify a committed-witness opening; owns only the PCS verifier capability.

Source code in zorch/spartan/pcs_glue.py 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
class WitnessOpenVerifier(
    VerifierStage[WitnessOpeningClaim, TrivialClaim, WitnessOpenProof]
):
    """Verify a committed-witness opening; owns only the PCS verifier capability."""

    def __init__(
        self,
        pcs_verifier: VerifierStage[OpeningClaim[Any], TrivialClaim, OpeningProof[Any]],
    ) -> None:
        self.pcs_verifier = pcs_verifier

    def verify(
        self,
        claim: WitnessOpeningClaim,
        reduction_proof: WitnessOpenProof,
        transcript: Transcript,
    ) -> VerifyResult[TrivialClaim]:
        verified = self.pcs_verifier.verify(
            OpeningClaim(claim.commitment, [claim.point[1:]]),
            OpeningProof(reduction_proof.values, reduction_proof.pcs_proof),
            transcript,
        )
        ok_open, transcript = verified.ok, verified.transcript
        eval_w = reduction_proof.values[0]
        z_eval = recombine_z_eval(eval_w, claim.public_value, claim.point[0])
        ok_final = claim.product_value == claim.matrix_value * z_eval
        return VerifyResult(TrivialClaim(), transcript, ok_open & ok_final)

witness_opening_claim 

witness_opening_claim(
    commitment: Array,
    instance: R1CS,
    public_inputs: Array,
    row: RowEvaluationClaim,
    batch: BatchedClaims,
    column: ColumnEvaluationClaim,
) -> WitnessOpeningClaim

Derive the terminal public claim from preceding reduced claims.

Source code in zorch/spartan/pcs_glue.py 
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
def witness_opening_claim(
    commitment: Array,
    instance: R1CS,
    public_inputs: Array,
    row: RowEvaluationClaim,
    batch: BatchedClaims,
    column: ColumnEvaluationClaim,
) -> WitnessOpeningClaim:
    """Derive the terminal public claim from preceding reduced claims."""
    public_value = eval_public_half(
        public_inputs, column.point[1:], instance.num_vars_padded
    )
    matrix_value = instance.eval_combined_matrix(
        row.point, column.point, batch.challenge
    )
    return WitnessOpeningClaim(
        commitment,
        column.point,
        column.value,
        matrix_value,
        public_value,
    )