Venue: NAACL 2024

# MuLan\({}^{\circledR}\): A Study of Fact Mutability in Language Models

Constanza Fierro\({}^{\dagger}\) Nicolas Garneau\({}^{\dagger}\)

**Emanuele Bugliarello\({}^{\ddagger}\) Yova Kenentchedjhieva\({}^{\ddagger}\) Anders Sogaard\({}^{\dagger}\) +\({}^{\dagger}\)Department of Computer Science, University of Copenhagen ++\({}^{\ddagger}\) Mohamed bin Zayed University of Artificial Intelligence \({}^{\natural}\)Google Research {c.fierro,nicolas.garneau,soegaard}@di.ku.dk**

Footnote †: footnotemark:

###### Abstract

Facts are subject to contingencies and can be true or false in different circumstances. One such contingency is _time_, wherein some facts mutate over a given period, e.g., the president of a country or the winner of a championship. Trustworthy language models ideally identify mutable facts as such and process them accordingly. We create MuLan\({}^{\circledR}\): a benchmark for evaluating the ability of English language models to anticipate time-contingency, covering both 1:1 and 1:\(N\) relations. We hypothesize that mutable facts are encoded differently than immutable ones, hence being easier to update. In a detailed evaluation of six popular large language models, we consistently find differences in the LLMs' confidence, representations, and update behavior, depending on the mutability of a fact. Our findings should inform future work on the injection of and induction of time-contingent knowledge to/from LLMs.1

