Struct Selector

pub struct Selector(/* private fields */);

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

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

use halo2_axiom::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 halo2_axiom::{
    circuit::{Chip, Layouter, Value},
    plonk::{Advice, Column, Error, Selector},
};
use ff::Field;

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(config.a, 0, Value::known(F::ONE));
        region.assign_advice(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.

pub fn index(&self) -> usize

Returns index of this selector

pub fn expr<F: Field>(&self) -> Expression<F>

Return expression from selector

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 for Selector

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

Tests for self and other values to be equal, and is used by ==.

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

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 StructuralPartialEq for Selector