# Protecting gender and identity with disentangled speech representations

###### Abstract

Besides its linguistic content, our speech is rich in biometric information
that can be inferred by classifiers. Learning privacy-preserving
representations for speech signals enables downstream tasks without sharing
unnecessary, private information about an individual. In this paper, we show
that protecting gender information in speech is more effective than modelling
speaker-identity information only when generating a non-sensitive
representation of speech. Our method relies on reconstructing speech by
decoding linguistic content along with gender information using a variational
autoencoder. Specifically, we exploit disentangled representation learning to
encode information about different attributes into separate subspaces that can
be factorised independently. We present a novel way to encode gender
information and disentangle two sensitive biometric identifiers, namely gender
and identity, in a privacy-protecting setting. Experiments on the LibriSpeech
dataset show that gender recognition and speaker verification can be reduced
to a random guess, protecting against classification-based attacks.

Index Terms: privacy, soft biometrics, disentangled representation learning,
variational autoencoder

##  1 Introduction

The human voice provides a uniquely identifiable pattern for each individual,
known as the voiceprint, a set of spectral characteristics that can be
inferred and may be used for user profiling [1, 2]. Privacy-enhancing
technologies aim to reduce the ability of an attacker to infer personal
attributes when performing classification tasks, such as speech transcription
[3, 4].

Approaches to protect voice privacy include voice transformation, voice
conversion and synthesis, and representation learning. Voice transformation
[5, 6] modifies the non-linguistic information of speech to de-identitfy the
speaker by applying basic transformations on features such as the pitch, time-
scale components and energy modifications. Approaches that convert voices to
synthesised identities [7] or produce new voices with generative networks [8]
learn to obfuscate sensitive attributes by synthesising new acoustic features
mapped onto the linguistic content of speech. Representation learning encodes
each factor of variation in the data into separate compressed representations
of latent subspaces [9]. These compact representations enable individual
component manipulation for speech reconstruction with a certain level of
privacy [3, 4, 10]. Furthermore, adversarial representation learning can be
used to hide the identity of a speaker [10].

In this paper, we propose a new way to encode gender by creating an embedding
space that independently captures gender information, and show that
considering gender information improves the privacy-utility trade-off compared
to existing representations. We consider attacks targeted at extracting
identity and gender, when speech recognition is the downstream task. Within
this scenario, we hypothesise gender to be the primary component in the
auditory identity of a speaker and that neutralising gender also affects the
ability to recognise the identity.

To this end, we define a generative model that allows us to independently
modify individual attributes in a lower dimensional space. To mitigate
undesired attribute inferences, we model gender information in two settings:
(i) by using gender information alone and (ii) by including both gender and
speaker-identity information. Specifically, we investigate the extent to which
concealing information related to a soft biometric identifier such as gender
helps concealing identity information. To the best of our knowledge no prior
work focused on disentangling identity and gender from content in order to use
gender information as a proxy for guiding privacy-preserving voice
representation learning. We show that our method is more effective in
protecting the identity and gender of a speaker from inference than existing
approaches on disentangled representation learning that use only identity
information to perform the anonymisation.

##  2 Related Work

Speech data anonymisation methods include voice transformation [6], voice
conversion and speech synthesis [7, 8, 11], and representation learning.
Representation learning can in turn be classified as adversarial [10],
disentangled [3, 4, 12] or hybrid [13].

Voice transformation aims at modifying the non-linguistic components of an
utterance, leaving the textual content unaffected. Voice transformation
involves extracting learned features, such as x-vectors [11, 14], or hand-
crafted features, such as fundamental frequency (F0), Mel-Frequency Cepstral
Coefficient (MFCC) and energy. The transformation typically refers to
modifying instantaneous characteristics of the source signal such as the
pitch, spectral envelope, time-scale and energy [5]. An audio sanitiser may
transform voice characteristics by using frequency warping [6].

Voice conversion and speech synthesis map the input voice of a source speaker
into that of a target speaker [7, 15]. These methods take advantage of the
underlying statistical characteristics of sounds to discriminate between
different aspects of audio signals and disentangle the textural style from the
semantic content [16].

Representation learning facilitates the task of extracting useful features
from the data, usually with autoencoding architectures that compress the data
to a smaller dimensionality [10, 13]. Disentangled representations are meant
to capture the different independent factors of variation in the data [3, 4,
12].

A few works consider gender as an attribute to protect. PCMelGAN [8] uses an
adversarial approach by generating speech with generative adversarial networks
(GANs) [17]. GANs, Variational Autoencoders (VAEs) and their combination can
be used to protect gender information through voice conversion with a
disentanglement approach [12]. Noe et al. [13] disentangle gender information
from x-vectors with adversarial learning. Low, moderate and high privacy
levels may be defined using a disentangled representation [3], where the
moderate level aims to reduce the success rate of inferring sensitive
attributes (emotion and gender) while maintaining high accuracy in inferring
speaker identity and linguistic content.

Beyond privacy, VAEs have been used to capture independent factors of speech
at different timescales in an unsupervised way [18]. Such a disentangled
representation is divided into discrete and independent subspaces, such that
each subspace corresponds to only one factor of variation in the data, without
affecting, or being affected by the transformation of the other subspaces [9].

The Factorised Hierarchical VAE (FHVAE) [19] uses multi-scale approach to
manipulate different sets of latent variables by factorisation and
discriminates between sequence-level (speaker identity) and segment-level
(content) attributes through a hierarchical process. An auxiliary lower bound
designed to disentangle global from local information at different time-scales
is introduced in AuxVAE [20], showing that the latent space can capture
individual speaker information. Similarly, VQ-VAE [21] produces an encoded
representation of speaker-specific information using vector quantisation.

##  3 Method

###  3.1 Privacy scenario

We consider the identity and the gender of a speaker as the private attributes
to protect, and speech recognition as the target task. We view speaker
identity in the context of a speaker verification task, which consists in
determining whether an utterance corresponds to the utterance of an enrolled
speaker.

We assume that the attacker has anonymised speech samples with labels and
attempts to infer the gender and identity of the speaker by classification and
verification, respectively. We consider an _ignorant_ attacker with no
knowledge of the target identity used for conversion or of the architectural
design of the Encoder-Decoder network [4].

We quantify privacy as the degree of randomness in classifying the gender
and/or verifying the identity of the speaker. We measure utility by the speech
recognition accuracy.

###  3.2 Disentanglement approach

We hypothesise that the linguistic and biometric information that is entangled
in speech signals can be decomposed into three subspaces, namely content (the
non-sensitive subspace), identity and gender (the sensitive subspaces). Thus
we aim to learn disentangled representations of content, identity and gender,
such that gender and identity attributes cannot be inferred given a set of
reconstructed speech utterances of a speaker.

We use an encoder network consisting of a one-dimensional convolutional layer
followed by 5 blocks of linear layers along with Vector Quantisation (VQ) to
obtain a quantised latent space encoding linguistic content [21]. We adapt the
disentangled representations method between content and speaker identity [3]
to disentangle the gender component.

We use Vector Quantised VAE (VQ-VAE) [21] to extract the linguistic content by
producing a discrete latent space through vector quantisation. Using quantised
instead of continuous latent vectors can facilitate the disentanglement of
non-sensitive and sensitive speech components that can be represented with
discrete sequences.

Vector quantisation in the latent space acts as a reparameterisation trick
that discretises the encoder output into fixed size vectors. The encoder
network parameterises a posterior distribution $q(z|x)$, where $x$ is the
input speech signal and $z\tt\sim Z$ the vector of latent variables sampled
from space $\tt Z$ according to a uniform prior distribution $p(z)$. In order
to disentangle variables associated with content, identity and gender, we
consider the latent variables $z$ representing the non-sensitive information
(content) and the vector of latent variables $b\tt\sim B$ representing
sensitive information to be protected with $b_{j}\in b$ and $j\in\\{1,2\\}$
representing gender and identity. Then $z$ and $b$ are said to be disentangled
if they can be factorised as [22]:

$q(z,b)=q(z)\prod_{j}q(b_{j}),$ (1)

where $q(.)$ represents the posterior of each vector of variables and $q(.,.)$
represents their aggregate posterior.

Disentangled representations help limit the amount of shared information
between separate latents and thus encourage predictions to depend only on
relevant (non-sensitive) latent dimensions [23]. Thus, we create an embedding
space that uniquely defines gender and use it to reconstruct speech, either
alone or along with identity. By independently encoding sensitive and non-
sensitive information and combining each of them by concatenation in the
decoding stage, we manage to produce disentangled representations of speech.

