`Information Field Theory <http://www.mpa-garching.mpg.de/ift/>`_ [1]_ (IFT) is information theory, the logic of reasoning under uncertainty, applied to fields.

`Information Field Theory <http://www.mpa-garching.mpg.de/ift/>`_ [1]_ (IFT) is information theory, the logic of reasoning under uncertainty, applied to fields.

A field can be any quantity defined over some space, e.g. the air temperature over Europe, the magnetic field strength in the Milky Way, or the matter density in the Universe.

A field can be any quantity defined over some space, e.g. the air temperature over Europe, the magnetic field strength in the Milky Way, or the matter density in the Universe.

IFT describes how data and knowledge can be used to infer field properties.

IFT describes how data and knowledge can be used to infer field properties.

**NIFTy** [1]_, [2]_, "\ **N**\umerical **I**\nformation **F**\ield **T**\heor\ **y**\ ", is a versatile library designed to enable the development of signal inference algorithms that are independent of the underlying spatial grid and its resolution.

**NIFTy** [1]_, [2]_, "\ **N**\umerical **I**\nformation **F**\ield **T**\heor\ **y**\ ", is a versatile library designed to enable the development of signal inference algorithms that are independent of the underlying grids (spatial, spectral, temporal, …) and their resolutions.

Its object-oriented framework is written in Python, although it accesses libraries written in C++ and C for efficiency.

Its object-oriented framework is written in Python, although it accesses libraries written in C++ and C for efficiency.

NIFTy offers a toolkit that abstracts discretized representations of continuous spaces, fields in these spaces, and operators acting on fields into classes.

NIFTy offers a toolkit that abstracts discretized representations of continuous spaces, fields in these spaces, and operators acting on these fields into classes.

Thereby, the correct normalization of operations on fields is taken care of automatically without concerning the user.

This allows for an abstract formulation and programming of inference algorithms, including those derived within information field theory.

This allows for an abstract formulation and programming of inference algorithms, including those derived within information field theory.

Thus, NIFTy permits its user to rapidly prototype algorithms in 1D and then apply the developed code in higher-dimensional settings to real world problems.

NIFTy's interface is designed to resemble IFT formulae in the sense that the user implements algorithms in NIFTy independent of the topology of the underlying spaces and the discretization scheme.

Thus, the user can develop algorithms on subsets of problems and on spaces where the detailed performance of the algorithm can be properly evaluated and then easily generalize them to other, more complex spaces and the full problem, respectively.

The set of spaces on which NIFTy operates comprises point sets, *n*-dimensional regular grids, spherical spaces, their harmonic counterparts, and product spaces constructed as combinations of those.

The set of spaces on which NIFTy operates comprises point sets, *n*-dimensional regular grids, spherical spaces, their harmonic counterparts, and product spaces constructed as combinations of those.

NIFTy takes care of numerical subtleties like the normalization of operations on fields and the numerical representation of model components, allowing the user to focus on formulating the abstract inference procedures and process-specific model properties.

@@ -34,8 +34,8 @@ Discretisation and index notation

...

@@ -34,8 +34,8 @@ Discretisation and index notation

.................................

.................................

To compute anything numerically, we first need to represent the problem in finite dimensions.

To compute anything numerically, we first need to represent the problem in finite dimensions.

As for stochastic processes, several discretisations of :math:`\mathcal{S}` like collocation methods, expansion into orthogonal polynomials, etc. can be used (see [6]_, [7]_ for an overview and further information about their reliability).

As for stochastic processes, several discretisations of :math:`\mathcal{S}` like collocation methods, expansion into orthogonal polynomials, etc. can be used (see [1]_, [2]_ for an overview and further information about their reliability).

In particular, NIFTy uses the midpoint method as reviewed in section 2.1 in [6]_ and Fourier expansion.

In particular, NIFTy uses the midpoint method as reviewed in section 2.1 of [1]_ and Fourier expansion.

Without going into the details, discretisation methods basically introduce a finite set of basis functions :math:`\{\phi_i\}_{i\in \mathcal{I}}`, where :math:`\mathcal{I}` denotes a generic index set with :math:`|\mathcal{I}| = N` being the chosen discretisation dimension.

Without going into the details, discretisation methods basically introduce a finite set of basis functions :math:`\{\phi_i\}_{i\in \mathcal{I}}`, where :math:`\mathcal{I}` denotes a generic index set with :math:`|\mathcal{I}| = N` being the chosen discretisation dimension.

Any Riemannian manifold :math:`(\mathcal{M},g)` is equipped with a canonical scalar product given by

Any Riemannian manifold :math:`(\mathcal{M},g)` is equipped with a canonical scalar product given by

...

@@ -70,7 +70,7 @@ After projection, any function :math:`f \in \mathcal{S}` is represented by its a

...

@@ -70,7 +70,7 @@ After projection, any function :math:`f \in \mathcal{S}` is represented by its a

