agda

Is there any way to unwrap a value, which is inside the Maybe monad, at the type level? For example, how to define type-safe tail for Vec s having this variant of pred : pred : ℕ -> Maybe ℕ pred 0 = nothing pred (suc n) = just n ? Something like tail : ∀ {n α} {A : Set α} -> Vec A n -> if isJust (pred n) then Vec A (from-just (pred n)) else ⊤ This example is totally artificial, but it's not always possible to get rid of some precondition, so you can write a correct by construction definition like the tail function from the standard library: tail : ∀ {a n} {A : Set a} → Vec A (1 + n) → Vec A n

Is there a typed programming language where I can constrain types like the following two examples? A Probability is a floating point number with minimum value 0.0 and maximum value 1.0. type Probability subtype of float where max_value = 0.0 min_value = 1.0 A Discrete Probability Distribution is a map, where: the keys should all be the same type, the values are all Probabilities, and the sum of the values = 1.0. type DPD<K> subtype of map<K, Probability> where sum(values) = 1.0 As far as I understand, this is not possible with Haskell or Agda. What you want is called refinement types . It's

Suppose we define a function f : N \to N f 0 = 0 f (s n) = f (n/2) -- this / operator is implemented as floored division. Agda will paint f in salmon because it cannot tell if n/2 is smaller than n. I don't know how to tell Agda's termination checker anything. I see in the standard library they have a floored division by 2 and a proof that n/2 < n. However, I still fail to see how to get the termination checker to realize that recursion has been made on a smaller subproblem. Agda's termination checker only checks for structural recursion (i.e. calls that happen on structurally smaller

First some boring imports: import Relation.Binary.PropositionalEquality as PE import Relation.Binary.HeterogeneousEquality as HE import Algebra import Data.Nat import Data.Nat.Properties open PE open HE using (_≅_) open CommutativeSemiring commutativeSemiring using (+-commutativeMonoid) open CommutativeMonoid +-commutativeMonoid using () renaming (comm to +-comm) Now suppose that I have a type indexed by, say, the naturals. postulate Foo : ℕ -> Set And that I want to prove some equalities about functions operating on this type Foo . Because agda is not very smart, these will be heterogeneous