Figure 1: Our architecture to encode content and reconstruct speech with the
desired speaker identity and/or gender. The latent space $z$ is
reparameterised to encode content information. The output of the encoder
$z_{e}$ is first discretised into $z_{d}$ as a one-hot vector of indices by
nearest neighbour and then mapped onto each embedding vector $e_{i}$ by
nearest neighbour look-up to give the quantised latent content vector $z_{q}$
fed as input to the decoder for reconstruction. The decoder (vocoder)
generates speech by mapping the speaker identity and gender onto the content
or by selectively mapping each attribute separately. The identity and gender
embeddings are concatenated with the quantised content information through two
gated recurrent units (GRU).

The vector quantisation step involves learning a latent embedding space (or
codebook) $e\in\mathcal{R}^{K\times D}$, where $K$ is the number of embedding
vectors (or codewords) and $D$ is the length of each vector. The vector of
latent variables $z_{e}$ taken as output from the encoder is discretised into
$z_{d}$ by nearest neighbour look-up to the closest codeword $e_{i}$, where
$i\in 1,2,..,K$ (see Fig. 1). This models the posterior distribution $q(z|x)$
as a one-hot vector of indices, where the closest entries are assigned an
index $k$ corresponding to the codeword $e_{k}$, and 0 at all other positions,
essentially applying a discretisation bottleneck.

We obtain the input to the decoder, $z_{q}$, by mapping the nearest
corresponding embedding vector $e_{K}$ onto the one-hot vector. In this way,
the content is encoded onto a discrete latent space, defined by a codebook
consisting of $K$ codewords. To reconstruct audio waveforms from the acoustic
features, instead of using a traditional vocoder such as Griffin-Lim [24], we
use – for its improved quality of the generated speech – a modified version of
WaveRNN [25], where two gated recurrent units (GRU) are used to capture
content information [26]. The logits that go through the softmax layer to
predict an 8-bit $\mu$-law sample are taken as output of two linear layers
following the autoregressive GRU cells.

To condition the decoder to reconstruct the speech signal with gender
characteristics, we use a single stacked bi-directional GRU that takes as
input the concatenation of the discrete latent vector output $z_{q}$ along
with the gender embeddings. We modify the dimensionality of the embedding
space used to model speaker information [26] and adapt it to encode gender
information. While, speaker information is encoded by 64-dimensional vectors
corresponding to each speaker in the set, only two of these vectors are needed
in a binary gender encoding, reducing the dimensionality needed. To combine
speaker identity and gender information, we add a bi-directional GRU layer to
model speaker information. The input to this recurrent layer is taken as the
output of the first conditional GRU, concatenated with the speaker embeddings.
We increase the input channels by four times to account for the dimensionality
produced by the concatenation of content and gender passed through a bi-
directional GRU.

The architecture defined above allows us to consider five settings: Same
Identity (SI); Random Identity (RI); Random Gender (RG); Same Identity, Random
gender (SIRG); and Random Identity, Same Gender (RISG). With SI, speech is
reconstructed maintaining the identity of the source speaker. The goal is to
reduce gender inference while preserving speaker identity. With RI, speech is
reconstructed using the encoded identity of another speaker in the set, chosen
at random. With RG, speech is generated by mapping a gender at random onto the
chosen utterance. With SIRG, speech is generated using the same identity as
the source speaker while varying the mapped gender at random for each
utterance. Thus, the utterances of a speaker will be mapped first onto the
same identity and then onto a randomly chosen gender. Finally, with RISG,
speech is generated by mapping a randomly chosen identity in the set, followed
by mapping to the same gender as the source speaker.

Note that the last three settings consider gender information and are specific
to our scenario, whereas existing works consider only identity information. In
the next section, we evaluate these five settings and their impact on privacy
and utility.

##  4 Validation

###  4.1 Experimental setup

We compare the proposed approach with methods that use disentangled
representations in a privacy setting and consider speaker identity and/or
gender as sensitive attributes. The methods we consider are EDGY [3],
Disentangl.-based VC [4], and the VAE model used by Wu et al. [12], which we
will refer to as Client-VAE, that uses identity information during training.
We use the publicly available code for EDGY [3], and the results reported in
the corresponding papers for Disentangl.-based VC [4] and Client-VAE [12].

We conduct three sets of experiments, one that uses only gender information,
and two that include gender and identity information. To facilitate the
comparison, we choose methods whose results were presented on the same
dataset, LibriSpeech [27], which consists of read speech from audiobooks. We
use the 100-hour training set consisting of clean speech and 251 speakers as
it has balanced gender distribution.

###  4.2 Performance measures

We measure utility as word error rate (WER), which counts the number of
insertions, deletions and substitutions between reference and predicted
transcript, over the total number of words in the reference transcript.

We measure the effectiveness of gender inference as the standard binary
classification accuracy, which is the sum of true positives and true negatives
over the total number of predictions.

Finally, for speaker verification we consider as rate of failure of an
attacker the equal error rate (EER). For biometrics verification (which
favours a false rejection over false acceptance) the lower the EER, the higher
the accuracy of the speaker verification task. Instead, for a privacy
scenario, an EER approaching 50% is desired as it represents randomness in
verifying the speaker identity [4, 14].

###  4.3 Models

For speech recognition, we use DeepSpeech2 [28], which consists of 11 layers
of alternating convolutional and recurent layers. The model uses the
Connectionist Temporal Classification (CTC) loss [29] to predict the most
likely transcription and reported a word error rate (WER) of 6.75% using a
3-gram language model on the LibriSpeech clean test set.

For gender classification, we design a deep convolutional network with 5
stacked one-dimensional convolutional layers followed by batch normalisation
and max polling with ReLU non-linear activation. The output layer consists of
a fully connected layer that outputs a pair of predictions for each binary
class, passing through a sigmoid function. We pre-trained the gender
classifier network on the LibriSpeech train set for 50000 iterations with a
learning rate of 0.0001 and the Adam optimiser, updating the weights using the
cross-entropy loss function. We tested the gender classifier on the
LibriSpeech clean test set and reported an accuracy of 91.37%.

For speaker verification, we extract speaker-identifying features with Thin
ResNet-34 [30], a smaller version of the original ResNet-34. The model was
pre-trained on the VoxCeleb2 [31] dataset using the angular prototypical loss
[30] and reported an EER of 5.73% in our experiments when tested on the
LibriSpeech clean test set. We use a pre-trained encoder with Contrastive
Predictive Coding (CPC) [26] with a codebook size of $K=512$ and $D=64$ on the
ZeroSpeech 2019 [32] dataset.

###  4.4 Discussion

Table 1 compares the recognition accuracy results for the methods under
analysis with the settings defined in Sec. 3.2. Furthermore, to visually
compare error rates for utility and privacy and to facilitate the
identification of the appropriate trade-off, Fig. 2 shows a bar plot with the
data of Table 1, but considering the Gender Error Rate, computed as $100-Acc$
where $Acc$ is the classification accuracy.

The SI setting provides an intermediate privacy protection as it is aimed at
maintaining the speaker identity and ignores gender information (note that
this setting corresponds to the _moderate_ privacy setting in EDGY). This
setting shows that mapping onto the same identity induces distortion in the
recognised identity, but remains quite low at 12.7% EER, while the gender
attribute can be inferred with high accuracy (70.78%).

The goal of RI is to protect from inference attacks both identity and gender
attributes in EDGY, while only identity is considered in Disentangl.-based VC
and Client-VAE. In the case of Disentangl.-based VC we consider the ignorant
scenario, where the attacker has no knowledge of the type of conversion being
applied. In RI, the speaker identity is better protected with
Disentangl.-based VC than with other methods, at the cost of a higher utility
degradation. In this setting, gender protection is also achieved in EDGY when
converting to a random target identity, with a minimal discrepancy from a
random guess (1.36 percentage points). A higher utility is achieved by Client-
VAE, which however fails to protect from gender inference (classification
accuracy of 77.8%).

The settings that are specific to our methods (also) consider gender
information. In SIRG, adding random gender information with respect to SI
affects both speaker and gender recognition rates, which are closer to random
guesses. Thus gender information is confirmed to play an important role for
the auditory identity of an individual. However, this setting is not as
effective as using a random speaker identity, as shown for RI and RISG.
Although gender recognition remains the same in RI and RISG, speaker
verification accuracy is reduced when adding gender information. SIRG and RISG
show that the encoded identity information is dominant over gender, due to
increased dimensionality of the embeddings, as seen by the low EER in SIRG.

Finally, RG offers better privacy protection both in terms of speaker
verification and gender classification, compared with methods encoding
identity information only. With RG, both gender binary accuracy and EER are
very close to the value of the ideal random guess. Furthermore, our settings
RISG and RG provide the best trade-off when both utility and privacy
objectives are considered. Also, the settings using speaker identity (SI and
SIRG) help quantify the extent to which gender information is present when
encoding identity information. However, this does not hold true when encoding
gender information alone, suggesting that gender can be disentangled from
identity. Thus, using gender information is preferable when defending against
inference attacks aiming at inferring the identity and the gender of a
speaker.

