Struct Program 

pub struct Program {
    pub name: Option<String>,
    pub spins: usize,
    pub bias: Vec<(usize, f64)>,
    pub factors: Vec<Factor>,
    pub colors: Vec<Vec<usize>>,
    pub encodings: Vec<EncodedVar>,
    pub schedule: Schedule,
    pub observe: Vec<String>,
    pub target: Option<String>,
    pub price: Option<String>,
}

A complete program.

Fields

name: Option<String>

spins: usize

bias: Vec<(usize, f64)>

factors: Vec<Factor>

colors: Vec<Vec<usize>>

encodings: Vec<EncodedVar>

schedule: Schedule

observe: Vec<String>

target: Option<String>

price: Option<String>

Implementations

impl Program

pub fn from_graph(g: &Graph, schedule: &Schedule) -> Program

Build a program from a graph and a schedule.

pub fn to_graph(&self) -> Result<Graph, FtpError>

Rebuild a graph from this program. Factors of arity above two are refused here rather than silently dropped; lowering them to pairwise is a separate pass with its own ancillas.

Examples found in repository

examples/hubo_vs_reduction.rs (line 139)

fn main() {
    let cases: [(usize, usize, usize); 4] = [(24, 3, 32), (32, 3, 48), (24, 4, 24), (40, 3, 60)];
    let budgets: [usize; 6] = [1, 4, 16, 64, 256, 1024];

    println!("hubo native vs Rosenberg reduction, on the same terms");
    println!(
        "mean best energy of the ORIGINAL model over {SEEDS} seeds; lower is better.\n\
         The native arm runs once, at 1x. Every reduced column is a MULTIPLE of that same budget.\n"
    );

    print!(
        "{:>4} {:>2} {:>4} {:>6} {:>4} {:>7} {:>8}  ",
        "n", "k", "trm", "spins", "anc", "pen/w", "native"
    );
    for b in budgets {
        print!("{:>9}", format!("red {b}x"));
    }
    println!("   broken");

    for (n, k, t) in cases {
        let mut native = 0.0f64;
        let mut reduced = [0.0f64; 6];
        let mut broken = 0usize;
        let (mut ancillas, mut rspins, mut penalty) = (0usize, 0usize, 0.0f64);

        for seed in 0..SEEDS {
            let terms = instance(n, k, t, seed);
            let h = hubo_of(&terms, n);
            let prog = Program::from_ftp(&ftp_of(&terms, n)).expect("a well-formed program");
            let red = reduce::to_pairwise(&prog).expect("a reducible program");
            let g = red.program.to_graph().expect("a pairwise graph");
            ancillas = red.ancillas;
            rspins = red.program.spins;
            penalty = red.penalty;

            let p = hubo::Params {
                beta_min: 0.05,
                beta_max: 8.0,
                stages: STAGES,
                sweeps_per_stage: SWEEPS,
            };
            native += hubo::anneal(&h, &p, seed).energy;

            let ladder = geometric_ladder(REDUCED_BETA_MIN, 8.0, STAGES);
            for (i, mult) in budgets.iter().enumerate() {
                let sched: Vec<(f64, usize)> =
                    ladder.iter().map(|&b| (b, SWEEPS * mult)).collect();
                let (state, reduced_e) = tempering::anneal(&g, &sched, seed, None);
                let original_e = h.energy(&state[..n]);
                reduced[i] += original_e;
                // Comparing the two energies IS the ancilla check, and it needs no knowledge of
                // which spins are ancillas or of how they were defined.
                if ((reduced_e + red.offset) - original_e).abs() > 1e-6 {
                    broken += 1;
                }
            }
        }

        let m = SEEDS as f64;
        print!(
            "{n:>4} {k:>2} {t:>4} {rspins:>6} {ancillas:>4} {:>7.0} {:>8.2}  ",
            penalty,
            native / m
        );
        for r in reduced {
            print!("{:>9.2}", r / m);
        }
        println!("   {:>3}/{}", broken, SEEDS as usize * budgets.len());
    }

    println!(
        "\n'anc' is the ancillas the reduction added and 'spins' the graph it had to search: each \
         one is a variable\nthe answer depends on and the question never mentioned. The native path \
         adds none.\n\n\
         'pen/w' is the penalty the reduction chose, against term weights of 1. That ratio is the \
         mechanism: any\nsingle flip that would move the search must first pay it, so the landscape \
         is rigid and a single-flip\nsampler cannot traverse it. 'broken' counts runs whose ancillas \
         did not hold, and it stays at zero --\nwhich is the confirmation, not a null result: the \
         reduced arm is stuck inside the feasible region\nrather than wandering out of it.\n\n\
         The budget columns are the finding. If the reduced arm caught up at 64x or 256x, the cost \
         of quadratising\nwould be compute, and compute is buyable."
    );
}