which defines an embedding :math:`\hat{\mathcal{S}} \hookrightarrow \mathcal{S} = \mathcal{F}(\mathcal{M})`.

which defines an embedding :math:`\hat{\mathcal{S}} \hookrightarrow \mathcal{S} = \mathcal{F}(\mathcal{M})`.

**Changes of bases** are performed by reapproximating the :math:`\{\phi_i\}_{i\in \mathcal{I}}` in terms of another basis :math:`\{\phi'_i\}_{i\in \mathcal{I'}}`:

**Changes of base** are performed by reapproximating the :math:`\{\phi_i\}_{i\in \mathcal{I}}` in terms of another basis :math:`\{\phi'_i\}_{i\in \mathcal{I'}}`:

.. math::

.. math::

...

@@ -81,7 +81,7 @@ The latter is e.g. true for regular collocation grids on tori and the associated

...

@@ -81,7 +81,7 @@ The latter is e.g. true for regular collocation grids on tori and the associated

The discrete Fourier transform then maps between those bases without loss of information.

The discrete Fourier transform then maps between those bases without loss of information.

**Discretisation of operators** works in the same way by expansion.

**Discretisation of operators** works in the same way by expansion.

For illustration purposes, let :math:`A: \mathcal{S} \rightarrow \mathcal{S}` be a not necessarily linear operator.

For illustration purposes, let :math:`A: \mathcal{S} \rightarrow \mathcal{S}` be a (not necessarily linear) operator.

The result of its action on functions :math:`s` is known and may be expanded in :math:`\{\phi_i\}_{i\in \mathcal{I}}`, i.e.

The result of its action on functions :math:`s` is known and may be expanded in :math:`\{\phi_i\}_{i\in \mathcal{I}}`, i.e.

.. math::

.. math::

...

@@ -94,14 +94,14 @@ Integrals can now be written as

...

@@ -94,14 +94,14 @@ Integrals can now be written as

.. [6] Bruno Sudret and Armen Der Kiureghian (2000), "Stochastic Finite Element Methods and Reliability: A State-of-the-Art Report"

.. [1] Bruno Sudret and Armen Der Kiureghian (2000), "Stochastic Finite Element Methods and Reliability: A State-of-the-Art Report"

.. [7] Dongbin Xiu (2010), "Numerical methods for stochastic computations", Princeton University Press.

.. [2] Dongbin Xiu (2010), "Numerical methods for stochastic computations", Princeton University Press.

Resolution and self-consistency

Resolution and self-consistency

...............................

...............................

...

@@ -129,40 +129,40 @@ Apparently, the discretisation and the discretised response need to satisfy a se

...

@@ -129,40 +129,40 @@ Apparently, the discretisation and the discretised response need to satisfy a se

.. math::

.. math::

R = \hat{R} \circ D \, .

R = \hat{R} \circ D \, .

An obvious corrollary is that different discretisations :math:`D, D'` with resulting discretised responses :math:`\hat{R}, \hat{R}'` will need to satisfy

An obvious corollary is that different discretisations :math:`D, D'` with resulting discretised responses :math:`\hat{R}, \hat{R}'` will need to satisfy

.. math::

.. math::

\hat{R} \circ D = \hat{R}' \circ D' \, .

\hat{R} \circ D = \hat{R}' \circ D' \, .

NIFTy is implemented such that in order to change resolution, only the line of code defining the space needs to be altered.

NIFTy is implemented such that in order to change resolution, only the line of code defining the space needs to be altered.

It automatically takes care of depended structures like volume factors, discretised operators and responses.

It automatically takes care of dependent structures like volume factors, discretised operators and responses.

A visualisation of this can be seen in figure 2 and 3, which displays the MAP inference of a signal at various resolutions.

A visualisation of this can be seen in figure 2, which displays the MAP inference of a signal at various resolutions.

.. figure:: images/converging_discretization.png

.. figure:: images/converging_discretization.png

:scale: 80%

:scale: 80%

:align: center

:align: center

Figure 3: Inference result converging at high resolution.

Figure 2: Inference result converging at high resolution.

Implementation in NIFTy

Implementation in NIFTy

-----------------------

.......................

.. currentmodule:: nifty5

.. currentmodule:: nifty5

Most codes in NIFTy will contain the description of a measurement process,

Most codes in NIFTy will contain the description of a measurement process or,

or more generally, a log-likelihood.

more generally, a log-likelihood.

This log-likelihood is necessarily a map from the quantity of interest (a field) to a real number.

This log-likelihood is necessarily a map from the quantity of interest (a field) to a real number.

The likelihood has to be unitless because it is a log-probability and should not scale with resolution.

The log-likelihood has to be unitless because it is a log-probability and should not scale with resolution.

Often, likelihoods contain integrals over the quantity of interest :math:`s`, which have to be discretized, e.g. by a sum

Often, log-likelihoods contain integrals over the quantity of interest :math:`s`, which have to be discretized, e.g. by a sum