Table 1: Comparison of utility and privacy levels obtained by different disentangled representations. Key – WER: Word Error Rate (%); Acc: binary classification accuracy (%); EER: equal error rate (%); SI: Same Identity; RI: Random Identity; RG: Random Gender; SIRG: Same Identity, Random Gender; RISG: Random Identity, Same Gender. Note that: smaller values denote higher utility for WER and lower privacy for EER; larger values denote lower privacy for gender accuracy; and a value of WER $>$ 100 denotes insertion of new words in the predicted transcription.  Ref. | Settings | Utility | Privacy
---|---|---|---
|  | WER | Acc | EER
EDGY [3] | SI | 70.78 | 76.27 | 12.70
EDGY [3] | RI | 66.17 | 51.36 | 42.85
Disentangl.VC [4] | RI | 115.10 | – | 49.85
Client-VAE [12] | RI | 24.38 | 77.80 | –
| SIRG | 64.99 | 59.89 | 36.63
ours | RISG | 65.92 | 51.15 | 52.00
| RG | 73.16 | 50.01 | 51.88
Figure 2: Visualisation of the utility and privacy levels obtained by
different disentangled representations. Key – SI: Same Identity; RI: Random
Identity; RG: Random Gender; SIRG: Same Identity, Random Gender; RISG: Random
Identity, Same Gender; WER: word error rate, GER: gender error rate; EER:
equal error rate. Note that: GER is computed as complementary of the
classification accuracy, i.e. ($100-Acc$); and GER and EER values close to 50%
(shown by the horizontal line) denote better privacy.

##  5 Conclusions

In this paper we showed that learning disentangled representations of speech
for content, gender and identity enables the protection of user privacy from
attribute inference attacks. We also showed that, in order to protect the
identity of a speaker, it is preferable to map the content onto a randomly
chosen gender rather than a randomly chosen identity. By encoding gender
information, we can better protect speaker information from inference using a
state-of-the-art speaker verification model. Specifically, mapping gender
information onto the encoded content provides better privacy than using
speaker information alone when reconstructing speech signals, thus improving
upon the current state-of-the-art models for disentangled representations.

As VQ-VAEs are effective in disentangling latent spaces but lack in
reconstruction capabilities compared to continuous VAEs, future work includes
investigating representations that improve control over the degradation of the
WER. Furthermore, we will extend the current model and test its robustness
when the knowledge of the attacker increases to cover the type of conversion
used to protect the privacy of the speaker.

Acknowledgements We thank the Alan Turing Institute (EP/N510129/1), which is
funded by the U.K. Engineering and Physical Sciences Research Council, for its
support through the project PRIMULA.

## References

  * [1] D. Toney, D. Feinberg, and K. Richmond, “Acoustic Features for Profiling Mobile Users of Conversational Interfaces,” in _International Conference on Mobile Human-Computer Interaction_. Springer, 2004, pp. 394–398.
  * [2] R. Singh, _Profiling Humans from their Voice_. Springer, Jan. 2019.
  * [3] R. Aloufi, H. Haddadi, and D. Boyle, “Privacy-preserving Voice Analysis via Disentangled Representations,” _Proceedings of the 2020 ACM SIGSAC Conference on Cloud Computing Security Workshop_ , Nov. 2020.
  * [4] B. M. Lal Srivastava, N. Vauquier, M. Sahidullah, A. Bellet, M. Tommasi, and E. Vincent, “Evaluating Voice Conversion-Based Privacy Protection against Informed Attackers,” in _IEEE International Conference on Acoustics, Speech and Signal Processing_ , 2020, pp. 2802–2806.
  * [5] Q. Jin, A. R. Toth, T. Schultz, and A. W. Black, “Voice convergin: Speaker de-identification by voice transformation,” in _IEEE International Conference on Acoustics, Speech and Signal Processing_ , 2009, pp. 3909–3912.
  * [6] J. Qian, H. Du, J. Hou, L. Chen, T. Jung, and X.-Y. Li, “Hidebehind: Enjoy Voice Input with Voiceprint Unclonability and Anonymity,” in _Proceedings of the 16th ACM Conference on Embedded Networked Sensor Systems_ , 2018, pp. 82–94.
  * [7] C.-Y. Huang, Y. Y. Lin, H.-Y. Lee, and L.-S. Lee, “Defending Your Voice: Adversarial Attack on Voice Conversion,” in _IEEE Spoken Language Technology Workshop_ , 2021, pp. 552–559.
  * [8] D. Ericsson, A. Östberg, E. L. Zec, J. Martinsson, and O. Mogren, “Adversarial Representation Learning for Private Speech Generation,” _arXiv preprint arXiv:2006.09114_ , Jun. 2020.
  * [9] Y. Bengio, A. Courville, and P. Vincent, “Representation Learning: A Review and New Perspectives,” _IEEE Transactions on Pattern Analysis and Machine Intelligence_ , vol. 35, pp. 1798–1828, 08 2013.
  * [10] B. M. L. Srivastava, A. Bellet, M. Tommasi, and E. Vincent, “Privacy-Preserving Adversarial Representation Learning in ASR: Reality or Illusion?” in _Proceedings INTERSPEECH 2019-20th Annual Conference of the International Speech Communication Association_ , Sep. 2019, pp. 3700–3704.
  * [11] B. M. L. Srivastava, N. Tomashenko, X. Wang, E. Vincent, J. Yamagishi, M. Maouche, A. Bellet, and M. Tommasi, “Design Choices for x-vector Based Speaker Anonymization,” in _Proceedings INTERSPEECH 2020-21st Annual Conference of the International Speech Communication Association_ , 2020.
  * [12] P. Wu, P. Liang, R. Salakhutdinov, and L.-P. Morency, “Understanding the Tradeoffs in Client-Side Privacy for Speech Recognition,” _arXiv preprint arXiv:2101.08919_ , Jan. 2021.
  * [13] P.-G. Noé, M. Mohammadamini, M. Driss, T. Parcollet, and J.-F. Bonastre, “Adversarial Disentanglement of Speaker Representation for Attribute-Driven Privacy Preservation,” _arXiv preprint arXiv:2012.04454_ , Aug. 2020.
  * [14] N. Tomashenko, B. M. L. Srivastava, X. Wang, E. Vincent, A. Nautsch, J. Yamagishi, N. Evans, J. Patino, J.-F. Bonastre, P.-G. Noé, and M. Todisco, “Introducing the VoicePrivacy Initiative,” in _Proceedings INTERSPEECH 2020-21st Annual Conference of the International Speech Communication Association_ , 2020, pp. 1693–1697.
  * [15] S. H. Mohammadi and A. Kain, “Siamese Autoencoders for Speech Style Extraction and Switching Applied to Voice Identification and Conversion,” in _Proceedings INTERSPEECH 2017-18th Annual Conference of the International Speech Communication Association_ , 2017, pp. 1293–1297.
  * [16] J. Chorowski, R. J. Weiss, R. A. Saurous, and S. Bengio, “On Using Backpropagation for Speech Texture Generation and Voice Conversion,” in _IEEE International Conference on Acoustics, Speech, and Signal Processing_ , Calgary, Canada, Apr. 2018.
  * [17] I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio, “Generative adversarial nets,” _Advances in neural information processing systems_ , vol. 27, pp. 2672–2680, 2014.
  * [18] D. P. Kingma and M. Welling, “Auto-Encoding Variational Bayes,” in _2nd International Conference on Learning Representations, Banff, AB, Canada_ , Apr. 2014.
  * [19] W.-N. Hsu, Y. Zhang, and J. Glass, “Unsupervised Learning of Disentangled and Interpretable Representations from Sequential Data,” in _Advances in Neural Information Processing Systems_ , Dec. 2017, pp. 1878–1889.
  * [20] S. Springenberg, E. Lakomkin, C. Weber, and S. Wermter, “Predictive Auxiliary Variational Autoencoder for Representation Learning of Global Speech Characteristics,” in _Proceedings INTERSPEECH 2019-20th Annual Conference of the International Speech Communication Association_ , May 2019, pp. 934–938.
  * [21] Van Den Oord, Aaron and Vinyals, Oriol and Kavukcuoglu, Koray, “Neural Discrete Representation Learning,” in _Advances in Neural Information Processing Systems_ , vol. 30, 2017, pp. 6303–6315.
  * [22] E. Creager, D. Madras, J.-H. Jacobsen, M. A. Weis, K. Swersky, T. Pitassi, and R. Zemel, “Flexibly fair representation learning by disentanglement,” _Proceedings of Machine Learning Research_ , pp. 1436–1445, 2019.
  * [23] F. Locatello, G. Abbati, T. Rainforth, S. Bauer, B. Schölkopf, and O. Bachem, “On the fairness of disentangled representations,” in _Advances in Neural Information Processing Systems_ , 2019, pp. 14 611–14 624.
  * [24] D. Griffin and J. Lim, “Signal estimation from modified short-time Fourier transform,” _IEEE Transactions on Acoustics, Speech, and Signal Processing_ , vol. 32, no. 2, pp. 236–243, Dec. 1984.
  * [25] N. Kalchbrenner, E. Elsen, K. Simonyan, S. Noury, N. Casagrande, E. Lockhart, F. Stimberg, A. van den Oord, S. Dieleman, and K. Kavukcuoglu, “Efficient Neural Audio Synthesis,” in _Proceedings of the 35th International Conference on Machine Learning_ , vol. 80, Jul. 2018, pp. 2410–2419.
  * [26] A. Oord, Y. Li, and O. Vinyals, “Representation Learning with Contrastive Predictive Coding,” _arXiv preprint arXiv:1807.03748_ , vol. abs/1807.03748, 2018.
  * [27] V. Panayotov, G. Chen, D. Povey, and S. Khudanpur, “Librispeech: an ASR Corpus Based on Public Domain Audio Books,” in _IEEE International Conference on Acoustics, Speech and Signal Processing_ , Apr. 2015, pp. 5206–5210.
  * [28] D. Amodei, S. Ananthanarayanan, R. Anubhai, J. Bai, E. Battenberg, C. Case, J. Casper, B. Catanzaro, Q. Cheng, G. Chen, J. Chen, J. Chen, Z. Chen, M. Chrzanowski, A. Coates, G. Diamos, K. Ding, N. Du, E. Elsen, and Z. Zhu, “Deep Speech 2: End-to-End Speech Recognition in English and Mandarin,” in _Proceedings of the 33nd International Conference on Machine Learning_ , Jun. 2016, pp. 173–182.
  * [29] A. Graves, S. Fernández, F. Gomez, and J. Schmidhuber, “Connectionist temporal classification: labelling unsegmented sequence data with recurrent neural networks,” in _Proceedings of the 23rd international conference on Machine learning_ , 2006, pp. 369–376.
  * [30] J. S. Chung, J. Huh, S. Mun, M. Lee, H.-S. Heo, S. Choe, C. Ham, S. Jung, B.-J. Lee, and I. Han, “In Defence of Metric Learning for Speaker Recognition,” in _Proceedings INTERSPEECH 2020-21th Annual Conference of the International Speech Communication Association_ , Sep. 2020, pp. 2977–2981.
  * [31] J. S. Chung, A. Nagrani, and A. Zisserman, “Voxceleb2: Deep Speaker Recognition,” in _Proceedings INTERSPEECH 2018-19th Annual Conference of the International Speech Communication Association_ , Sep 2018, pp. 1086–1090.
  * [32] E. Dunbar, R. Algayres, J. Karadayi, M. Bernard, J. Benjumea, X.-N. Cao Kam, L. Miskic, C. Dugrain, L. Ondel, A. Black, L. Besacier, S. Sakti, and E. Dupoux, “The Zero Resource Speech Challenge 2019: TTS Without T,” in _Proceedings INTERSPEECH 2019-20th Annual Conference of the International Speech Communication Association_ , Sep. 2019, pp. 1088–1092.