pub fn to_ftp(&self) -> String

Serialise. The output re-parses to an equal program and re-writes byte-identically.

pub fn from_ftp(text: &str) -> Result<Program, FtpError>

Parse. Errors carry the line number, because a format nobody can debug is a format nobody adopts.

Examples found in repository

examples/hubo_vs_reduction.rs (line 137)

fn main() {
    let cases: [(usize, usize, usize); 4] = [(24, 3, 32), (32, 3, 48), (24, 4, 24), (40, 3, 60)];
    let budgets: [usize; 6] = [1, 4, 16, 64, 256, 1024];

    println!("hubo native vs Rosenberg reduction, on the same terms");
    println!(
        "mean best energy of the ORIGINAL model over {SEEDS} seeds; lower is better.\n\
         The native arm runs once, at 1x. Every reduced column is a MULTIPLE of that same budget.\n"
    );

    print!(
        "{:>4} {:>2} {:>4} {:>6} {:>4} {:>7} {:>8}  ",
        "n", "k", "trm", "spins", "anc", "pen/w", "native"
    );
    for b in budgets {
        print!("{:>9}", format!("red {b}x"));
    }
    println!("   broken");

    for (n, k, t) in cases {
        let mut native = 0.0f64;
        let mut reduced = [0.0f64; 6];
        let mut broken = 0usize;
        let (mut ancillas, mut rspins, mut penalty) = (0usize, 0usize, 0.0f64);

        for seed in 0..SEEDS {
            let terms = instance(n, k, t, seed);
            let h = hubo_of(&terms, n);
            let prog = Program::from_ftp(&ftp_of(&terms, n)).expect("a well-formed program");
            let red = reduce::to_pairwise(&prog).expect("a reducible program");
            let g = red.program.to_graph().expect("a pairwise graph");
            ancillas = red.ancillas;
            rspins = red.program.spins;
            penalty = red.penalty;

            let p = hubo::Params {
                beta_min: 0.05,
                beta_max: 8.0,
                stages: STAGES,
                sweeps_per_stage: SWEEPS,
            };
            native += hubo::anneal(&h, &p, seed).energy;

            let ladder = geometric_ladder(REDUCED_BETA_MIN, 8.0, STAGES);
            for (i, mult) in budgets.iter().enumerate() {
                let sched: Vec<(f64, usize)> =
                    ladder.iter().map(|&b| (b, SWEEPS * mult)).collect();
                let (state, reduced_e) = tempering::anneal(&g, &sched, seed, None);
                let original_e = h.energy(&state[..n]);
                reduced[i] += original_e;
                // Comparing the two energies IS the ancilla check, and it needs no knowledge of
                // which spins are ancillas or of how they were defined.
                if ((reduced_e + red.offset) - original_e).abs() > 1e-6 {
                    broken += 1;
                }
            }
        }

        let m = SEEDS as f64;
        print!(
            "{n:>4} {k:>2} {t:>4} {rspins:>6} {ancillas:>4} {:>7.0} {:>8.2}  ",
            penalty,
            native / m
        );
        for r in reduced {
            print!("{:>9.2}", r / m);
        }
        println!("   {:>3}/{}", broken, SEEDS as usize * budgets.len());
    }

    println!(
        "\n'anc' is the ancillas the reduction added and 'spins' the graph it had to search: each \
         one is a variable\nthe answer depends on and the question never mentioned. The native path \
         adds none.\n\n\
         'pen/w' is the penalty the reduction chose, against term weights of 1. That ratio is the \
         mechanism: any\nsingle flip that would move the search must first pay it, so the landscape \
         is rigid and a single-flip\nsampler cannot traverse it. 'broken' counts runs whose ancillas \
         did not hold, and it stays at zero --\nwhich is the confirmation, not a null result: the \
         reduced arm is stuck inside the feasible region\nrather than wandering out of it.\n\n\
         The budget columns are the finding. If the reduced arm caught up at 64x or 256x, the cost \
         of quadratising\nwould be compute, and compute is buyable."
    );
}

pub fn digest(&self) -> u64

A stable digest of the canonical text, for asserting that two runs ran the same program.

FNV-1a over the serialisation. Not a security hash and not claimed to be one; it answers “is this the same program” and nothing else.

Trait Implementations

impl Clone for Program

fn clone(&self) -> Program

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Program

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

Formats the value using the given formatter.

impl Default for Program

fn default() -> Program

Returns the “default value” for a type.

impl PartialEq for Program

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Program