Original: Transforming Worlds: Automated Involutive MCMC for Open-Universe Probabilistic Models
Revised: Transforming Worlds: Automated Involutive MCMC for Open-Universe Probabilistic Models

Original: 1. Introduction
Revised: 1. Introduction

Original: Open-universe probabilistic models (OUPMs) enable Bayesian inference about the existence and attributes of latent objects underlying observed data, as well as their interconnections.
Revised: Open-universe probabilistic models (OUPMs) enable Bayesian inference about the existence and attributes of latent objects underlying observed data, as well as their interconnections.

Original: Prominent applications include seismic monitoring for global nuclear safety (Arora et al., 2013; Arora, 2012); information extraction from natural language documents (Russell et al., 2016); generating realistic 3D scenes with varying numbers of objects (Yeh et al., 2012); “inverse graphics” approaches to breaking CAPTCHAs (Mansinghka et al., 2013) and inferring 3D scenes from 2D data (Kulkarni et al., 2015; Zinberg et al., 2019); and simultaneous deduplication, cleaning, and record linkage from real-world databases with millions of records (Lew et al., 2020).
Revised: Prominent applications include seismic monitoring for global nuclear safety (Arora et al., 2013; Arora, 2012); information extraction from natural language documents (Russell et al., 2016); generating realistic 3D scenes with varying numbers of objects (Yeh et al., 2012); “inverse graphics” approaches to breaking CAPTCHAs (Mansinghka et al., 2013) and inferring 3D scenes from 2D data (Kulkarni et al., 2015; Zinberg et al., 2019); and simultaneous deduplication, cleaning, and record linkage from real-world databases with millions of records (Lew et al., 2020).

Original: Because the state space in OUPMs has a priori unknown dimension, popular black-box inference algorithms such as Hamiltonian Monte Carlo cannot be applied.
Revised: Because the state space in OUPMs has a priori unknown dimension, popular black-box inference algorithms such as Hamiltonian Monte Carlo cannot be applied.

Original: Instead, applications rely on custom MCMC kernels.
Revised: Instead, applications rely on custom MCMC kernels.

Original: These kernels use application-speciﬁc, data-driven heuristics to intelligently delete, split, or merge hypothesized objects, “birth” new objects, and modify the properties of and relationships between objects.
Revised: These kernels use application-speciﬁc, data-driven heuristics to intelligently delete, split, or merge hypothesized objects, “birth” new objects, and modify the properties of and relationships between objects.

Original: Although these proposals can be designed and justiﬁed in the reversible-jump MCMC framework, this is often challenging.
Revised: Although these proposals can be designed and justiﬁed in the reversible-jump MCMC framework, this is often challenging.

Original: As Brooks et al.
Revised: As Brooks et al.

Original: (2003) noted, “the application of reversible jump...has predominantly remained within the domain of the MCMC expert,” due to the diﬃculty of deriving and implementing eﬀective RJMCMC kernels.
Revised: (2003) noted, “the application of reversible jump...has predominantly remained within the domain of the MCMC expert,” due to the diﬃculty of deriving and implementing eﬀective RJMCMC kernels.

Original: This abstract introduces a new framework for OUPM inference that makes it easier to design and implement custom, data-driven kernels.
Revised: This abstract introduces a new framework for OUPM inference that makes it easier to design and implement custom, data-driven kernels.

Original: We adapt involutive MCMC (CusumanoTowner et al., 2020; Neklyudov et al., 2020), a generalization of reversible-jump MCMC, to the setting of OUPMs.
Revised: We adapt involutive MCMC (CusumanoTowner et al., 2020; Neklyudov et al., 2020), a generalization of reversible-jump MCMC, to the setting of OUPMs.

Original: This enables software to automatically generate correct and scalable implementations of complex, application-speciﬁc kernels from high-level user speciﬁcations.
Revised: This enables software to automatically generate correct and scalable implementations of complex, application-speciﬁc kernels from high-level user speciﬁcations.

Original: Users design inference programs that propose incremental changes to possible worlds, creat ing, deleting, or modifying objects according to data-driven, application-speciﬁc heuristics; these proposals are automatically converted into stationary MCMC kernels via an accep- t/reject step
Revised: Users design inference programs that propose incremental changes to possible worlds, creat ing, deleting, or modifying objects according to data-driven, application-speciﬁc heuristics; these proposals are automatically converted into stationary MCMC kernels via an accep- t/reject step

Original: To automatically compute the acceptance probability, our approach leverages program tracing and dependency tracking (for eﬃcient computation of proposal and model densities and diﬀerentiable programming
Revised: To automatically compute the acceptance probability, our approach leverages program tracing and dependency tracking (for eﬃcient computation of proposal and model densities and diﬀerentiable programming

Original: (for the Jacobian determinant)
Revised: (for the Jacobian determinant)

Original: Preliminary experiments on (1) an auditory scene analysis application
Revised: Preliminary experiments on (1) an auditory scene analysis application

Original: Cusimano et al.,
Revised: Cusimano et al.,

Original: ) (Figure 3) and (2) Gaussian mixture modeling with an unknown number of components (Richardson and Green,
Revised: ) (Figure 3) and (2) Gaussian mixture modeling with an unknown number of components (Richardson and Green,

Original: ) (Figure 4) show that our approach enables data-driven kernels that are faster than generic probabilistic programming language (PPL) inference and generic birth/death RJMCMC kernels without application-speciﬁc customizations.
Revised: ) (Figure 4) show that our approach enables data-driven kernels that are faster than generic probabilistic programming language (PPL) inference and generic birth/death RJMCMC kernels without application-speciﬁc customizations.

Original: Related Work.
Revised: Related Work.

Original: We build on involutive MCMC, introduced by Cusumano-Towner et al.
Revised: We build on involutive MCMC, introduced by Cusumano-Towner et al.

Original: (2020) as a framework supporting higher degrees of automation for application-speciﬁc
Revised: (2020) as a framework supporting higher degrees of automation for application-speciﬁc

Original: MCMC algorithms, and (independently) as a mathematical generalization of many classic MCMC methods by Neklyudov et al.
Revised: MCMC algorithms, and (independently) as a mathematical generalization of many classic MCMC methods by Neklyudov et al.

Original: Our main theoretical contribution is a generalization of involutive MCMC to OUPMs.
Revised: Our main theoretical contribution is a generalization of involutive MCMC to OUPMs.

Original: We compare our approach to the generic ancestral resampling MH algorithm
Revised: We compare our approach to the generic ancestral resampling MH algorithm

Original: (Wingate et al., 2011) used by many probabilistic programming languages supporting OUPMs, such as BLOG (Milch et al., 2005a).
Revised: (Wingate et al., 2011) used by PPLs such as BLOG (Milch et al., 2005a).

Original: Previous work has explored using application-speciﬁc kernels for BLOG models (Milch and Russell, 2012), but these require modifying the BLOG inference engine’s source code and manually deriving parts of the acceptance ratio.
Revised: Previous work has explored using application-speciﬁc kernels for BLOG models (Milch and Russell, 2012), but requires modifying the BLOG inference engine’s source code.

Original: The Gen (Cusumano-Towner et al., 2019) and Stochaskell (Roberts et al., 2019)
Revised: The Gen (Cusumano-Towner et al., 2019) and Stochaskell (Roberts et al., 2019)

Original: PPLs support forms of automated reversible-jump MCMC, but neither features high-level OUPM inference constructs; custom kernels in both languages operate on low-level program traces, not high-levelobject-based world representations, which can compromiseboth ease of use and asymptotic performance.
Revised: PPLs support forms of automated reversible-jump MCMC, but neither features high-level OUPM inference constructs; custom kernels in both languages operate on low-level program traces, not high-level world representations, which can compromise ease of use and asymptotic performance.

Original: Furthermore, the automation technique proposed by Roberts et al.
Revised: The automation technique proposed by Roberts et al.

Original: (2019) does not support unrestricted use of auxiliary variables, and (e.g.) cannot handle the algorithms benchmarked in Figure 3.
Revised: (2019) does not support unrestricted use of auxiliary variables, and (e.g.) cannot handle the algorithms benchmarked in Figure 3.

Revised: Zhou et al.

Revised: (2020) introduce an automated inference approach applicable to

Revised: OUPMs, which does not address the implementation of custom MCMC kernels.

Original: 2. Open Universe Probabilistic Models
Revised: 2. Open Universe Probabilistic Models

Original: Figure 1 shows an open-universe model for inferring the set of seismic events underlying observed detections from seismic monitoring stations.
Revised: Figure 1 shows an open-universe model for inferring the set of seismic events underlying observed detections from seismic monitoring stations.

Original: A priori, it is unknown how many events there are, and which detections correspond to the same event (or, in the case of spurious false positives, to no event at all).
Revised: A priori, it is unknown how many events there are, and which detections correspond to the same event (or, in the case of spurious false positives, to no event at all).

Original: Standard probabilistic graphical models are ill-suited for encoding this sort of uncertainty about the number of objects reﬂected in a dataset and their causal relationships.
Revised: Standard probabilistic graphical models are ill-suited for encoding this sort of uncertainty about the number of objects reﬂected in a dataset and their causal relationships.

Original: Open-universe probabilistic models enable reasoning about such problems, by deﬁning generative processes over entire relational domains.
Revised: Open-universe probabilistic models enable reasoning about such problems, by deﬁning generative processes over entire relational domains.

Original: Model speciﬁcation.
Revised: Model speciﬁcation.

Original: An OUPM is fully speciﬁed by: (1) a ﬁnite set T of object types (in Figure 1, Event , Station , and Detection ); (2) a ﬁnite set N τ of possible origins for each object type τ (in Figure 1, a Detection may originate from a ( Station , Event ) pair, or from a single ( Station ) that records a false positive); (3) a countable set P of typed object properties P ( τ 1 , . . .
Revised: An OUPM is fully speciﬁed by: (1) a ﬁnite set T of object types (in Figure 1, Event , Station , and Detection ); (2) a ﬁnite set N τ of possible origins for each object type τ (in Figure 1, a Detection may originate from a ( Station , Event ) pair, or from a single ( Station ) that records a false positive); (3) a countable set P of typed object properties P ( τ 1 , . . .

Original: , τ n ) (such as magnitude(Event) and reading(Detection) ); and (4) a contingent Bayesian network C over a set of random variables that encode the number of objects that exist, as well as their properties and relationships (Milch et al., 2005b).
Revised: , τ n ) (such as magnitude(Event) and reading(Detection) ); and (4) a contingent Bayesian network C over a set of random variables that encode the number of objects that exist, as well as their properties and relationships (Milch et al., 2005b).

Original: Contingent Bayesian networks.
Revised: Contingent Bayesian networks.

Original: The probabilistic structure of an OUPM is given by a contingent Bayesian network C over an inﬁnite set V of possible variables .
Revised: The probabilistic structure of an OUPM is given by a contingent Bayesian network C over an inﬁnite set V of possible variables .

Original: These variables are deﬁned in terms of objects : we write τ (( o 1 , . . .
Revised: These variables are deﬁned in terms of objects : we write τ (( o 1 , . . .

Original: , o n ) , i ) to refer to the i th object of type τ with origin ( o 1 , . . .
Revised: , o n ) , i ) to refer to the i th object of type τ with origin ( o 1 , . . .

Original: , o n ).
Revised: , o n ).

Original: Then each node v ∈ V of the contingent Bayesian network corresponds to either a number variable N τ ( o 1 , . . .
Revised: Then each node v ∈ V of the contingent Bayesian network corresponds to either a number variable N τ ( o 1 , . . .

Original: , o n ), which represents the number of objects of type τ with origin ( o 1 , . .
Revised: , o n ), which represents the number of objects of type τ with origin ( o 1 , . .

Original: . , o n ), or to a property variable P ( o 1 , . .
Revised: . , o n ), or to a property variable P ( o 1 , . .

Original: o n ), which represents the value of the property P for the given tuple of objects.
Revised: o n ), which represents the value of the property P for the given tuple of objects.

Original: Like an ordinary Bayesian network, a contingent Bayesian network uses a directed graph to describe the probabilistic dependencies among variables.
Revised: Like an ordinary Bayesian network, a contingent Bayesian network uses a directed graph to describe the probabilistic dependencies among variables.

Original: However, the edges in a CBN’s graph are contingent: they are
Revised: However, the edges in a CBN’s graph are contingent: they are

Original: [Figure]
Revised: [Figure]

Original: procedure OUPM-IMCMC ( p, q, f, x ) ( y, q x ( y )) ← SampleAndScore ( q, x ) ( U, M, y (cid:48) , J ) ← ProcessInvolution ( f, ( x, y ))
Revised: procedure OUPM-IMCMC ( p, q, f, x ) ( y, q x ( y )) ← SampleAndScore ( q, x ) ( U, M, y (cid:48) , J ) ← ProcessInvolution ( f, ( x, y ))

Original: ( x (cid:48) , p ( x (cid:48) ) p ( x ) )
Revised: ( x (cid:48) , p ( x (cid:48) ) p ( x ) )

Original: ← UpdateWorld ( x, U, M ) q x (cid:48) ( y (cid:48) )
Revised: ← UpdateWorld ( x, U, M ) q x (cid:48) ( y (cid:48) )

Original: ← Score ( q, x (cid:48) , y (cid:48) ) with probability p ( x (cid:48) ) p ( x ) × q x (cid:48) ( y (cid:48) )
Revised: ← Score ( q, x (cid:48) , y (cid:48) ) with probability p ( x (cid:48) ) p ( x ) × q x (cid:48) ( y (cid:48) )

Original: × 1 q x ( y ) ×
Revised: × 1 q x ( y ) ×

Original: J return x (cid:48) else return x end procedure procedure ProcessInvolution ( f, ( x, y ))
Revised: J return x (cid:48) else return x end procedure procedure ProcessInvolution ( f, ( x, y ))

Original: (cid:46) Track continuous reads and writes, manipulation moves M , and property updates U (Rd , Wr , M, U, y (cid:48) )
Revised: (cid:46) Track continuous reads and writes, manipulation moves M , and property updates U (Rd , Wr , M, U, y (cid:48) )

Original: ← {} , {} , [ ] , {} , {}
Revised: ← {} , {} , [ ] , {} , {}

Original: Execute f , but with each manipulation command m ( create , delete , change , split , merge ) ≡ ( M ← M ∪ { m } ) "proposed [ k ] " ≡ ( if y [ k ] is continuous:
Revised: Execute f , but with each manipulation command m ( create , delete , change , split , merge ) ≡ ( M ← M ∪ { m } ) "proposed [ k ] " ≡ ( if y [ k ] is continuous:

Original: Rd ← Rd ∪ { y [ k ] } ; y [ k ]) "set backward [ k ] = v " ≡ ( if v is continuous:
Revised: Rd ← Rd ∪ { y [ k ] } ; y [ k ]) "set backward [ k ] = v " ≡ ( if v is continuous:

Original: Wr ← Wr ∪ { y [ k ] } ; y (cid:48)
Revised: Wr ← Wr ∪ { y [ k ] } ; y (cid:48)

Original: ← y (cid:48) ∪ { k (cid:55)→ v } ) "get ( P ( o 1 , . . .
Revised: ← y (cid:48) ∪ { k (cid:55)→ v } ) "get ( P ( o 1 , . . .

Original: , o n )
Revised: , o n )

Original: ) " ≡ ( v ← x
Revised: ) " ≡ ( v ← x

Original: [ P ( o 1 , . . .
Revised: [ P ( o 1 , . . .

Original: , o n )]; if v is continuous:
Revised: , o n )]; if v is continuous:

Original: Rd ← Rd ∪ { v } ; v ) "set P ( o 1 , . . .
Revised: Rd ← Rd ∪ { v } ; v ) "set P ( o 1 , . . .

Original: , o n ) = v " ≡ ( if v is continuous:
Revised: , o n ) = v " ≡ ( if v is continuous:

Original: Wr ← Wr ∪ { v } ; U [ P ( o 1 , . . .
Revised: Wr ← Wr ∪ { v } ; U [ P ( o 1 , . . .

Original: , o n )] ← v ) J ← uninitialized | Rd | × | Rd | matrix for i in { 1 , . . .
Revised: , o n )] ← v ) J ← uninitialized | Rd | × | Rd | matrix for i in { 1 , . . .

Original: , | Wr |} : (cid:46) Execute f with reverse-mode AD to compute ∂
Revised: , | Wr |} : (cid:46) Execute f with reverse-mode AD to compute ∂

Original: Wr[ i ] ∂
Revised: Wr[ i ] ∂

Original: Rd
Revised: Rd

Original: [ j ] for each j ∈ { 1 , . .
Revised: [ j ] for each j ∈ { 1 , . .

Original: | Rd |}
Revised: | Rd |}

Original: J [: , i ] ← ∇ Rd (Wr[ i ]) return ( U, M, y (cid:48) , | det J | ) end procedure labeled with predicates, involving the other possible variables, determining the conditions under which they are active .
Revised: J [: , i ] ← ∇ Rd (Wr[ i ]) return ( U, M, y (cid:48) , | det J | ) end procedure labeled with predicates, involving the other possible variables, determining the conditions under which they are active .

Original: The conditional distribution for a variable v , p v ( ω [ v ] | ω Pa ω ( v ) ), may depend only on v ’s active parents P a ω ( v ) in a particular possible world ω .
Revised: The conditional distribution for a variable v , p v ( ω [ v ] | ω Pa ω ( v ) ), may depend only on v ’s active parents P a ω ( v ) in a particular possible world ω .

Original: Induced probability distribution over minimal self-supporting instantiations.
Revised: Induced probability distribution over minimal self-supporting instantiations.

Original: Fixing a set U ⊆ V of observed variables (in Figure 1, { detections() } ), the CBN C can be used to deﬁne a probability distribution over minimal self-supporting instantiations (MSSIs) for U : ﬁnite assignments w to a subset of variables vars( w )
Revised: Fixing a set U ⊆ V of observed variables (in Figure 1, { detections() } ), the CBN C can be used to deﬁne a probability distribution over minimal self-supporting instantiations (MSSIs) for U : ﬁnite assignments w to a subset of variables vars( w )

Original: ⊆ V , where U ⊆ vars( w ), such that (1) w is self-supporting —if v ∈ vars( w ) and u ∈ P a w ( v ) then u ∈ vars( w ); and (2) w is minimal —if any variable v (cid:54)∈ U were removed from w it would no longer be self-supporting.
Revised: ⊆ V , where U ⊆ vars( w ), such that (1) w is self-supporting —if v ∈ vars( w ) and u ∈ P a w ( v ) then u ∈ vars( w ); and (2) w is minimal —if any variable v (cid:54)∈ U were removed from w it would no longer be self-supporting.

Original: [Figure]
Revised: [Figure]

Original: Object origin relationships before birth:
Revised: Object origin relationships before birth:

Original: Object origin relationships after birth: stations stations
Revised: Object origin relationships after birth: stations stations

Original: Posit new event to explain
Revised: Posit new event to explain

Original: Delete event , making into a false positive
Revised: Delete event , making into a false positive

Original: False positive detections ,
Revised: False positive detections ,

Original: Dubious events Dubious events
Revised: Dubious events Dubious events