# FIRE 6.5: Feynman Integral Reduction with New Simplification Library

Alexander V. Smirnov<EMAIL_ADDRESS>Mao Zeng<EMAIL_ADDRESS>Research Computing Center, Moscow State University,
119992 Moscow, Russia  Moscow Center for Fundamental and Applied Mathematics,
119992, Moscow, Russia  Higgs Centre for Theoretical Physics, University of
Edinburgh,
James Clerk Maxwell Building, Peter Guthrie Tait Road, Edinburgh, EH9 3FD,
United Kingdom

###### Abstract

FIRE is a program which performs integration-by-parts (IBP) reduction of
Feynman integrals. Originally, the C++ version of FIRE relies on the computer
algebra system Fermat by Robert Lewis to simplify rational functions. We
present an upgrade of FIRE which incorporates a new library FUEL initially
described in a separate publication, which enables a flexible choice of third-
party computer algebra systems as simplifiers, as well as efficient
communications with some of the simplifiers as C++ libraries rather than
through Unix pipes. We achieve significant speedups for IBP reduction of
Feynman integrals involving many kinematic variables, when using an open
source backend based on FLINT newly added in this work, or the Symbolica
backend developed by Ben Ruijl as a potential successor of FORM.

###### keywords:

Feynman integrals , Integrate by parts , Computer algebra

††journal: Computer Physics Communications

PROGRAM SUMMARY

Program title: FIRE, version 6.5 (FIRE 6.5)
CPC Library link to program files: (to be added by Technical Editor)
Developer’s repository link: https://gitlab.com/feynmanintegrals/fire.git
Code Ocean capsule: (to be added by Technical Editor)
Licensing provisions: GPLv2
Programming language: Wolfram Mathematica 8.0 or higher, C++17
Supplementary material: see linked repository for installation instructions
Journal reference of previous version:
https://doi.org/10.1016/j.cpc.2019.106877
Does the new version supersede the previous version? Yes.
Reasons for the new version: The new version no longer relies on a single
computer algebra system, Fermat [1], but instead allows a flexible choice of
several systems, some of which offer higher performance, especially when the
number of variables is large.
Summary of revisions: A new library FUEL [2] is used as a core component of
the new version of FIRE to access different computer algebra systems as
simplifiers of rational function expressions. Since the first release of FUEL
described elsewhere, FUEL version 1.0 here has been enhanced with a new
backend based on the open source library FLINT [3] that provides highly
performant simplification of rational functions.
Nature of problem: Feynman integrals of a given family are reduced to a finite
set of master integrals, by solving linear equations arising from integration
by parts, using Gaussian elimination. The coefficient of the linear equations
are generally rational functions in kinematic variables and the spacetime
dimension, and the simplification of such rational functions during Gaussian
elimination is a key task that is improved in this upgrade of FIRE.
Solution method: Computer algebra systems with state-of-the-art capabilities
for polynomial GCD computations are used as simplification backends, or
simplifiers in short. Due to the design of FIRE, text strings are used as the
exchange format for rational functions before and after simplification. A fast
C++ parser is written to parse strings into the internal format of an external
simplifer, FLINT [3], with state-of-the-art performance for multivariate
polynomial calculations. Similarly, the simplifier Symbolica [4] has high
performance in both GCD computations and parsing, and has been integrated into
FIRE.
References:
[1] https://home.bway.net/lewis/, free–ware with some restrictions;
[2] https://doi.org/10.26089/NumMet.v24r425, open source;
[3] https://flintlib.org/, open source;
[4] https://symbolica.io/, commerical software with free licenses for students
and hobbyists

##  1 Introduction

Evaluating Feynman integrals underlies perturbative calculations in quantum
field theory. Integration-by-parts (IBP) reduction [1] is a standard step in
evaluating Feynman integrals and expresses all integrals of a given family,
with a common set of propagators, in terms of a finite number of master
integrals. IBP reduction exploits the fact that total derivatives integrate to
zero in dimensional regularization, which generates linear relations, referred
to as _integration-by-parts equations_ , between different integrals of a
given family. Typically, master integrals are chosen to be “simple” integrals
where propagators are not raised to high powers and numerators are low-degree
monomials.

In all but the simplest applications, one must consider non-obvious linear
sums of IBP equations to accomplish the reduction. One systematic approach is
the Laporta algorithm [2]. Some publicly available implementations of the
Laporta algorithm include AIR [3], Reduze [4], LiteRed [5], FIRE [6, 7, 8],
and Kira [9, 10, 11]. FIRE has been developed by one of the current authors
and collaborators over the past decade and has found many applications in
cutting-edge calculations in high energy physics. The Laporta algorithm
generates all IBP equations under a certain cutoff of the most complicated
integral involved, before solving the system of linear equations using
Gaussian elimination. The linear equations have coefficients that are
polynomials in the spacetime dimension $d$ and kinematic variables (e.g.
Mandelstam variables and mass parameters), and the coefficients become
rational functions of the same set of variables during Gaussian elimination.
These rational functions need to be simplified (usually into single fractions
whose numerators and denominators have no nontrivial polynomial GCD)
throughout the process of Gaussian elimination to prevent the expressions from
exploding in size.

