involved are pretty nasty, though, so this would be very hard to do without a solver for semiring equations. However, such a solver would also depend on reflection machinery, bloating the dependency tree of y z → x *Z (y +Z z) ≡Z x *Z y +Z x *Z z distlZ (a , b) (c , d) (e , f) = use-nat-solver where postulate use-nat-solver : a * (c + e) + b * (d + f) + (a * d + b * c + (a * f + b * e)) ≡ a * c + b * d Fin x ≡ Fin y in example above, but does not give you definitional injectivity, so the constraint solver does not know how to solve the constraint Fin x = Fin _. Relevant issue: https://github.com/agda

involved are pretty nasty, though, so this would be very hard to do without a solver for semiring equations. However, such a solver would also depend on reflection machinery, bloating the dependency tree of y z → x *Z (y +Z z) ≡Z x *Z y +Z x *Z z distlZ (a , b) (c , d) (e , f) = use-nat-solver where postulate use-nat-solver : a * (c + e) + b * (d + f) + (a * d + b * c + (a * f + b * e)) ≡ a * c + b * d Fin x ≡ Fin y in example above, but does not give you definitional injectivity, so the constraint solver does not know how to solve the constraint Fin x = Fin _. Relevant issue: https://github.com/agda

involved are pretty nasty, though, so this would be very hard to do without a solver for semiring equations. However, such a solver would also depend on reflection machinery, bloating the dependency tree of y z → x *Z (y +Z z) ≡Z x *Z y +Z x *Z z distlZ (a , b) (c , d) (e , f) = use-nat-solver where postulate use-nat-solver : a * (c + e) + b * (d + f) + (a * d + b * c + (a * f + b * e)) ≡ a * c + b * d Fin x ≡ Fin y in example above, but does not give you definitional injectivity, so the constraint solver does not know how to solve the constraint Fin x = Fin _. Relevant issue: https://github.com/agda

involved are pretty nasty, though, so this would be very hard to do without a solver for semiring equations. However, such a solver would also depend on reflection machinery, bloating the dependency tree of y z → x *Z (y +Z z) ≡Z x *Z y +Z x *Z z distlZ (a , b) (c , d) (e , f) = use-nat-solver where postulate use-nat-solver : a * (c + e) + b * (d + f) + (a * d + b * c + (a * f + b * e)) ≡ a * c + b * d Fin x ≡ Fin y in example above, but does not give you definitional injectivity, so the constraint solver does not know how to solve the constraint Fin x = Fin _. Relevant issue: https://github.com/agda

write tactics that can be applied without any syntactic overhead. For instance, suppose you have a solver: magic : Type → Term that takes a reflected goal and outputs a proof (when successful). You can of sorts implements a constructor (sort metavariable) representing an unknown sort. The constraint solver can compute these sort metavariables, just like it does when computing regular term metavariables

write tactics that can be applied without any syntactic overhead. For instance, suppose you have a solver: magic : Type → Term that takes a reflected goal and outputs a proof (when successful). You can of sorts implements a constructor (sort metavariable) representing an unknown sort. The constraint solver can compute these sort metavariables, just like it does when computing regular term metavariables

write tactics that can be applied without any syntactic overhead. For instance, suppose you have a solver: magic : Type → Term that takes a reflected goal and outputs a proof (when successful). You can of sorts implements a constructor (sort metavariable) representing an unknown sort. The constraint solver can compute these sort metavariables, just like it does when computing regular term metavariables

write tactics that can be applied without any syntactic overhead. For instance, suppose you have a solver: 144 Chapter 3. Language Reference Agda User Manual, Release 2.6.2 magic : Type → Term that takes of sorts implements a constructor (sort metavariable) representing an unknown sort. The constraint solver can compute these sort metavariables, just like it does when computing regular term metavariables

write tactics that can be applied without any syntactic overhead. For instance, suppose you have a solver: magic : Type → Term that takes a reflected goal and outputs a proof (when successful). You can of sorts implements a constructor (sort metavariable) representing an unknown sort. The constraint solver can compute these sort metavariables, just like it does when computing regular term metavariables

write tactics that can be applied without any syntactic overhead. For instance, suppose you have a solver: 144 Chapter 3. Language Reference Agda User Manual, Release 2.6.2.1 magic : Type → Term that of sorts implements a constructor (sort metavariable) representing an unknown sort. The constraint solver can compute these sort metavariables, just like it does when computing regular term metavariables