Original: False positive detection (
Revised: False positive detection (

Original: [Figure]
Revised: [Figure]

Original: moves
Revised: moves

Original: [Figure]
Revised: [Figure]

Original: by
Revised: by

Original: [Figure]
Revised: [Figure]

Original: defined in (b).
Revised: defined in (b).

Original: Let W be the set of all possible minimal self-supporting instantiations for a ﬁxed set U of observed variables, and let vars( W ) = { vars( w ) | w ∈ W} be the set of possible setsof-variables that can be jointly speciﬁed by a minimal self-supporting instantiation.
Revised: Let W be the set of all possible minimal self-supporting instantiations for a ﬁxed set U of observed variables, and let vars( W ) = { vars( w ) | w ∈ W} be the set of possible setsof-variables that can be jointly speciﬁed by a minimal self-supporting instantiation.

Original: For v ∈ vars( W ), let v d be the set of all possible joint assignments to the discrete variables in v .
Revised: For v ∈ vars( W ), let v d be the set of all possible joint assignments to the discrete variables in v .

Original: Then we can deﬁne a reference measure µ over the space W of MSSIs, given by µ ( E ) =
Revised: Then we can deﬁne a reference measure µ over the space W of MSSIs, given by µ ( E ) =

Original: (cid:88)
Revised: (cid:88)

Original: [Equation]
Revised: [Equation]

Original: (cid:88)
Revised: (cid:88)

Original: [Equation]
Revised: [Equation]

Original: where w c is the vector of values of the continuous variables in an MSSI w , and λ k is the
Revised: where w c is the vector of values of the continuous variables in an MSSI w , and λ k is the

Original: Lebesgue measure on R k .
Revised: Lebesgue measure on R k .

Original: With respect to µ , the probability density for the OUPM, as a distribution over MSSIs, is given by p ( w ) =
Revised: With respect to µ , the probability density for the OUPM, as a distribution over MSSIs, is given by p ( w ) =

Original: (cid:81) v ∈ vars( w ) p v ( w [ v ] | { u (cid:55)→ w [ u ] | u ∈ P a w ( v ) } ) .
Revised: (cid:81) v ∈ vars( w ) p v ( w [ v ] | { u (cid:55)→ w [ u ] | u ∈ P a w ( v ) } ) .

Original: [Equation]
Revised: [Equation]

Original: 3. Involutive MCMC for Open Universe Models
Revised: 3. Involutive MCMC for Open Universe Models

Original: An involutive MCMC kernel (Cusumano-Towner et al., 2020; Neklyudov et al., 2020) for a target density p on a measure space ( X, Σ X , µ X ) uses a three-step process to transform a state x into a next state x (cid:48) .
Revised: An involutive MCMC kernel (Cusumano-Towner et al., 2020; Neklyudov et al., 2020) for a target density p on a measure space ( X, Σ X , µ X ) uses a three-step process to transform a state x into a next state x (cid:48) .

Original: First, auxiliary variables y are sampled from a state-dependent proposal with density q x , deﬁned over a measure space ( Y, Σ Y , µ Y ).
Revised: First, auxiliary variables y are sampled from a state-dependent proposal with density q x , deﬁned over a measure space ( Y, Σ Y , µ Y ).

Original: Second, an involutionf is applied to ( x, y ) to obtain ( x (cid:48) , y (cid:48) ): x (cid:48) is the proposed next state, and y (cid:48) is an auxiliary variable value that would cause the kernel to propose the old state x from the new state x (cid:48)
Revised: Second, an involutionf is applied to ( x, y ) to obtain ( x (cid:48) , y (cid:48) ): x (cid:48) is the proposed next state, and y (cid:48) is an auxiliary variable value that would cause the kernel to propose the old state x from the new state x (cid:48)

Original: (since f ( x (cid:48) , y (cid:48) ) = ( x, y )).
Revised: (since f ( x (cid:48) , y (cid:48) ) = ( x, y )).

Original: Third, an acceptance probability α ( x, y, x (cid:48) , y (cid:48) ) is computed.
Revised: Third, an acceptance probability α ( x, y, x (cid:48) , y (cid:48) ) is computed.

Original: With probability α , x (cid:48) is the Markov chain’s next state; otherwise the state x is repeated.
Revised: With probability α , x (cid:48) is the Markov chain’s next state; otherwise the state x is repeated.

Original: Cusumano-Towner et al.
Revised: Cusumano-Towner et al.

Original: (2020) show that this process yields a stationary kernel for p when α
Revised: (2020) show that this process yields a stationary kernel for p when α

Original: [Equation]
Revised: [Equation]

Original: where d ( µ ◦ f − 1 ) dµ is the Radon-Nikodym derivative of the pushforward of µ = µ X × µ Y through f with respect to µ .
Revised: where d ( µ ◦ f − 1 ) dµ is the Radon-Nikodym derivative of the pushforward of µ = µ X × µ Y through f with respect to µ .

Original: In general, this does not yield a constructive procedure for computing this Radon-Nikodym derivative, but Cusumano-Towner et al.
Revised: In general, this does not yield a constructive procedure for computing this Radon-Nikodym derivative, but Cusumano-Towner et al.

Original: (2020) show that when p and q are distributions over a space D of ﬁnite dictionaries , i.e., ﬁnite sets of key-value pairs, the Radon-Nikodym derivative can be computed as the determinant of a Jacobian matrix.
Revised: (2020) show that when p and q are distributions over a space D of ﬁnite dictionaries , i.e., ﬁnite sets of key-value pairs, the Radon-Nikodym derivative can be computed as the determinant of a Jacobian matrix.

Original: It turns out (Theorem 1) that a similar result holds when p is an open-universe model.
Revised: It turns out (Theorem 1) that a similar result holds when p is an open-universe model.

Original: Suppose f is an involution on the space W × D , and that there is a countable partition { C i } of W × D such that: (i) ( x
Revised: Suppose f is an involution on the space W × D , and that there is a countable partition { C i } of W × D such that: (i) ( x

Original: , y ) ∈ C i = ⇒ f
Revised: , y ) ∈ C i = ⇒ f

Original: ( x, y ) ∈
Revised: ( x, y ) ∈

Original: C i , (ii) for all ( x, y ) ∈
Revised: C i , (ii) for all ( x, y ) ∈

Original: C i , the total number of continuous values in minimal self-supporting instantiation x , plus the number of continuous values in dictionary y , is constant, and (iii) for each C
Revised: C i , the total number of continuous values in minimal self-supporting instantiation x , plus the number of continuous values in dictionary y , is constant, and (iii) for each C

Original: i , for ( x, y ) ∈
Revised: i , for ( x, y ) ∈

Original: C i , there is a diﬀerentiable bijection
Revised: C i , there is a diﬀerentiable bijection

Original: h
Revised: h

Original: i : R k i → R k i mapping the continuous values in x and y to continuous values in x (cid:48) and y (cid:48) (where ( x (cid:48) , y (cid:48) )
Revised: i : R k i → R k i mapping the continuous values in x and y to continuous values in x (cid:48) and y (cid:48) (where ( x (cid:48) , y (cid:48) )

Original: =
Revised: =

Original: f ( x, y )).
Revised: f ( x, y )).

Original: Then, we have:
Revised: Then, we have:

Original: Theorem 1 For any open universe model with density p , any collection of distributions over ﬁnite dictionaries with densities q x , and any involution satisfying the above conditions, involutive MCMC with α ( x, y, x (cid:48) , y (cid:48) )
Revised: Theorem 1 For any open universe model with density p , any collection of distributions over ﬁnite dictionaries with densities q x , and any involution satisfying the above conditions, involutive MCMC with α ( x, y, x (cid:48) , y (cid:48) )

Original: =
Revised: =

Original: p ( x (cid:48) )
Revised: p ( x (cid:48) )

Original: q x (cid:48) ( y (cid:48) )
Revised: q x (cid:48) ( y (cid:48) )

Original: p ( x ) q x ( y ) ×| det( Jh i ( x, y ))
Revised: p ( x ) q x ( y ) ×| det( Jh i ( x, y ))

Original: | is stationary for p , where
Revised: | is stationary for p , where

Original: Jh i ( x, y ) is the Jacobian of h i at the continuous variables of ( x, y ) , and i is s.t.
Revised: Jh i ( x, y ) is the Jacobian of h i at the continuous variables of ( x, y ) , and i is s.t.

Original: ( x, y ) ∈
Revised: ( x, y ) ∈

Original: C i .
Revised: C i .

Original: The proof involves a translation to the ﬁnite dictionary case, and exploits the structure of minimal self-supporting instantiations to guarantee the necessary properties of f .
Revised: The proof involves a translation to the ﬁnite dictionary case, and exploits the structure of minimal self-supporting instantiations to guarantee the necessary properties of f .

Original: 4. Automation of Acceptance Probability via PPLs and AD
Revised: 4. Automation of Acceptance Probability via PPLs and AD

Original: We have extended the Gen probabilistic programming system (Cusumano-Towner et al., 2019) with new constructs for OUPMs (sample code in Figure 1) and automated involutive
Revised: We have extended the Gen probabilistic programming system (Cusumano-Towner et al., 2019) with new constructs for OUPMs (sample code in Figure 1) and automated involutive

Original: MCMC for these models (Figure 2, Algorithm 1).
Revised: MCMC for these models (Figure 2, Algorithm 1).

Original: The contributions are: (1) a new modeling language for open-universe models, capable of eﬃciently simulating MSSIs, evaluating densities, and modifying world states; (2) a new DSL for deﬁning object-based involutive
Revised: The contributions are: (1) a new modeling language for open-universe models, capable of eﬃciently simulating MSSIs, evaluating densities, and modifying world states; (2) a new DSL for deﬁning object-based involutive

Original: MCMC proposals (Appendix C); and (3) an automated implementation of involutive MCMC for open-universe models, which automatically calculates acceptance ratios via probabilistic and diﬀerentiable programming techniques (Algorithm 1).
Revised: MCMC proposals (Appendix C); and (3) an automated implementation of involutive MCMC for open-universe models, which automatically calculates acceptance ratios via probabilistic and diﬀerentiable programming techniques (Algorithm 1).

Original: See Appendix D for more details.
Revised: See Appendix D for more details.

Original: 5. Experiments
Revised: 5. Experiments

Original: Auditory scene analysis.
Revised: Auditory scene analysis.

Original: We implemented a variant of Cusimano et al.
Revised: We implemented a variant of Cusimano et al.

Original: (2018)’s model of human auditory scene perception, which is based on an OUPM of sound sources with properties including amplitude, type, pitch, and duration.
Revised: (2018)’s model of human auditory scene perception, which is based on an OUPM of sound sources with properties including amplitude, type, pitch, and duration.

Original: See Figure 3 for an example problem, and Appendix A.2 for details.
Revised: See Figure 3 for an example problem, and Appendix A.2 for details.

Original: We implemented two custom, data-driven kernels: a data-driven sound detection kernel (Figure 11) that applies image-ﬁltering and edgedetection to frequency-domain spectrograms and proposes new audio sources to explain sounds it detects in the data but not in the currently-hypothesized world, and a datadriven sound splitting kernel (Figure 12) that splits long sounds into shorter ones at endpoints detected in the observed soundwaves.
Revised: We implemented two custom, data-driven kernels: a data-driven sound detection kernel (Figure 11) that applies image-ﬁltering and edgedetection to frequency-domain spectrograms and proposes new audio sources to explain sounds it detects in the data but not in the currently-hypothesized world, and a datadriven sound splitting kernel (Figure 12) that splits long sounds into shorter ones at endpoints detected in the observed soundwaves.

Original: We also implemented two baseline inference strategies: an ancestral resampling kernel (Figure 9) based on generic PPL inference in
Revised: We also implemented two baseline inference strategies: an ancestral resampling kernel (Figure 9) based on generic PPL inference in

Original: BLOG; and a generic birth/death RJMCMC kernel (Figure 10) that proposes to create a sound with parameters generated from the prior, or delete a sound.
Revised: BLOG; and a generic birth/death RJMCMC kernel (Figure 10) that proposes to create a sound with parameters generated from the prior, or delete a sound.

Original: Figure Figure 3(b) shows quantitative performance comparisons indicating superior performance for custom datadriven kernels.
Revised: Figure Figure 3(b) shows quantitative performance comparisons indicating superior performance for custom datadriven kernels.

Original: Common failure modes of the generic kernels are illustrated in Figure 3(c).
Revised: Common failure modes of the generic kernels are illustrated in Figure 3(c).

Original: Open-universe Gaussian mixture modeling.
Revised: Open-universe Gaussian mixture modeling.

Original: We also implemented Richardson and
Revised: We also implemented Richardson and

Original: Green (1997)’s data-driven inference algorithm for clustering in a Gaussian mixture model with an unknown number of components.
Revised: Green (1997)’s data-driven inference algorithm for clustering in a Gaussian mixture model with an unknown number of components.

Original: See Appendix A.1 for details, including an illustration in Figure 4.
Revised: See Appendix A.1 for details, including an illustration in Figure 4.

Original: We have found that BLOG inference typically fails to accept moves to world states with diﬀerent numbers of clusters, whereas the data-driven algorithm rapidly mixes.
Revised: We have found that BLOG inference typically fails to accept moves to world states with diﬀerent numbers of clusters, whereas the data-driven algorithm rapidly mixes.

Original: Note that Richardson and Green (1997)’s algorithm includes a split-merge kernel with a Jacobian term that our approach calculates automatically.
Revised: Note that Richardson and Green (1997)’s algorithm includes a split-merge kernel with a Jacobian term that our approach calculates automatically.

Original: Appendix A. Experimental Details A.1. Open-universe Gaussian Mixture Model.
Revised: Appendix A. Experimental Details A.1. Open-universe Gaussian Mixture Model.

Original: Richardson and Green (1997) develop a series of highly data-driven MCMC kernels for a Gaussian mixture model with an unknown number of mixture components.
Revised: Richardson and Green (1997) develop a series of highly data-driven MCMC kernels for a Gaussian mixture model with an unknown number of mixture components.

Original: Here we compare their algorithm, implemented using our system for involutive MCMC in OUPMs, to the generic inference engine in BLOG.
Revised: Here we compare their algorithm, implemented using our system for involutive MCMC in OUPMs, to the generic inference engine in BLOG.

Original: The model is as follows.
Revised: The model is as follows.

Original: The number of mixture components, k , is a Poisson random variable.
Revised: The number of mixture components, k , is a Poisson random variable.

Original: The mixture weights and the parameters of each mixture component are drawn from the appropriate conjugate priors:
Revised: The mixture weights and the parameters of each mixture component are drawn from the appropriate conjugate priors:

Original: [Equation]
Revised: [Equation]

Original: where 1 k denotes a vector of ones in R k ; w j , µ j , and σ 2 j denote the weight, mean
Revised: where 1 k denotes a vector of ones in R k ; w j , µ j , and σ 2 j denote the weight, mean

Original: [Equation]
Revised: [Equation]

Original: and variance of the j -th mixture component respectively; and α , β , δ , κ , and ξ are ﬁxed hyperparameters.
Revised: and variance of the j -th mixture component respectively; and α , β , δ , κ , and ξ are ﬁxed hyperparameters.

Original: Lastly, for the i -th data point we sample a cluster allocation
Revised: Lastly, for the i -th data point we sample a cluster allocation

Original: [Equation]
Revised: [Equation]

Original: and given the cluster allocation, we sample a value from the assigned cluster; ie.
Revised: and given the cluster allocation, we sample a value from the assigned cluster; ie.

Original: [Equation]
Revised: [Equation]

Original: Our involutive MCMC proposal consists of ﬁrst updating the weights, means, variances, and allocations using Gibbs updates
Revised: Our involutive MCMC proposal consists of ﬁrst updating the weights, means, variances, and allocations using Gibbs updates

Original: [Equation]
Revised: [Equation]

Original: and then performing a split or merge move to change the number of clusters.
Revised: and then performing a split or merge move to change the number of clusters.

Original: The Gibbs updates are given by
Revised: The Gibbs updates are given by

Original: [Equation]
Revised: [Equation]

Original: where n j denotes the number of data points allocated to the j -th cluster.
Revised: where n j denotes the number of data points allocated to the j -th cluster.

Original: Our merge moves consist of choosing indices j 1 (cid:54) =
Revised: Our merge moves consist of choosing indices j 1 (cid:54) =

Original: j 2 and j ∗ uniformly at random and merging the j 1 -th and j 2 -th clusters into the j ∗ -th cluster.
Revised: j 2 and j ∗ uniformly at random and merging the j 1 -th and j 2 -th clusters into the j ∗ -th cluster.

Original: We ensure that the zeroth, ﬁrst, and second moments of the newly generated cluster match the corresponding moments in the mixture of the original clusters; i.e.
Revised: We ensure that the zeroth, ﬁrst, and second moments of the newly generated cluster match the corresponding moments in the mixture of the original clusters; i.e.

Original: [Equation]
Revised: [Equation]

Original: To ensure ergodicity, our split procedure relies on three auxiliary variables
Revised: To ensure ergodicity, our split procedure relies on three auxiliary variables

Original: [Equation]
Revised: [Equation]

Original: [Figure]
Revised: [Figure]

Original: and generates new clusters according to
Revised: and generates new clusters according to

Original: [Equation]
Revised: [Equation]

Original: Using (2) and (3)
Revised: Using (2) and (3)

Original: [Equation]
Revised: [Equation]

Original: we can derive our involution’s Jacobian matrix (leaving out rows and columns which merely copy a value):
Revised: we can derive our involution’s Jacobian matrix (leaving out rows and columns which merely copy a value):

Original: [Equation]
Revised: [Equation]

Original: 
Revised: 

Original: [Equation]
Revised: [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: u
Revised: u

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: w 1 w σ w ∗ ( u 22 u 3 − u 22 − u 3 +1 ) w σ 2 ∗ ( u 22 u 3 − u 22 − u 3 +1 ) ( u 1 − 1)2 u 2 w ∗ σ 2 ∗ ( u 3 − 1) ww ∗ σ 2 ∗ ( u 22 − 1 )
Revised: w 1 w σ w ∗ ( u 22 u 3 − u 22 − u 3 +1 ) w σ 2 ∗ ( u 22 u 3 − u 22 − u 3 +1 ) ( u 1 − 1)2 u 2 w ∗ σ 2 ∗ ( u 3 − 1) ww ∗ σ 2 ∗ ( u 22 − 1 )

Original: w  .
Revised: w  .

Original: Given a speciﬁcation of the inference kernel, our system automatically calculates this Jacobian matrix and its determinant
Revised: Given a speciﬁcation of the inference kernel, our system automatically calculates this Jacobian matrix and its determinant

Original: [Equation]
Revised: [Equation]

Original: without the user needing to work through this derivation.
Revised: without the user needing to work through this derivation.

Original: Figure 4 shows representative results, in which the involutive MCMC proposal accurately recovers the true latent clusters, whereas the ancestral sampling proposal only roughly narrows down the component parameters.
Revised: Figure 4 shows representative results, in which the involutive MCMC proposal accurately recovers the true latent clusters, whereas the ancestral sampling proposal only roughly narrows down the component parameters.

Original: [Figure]
Revised: [Figure]

Original: in detections
Revised: in detections

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure]
Revised: [Figure]

Original: (Detection(
Revised: (Detection(

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: A.2. Auditory Scene Interpretation.
Revised: A.2. Auditory Scene Interpretation.

Original: Auditory scene analysis Bregman (1994) is a perception task that involves separating an audio waveform into individual sound sources when the number and properties of the sources are unknown a-priori (Figure 3a).
Revised: Auditory scene analysis Bregman (1994) is a perception task that involves separating an audio waveform into individual sound sources when the number and properties of the sources are unknown a-priori (Figure 3a).

Original: Recently, Cusimano et al.
Revised: Recently, Cusimano et al.

Original: (2018) proposed a computational model of human auditory scene analysis based on an open-universe probabilistic model of sound sources, and showed that probabilistic inference in this model based on
Revised: (2018) proposed a computational model of human auditory scene analysis based on an open-universe probabilistic model of sound sources, and showed that probabilistic inference in this model based on

Original: MCMC is able to qualitatively reproduce human inferences about auditory scenes, including reporting ambiguity in the same situations as humans.
Revised: MCMC is able to qualitatively reproduce human inferences about auditory scenes, including reporting ambiguity in the same situations as humans.

Original: The model.
Revised: The model.

Original: We developed a simpliﬁed version of the model of Cusimano et al.
Revised: We developed a simpliﬁed version of the model of Cusimano et al.

Original: (2018) that uses a prior distribution on the number of sounds and the type of each sound (‘tone’ or ‘white noise’).
Revised: (2018) that uses a prior distribution on the number of sounds and the type of each sound (‘tone’ or ‘white noise’).

Original: Tones have an unknown frequency, onset time, and duration, and white noise sounds have an unknown amplitude, onset time, and duration.
Revised: Tones have an unknown frequency, onset time, and duration, and white noise sounds have an unknown amplitude, onset time, and duration.

Original: [Figure]
Revised: [Figure]

Original: Inference Experiments.
Revised: Inference Experiments.

Original: We implemented four involutive MCMC kernels for this model in our extended version of Gen. We performed experiments applying these kernels to the audio waveform shown in Figure 3a, which consists of a short tone, followed by a short period of white noise, followed by a short tone at the same frequency as the ﬁrst tone (Cusimano et al., 2018).
Revised: We implemented four involutive MCMC kernels for this model in our extended version of Gen. We performed experiments applying these kernels to the audio waveform shown in Figure 3a, which consists of a short tone, followed by a short period of white noise, followed by a short tone at the same frequency as the ﬁrst tone (Cusimano et al., 2018).

Original: When the noise is very loud, humans tend to hear one continuous tone temporarily obscured by a loud noise, whereas when the noise is quiet, humans hear two distinct short tones, with noise in the middle.
Revised: When the noise is very loud, humans tend to hear one continuous tone temporarily obscured by a loud noise, whereas when the noise is quiet, humans hear two distinct short tones, with noise in the middle.

Original: Our example uses a softer noise, and our best-performing inference programs, which use application-speciﬁc kernels implemented via our framework, recover the true decomposition (two tones separated by noise).
Revised: Our example uses a softer noise, and our best-performing inference programs, which use application-speciﬁc kernels implemented via our framework, recover the true decomposition (two tones separated by noise).

Original: However, generic inference kernels often incorrectly infer a single long tone (Figure 3).
Revised: However, generic inference kernels often incorrectly infer a single long tone (Figure 3).

Original: In addition to testing our kernels on the speciﬁc audio scene in Figure 3a, we tested them on 100 audio scenes generated from our model’s prior distribution, with similar results (Figure 8).
Revised: In addition to testing our kernels on the speciﬁc audio scene in Figure 3a, we tested them on 100 audio scenes generated from our model’s prior distribution, with similar results (Figure 8).

Original: Generic Kernels
Revised: Generic Kernels

Original: The ﬁrst two kernels we implemented are not application speciﬁc or data driven.
Revised: The ﬁrst two kernels we implemented are not application speciﬁc or data driven.

Original: Our ancestral resampling kernel (Figure 9) resimulates a single variable from the prior distribution (also ancestrally generating any additional variable values which need to be added to the world due to the resimulated variable).
Revised: Our ancestral resampling kernel (Figure 9) resimulates a single variable from the prior distribution (also ancestrally generating any additional variable values which need to be added to the world due to the resimulated variable).

Original: Our generic birth-death reversible-jump kernel (Figure 10) randomly proposes to create or delete individual sounds, proposing new sounds’ properties from the prior.
Revised: Our generic birth-death reversible-jump kernel (Figure 10) randomly proposes to create or delete individual sounds, proposing new sounds’ properties from the prior.

Original: We cycle this kernel with the ancestral resampling kernel so that property values of existing sounds can more easily be updated.
Revised: We cycle this kernel with the ancestral resampling kernel so that property values of existing sounds can more easily be updated.

Original: Figure 3(b) shows that in our experiments, these two kernels converge to inferences of latent waveforms under which the observed sounds are substantially less likely than under the latent waveforms our data-driven kernels recover.
Revised: Figure 3(b) shows that in our experiments, these two kernels converge to inferences of latent waveforms under which the observed sounds are substantially less likely than under the latent waveforms our data-driven kernels recover.

Original: Figure 3(c) visualizes two common failure mode these kernels exhibit due to their inability to eﬃciently incorporate evidence from the data, and their inability to make proposals to split long sounds into short ones (which require application-speciﬁc logic to calculate endpoints of the new sounds based on the position of the sound being split).
Revised: Figure 3(c) visualizes two common failure mode these kernels exhibit due to their inability to eﬃciently incorporate evidence from the data, and their inability to make proposals to split long sounds into short ones (which require application-speciﬁc logic to calculate endpoints of the new sounds based on the position of the sound being split).

Original: We found that the generic birth-death kernel often failed to exit a local minimum in which a single continuous tone is inferred instead of two temporally separated tones of the same frequency (Figure 3c, left).
Revised: We found that the generic birth-death kernel often failed to exit a local minimum in which a single continuous tone is inferred instead of two temporally separated tones of the same frequency (Figure 3c, left).

Original: The generic kernel performs worst—it usually infers one continuous tone, but often also infers spurious tones.
Revised: The generic kernel performs worst—it usually infers one continuous tone, but often also infers spurious tones.

Original: Aside: proposing from the prior in involutive MCMC.
Revised: Aside: proposing from the prior in involutive MCMC.

Original: To facilitate proposing values from the prior in involutive MCMC kernels, we have implemented a regenerate command which can be called from within the involution DSL.
Revised: To facilitate proposing values from the prior in involutive MCMC kernels, we have implemented a regenerate command which can be called from within the involution DSL.

Original: (For examples, see Figures 9, 10, and 11.)
Revised: (For examples, see Figures 9, 10, and 11.)

Original: The command regenerate properties of object samples a value from the prior for each property of the given object (using the prior as it will appear in x (cid:48) ).
Revised: The command regenerate properties of object samples a value from the prior for each property of the given object (using the prior as it will appear in x (cid:48) ).

Original: This complicates our picture of involutive MCMC slightly, as there are now random values being sampled during the execution of the involution function, instead of only in the proposal probabilistic program.
Revised: This complicates our picture of involutive MCMC slightly, as there are now random values being sampled during the execution of the involution function, instead of only in the proposal probabilistic program.

Original: We thus must view the proposal function as only implementing part of the q distribution and sampling part of y , with the rest of q implemented by the involution
Revised: We thus must view the proposal function as only implementing part of the q distribution and sampling part of y , with the rest of q implemented by the involution

Original: DSL’s regenerate commands.
Revised: DSL’s regenerate commands.

Original: To ensure involutiveness, when a transition ( x, y ) → ( x (cid:48) , y (cid:48) ) uses a regenerate command, the reversing move ( x (cid:48) , y (cid:48) )
Revised: To ensure involutiveness, when a transition ( x, y ) → ( x (cid:48) , y (cid:48) ) uses a regenerate command, the reversing move ( x (cid:48) , y (cid:48) )

Original: → ( x, y ) must specify in y the value sampled by regeneration during the forward move.
Revised: → ( x, y ) must specify in y the value sampled by regeneration during the forward move.

Original: To specify reverse-move values for non-regenerated values, users use syntax backward[addr] = value , where addr is the address (variable name) at which the proposal function should sample this value.
Revised: To specify reverse-move values for non-regenerated values, users use syntax backward[addr] = value , where addr is the address (variable name) at which the proposal function should sample this value.

Original: Since users do not specify an address for the values in y which are regenerated (unlike values in y which are sampled in the proposal function), we provide the following additional syntax syntax: backward[property(object)]
Revised: Since users do not specify an address for the values in y which are regenerated (unlike values in y which are sampled in the proposal function), we provide the following additional syntax syntax: backward[property(object)]

Original: = regenerated sets the value in y for regenerating the variable property(object) to the value of property(object) in x , and backward[properties of object] = regenerated does this for all properties of object .
Revised: = regenerated sets the value in y for regenerating the variable property(object) to the value of property(object) in x , and backward[properties of object] = regenerated does this for all properties of object .

Original: See Section E for more details.
Revised: See Section E for more details.

Original: Custom kernels.
Revised: Custom kernels.

Original: Some speciﬁc domains, like data-clustering, have seen standard MCMC kernels developed for data-driven inference, which are fairly conceptually simple but previously required fairly deriving fairly involved calculations (Richardson and Green, 1997;
Revised: Some speciﬁc domains, like data-clustering, have seen standard MCMC kernels developed for data-driven inference, which are fairly conceptually simple but previously required fairly deriving fairly involved calculations (Richardson and Green, 1997;

Original: Wang and Russell, 2015).
Revised: Wang and Russell, 2015).

Original: In addition to facilitating the implementation of these types of kernels and removing the need to manually derive acceptance probabilities, involutive
Revised: In addition to facilitating the implementation of these types of kernels and removing the need to manually derive acceptance probabilities, involutive

Original: MCMC facilitates the development of data-driven kernels in more complicated domains which involve complicated logic to use information from data eﬀectively.
Revised: MCMC facilitates the development of data-driven kernels in more complicated domains which involve complicated logic to use information from data eﬀectively.

Original: For instance,
Revised: For instance,

Original: Cusimano et al.
Revised: Cusimano et al.

Original: (2018)’s experiments used MCMC inference with a proposal based neural- network transformations of observed soundwaves, implemented in an early version of our inference programming system.
Revised: (2018)’s experiments used MCMC inference with a proposal based neural- network transformations of observed soundwaves, implemented in an early version of our inference programming system.

Original: For our experiments in this paper, we developed a roughly 250-LOC image-ﬁltering and edge-detection algorithm to analyze observed soundwaves and detect possible errors in the currently inferred latent sounds.
Revised: For our experiments in this paper, we developed a roughly 250-LOC image-ﬁltering and edge-detection algorithm to analyze observed soundwaves and detect possible errors in the currently inferred latent sounds.

Original: We called this sound-analysis program from within 2 involutive MCMC kernels we developed which our system automated the implementation of, including eﬃciently updating world states and calculating the Jacobian correction term
Revised: We called this sound-analysis program from within 2 involutive MCMC kernels we developed which our system automated the implementation of, including eﬃciently updating world states and calculating the Jacobian correction term

Original: Our data-driven sound detection kernel (Figure 11) either proposes to delete a sound, or to create a new sound which with high probability is proposed at a time and frequency where our analysis program detected a sound in the data but not the currently inferred latents.
Revised: Our data-driven sound detection kernel (Figure 11) either proposes to delete a sound, or to create a new sound which with high probability is proposed at a time and frequency where our analysis program detected a sound in the data but not the currently inferred latents.

Original: Figure 3(b) and Figure 8 show that this kernel both initially performs better than the generic kernels, and ultimately converges to a better state.
Revised: Figure 3(b) and Figure 8 show that this kernel both initially performs better than the generic kernels, and ultimately converges to a better state.

Original: We also add a data-driven sound splitting kernel (Figure 12), which either proposes to merge two short tones/noises into a long one, or splits a long sound into two short ones, proposing endpoints for the new sounds based on the analysis of the sounds.
Revised: We also add a data-driven sound splitting kernel (Figure 12), which either proposes to merge two short tones/noises into a long one, or splits a long sound into two short ones, proposing endpoints for the new sounds based on the analysis of the sounds.

Original: Figure 3(b) and Figure 8 show that the addition of this kernel substantially speeds up convergence.
Revised: Figure 3(b) and Figure 8 show that the addition of this kernel substantially speeds up convergence.

Original: This is to be expected, since this kernel can integrate information from the data about another class of possible mistakes in inferred latents: when one sound has been mistakenly interpreted as two, or vice versa.
Revised: This is to be expected, since this kernel can integrate information from the data about another class of possible mistakes in inferred latents: when one sound has been mistakenly interpreted as two, or vice versa.

Original: We cycle both of the data-driven kernels with Gaussian drift kernels for the parameters of inferred audio sources.
Revised: We cycle both of the data-driven kernels with Gaussian drift kernels for the parameters of inferred audio sources.

Original: A.2.1. The automated acceptance probability for the data-driven sound detection kernel
Revised: A.2.1. The automated acceptance probability for the data-driven sound detection kernel

Original: To illustrate the calculations our system automates, we give the acceptance probability calculation performed when running the data-driven sound detection kernel , including calculating the Jacobian of the transformation.
Revised: To illustrate the calculations our system automates, we give the acceptance probability calculation performed when running the data-driven sound detection kernel , including calculating the Jacobian of the transformation.

Original: Model density.
Revised: Model density.

Original: We can factor the density of the model, p ( x ), as p ( x ) = p ( x L ) p ( x O | x L ), where x L is the collection of latent variable values in x (the number of underlying sound sources, and the properties of each one), and x O is the observed sound waves variable in x .
Revised: We can factor the density of the model, p ( x ), as p ( x ) = p ( x L ) p ( x O | x L ), where x L is the collection of latent variable values in x (the number of underlying sound sources, and the properties of each one), and x O is the observed sound waves variable in x .

Original: For any x where each variable is within its support, the probability of the latents is:
Revised: For any x where each variable is within its support, the probability of the latents is:

Original: [Equation]
Revised: [Equation]

Original: Here, x N S is the number of sound sources in MSSI x
Revised: Here, x N S is the number of sound sources in MSSI x

Original: (the value of the number variable number Source() ); x D,i is the duration of the i th audio source in x ; x τ,i is the starttime of the i th audio source in x ; x n,i is an indicator which is 1 if the i th source in x is a noise and 0 otherwise; x ( α | f ) ,i denotes the amplitude of the i th sound in x if it is a noise, and the frequency of this sound if it is a tone.
Revised: (the value of the number variable number Source() ); x D,i is the duration of the i th audio source in x ; x τ,i is the starttime of the i th audio source in x ; x n,i is an indicator which is 1 if the i th source in x is a noise and 0 otherwise; x ( α | f ) ,i denotes the amplitude of the i th sound in x if it is a noise, and the frequency of this sound if it is a tone.

Original: We let L denote the length of the rendered audio tones (which is a global constant).
Revised: We let L denote the length of the rendered audio tones (which is a global constant).

Original: The probability of the observation given the latents is:
Revised: The probability of the observation given the latents is:

Original: [Equation]
Revised: [Equation]

Original: where x O denotes the observed soundwaves in x (from the observed sound property in
Revised: where x O denotes the observed soundwaves in x (from the observed sound property in

Original: Figure 7) represented as a vector, r ( x L ) denotes the rendering of the latent audio sources in x into sound-waves, and I k denotes the k -dimensional identity matrix.
Revised: Figure 7) represented as a vector, r ( x L ) denotes the rendering of the latent audio sources in x into sound-waves, and I k denotes the k -dimensional identity matrix.

Original: State-dependent proposal density.
Revised: State-dependent proposal density.

Original: The state-dependent proposal distribution q x ( y ) is parameterized by a current MSSI x .
Revised: The state-dependent proposal distribution q x ( y ) is parameterized by a current MSSI x .

Original: It is a distribution over ﬁnite dictionaries, implemented as a Gen program.
Revised: It is a distribution over ﬁnite dictionaries, implemented as a Gen program.

Original: Using standard techniques from probabilistic programming, Gen can automate the computation of densities of dictionaries sampled by the proposal: q x
Revised: Using standard techniques from probabilistic programming, Gen can automate the computation of densities of dictionaries sampled by the proposal: q x

Original: [Equation]
Revised: [Equation]

Original: y )
Revised: y )

Original: =   (1 − β ( x ))
Revised: =   (1 − β ( x ))

Original: φ n ( x ) y n φ ( x ; y n ) y
Revised: φ n ( x ) y n φ ( x ; y n ) y

Original: [Equation]
Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: ρ ( x, y i ) θ ρ ( x, y i ; y n ) y
Revised: ρ ( x, y i ) θ ρ ( x, y i ; y n ) y

Original: [Equation]
Revised: [Equation]

Original: (cid:48) )
Revised: (cid:48) )

Original: y ρ (
Revised: y ρ (

Original: [Equation]
Revised: [Equation]

Original: −
Revised: −

Original: [Equation]
Revised: [Equation]

Original: ( x, y i ))
Revised: ( x, y i ))

Original: [Equation]
Revised: [Equation]

Original: − y ρ y b =β ( x ) · (
Revised: − y ρ y b =β ( x ) · (

Original: [Equation]
Revised: [Equation]

Original: σ
Revised: σ

Original: [Equation]
Revised: [Equation]

Original: x )) x
Revised: x )) x