An alternative to the Laporta algorithm is deriving reduction rules with
symbolic dependence on the powers of propagators and irreducible scalar
products, through heuristic algorithms, e.g. implemented in LiteRed [12], or
through Groebner bases [13, 14, 15, 16, 17, 18, 19]. The reduction rules
express complicated integrals in terms of simpler integrals (according to some
ordering), and the rules generally need to be applied repeatedly to express a
given integral in terms of master integrals. Therefore the simplification of
rational functions in intermediate steps is again an essential computational
task. The approach of syzygy equations [20, 21, 22, 23, 24, 25, 26, 27, 28]
reduces the size of the linear system, while the approach of block triangular
forms [29, 30] makes the linear system more structured, but the need to
simplify rational functions in intermediate steps remains.

Simplification of rational functions is a functionality provided by _computer
algebra systems_. Some IBP programs are written in a computer algebra system
already, so this functionality can be accessed naturally. For example, AIR is
written in Maple, and FIRE has an alternative Wolfram Mathematica variant
besides the much faster C++ variant. However, many of the high-performance IBP
programs are written in a general-purpose programming language. This requires
interfacing an external computer algebra system as either a separate program
or as a library. For example, Reduze, Kira, and (the preferred variant of)
FIRE are primarily written in C++. All these three programs (until the new
version of FIRE presented here) use the Fermat computer algebra system by
default for simplifying rational functions.111The authors of Reduze explored
using GiNaC [31] instead but found the speed to uncompetitive against Fermat
at the time of writing of their paper [4]. Ref. [27] uses Singular [32] for
simplification of rational functions. Fermat is a command line program that
takes text input and generates text output, and the aforementioned IBP
programs communicate with Fermat via bi-directional Unix pipes, mimicking how
a human user would interact with a command-line program. Specifically,
previous versions of FIRE communicates with Fermat using the gateToFermat
library by M. Tentukov.

A recent paper [33] by the current authors has presented a C++ library, FUEL,
which provides an uniform interface to many computer algebra systems as
simplification backends, or _simplifiers_ in short. This allows a flexible
choice of simplifiers, some of which are found to out-perform Fermat for
various IBP reduction problems. Additionally, FUEL can communicate with some
simplifiers as C++ libraries, which enhances performance by removing the
overhead of pipes.

In this paper, we present a new version of FIRE which uses FUEL for
simplification of rational functions. The user interface is largely unchanged
from previous versions of FIRE, except that users are now provided with a
choice of third-party computer algebra systems as the simplifier. The build
system has been updated to automatically handle the installation of some of
the third-party software. We present FIRE benchmarks to compare the three top-
performing simplifier backends: Fermat [34], FLINT [35], and Symbolica [36].
The benchmark IBP reduction problems involve a variety of loop orders and
numbers of variables, and include runs based on either the Laporta algorithm
or LiteRed reduction rules. In particular, the ability to use FLINT for our
purpose is first presented in this paper. Other new features added to FIRE
since the announcement of version 6.0 [8], covered in other publications,
includes balanced reconstruction of rational functions [37] and improving the
choice of master integrals [38]. The latter feature has been separated into a
standalone package after initial inclusion as part of FIRE. (See also Ref.
[39] for related work.)

We mention in passing that an entirely different approach is reconstructing
rational functions from finite-field numerical evaluations [40, 41, 42, 43,
44, 45, 46, 37], bypassing the need to simplify rational functions in
intermediate steps. A related technique is the further simplification of
rational functions by multivariate partial fractioning [47, 48], _after_
analytic results for IBP reduction tables or complete loop amplitudes have
already been obtained.

##  2 Performance considerations in rational function simplification

The complete list of supported simplifiers included in FUEL, and hence
available in the new version of FIRE, can be found on the README on
https://gitlab.com/feynmanintegrals/fuel.git.
In this section, we focus on FLINT and Symbolica, which achieve competitive
performance across a wide range of IBP reduction problems when used with FIRE.
In Ref. [33] which presented FUEL, the Nemo computer algebra system [49] was
investigated as a simplifier, which provided much of the prototyping for our
subsequent use of FLINT in FUEL 1.0 described here. Nemo is a package for the
Julia programming language, and the underlying engine for polynomial
computations is the C library FLINT. By switching to using FLINT directly, we
find it easier to gain control over performance. We use recent development
versions of FLINT which contain an implementation of multivariate rational
function arithmetic on top of its more established polynomial
functionality.222Originally, multivariate rational functions are implemented
in the Calcium library [50], before being merged into the development
repository of FLINT earlier this year. The relevant functionality is available
in the header file fmpz_mpoly_q.h. Symbolica [36] is being developed by Ben
Ruijl as a modernized alternative to FORM [51], and the use of Symbolica in
FUEL was already investigated in Ref. [33]. The author of Symbolica has
further optimized the software for our purposes since then.

In the subsections below, we briefly describe some of the performance
considerations that have been taken into account in the FLINT and Symbolica
backends.

###  2.1 Overhead in string representations of expressions

In FIRE and FUEL, rational functions are stored as strings in the common
mathematical notation, e.g. (2*x-y)/(x+y^2). Though not without drawbacks,
this is a convenient choice, since (1) this format is accepted by almost any
third-party computer algebra system; (2) database systems, used to store
intermediate results, commonly accept string data; (3) strings are used to
exchange expressions between different worker processes running in parallel.

When FIRE needs to simplify an expression, it is sent as a string to the
external simplifier, which parses the string into an internal representation,
performs simplifications, and prints out the simplified expression. As pointed
out in the initial paper for FUEL [33], an external simplifier must have
excellent performance in not only the simplification itself but also parsing
and printing to achieve competitive performance. For example, the
aforementioned reference finds Maple to be among the fastest simplifiers in
contrived tests that minimize the overhead of parsing and printing, but Maple
performs poorly for realistic FIRE workloads due to the overhead.

FLINT has a built-in parser for polynomials but not rational functions. We
have written a fast C++ parser to convert strings representing rational
functions into FLINT’s internal rational function type. The parsing algorithm
is a variant of the well-known shunting yard algorithm for parsing
mathematical expressions while taking operator precedence into account.
Symbolica also has a fast parser for rational function expressions. The good
parsing performance is essential for the good performance of FLINT and
Symbolica backends in the simpler IBP reduction problems tested in Section 3,
since the parsing overhead is usually significant in this situation [33].

###  2.2 Re-evaluation cost

Since FIRE stores rational functions as strings, binary arithmetic operators
are implemented by concatenating the operands with the appropriate operator
characters. For example, to add two rational functions that were previously
simplified, written schematically as (poly1)/(poly2) and (poly3)/(poly4), FIRE
forms the string
(poly1)/(poly2) + (poly3)/(poly4)
and sends it (via the FUEL library) to the simplifier. However, now the
simplifier does not make assumptions about the input and attempts to simplify
the two rational functions again before adding them. For example, the
simplifier will attempt to find the polynomial GCD of poly1 and poly2 and
divide both polynomials by the GCD. This step can be avoided if it is known
that the rational function is already simplified and the numerator and
denominator have no nontrivial GCD.

To solve this problem, the FLINT and Symbolica backends have been programmed
to print out simplified rational functions in the custom notation
[poly1,poly2] instead of (poly1)/(poly2), to indicate that the rational
function has already been simplified. When such strings are inserted into
further computations, the parser will directly produce a rational function
given by the numerator poly1 and denominator poly2, without attempting a
redundant polynomial GCD computation. When a simplified expression is a single
polynomial rather than a rational function, the custom notation
[poly] is used.333When this notation is encountered in further computations,
the FLINT backend uses a polynomial parser that does not handle rational
functions, and the Symbolica backend uses a dedicated parser for polynomials
that are known to have been expanded.

At the end of a FIRE run, all such non-conventional strings are converted back
to the conventional mathematical format, for the results (IBP reduction
tables) to be consumed by end users, e.g. using Wolfram Mathematica.

##  3 Benchmarks

All the benchmarks are run on two machines whose characteristics are
summarized in Table 1.

Machine No. | CPU | No. of cores | Frequency | Cache Size | RAM
---|---|---|---|---|---
1 | Intel Core i5-9500 | 6 | 3.00 GHz | 9216 KB | 16 GB
2 | Intel Core i7-8550U | 4 | 1.80 GHz | 8192 KB | 16 GB
Table 1: Characteristics of the two machines used to run benchmark tests

