Update to a newer version of Agda

Oct 13, 2025 by pinkandtrash.com 16 views

Introduction

In this article, we will explore an issue with instance search in Agda, a dependently typed programming language. The issue arises when trying to resolve instance arguments in certain situations, resulting in a stuck instance search. We will examine a specific example that demonstrates this problem and discuss the implications of this behavior.

Background

Agda is a dependently typed programming language that allows for the development of formal proofs and specifications. One of its key features is its instance search mechanism, which enables the automatic resolution of type class instances. However, in certain situations, this mechanism can get stuck, leading to errors and difficulties in development.

The Example

The following code snippet is an example of a module that defines a record PreMagStr and a record MorphStr:

{-# OPTIONS --without-K #-}

module Premag-issue where

open import Agda.Primitive renaming (_⊔_ to lmax; lsuc to lsucc)
open import Agda.Builtin.Equality renaming (_≡_ to _==_)

module _ (j : Level) where

  record PreMagStr {i} (B₀ : Set i) : Set (lmax i (lsucc j)) where
    infixr 82 _◻_
    field
      hom : B₀ → B₀ → Set j
      _◻_ : {a b c : B₀} → hom b c → hom a b → hom a c

open PreMagStr {{...}}

module _ {i₁ i₂ j₁ j₂} {B₀ : Set i₁} {C₀ : Set i₂} {{ξB : PreMagStr j₁ B₀}} {{ξC : PreMagStr j₂ C₀}} where

  record MorphStr (F₀ : B₀ → C₀) : Set (lmax (lmax i₁ j₁) (lmax i₂ j₂)) where
    field
      F₁ : {a b : B₀} → hom a b → hom (F₀ a) (F₀ b)
      F-◻ : {a b c : B₀} (f : hom a b) (g : hom b c) → F₁ (g ◻ f) == F₁ g ◻ F₁ f

This code defines a record PreMagStr with a field hom and a record MorphStr with a field F₁. The issue arises when trying to resolve the instance arguments _r_53 and _r_66 in the MorphStr record.

The Error

When trying to compile this code with Agda 2.6.4.3 or 2.7.0.1, we get the following error:

Failed to solve the following constraints:
  Is usable at default modality: (F₁
                                  : {a b : B₀} →
                                    PreMagStr.hom ξB a b → PreMagStr.hom ξC (F₀ a) (F₀ b))
                                 (F-◻
                                  : {a b c : B₀} (f : PreMagStr.hom ξB a b)
                                    (g : PreMagStr.hom ξB b c) →
                                    F₁ ((_r_53 (F₀ = F₀) (F₁ = F₁) (f = f) (g = g) PreMagStr.◻ g) f)
                                    ==
                                    (_r_66 (F₀ = F₀) (F₁ = F₁) (f = f) (g = g) PreMagStr.◻ F₁ g)
                                    (F₁ f)) →
                                 MorphStr F₀
    (blocked on _a_48)
  Resolve instance argument _r_53 : PreMagStr _j_50 _B₀_52
  Candidates
    ξC : PreMagStr j₂ C₀
    ξB : PreMagStr j₁ B₀
    (stuck)
  Resolve instance argument _r_66 : PreMagStr _j_63 _B₀_65
  Candidates
    ξC : PreMagStr j₂ C₀
    ξB : PreMagStr j₁ B₀
    (stuck)
  PreMagStr.hom _r_66 _a_67 _c_69
    =< PreMagStr.hom ξC (F₀ _a_48) (F₀ _b_49)
    (blocked on _r_66)
  PreMagStr.hom ξC (F₀ a) (F₀ b) =< PreMagStr.hom _r_66 _a_67 _b_68
    (blocked on _r_66)
  PreMagStr.hom ξC (F₀ b) (F₀ c) =< PreMagStr.hom _r_66 _b_68 _c_69
    (blocked on _r_66)
  PreMagStr.hom _r_53 _a_54 _c_56 =< PreMagStr.hom ξB _a_48 _b_49
    (blocked on _r_53)
  PreMagStr.hom ξB a b =< PreMagStr.hom _r_53 _a_54 _b_55
    (blocked on _r_53)
  PreMagStr.hom ξB b c =< PreMagStr.hom _r_53 _b_55 _c_56
    (blocked on _r_53)

This error message indicates that the instance search is stuck on the arguments _r_53 and _r_66, which are instance arguments of the PreMagStr record.

Discussion

The issue arises because the instance search mechanism is trying to resolve the instance arguments _r_53 and _r_66 in a circular manner. The instance search is trying to resolve _r_53 using the instance argument _r_66, and vice versa. This circularity leads to a stuck instance search.

This behavior is not expected, and it should be fixed. The instance search mechanism should be able to resolve instance arguments in a more efficient and robust manner.

Conclusion

In conclusion, the instance search getting stuck on argument that it used to resolve is a problem that arises in Agda 2.6.4.3 and 2.7.0.1. This issue is caused by a circularity in the instance search mechanism, which leads to a stuck instance search. This behavior is not expected, and it should be fixed. The instance search mechanism should be able to resolve instance arguments in a more efficient and robust manner.

Recommendations

To resolve this issue, we recommend the following:

Update to a newer version of Agda: If you are using Agda 2.6.4.3 or 2.7.0.1, we recommend updating to a newer version of Agda, such as 2.7.1 or later.
Use a different instance search strategy: If you are experiencing issues with the instance search mechanism, you may want to consider using a different instance search strategy, such as the --without-K option.
Use a different type class: If you are experiencing issues with the PreMagStr type class, you may want to consider using a different type class that does not exhibit the same circularity.

Introduction

In our previous article, we explored an issue with instance search in Agda, a dependently typed programming language. The issue arises when trying to resolve instance arguments in certain situations, resulting in a stuck instance search. In this article, we will provide a Q&A section to address some common questions related to this issue.

Q: What is instance search in Agda?

A: Instance search is a mechanism in Agda that allows for the automatic resolution of type class instances. It is a powerful tool that enables developers to write more concise and expressive code.

Q: What causes the instance search to get stuck?

A: The instance search gets stuck when it tries to resolve instance arguments in a circular manner. This circularity leads to a stuck instance search.

Q: How can I resolve the issue?

A: To resolve the issue, you can try the following:

Update to a newer version of Agda: If you are using Agda 2.6.4.3 or 2.7.0.1, we recommend updating to a newer version of Agda, such as 2.7.1 or later.
Use a different instance search strategy: If you are experiencing issues with the instance search mechanism, you may want to consider using a different instance search strategy, such as the --without-K option.
Use a different type class: If you are experiencing issues with the PreMagStr type class, you may want to consider using a different type class that does not exhibit the same circularity.

Q: Can I avoid using instance search altogether?

A: Yes, you can avoid using instance search altogether by manually resolving instance arguments. However, this approach can lead to more verbose and error-prone code.

Q: Are there any workarounds for this issue?

A: Yes, there are several workarounds for this issue. One approach is to use a different type class that does not exhibit the same circularity. Another approach is to use a different instance search strategy, such as the --without-K option.

Q: Is this issue specific to Agda?

A: No, this issue is not specific to Agda. Similar issues can arise in other dependently typed programming languages, such as Coq and Idris.

Q: How can I report this issue to the Agda developers?

A: If you are experiencing this issue, you can report it to the Agda developers by filing a bug report on the Agda issue tracker. Be sure to provide a clear and concise description of the issue, along with any relevant code examples.

Conclusion

In conclusion, the instance search getting stuck on argument that it used to resolve is a problem that arises in Agda 2.6.4.3 and 2.7.0.1. This issue is caused by a circularity in the instance search mechanism, which leads to a stuck instance search. By following the recommendations outlined in this article, you should be able to resolve the issue and continue developing your Agda code.

Additional Resources

Agda documentation: https://agda.readthedocs.io/en/v2.7.1/
Agda issue tracker: https://github.com/agda/agda/issues
Agda community forum: https://discourse.agda-lang.org/