Enum BooleanTraceCommitmentError 

#[non_exhaustive]
pub enum BooleanTraceCommitmentError<E> {
    Boolean(E),
    StackedArity {
        expected: usize,
        actual: usize,
    },
    TableShapeMismatch {
        table: usize,
        expected: TableShape,
        actual: TableShape,
    },
    TableCountMismatch {
        expected: usize,
        actual: usize,
    },
    NonBooleanCell {
        table: usize,
        column: usize,
    },
    PointCount {
        expected: usize,
        actual: usize,
    },
    PointArity {
        table: usize,
        expected: usize,
        actual: usize,
    },
    ValueCount {
        expected: usize,
        actual: usize,
    },
    ColumnBatchTranscript(TranscriptError),
    ColumnBatchValueMismatch {
        batch: usize,
    },
}

Why a Boolean trace could not be committed or opened.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Boolean(E)

The bit commitment underneath refused the witness or the opening.

StackedArity

The table shapes do not stack to the arity this commitment holds.

Fields

expected: usize

Variables the commitment holds.

actual: usize

Variables the shapes stack to.

TableShapeMismatch

The retained source tables do not have the exact shapes promised by the opening protocol.

Fields

table: usize

Table whose retained shape disagreed with the protocol.

expected: TableShape

Shape the protocol describes.

actual: TableShape

Shape the committed prover data retains.

TableCountMismatch

The protocol and retained source table lists have different lengths.

Fields

expected: usize

Number of tables described by the protocol.

actual: usize

Number of tables retained by the prover.

NonBooleanCell

A trace cell holds neither zero nor one, so it addresses no bit.

Fields

table: usize

Table holding the cell.

column: usize

Column holding the cell.

PointCount

One point per opening batch is required.

Fields

expected: usize

Batches the protocol schedules.

actual: usize

Points supplied.

PointArity

A point does not name the rows of the table it opens.

Fields

table: usize

Table the point opens.

expected: usize

Variables that table’s rows need.

actual: usize

Variables the point names.

ValueCount

The proof carries a different number of values than the protocol opens.

A column read at both rows carries one reading per row, so the count is readings, one per value position.

Fields

expected: usize

Readings the protocol opens, one per value position.

actual: usize

Values the proof carries.

ColumnBatchTranscript(TranscriptError)

A typed column-batching transcript could not replay its proof shape.

ColumnBatchValueMismatch

The inner opening disagreed with the prover’s independently computed batch value.

Fields

batch: usize

Batch whose aggregate value disagreed.

Trait Implementations

impl<E: Debug> Debug for BooleanTraceCommitmentError<E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E> Display for BooleanTraceCommitmentError<E>

where E: Display,

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E> Error for BooleanTraceCommitmentError<E>

where E: Error, Self: Debug + Display,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<E> From<TranscriptError> for BooleanTraceCommitmentError<E>

fn from(source: TranscriptError) -> Self

Converts to this type from the input type.