Original: NS + · (0 .
Revised: NS + · (0 .

Original: [Equation]
Revised: [Equation]

Original: ( y α ;8 , 10))
Revised: ( y α ;8 , 10))

Original: yn · (0 . 6 · (37 − 0 . 4)
Revised: yn · (0 . 6 · (37 − 0 . 4)

Original: [Equation]
Revised: [Equation]

Original: 1 ) 1 − yn (
Revised: 1 ) 1 − yn (

Original: [Equation]
Revised: [Equation]

Original: 1)y b = 1 ∧ y σ =β ( x )
Revised: 1)y b = 1 ∧ y σ =β ( x )

Original: [Equation]
Revised: [Equation]

Original: σ ( x ) x
Revised: σ ( x ) x

Original: NS + · θ n ( x ) y n θ ( x ; y n ) y s · N T     y D
Revised: NS + · θ n ( x ) y n θ ( x ; y n ) y s · N T     y D

Original: y τ y v ( y n i ) 
Revised: y τ y v ( y n i ) 

Original:  ;  
Revised:  ;  

Original: R D
Revised: R D

Original: R τ
Revised: R τ

Original: R v ( y n ) 
Revised: R v ( y n ) 

Original:  ,  
Revised:  ,  

Original: D D ( x, y s , y n ) D τ ( x, y s , y n )
Revised: D D ( x, y s , y n ) D τ ( x, y s , y n )

Original: D v ( y n ) ( x, y s , y n ) 
Revised: D v ( y n ) ( x, y s , y n ) 

Original:  ,   0 .   0 .
Revised:  ,   0 .   0 .

Original:   σ v ( y n ) 
Revised:   σ v ( y n ) 

Original:    y b = 1 ∧ y σ =
Revised:    y b = 1 ∧ y σ =

Original: Here, x N S is the number of sound sources in MSSI x , and y b determines whether a new sound source will be proposed; if y b = 1, y σ determines whether the new source will be proposed using the data-driven edge-detection proposal or from the prior.
Revised: Here, x N S is the number of sound sources in MSSI x , and y b determines whether a new sound source will be proposed; if y b = 1, y σ determines whether the new source will be proposed using the data-driven edge-detection proposal or from the prior.

Original: (In Figure 11, y b corresponds to do birth ; y σ to do smart birth .)
Revised: (In Figure 11, y b corresponds to do birth ; y σ to do smart birth .)

Original: y n is an indicator for whether the source being created/deleted is white noise, as opposed to a tone ( y n is objtype in Figurewhen y b
Revised: y n is an indicator for whether the source being created/deleted is white noise, as opposed to a tone ( y n is objtype in Figurewhen y b

Original: = 0 ∨ y σ = 1, and is proposed via regenerate when y b = 1 ∧ y σ = 0).
Revised: = 0 ∨ y σ = 1, and is proposed via regenerate when y b = 1 ∧ y σ = 0).

Original: When y σ = 1, an index y s is computed determining which of the sounds from the image-ﬁltering and edge-detection algorithm with the type indicated by y n will be proposed (the index of sample action in Figure 11).
Revised: When y σ = 1, an index y s is computed determining which of the sounds from the image-ﬁltering and edge-detection algorithm with the type indicated by y n will be proposed (the index of sample action in Figure 11).

Original: Based on y s , new sound onset and duration parameters
Revised: Based on y s , new sound onset and duration parameters

Original: y τ and y D , as well as either a frequency y f or an amplitude y α .
Revised: y τ and y D , as well as either a frequency y f or an amplitude y α .

Original: When the data-driven proposal is not used ( y b = 1 ∧ y σ = 0), y α (or y f ), y n , and other parameters are proposed from the model’s prior over sound sources.
Revised: When the data-driven proposal is not used ( y b = 1 ∧ y σ = 0), y α (or y f ), y n , and other parameters are proposed from the model’s prior over sound sources.

Original: If y b = 0, a death move is proposed, to delete sound y i .
Revised: If y b = 0, a death move is proposed, to delete sound y i .

Original: The variable y ρ is introduced to enable the implementation of an involution: it represents whether the move reversing a proposed death move will be data-driven.
Revised: The variable y ρ is introduced to enable the implementation of an involution: it represents whether the move reversing a proposed death move will be data-driven.

Original: If y ρ = 1, y s (cid:48) represents which heuristically detected sound source with the type indicated by y n will be used as the basis to repropose the deleted audio source, in the reverse proposal.
Revised: If y ρ = 1, y s (cid:48) represents which heuristically detected sound source with the type indicated by y n will be used as the basis to repropose the deleted audio source, in the reverse proposal.

Original: N T ( v ; R, µ, Σ) denotes the PDF of a multivariate truncated normal distribution with ranges
Revised: N T ( v ; R, µ, Σ) denotes the PDF of a multivariate truncated normal distribution with ranges

Original: R , means µ , and covariance matrix Σ, evaluated at v .
Revised: R , means µ , and covariance matrix Σ, evaluated at v .

Original: The proposal is based on a number of functions, as well as the scene length parameter
Revised: The proposal is based on a number of functions, as well as the scene length parameter

Original: L , the standard deviations σ α = 4 and σ f = 1, and the ranges R D = (0 . 1 , 1), R τ = (0 , L ),
Revised: L , the standard deviations σ α = 4 and σ f = 1, and the ranges R D = (0 . 1 , 1), R τ = (0 , L ),

Original: R f = (0 . 4 , 24), and R α = ( −∞ , ∞ ).
Revised: R f = (0 . 4 , 24), and R α = ( −∞ , ∞ ).

Original: These functions, and some additional functions needed for their deﬁnitions, are described below:
Revised: These functions, and some additional functions needed for their deﬁnitions, are described below:

Original: • k
Revised: • k

Original: ( x, y n ) is the number of possible sounds to create of type y n detected in state x • S B ( x, i, y n ) is a score for the action of creating a sound close to the i th detected sound of type y n , from a user-written scoring heuristic • S D ( x, i ) is a score for the action of deleting the i th sound in the current world, from a user-written scoring heuristic (a diﬀerent heuristic from S B ) • π B ( x ) =
Revised: ( x, y n ) is the number of possible sounds to create of type y n detected in state x • S B ( x, i, y n ) is a score for the action of creating a sound close to the i th detected sound of type y n , from a user-written scoring heuristic • S D ( x, i ) is a score for the action of deleting the i th sound in the current world, from a user-written scoring heuristic (a diﬀerent heuristic from S B ) • π B ( x ) =

Original: [Table]
Revised: [Table]

Original: [Table]
Revised: [Table]

