Struct halo2_proofs::plonk::Selector

pub struct Selector(_, _);

A selector, representing a fixed boolean value per row of the circuit.

Selectors can be used to conditionally enable (portions of) gates:

use halo2_proofs::poly::Rotation;

let a = meta.advice_column();
let b = meta.advice_column();
let s = meta.selector();

meta.create_gate("foo", |meta| {
    let a = meta.query_advice(a, Rotation::prev());
    let b = meta.query_advice(b, Rotation::cur());
    let s = meta.query_selector(s);

    // On rows where the selector is enabled, a is constrained to equal b.
    // On rows where the selector is disabled, a and b can take any value.
    vec![s * (a - b)]
});

Selectors are disabled on all rows by default, and must be explicitly enabled on each row when required:

use group::ff::Field;
use halo2_proofs::{
    circuit::{Chip, Layouter, Value},
    plonk::{Advice, Column, Error, Selector},
};

struct Config {
    a: Column<Advice>,
    b: Column<Advice>,
    s: Selector,
}

fn circuit_logic<F: Field, C: Chip<F>>(chip: C, mut layouter: impl Layouter<F>) -> Result<(), Error> {
    let config = chip.config();
    layouter.assign_region(|| "bar", |mut region| {
        region.assign_advice(|| "a", config.a, 0, || Value::known(F::ONE))?;
        region.assign_advice(|| "a", config.b, 1, || Value::known(F::ONE))?;
        config.s.enable(&mut region, 1)
    })?;
    Ok(())
}

Implementations

impl Selector

pub fn enable<F: Field>( &self, region: &mut Region<'_, F>, offset: usize ) -> Result<(), Error>

Enable this selector at the given offset within the given region.

pub fn is_simple(&self) -> bool

Is this selector “simple”? Simple selectors can only be multiplied by expressions that contain no other simple selectors.

Trait Implementations

impl Clone for Selector

fn clone(&self) -> Selector

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Selector

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

Formats the value using the given formatter.

impl From<Selector> for RegionColumn

fn from(selector: Selector) -> RegionColumn

Converts to this type from the input type.

impl Hash for Selector

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Selector> for Selector

fn eq(&self, other: &Selector) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Selector

impl Eq for Selector

impl StructuralEq for Selector

impl StructuralPartialEq for Selector