Footnote 1: Code and dataset: [https://github.com/coastcloph/fact_mutability](https://github.com/coastcloph/fact_mutability).

## 1 Introduction

Pretrained and large language models (LLMs) trained on vast amounts of text are known to encode factual knowledge Petroni et al. (2019); Jiang et al. (2020); Liu et al. (2023). By using cloze-tests or next-token prediction, it is possible to retrieve facts memorized during pretraining Meng et al. (2022b); Yin et al. (2022); Chalkidis et al. (2023). However, factual knowledge changes over time, and facts such as who is the president of a country, or where someone lives, are time-contingent truths, drifting or mutating with the passage of time.

Dhingra et al. (2022) posit that pretrained LLMs are not time-aware, given that they do not predict the right answer for a specific time period. Jain et al. (2023) and Qiu et al. (2023) prompted LLMs to measure their ability to reason with temporal information, finding again that LLMs show limited time awareness and lag behind human performance. In this paper, we challenge this belief by studying the representations and behavior of LLMs with respect to facts that mutate over time, hypothesizing that despite the low performance encountered in the temporal tasks studied so far, LLMs do encode mutability in their knowledge representations.

The inherent temporality of facts has also been studied from the perspective of model updates, exploring how to best edit the knowledge embedded in pretrained LLMs. Most of the editing techniques have focused on modifying the parameters directly De Cao et al. (2021); Mitchell et al. (2022); Meng et al. (2022a), however Cohen et al. (2023) found that a simple in-context editing obtains more consistent updates than direct parameter modifications. In this paper, we explore LLMs behavior with respect to mutability by studying the effectiveness of knowledge updates given a fact's mutability type.

In order to study LLMs' ability to anticipate when facts are time-contingent, we introduce the MuLan\({}^{\circledR}\): **(Mutability in Language models)** dataset. Unlike LAMA Petroni et al. (2019), which contains mostly immutable relations, and TempLamA Dhingra et al. (2022), which contains exclusively mutable relations, MuLan\({}^{\circledR}\): contains a balanced mix of both types of relations, curated to enable the controlled study of mutability, while also disentangling this phenomenon from cardinality, i.e., the property of some relations to take multiple objects at the same time. MuLan\({}^{\circledR}\): contains 35 relations extracted from WikiData,2 each with up to 1,500 queries. Equipped with this resource, we address the following research questions.

Footnote 2: [https://www.wikidata.org/](https://www.wikidata.org/).

**RQ1:** Will LLMs exhibit lower confidence and performance on time-contingent truths? We find that there is a difference in performance, but the gap in confidence is even more impressive Table 1).

**RQ2:** Will LLMs represent time-contingent truths differently, making it easy to differentiate

representations in terms of mutability? Using probe classifiers, we find that representations do encode mutability (as shown in Table 2).

**RQ3:** Will updating mutable facts be easier than immutable ones? Using in-context learning, we show that mutable facts are indeed more consistently updated than immutable ones (see Table 3).

In the study of RQ1-3, we probe six popular LLMs on MulanN. Analyzing their predictions, representations, and update behavior, we find consistent differences depending on a fact's mutability. This indicates that while time awareness in LLMs cannot be detected through prompting (Dhingra et al., 2022; Jain et al., 2023; Qiu et al., 2023), it is present in their representations. This finding should inform the design of methods for the induction of factual knowledge from LLMs, and for updating knowledge contingent with the passage of time.

## 2 The MuLanN Benchmark

ProbingSimilar to Petroni et al. (2019), we probe language models for their encoded knowledge using Wikidata triples (subject, relation, object) e.g., (Germany, capital, Berlin). To probe language models, these triples can be formulated as a query for which, given a subject and a relation (a query; e.g., "The capital of _Germany_ is _[X]_."), the goal is to retrieve the corresponding object(s). Naturally, some relations, e.g., capital of, are binary or one-to-one (1:1)3 but many others may have many possible completions being \(n\)-ary (1:N), e.g., the relation shares borders with. Both 1:1 and 1:N relations can be involved in time-contingent truths.4 But time-contingent 1:1 facts are, in a sense, 1:N across time, so including 1:N facts that are _not_ time-contingent provides for an interesting control scenario. Therefore, we construct MulanN, to contain 3 sets of relations: Immutable-1 (1:1), Immutable-N (1:N), and Mutable (1:N). Note how instances of Immutable-N and Mutable relations might look similar to a language model from a training perspective, given that the data is shuffled at training time.5

Footnote 3: Each subject has only one correct object.

DatasetTo create MulanN, we first select the set of relations for each mutability type. We use LAMA (Petroni et al., 2019) and TempLAMA (Dhingra et al., 2022) as a starting point and further expand the number of candidate relations with the WikiData database. We then verify the mutability and cardinality of a relation by using the average number of objects, defining a threshold to differentiate between Immutable-1 and Immutable-N, and validating that the cardinality of Mutable and Immutable-N is similar on average. By doing so, we obtain 12 Immutable-1 relations, 10 Immutable-N relations, and 13 Mutable relations. All relations are listed in Table 5 in Appendix A. For each relation, we retrieve up to 1,500 widely known subjects.6 For each query, we retrieve the corresponding objects along with their aliases (e.g., New York-NYC). The dataset consists of 47k subject-relation queries (17k Immutable-1, 13k Immutable-N, and 17k Mutable). For each relation, we create 5 paraphrased templates to account for prompt brittleness Elazar et al. (2021). We alter ambiguous templates to specify the desired entity type, e.g., we change the LAMA template for relation P19 (place of birth) from "[X] was born in [Y]" to "[X] was born in the location of [Y].", to remove the year vs. location ambiguity.

Footnote 6: We use the number of translated pages on Wikipedia as a proxy for widely known entities.

ModelsWe consider two types of pretrained LLMs: foundation and instruction-tuned models. As foundation models, we use LLaMA (Touvron et al., 2023a), LLama-2 (Touvron et al., 2023b), and Falcon (Almazrouei et al., 2023); we evaluate the 7 billion parameters versions for all the models. LLaMA is a model designed for general-purpose tasks such as question answering, and text generation. The LLama-2 model is the more recent and more performant version, which is better suited for reasoning tasks. Finally, Falcon has been trained on RefineWeb, an enhanced curated corpora (Penedo et al., 2023). We also consider their instruction-tuned variants, namely Alpaca (Taori et al., 2023), LLama-2\({}_{\text{Chat}}\)(Touvron et al., 2023b), and FalconInstr.7 We hypothesize that instruction-tuned models will be inclined to produce more succinct answers, making them easier to evaluate in an 

open-generation setup such as the one we consider.

EvaluationWe perform greedy decoding with a beam of size 1 for all models, and we follow the evaluation scheme of Rajpurkar et al. (2016) measuring the average word overlap between the prediction and ground truth answer (the list of WikiData objects along with their aliases). In case of multiple answers, we take the maximum F1 score.8

Footnote 8: We normalize both the prediction and ground truths to remove punctuation, articles, upper cases, and extra white spaces. We also truncate the prediction (after normalization) to have at most the length of the target, to account for foundation models’ longer predictions.

## 3 Results

Performance & Confidence (RQ1)Table 1 shows how LLMs are, in general, better at predicting immutable facts than mutable ones. LLama-2 and LLama-2 show strong performance across relation types. Relations native language (P130) and located in (P30) are the easiest to predict, presumably because their output space is rather limited (detailed results in App. B). Next, we consider models' confidence across mutable and immutable facts, where we define the confidence of a model as being the probability of the first predicted token. Table 1 shows, across models, a significant difference in confidence between predicting Immutable-1 facts and predicting Mutable facts. The drop from Immutable-1 to Immutable-N facts is unsurprising given that there are several plausible answers Holtzman et al. (2021), but the additional drop from Immutable-N to Mutable suggests that LLMs might treat mutable facts differently. Figures in Appendix C show how slightly correlated the F1 score is with the confidence across models.

Representations Encode Mutability (RQ2) 

templates and only one object (chosen randomly); we report the macro average across relations. Note that for the control task it does not make sense to look at the probe accuracy in the validation or test set, as these have a different set of relations than the training (and so there is no connection between the random labels assigned for train and test).

We experiment with a linear projection as the probe model, which uses as input the last token representation from the last layer (details in SSE). Table 2 presents the results for the classification task of Mutable vs Immutable-1 and Mutable vs Immutable-N. We see that the codelength of the mutable class is much smaller than that of the random labels, and the compression is above that of a uniform codelength. This means that it is relatively _easy_ to tell mutable facts from immutable facts, supporting our findings in RQ1. Accuracy is generally high, which validates that the probe can find dimensions that encode mutability across unseen types of relations. To further measure whether these probes are relying only on spurious features of the templates themselves, we train a Naive Bayes classifier on bag of words of the templates, obtaining an accuracy of 0.64 for Immutable-1 and 0.6 for Immutable-N. Given that the accuracy of all probes is higher, we conclude that the probes found mutability features in the representations. Note that higher accuracy could be obtained by experimenting with other probe architectures and performing a more exhaustive search of hyperparameters; however, our main metric is the MDL, and we already find with this result that mutability is more salient than simply template--or type--representations.

Additionally, we assess whether these mutability features found in the representations might simply be frequency features. We study the accuracy of the classifier by dividing the test set in frequency bins,12 the plots can be found in SSD.1. The main observation is that the performance of the classifier cannot be explained simply by frequency, e.g. in the 3rd bin there are 964 Immutable-1 and 840 Mutable examples, and the Immutable-1 classifiers (Figure 6) get around 85-95% accuracy (depending on the model), way above a classifier using simply frequency (where low frequent examples would be considered mutable, therefore getting 46% accuracy); the same goes for higher bins and for the Immutable-N classifiers (see SSD.1).

Footnote 12: We use the number of Wikipedia pages of an entity as a proxy of frequency for its facts.

Edits (RQ3)Finally, we study how mutability affects knowledge updates in LLMs. To do so, we first select a set of queries per model, each set is composed of facts that an LLM has memorized.13 From this set, we then sample the queries so as to have equal number of examples for each mutability type.14 For each query, we randomly select a new target object to replace the memorized one.15 To update the knowledge of the LLMs we follow Cohen et al. (2023) and Sogaard (2021), and we convert the queries to be of the form "_Imagine that_ <fact_update>. _Then_, <query>." Here, <query> uses the best performing template, and <fact_update> contains one of the other 4 templates with the new object. We consider an update to be successful if the model's top prediction is an exact match to the new target object. Table 3 shows that, for most of the models, the rate of Mutable

\begin{table}
\begin{tabular}{l l c r r} \hline \hline
**Data** & **Model** & **Acc.** & **Codelength** & **Compr.** \\ \hline  & LLaMA & 0.86 & 610 / 4880 & 10.2 / 1.2 \\  & Alpaca & 0.87 & 487 / 6627 & 12.7 / 0.9 \\ Imm-1 & LLama-2 & 0.85 & 537 / 4722 & 11.5 / 1.3 \\  & LLama-2\({}_{\text{Chat}}\) & 0.85 & 778 / 4620 & 8.0 / 1.3 \\  & Falcon\({}_{\text{tstart}}\) & 0.89 & 649 / 4694 & 9.6 / 1.3 \\  & Falcon\({}_{\text{tstart}}\) & 0.89 & 617 / 4329 & 10 / 1.4 \\ \hline  & LLaMA & 0.78 & 1058 / 3354 & 6.4 / 2.0 \\  & Alpaca & 0.88 & 453 / 901 & 15.0 / 7.5 \\  & LLama-2 & 0.87 & 1014 / 2513 & 6.7 / 2.7 \\  & LLama-2\({}_{\text{Chaat}}\) & 0.74 & 764 / 4671 & 8.9 / 1.4 \\  & Falcon & 0.83 & 714 / 1999 & 9.5 / 3.4 \\  & Falcon\({}_{\text{tstart}}\) & 0.87 & 534 / 3302 & 12.7 / 2.0 \\ \hline \hline \end{tabular}
\end{table}
Table 2: Representations classification results between immutable and mutable. The MDL results are presented as: mutability / random relation labels. Accuracy is the macro average on the test relations.

\begin{table}
\begin{tabular}{l c c c} \hline \hline  & \multicolumn{3}{c}{**Update Success Rate**} \\ \cline{2-4}
**Model** & **Immutable-1** & **Immutable-N** & **Mutable** \\ \hline LLaMA & **0.718** & 0.650 & 0.588 \\ Alpaca & 0.734 & **0.862** & 0.845 \\ LLama-2 & 0.566 & 0.654 & **0.725** \\ LLama-2\({}_{\text{CHat}}\) & 0.397 & 0.393 & **0.526** \\ Falcon & 0.449 & 0.382 & **0.610** \\ Falcon\({}_{\text{nstart}}\) & 0.302 & 0.331 & **0.528** \\ \hline \hline \end{tabular}
\end{table}
Table 3: Fraction of successful knowledge updates.

 

facts successfully updated is consistently _higher_ than for Immutable ones. We find a slightly different trend for LLaMA, where the pretrained version is more effective at updating Immutable-1 and the instruct-tuned version obtains similar numbers for Immutable-N and Mutable.

We also analyze whether this different behavior might be due only to differences in frequency. We break down the updates accuracy in the three highest frequency percentiles. As we can see in Table 4, there is a clear trend across models that mutable facts, even if they are frequent, are easier to update by models, whereas immutable ones (either 1 or N) are harder. In lower bins there is no clear trend in accuracy differences between mutability types.

## 4 Conclusion

Using our novel resource, MuLan\({}^{\circledR}\), we find new evidence for time awareness in LLMs, specifically for encoding of fact mutability in their representations and for the comparative ease of editing of mutable facts versus immutable ones. Research on the learning dynamics of LLMs may further investigate how LLMs trained on shuffled data acquire such time awareness. From a practical standpoint, on the other hand, our findings should inform future work on the induction of knowledge from LLMs, and the design choices for updating LLMs.

### Limitations

The accuracy of MuLan\({}^{\circledR}\) is dependent on the accuracy of Wikidata, since we extracted the queries using its API. Also, MuLan\({}^{\circledR}\) and the models analyzed are exclusively in English. Even though we try to control and analyze confounds, there might be other possible confounds, e.g. objects' types in the updates, and a more exact estimation of entities' frequency in the training data. The experiment we perform regarding the updates of mutable facts is limited to contextual modification of LLM knowledge, and we hope that this preliminary experiment will pave the way for other update mechanisms.

## References

* A. Holtzman, P. West, V. Shwartz, Y. Choi, and L. Zettlemoyer (2021)Surface form competition: why the highest probability answer isn't always right. In Proceedings of the 2021 Conference

\begin{table}
\begin{tabular}{l c c c c c c c c} \hline \hline  & \multicolumn{3}{c}{**Immutable-1**} & \multicolumn{3}{c}{**Immutable-N**} & \multicolumn{3}{c}{**Mutable**} \\ \cline{2-9}
**Models** & **1st** & **2nd** & **3rd** & **1st** & **2nd** & **3rd** & **1st** & **2nd** & **3rd** \\ \hline LLaMA & 71.4 & 80.9 & **82.3** & 65.0 & 78.9 & 30.7 & 51.7 & 52.1 & 46.6 \\ Alpaca & 76.8 & 82.1 & 77.8 & 82.4 & 87.1 & **95.3** & 91.1 & 85.4 & 81.4 \\ LLama-2 & 62.6 & 56.2 & 36.3 & 66.1 & 51.7 & **82.3** & 70.0 & 72.1 & 62.1 \\ LLama-2\({}_{\text{Clat}}\) & 41.1 & 41.0 & 40.2 & 38.9 & 39.6 & 42.2 & 42.6 & 51.2 & **51.5** \\ Falcon & 42.0 & 63.2 & 42.8 & 30.6 & 46.2 & 57.1 & 56.7 & **69.7** & 60.0 \\ Falcon\({}_{\text{Insor}}\) & 31.8 & 37.1 & 23.2 & 27.6 & 42.3 & 44.0 & 46.9 & 55.5 & **56.7** \\ \hline \hline \end{tabular}
\end{table}
Table 4: Update accuracy according to the 1st, 2nd, and 3rd highest percentile in terms of entities’ frequency. In bold/underline the highest/2nd highest accuracy per model. The results show that even when comparing frequent entities, mutable facts are easier to update.

 

on Empirical Methods in Natural Language Processing_, pages 7038-7051, Online and Punta Cana, Dominican Republic. Association for Computational Linguistics.
* Jain et al. (2023) Raghav Jain, Daivik Sojitra, Arkadeep Acharya, Sriparna Saha, Adam Jatowt, and Sandipan Dandapat. 2023. Do language models have a common sense regarding time? revisiting temporal commonsense reasoning in the era of large language models. In _Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing_, pages 6750-6774, Singapore. Association for Computational Linguistics.
* Jiang et al. (2020) Zhengbao Jiang, Antonios Anastasopoulos, Jun Araki, Haibo Ding, and Graham Neubig. 2020. X-FACTR: Multilingual factual knowledge retrieval from pretrained language models. In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_, pages 5943-5959, Online. Association for Computational Linguistics.
* Kingma and Ba (2014) Diederik P Kingma and Jimmy Ba. 2014. Adam: A method for stochastic optimization. _arXiv preprint arXiv:1412.6980_.
* Liu et al. (2023) Pengfei Liu, Weizhe Yuan, Jinlan Fu, Zhengbao Jiang, Hiroaki Hayashi, and Graham Neubig. 2023. Pretrain, prompt, and predict: A systematic survey of prompting methods in natural language processing. _ACM Computing Surveys_, 55(9):1-35.
* Meng et al. (2022a) Kevin Meng, David Bau, Alex Andonian, and Yonatan Belinkov. 2022a. Locating and editing factual associations in gpt. _Advances in Neural Information Processing Systems_, 35:17359-17372.
* Meng et al. (2022b) Zaiqiao Meng, Fangyu Liu, Ehsan Sharegli, Yixuan Su, Charlotte Collins, and Nigel Collier. 2022b. Rewire-then-probe: A contrastive recipe for probing biomedical knowledge of pre-trained language models. In _Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)_, pages 4798-4810, Dublin, Ireland. Association for Computational Linguistics.
* Mitchell et al. (2022) Eric Mitchell, Charles Lin, Antoine Bosseltu, Chelsea Finn, and Christopher D Manning. 2022. Fast model editing at scale. In _International Conference on Learning Representations_.
* Penedo et al. (2023) Guilherme Penedo, Quentin Malatric, Daniel Hesslow, RNAandra Cojocaru, Alessandro Cappelli, Hamza Alobeidli, Baptiste Pannier, Ebtesam Almazzrouei, and Julien Launay. 2023. The RefinedWeb dataset for Falcon LLM: outperforming curated corpora with web data, and web data only. _arXiv preprint arXiv:2306.01116_.
* Petroni et al. (2019) Fabio Petroni, Tim Rocktaschel, Sebastian Riedel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, and Alexander Miller. 2019. Language models as knowledge bases? In _Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP)_, pages 2463-2473, Hong Kong, China. Association for Computational Linguistics.
* Qiu et al. (2023) Yifu Qiu, Zheng Zhao, Yfah Ziser, Anna Korhonen, Edoardo M Ponti, and Shay B Cohen. 2023. Are large language models temporally grounded? _arXiv preprint arXiv:2311.08398_.
* Rajpurkar et al. (2016) Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: 100,000+ questions for machine comprehension of text. In _Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing_, pages 2383-2392, Austin, Texas. Association for Computational Linguistics.
* Rissanen (1984) J. Rissanen. 1984. Universal coding, information, prediction, and estimation. _IEEE Transactions on Information Theory_, 30(4):629-636.
* Sogaard (2021) Anders Sogaard. 2021. Locke's holiday: Belief bias in machine reading. In _Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing_, pages 8240-8245, Online and Punta Cana, Dominican Republic. Association for Computational Linguistics.
* Taori et al. (2023) Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. 2023. Stanford alpaca: An instruction-following llama model. [https://github.com/tatsu-lab/stanford_alpaca](https://github.com/tatsu-lab/stanford_alpaca).
* Touvron et al. (2023a) Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothee Lacroix, Baptiste Roziere, Naman Goyal, Eric Hambro, Faisal Azhar, Aurelien Rodriguez, Armand Joulin, Edouard Grave, and Guillaume Lample. 2023a. Llama: Open and efficient foundation language models. _ArXiv_, abs/2302.13971.
* Touvron et al. (2023b) Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almhairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajiwal Bhargava, Shruti Bhosalie, et al. 2023b. Llama 2: Open foundation and fine-tuned chat models. _arXiv preprint arXiv:2307.09288_.
* Voita and Titov (2020) Elena Voita and Ivan Titov. 2020. Information-theoretic probing with minimum description length. In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_, pages 183-196, Online. Association for Computational Linguistics.
* Yin et al. (2022) Da Yin, Hritik Bansal, Masoud Monajatipoor, Liunian Harold Li, and Kai-Wei Chang. 2022. GeoMLAMA: Geo-diverse commonsense probing on multilingual pre-trained language models. In _Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing_, pages 2039-2055, Abu Dhabi, United Arab Emirates. Association for Computational Linguistics 

The MuLan\({}^{\circledR}\) Dataset

Table 5 presents all the relations included in the MuLan\({}^{\circledR}\) dataset, and some concrete examples can be found in Table 6.

We also provide the performance and confidence results break down per relation in Table 7. We note that some of the mutable examples in MuLan\({}^{\circledR}\) only have one target answer, despite having multiple potential answers in reality. This limitation arises from the incomplete nature of WikiData. We compute the average F1-scores when discarding these incomplete examples and the models obtain: 30.19 LLaMA, 40.20 Alpaca, 32.6 LLama-2, 40.80 LLama-2\({}_{\text{Chat}}\), 21.91 Falcon, 31.60 FalconInstr. We note that the same trends discussed in SS3 still stand.

### Frequency Per Mutability Type

We use the number of Wikipedia sites (in different languages) of a subject as a proxy of frequency (as done for selecting the subjects, see footnote 6), given that we don't have access to each model's training data.16 Given this frequency proxy, we find that in MuLan\({}^{\circledR}\) immutable facts are more frequent than mutable, with average and standard deviation counts of:

Footnote 16: Note that computing co-occurrences may lead to incorrect conclusions since WikiData is not thorough with all the valid completions over time, so subject-object co-occurrences of mutable facts would be less than in reality because we wouldn’t be using all the valid object completions.

* Immutable-1: 87.1 \(\pm\) 64.7
* Immutable-N: 103.2 \(\pm\) 64.8
* Mutable: 65.4 \(\pm\) 53.7

## Appendix B Performance of Each Model

Table 7 presents the performance results of each model per relation. To run each model we use one NVIDIA A100-40GB, and it takes from a few hours to 1 day depending on the model.

## Appendix C F1-Score vs Confidence for each model

Correlation analysis between the F1 score and the confidence of each model. There is a slight trend in the performance of models with respect to their confidence, but the difference in confidence between 0 and 1 is not huge.

## Appendix D Probe Classifier

The relations that we use for training are:

* Implantable-1: P103, P19, P159.
* Immutable-N: P27, P1412, P190.
* Mutable: P937, P286, P6.

The relations that we use for validation are:

* Immutable-1: P20, P364.
* Immutable-N: P69, P101.
* Mutable: P108, P488.

The number of examples per split is (Immutable-1 / Immutable-N):

* Train: 6230 / 6820.
* Validation: 5780 / 5910.
* Test: 35000 / 31410.

To obtain the LM representation and train the probe classifier we use one NVIDIA A100-40GB, each probe classifier takes a couple of hours to train.

Figure 1: Average confidence per F1-Score for Llama Chat over all the queries in MuLan\({}^{\circledR}\).

Figure 2: Average confidence per F1-Score for Alpaca over all the queries in MuLan\({}^{\circledR}\).

 



### Classifiers Performance vs Frequency

Given the frequencies described in A.1, we conducted additional analysis to investigate whether the different behaviors we find are only due to differences in frequency. We analyze the classifiers accuracy on different frequency bins, in order to asses if it is simply learning to classify frequency features as opposed to mutability features.

The distribution of classes per bin is presented in Table 8 and the accuracy for each bin and model is presented in Figure 6 and Figure 7 for the Imm-1 and Imm-N classifiers respectively. We observe from Table 8 that the classes (immutable/mutable) are roughly balanced in the different bins, but we do tend to have more mutable examples in the least frequent bins and more immutable in the higher-frequency bins. From the plots in Figure 6 and Figure 7 we see that the performance differs across bins, we obtain high accuracy (>90%) in lower and upper bins, while mid bins accuracy is around 85% for the Imm-1 classifier and around 80% for the Imm-N classifier (it differs somewhat per model). However, we note that the performance of the classifiers cannot be explained only by frequency. For the Imm-N classifier e.g. in the 3rd bin, there are 609 immutable and 1052 mutable examples. Depending on the model, the classifier obtains between 70-95% accuracy, whereas a random classi

\begin{table}
\begin{tabular}{c|l|c} \hline \hline
**Relation** & **Query** & **Objects** \\ \hline P19 – Place of birth & **Aristotle** is originally from_X\_. & [Stageira] \\ \hline P47 – Shares border with & **Chile** shares border with \_X\_. & [Argentina, Bolivia, Peru] \\ \hline P286 – Head coach & The head coach of **Rafael Nadal** is \_X\_. & [Toni Nadal, Carlos Moya, Francisco Roig] \\ \hline \hline \end{tabular}
\end{table}
Table 6: Examples of queries with their respective list of possible objects.



fier using only the frequency would obtain 60%. The same goes with a higher bin, where there are 995 immutable and 639 mutable examples, and the accuracy is still ranging between 65-85% whereas a classifier using only the frequency would obtain 55%. In the same line for the Imm-1 classifier, we see that in the 3rd bin there are 964 immutable-1 and 840 mutable examples, and the models get around 85-95% accuracy, way above a classifier using simple frequency (where low frequent examples would be considered mutable, therefore getting 46% accuracy). Similarly, in higher bins (9th), there are 1071 and 818 immutable-1 and mutable examples respectively, and the classifiers obtain 75-85% accuracy, indicating that they are not simply considering all these high frequent examples mutable.

## Appendix E MDL Experimental Setup

We train the probes using the Adam optimizer Kingma and Ba (2014), with weight decay 0.01 and the default learning rate in the HuggingFace trainer (5e-5). We use a linear learning rate scheduler with warm-up ratio of {0.0, 0.1, 0.2}.17 We use early stopping with patience 4 and we train for a maximum of 12 epochs.

Footnote 17: Defined specifically for each probe by using the one that gives the best validation accuracy when the probe is trained on all the data (on \(t_{S}\)).

## Appendix F Updates Data

After the selection process described in the Edits (Q3) section we obtain the following number of examples per model: 177 (LLaMA), 406 (Alpaca), 182 (LLama-2), 2138 (LLama-2\({}_{\text{Cha}}\)), 136 (Falcon), 583 (FalconInstr).

Figure 5: Average confidence per F1-Score for Falcon over all the queries in MuLaN.

 

Figure 6: Accuracy of the MDL classifier per percentile for all six models on the **Immutable-1** types of relations.

Figure 7: Accuracy of the MDL classifier per percentile for all six models on the **Immutable-N** types of relations.