Original: the total score of all detected birth actions, divided by the total score of all detected birth and death actions •
Revised: the total score of all detected birth actions, divided by the total score of all detected birth and death actions •

Original: [Equation]
Revised: [Equation]

Original: is the probability of y b = 1, given x .
Revised: is the probability of y b = 1, given x .

Original: Hyperparameter π ∗ B = 0 .
Revised: Hyperparameter π ∗ B = 0 .

Original: 5 is a prior probability of doing a birth move, not factoring in the scores assigned to detected actions, and hyperparameter π R = 0 .
Revised: 5 is a prior probability of doing a birth move, not factoring in the scores assigned to detected actions, and hyperparameter π R = 0 .

Original: 1 is the probability of making a decision to do a birth vs death move without considering the scores.
Revised: 1 is the probability of making a decision to do a birth vs death move without considering the scores.

Original: • β σ ( x ) = 1 − 0 .
Revised: • β σ ( x ) = 1 − 0 .

Original: [ | θ ( x ) | > 0] is the probability of y σ = 1 given that y b = 1 for MSSI x .
Revised: [ | θ ( x ) | > 0] is the probability of y σ = 1 given that y b = 1 for MSSI x .

Original: • β ρ ( x, i ) is 0, if removing sound i from x and running image ﬁltering and edge detection does not ﬁnd any sounds of the same type as sound i in x , and 0 .
Revised: • β ρ ( x, i ) is 0, if removing sound i from x and running image ﬁltering and edge detection does not ﬁnd any sounds of the same type as sound i in x , and 0 .

Original: 95 otherwise.
Revised: 95 otherwise.

Original: • D D ( x, i, y n ) is the predicted duration of the i th detected sound source of type y n from the image ﬁltering and edge detection algorithm applied to x .
Revised: • D D ( x, i, y n ) is the predicted duration of the i th detected sound source of type y n from the image ﬁltering and edge detection algorithm applied to x .

Original: Similarly, D τ gives the predicted onset, D α the predicted amplitude (if applicable), and D f the predicted frequency (if applicable).
Revised: Similarly, D τ gives the predicted onset, D α the predicted amplitude (if applicable), and D f the predicted frequency (if applicable).

Original: • v ( y n ) is the symbol α (amplitude)
Revised: • v ( y n ) is the symbol α (amplitude)

Original: if y n = 1 and the symbol f (frequency) if y n = 0. • θ n ( x ) = { 0 (cid:55)→ (cid:80) k
Revised: if y n = 1 and the symbol f (frequency) if y n = 0. • θ n ( x ) = { 0 (cid:55)→ (cid:80) k

Original: ( x, 0) i =1 S B ( x,i, 0) (cid:80) k
Revised: ( x, 0) i =1 S B ( x,i, 0) (cid:80) k

Original: ( x, 0) i =1 S B ( x,i, 0)+ (cid:80) k
Revised: ( x, 0) i =1 S B ( x,i, 0)+ (cid:80) k

Original: ( x, 1) i =1 S B ( x,i, 1) , 1 (cid:55)→ (cid:80) k
Revised: ( x, 1) i =1 S B ( x,i, 1) , 1 (cid:55)→ (cid:80) k

Original: ( x, 1) i =1 S B ( x,i, 1) (cid:80) k
Revised: ( x, 1) i =1 S B ( x,i, 1) (cid:80) k

Original: ( x, 0) i =1 S B ( x,i, 0)+ (cid:80) k
Revised: ( x, 0) i =1 S B ( x,i, 0)+ (cid:80) k

Original: ( x, 1) i =1 S B ( x,i, 1) } is a dictionary from values of y n to the probability of choosing to birth an object of type y n based on the heuristically-assigned S B scores.
Revised: ( x, 1) i =1 S B ( x,i, 1) } is a dictionary from values of y n to the probability of choosing to birth an object of type y n based on the heuristically-assigned S B scores.

Original: • φ n ( x ) = { 0 (cid:55)→
Revised: • φ n ( x ) = { 0 (cid:55)→

Original: [Equation]
Revised: [Equation]

Original: } gives the probability of deleting a noise vs deleting a tone.
Revised: } gives the probability of deleting a noise vs deleting a tone.

Original: • θ ( x ; y n ) is a vector-valued function, taking values in the ( k ( x, y n ) − 1)-simplex.
Revised: • θ ( x ; y n ) is a vector-valued function, taking values in the ( k ( x, y n ) − 1)-simplex.

Original: It represents a distribution over more or less promising detections based on the S B scores.
Revised: It represents a distribution over more or less promising detections based on the S B scores.

Original: In particular, θ ( x ; y n ) j =
Revised: In particular, θ ( x ; y n ) j =

Original: [Equation]
Revised: [Equation]

Original: • φ ( x ; y n ) is a vector-valued function representing a distribution over which existing audio source of type y n to delete.
Revised: • φ ( x ; y n ) is a vector-valued function representing a distribution over which existing audio source of type y n to delete.

Original: In particular, φ ( x ; y n )
Revised: In particular, φ ( x ; y n )

Original: j
Revised: j

Original: [Equation]
Revised: [Equation]

Original: • θ ρ ( x, i ; y n ) is a vector-valued function, taking values in the ( k ρ ( x, i, y n )-1) simplex, where k ρ ( x, i, y n ) is the number of detected sounds of type y n from the edge detection routine, applied to x without sound source i .
Revised: • θ ρ ( x, i ; y n ) is a vector-valued function, taking values in the ( k ρ ( x, i, y n )-1) simplex, where k ρ ( x, i, y n ) is the number of detected sounds of type y n from the edge detection routine, applied to x without sound source i .

Original: In particular, θ ρ ( x, i ; y n )
Revised: In particular, θ ρ ( x, i ; y n )

Original: j ∝ N T     x D,i x τ
Revised: j ∝ N T     x D,i x τ

Original: [Equation]
Revised: [Equation]

Original: i x v ( y n )
Revised: i x v ( y n )

Original: [Equation]
Revised: [Equation]

Original: i  
Revised: i  

Original: [Equation]
Revised: [Equation]

Original:  
Revised:  

Original: [Equation]
Revised: [Equation]

Original: D
Revised: D

Original: [Equation]
Revised: [Equation]

Original: R v ( y n ) ) 
Revised: R v ( y n ) ) 

Original: 
Revised: 

Original: [Equation]
Revised: [Equation]

Original:  
Revised:  

Original: D ρD ( x
Revised: D ρD ( x

Original: [Equation]
Revised: [Equation]

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: j
Revised: j

Original: [Equation]
Revised: [Equation]

Original: y n )
Revised: y n )

Original: D ρτ
Revised: D ρτ

Original: [Equation]
Revised: [Equation]

Original: x
Revised: x

Original: [Equation]
Revised: [Equation]

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: j
Revised: j

Original: [Equation]
Revised: [Equation]

Original: y n )
Revised: y n )

Original: [Equation]
Revised: [Equation]

Original: ( x, i, j, y n )   ,   0 .   0 .
Revised: ( x, i, j, y n )   ,   0 .   0 .

Original:   σ v ( y n ) 
Revised:   σ v ( y n ) 

Original:  
Revised:  

Original:  where D ρD , D ρτ , D ρα , and D ρf are functions on ( x, i, j, y n ) giving the duration, onset, and amplitude/frequency of the j th sound of type y n detected via the detector applied to x without source i .
Revised:  where D ρD , D ρτ , D ρα , and D ρf are functions on ( x, i, j, y n ) giving the duration, onset, and amplitude/frequency of the j th sound of type y n detected via the detector applied to x without source i .

Original: The Jacobian.
Revised: The Jacobian.

Original: The create detected sound kernel always either creates or deletes a sound; we show the Jacobian of the matrix for a move which creates a sound (the transpose of which is the Jacobian of the matrix for the corresponding deletion).
Revised: The create detected sound kernel always either creates or deletes a sound; we show the Jacobian of the matrix for a move which creates a sound (the transpose of which is the Jacobian of the matrix for the corresponding deletion).

Original: The transition ( x, y ) → ( x (cid:48) , y (cid:48) ) during a creation copies over every continuous value in x and y into x (cid:48) .
Revised: The transition ( x, y ) → ( x (cid:48) , y (cid:48) ) during a creation copies over every continuous value in x and y into x (cid:48) .

Original: These values come from the properties starttime ( τ ) and duration ( D ) of each source, and the amplitude ( D ) property of each noise or frequency ( f ) property of each tone.
Revised: These values come from the properties starttime ( τ ) and duration ( D ) of each source, and the amplitude ( D ) property of each noise or frequency ( f ) property of each tone.

Original: Depending on the index of the newly-created sound, the indices of each object may change, as is described in .
Revised: Depending on the index of the newly-created sound, the indices of each object may change, as is described in .

Original: In particular, when we birth a new source with index i , we must increment the index of each existing source with index ≥ i .
Revised: In particular, when we birth a new source with index i , we must increment the index of each existing source with index ≥ i .

Original: We deﬁne the following identiﬁers for whether the object at index a is moved to index b , and whether the birth index i equals a given index a :
Revised: We deﬁne the following identiﬁers for whether the object at index a is moved to index b , and whether the birth index i equals a given index a :

Original: C a → b = (cid:40)( i > a ∧ a = b ) ∨ ( i ≤ a ∧ b = a + 1) otherwise
Revised: C a → b = (cid:40)( i > a ∧ a = b ) ∨ ( i ≤ a ∧ b = a + 1) otherwise

Original: B a
Revised: B a

Original: =
Revised: =

Original: (cid:40)i = a otherwise
Revised: (cid:40)i = a otherwise

Original: Using these deﬁnitions, we can write the Jacobian of the transformation which copies starttime ( τ ), duration ( D ), and amplitude/frequency ( α | f ) values for each object as:
Revised: Using these deﬁnitions, we can write the Jacobian of the transformation which copies starttime ( τ ), duration ( D ), and amplitude/frequency ( α | f ) values for each object as:

Original: J =   x ( α | f ) ,x τ,x D,x ( α | f ) ,x τ,x D,... x D,NS + y ( α | f )
Revised: J =   x ( α | f ) ,x τ,x D,x ( α | f ) ,x τ,x D,... x D,NS + y ( α | f )

Original: B
Revised: B

Original: B  . . .
Revised: B  . . .

Original: y τ
Revised: y τ

Original: B
Revised: B

Original: B . . .
Revised: B . . .

Original: y D
Revised: y D

Original: B
Revised: B

Original: B. . .
Revised: B. . .

Original: B N S + x ( α | f ) ,
Revised: B N S + x ( α | f ) ,

Original: C 1 →
Revised: C 1 →

Original: C 1 →  . . .
Revised: C 1 →  . . .

Original: x τ,
Revised: x τ,

Original: C 1 →
Revised: C 1 →

Original: C 1 → . . .
Revised: C 1 → . . .

Original: x D,
Revised: x D,

Original: C 1 →
Revised: C 1 →

Original: C 1 →. . .
Revised: C 1 →. . .

Original: C 1 → N S + x ( α | f ) ,
Revised: C 1 → N S + x ( α | f ) ,

Original: C 2 →
Revised: C 2 →

Original: C 2 →  . . .
Revised: C 2 →  . . .

Original: x τ,
Revised: x τ,

Original: C 2 →
Revised: C 2 →

Original: C 2 → . . .
Revised: C 2 → . . .

Original: x D,
Revised: x D,

Original: C 2 →
Revised: C 2 →

Original: C 2 →. . .
Revised: C 2 →. . .

Original: C 2 → N S +1 .
Revised: C 2 → N S +1 .

Original: x D,NS
Revised: x D,NS

Original: C 2 → N S
Revised: C 2 → N S

Original: C 2 → N S . . .
Revised: C 2 → N S . . .

Original: C N S → N S +   where
Revised: C N S → N S +   where

Original: J
Revised: J

Original: [Equation]
Revised: [Equation]

Original: Since this is a permutation matrix, it always has determinant − 1 or 1.
Revised: Since this is a permutation matrix, it always has determinant − 1 or 1.

Original: Our system is capable of computing this Jacobian using automatic diﬀerentiation and discovering this.
Revised: Our system is capable of computing this Jacobian using automatic diﬀerentiation and discovering this.

Original: As an optimization, in practice, our system can identify that this transformation only copies values, and thus will have a permutation-matrix Jacobian which it does not need to take the determinant of, since it will certainly have magnitude 1, as we describe in the
Revised: As an optimization, in practice, our system can identify that this transformation only copies values, and thus will have a permutation-matrix Jacobian which it does not need to take the determinant of, since it will certainly have magnitude 1, as we describe in the

Original: Jacobian sparsity paragraph in Section D. For an description of an inference kernel we have implemented which has a Jacobian whose determinant’s magnitude is (usually) not 1, see Section A.1.
Revised: Jacobian sparsity paragraph in Section D. For an description of an inference kernel we have implemented which has a Jacobian whose determinant’s magnitude is (usually) not 1, see Section A.1.

Original: Acceptance probability.
Revised: Acceptance probability.

Original: When using the involutive MCMC kernel
Revised: When using the involutive MCMC kernel

Original: [Equation]
Revised: [Equation]

Original: our system automatically calculates q x ( y ), q x (cid:48)
Revised: our system automatically calculates q x ( y ), q x (cid:48)

Original: ( y (cid:48) ), p ( x ), p ( x (cid:48) ), and J , to compute the acceptance probability of the move ( x, y )
Revised: ( y (cid:48) ), p ( x ), p ( x (cid:48) ), and J , to compute the acceptance probability of the move ( x, y )