Each benchmark tests the time taken by a FIRE run to perform an IBP reduction
task. The FIRE configurations allow up to 4 sector worker threads and up to 4
simplifier threads to run in parallel. The results for each benchmark tests
are displayed as two numbers to indicate the time taken on Machine 1 and
Machine 2, respectively.444The versions of the simplifiers are as follows.
FLINT: https://github.com/wbhart/flint2.git, commit hash 283e51, Fri Sep 8
2023. Symbolica: https://github.com/benruijl/symbolica.git, commit hash
10c562, Oct 7 2023. Fermat: version 5.17. The later version Fermat 7.0 has
certain improvements, but we do not see any noticeable speedup for the
benchmarks in this paper with up to 5 variables, possibly due to overhead such
as parsing.

###  3.1 Nonplanar vertex diagram

The nonplanar vertex diagram is shown in Fig. 1

Figure 1: The nonplanar vertex diagram with two loops.

We set

$p^{2}=q^{2}=0,\quad p\cdot q=-1/2,$ (1)

without nontrivial kinematic variables, so only the spacetime dimension $d$
will be involved in solving the IBP system. As in an existing example in
previous versions of FIRE, reduction rules produced by LiteRed [12] are used.
The only irreducible scalar product is

$(l-r)^{2}\,.$ (2)

We test a simple IBP problem of reducing the vertex integral with 1 power of
the above ISP, as well as a harder IBP problem of reducing the vertex integral
with the same ISP raised to the 20th power. The execution times are in Table
2. To reduce noise, every run is repeated 10 times, and the median value of
the execution time is taken. For reducing a rank-20 integral, FLINT and
Symbolica show moderate speedups over Fermat. Note that the FLINT backend
could be further optimized for univariate rational functions involved in this
IBP reduction problem, since we always interface with multivariate rational
functions provided by FLINT, which is sub-optimal for the special univariate
case.

Simplifier | rank-1 time (s) | rank-20 time (s)
---|---|---
FLINT | 0.70, 0.93 | 11, 18
Symbolica | 0.65, 0.84 | 13, 18
Fermat | 0.65, 0.91 | 14, 24
Table 2: Time taken for FIRE to perform the IBP reduction for the nonplanar
vertex diagram, with rank-1 or rank-20 numerators, for three different
simplifier backends. Every result is shown as two numbers, indicating the time
measured on the two different machines.

###  3.2 Two-loop massless double box

The double box diagram is shown in Fig. 2.

Figure 2: The double box diagram.

The kinematic variables are

$(p_{1}+p_{2})^{2}=s,\quad(p_{1}+p_{3})^{2}=t\,.$ (3)

The two irreducible scalar products are chosen as

$(k_{2}+p_{1})^{2},\quad(k_{1}-p_{3})^{2}\,.$ (4)

We test an easy problem of the reduction of the integral with a rank-2
numerator (i.e. degree 2 in the irreducible scalar products),
$(k_{2}+p_{1})^{2}(k_{1}-p_{3})^{2}$, as well as a harder problem of the
reduction of the integral with a rank-8 numerator,
$[(k_{2}+p_{1})^{2}]^{4}[(k_{1}-p_{3})^{2}]^{4}$. The easier problem is one of
the examples included in existing versions of FIRE. Symmetry rules for master
integrals as well as preferences for master integrals are supplied to FIRE.
The execution times are shown in Table. 3. For the rank-2 integral, every run
is repeated 10 times, and the median value of the execution time is taken,
while the rank-8 integral is tested with single runs. For reducing a rank-8
integral, FLINT and Symbolica show significant speedups over Fermat.

Simplifier | rank-2 time (s) | rank-8 time (1000 s)
---|---|---
FLINT | 7.5, 10.8 | 0.13, 0.30
Symbolica | 6.7, 9.2 | 0.13, 0.26
Fermat | 7.9, 14.9 | 0.25, 0.48
Table 3: Time taken for FIRE to perform the IBP reduction for the massless
double box diagram, with rank-2 or rank-8 numerators, for three different
simplifier backends. Every result is shown as two numbers, indicating the time
measured on the two different machines.

###  3.3 Four-loop diagram for classical two-body interaction

This is an example from Ref. [52] on the classical scattering of charged
bodies in electrodynamics at the 5th order in $\alpha$. One of the diagrams
involved is shown in Fig. 3.

Figure 3: The four-loop iterated ladder diagram for classical two-body
scattering. The red dashed lines indicate the nine propagators that are cut in
the IBP reduction calculation.

We work in the kinematic limit that the massless vertical lines in the middle
are much softer than the momenta carried by the massive horizontal lines on
the top and bottom. As a result, all the massive propagators are expanded to
leading order as linearized propagators related to the normalized velocities
$u_{1}$ and $u_{2}$ of the massive incoming momenta on the left. The
propagators are

$\displaystyle
k_{1}^{2},\,k_{2}^{2},\,k_{3}^{2},\,k_{4}^{2},\,(q-k_{1}-k_{2}-k_{3}-k_{4})^{2},\,2u_{1}\cdot
k_{1},\,2u_{1}\cdot(k_{1}+k_{2}),\,2u_{1}\cdot(k_{1}+k_{2}+k_{3}),$
$\displaystyle 2u_{1}\cdot(k_{1}+k_{2}+k_{3}+k_{4}),\,-2u_{2}\cdot
k_{1},\,-2u_{2}\cdot(k_{1}+k_{2}),\,-2u_{2}\cdot(k_{1}+k_{2}+k_{3}),$
$\displaystyle-2u_{2}\cdot(k_{1}+k_{2}+k_{3}+k_{4})\,.$ (5)

We have $u_{1}^{2}=u_{2}^{2}=1$ and set $q^{2}=-1$. The only nontrivial
kinematic variable is $y=u_{1}\cdot u_{2}$. We reduce a rank-2 tensor integral
with numerator $(k_{3}\cdot k_{4})^{2}$ on a nine-particle cut indicated by
red dashed lines in Fig. 3. An integral is set to zero if any of the nine
propagators is canceled by a numerator. Full results for the IBP reduction can
be subsequently obtained by merging IBP reduction results on a full set of
spanning cuts (see e.g. [23]). The execution times are shown in Table 4.
Again, FLINT and Symbolica demonstrate speedups over Fermat. Much more
dramatic speedups will be seen in the next example.

Simplifier | Time (1000s)
---|---
FLINT | 0.45, 0.97
Symbolica | 0.45, 0.94
Fermat | 0.82, 1.60
Table 4: Time taken for FIRE to perform the IBP reduction for the soft-
expanded 4-loop iterated ladder diagram with a rank-2 numerator, for three
different simplifier backends. Every result is shown as two numbers,
indicating the time measured on the two different machines.

###  3.4 Three-loop banana diagram

The three-loop banana diagram is shown in Fig. 4.

Figure 4: The three-loop banana diagram.

We consider the unequal mass case, with four different internal masses
$m_{1},m_{2},m_{3},m_{4}$. The external mass is set to a numerical value,
$p^{2}=1$. We reduce a tensor integral whose numerator is a dot product
between the loop momentum for the $m_{2}$ line and the loop momentum for the
$m_{3}$ line. The execution times are shown in Table 5. Unlike the previous
benchmarks, this one has an unusually large number of kinematic scales. In
this case, FLINT and Symbolica backends offer dramatic speedups, up to about 9
times, over the Fermat backend.555Though FLINT is the fastest for this
benchmark, we have also encountered five-variable IBP reduction problems for
which Symbolica is the fastest [33], with both FLINT and Symbolica leading
Fermat considerably according to re-testing.

Simplifier | Time (1000s)
---|---
FLINT | 0.62, 1.01
Symbolica | 1.02, 1.66
Fermat | 5.36, 9.23
Table 5: Time taken for FIRE to perform the IBP reduction for the 3-loop
banana diagram with unequal internal masses, with a rank-1 numerator, for
three different simplifier backends. Every result is shown as two numbers,
indicating the time measured on the two different machines.55footnotemark: 5

##  4 Installation and Usage

Most of the installation and usage instructions are unchanged from the
original paper describing FIRE 6.0 [8], which should be the read by first-time
users. Here we only describe the new features introduced in this FIRE upgrade.

###  4.1 Installation

The installation instructions are similar to FIRE 6.0 [8], except that the
configure script allows additional optional arguments for installing third-
party simplifiers to be used by FIRE through FUEL. For example, to compile
FLINT and Symbolica backends, in addition to the bundled Fermat backend, run

./configure --enable_flint --enable_symbolica

As in FIRE 6.0, the ZStandard library can be used for compressed database
storage, and the tcmalloc library can be used for faster memory allocations.
This changes the above command to

./configure --enable_flint --enable_symbolica --enable_zstd --enable_tcmalloc

Then the dependencies can be compiled by

make dep

while FIRE itself can be compiled by

make

