agda

I am taking this from the "Brutal Introduction to Agda" http://oxij.org/note/BrutalDepTypes/ Suppose we want to define division by two on even numbers. We can do this as: div : (n : N) -> even n -> N div zero p = zero div (succ (succ n)) p= succ (div n p) div (succ zero) () N is the natural numbers and even is the following "proposition" even : N -> Set even zero = \top even (succ zero) = \bot even (succ (succ n)) = even n data \bot : Set where record \top : Set where When you evaluate the expression div (succ (succ zero)) You get \p -> succ zero Which is what you expect. However, what I don't

I am working with pair of Stream of rationals, Lets say (L,R) Where L and R are Stream of rationals. There are 3 conditions which L and R both have to satisfy to say it is valid. I have written the code as.. isCut_ : cut → Set isCut x = (p q : pair ) → if((((p mem (getLC x)) ∨ (p mem (getRC x)))) ∧ ((not (p mem getLC x)) ∨ (not (p mem getRC x))) ∧ (not (p <pair q) ∨ ((p mem getLC x) ∨ (q mem getRC x))))then ⊤ else ⊥ I really wanted to change the return type of this function to Bool. Here cut means (L, R) and mem is membership. The problem coming from forall p q which expect return type to be

The instance arguments machinery is described in an old paper and at the Agda wiki . Are there some notable facts that these sources do not mention? What are limitations of instance search? Removing ambiguity If we typecheck this: open import Category.Functor open import Category.Monad open RawFunctor open RawMonad and run C-c C-w _<$>_ ( C-c C-w is "explain why a particular name in scope"), we get (after some cleaning) _<$>_ is in scope as * a record field Category.Functor.RawFunctor._<$>_ * a record field Category.Monad.RawMonad._._<$>_ I.e. _<$>_ is ambiguous, so it's cumbersome to use

The question is about Observational Type Theory . Consider this setting: data level : Set where # : ℕ -> level ω : level _⊔_ : level -> level -> level # α ⊔ # β = # (α ⊔ℕ β) _ ⊔ _ = ω _⊔ᵢ_ : level -> level -> level α ⊔ᵢ # 0 = # 0 α ⊔ᵢ β = α ⊔ β mutual Prop = Univ (# 0) Type = Univ ∘ # ∘ suc data Univ : level -> Set where bot : Prop top : Prop nat : Type 0 univ : ∀ α -> Type α σ≡ : ∀ {α β γ} -> α ⊔ β ≡ γ -> (A : Univ α) -> (⟦ A ⟧ -> Univ β) -> Univ γ π≡ : ∀ {α β γ} -> α ⊔ᵢ β ≡ γ -> (A : Univ α) -> (⟦ A ⟧ -> Univ β) -> Univ γ πᵤ : ∀ {α} -> (A : Univ α) {k : ⟦ A ⟧ -> level} -> (∀ x -> Univ (k x))

In the following Agda code, I have a term language based on de Bruijn indices. I can define substitution over terms in the usual de Bruijn indices way, using renaming to allow the substitution to proceed under a binder. module Temp where data Type : Set where unit : Type _⇾_ : Type → Type → Type -- A context is a snoc-list of types. data Cxt : Set where ε : Cxt _∷_ : Cxt → Type → Cxt -- Context membership. data _∈_ (τ : Type) : Cxt → Set where here : ∀ {Γ} → τ ∈ Γ ∷ τ there : ∀ {Γ τ′} → τ ∈ Γ → τ ∈ Γ ∷ τ′ infix 3 _∈_ data Term (Γ : Cxt) : Type → Set where var : ∀ {τ} → τ ∈ Γ → Term Γ τ 〈〉 :

I'm trying to follow the code for McBride's How to Keep Your Neighbours in Order , and can't understand why Agda (I'm using Agda 2.4.2.2) gives the following error message: Instance search can only be used to find elements in a named type when checking that the expression t has type .T for function _:-_ . The code is given bellow data Zero : Set where record One : Set where constructor <> data Two : Set where tt ff : Two So : Two -> Set So tt = One So ff = Zero record <<_>> (P : Set) : Set where constructor ! field {{ prf }} : P _=>_ : Set -> Set -> Set P => T = {{ p : P }} -> T infixr 3 _=>_

I'm using sized types, and have a substitution function for typed terms which termination-checks if I give a definition directly, but not if I factor it via (monadic) join and fmap. {-# OPTIONS --sized-types #-} module Subst where open import Size To show the problem, it's enough to have unit and sums. I have data types of Trie and Term , and I use tries with a codomain of Term inside Term , as part of the elimination form for sums. data Type : Set where 𝟏 : Type _+_ : Type → Type → Type postulate Cxt : Set → Set -- Every value in the trie is typed in a context obtained by extending Γ. data