Original: → ( x (cid:48) , y (cid:48) ), p ( x (cid:48)
Revised: → ( x (cid:48) , y (cid:48) ), p ( x (cid:48)

Original: [Equation]
Revised: [Equation]

Original: p ( x
Revised: p ( x

Original: [Equation]
Revised: [Equation]

Original: ×
Revised: ×

Original: [Equation]
Revised: [Equation]

Original: (cid:48)
Revised: (cid:48)

Original: [Equation]
Revised: [Equation]

Original: y (cid:48)
Revised: y (cid:48)

Original: [Equation]
Revised: [Equation]

Original: These terms are all equivalent to the above expressions for q x ( y ), p ( x ), and J (sometimes substituting x (cid:48) for x or y (cid:48) for y ).
Revised: These terms are all equivalent to the above expressions for q x ( y ), p ( x ), and J (sometimes substituting x (cid:48) for x or y (cid:48) for y ).

Original: In practice, the q terms are automatically calculated using the given expressions, while computational optimizations let us avoid calculating the determinant of the Jacobian matrix (which is just a permutation matrix), and let us avoid fully calculating p ( x (cid:48) ) and p ( x ), instead directly calculating
Revised: In practice, the q terms are automatically calculated using the given expressions, while computational optimizations let us avoid calculating the determinant of the Jacobian matrix (which is just a permutation matrix), and let us avoid fully calculating p ( x (cid:48) ) and p ( x ), instead directly calculating

Original: [Equation]
Revised: [Equation]

Original: (cid:48)
Revised: (cid:48)

Original: [Equation]
Revised: [Equation]

Original: where, as above, y b is 1 when y proposes to create a new source and 0 otherwise, and y s is the index of the source being created/deleted.
Revised: where, as above, y b is 1 when y proposes to create a new source and 0 otherwise, and y s is the index of the source being created/deleted.

Original: We can avoid evaluating the product expressions because the majority of terms in the numerator and denominator cancel out, since all audio sources except the one being created/deleted are unaﬀected by the update.
Revised: We can avoid evaluating the product expressions because the majority of terms in the numerator and denominator cancel out, since all audio sources except the one being created/deleted are unaﬀected by the update.

Original: Appendix B. Open-Universe Models and Contingent Bayesian Networks
Revised: Appendix B. Open-Universe Models and Contingent Bayesian Networks

Original: In this section, we give a more complete deﬁnition of open-universe probabilistic models and contingent Bayesian networks (outlined in Section 2).
Revised: In this section, we give a more complete deﬁnition of open-universe probabilistic models and contingent Bayesian networks (outlined in Section 2).

Original: Open-universe probabilistic models are models of relational domains in which the number of objects, and their link structure, is not known a priori.
Revised: Open-universe probabilistic models are models of relational domains in which the number of objects, and their link structure, is not known a priori.

Original: The usual representations for structured probability distributions—e.g., probabilistic graphical models—are insuﬃcient for specifying OUPMs, which typically deﬁne an unbounded number of random variables, with conditional independence relationships that are themselves random.
Revised: The usual representations for structured probability distributions—e.g., probabilistic graphical models—are insuﬃcient for specifying OUPMs, which typically deﬁne an unbounded number of random variables, with conditional independence relationships that are themselves random.

Original: OUPMs can be speciﬁed formally, however, as programs in suﬃciently expressive probabilistic programming languages (Milch et al., 2005a), or as contingent Bayesian networks (CBNs) with inﬁnitely many nodes (Milch et al., 2005b).
Revised: OUPMs can be speciﬁed formally, however, as programs in suﬃciently expressive probabilistic programming languages (Milch et al., 2005a), or as contingent Bayesian networks (CBNs) with inﬁnitely many nodes (Milch et al., 2005b).

Original: Here, we review the standard deﬁnition of OUPMs as
Revised: Here, we review the standard deﬁnition of OUPMs as

Original: CBNs, and extend it to allow for objects with real-valued random properties.
Revised: CBNs, and extend it to allow for objects with real-valued random properties.

Original: Open-Universe Probabilistic Models
Revised: Open-Universe Probabilistic Models

Original: An open universe probabilistic model is a tuple ( T , N , P , C ), where
Revised: An open universe probabilistic model is a tuple ( T , N , P , C ), where

Original: • T is a ﬁnite 3 set of object types over which the model is deﬁned (e.g., Person ).
Revised: • T is a ﬁnite 3 set of object types over which the model is deﬁned (e.g., Person ).

Original: • N is a ﬁnite 3 set of object origin declarations ( τ, ( τ 1 , . . .
Revised: • N is a ﬁnite 3 set of object origin declarations ( τ, ( τ 1 , . . .

Original: , τ n )), with τ, τ j ∈ T .
Revised: , τ n )), with τ, τ j ∈ T .

Original: An object origin declaration speciﬁes that a tuple of objects, of types ( τ 1 , . . .
Revised: An object origin declaration speciﬁes that a tuple of objects, of types ( τ 1 , . . .

Original: , τ n ) respectively, can be the origin of a separate object of type τ .
Revised: , τ n ) respectively, can be the origin of a separate object of type τ .

Original: For example, in a model of genealogy, we might declare ( Person , ( Person , Person ))
Revised: For example, in a model of genealogy, we might declare ( Person , ( Person , Person ))

Original: ∈ N , encoding that a pair of people can be the origin (i.e., parents) of other people.
Revised: ∈ N , encoding that a pair of people can be the origin (i.e., parents) of other people.

Original: A model’s object origin declarations determines sets of possible objects O τ ( N ) for each type τ , which are ﬁnite expressions of the form ( τ, ( o 1 , . . .
Revised: A model’s object origin declarations determines sets of possible objects O τ ( N ) for each type τ , which are ﬁnite expressions of the form ( τ, ( o 1 , . . .

Original: , o n ) , i ), where ( τ, ( τ 1 , . .
Revised: , o n ) , i ), where ( τ, ( τ 1 , . .

Original: τ n ))
Revised: τ n ))

Original: ∈ N , i ∈ N , and o j ∈
Revised: ∈ N , i ∈ N , and o j ∈

Original: O τ j ( N ) for each j .
Revised: O τ j ( N ) for each j .

Original: We call ( τ, ( o 1 , . . .
Revised: We call ( τ, ( o 1 , . . .

Original: , o n ) , i ) the i th object of type τ with origin ( o 1 , . . .
Revised: , o n ) , i ) the i th object of type τ with origin ( o 1 , . . .

Original: , o n ).
Revised: , o n ).

Original: • P is a countable set of typed object property declarations ( P, ( τ 1 , . . .
Revised: • P is a countable set of typed object property declarations ( P, ( τ 1 , . . .

Original: , τ n )), with τ j ∈ T , together with value domains dom( P ) for each property.
Revised: , τ n )), with τ j ∈ T , together with value domains dom( P ) for each property.

Original: A property represents data concerning zero or more objects, of types ( τ 1 , . .
Revised: A property represents data concerning zero or more objects, of types ( τ 1 , . .

Original: τ n ) respectively.
Revised: τ n ) respectively.

Original: For example, a model might declare a property representing the number of ﬂights between two places.
Revised: For example, a model might declare a property representing the number of ﬂights between two places.

Original: • C is a continuously-extended contingent Bayesian network on the set of possible variables for ( T , N , P ), { ( x, ( o 1 , . . .
Revised: • C is a continuously-extended contingent Bayesian network on the set of possible variables for ( T , N , P ), { ( x, ( o 1 , . . .

Original: , o n )) | ( x, ( τ 1 , . . .
Revised: , o n )) | ( x, ( τ 1 , . . .

Original: , τ n ))
Revised: , τ n ))

Original: ∈ P ∪ N ∧ ∀
Revised: ∈ P ∪ N ∧ ∀

Original: j, o j ∈
Revised: j, o j ∈

Original: O τ j ( N ) } .
Revised: O τ j ( N ) } .

Original: For every origin declaration ( τ, ( τ 1 , . . .
Revised: For every origin declaration ( τ, ( τ 1 , . . .

Original: , τ n )) ∈ N , and every tuple ( o 1 , . . .
Revised: , τ n )) ∈ N , and every tuple ( o 1 , . . .

Original: , o n ) ∈ (cid:78) j O τ j ( N ) of possible objects of the correct types, there is a possible number variable ( τ, ( o 1 , . . .
Revised: , o n ) ∈ (cid:78) j O τ j ( N ) of possible objects of the correct types, there is a possible number variable ( τ, ( o 1 , . . .

Original: , o n )), with domain Z ≥ 0 , representing the number of objects of type τ that have objects ( o 1 , . . .
Revised: , o n )), with domain Z ≥ 0 , representing the number of objects of type τ that have objects ( o 1 , . . .

Original: , o n ) as their origin.
Revised: , o n ) as their origin.

Original: For every property declaration ( P, ( τ 1 , . . .
Revised: For every property declaration ( P, ( τ 1 , . . .

Original: , τ n ))
Revised: , τ n ))

Original: and object tuple ( o 1 , . . .
Revised: and object tuple ( o 1 , . . .

Original: , o n ) of the correct types, there is a possible property variable specifying the value of the property P (within dom( P )) of the object tuple ( o 1 , . . .
Revised: , o n ) of the correct types, there is a possible property variable specifying the value of the property P (within dom( P )) of the object tuple ( o 1 , . . .

Original: , o n ).
Revised: , o n ).

Original: The contingent Bayesian network itself deﬁnes a distribution over assignments to these inﬁnitely many possible variables, as we describe in the following section.
Revised: The contingent Bayesian network itself deﬁnes a distribution over assignments to these inﬁnitely many possible variables, as we describe in the following section.

Original: countable without compromising any results, existing formal languages for deﬁning OUPMs, ours not provide a way to declare models where either of these are
Revised: countable without compromising any results, existing formal languages for deﬁning OUPMs, ours not provide a way to declare models where either of these are

Original: It would be interesting to consider whether any natural applications would require this how might be designed to expose it.
Revised: It would be interesting to consider whether any natural applications would require this how might be designed to expose it.

Original: Contingent Bayesian Networks
Revised: Contingent Bayesian Networks

Original: For a set of possible variables V , let Ω = (cid:78) v ∈V dom( v ) be the space of all possible assignments of the (possibly inﬁnitely many) variables to values within their domains.
Revised: For a set of possible variables V , let Ω = (cid:78) v ∈V dom( v ) be the space of all possible assignments of the (possibly inﬁnitely many) variables to values within their domains.

Original: When the domains are discrete, we can use a contingent Bayesian network (CBN) (Milch et al., 2005b) to deﬁne a distribution over such assignments.
Revised: When the domains are discrete, we can use a contingent Bayesian network (CBN) (Milch et al., 2005b) to deﬁne a distribution over such assignments.

Original: Analogously to a Bayesian network on a ﬁnite number of variables, a CBN on an inﬁnite set of variables V speciﬁes an inﬁnite directed graph with V as the nodes.
Revised: Analogously to a Bayesian network on a ﬁnite number of variables, a CBN on an inﬁnite set of variables V speciﬁes an inﬁnite directed graph with V as the nodes.

Original: But whereas traditional
Revised: But whereas traditional

Original: Bayesian networks ﬁx the dependency structure, in a CBN the edges are contingent : each edge u → v is labeled with an event Ω u → v ⊆ Ω within which the edge is active .
Revised: Bayesian networks ﬁx the dependency structure, in a CBN the edges are contingent : each edge u → v is labeled with an event Ω u → v ⊆ Ω within which the edge is active .

Original: As in
Revised: As in

Original: Bayesian networks, to each variable v we associate a conditional probability distribution (CPD) p v .
Revised: Bayesian networks, to each variable v we associate a conditional probability distribution (CPD) p v .

Original: But this conditional probability distribution is allowed to depend only on the active parents of v , which can be formalized as follows: for each variable v ∈ V , the contingent Bayesian network associates a partition Λ v of the space Ω, such that if ω 1 and ωdiﬀer only in their assignment to u , and the edge u → v either does not exist or is inactive in ω 1 , then ω 1 and ω 2 belong to the same component of Λ v .
Revised: But this conditional probability distribution is allowed to depend only on the active parents of v , which can be formalized as follows: for each variable v ∈ V , the contingent Bayesian network associates a partition Λ v of the space Ω, such that if ω 1 and ωdiﬀer only in their assignment to u , and the edge u → v either does not exist or is inactive in ω 1 , then ω 1 and ω 2 belong to the same component of Λ v .

Original: Then p v ( · | ω ∈ λ ) is allowed to depend on which component λ of the partition ω is in, but nothing else, preventing dependencies on the values of inactive parents.
Revised: Then p v ( · | ω ∈ λ ) is allowed to depend on which component λ of the partition ω is in, but nothing else, preventing dependencies on the values of inactive parents.

Original: We write P a ω ( v ) for the active parents of the variable v in state ω .
Revised: We write P a ω ( v ) for the active parents of the variable v in state ω .

Original: These conditional probabilities together deﬁne a probability measure Π on the space Ω, equipped with a non-standard σ -algebra; we refer the reader to Milch et al.
Revised: These conditional probabilities together deﬁne a probability measure Π on the space Ω, equipped with a non-standard σ -algebra; we refer the reader to Milch et al.

Original: (2005b)
Revised: (2005b)

Original: for a detailed treatment.
Revised: for a detailed treatment.

Original: Minimal Self-Supporting Instantiations.
Revised: Minimal Self-Supporting Instantiations.

Original: In open-universe models, possible worlds ω ∈ Ω are generally inﬁnite, because they specify assignments to all of the possible variables v ∈ V .
Revised: In open-universe models, possible worlds ω ∈ Ω are generally inﬁnite, because they specify assignments to all of the possible variables v ∈ V .

Original: But for inference, we must work with ﬁnite representations.
Revised: But for inference, we must work with ﬁnite representations.

Original: If we can partition Ω into disjoint equivalence classes Ω i , then we can work with the equivalence classes, using the distribution p (Ω i ) =
Revised: If we can partition Ω into disjoint equivalence classes Ω i , then we can work with the equivalence classes, using the distribution p (Ω i ) =

Original: Π(Ω i ).
Revised: Π(Ω i ).

Original: One useful strategy for partitioning Ω is to consider the minimal self-supporting instantiations of a ﬁnite set of variables U ⊆ V .
Revised: One useful strategy for partitioning Ω is to consider the minimal self-supporting instantiations of a ﬁnite set of variables U ⊆ V .

Original: Each component w of the partition is labeled by a set of variables vars( w ) ⊆
Revised: Each component w of the partition is labeled by a set of variables vars( w ) ⊆

Original: V , with U ⊆ vars( w ), as well as an assignment w [ v ] ∈ dom( v ) for each v ∈ vars( w ).
Revised: V , with U ⊆ vars( w ), as well as an assignment w [ v ] ∈ dom( v ) for each v ∈ vars( w ).

Original: The component w contains all full possible worlds ω ∈ Ω that agree with w on the values of each v ∈ vars( w ).
Revised: The component w contains all full possible worlds ω ∈ Ω that agree with w on the values of each v ∈ vars( w ).

Original: To ensure that the components w are indeed disjoint, we only include w as a component if: (1) it is selfsupporting , meaning that for all ω ∈ w , if v ∈ vars(w) and u ∈ P a ω ( v ), then u ∈ vars( w ); and (2) it is minimal , meaning that removing any variable v (cid:54)∈ U from vars( w ) would cause it to fail to be self-supporting.
Revised: To ensure that the components w are indeed disjoint, we only include w as a component if: (1) it is selfsupporting , meaning that for all ω ∈ w , if v ∈ vars(w) and u ∈ P a ω ( v ), then u ∈ vars( w ); and (2) it is minimal , meaning that removing any variable v (cid:54)∈ U from vars( w ) would cause it to fail to be self-supporting.

Original: Together, these criteria ensure that for any U ⊆ V , the components w are disjoint, and so p ( w ) =
Revised: Together, these criteria ensure that for any U ⊆ V , the components w are disjoint, and so p ( w ) =

Original: Π( w ) is a valid probability distribution over minimal self-supporting instantiations w .
Revised: Π( w ) is a valid probability distribution over minimal self-supporting instantiations w .

Original: Conveniently, the probability of each component w is a simple product of the conditional distributions p v , as in a typical Bayesian network:
Revised: Conveniently, the probability of each component w is a simple product of the conditional distributions p v , as in a typical Bayesian network:

Original: [Equation]
Revised: [Equation]

Original: B
Revised: B

Original: 1. Contingent Bayesian Networks with Continuous Variables
Revised: 1. Contingent Bayesian Networks with Continuous Variables

Original: We now extend the CBN framework to support models with some continuous object property domains, so long as no discrete variables count continuous variables as parents.
Revised: We now extend the CBN framework to support models with some continuous object property domains, so long as no discrete variables count continuous variables as parents.

Original: 4 (Wu et al.
Revised: 4 (Wu et al.

Original: (2018) give a semantics for open-universe models that interprets them as inﬁnite product measures over assignments to all basic random variables.
Revised: (2018) give a semantics for open-universe models that interprets them as inﬁnite product measures over assignments to all basic random variables.

Original: This allows them to interpret
Revised: This allows them to interpret

Original: OUPMs with continuous and discrete random variables, but does not serve our purposes: it does not yield a formula for the density of an MSSI in an open-universe model, nor can it be used to prove that incremental computation strategies for fast MCMC are correct, as—unlike in CBNs—it does not account for contingent dependency structure among variables.)
Revised: OUPMs with continuous and discrete random variables, but does not serve our purposes: it does not yield a formula for the density of an MSSI in an open-universe model, nor can it be used to prove that incremental computation strategies for fast MCMC are correct, as—unlike in CBNs—it does not account for contingent dependency structure among variables.)

Original: As before, let V be a collection of variables, but now suppose some variables V c ⊆
Revised: As before, let V be a collection of variables, but now suppose some variables V c ⊆

Original: V have continuous domains.
Revised: V have continuous domains.

Original: Then deﬁne the surrogate discrete domain dom D ( v ) of a variable v to be dom( v ) if v (cid:54)∈ V c , and { (cid:63) } otherwise.
Revised: Then deﬁne the surrogate discrete domain dom D ( v ) of a variable v to be dom( v ) if v (cid:54)∈ V c , and { (cid:63) } otherwise.

Original: A continuously extended CBN deﬁnes (1) an ordinary CBN on the variables V , treating them as having surrogate discrete domains dom D , and (2) conditional probability densities p v ( · | { w [ u ] | u ∈ P a w ( v ) } ) for each continuous variable v ∈ V c .
Revised: A continuously extended CBN deﬁnes (1) an ordinary CBN on the variables V , treating them as having surrogate discrete domains dom D , and (2) conditional probability densities p v ( · | { w [ u ] | u ∈ P a w ( v ) } ) for each continuous variable v ∈ V c .

Original: The CBN induces a distribution Π on minimal self-supporting worlds, which we modify to deﬁne a probability measure on the space W of continuously extended minimal self-supporting worlds : pairs ( w d , w c ) of a minimal self-supporting world w d for the discrete CBN, plus a real-valued assignment w c to all variables in vars( w d ) ∩ V c .
Revised: The CBN induces a distribution Π on minimal self-supporting worlds, which we modify to deﬁne a probability measure on the space W of continuously extended minimal self-supporting worlds : pairs ( w d , w c ) of a minimal self-supporting world w d for the discrete CBN, plus a real-valued assignment w c to all variables in vars( w d ) ∩ V c .

Original: We let w [ v ] denote w c
Revised: We let w [ v ] denote w c

Original: [ v ] if v ∈ V c and w d [ v ] otherwise.
Revised: [ v ] if v ∈ V c and w d [ v ] otherwise.

Original: The distribution has density
Revised: The distribution has density

Original: [Equation]
Revised: [Equation]

Original: with respect to the reference measure
Revised: with respect to the reference measure

Original: [Equation]
Revised: [Equation]

Original: where λ k denotes the k -dimensional Lebesgue measure.
Revised: where λ k denotes the k -dimensional Lebesgue measure.

Original: Using Equation 4 for the ﬁrst term of p ( w ), we see that in the continuous case, we still have the ordinary Bayes net factorization
Revised: Using Equation 4 for the ﬁrst term of p ( w ), we see that in the continuous case, we still have the ordinary Bayes net factorization

Original: [Equation]
Revised: [Equation]

Original: B.1.1. Continuously-Extended CBNs with Continuous Parents of Discrete Variables
Revised: B.1.1. Continuously-Extended CBNs with Continuous Parents of Discrete Variables

Original: In the previous section, we deﬁne continuously-extended contingent Bayesian networks with the restriction that no discrete variables have continuous variables as parents.
Revised: In the previous section, we deﬁne continuously-extended contingent Bayesian networks with the restriction that no discrete variables have continuous variables as parents.

Original: We now give a more ﬂexible development.
Revised: We now give a more ﬂexible development.

Original: Let V be a collection of variables, where V c ⊆
Revised: Let V be a collection of variables, where V c ⊆

Original: V have continuous domains.
Revised: V have continuous domains.

Original: Deﬁne surrogate discrete domain dom D ( v ) to be dom( v ) if v / ∈ V c , and { (cid:63) } otherwise.
Revised: Deﬁne surrogate discrete domain dom D ( v ) to be dom( v ) if v / ∈ V c , and { (cid:63) } otherwise.

Original: Now deﬁne a continuously extended CBN to comprise: (1) an ordinary CBN on the variables
Revised: Now deﬁne a continuously extended CBN to comprise: (1) an ordinary CBN on the variables

Original: V , treating them as having surrogate discrete domains dom D , and (2) a conditional joint probability density P c ( w c | w ) on the values of the continuous variables in a minimal selfsupporting instantiation w given the values of all w ’s discrete variables.
Revised: V , treating them as having surrogate discrete domains dom D , and (2) a conditional joint probability density P c ( w c | w ) on the values of the continuous variables in a minimal selfsupporting instantiation w given the values of all w ’s discrete variables.

Original: This CBN induces distribution Π on minimal self-supporting worlds; as before, we modify this to deﬁne the space W of continuously extended minimal self-supporting worlds , consisting of a minimal self-supporting world w of the CBN, and an assignment w [ v ] to each continuous variable in vars( v ) ∩ V c .
Revised: This CBN induces distribution Π on minimal self-supporting worlds; as before, we modify this to deﬁne the space W of continuously extended minimal self-supporting worlds , consisting of a minimal self-supporting world w of the CBN, and an assignment w [ v ] to each continuous variable in vars( v ) ∩ V c .

Original: We use w c to denote the assignment of values w [ v ] to the continuous variables v ∈ V c ∩ vars( w ) in w .
Revised: We use w c to denote the assignment of values w [ v ] to the continuous variables v ∈ V c ∩ vars( w ) in w .

Original: The distribution then has density
Revised: The distribution then has density

Original: [Equation]
Revised: [Equation]

Original: with respect to the same reference measure from Section 2: µ
Revised: with respect to the same reference measure from Section 2: µ

Original: [Equation]
Revised: [Equation]

Original: where λ k denotes the k -dimensional Lebesgue measure.
Revised: where λ k denotes the k -dimensional Lebesgue measure.

Original: We note that the density we give ultimately factorizes, as before, as a marginal probability for the discrete variables and a conditional density for the continuous variables.
Revised: We note that the density we give ultimately factorizes, as before, as a marginal probability for the discrete variables and a conditional density for the continuous variables.

Original: (In principle, this alone is not a restriction, because any distribution over minimal self-supporting instantiations can be factored in this way.)
Revised: (In principle, this alone is not a restriction, because any distribution over minimal self-supporting instantiations can be factored in this way.)

Original: But in the previous formulation (from Section 2), this factorization was embedded into the discrete CBN itself, aﬀecting which worlds w counted as minimal and self-supporting in the ﬁrst place.
Revised: But in the previous formulation (from Section 2), this factorization was embedded into the discrete CBN itself, aﬀecting which worlds w counted as minimal and self-supporting in the ﬁrst place.

Original: The key diﬀerence between this section’s formulation and the one in
Revised: The key diﬀerence between this section’s formulation and the one in

Original: Section 2 is that here we divorce the factorization of the continuous density from the CBN’s structure; the edges involving continuous variables in the CBN serve only to determine which continuous variables are required in a minimal, self-supporting instantiation for an observed set of variables U .
Revised: Section 2 is that here we divorce the factorization of the continuous density from the CBN’s structure; the edges involving continuous variables in the CBN serve only to determine which continuous variables are required in a minimal, self-supporting instantiation for an observed set of variables U .

Original: Appendix C. Modeling and Inference Programming Languages for OUPMs
Revised: Appendix C. Modeling and Inference Programming Languages for OUPMs

Original: In this section, we brieﬂy outline our modeling language for OUPMs, and our DSL for writing involutions for involutive MCMC on OUPMs.
Revised: In this section, we brieﬂy outline our modeling language for OUPMs, and our DSL for writing involutions for involutive MCMC on OUPMs.

Original: OUPM Modeling Language
Revised: OUPM Modeling Language

Original: We have developed a new modeling language that is inspired by BLOG (Milch, 2006) for use in the Gen probabilistic programming system; for examples, refer to Figure 1, Figure 5, or Figure 7.
Revised: We have developed a new modeling language that is inspired by BLOG (Milch, 2006) for use in the Gen probabilistic programming system; for examples, refer to Figure 1, Figure 5, or Figure 7.

Original: Our language extends one of Gen’s built-in modeling languages in the following ways.
Revised: Our language extends one of Gen’s built-in modeling languages in the following ways.

Original: We add type statements for declaring object types, property declarations for adding properties, and number declarations for adding possible origins.
Revised: We add type statements for declaring object types, property declarations for adding properties, and number declarations for adding possible origins.

Original: When writing world models with our system, users must deﬁne a special property O () with respect to which the model will take minimal self-supporting instantiations; they do this using an observation model statement.
Revised: When writing world models with our system, users must deﬁne a special property O () with respect to which the model will take minimal self-supporting instantiations; they do this using an observation model statement.

Original: Property and number declarations are attached to function bodies which together deﬁne the contingent Bayesian network.
Revised: Property and number declarations are attached to function bodies which together deﬁne the contingent Bayesian network.

Original: In particular, a property statement declares the existence of a property P ( τ 1 , . . .
Revised: In particular, a property statement declares the existence of a property P ( τ 1 , . . .

Original: , τ n ), and deﬁnes a probabilistic generative process for the property’s value.
Revised: , τ n ), and deﬁnes a probabilistic generative process for the property’s value.

Original: A number statement ( τ, ( τ 1 , . . . , τ n )) declares that ( τ 1 , . . .
Revised: A number statement ( τ, ( τ 1 , . . . , τ n )) declares that ( τ 1 , . . .

Original: , τ n ) is a permissible origin signature for objects of type τ , and declares the distribution over how many objects of type τ there are with each origin matching ( τ 1 , . . .
Revised: , τ n ) is a permissible origin signature for objects of type τ , and declares the distribution over how many objects of type τ there are with each origin matching ( τ 1 , . . .

Original: , τ n ).
Revised: , τ n ).

Original: (So each property/number statement simultaneously serves as an object property declaration/object origin declaration, and declares the distribution over the corresponding property/number variables in the OUPM’s CBN.)
Revised: (So each property/number statement simultaneously serves as an object property declaration/object origin declaration, and declares the distribution over the corresponding property/number variables in the OUPM’s CBN.)

Original: The bodies of number and property declarations are speciﬁed in an imperative probabilistic programming language that induces distributions over ﬁnite dictionaries, called traces.
Revised: The bodies of number and property declarations are speciﬁed in an imperative probabilistic programming language that induces distributions over ﬁnite dictionaries, called traces.

Original: The language uses
Revised: The language uses

Original: Julia syntax for deﬁning functions, but may sample random variable values using x ∼ d statements.
Revised: Julia syntax for deﬁning functions, but may sample random variable values using x ∼ d statements.

Original: A program in the language deﬁnes a distribution over traces mapping each key x to the value sampled from the corresponding d in an execution of the function.
Revised: A program in the language deﬁnes a distribution over traces mapping each key x to the value sampled from the corresponding d in an execution of the function.

Original: The language is a built-in modeling language in Gen that was augmented with support for get( P ( o 1 , . . .
Revised: The language is a built-in modeling language in Gen that was augmented with support for get( P ( o 1 , . . .

Original: , o n ) ) statements to access the value of P ( o 1 , . . .
Revised: , o n ) ) statements to access the value of P ( o 1 , . . .

Original: , o n ) in the world; this introduces an edge in the contingent Bayes net representing the model.
Revised: , o n ) in the world; this introduces an edge in the contingent Bayes net representing the model.

Original: Represented as imperative probabilistic programs, number variables must always have 0 or 1 keys in their traces, corresponding to either deterministically returning a number, or sampling a single random number.
Revised: Represented as imperative probabilistic programs, number variables must always have 0 or 1 keys in their traces, corresponding to either deterministically returning a number, or sampling a single random number.

Original: Properties may have more than 1 key in their trace (so long as the set of possible keys is countable), but when they do, the the property statement P must be understood as deﬁning a separate object property declaration P => k for each k which can appear as a key in the trace.
Revised: Properties may have more than 1 key in their trace (so long as the set of possible keys is countable), but when they do, the the property statement P must be understood as deﬁning a separate object property declaration P => k for each k which can appear as a key in the trace.

Original: For simplicity, in what follows, we will assume that each P ( o 1 , . . .
Revised: For simplicity, in what follows, we will assume that each P ( o 1 , . . .

Original: , o n ) is itself a variable with only 0 or 1 keys in its probabilistic program’s traces; however, the algorithms we give also hold when there can be multiple keys.
Revised: , o n ) is itself a variable with only 0 or 1 keys in its probabilistic program’s traces; however, the algorithms we give also hold when there can be multiple keys.

Original: We represent MSSIs as sets of pairs ( P ( o 1 , . . .
Revised: We represent MSSIs as sets of pairs ( P ( o 1 , . . .

Original: , o n ) , t ), where P is a number or property probabilistic program whose type signature matches ( o 1 , . .
Revised: , o n ) , t ), where P is a number or property probabilistic program whose type signature matches ( o 1 , . .

Original: . , o n ), and t is a trace for this variable.
Revised: . , o n ), and t is a trace for this variable.

Original: OUPM Involution Programming Language
Revised: OUPM Involution Programming Language

Original: We implement a new OUPM involution programming language to implement involutions on the space of pairs ( x, y ), where x is a world represented as described above, and y is a trace from a imperative probabilistic program.
Revised: We implement a new OUPM involution programming language to implement involutions on the space of pairs ( x, y ), where x is a world represented as described above, and y is a trace from a imperative probabilistic program.

Original: Involutions are written as imperative functions which may call special commands to modify state x in order to produce x (cid:48) , to access values in x and y , and to specify the new values for y (cid:48) .
Revised: Involutions are written as imperative functions which may call special commands to modify state x in order to produce x (cid:48) , to access values in x and y , and to specify the new values for y (cid:48) .

Original: Speciﬁcally, the DSL provides support for the following.
Revised: Speciﬁcally, the DSL provides support for the following.

Original: • Querying the current model state ( x ).
Revised: • Querying the current model state ( x ).

Original: Users may query the current model state
Revised: Users may query the current model state

Original: using the syntax get( P ( o 1 , . .
Revised: using the syntax get( P ( o 1 , . .

Original: , o n )[ a ] ) , which retrieves the sample at address a of the trace for the property P ( o 1 , . . .
Revised: , o n )[ a ] ) , which retrieves the sample at address a of the trace for the property P ( o 1 , . . .

Original: , o n ).
Revised: , o n ).

Original: Similarly, get number( τ ( o 1 , . . .
Revised: Similarly, get number( τ ( o 1 , . . .

Original: , o n )) ) retrieves the number variable
Revised: , o n )) ) retrieves the number variable

Original: value in
Revised: value in

Original: x deﬁning
Revised: x deﬁning

Original: how
Revised: how

Original: many objects of type τ
Revised: many objects of type τ

Original: exist with origin
Revised: exist with origin

Original: o o
Revised: o o

Original: n )
Revised: n )

