Struct EvolutionModel 

pub struct EvolutionModel<P, L>
where
    P: GenomePrior,
    L: GenomeLikelihood<P::Genome>,
{ /* private fields */ }

A probabilistic model of an evolutionary population: a genome prior program, an observation program (likelihood), and an inverse temperature β.

Implementations

impl<P, F> EvolutionModel<P, FactorFitness<F>>

where P: GenomePrior, F: Fitness<Genome = P::Genome, Value = f64> + Clone + Send + Sync + 'static,

pub fn new(prior: P, fitness: F) -> Self

Create a model with a black-box scalar fitness entering as factor(β·f(x)) (the classical Gibbs-posterior mode), at β = 1.

pub fn fitness_value(&self, genome: &P::Genome) -> f64

Raw fitness f(x) (higher is better).

pub fn log_weight(&self, genome: &P::Genome) -> f64

The tempered fitness log-factor β · f(x).

pub fn to_weighted_trace(&self, genome: &P::Genome) -> Trace

Create a fugue trace whose choices equal the genome’s encoding under this model’s prior and whose total_log_weight() equals β · f(x) — the “fitness as likelihood” weighted-trace contract (EV-52): a genuine factor(β·f) model run through TraceScoringHandler, so the mass lands in log_factors.

impl<P, L> EvolutionModel<P, L>

where P: GenomePrior, L: GenomeLikelihood<P::Genome>,

pub fn from_likelihood(prior: P, likelihood: L) -> Self

Create a model from an arbitrary observation program (observe statements, latent nuisance parameters, factors), at β = 1.

pub fn with_beta(self, beta: f64) -> Self

Set the inverse temperature β directly (β ≥ 0).

pub fn with_temperature(self, temperature: f64) -> Self

Set the temperature T; equivalent to β = 1/T.

pub fn beta(&self) -> f64

Current inverse temperature β.

pub fn temperature(&self) -> f64

Current temperature T = 1/β.

pub fn prior(&self) -> &P

The prior program.

pub fn likelihood(&self) -> &L

The observation program.

pub fn target_model(&self) -> impl Fn() -> Model<P::Genome> + Clone + '_

The fixed-β target as a program: log π_β(x) = log p(x) + β·log p(data|x). This is the model MH runs against.

pub fn smc_model(&self) -> impl Fn() -> Model<P::Genome> + Clone + '_

The untempered (β = 1) joint program for tempered SMC: fugue’s adaptive_smc supplies β by tempering log_likelihood + log_factors, applying it exactly once.

pub fn sample_prior<R: Rng>(&self, rng: &mut R) -> P::Genome

Draw a genome from the prior p(x) by running the prior program.

pub fn score(&self, genome: &P::Genome) -> (P::Genome, Trace)

Score a genome under the fixed-β target by replaying its encoding under this model’s prior (GenomePrior::trace_of) through the target program — so this works for every prior, including generative grammars over trees.

The returned trace satisfies log π_β(g) = trace.total_log_weight() and log p(g) = trace.log_prior. A genome outside the prior’s support scores log_prior = −∞.

Note: if the likelihood contains latent nuisance sites, they are not part of trace_of(g) and would abort a strict replay — score via the SMC/MH drivers in that case (which sample them), or marginalize them externally.

pub fn log_boltzmann_target(&self, genome: &P::Genome) -> f64

Unnormalised log target log π_β(x) = log p(x) + β·log p(data|x).

Trait Implementations

impl<P, L> Clone for EvolutionModel<P, L>

where P: GenomePrior + Clone, L: GenomeLikelihood<P::Genome> + Clone,

fn clone(&self) -> EvolutionModel<P, L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.