Since both the FLINT library and the finite-field part of FIRE depend on GMP
and MPFR libraries for arbitrary-precision arithmeetic, the source code for
the latter two libraries have been bundled and will be built during the make
dep step. For convenience, we have optionally supplied prebuilt binaries of
these two libraries which work for most current Linux distributions that use
glibc as the C library, such as Ubuntu 22.04 and CentOS 7. The use of the
prebuilt binaries can be enabled by the following extra options supplied to
the command line of configure:

\--enable_prebuilt_gmp --enable_prebuilt_mpfr

###  4.2 Usage

The only significant change in usage compared with FIRE 6.0 is the possibility
to specify the simplifier used. Currently, Fermat is still the default
simplifier. To specify a different simplifer, e.g. FLINT, one can use the

\--calc flint

command line option for FIRE or the finite-field variant FIREp. Alternatively,
one can add the line

#calc flint

to the configuration file. Similarly, one could replace flint by the name of
another simplifier in lower-case letters, e.g. symbolica, if desired. Please
note that the user is responsible for acquiring the licenses of any
proprietary simplifiers, such as Fermat and Symbolica.

To run the benchmarks in Section 3 with e.g. FLINT, one can run the following
commands from the FIRE6 directory:

bin/FIRE6 -c examples/v2l --calc flint

bin/FIRE6 -c examples/v2l_high --calc flint

bin/FIRE6 -c examples/doubleboxrp --calc flint

bin/FIRE6 -c examples/doubleboxrp_high --calc flint

bin/FIRE6 -c examples/softQuadrupleBox --calc flint

bin/FIRE6 -c examples/bananaUnequal --calc flint

The necessary .start and .config files for running the benchmarks have been
included in FIRE’s git repository. The benchmark.sh script in the FIRE6
directory runs the complete benchmarks in Section 3 for all the three
simplifiers discussed.

##  5 Conclusion

We have presented the new version 6.5 of FIRE, a program for integration-by-
parts reduction of Feynman integrals. The main change is the use of the FUEL
library which provides a uniform interface for simplifying rational functions,
with a flexible choice of third-party simplifiers as backends. We have
presented benchmarks for a variety of IBP reduction problems, including both
runs based on the Laporta algorithm and runs based on LiteRed reduction rules.
The open source FLINT backend, newly added in this work, and the Symbolica
backend both achieve performance that is comparable with, or moderately better
than, the default Fermat backend for simple IBP reduction problems with a
small number of kinematic scales and low-complexity integrals. FLINT and
Symbolica start to significantly out-perform Fermat when the complexity of the
integrals increases, as can be seen in the benchmark for the double box
diagram with a rank-8 numerator and the four-loop diagram involved in
classical two-body scattering in electrodynamics. The performance advantages
of FLINT and Symbolica over Fermat become especially prominent for IBP
problems with a large number of kinematic scales, with a speedup of up to a
factor 9 seen in the benchmark for the 3-loop banana diagram with four unequal
internal masses.

In the future, we would like to explore further ideas for optimizing the
simplification of rational functions in FIRE, e.g. by exploring the freedom to
reorder summation terms, as already implemented in Kira [9]. More complicated
IBP reduction tasks involving many kinematic scales will be tested, given the
promising results already seen. We would also like to apply FUEL to the
reconstruction of multivariate rational functions through the balanced
reconstruction algorithm [37].

##  6 Acknowledgments

The authors would like to thank Enrico Herrmann, Ben Ruijl, and Johann
Usovitsch for insightful discussions and/or comments on the manuscript. The
work of AS was supported by the Russian Science Foundation under Agreement No.
21-71-30003 (usage of the FUEL library in the public version of FIRE) and by
the Ministry of Education and Science of the Russian Federation as part of the
program of the Moscow Center for Fundamental and Applied Mathematics under
Agreement No. 075-15-2022-284 (developing the upgrade of the FUEL library that
works directly with simplifier libraries). M.Z.’s work is supported in part by
the U.K. Royal Society through Grant URF\R1\20109. For the purpose of open
access, the authors have applied a Creative Commons Attribution (CC BY)
license to any Author Accepted Manuscript version arising from this
submission.