Original: Several higher-level commands are also provided to access higher-
Revised: Several higher-level commands are also provided to access higher-

Original: level
Revised: level

Original: discrtete
Revised: discrtete

Original: information about the current state, including get object set ( τ ), which gets the set of all existing objects of type τ in x . • Querying the auxiliary randomness ( y ).
Revised: information about the current state, including get object set ( τ ), which gets the set of all existing objects of type τ in x . • Querying the auxiliary randomness ( y ).

Original: The syntax proposed[ a ] returns y
Revised: The syntax proposed[ a ] returns y

Original: [ a ], the value at address a in the random trace y of the proposal program Q .
Revised: [ a ], the value at address a in the random trace y of the proposal program Q .

Original: Proposing the new model state ( x (cid:48) ).
Revised: Proposing the new model state ( x (cid:48) ).

Original: The new model state is proposed via commands that imperatively modify the old state x .
Revised: The new model state is proposed via commands that imperatively modify the old state x .

Original: They can do this either by changing the structure of x (by adding or removing objects, and changing the origins or indices of objects), or by writing new values to object properties.
Revised: They can do this either by changing the structure of x (by adding or removing objects, and changing the origins or indices of objects), or by writing new values to object properties.

Original: The commands create , delete , split , merge , and change add, remove, and change the relationships of objects in the possible world, updating the values of number variables as necessary.
Revised: The commands create , delete , split , merge , and change add, remove, and change the relationships of objects in the possible world, updating the values of number variables as necessary.

Original: The behavior of each detailed below, and illustrated and described in Figure 13.
Revised: The behavior of each detailed below, and illustrated and described in Figure 13.

Original: Commands that remove objects have the eﬀect of deleting any traces for variables
Revised: Commands that remove objects have the eﬀect of deleting any traces for variables

Original: G ( o 1 , . . .
Revised: G ( o 1 , . . .

Original: , o i , . . .
Revised: , o i , . . .

Original: o n ) of an object tuple including an o i slated for deletion.
Revised: o n ) of an object tuple including an o i slated for deletion.

Original: If the deleted object is the origin of other objects (e.g., if an Event with Detection s is deleted
Revised: If the deleted object is the origin of other objects (e.g., if an Event with Detection s is deleted

Original: ), those objects are not automatically deleted: users may either manually remove them or change their origins using change .
Revised: ), those objects are not automatically deleted: users may either manually remove them or change their origins using change .

Original: The command set G ( o 1 , . . .
Revised: The command set G ( o 1 , . . .

Original: , o n )[ a ] = v sets the sample at address a of a trace for G ( o 1 , . . .
Revised: , o n )[ a ] = v sets the sample at address a of a trace for G ( o 1 , . . .

Original: o n ) to v in the proposed state x (cid:48) .
Revised: o n ) to v in the proposed state x (cid:48) .

Original: • Transforming the auxiliary randomness ( y (cid:48) ).
Revised: • Transforming the auxiliary randomness ( y (cid:48) ).

Original: The user’s code is responsible for computing a new trace y (cid:48) of Q that makes f into an involution.
Revised: The user’s code is responsible for computing a new trace y (cid:48) of Q that makes f into an involution.

Original: Intuitively, y (cid:48) must specify the proposal choices that would reverse the current move; in Figure 2, the forward move that posits a new Event to explain a false positive is reversed by a move that deletes the newly created Event and reclassiﬁes its sole detection as a false positive.
Revised: Intuitively, y (cid:48) must specify the proposal choices that would reverse the current move; in Figure 2, the forward move that posits a new Event to explain a false positive is reversed by a move that deletes the newly created Event and reclassiﬁes its sole detection as a false positive.

Original: Users can write to y (cid:48) using the syntax backward[ a ] = v .
Revised: Users can write to y (cid:48) using the syntax backward[ a ] = v .

Original: C.1. Object manipulation moves
Revised: C.1. Object manipulation moves

Original: The involution programming language includes commands to create, delete, split, merge, and change the origins of objects in the world.
Revised: The involution programming language includes commands to create, delete, split, merge, and change the origins of objects in the world.

Original: It is clear that these moves should increment or decrements number variables in the world to change the number of objects hypothesized to exist.
Revised: It is clear that these moves should increment or decrements number variables in the world to change the number of objects hypothesized to exist.

Original: However, to enable us to delete any object with any index, or create an object at any index (needed for reversibility), we need some scheme for reindexing the other existing objects.
Revised: However, to enable us to delete any object with any index, or create an object at any index (needed for reversibility), we need some scheme for reindexing the other existing objects.

Original: (For example, when creating a new object 1, the system must “make room” for the new object 1, for example by incrementing the index of every existing object.)
Revised: (For example, when creating a new object 1, the system must “make room” for the new object 1, for example by incrementing the index of every existing object.)

Original: We describe the reindexing scheme we use.
Revised: We describe the reindexing scheme we use.

Original: create <type> with [ origin <origin>] index <index> create Event with indexdelete merge Detection with origin ■ index 2,3 to indexchange to origin ( ■ , ⬤ ) index
Revised: create <type> with [ origin <origin>] index <index> create Event with indexdelete merge Detection with origin ■ index 2,3 to indexchange to origin ( ■ , ⬤ ) index

Original: Event()
Revised: Event()

Original: [Table]
Revised: [Table]

Original: Event(
Revised: Event(

Original: [Table]
Revised: [Table]

Original: Event()
Revised: Event()

Original: [Table]
Revised: [Table]

Original: 4 Event()
Revised: 4 Event()

Original: Detection( ■ ) 1 2 3 Detection( ■ )
Revised: Detection( ■ ) 1 2 3 Detection( ■ )

Original: Detection( ■ ) 1 2 1 2 3 Detection( ■ ) 2 Detection( ■ ) 2 Detection( ■ , ⬤ ) 1 Detection( ■ ) 3 Detection( ■ , ⬤ )delete <object> merge <object1>, <object2> to index <index> [< changing clauses>...] change <object> to origin <origin> index <index> split <object> to indices <index1>, <index2> [< changing clauses>...] split to indices 1,changing to origin ( , Event with index 2) index
Revised: Detection( ■ ) 1 2 1 2 3 Detection( ■ ) 2 Detection( ■ ) 2 Detection( ■ , ⬤ ) 1 Detection( ■ ) 3 Detection( ■ , ⬤ )delete <object> merge <object1>, <object2> to index <index> [< changing clauses>...] change <object> to origin <origin> index <index> split <object> to indices <index1>, <index2> [< changing clauses>...] split to indices 1,changing to origin ( , Event with index 2) index

Original: Station() Detection( , )
Revised: Station() Detection( , )

Original: Event()

Revised: Event()

Original: Event() 

Revised: Event()

Original: Station() Detection( , ) 1merge , to indexchanging to origin ( , Event with index 1) indexchanging to origin ( , Event with index 1) index
Revised: Station() Detection( , ) 1merge , to indexchanging to origin ( , Event with index 1) indexchanging to origin ( , Event with index 1) index

Original: Station()
Revised: Station()

Original: Detection( , )
Revised: Detection( , )

Original: Event()11 Event()
Revised: Event()11 Event()

Original: Station()
Revised: Station()

Original: Detection( , ) 
 Detection( , )
Revised: Detection( , ) 
 Detection( , )

Original: Inserts a new object <type>(<origin>, <index>) .
Revised: Inserts a new object <type>(<origin>, <index>) .

Original: Deletes <object>.
Revised: Deletes <object>.

Original: Deletes <object> with type <type> and inserts new=<type>(<origin>, <index>) , changing all references to <object> to become references to new .
Revised: Deletes <object> with type <type> and inserts new=<type>(<origin>, <index>) , changing all references to <object> to become references to new .

Original: Deletes <object>=<type>(<origin>, <index>) and inserts <type>(<origin>, <index1>) , and <type>(<origin>, <index2>) .
Revised: Deletes <object>=<type>(<origin>, <index>) and inserts <type>(<origin>, <index1>) , and <type>(<origin>, <index2>) .

Original: Performs the change commands specified by the changing clauses, to change the origins of children of <object>.
Revised: Performs the change commands specified by the changing clauses, to change the origins of children of <object>.

Original: Deletes <object1>=<type>(<origin>, <index1>) and <object2>=<type>(<origin>, <index2>) and inserts <type>(<origin>, <index>) .
Revised: Deletes <object1>=<type>(<origin>, <index1>) and <object2>=<type>(<origin>, <index2>) and inserts <type>(<origin>, <index>) .

Original: Performs the change commands specified by the changing clauses, to change origins of children of the deleted objects .
Revised: Performs the change commands specified by the changing clauses, to change origins of children of the deleted objects .

Original: <type> with [ origin <origin>], index <index>
Revised: <type> with [ origin <origin>], index <index>

Original: Constructor for the object <type>(<origin>, <index>) .
Revised: Constructor for the object <type>(<origin>, <index>) .

Original: [Figure]
Revised: [Figure]

Original: Reindexing.
Revised: Reindexing.

Original: For any given origin tuple of objects, origin , a world contains N origin T objects of type T : { T ( origin , 1) , ..., T ( origin , N origin T ) } .
Revised: For any given origin tuple of objects, origin , a world contains N origin T objects of type T : { T ( origin , 1) , ..., T ( origin , N origin T ) } .

Original: Deleting the object T ( origin , i ) corresponds to a “vector deletion” which decrements the value of N origin T and decrements the index of every object T ( origin , j ) for j > i .
Revised: Deleting the object T ( origin , i ) corresponds to a “vector deletion” which decrements the value of N origin T and decrements the index of every object T ( origin , j ) for j > i .

Original: Likewise, adding an object T ( origin , i ) is a “vector insertion” which increments N origin T and increments the index of every object
Revised: Likewise, adding an object T ( origin , i ) is a “vector insertion” which increments N origin T and increments the index of every object

Original: T ( origin , j ) for j ≥ i .
Revised: T ( origin , j ) for j ≥ i .

Original: In a world model, “changing the index” of an object T ( origin , j ) corresponds to updating the world so that the trace for any property or number variable P [ o 1 , ..., T ( origin , j ) , ..., o n ] becomes the trace for P [ o 1 , ..., T ( origin , j + 1) , ..., o n ] or
Revised: In a world model, “changing the index” of an object T ( origin , j ) corresponds to updating the world so that the trace for any property or number variable P [ o 1 , ..., T ( origin , j ) , ..., o n ] becomes the trace for P [ o 1 , ..., T ( origin , j + 1) , ..., o n ] or

Original: P [ o 1 , ..., T ( origin , j − 1) , ..., o n ].
Revised: P [ o 1 , ..., T ( origin , j − 1) , ..., o n ].

Original: Likewise, the update must change any object which has
Revised: Likewise, the update must change any object which has

Original: T ( origin , j ) in its origin to instead have T ( origin , j + 1) or T ( origin , j − 1) in its origin.
Revised: T ( origin , j ) in its origin to instead have T ( origin , j + 1) or T ( origin , j − 1) in its origin.

Original: While in a naive implementation, simple reindexing operations require copying many traces and greatly perturbing the model state, which causes extreme ineﬃciency when implementing split/merge and birth/death moves in PPLs like vanilla Gen or Stochaskell, the use of explicit open universe modeling constructs encodes enough structure for us to implement these moves very eﬃciently without copying data, using the object aliasing technique presented in Appendix D.
Revised: While in a naive implementation, simple reindexing operations require copying many traces and greatly perturbing the model state, which causes extreme ineﬃciency when implementing split/merge and birth/death moves in PPLs like vanilla Gen or Stochaskell, the use of explicit open universe modeling constructs encodes enough structure for us to implement these moves very eﬃciently without copying data, using the object aliasing technique presented in Appendix D.

Original: Appendix D. Automatically Implementing Inference Kernels Eﬃciently
Revised: Appendix D. Automatically Implementing Inference Kernels Eﬃciently

Original: In this section, we describe in more detail the technique by which we automate the implementation of inference kernels, and the optimizations we use to produce implementations performant enough to scale to real-world data sizes.
Revised: In this section, we describe in more detail the technique by which we automate the implementation of inference kernels, and the optimizations we use to produce implementations performant enough to scale to real-world data sizes.

Original: This technique extends upon an approach for automating involutive MCMC over traces of probabilistic programs described in Cusumano-Towner et al.
Revised: This technique extends upon an approach for automating involutive MCMC over traces of probabilistic programs described in Cusumano-Towner et al.

Original: In particular, we are able to exploit sparsity in the calculated Jacobian to avoid calculating the determinant of a large matrix, and exploit the conditional-independence relationships encoded in the contingent Bayesian network underlying the OUPM to eﬃciently calculate the state ratio p ( x (cid:48) )
Revised: In particular, we are able to exploit sparsity in the calculated Jacobian to avoid calculating the determinant of a large matrix, and exploit the conditional-independence relationships encoded in the contingent Bayesian network underlying the OUPM to eﬃciently calculate the state ratio p ( x (cid:48) )

Original: /p
Revised: /p

Original: ( x ).
Revised: ( x ).

Original: The performance enabled by the latter is one of the key beneﬁts of introducing ﬁrst-class support for involutive MCMC on OUPMs.
Revised: The performance enabled by the latter is one of the key beneﬁts of introducing ﬁrst-class support for involutive MCMC on OUPMs.

Original: To implement the inference kernel speciﬁed by a given proposal q and involution f , we must be able to sample and score auxiliary randomness y ∼ q x , produce transitions ( x, y )
Revised: To implement the inference kernel speciﬁed by a given proposal q and involution f , we must be able to sample and score auxiliary randomness y ∼ q x , produce transitions ( x, y )

Original: → ( x (cid:48) , y (cid:48) ), and calculate acceptance probabilities by calculating q x ( y ), q x (cid:48) ( y (cid:48) ), p ( x (cid:48) ) p ( x ) , and | det ∂ ( x (cid:48) ,y (cid:48) )
Revised: → ( x (cid:48) , y (cid:48) ), and calculate acceptance probabilities by calculating q x ( y ), q x (cid:48) ( y (cid:48) ), p ( x (cid:48) ) p ( x ) , and | det ∂ ( x (cid:48) ,y (cid:48) )

Original: ∂ ( x,y ) | 5 .
Revised: ∂ ( x,y ) | 5 .

Original: Since q is a probabilistic program, scoring and sampling are simple; furthermore, y only contains the minimal number of random choices needed to specify the transition x → x (cid:48) , and thus is cheap to score.
Revised: Since q is a probabilistic program, scoring and sampling are simple; furthermore, y only contains the minimal number of random choices needed to specify the transition x → x (cid:48) , and thus is cheap to score.

Original: On the other hand, naive calculation of the
Revised: On the other hand, naive calculation of the

Original: Jacobian term and state ratio may be extremely expensive, since x may be large, for instance containing a number of variables polynomial in dataset size.
Revised: Jacobian term and state ratio may be extremely expensive, since x may be large, for instance containing a number of variables polynomial in dataset size.

Original: As shown in algorithm 3, after sampling y ∼ q x , we factorize the move into 2 parts, both of which we provide eﬃcient algorithms for:
Revised: As shown in algorithm 3, after sampling y ∼ q x , we factorize the move into 2 parts, both of which we provide eﬃcient algorithms for:

Original: Running f in an instrumented manner to compute the Jacobian term, y (cid:48) , and an update speciﬁcation U for x 2.
Revised: Running f in an instrumented manner to compute the Jacobian term, y (cid:48) , and an update speciﬁcation U for x 2.

Original: Computing x (cid:48) and the state ratio from x and U
Revised: Computing x (cid:48) and the state ratio from x and U

Original: D.1. Eﬃciently calculating the Jacobian term
Revised: D.1. Eﬃciently calculating the Jacobian term

Original: The involutive acceptance probability must include the absolute value of the determinant of the Jacobian matrix for the transformation of continuous values in ( x, y ) into those in ( x (cid:48) , y (cid:48) ).
Revised: The involutive acceptance probability must include the absolute value of the determinant of the Jacobian matrix for the transformation of continuous values in ( x, y ) into those in ( x (cid:48) , y (cid:48) ).

Original: Naively, this can be extremely expensive to calculate, since | x | may be very large, and determinant calculation is O ( n 3 ) in matrix dimension.
Revised: Naively, this can be extremely expensive to calculate, since | x | may be very large, and determinant calculation is O ( n 3 ) in matrix dimension.

Original: Jacobian sparsity.
Revised: Jacobian sparsity.

Original: In practice, most transformations ( x, y )
Revised: In practice, most transformations ( x, y )

Original: → ( x (cid:48) , y (cid:48) ) only modify the values of a small number of continuous values; all other continuous values are simply copied from ( x, y ) to ( x (cid:48) , y (cid:48) )
Revised: → ( x (cid:48) , y (cid:48) ) only modify the values of a small number of continuous values; all other continuous values are simply copied from ( x, y ) to ( x (cid:48) , y (cid:48) )

Original: (either at the same address or a new one).
Revised: (either at the same address or a new one).

Original: Such a copy introduces a column into the Jacobian matrix which contains all zeros except for one 1 in the position the value was copied to.
Revised: Such a copy introduces a column into the Jacobian matrix which contains all zeros except for one 1 in the position the value was copied to.

Original: Such a column cannot eﬀect the absolute value of the matrix’s determinant, so we do not need to include rows and columns corresponding to copying in the matrix.
Revised: Such a column cannot eﬀect the absolute value of the matrix’s determinant, so we do not need to include rows and columns corresponding to copying in the matrix.

Original: What this means in practice is that in algorithm 2, we only track transformations of the values which are explicitly read from x or y into values explicitly written into the next procedure ProcessInvolution ( f, ( x, y ))
Revised: What this means in practice is that in algorithm 2, we only track transformations of the values which are explicitly read from x or y into values explicitly written into the next procedure ProcessInvolution ( f, ( x, y ))

Original: (cid:46) Track continuous reads and writes, manipulation moves M , and property updates U (Rd , Wr , M, U, y (cid:48) )
Revised: (cid:46) Track continuous reads and writes, manipulation moves M , and property updates U (Rd , Wr , M, U, y (cid:48) )

Original: ← {} , {} , [ ] , {} , {} Execute f , but with each manipulation command m ( create , delete , change , split , merge ) ≡ ( M ← M ∪ { m } ) "proposed [ k ] " ≡ ( if y [ k ] is continuous:
Revised: ← {} , {} , [ ] , {} , {} Execute f , but with each manipulation command m ( create , delete , change , split , merge ) ≡ ( M ← M ∪ { m } ) "proposed [ k ] " ≡ ( if y [ k ] is continuous:

Original: Rd ← Rd ∪ { y [ k ] } ; y [ k ]) "set backward [ k ] = v " ≡ ( if v is continuous:
Revised: Rd ← Rd ∪ { y [ k ] } ; y [ k ]) "set backward [ k ] = v " ≡ ( if v is continuous:

Original: Wr ← Wr ∪ { y [ k ] } ; y (cid:48)
Revised: Wr ← Wr ∪ { y [ k ] } ; y (cid:48)

Original: ← y (cid:48) ∪ { k (cid:55)→ v } ) "get ( P ( o 1 , . . .
Revised: ← y (cid:48) ∪ { k (cid:55)→ v } ) "get ( P ( o 1 , . . .

Original: , o n )[ k ]) " ≡ ( v ← x [ P ( o 1 , . . .
Revised: , o n )[ k ]) " ≡ ( v ← x [ P ( o 1 , . . .