Here the domain of the integral :math:`\Omega = \dot{\bigcup_q} \; \Omega_i` is the disjoint union over smaller :math:`\Omega_i`, e.g. the pixels of the space, and :math:`s_i` is the discretized field value on the :math:`i`-th pixel.

Here the domain of the integral :math:`\Omega = \dot{\bigcup_q} \; \Omega_i` is the disjoint union over smaller :math:`\Omega_i`, e.g. the pixels of the space, and :math:`s_i` is the discretized field value on the :math:`i`-th pixel.

This introduces the weighting :math:`V_i=\int_{\Omega_i}\text{d}x\, 1`, also called the volume factor, a property of the space.

This introduces the weighting :math:`V_i=\int_{\Omega_i}\text{d}x\, 1`, also called the volume factor, a property of the space.

NIFTy aids you in constructing your own likelihood by providing methods like :func:`~field.Field.weight`, which weights all pixels of a field with its corresponding volume.

NIFTy aids you in constructing your own log-likelihood by providing methods like :func:`~field.Field.weight`, which weights all pixels of a field with their corresponding volume.

An integral over a :class:`~field.Field` :code:`s` can be performed by calling :code:`s.weight(1).sum()`, which is equivalent to :code:`s.integrate()`.

An integral over a :class:`~field.Field` :code:`s` can be performed by calling :code:`s.weight(1).sum()`, which is equivalent to :code:`s.integrate()`.

Volume factors are also applied automatically in the following places:

Volume factors are also applied automatically in the following places:

...

@@ -170,32 +170,38 @@ Volume factors are also applied automatically in the following places:

...

@@ -170,32 +170,38 @@ Volume factors are also applied automatically in the following places:

- some response operators, such as the :class:`~library.los_response.LOSResponse`. In this operator a line integral is descritized, so a 1-dimensional volume factor is applied.

- some response operators, such as the :class:`~library.los_response.LOSResponse`. In this operator a line integral is descritized, so a 1-dimensional volume factor is applied.

- In :class:`~library.correlated_fields.CorrelatedField` as well :class:`~library.correlated_fields.MfCorrelatedField`, the field is multiplied by the square root of the total volume in configuration space. This ensures that the same field reconstructed over a larger domain has the same variance in position space in the limit of infinite resolution. It also ensures that power spectra in NIFTy behave according to the definition of a power spectrum, namely the power of a k-mode is the expectation of the k-mode square, divided by the volume of the space.

- In :class:`~library.correlated_fields.CorrelatedField` as well :class:`~library.correlated_fields.MfCorrelatedField`, the field is multiplied by the square root of the total volume in configuration space. This ensures that the same field reconstructed over a larger domain has the same variance in position space in the limit of infinite resolution. It also ensures that power spectra in NIFTy behave according to the definition of a power spectrum, namely the power of a k-mode is the expectation of the k-mode square, divided by the volume of the space.

Note that in contrast to some older versions of NIFTy, the dot product of fields does not apply a volume factor

Note that in contrast to some older versions of NIFTy, the dot product :code:`s.vdot(t)` of fields does **not** apply a volume factor, but instead just sums over the field components,

.. math::

.. math::

s^\dagger t = \sum_i s_i^* t_i .

s^\dagger t = \sum_i \overline{s^i}\, t^i \, ,

If this dot product is supposed to be invariant under changes in resolution, then either :math:`s_i` or :math:`t_i` has to decrease as the number of pixels increases, or more specifically, one of the two fields has to be an extensive quantity while the other has to be intensive.

where the bar denotes complex conjugation.

One can make this more explicit by denoting intensive quantities with upper index and extensive quantities with lower index

This dot product is **not** invariant under changes in resolution, as then the number of discretised field components increases.

Upper index components like :math:`s^i`, however, are designed **not** to scale with the volume.

One solution to obtain a resolution independent quantity is to make one of the two factors extensive while the other stays intensive.

This is more explicit when intensive quantities are denoted by an upper index and extensive quantities by a lower index,

.. math::

.. math::

s^\dagger t = (s^*)^i t_i

s^\dagger t = \overline{s^i} t_i

where we used Einstein sum convention.

where we used Einstein sum convention.

This notation connects to the theoretical discussion before.

Here, the volume metric is incorporated by lowering one index, i.e. :math:`t_i = v_{ij}\,t^j`.

One of the field has to have the volume metric already incorperated to assure the continouum limit works.

When building statistical models, all indices will end up matching this upper-lower convention automatically, e.g. for a Gaussian log-likelihood :math:`L` we have

When building statistical models, all indices will end up matching this upper-lower convention automatically, e.g. for a Gaussian log-likelihood :math:`L` we have

.. math::

.. math::

L = \frac{1}{2}s^i \left(S^{-1}\right)_{ij} s^j

L = \frac{1}{2}\overline{s^i} \left(S^{-1}\right)_{ij} s^j