## References

  * Chetyrkin and Tkachov [1981] K. G. Chetyrkin, F. V. Tkachov,  Integration by Parts: The Algorithm to Calculate beta Functions in 4 Loops,  Nucl. Phys. B 192 (1981) 159–204. doi:10.1016/0550-3213(81)90199-1.
  * Laporta [2000] S. Laporta,  High precision calculation of multiloop Feynman integrals by difference equations,  Int. J. Mod. Phys. A 15 (2000) 5087–5159. doi:10.1142/S0217751X00002159. arXiv:hep-ph/0102033.
  * Anastasiou and Lazopoulos [2004] C. Anastasiou, A. Lazopoulos,  Automatic integral reduction for higher order perturbative calculations,  JHEP 07 (2004) 046\. doi:10.1088/1126-6708/2004/07/046. arXiv:hep-ph/0404258.
  * von Manteuffel and Studerus [2012] A. von Manteuffel, C. Studerus,  Reduze 2 - Distributed Feynman Integral Reduction (2012). arXiv:1201.4330.
  * Lee [2014] R. N. Lee,  LiteRed 1.4: a powerful tool for reduction of multiloop integrals,  J. Phys. Conf. Ser. 523 (2014) 012059. doi:10.1088/1742-6596/523/1/012059. arXiv:1310.1145.
  * Smirnov and Smirnov [2013] A. V. Smirnov, V. A. Smirnov,  FIRE4, LiteRed and accompanying tools to solve integration by parts relations,  Comput. Phys. Commun. 184 (2013) 2820–2827. doi:10.1016/j.cpc.2013.06.016. arXiv:1302.5885.
  * Smirnov [2015] A. V. Smirnov,  FIRE5: a C++ implementation of Feynman Integral REduction,  Comput. Phys. Commun. 189 (2015) 182–191. doi:10.1016/j.cpc.2014.11.024. arXiv:1408.2372.
  * Smirnov and Chuharev [2020] A. V. Smirnov, F. S. Chuharev,  FIRE6: Feynman Integral REduction with Modular Arithmetic,  Comput. Phys. Commun. 247 (2020) 106877. doi:10.1016/j.cpc.2019.106877. arXiv:1901.07808.
  * Maierhöfer et al. [2018] P. Maierhöfer, J. Usovitsch, P. Uwer,  Kira—A Feynman integral reduction program,  Comput. Phys. Commun. 230 (2018) 99–112. doi:10.1016/j.cpc.2018.04.012. arXiv:1705.05610.
  * Maierhöfer and Usovitsch [2018] P. Maierhöfer, J. Usovitsch,  Kira 1.2 Release Notes (2018). arXiv:1812.01491.
  * Klappert et al. [2021] J. Klappert, F. Lange, P. Maierhöfer, J. Usovitsch,  Integral reduction with Kira 2.0 and finite field methods,  Comput. Phys. Commun. 266 (2021) 108024. doi:10.1016/j.cpc.2021.108024. arXiv:2008.06494.
  * Lee [2012] R. N. Lee,  Presenting LiteRed: a tool for the Loop InTEgrals REDuction (2012). arXiv:1212.2685.
  * Tarasov [2004] O. V. Tarasov,  Computation of Grobner bases for two loop propagator type integrals,  Nucl. Instrum. Meth. A 534 (2004) 293–298. doi:10.1016/j.nima.2004.07.104. arXiv:hep-ph/0403253.
  * Gerdt and Robertz [2006] V. P. Gerdt, D. Robertz,  A Maple package for computing Grobner bases for linear recurrence relations,  Nucl. Instrum. Meth. A 559 (2006) 215–219. doi:10.1016/j.nima.2005.11.171. arXiv:cs/0509070.
  * Smirnov and Smirnov [2006] A. V. Smirnov, V. A. Smirnov,  Applying Grobner bases to solve reduction problems for Feynman integrals,  JHEP 01 (2006) 001\. doi:10.1088/1126-6708/2006/01/001. arXiv:hep-lat/0509187.
  * Smirnov [2006] A. V. Smirnov,  An Algorithm to construct Grobner bases for solving integration by parts relations,  JHEP 04 (2006) 026\. doi:10.1088/1126-6708/2006/04/026. arXiv:hep-ph/0602078.
  * Smirnov and Smirnov [2006] A. V. Smirnov, V. A. Smirnov,  S-bases as a tool to solve reduction problems for Feynman integrals,  Nucl. Phys. B Proc. Suppl. 160 (2006) 80–84. doi:10.1016/j.nuclphysbps.2006.09.032. arXiv:hep-ph/0606247.
  * Lee [2008] R. N. Lee,  Group structure of the integration-by-part identities and its application to the reduction of multiloop integrals,  JHEP 07 (2008) 031\. doi:10.1088/1126-6708/2008/07/031. arXiv:0804.3008.
  * Barakat et al. [2023] M. Barakat, R. Brüser, C. Fieker, T. Huber, J. Piclum,  Feynman integral reduction using Gröbner bases,  JHEP 05 (2023) 168\. doi:10.1007/JHEP05(2023)168. arXiv:2210.05347.
  * Gluza et al. [2011] J. Gluza, K. Kajda, D. A. Kosower,  Towards a Basis for Planar Two-Loop Integrals,  Phys. Rev. D 83 (2011) 045012. doi:10.1103/PhysRevD.83.045012. arXiv:1009.0472.
  * Schabinger [2012] R. M. Schabinger,  A New Algorithm For The Generation Of Unitarity-Compatible Integration By Parts Relations,  JHEP 01 (2012) 077\. doi:10.1007/JHEP01(2012)077. arXiv:1111.4220.
  * Ita [2016] H. Ita,  Two-loop Integrand Decomposition into Master Integrals and Surface Terms,  Phys. Rev. D 94 (2016) 116015. doi:10.1103/PhysRevD.94.116015. arXiv:1510.05626.
  * Larsen and Zhang [2016] K. J. Larsen, Y. Zhang,  Integration-by-parts reductions from unitarity cuts and algebraic geometry,  Phys. Rev. D 93 (2016) 041701. doi:10.1103/PhysRevD.93.041701. arXiv:1511.01071.
  * Abreu et al. [2017] S. Abreu, F. Febres Cordero, H. Ita, M. Jaquier, B. Page, M. Zeng,  Two-Loop Four-Gluon Amplitudes from Numerical Unitarity,  Phys. Rev. Lett. 119 (2017) 142001. doi:10.1103/PhysRevLett.119.142001. arXiv:1703.05273.
  * Abreu et al. [2018] S. Abreu, F. Febres Cordero, H. Ita, B. Page, M. Zeng,  Planar Two-Loop Five-Gluon Amplitudes from Numerical Unitarity,  Phys. Rev. D 97 (2018) 116014. doi:10.1103/PhysRevD.97.116014. arXiv:1712.03946.
  * Böhm et al. [2018] J. Böhm, A. Georgoudis, K. J. Larsen, H. Schönemann, Y. Zhang,  Complete integration-by-parts reductions of the non-planar hexagon-box via module intersections,  JHEP 09 (2018) 024\. doi:10.1007/JHEP09(2018)024. arXiv:1805.01873.
  * Bendle et al. [2020] D. Bendle, J. Böhm, W. Decker, A. Georgoudis, F.-J. Pfreundt, M. Rahn, P. Wasser, Y. Zhang,  Integration-by-parts reductions of Feynman integrals using Singular and GPI-Space,  JHEP 02 (2020) 079\. doi:10.1007/JHEP02(2020)079. arXiv:1908.04301.
  * Wu et al. [2023] Z. Wu, J. Boehm, R. Ma, H. Xu, Y. Zhang,  NeatIBP 1.0, A package generating small-size integration-by-parts relations for Feynman integrals (2023). arXiv:2305.08783.
  * Liu and Ma [2019] X. Liu, Y.-Q. Ma,  Determining arbitrary Feynman integrals by vacuum integrals,  Phys. Rev. D 99 (2019) 071501. doi:10.1103/PhysRevD.99.071501. arXiv:1801.10523.
  * Guan et al. [2020] X. Guan, X. Liu, Y.-Q. Ma,  Complete reduction of integrals in two-loop five-light-parton scattering amplitudes,  Chin. Phys. C 44 (2020) 093106. doi:10.1088/1674-1137/44/9/093106. arXiv:1912.09294.
  * Bauer et al. [2002] C. W. Bauer, A. Frink, R. Kreckel,  Introduction to the GiNaC framework for symbolic computation within the C++ programming language,  J. Symb. Comput. 33 (2002) 1–12. doi:10.1006/jsco.2001.0494. arXiv:cs/0004015.
  * Decker et al. [2018] W. Decker, G.-M. Greuel, G. Pfister, H. Schönemann, Singular 4-1-1 — A computer algebra system for polynomial computations, http://www.singular.uni-kl.de, 2018\.
  * Mokrov et al. [2023] K. Mokrov, A. Smirnov, M. Zeng,  Rational Function Simplification for Integration-by-Parts Reduction and Beyond (2023). arXiv:2304.13418.
  * Lewis [????] R. H. Lewis, Fermat: A Computer Algebra System for Polynomial and Matrix Computation, http://home.bway.net/lewis/, ???? Accessed: 2023-02-18.
  * team [2023] T. F. team, FLINT: Fast Library for Number Theory, 2023. Version 2.9.0, https://flintlib.org.
  * Ruijl [2023] B. Ruijl, Symbolica, https://symbolica.io/, 2023. Accessed: 2023-06-23.
  * Belitsky et al. [2023] A. V. Belitsky, A. V. Smirnov, R. V. Yakovlev,  Balancing act: Multivariate rational reconstruction for IBP,  Nucl. Phys. B 993 (2023) 116253. doi:10.1016/j.nuclphysb.2023.116253. arXiv:2303.02511.
  * Smirnov and Smirnov [2020] A. V. Smirnov, V. A. Smirnov,  How to choose master integrals,  Nucl. Phys. B 960 (2020) 115213. doi:10.1016/j.nuclphysb.2020.115213. arXiv:2002.08042.
  * Usovitsch [2020] J. Usovitsch,  Factorization of denominators in integration-by-parts reductions (2020). arXiv:2002.08173.
  * von Manteuffel and Schabinger [2015] A. von Manteuffel, R. M. Schabinger,  A novel approach to integration by parts reduction,  Phys. Lett. B 744 (2015) 101–104. doi:10.1016/j.physletb.2015.03.029. arXiv:1406.4513.
  * Peraro [2016] T. Peraro,  Scattering amplitudes over finite fields and multivariate functional reconstruction,  JHEP 12 (2016) 030\. doi:10.1007/JHEP12(2016)030. arXiv:1608.01902.
  * Klappert and Lange [2020] J. Klappert, F. Lange,  Reconstructing rational functions with FireFly,  Comput. Phys. Commun. 247 (2020) 106951. doi:10.1016/j.cpc.2019.106951. arXiv:1904.00009.
  * Peraro [2019] T. Peraro,  FiniteFlow: multivariate functional reconstruction using finite fields and dataflow graphs,  JHEP 07 (2019) 031\. doi:10.1007/JHEP07(2019)031. arXiv:1905.08019.
  * Laurentis and Maître [2019] G. Laurentis, D. Maître,  Extracting analytical one-loop amplitudes from numerical evaluations,  JHEP 07 (2019) 123\. doi:10.1007/JHEP07(2019)123. arXiv:1904.04067.
  * De Laurentis and Page [2022] G. De Laurentis, B. Page,  Ansätze for scattering amplitudes from p-adic numbers and algebraic geometry,  JHEP 12 (2022) 140\. doi:10.1007/JHEP12(2022)140. arXiv:2203.04269.
  * Magerya [2022] V. Magerya,  Rational Tracer: a Tool for Faster Rational Function Reconstruction (2022). arXiv:2211.03572.
  * Abreu et al. [2019] S. Abreu, J. Dormans, F. Febres Cordero, H. Ita, B. Page, V. Sotnikov,  Analytic Form of the Planar Two-Loop Five-Parton Scattering Amplitudes in QCD,  JHEP 05 (2019) 084\. doi:10.1007/JHEP05(2019)084. arXiv:1904.00945.
  * Heller and von Manteuffel [2022] M. Heller, A. von Manteuffel,  MultivariateApart: Generalized partial fractions,  Comput. Phys. Commun. 271 (2022) 108174. doi:10.1016/j.cpc.2021.108174. arXiv:2101.08283.
  * Fieker et al. [2017] C. Fieker, W. Hart, T. Hofmann, F. Johansson,  Nemo/hecke: computer algebra and number theory packages for the julia programming language,  in: Proceedings of the 2017 acm on international symposium on symbolic and algebraic computation, 2017, pp. 157–164.
  * Johansson [2023] F. Johansson, Calcium, https://github.com/fredrik-johansson/calcium, 2023\. Accessed: 2023-10-30.
  * Ruijl et al. [2017] B. Ruijl, T. Ueda, J. Vermaseren,  FORM version 4.2 (2017). arXiv:1707.06453.
  * Bern et al. [2023] Z. Bern, E. Herrmann, R. Roiban, M. S. Ruf, A. V. Smirnov, V. A. Smirnov, M. Zeng,  Conservative binary dynamics at order $O(\alpha^{5})$ in electrodynamics (2023). arXiv:2305.08981.