Почему у композиции и приложения есть зависимая реализация в Agda?

Question

Почему у композиции функций (∘) и приложения ($) есть реализация, доступная в https://github.com/agda/agda-stdlib/blob/master/src/Function.agda#L74-L76? Для удобства скопировано здесь:

_∘_ : ∀ {a b c}
        {A : Set a} {B : A → Set b} {C : {x : A} → B x → Set c} →
        (∀ {x} (y : B x) → C y) → (g : (x : A) → B x) →
        ((x : A) → C (g x))
f ∘ g = λ x → f (g x)

_∘'_ : ∀ {a b c} {A : Set a} {B : Set b} {C : Set c} →
         (B → C) → (A → B) → (A → C)
f ∘' g = λ x → f (g x)

_$_ : ∀ {a b} {A : Set a} {B : A → Set b} →
      ((x : A) → B x) → ((x : A) → B x)
f $ x = f x

_$'_ : ∀ {a b} {A : Set a} {B : Set b} →
       (A → B) → (A → B)
f $' x = f x

Сначала я подумал, что обоснованиеза этим было то, что $ сможет обрабатывать типы более высокого порядка, с которыми $' не сможет справиться.Например, рассмотрим A = Nat, B = List, f равно :: , где B зависит от A. Но после многих испытаний я не смог придумать пример, который показал бы, чтореализация $' недостаточна.Какие сценарии обрабатывает $, с чем $' не справляется?(Точно так же, какие сценарии ∘ обрабатывают, а ∘' - нет?

open import Agda.Builtin.Nat public
open import Agda.Primitive public

--data List {a} (A : Set a) : Set a where
--  []  : List A
--  _∷_ : (x : A) (xs : List A) → List A

data Vec {a} (A : Set a) : Nat → Set a where
  []  : Vec A zero
  _∷_ : ∀ {n} (x : A) (xs : Vec A n) → Vec A (suc n)

tail : ∀ {a n} {A : Set a} → Vec A (suc n) → Vec A n
tail (x ∷ s) = s

_$_ : ∀ {a b} {A : Set a} {B : A → Set b} →
      ((x : A) → B x) → ((x : A) → B x)
f $ x = f x

_$'_ : ∀ {a b} {A : Set a} {B : Set b} →
       (A → B) → (A → B)
f $' x = f x

_∘_ : ∀ {a b c}
        {A : Set a} {B : A → Set b} {C : {x : A} → B x → Set c} →
        (∀ {x} (y : B x) → C y) → (g : (x : A) → B x) →
        ((x : A) → C (g x))
f ∘ g = λ x → f (g x)

_∘'_ : ∀ {a b c} {A : Set a} {B : Set b} {C : Set c} →
         (B → C) → (A → B) → (A → C)
f ∘' g = λ x → f (g x)

Vecc : ∀ {a} → Nat → (A : Set a) → (Set a)
Vecc x y = Vec y x

data Pair {a b} (A : Set a) (B : A → Set b) : Set (a ⊔ b) where
  _,_ : (x : A) → (y : B x) → Pair A B

-- Dependent Pair attempt
--fst : ∀ {a b} {A : Set a} {B : A → Set b} → Pair A B → A
--fst (a , b) = a
--
--f : Pair Nat $' Vec Nat
--f = _,_ zero $' []
--
--g : Pair (Pair Nat $' Vec Nat) $' λ x → Nat
--g = _,_ (_,_ zero $' []) $' zero

-- Some other attempt
--f : ∀ {a n} {A : Set a} → Vec A ((suc ∘' suc) n) → Vec A n
--f {a} = tail {a} ∘' tail {a}

-- Vec attempt
--f : ∀ {a} (A : Set a) → (Set a)
--f {a} = Vecc {a} (suc zero) ∘' Vecc {a} (suc zero)
--
--h = f Nat
--
--x : h
--x = (zero ∷ []) ∷ []

-- List attempt
--f : ∀ {a} (A : Set a) → (Set a)
--f {a} = List {a} ∘' List {a}
--
--g : ∀ {a} (A : Set a) → (Set a)
--g {a} = List {a} ∘ List {a}
--
--h = f Nat
--i = g Nat
--
--x : h
--x = (zero ∷ []) ∷ []

Answer 1

Один работает с зависимыми функциями, другой нет, как упоминал Андрас Ковач.

Важным отличием является то, что для независимых функций могут быть построены более сильные доказательства.Например:

eq : {A B} -> f : (A -> B) -> x y : A -> x == y -> (f x) == (f y)
eq f x .x refl = refl

Здесь мы можем построить равенство f x и f y.Но мы не можем сделать то же самое для зависимых функций - потому что нет способа доказать B x == B y.Таким образом, существует только более слабое доказательство того, что f x может быть "приведен" к f y.

transport : {A} {B : A -> Set} -> f : (x : A -> B x) -> x y : A -> x == y -> f x -> f y
transport f x .x refl fx = fx

(На самом деле, transport обычно определяется как B x -> B y, а не для зависимой функции;но я просто не могу придумать лучшего имени)

Answer 2

∘′ и $′ не работают с зависимыми функциями.Вы просто не пробовали никаких тестов с зависимыми функциями.Для f $ x примеров f должно быть зависимым, для f ∘ g любая из функций должна быть зависимой.Пример:

open import Data.Nat
open import Data.Vec
open import Function
open import Relation.Binary.PropositionalEquality

replicate' : {A : Set} → A → (n : ℕ) → Vec A n
replicate' a n = replicate a

refl' : {A : Set}(a : A) → a ≡ a
refl' a = refl

-- fail1 : Vec ℕ 10
-- fail1 = replicate' 10 $′ 10

ok1 : Vec ℕ 10
ok1 = replicate' 10 $ 10

-- fail2 : ∀ n → replicate' 10 n ≡ replicate' 10 n
-- fail2 = refl' ∘′ replicate' 10

ok2 : ∀ n → replicate' 10 n ≡ replicate' 10 n
ok2 = refl' ∘ replicate' 10