Omega vs Trace

[zenna]

The purpose of this is to discuss the difference between Omega values and trace values.

Omega

• An ω object is a mapping Ω : K -> V where K is a set of keys and V is a set of values
• The set of Keys is the set of integer tuples Tuple{UInt}
• There's a finite set P of primitive random variable classes
• A primitive random variable is then identified as a pair (k ∈ K, p ∈ P)
• A class is a sequence of random variables, expressed as a function f where f(i, ω) is x_i(ω)

Currently, in reality the setup is slightly different in that Ω : K * P -> V, i.e. a mapping from primitive random variables to values.

• This wasn't necessary before because we assumed the sample space was Lebesgue on unit hypercube
• It becomes necessary when we are more agnostic about what the base measure is, since it needs to be specified somewhere
• Concretely, if we have an inference procedure that modifies a primitive random variable, it needs to know what it is modifying
• Similarly when we compute the logpdf, we need to know the underlying primtiives, if we assume they aren't all the same, e..g stduniforms

The primitive distributions then have the form, e.g.:

StdUnif(i, ω) = ω((i, StdUnif))

which is kinda cute.

Q. Is fact that in practice Ω is mapping from primitive random variables implementation quirk or fundamental?

Trace

• A trace τ in T object is a mapping T: RV -> V
• There's a sense, which we could formalise, in which a trace can be consistent or inconsistent with some ω
  • Essentially, τ is consistent with ω if for all X in τ, X(ω) = τ(X)
  • What is τ for?
    • Providing information about random variables through conditioning
    • Specifying proposals

The main questions are

• Are T and Ω distinct conceptually and fundamentally?
• In implementation is it better to keep have them be the same thing or have them be distinct things

[zenna]

It might conceptually cleaner to keep them separate but I think it'll make implementation a headache, at least in the near future.

One way to be conceptually satisfied is instead of the above formalism to say that Ω: RV -> V and formulate a notion of self consistency