Original: , o n )]
Revised: , o n )]

Original: [ k ]; if v is continuous:
Revised: [ k ]; if v is continuous:

Original: Rd ← Rd ∪ { v } ; v ) "set P ( o 1 , . . .
Revised: Rd ← Rd ∪ { v } ; v ) "set P ( o 1 , . . .

Original: , o n )[ k ] = v " ≡ ( if v is continuous:
Revised: , o n )[ k ] = v " ≡ ( if v is continuous:

Original: Wr ← Wr ∪ { v } ; U [ P ( o 1 , . . .
Revised: Wr ← Wr ∪ { v } ; U [ P ( o 1 , . . .

Original: , o n )]
Revised: , o n )]

Original: [ k ] ← v ) J ← uninitialized | Rd | × | Rd | matrix for i in { 1 , . .
Revised: [ k ] ← v ) J ← uninitialized | Rd | × | Rd | matrix for i in { 1 , . .

Original: , | Wr |} : (cid:46) Execute f with reverse-mode AD to compute ∂
Revised: , | Wr |} : (cid:46) Execute f with reverse-mode AD to compute ∂

Original: Wr[ i ] ∂
Revised: Wr[ i ] ∂

Original: Rd
Revised: Rd

Original: [ j ] for each j ∈ { 1 , . .
Revised: [ j ] for each j ∈ { 1 , . .

Original: | Rd |}
Revised: | Rd |}

Original: J [: , i ] ← ∇ Rd (Wr
Revised: J [: , i ] ← ∇ Rd (Wr

Original: [ i ]) U ← CompileManipulationMoves( U, M, x ) (cid:46)
Revised: [ i ]) U ← CompileManipulationMoves( U, M, x ) (cid:46)

Original: Get variable updates to implement manipulation moves.
Revised: Get variable updates to implement manipulation moves.

Original: return ( U, y (cid:48) , | det J | ) end procedure state x (cid:48) or reversing randomness y (cid:48) ; all unmentioned continuous values are simply copied without transformation.
Revised: return ( U, y (cid:48) , | det J | ) end procedure state x (cid:48) or reversing randomness y (cid:48) ; all unmentioned continuous values are simply copied without transformation.

Original: This enables us to calculate the determinant of the Jacobian matrix in O (1) in the size of x for many updates, rather than O ( | x | 3 ).
Revised: This enables us to calculate the determinant of the Jacobian matrix in O (1) in the size of x for many updates, rather than O ( | x | 3 ).

Original: Implementation via nonstandard interpretation.
Revised: Implementation via nonstandard interpretation.

Original: Algorithm 2 shows how to use nonstandard interpretation of a world involution f to calculate the Jacobian correction term.
Revised: Algorithm 2 shows how to use nonstandard interpretation of a world involution f to calculate the Jacobian correction term.

Original: Additionally, this interpretation tracks all object manipulation moves which are called, and all set commands.
Revised: Additionally, this interpretation tracks all object manipulation moves which are called, and all set commands.

Original: These are compiled into an object U which fully speciﬁes the update x → x (cid:48) .
Revised: These are compiled into an object U which fully speciﬁes the update x → x (cid:48) .

Original: U is a mapping from variable names G
Revised: U is a mapping from variable names G

Original: o 1 , . .
Revised: o 1 , . .

Original: , o n ) to partial traces U
Revised: , o n ) to partial traces U

Original: [ G ( o 1 , . . .
Revised: [ G ( o 1 , . . .

Original: , o n )], which map addresses to values.
Revised: , o n )], which map addresses to values.

Original: U speciﬁes to update each trace x
Revised: U speciﬁes to update each trace x

Original: [ G ( o 1 , . . .
Revised: [ G ( o 1 , . . .

Original: , o n )] by overwriting addresses a in this trace with U [ G ( o 1 , . .
Revised: , o n )] by overwriting addresses a in this trace with U [ G ( o 1 , . .

Original: o n )]
Revised: o n )]

Original: [ a ].
Revised: [ a ].

Original: We do not detail the process of compiling object manipulation moves into update speciﬁcations; it is a fairly straightforward process of determining how much each number variable must be incremented, and changing object alias associations (which are described below).
Revised: We do not detail the process of compiling object manipulation moves into update speciﬁcations; it is a fairly straightforward process of determining how much each number variable must be incremented, and changing object alias associations (which are described below).

Original: D.2. Eﬃciently calculating the state ratio
Revised: D.2. Eﬃciently calculating the state ratio

Original: Because we use world models written using declarative get commands to mediate dependencies among variables in each world, our backend has access to information about which variables are conditionally independent in each state for any world model.
Revised: Because we use world models written using declarative get commands to mediate dependencies among variables in each world, our backend has access to information about which variables are conditionally independent in each state for any world model.

Original: Unlike in existing systems for programmable inference, which can only track dependency information in very simple models, this in principle enables us to eﬃciently calculate the state ratio
Revised: Unlike in existing systems for programmable inference, which can only track dependency information in very simple models, this in principle enables us to eﬃciently calculate the state ratio

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: To do this, we only need to consider variables which introduce terms to this ratio that do not cancel out.
Revised: To do this, we only need to consider variables which introduce terms to this ratio that do not cancel out.

Original: These are the variables which have been added to or deleted from x (cid:48) , variables whose traces have changed between x and x (cid:48) , and variables whose dependencies’ values have changed.
Revised: These are the variables which have been added to or deleted from x (cid:48) , variables whose traces have changed between x and x (cid:48) , and variables whose dependencies’ values have changed.

Original: Complications vs updating regular Bayesian networks.
Revised: Complications vs updating regular Bayesian networks.

Original: While world models are similar to Bayesian networks in that they contain a dependency graph among variables, they are far more general, and present novel challenges for producing eﬃcient updates.
Revised: While world models are similar to Bayesian networks in that they contain a dependency graph among variables, they are far more general, and present novel challenges for producing eﬃcient updates.

Original: In procedure OUPM-IMCMC ( p, q, f, x ) ( y, q x ( y ))
Revised: In procedure OUPM-IMCMC ( p, q, f, x ) ( y, q x ( y ))

Original: ← SampleAndScore ( q, x ) ( U, y (cid:48) , J ) ← ProcessInvolution ( f, ( x, y ))
Revised: ← SampleAndScore ( q, x ) ( U, y (cid:48) , J ) ← ProcessInvolution ( f, ( x, y ))

Original: ( x (cid:48) , p ( x (cid:48) ) p ( x ) )
Revised: ( x (cid:48) , p ( x (cid:48) ) p ( x ) )

Original: ← UpdateWorld ( x, U ) q x (cid:48) ( y (cid:48) )
Revised: ← UpdateWorld ( x, U ) q x (cid:48) ( y (cid:48) )

Original: ← Score ( q, x (cid:48) , y (cid:48) )
Revised: ← Score ( q, x (cid:48) , y (cid:48) )

Original: α ← p ( x (cid:48) ) p ( x ) × q x (cid:48)
Revised: α ← p ( x (cid:48) ) p ( x ) × q x (cid:48)

Original: ( y (cid:48) )
Revised: ( y (cid:48) )

Original: × 1 q x ( y ) × J with probability α return x (cid:48)
Revised: × 1 q x ( y ) × J with probability α return x (cid:48)

Original: else return x end procedure (cid:46) Update a trace by executing the corresponding imperative probabilistic program.
Revised: else return x end procedure (cid:46) Update a trace by executing the corresponding imperative probabilistic program.

Original: procedure Execute ( v = G ( o 1 , . . .
Revised: procedure Execute ( v = G ( o 1 , . . .

Original: , o n ) , ˜ x, U, x ) r ← 1, C ← get( U, v, {} ) t ← Trace G ( o 1 , . . .
Revised: , o n ) , ˜ x, U, x ) r ← 1, C ← get( U, v, {} ) t ← Trace G ( o 1 , . . .

Original: , o n ), but with " a ∼ d " ≡ if a ∈ vars( C ): C [ a ]; else : x [ v ][ a ] "get G (cid:48)
Revised: , o n ), but with " a ∼ d " ≡ if a ∈ vars( C ): C [ a ]; else : x [ v ][ a ] "get G (cid:48)

Original: ( o (cid:48) 1 , . . .
Revised: ( o (cid:48) 1 , . . .

Original: , o (cid:48) m ) ≡ ( if ( u = G (cid:48)
Revised: , o (cid:48) m ) ≡ ( if ( u = G (cid:48)

Original: ( o (cid:48) 1 , . . .
Revised: ( o (cid:48) 1 , . . .

Original: o (cid:48) m )) / ∈ vars(˜ x ): (cid:46)
Revised: o (cid:48) m )) / ∈ vars(˜ x ): (cid:46)

Original: If we might have to update u , we must do it before accessing its value in v .
Revised: If we might have to update u , we must do it before accessing its value in v .

Original: (˜ x, r (cid:48) ) ← Execute( G (cid:48)
Revised: (˜ x, r (cid:48) ) ← Execute( G (cid:48)

Original: ( o (cid:48) 1 , . . .
Revised: ( o (cid:48) 1 , . . .

Original: o (cid:48) m ) , ˜ x, U, x ) r ← r × r (cid:48)
Revised: o (cid:48) m ) , ˜ x, U, x ) r ← r × r (cid:48)

Original: ˜ x
Revised: ˜ x

Original: [ u ] ) if p ˜ x
Revised: [ u ] ) if p ˜ x

Original: ( t ) = 0: (cid:46)
Revised: ( t ) = 0: (cid:46)

Original: In this case, v will be pruned.
Revised: In this case, v will be pruned.

Original: ˜ x ← x ∪ { x [ v ] } else : ˜ x ← ˜ x
Revised: ˜ x ← x ∪ { x [ v ] } else : ˜ x ← ˜ x

Original: { v (cid:55)→ t } if v vars( x ):
Revised: { v (cid:55)→ t } if v vars( x ):

Original: ) p
Revised: ) p

