Are you tired of staring at the “Term type wrong” error in Coq, wondering what sorcery is required to fix it? Fear not, dear proof assistant enthusiast! In this comprehensive guide, we’ll delve into the mysteries of Coq’s type system and provide you with the knowledge to conquer this frustrating error once and for all.
Understanding the “Term Type Wrong” Error
The “Term type wrong” error is a common obstacle that Coq users encounter, especially when working with complex proofs or defining custom types. It occurs when Coq’s type checker detects a mismatch between the expected type of a term and its actual type.
This error can manifest in various ways, such as:
- When defining a function or a lemma, Coq complains that the term doesn’t have the correct type.
- When using a function or lemma, Coq errors saying that the argument has the wrong type.
- When trying to apply a lemma, Coq claims that the hypothesis doesn’t match the expected type.
In this article, we’ll explore the most common causes of the “Term type wrong” error and provide solutions to overcome them.
Cause 1: Type Mismatch Between Functions and Arguments
One of the most frequent causes of the “Term type wrong” error is a type mismatch between a function and its arguments. This can occur when:
- A function is defined with a specific type, but the argument passed to it has a different type.
- A function is applied to an argument with a subtype that’s not compatible with the function’s expected type.
To illustrate this, let’s consider an example:
Definition add (x y : nat) := x + y. Eval compute in (add 2 "hello").
In this example, we’ve defined a function `add` that takes two natural numbers as arguments and returns their sum. However, when we try to apply this function to a natural number `2` and a string `”hello”`, Coq will raise the “Term type wrong” error because the string `”hello”` is not a natural number.
To fix this, we need to ensure that the argument types match the function’s expected types. In this case, we can simply use a natural number as the second argument:
Eval compute in (add 2 3).
Cause 2: Incorrect Use of Type Constructors
Type constructors, such as `prod`, `sum`, and `sig`, are used to build more complex types in Coq. However, if used incorrectly, they can lead to the “Term type wrong” error.
Let’s consider an example:
Definition my_type := prod nat nat. Definition my_term : my_type := (1, "hello").
In this example, we’ve defined a type `my_type` as a product of two natural numbers, and then tried to define a term `my_term` of type `my_type` with a string as the second component. Coq will raise the “Term type wrong” error because the string `”hello”` is not a natural number.
To fix this, we need to ensure that we’re using the correct type constructors and providing the correct types for each component:
Definition my_type := prod nat nat. Definition my_term : my_type := (1, 2).
Cause 3: Incorrect Use of Coercions
Coercions are a powerful feature in Coq that allow us to automatically convert between types. However, if used incorrectly, they can lead to the “Term type wrong” error.
Let’s consider an example:
Coercion nat_to_string (x : nat) := string_of_nat x. Definition my_term : string := 1.
In this example, we’ve defined a coercion `nat_to_string` that converts a natural number to a string. Then, we’ve tried to define a term `my_term` of type `string` using the coercion. Coq will raise the “Term type wrong” error because the coercion is not explicit.
To fix this, we need to make the coercion explicit:
Definition my_term : string := nat_to_string 1.
Solution: Using Coq’s Type Inference and Error Messages
Coq provides an excellent type inference system that can often help us identify the source of the “Term type wrong” error. By using the `Check` command, we can ask Coq to display the type of a term, which can help us diagnose the issue.
Check (add 2 "hello").
In this example, Coq will respond with an error message indicating that the term `”hello”` has type `string`, which is not compatible with the expected type `nat`.
Similarly, when defining a function or lemma, Coq will often provide an error message indicating the expected type of the term. By carefully reading these error messages, we can often identify the source of the type mismatch and correct it.
Solution: Breaking Down Complex Terms and Proofs
Sometimes, the “Term type wrong” error can occur due to a complex term or proof that’s difficult to understand. In such cases, it’s helpful to break down the term or proof into smaller, more manageable pieces.
For example, if we’re trying to prove a lemma that involves a complex term, we can start by breaking down the term into its constituent parts and checking each part individually:
Lemma my_lemma : forall x y, P x y -> Q x y. intros x y H. Check (P x y). Check (Q x y).
By breaking down the proof into smaller steps and checking the types of each part, we can often identify the source of the type mismatch and correct it.
Solution: Using Coq’s SSReflect Library
The SSReflect library provides a set of tactics and notations that can help us write more concise and readable proofs. One of the benefits of using SSReflect is that it can help us avoid the “Term type wrong” error by providing a more explicit and structured approach to proof writing.
For example, instead of writing a proof using Coq’s built-in tactics, we can use SSReflect’s `move` tactic to explicitly state the hypotheses and conclusions:
From Coq Require Import ssreflect. Lemma my_lemma : forall x y, P x y -> Q x y. move => x y H. move : (P x y) => Px_y. move : (Q x y) => Qx_y.
By using SSReflect’s `move` tactic, we can explicitly state the hypotheses and conclusions, which can help us avoid the “Term type wrong” error.
Common Pitfalls and Best Practices
To avoid the “Term type wrong” error in Coq, it’s essential to follow best practices and avoid common pitfalls. Here are some tips to keep in mind:
-
Always check the types of your terms and functions using the `Check` command.
-
Use explicit type annotations when defining functions and lemmas.
-
Avoid using implicit coercions; instead, use explicit coercions or make the coercion explicit.
-
Break down complex terms and proofs into smaller, more manageable pieces.
-
Use Coq’s type inference system to your advantage by carefully reading error messages and using the `Check` command to debug your code.
-
Consider using the SSReflect library to write more concise and readable proofs.
Conclusion
The “Term type wrong” error is a common obstacle in Coq, but with the right techniques and best practices, it’s easily avoidable. By understanding the causes of the error, using Coq’s type inference system, breaking down complex terms and proofs, and following best practices, you can overcome this error and write robust and correct proofs.
Remember, practice makes perfect! The more you work with Coq and encounter the “Term type wrong” error, the more familiar you’ll become with the solutions and best practices outlined in this article.
So, the next time you encounter the “Term type wrong” error, don’t panic! Simply follow the steps outlined in this article, and you’ll be well on your way to writing correct and efficient proofs in Coq.
| Causes of “Term Type Wrong” Error | Solutions |
|---|---|
| Type mismatch between functions and arguments | Ensure argument types match function’s expected types |
| Incorrect use of type constructors | Use correct type constructors and provide correct types for each component |