Original: ( x [ v ] p ˜ procedure
Revised: ( x [ v ] p ˜ procedure

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: topologically fore pos have been updated
Revised: topologically fore pos have been updated

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: end procedure
Revised: end procedure

Original: OUPMs, dependencies among variables are not ﬁxed, and may change from state to state in a model, because the underlying Bayesian networks are contingent.
Revised: OUPMs, dependencies among variables are not ﬁxed, and may change from state to state in a model, because the underlying Bayesian networks are contingent.

Original: While Milch et al.
Revised: While Milch et al.

Original: (2005b) introduced the contingent Bayesian network formalism to handle such models, they did not develop algorithms for performing arbitrary updates to these networks.
Revised: (2005b) introduced the contingent Bayesian network formalism to handle such models, they did not develop algorithms for performing arbitrary updates to these networks.

Original: Another complication is that in a world model, the values of variables in the world may deterministically depend on other variables.
Revised: Another complication is that in a world model, the values of variables in the world may deterministically depend on other variables.

Original: For instance, it would be valid for the reading of a seismic Detection to be deterministically equivalent to the magnitude of the corresponding Event .
Revised: For instance, it would be valid for the reading of a seismic Detection to be deterministically equivalent to the magnitude of the corresponding Event .

Original: In these situations, the values of variables ( reading s) may change even if no update is speciﬁed for them, since their values are deterministic functions of other updated variables ( magnitude s).
Revised: In these situations, the values of variables ( reading s) may change even if no update is speciﬁed for them, since their values are deterministic functions of other updated variables ( magnitude s).

Original: Hence, we cannot compile an update which only visit variables in the Markov blankets of variables updates are explicitly speciﬁed for, unlike in Bayesian networks.
Revised: Hence, we cannot compile an update which only visit variables in the Markov blankets of variables updates are explicitly speciﬁed for, unlike in Bayesian networks.

Original: Instead, we introduce algorithm 3, which dynamically tracks changes to the dependency graph and changes to variables which require new variables to be updated.
Revised: Instead, we introduce algorithm 3, which dynamically tracks changes to the dependency graph and changes to variables which require new variables to be updated.

Original: One important insight is that when we update a variable a , we must visit every variable b which depends on a to correctly calculate the state ratio.
Revised: One important insight is that when we update a variable a , we must visit every variable b which depends on a to correctly calculate the state ratio.

Original: At this time, we can check whether b ’s value is deterministically changed by the update to a , and if so, enqueue the dependencies of b to be updated.
Revised: At this time, we can check whether b ’s value is deterministically changed by the update to a , and if so, enqueue the dependencies of b to be updated.

Original: This is implemented by procedure UpdateWorld , which pulls variables relevant to the state ratio or update from a queue, adding new variables to the queue as needed.
Revised: This is implemented by procedure UpdateWorld , which pulls variables relevant to the state ratio or update from a queue, adding new variables to the queue as needed.

Original: However, complications arise due to the necessity of updating variables in a topological order of the dependency graph.
Revised: However, complications arise due to the necessity of updating variables in a topological order of the dependency graph.

Original: Update order
Revised: Update order

Original: The order in which variables are updated is critical for the correctness of UpdateWorld .
Revised: The order in which variables are updated is critical for the correctness of UpdateWorld .

Original: For instance, say b ∈ P a x (cid:48) ( a ) and a, b ∈ vars( U ).
Revised: For instance, say b ∈ P a x (cid:48) ( a ) and a, b ∈ vars( U ).

Original: If we update b before we have updated a , it is impossible to calculate the factor p ( x (cid:48)
Revised: If we update b before we have updated a , it is impossible to calculate the factor p ( x (cid:48)

Original: [ b ] | x (cid:48)
Revised: [ b ] | x (cid:48)

Original: Pa x (cid:48) ( b ) )
Revised: Pa x (cid:48) ( b ) )

Original: =
Revised: =

Original: p ( x (cid:48)
Revised: p ( x (cid:48)

Original: [ b ] | x (cid:48)
Revised: [ b ] | x (cid:48)

Original: [ a ]) in the state ratio, because the value of x (cid:48)
Revised: [ a ]) in the state ratio, because the value of x (cid:48)

Original: [ a ] is not yet known.
Revised: [ a ] is not yet known.

Original: Thus, variables must be updated in the topological order induced by the graph of dependencies in the state x (cid:48) .
Revised: Thus, variables must be updated in the topological order induced by the graph of dependencies in the state x (cid:48) .

Original: However, we cannot know the topological order of x (cid:48) before the update, so we instead use the topological ordering of the old state x , with special-case logic to handle places where this order diﬀers from that in x (cid:48) .
Revised: However, we cannot know the topological order of x (cid:48) before the update, so we instead use the topological ordering of the old state x , with special-case logic to handle places where this order diﬀers from that in x (cid:48) .

Original: This is justiﬁed by the fact that eﬃcient updates are only helpful in transitions x → x (cid:48) producing fairly local changes, and thus we expect that updates we could implement eﬃciently will only change the world’s topological order minorly.
Revised: This is justiﬁed by the fact that eﬃcient updates are only helpful in transitions x → x (cid:48) producing fairly local changes, and thus we expect that updates we could implement eﬃciently will only change the world’s topological order minorly.

Original: To implement this, the update queue Q in UpdateWorld is a priority queue indexed by the topological order of x .
Revised: To implement this, the update queue Q in UpdateWorld is a priority queue indexed by the topological order of x .

Original: In practice, UpdateWorld must also update the topological order of x to one for x (cid:48) ; we elide these details, along with details of maintaining the children x lookup table (which gives the children of each variable in the CBN graph) and the details of implementing the prune function which removes variables which are not needed for a minimal self-supporting instantiation.
Revised: In practice, UpdateWorld must also update the topological order of x to one for x (cid:48) ; we elide these details, along with details of maintaining the children x lookup table (which gives the children of each variable in the CBN graph) and the details of implementing the prune function which removes variables which are not needed for a minimal self-supporting instantiation.

Original: We handle changes in variable order between x and x (cid:48) in the Execute procedure, which updates variable traces.
Revised: We handle changes in variable order between x and x (cid:48) in the Execute procedure, which updates variable traces.

Original: When Execute observes that a variable v get s the value of a variable u which has not yet been updated, this means that in x , u was topologically later than v , but in x (cid:48) , it is topologically before v .
Revised: When Execute observes that a variable v get s the value of a variable u which has not yet been updated, this means that in x , u was topologically later than v , but in x (cid:48) , it is topologically before v .

Original: In this situation, we recursively call Execute( u ) to ensure that we have updated u to the proper value before it is used to update v .
Revised: In this situation, we recursively call Execute( u ) to ensure that we have updated u to the proper value before it is used to update v .

Original: Runtime.
Revised: Runtime.

Original: The full algorithm which accounts for topological order updating runs in
Revised: The full algorithm which accounts for topological order updating runs in

Original: O (( N + M )(log( N + M ) + T )), where N in the number of variables which are updated or impact the state ratio, M is the number of variables whose indices in the topological ordering change during the update, and T is the maximum runtime of updating a single variable in the world.
Revised: O (( N + M )(log( N + M ) + T )), where N in the number of variables which are updated or impact the state ratio, M is the number of variables whose indices in the topological ordering change during the update, and T is the maximum runtime of updating a single variable in the world.

Original: 6 So long as N << | vars( x (cid:48) )
Revised: 6 So long as N << | vars( x (cid:48) )

Original: | and M << | vars( x (cid:48) )
Revised: | and M << | vars( x (cid:48) )

Original: | (both of which are true for most local updates), this algorithm is much faster than generating a new state x (cid:48) from scratch, which takes θ ( | vars( x (cid:48) ) | T ).
Revised: | (both of which are true for most local updates), this algorithm is much faster than generating a new state x (cid:48) from scratch, which takes θ ( | vars( x (cid:48) ) | T ).

Original: Aliased object representation.
Revised: Aliased object representation.

Original: To eﬃciently implement object manipulation moves, which may change the origins and indices of objects, we use a special internal representation of worlds.
Revised: To eﬃciently implement object manipulation moves, which may change the origins and indices of objects, we use a special internal representation of worlds.

Original: If we stored a mapping from the string “ G ( o 1 , . .
Revised: If we stored a mapping from the string “ G ( o 1 , . .

Original: , o n )” to traces in the world, then whenever an object o k = T (origin , j ) had its origin or index change, we would need to update the entry G ( o 1 , . .
Revised: , o n )” to traces in the world, then whenever an object o k = T (origin , j ) had its origin or index change, we would need to update the entry G ( o 1 , . .

Original: , T (origin , j ) , . . .
Revised: , T (origin , j ) , . . .

Original: , o n ) for every property of this object.
Revised: , o n ) for every property of this object.

Original: Instead, we assign each object a unique identiﬁer by storing a lookup table from identiﬁer i k to object o k = T (origin , j ) with each world state.
Revised: Instead, we assign each object a unique identiﬁer by storing a lookup table from identiﬁer i k to object o k = T (origin , j ) with each world state.

Original: We then store traces in a dictionary from keys G
Revised: We then store traces in a dictionary from keys G

Original: ( i 1 , . .
Revised: ( i 1 , . .

Original: , i n ), where each i k is an identiﬁer.
Revised: , i n ), where each i k is an identiﬁer.

Original: Index and origin changes can thus be implemented in O (1) by updating entries in the lookup table, rather than O ( n ) in the number of properties of the updated object.
Revised: Index and origin changes can thus be implemented in O (1) by updating entries in the lookup table, rather than O ( n ) in the number of properties of the updated object.

Original: Appendix E. Involutive MCMC with Ancestral Regeneration.
Revised: Appendix E. Involutive MCMC with Ancestral Regeneration.

Original: A key beneﬁt of involutive MCMC is that it makes it feasible to rapidly prototype inference kernels, because the acceptance-probability calculations are automated.
Revised: A key beneﬁt of involutive MCMC is that it makes it feasible to rapidly prototype inference kernels, because the acceptance-probability calculations are automated.

Original: A useful development pattern is to begin with a kernel which uses generic inference techniques, like ancestral regeneration, for proposal values for most variables, and then iterate on this kernel by adding more data-driven proposals for variables for which the generic kernels are ineﬀective.
Revised: A useful development pattern is to begin with a kernel which uses generic inference techniques, like ancestral regeneration, for proposal values for most variables, and then iterate on this kernel by adding more data-driven proposals for variables for which the generic kernels are ineﬀective.

Original: To facilitate this, in the involution programming language presented in Section C, we add a command regenerate P ( o 1 , . . .
Revised: To facilitate this, in the involution programming language presented in Section C, we add a command regenerate P ( o 1 , . . .

Original: , o n ) to resample property P of ( o 1 , . .
Revised: , o n ) to resample property P of ( o 1 , . .

Original: , o n ) from the prior distribution
Revised: , o n ) from the prior distribution

Original: [Equation]
Revised: [Equation]

Original: where P a x ( u ) denotes the parents of variable u in the contingent Bayesian network for the open universe model the kernel operates on (with density p ), in world x .
Revised: where P a x ( u ) denotes the parents of variable u in the contingent Bayesian network for the open universe model the kernel operates on (with density p ), in world x .

Original: To support this command, we must modify our formulation of automated involutive
Revised: To support this command, we must modify our formulation of automated involutive

Original: MCMC.
Revised: MCMC.

Original: The reason for this is that in involutive MCMC, all randomness in an inference kernel must come from the proposal y ∼ q x ; f must be a deterministic function.
Revised: The reason for this is that in involutive MCMC, all randomness in an inference kernel must come from the proposal y ∼ q x ; f must be a deterministic function.

Original: Therefore, we must understand the execution of regenerate lines in the involution program as in fact being part of the q x proposal which produces auxiliary randomness y .
Revised: Therefore, we must understand the execution of regenerate lines in the involution program as in fact being part of the q x proposal which produces auxiliary randomness y .

Original: The ancestral sampling distribution.
Revised: The ancestral sampling distribution.

Original: Given a partial world P containing values for some of the variables over which a contingent Bayesian network is deﬁned, we deﬁne the ancestral sampling distribution r P over the space W of MSSIs, which completes P into a full MSSI w .
Revised: Given a partial world P containing values for some of the variables over which a contingent Bayesian network is deﬁned, we deﬁne the ancestral sampling distribution r P over the space W of MSSIs, which completes P into a full MSSI w .

Original: If w and P disagree on any variable v (so w [ v ] (cid:54) =
Revised: If w and P disagree on any variable v (so w [ v ] (cid:54) =

Original: P [ v ]), then r P ( w ) = 0, and if they agree on all variables,
Revised: P [ v ]), then r P ( w ) = 0, and if they agree on all variables,

Original: [Equation]
Revised: [Equation]

Original: An extended proposal and involution for ancestral regeneration.
Revised: An extended proposal and involution for ancestral regeneration.

Original: Say we have an involutive MCMC kernel deﬁned by a partial proposal distribution ˜ q x and an “involution” including regeneration commands ˜ f .
Revised: Say we have an involutive MCMC kernel deﬁned by a partial proposal distribution ˜ q x and an “involution” including regeneration commands ˜ f .

Original: To explain this as involutive MCMC, we now deﬁne a distribution q x using ˜ q x which includes the randomness from regeneration.
Revised: To explain this as involutive MCMC, we now deﬁne a distribution q x using ˜ q x which includes the randomness from regeneration.

Original: We will describe q x as producing tuples (˜ y, w ), where ˜ y ∼ ˜ q x , and w is sampled from the ancestral resampling distribution r .
Revised: We will describe q x as producing tuples (˜ y, w ), where ˜ y ∼ ˜ q x , and w is sampled from the ancestral resampling distribution r .

Original: Deﬁne the function ˜ f 1 by ˜ f
Revised: Deﬁne the function ˜ f 1 by ˜ f

Original: ( x, y ) =
Revised: ( x, y ) =

Original: ( ˜ f 1 ( x, y ) , · ).
Revised: ( ˜ f 1 ( x, y ) , · ).

Original: We require ˜ f to be such that ˜ f
Revised: We require ˜ f to be such that ˜ f

Original: ( x, y ) =
Revised: ( x, y ) =

Original: ˜ x (cid:48) , where ˜ x (cid:48) is a partial world.
Revised: ˜ x (cid:48) , where ˜ x (cid:48) is a partial world.

Original: (This comes from the user-written “involution” ˜
Revised: (This comes from the user-written “involution” ˜

Original: f applying changes to world x , based on y , to produce a partial world, in which other variables may then be ancestrally sampled to produce a complete world.)
Revised: f applying changes to world x , based on y , to produce a partial world, in which other variables may then be ancestrally sampled to produce a complete world.)

Original: We can then say w ∼ r ˜ f 1 ( x, ˜ y ) .
Revised: We can then say w ∼ r ˜ f 1 ( x, ˜ y ) .

Original: We deﬁne:
Revised: We deﬁne:

Original: [Equation]
Revised: [Equation]

Original: We now deﬁne an involution f ( x, (˜ y, w ))
Revised: We now deﬁne an involution f ( x, (˜ y, w ))

Original: =
Revised: =

Original: ( x (cid:48) , (˜ y (cid:48) , w (cid:48) )).
Revised: ( x (cid:48) , (˜ y (cid:48) , w (cid:48) )).

Original: For this, we require that ˜ f has the property
Revised: For this, we require that ˜ f has the property

Original: that if ˜ f
Revised: that if ˜ f

Original: ( x, y ) =
Revised: ( x, y ) =

Original: (˜ x (cid:48) , ˜ y (cid:48) ), for any ¯ x (cid:48) ∈ W which agrees with ˜ x (cid:48) , ˜ f
Revised: (˜ x (cid:48) , ˜ y (cid:48) ), for any ¯ x (cid:48) ∈ W which agrees with ˜ x (cid:48) , ˜ f

Original: (¯ x (cid:48) , ˜ y (cid:48) )
Revised: (¯ x (cid:48) , ˜ y (cid:48) )

Original: =
Revised: =

Original: (˜ x, ˜ y (cid:48) ) for some ˜ x agreeing with x .
Revised: (˜ x, ˜ y (cid:48) ) for some ˜ x agreeing with x .

Original: (This is an involution in the case where ˜ x, ˜ x (cid:48) ∈ W .)
Revised: (This is an involution in the case where ˜ x, ˜ x (cid:48) ∈ W .)

Original: Given ˜ f , we deﬁne f
Revised: Given ˜ f , we deﬁne f

Original: [Equation]
Revised: [Equation]

Original: where
Revised: where

Original: [Equation]
Revised: [Equation]

Original: The acceptance ratio.
Revised: The acceptance ratio.

Original: Using the above distribution, for ˜ f satisfying similar partitioning properties as we require for involutions f in Theorem 1, the acceptance probability α ( x, (˜ y, w ) , x (cid:48) , (˜ y (cid:48) , w (cid:48) )) is
Revised: Using the above distribution, for ˜ f satisfying similar partitioning properties as we require for involutions f in Theorem 1, the acceptance probability α ( x, (˜ y, w ) , x (cid:48) , (˜ y (cid:48) , w (cid:48) )) is

Original: [Equation]
Revised: [Equation]

Original: where | det ∂ ˜ f
Revised: where | det ∂ ˜ f

Original: ( x, ˜ y ) ∂ ( x, ˜ y ) | is the determinant of the Jacobian of the transformation of continuous values under ˜ f
Revised: ( x, ˜ y ) ∂ ( x, ˜ y ) | is the determinant of the Jacobian of the transformation of continuous values under ˜ f

Original: at ( x, ˜ y ).
Revised: at ( x, ˜ y ).

Original: E.1. Automating involutive MCMC with ancestral resampling.
Revised: E.1. Automating involutive MCMC with ancestral resampling.

Original: In section C, we introduced a language for specifying involutions on open-universe models.
Revised: In section C, we introduced a language for specifying involutions on open-universe models.

Original: An involution in the language takes as arguments the current world state x and auxiliary randomness ˜ y ∼ ˜ q x , and produces a sequence M of object manipulation moves, and a set
Revised: An involution in the language takes as arguments the current world state x and auxiliary randomness ˜ y ∼ ˜ q x , and produces a sequence M of object manipulation moves, and a set

Original: U of tuples ( v, u ), where v is a variable to update the trace for, and u speciﬁes the updated value.
Revised: U of tuples ( v, u ), where v is a variable to update the trace for, and u speciﬁes the updated value.

Original: It also produces the reversing randomness ˜
Revised: It also produces the reversing randomness ˜

Original: y (cid:48) and the Jacobian correction term J .
Revised: y (cid:48) and the Jacobian correction term J .

Original: A new state x (cid:48) is constructed by applying M to the current state x , then applying all the speciﬁed updates from U .
Revised: A new state x (cid:48) is constructed by applying M to the current state x , then applying all the speciﬁed updates from U .

Original: However, it is possible that the produced state x (cid:48)
Revised: However, it is possible that the produced state x (cid:48)

Original: is not a valid world model state, either because 1.
Revised: is not a valid world model state, either because 1.

Original: x (cid:48) is not minimal, in which case variables in x (cid:48) are automatically deleted by our system to ensure minimality; or 2.
Revised: x (cid:48) is not minimal, in which case variables in x (cid:48) are automatically deleted by our system to ensure minimality; or 2.

Original: x (cid:48) is not self-supporting, in which case additional variables needed for it to be self supporting are automatically generated from the prior by our system.
Revised: x (cid:48) is not self-supporting, in which case additional variables needed for it to be self supporting are automatically generated from the prior by our system.

Original: Automatic deletions impose no semantic diﬃculties; however, when adding variables automatically, the above formulation of involutive MCMC with ancestral regeneration is needed to correctly calculate acceptance ratios.
Revised: Automatic deletions impose no semantic diﬃculties; however, when adding variables automatically, the above formulation of involutive MCMC with ancestral regeneration is needed to correctly calculate acceptance ratios.

Original: Accumulating the state ratio.
Revised: Accumulating the state ratio.

Original: To implement an MCMC kernel, after sampling ˜ y ∼ ˜ q x and calculating ( M, U, ˜ y (cid:48) , J ), we construct state x (cid:48) using a function update( x, M, U ) (Algorithm 3).
Revised: To implement an MCMC kernel, after sampling ˜ y ∼ ˜ q x and calculating ( M, U, ˜ y (cid:48) , J ), we construct state x (cid:48) using a function update( x, M, U ) (Algorithm 3).

Original: To calculate the acceptance ratio, we can calculate ˜ q x (cid:48)
Revised: To calculate the acceptance ratio, we can calculate ˜ q x (cid:48)

Original: (˜ y ) and ˜ q x (˜ y (cid:48) )
Revised: (˜ y ) and ˜ q x (˜ y (cid:48) )

Original: directly, and we know J .
Revised: directly, and we know J .

Original: Thus, what remains is to calculate p ( x (cid:48) )
Revised: Thus, what remains is to calculate p ( x (cid:48) )

Original: p ( x ) × r ˜ f 1( x (cid:48) , ˜ y (cid:48) )
Revised: p ( x ) × r ˜ f 1( x (cid:48) , ˜ y (cid:48) )

Original: ( x ) r ˜ f 1( x, ˜ y )
Revised: ( x ) r ˜ f 1( x, ˜ y )

Original: ( x (cid:48) ) .
Revised: ( x (cid:48) ) .

Original: When no values are generated via ancestral resampling, this reduces to the term p ( x (cid:48) ) p ( x ) .
Revised: When no values are generated via ancestral resampling, this reduces to the term p ( x (cid:48) ) p ( x ) .

Original: Our implementation has the update procedure return this term as well, as it can be calculated by accumulating values while updating x to x (cid:48) .
Revised: Our implementation has the update procedure return this term as well, as it can be calculated by accumulating values while updating x to x (cid:48) .

Original: We accumulate p ( x (cid:48)
Revised: We accumulate p ( x (cid:48)

Original: [ v ] | x (cid:48)
Revised: [ v ] | x (cid:48)

Original: Pax (cid:48) ( v ) )
Revised: Pax (cid:48) ( v ) )

Original: p ( x [ v ] | x
Revised: p ( x [ v ] | x

Original: Pax ( v ) )
Revised: Pax ( v ) )

Original: every time the trace for variable v is updated from t v to t (cid:48) v , 1 p ( x [ v ] | x Pax ( v ) ) for every variable v which is deleted, and p ( x (cid:48)
Revised: every time the trace for variable v is updated from t v to t (cid:48) v , 1 p ( x [ v ] | x Pax ( v ) ) for every variable v which is deleted, and p ( x (cid:48)

Original: [ v ] | x (cid:48)
Revised: [ v ] | x (cid:48)

Original: Pa x (cid:48) ( v ) ) for every variable which is added.
Revised: Pa x (cid:48) ( v ) ) for every variable which is added.

Original: In the case where some values are produced via ancestral sampling rather than the external proposal, we must account for the r ˜ f 1( x (cid:48) , ˜ y (cid:48) )
Revised: In the case where some values are produced via ancestral sampling rather than the external proposal, we must account for the r ˜ f 1( x (cid:48) , ˜ y (cid:48) )

Original: ( x ) r ˜ f 1( x, ˜ y )
Revised: ( x ) r ˜ f 1( x, ˜ y )

Original: ( x (cid:48) ) term.
Revised: ( x (cid:48) ) term.

Original: By equation 8, the denominator of this is the product of terms p v ( x (cid:48)
Revised: By equation 8, the denominator of this is the product of terms p v ( x (cid:48)

Original: [ v ] | x (cid:48)
Revised: [ v ] | x (cid:48)

Original: Pa x (cid:48) ( v ) ) for variables v which are ancestral sampled in this move from x to x (cid:48) .
Revised: Pa x (cid:48) ( v ) ) for variables v which are ancestral sampled in this move from x to x (cid:48) .

Original: This is straightforward for the update procedure to accumulate as it generates each of these values.
Revised: This is straightforward for the update procedure to accumulate as it generates each of these values.

Original: The numerator of this fraction is the product of p v ( x [ v ] | x Pa x ( v ) ) terms for each variable v which is ancestralsampled in the reverse move.
Revised: The numerator of this fraction is the product of p v ( x [ v ] | x Pa x ( v ) ) terms for each variable v which is ancestralsampled in the reverse move.

Original: To properly account for this, then, the update procedure needs to know which properties will be ancestral-sampled in the reversing move.
Revised: To properly account for this, then, the update procedure needs to know which properties will be ancestral-sampled in the reversing move.

Original: We can thus deﬁne this procedure’s signature as ( x (cid:48) , r ˜ f
Revised: We can thus deﬁne this procedure’s signature as ( x (cid:48) , r ˜ f

Original: ( x (cid:48) , ˜ y (cid:48) )
Revised: ( x (cid:48) , ˜ y (cid:48) )

Original: ( x ) r ˜ f
Revised: ( x ) r ˜ f

Original: ( x, ˜ y )
Revised: ( x, ˜ y )

Original: ( x (cid:48) ) )
Revised: ( x (cid:48) ) )

Original: =
Revised: =

Original: update( x, M, U, R ) where R is the set of variables which will be regenerated in the reversing move.
Revised: update( x, M, U, R ) where R is the set of variables which will be regenerated in the reversing move.

Original: Involution language extension.
Revised: Involution language extension.

Original: To provide access to R , we extend the language from section C, adding the syntax backward[ P ( o 1 , . . .
Revised: To provide access to R , we extend the language from section C, adding the syntax backward[ P ( o 1 , . . .

Original: , o n ) ]
Revised: , o n ) ]

Original: = regenerated to specify that the reverse-direction proposal ancestral samples a value for P ( o 1 , . . .
Revised: = regenerated to specify that the reverse-direction proposal ancestral samples a value for P ( o 1 , . . .

Original: , o n ).
Revised: , o n ).

Original: One can also write backward[properties of
Revised: One can also write backward[properties of

Original: [Equation]
Revised: [Equation]

Original: regenerated to specify that all properties for any object tuple including o are regenerated by the reverse move.
Revised: regenerated to specify that all properties for any object tuple including o are regenerated by the reverse move.

Original: We also add a command regenerate P of o , to specify that the value for P ( o ) should be ancestral-sampled to produce x (cid:48) , rather than copying the value for this property currently in x .
Revised: We also add a command regenerate P of o , to specify that the value for P ( o ) should be ancestral-sampled to produce x (cid:48) , rather than copying the value for this property currently in x .

Original: (Copying from x is the default behavior when P ( o 1 , . . .
Revised: (Copying from x is the default behavior when P ( o 1 , . . .

Original: , o n ) is present in x ; ancestral sampling is the default behavior when it is not present in x .)
Revised: , o n ) is present in x ; ancestral sampling is the default behavior when it is not present in x .)

Original: One way to think about the need to specify the values ancestrally sampled in the reverse move is as follows.
Revised: One way to think about the need to specify the values ancestrally sampled in the reverse move is as follows.

Original: Although users do not specify a dictionary key for values in the full auxiliary randomness y which are generated by ancestral resampling, to ensure that the full f is a valid involution, f must still write the values of these variables to y (cid:48) in the reversing move.
Revised: Although users do not specify a dictionary key for values in the full auxiliary randomness y which are generated by ancestral resampling, to ensure that the full f is a valid involution, f must still write the values of these variables to y (cid:48) in the reversing move.

Original: Because users don’t specify a dictionary key, we provide a special syntax, set backward[ P ( o 1 , . . .
Revised: Because users don’t specify a dictionary key, we provide a special syntax, set backward[ P ( o 1 , . . .

Original: , o n ) ]
Revised: , o n ) ]

Original: = regenerated to automatically set the regenerated value in y (cid:48) of variable P ( o 1 , . . .
Revised: = regenerated to automatically set the regenerated value in y (cid:48) of variable P ( o 1 , . . .

Original: , o n ) to equal this variable’s current value in x .
Revised: , o n ) to equal this variable’s current value in x .

Original: While the need to specify when a reverse move uses ancestral sampling adds a small cognitive burden to the user of our inference programming language, we provide dynamic error checks to ensure it is not a source of incorrectness.
Revised: While the need to specify when a reverse move uses ancestral sampling adds a small cognitive burden to the user of our inference programming language, we provide dynamic error checks to ensure it is not a source of incorrectness.

Original: If users forget to include the proper backward[ . . . ]
Revised: If users forget to include the proper backward[ . . . ]

Original: = regenerated statements, we can dynamically detect this error by running the reverse move and seeing which values are actually regenerated.
Revised: = regenerated statements, we can dynamically detect this error by running the reverse move and seeing which values are actually regenerated.

Original: It is thus simple to report when users have forgotten to include these commands, making it a fairly painless debugging procedure to add the proper reverse-regenerate speciﬁcations.
Revised: It is thus simple to report when users have forgotten to include these commands, making it a fairly painless debugging procedure to add the proper reverse-regenerate speciﬁcations.