diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1608f59701..cbb0b5d07e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -79,6 +79,11 @@ Deprecated names
   ¬∀⟶∃¬-          ↦   ¬∀⇒∃¬
   ```
 
+* In `Data.List.Fresh.Relation.Unary.Any`:
+  ```agda
+  witness   ↦   satisfiable
+  ```
+
 * In `Data.Rational.Properties`:
   ```agda
   nonPos*nonPos⇒nonPos  ↦  nonPos*nonPos⇒nonNeg
diff --git a/src/Data/List/Fresh.agda b/src/Data/List/Fresh.agda
index c75d2edade..5f056cddb1 100644
--- a/src/Data/List/Fresh.agda
+++ b/src/Data/List/Fresh.agda
@@ -22,11 +22,11 @@ open import Data.List.Relation.Unary.AllPairs using (AllPairs; []; _∷_)
 open import Data.Maybe.Base as Maybe using (Maybe; just; nothing)
 open import Data.Nat.Base using (ℕ; zero; suc)
 open import Function.Base using (_∘′_; flip; id; _on_)
-open import Relation.Nullary using (does)
-open import Relation.Unary as U using (Pred)
-open import Relation.Binary.Core using (Rel)
-import Relation.Binary.Definitions as B using (Reflexive)
+open import Relation.Binary.Core using (Rel; REL)
+open import Relation.Binary.Definitions as Binary using (Reflexive)
 open import Relation.Nary using (_⇒_; ∀[_])
+open import Relation.Nullary using (does)
+open import Relation.Unary as Unary using (Pred; Decidable)
 
 
 private
@@ -34,6 +34,10 @@ private
     a b p r s : Level
     A : Set a
     B : Set b
+    R : Rel A r
+    S : Rel A s
+    x y : A
+
 
 ------------------------------------------------------------------------
 -- Basic type
@@ -41,14 +45,14 @@ private
 -- If we pick an R such that (R a b) means that a is different from b
 -- then we have a list of distinct values.
 
-module _ {a} (A : Set a) (R : Rel A r) where
+module _ (A : Set a) (R : Rel A r) where
 
   data List# : Set (a ⊔ r)
-  fresh : (a : A) (as : List#) → Set r
+  fresh : REL A List# r
 
   data List# where
     []   : List#
-    cons : (a : A) (as : List#) → fresh a as → List#
+    cons : (x : A) (xs : List#) → fresh x xs → List#
 
   -- Whenever R can be reconstructed by η-expansion (e.g. because it is
   -- the erasure ⌊_⌋ of a decidable predicate, cf. Relation.Nary) or we
@@ -64,29 +68,29 @@ module _ {a} (A : Set a) (R : Rel A r) where
 
 -- Convenient notation for freshness making A and R implicit parameters
 infix 5 _#_
-_#_ : {R : Rel A r} (a : A) (as : List# A R) → Set r
+_#_ : REL A (List# A R) _
 _#_ = fresh _ _
 
 ------------------------------------------------------------------------
 -- Operations for modifying fresh lists
 
-module _ {R : Rel A r} {S : Rel B s} (f : A → B) (R⇒S : ∀[ R ⇒ (S on f) ]) where
+module _ (f : A → B) (R⇒S : ∀[ R ⇒ (S on f) ]) where
 
   map   : List# A R → List# B S
-  map-# : ∀ {a} as → a # as → f a # map as
+  map-# : ∀ xs → x # xs → f x # map xs
 
   map []             = []
-  map (cons a as ps) = cons (f a) (map as) (map-# as ps)
+  map (cons x xs ps) = cons (f x) (map xs) (map-# xs ps)
 
   map-# []        _        = _
-  map-# (a ∷# as) (p , ps) = R⇒S p , map-# as ps
+  map-# (x ∷# xs) (p , ps) = R⇒S p , map-# xs ps
 
-module _ {R : Rel B r} (f : A → B) where
+module _ (f : A → B) where
 
   map₁ : List# A (R on f) → List# B R
   map₁ = map f id
 
-module _ {R : Rel A r} {S : Rel A s} (R⇒S : ∀[ R ⇒ S ]) where
+module _ {S : Rel A s} (R⇒S : ∀[ R ⇒ S ]) where
 
   map₂ : List# A R → List# A S
   map₂ = map id R⇒S
@@ -94,115 +98,115 @@ module _ {R : Rel A r} {S : Rel A s} (R⇒S : ∀[ R ⇒ S ]) where
 ------------------------------------------------------------------------
 -- Views
 
-data Empty {A : Set a} {R : Rel A r} : List# A R → Set (a ⊔ r) where
+data Empty {A : Set a} {R : Rel A r} : Pred (List# A R) (a ⊔ r) where
   [] : Empty []
 
-data NonEmpty {A : Set a} {R : Rel A r} : List# A R → Set (a ⊔ r) where
+data NonEmpty {A : Set a} {R : Rel A r} : Pred (List# A R) (a ⊔ r) where
   cons : ∀ x xs pr → NonEmpty (cons x xs pr)
 
 ------------------------------------------------------------------------
 -- Operations for reducing fresh lists
 
-length : {R : Rel A r} → List# A R → ℕ
+length : List# A R → ℕ
 length []        = 0
 length (_ ∷# xs) = suc (length xs)
 
 ------------------------------------------------------------------------
 -- Operations for constructing fresh lists
 
-pattern [_] a = a ∷# []
+pattern [_] x = x ∷# []
 
-fromMaybe : {R : Rel A r} → Maybe A → List# A R
+fromMaybe : Maybe A → List# A R
 fromMaybe nothing  = []
-fromMaybe (just a) = [ a ]
+fromMaybe (just x) = [ x ]
 
-module _ {R : Rel A r} (R-refl : B.Reflexive R) where
+module _ (refl : Reflexive {A = A} R) where
 
   replicate   : ℕ → A → List# A R
-  replicate-# : (n : ℕ) (a : A) → a # replicate n a
+  replicate-# : ∀ n x → x # replicate n x
 
-  replicate zero    a = []
-  replicate (suc n) a = cons a (replicate n a) (replicate-# n a)
+  replicate zero    x = []
+  replicate (suc n) x = cons x (replicate n x) (replicate-# n x)
 
-  replicate-# zero    a = _
-  replicate-# (suc n) a = R-refl , replicate-# n a
+  replicate-# zero    x = _
+  replicate-# (suc n) x = refl , replicate-# n x
 
 ------------------------------------------------------------------------
 -- Operations for deconstructing fresh lists
 
-uncons : {R : Rel A r} → List# A R → Maybe (A × List# A R)
+uncons : List# A R → Maybe (A × List# A R)
 uncons []        = nothing
-uncons (a ∷# as) = just (a , as)
+uncons (x ∷# xs) = just (x , xs)
 
-head : {R : Rel A r} → List# A R → Maybe A
+head : List# A R → Maybe A
 head = Maybe.map proj₁ ∘′ uncons
 
-tail : {R : Rel A r} → List# A R → Maybe (List# A R)
+tail : List# A R → Maybe (List# A R)
 tail = Maybe.map proj₂ ∘′ uncons
 
-take   : {R : Rel A r} → ℕ → List# A R → List# A R
-take-# : {R : Rel A r} → ∀ n a (as : List# A R) → a # as → a # take n as
+take   : ℕ → List# A R → List# A R
+take-# : ∀ n y xs → y # xs → y # take {R = R} n xs
 
 take zero    xs             = []
 take (suc n) []             = []
-take (suc n) (cons a as ps) = cons a (take n as) (take-# n a as ps)
+take (suc n) (cons x xs ps) = cons x (take n xs) (take-# n x xs ps)
 
-take-# zero    a xs        _        = _
-take-# (suc n) a []        ps       = _
-take-# (suc n) a (x ∷# xs) (p , ps) = p , take-# n a xs ps
+take-# zero    y xs        _        = _
+take-# (suc n) y []        ps       = _
+take-# (suc n) y (x ∷# xs) (p , ps) = p , take-# n y xs ps
 
-drop : {R : Rel A r} → ℕ → List# A R → List# A R
-drop zero    as        = as
+drop : ℕ → List# A R → List# A R
+drop zero    xs        = xs
 drop (suc n) []        = []
-drop (suc n) (a ∷# as) = drop n as
+drop (suc n) (x ∷# xs) = drop n xs
 
-module _ {P : Pred A p} (P? : U.Decidable P) where
+module _ {P : Pred A p} (P? : Decidable P) where
 
-  takeWhile   : {R : Rel A r} → List# A R → List# A R
-  takeWhile-# : ∀ {R : Rel A r} a (as : List# A R) → a # as → a # takeWhile as
+  takeWhile   : List# A R → List# A R
+  takeWhile-# : ∀ y xs → y # xs → y # takeWhile {R = R} xs
 
   takeWhile []             = []
-  takeWhile (cons a as ps) =
-    if does (P? a) then cons a (takeWhile as) (takeWhile-# a as ps) else []
+  takeWhile (cons x xs ps) =
+    if does (P? x) then cons x (takeWhile xs) (takeWhile-# x xs ps) else []
 
   -- this 'with' is needed to cause reduction in the type of 'takeWhile (a ∷# as)'
-  takeWhile-# a []        _        = _
-  takeWhile-# a (x ∷# xs) (p , ps) with does (P? x)
-  ... | true  = p , takeWhile-# a xs ps
+  takeWhile-# y []        _        = _
+  takeWhile-# y (x ∷# xs) (p , ps) with does (P? x)
+  ... | true  = p , takeWhile-# y xs ps
   ... | false = _
 
-  dropWhile : {R : Rel A r} → List# A R → List# A R
+  dropWhile : List# A R → List# A R
   dropWhile []            = []
-  dropWhile aas@(a ∷# as)  = if does (P? a) then dropWhile as else aas
+  dropWhile xxs@(x ∷# xs)  = if does (P? x) then dropWhile xs else xxs
 
-  filter   : {R : Rel A r} → List# A R → List# A R
-  filter-# : ∀ {R : Rel A r} a (as : List# A R) → a # as → a # filter as
+  filter   : List# A R → List# A R
+  filter-# : ∀ y xs → y # xs → y # filter {R = R} xs
 
   filter []             = []
-  filter (cons a as ps) =
-    let l = filter as in
-    if does (P? a) then cons a l (filter-# a as ps) else l
+  filter (cons x xs ps) =
+    let l = filter xs in
+    if does (P? x) then cons x l (filter-# x xs ps) else l
 
-  -- this 'with' is needed to cause reduction in the type of 'filter-# a (x ∷# xs)'
-  filter-# a []        _        = _
-  filter-# a (x ∷# xs) (p , ps) with does (P? x)
-  ... | true  = p , filter-# a xs ps
-  ... | false = filter-# a xs ps
+  -- this 'with' is needed to cause reduction in the type of 'filter-# y (x ∷# xs)'
+  filter-# y []        _        = _
+  filter-# y (x ∷# xs) (p , ps) with does (P? x)
+  ... | true  = p , filter-# y xs ps
+  ... | false = filter-# y xs ps
 
 ------------------------------------------------------------------------
 -- Relationship to List and AllPairs
 
-toList : {R : Rel A r} → List# A R → ∃ (AllPairs R)
-toAll  : ∀ {R : Rel A r} {a} as → fresh A R a as → All (R a) (proj₁ (toList as))
+toList : List# A R → ∃ (AllPairs R)
+toAll  : ∀ xs → x # xs → All (R x) (proj₁ (toList {R = R} xs))
 
 toList []             = -, []
 toList (cons x xs ps) = -, toAll xs ps ∷ proj₂ (toList xs)
 
 toAll []        ps       = []
-toAll (a ∷# as) (p , ps) = p ∷ toAll as ps
+toAll (x ∷# xs) (p , ps) = p ∷ toAll xs ps
 
-fromList   : ∀ {R : Rel A r} {xs} → AllPairs R xs → List# A R
-fromList-# : ∀ {R : Rel A r} {x xs} (ps : AllPairs R xs) →
+fromList   : ∀ {xs} → AllPairs R xs → List# A R
+fromList-# : ∀ {xs} (ps : AllPairs R xs) →
              All (R x) xs → x # fromList ps
 
 fromList []       = []
diff --git a/src/Data/List/Fresh/Membership/Setoid.agda b/src/Data/List/Fresh/Membership/Setoid.agda
index 6be37629d7..b5d52b397c 100644
--- a/src/Data/List/Fresh/Membership/Setoid.agda
+++ b/src/Data/List/Fresh/Membership/Setoid.agda
@@ -10,22 +10,26 @@ open import Relation.Binary.Bundles using (Setoid)
 
 module Data.List.Fresh.Membership.Setoid {c ℓ} (S : Setoid c ℓ) where
 
-open import Level using (Level; _⊔_)
+open import Level using (Level)
 open import Data.List.Fresh using (List#)
 open import Data.List.Fresh.Relation.Unary.Any as Any using (Any)
-open import Relation.Binary.Core using (Rel)
+open import Relation.Binary.Core using (Rel; REL)
 open import Relation.Nullary.Negation.Core using (¬_)
 
-open Setoid S renaming (Carrier to A)
-
-infix 4 _∈_ _∉_
+open Setoid S
+  using (_≈_)
+  renaming (Carrier to A)
 
 private
   variable
     r : Level
+    R : Rel A r
+
+
+infix 4 _∈_ _∉_
 
-_∈_ : {R : Rel A r} → A → List# A R → Set _
+_∈_ : REL A (List# A R) _
 x ∈ xs = Any (x ≈_) xs
 
-_∉_ : {R : Rel A r} → A → List# A R → Set _
+_∉_ : REL A (List# A R) _
 x ∉ xs = ¬ (x ∈ xs)
diff --git a/src/Data/List/Fresh/Membership/Setoid/Properties.agda b/src/Data/List/Fresh/Membership/Setoid/Properties.agda
index 819ee4a893..398bfdf6d5 100644
--- a/src/Data/List/Fresh/Membership/Setoid/Properties.agda
+++ b/src/Data/List/Fresh/Membership/Setoid/Properties.agda
@@ -11,101 +11,96 @@ open import Relation.Binary.Bundles using (Setoid)
 module Data.List.Fresh.Membership.Setoid.Properties {c ℓ} (S : Setoid c ℓ)
   where
 
-open import Level using (Level; _⊔_)
+open import Level using (Level)
 open import Data.List.Fresh
 open import Data.List.Fresh.Properties using (fresh-respectsˡ)
 open import Data.List.Fresh.Membership.Setoid S using (_∈_; _∉_)
 open import Data.List.Fresh.Relation.Unary.Any using (Any; here; there; _─_)
-import Data.List.Fresh.Relation.Unary.Any.Properties as List#
+open import Data.List.Fresh.Relation.Unary.Any.Properties as List#
   using (length-remove)
-open import Data.Empty using (⊥; ⊥-elim)
 open import Data.Nat.Base using (ℕ; suc; zero; _≤_; _<_; z≤n; s≤s; z<s; s<s)
 open import Data.Nat.Properties using (module ≤-Reasoning)
 open import Data.Product.Base using (∃; _×_; _,_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂; fromInj₂)
 open import Function.Base using (id; _∘′_; _$_)
 open import Relation.Binary.Core using (Rel)
-open import Relation.Nullary.Negation.Core using (¬_)
+open import Relation.Binary.Definitions as Binary using (_Respectsˡ_)
+open import Relation.Binary.PropositionalEquality.Core as ≡
+  using (cong)
+open import Relation.Nary using (∀[_]; _⇒_)
+open import Relation.Nullary.Negation.Core using (¬_; contradiction; contradiction′)
 open import Relation.Nullary.Irrelevant using (Irrelevant)
 open import Relation.Unary as Unary using (Pred)
-import Relation.Binary.Definitions as Binary using (_Respectsˡ_; Irrelevant)
-import Relation.Binary.PropositionalEquality.Core as ≡
-  using (_≡_; cong; sym; subst)
-open import Relation.Nary using (∀[_]; _⇒_)
-open import Relation.Nullary.Negation.Core using (contradiction)
 
 open Setoid S renaming (Carrier to A)
 
 private
   variable
-    p r : Level
+    r : Level
+    R : Rel A r
+    x y : A
+    xs : List# A R
+
 
 ------------------------------------------------------------------------
 -- transport
 
-module _ {R : Rel A r} where
-
-  ≈-subst-∈ : ∀ {x y} {xs : List# A R} → x ≈ y → x ∈ xs → y ∈ xs
-  ≈-subst-∈ x≈y (here x≈x′)  = here (trans (sym x≈y) x≈x′)
-  ≈-subst-∈ x≈y (there x∈xs) = there (≈-subst-∈ x≈y x∈xs)
+≈-subst-∈ : x ≈ y → x ∈ xs → y ∈ xs
+≈-subst-∈ x≈y (here x≈x′)  = here (trans (sym x≈y) x≈x′)
+≈-subst-∈ x≈y (there x∈xs) = there (≈-subst-∈ x≈y x∈xs)
 
 ------------------------------------------------------------------------
 -- relationship to fresh
 
-module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) where
+module _ (R⇒≉ : ∀[ R ⇒ _≉_ ]) where
 
-  fresh⇒∉ : ∀ {x} {xs : List# A R} → x # xs → x ∉ xs
+  fresh⇒∉ : ∀ {xs : List# A R} → x # xs → x ∉ xs
   fresh⇒∉ (r , _)    (here x≈y)   = R⇒≉ r x≈y
   fresh⇒∉ (_ , x#xs) (there x∈xs) = fresh⇒∉ x#xs x∈xs
 
 ------------------------------------------------------------------------
 -- disjointness
 
-module _ {R : Rel A r} where
-
-  distinct : ∀ {x y} {xs : List# A R} → x ∈ xs → y ∉ xs → x ≉ y
-  distinct x∈xs y∉xs x≈y = y∉xs (≈-subst-∈ x≈y x∈xs)
+distinct : x ∈ xs → y ∉ xs → x ≉ y
+distinct x∈xs y∉xs x≈y = y∉xs (≈-subst-∈ x≈y x∈xs)
 
 ------------------------------------------------------------------------
 -- remove
 
-module _ {R : Rel A r} where
-
-  remove-inv : ∀ {x y} {xs : List# A R} (x∈xs : x ∈ xs) →
-               y ∈ xs → x ≈ y ⊎ y ∈ (xs ─ x∈xs)
-  remove-inv (here x≈z)   (here y≈z)   = inj₁ (trans x≈z (sym y≈z))
-  remove-inv (here _)     (there y∈xs) = inj₂ y∈xs
-  remove-inv (there _)    (here y≈z)   = inj₂ (here y≈z)
-  remove-inv (there x∈xs) (there y∈xs) = Sum.map₂ there (remove-inv x∈xs y∈xs)
+remove-inv : (x∈xs : x ∈ xs) → y ∈ xs → x ≈ y ⊎ y ∈ (xs ─ x∈xs)
+remove-inv (here x≈z)   (here y≈z)   = inj₁ (trans x≈z (sym y≈z))
+remove-inv (here _)     (there y∈xs) = inj₂ y∈xs
+remove-inv (there _)    (here y≈z)   = inj₂ (here y≈z)
+remove-inv (there x∈xs) (there y∈xs) = Sum.map₂ there (remove-inv x∈xs y∈xs)
 
-  ∈-remove : ∀ {x y} {xs : List# A R} (x∈xs : x ∈ xs) → y ∈ xs → x ≉ y → y ∈ (xs ─ x∈xs)
-  ∈-remove x∈xs y∈xs x≉y = fromInj₂ (⊥-elim ∘′ x≉y) (remove-inv x∈xs y∈xs)
+∈-remove : (x∈xs : x ∈ xs) → y ∈ xs → x ≉ y → y ∈ (xs ─ x∈xs)
+∈-remove x∈xs y∈xs x≉y = fromInj₂ (contradiction′ x≉y) (remove-inv x∈xs y∈xs)
 
-module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) (≉⇒R : ∀[ _≉_ ⇒ R ]) where
+module _ (R⇒≉ : ∀[ R ⇒ _≉_ ]) (≉⇒R : ∀[ _≉_ ⇒ R ]) where
 
   private
     R≈ : R Binary.Respectsˡ _≈_
     R≈ x≈y Rxz = ≉⇒R (R⇒≉ Rxz ∘′ trans x≈y)
 
-  fresh-remove : ∀ {x} {xs : List# A R} (x∈xs : x ∈ xs) → x # (xs ─ x∈xs)
+  fresh-remove : ∀ {xs : List# A R} (x∈xs : x ∈ xs) → x # (xs ─ x∈xs)
   fresh-remove {xs = cons x xs pr} (here x≈y)   = fresh-respectsˡ R≈ (sym x≈y) pr
   fresh-remove {xs = cons x xs pr} (there x∈xs) =
     ≉⇒R (distinct x∈xs (fresh⇒∉ R⇒≉ pr)) , fresh-remove x∈xs
 
-  ∉-remove : ∀ {x} {xs : List# A R} (x∈xs : x ∈ xs) → x ∉ (xs ─ x∈xs)
+  ∉-remove : ∀ {xs : List# A R} (x∈xs : x ∈ xs) → x ∉ (xs ─ x∈xs)
   ∉-remove x∈xs = fresh⇒∉ R⇒≉ (fresh-remove x∈xs)
 
 ------------------------------------------------------------------------
 -- injection
 
-module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) where
+module _ (R⇒≉ : ∀[ R ⇒ _≉_ ]) where
 
   injection : ∀ {xs ys : List# A R} (inj : ∀ {x} → x ∈ xs → x ∈ ys) →
               length xs ≤ length ys
   injection {[]}                 {ys} inj = z≤n
   injection {xxs@(cons x xs pr)} {ys} inj = begin
     length xxs               ≤⟨ s≤s (injection step) ⟩
-    suc (length (ys ─ x∈ys)) ≡⟨ ≡.sym (List#.length-remove x∈ys) ⟩
+    suc (length (ys ─ x∈ys)) ≡⟨ length-remove x∈ys ⟨
     length ys                ∎
 
     where
@@ -118,34 +113,34 @@ module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) where
     x∈ys : x ∈ ys
     x∈ys = inj (here refl)
 
-    step : ∀ {y} → y ∈ xs → y ∈ (ys ─ x∈ys)
-    step {y} y∈xs = ∈-remove x∈ys (inj (there y∈xs)) (distinct y∈xs x∉xs ∘′ sym)
+    step : y ∈ xs → y ∈ (ys ─ x∈ys)
+    step y∈xs = ∈-remove x∈ys (inj (there y∈xs)) (distinct y∈xs x∉xs ∘′ sym)
 
   strict-injection : ∀ {xs ys : List# A R} (inj : ∀ {x} → x ∈ xs → x ∈ ys) →
    (∃ λ x → x ∈ ys × x ∉ xs) → length xs < length ys
   strict-injection {xs} {ys} inj (x , x∈ys , x∉xs) = begin
     suc (length xs)          ≤⟨ s≤s (injection step) ⟩
-    suc (length (ys ─ x∈ys)) ≡⟨ ≡.sym (List#.length-remove x∈ys) ⟩
+    suc (length (ys ─ x∈ys)) ≡⟨ length-remove x∈ys ⟨
     length ys                ∎
 
     where
 
     open ≤-Reasoning
 
-    step : ∀ {y} → y ∈ xs → y ∈ (ys ─ x∈ys)
-    step {y} y∈xs = fromInj₂ (λ x≈y → contradiction ((≈-subst-∈ (sym x≈y) y∈xs)) x∉xs)
-                  $ remove-inv x∈ys (inj y∈xs)
+    step : y ∈ xs → y ∈ (ys ─ x∈ys)
+    step y∈xs = fromInj₂ (λ x≈y → contradiction ((≈-subst-∈ (sym x≈y) y∈xs)) x∉xs)
+                $ remove-inv x∈ys (inj y∈xs)
 
 
 ------------------------------------------------------------------------
 -- proof irrelevance
 
-module _ {R : Rel A r} (R⇒≉ : ∀[ R ⇒ _≉_ ]) (≈-irrelevant : Binary.Irrelevant _≈_) where
+module _ (R⇒≉ : ∀[ R ⇒ _≉_ ]) (≈-irrelevant : Binary.Irrelevant _≈_) where
 
-  ∈-irrelevant : ∀ {x} {xs : List# A R} → Irrelevant (x ∈ xs)
+  ∈-irrelevant : ∀ {xs : List# A R} → Irrelevant (x ∈ xs)
   -- positive cases
-  ∈-irrelevant (here x≈y₁)   (here x≈y₂)   = ≡.cong here (≈-irrelevant x≈y₁ x≈y₂)
-  ∈-irrelevant (there x∈xs₁) (there x∈xs₂) = ≡.cong there (∈-irrelevant x∈xs₁ x∈xs₂)
+  ∈-irrelevant (here x≈y₁)   (here x≈y₂)   = cong here (≈-irrelevant x≈y₁ x≈y₂)
+  ∈-irrelevant (there x∈xs₁) (there x∈xs₂) = cong there (∈-irrelevant x∈xs₁ x∈xs₂)
   -- absurd cases
   ∈-irrelevant {xs = cons x xs pr} (here x≈y)    (there x∈xs₂) =
     contradiction x≈y (distinct x∈xs₂ (fresh⇒∉ R⇒≉ pr))
diff --git a/src/Data/List/Fresh/Properties.agda b/src/Data/List/Fresh/Properties.agda
index 1f39b1d057..7d8ae09aec 100644
--- a/src/Data/List/Fresh/Properties.agda
+++ b/src/Data/List/Fresh/Properties.agda
@@ -11,42 +11,44 @@ module Data.List.Fresh.Properties where
 open import Data.List.Fresh using (List#; _∷#_; _#_; Empty; NonEmpty; cons; [])
 open import Data.Product.Base using (_,_)
 open import Level using (Level; _⊔_)
+open import Relation.Binary.Definitions as Binary using (_Respects_; _Respectsˡ_)
+open import Relation.Binary.Core using (Rel)
 open import Relation.Nullary.Decidable using (Dec; yes; no)
 open import Relation.Nullary.Negation using (¬_)
-open import Relation.Unary as U using (Pred)
-import Relation.Binary.Definitions as B using (_Respectsˡ_; Irrelevant)
-open import Relation.Binary.Core using (Rel)
-
 
 private
   variable
-    a b e p r : Level
+    a b ℓ p r : Level
     A : Set a
     B : Set b
+    R : Rel A r
+    x y : A
+    xs : List# A R
+
 
 ------------------------------------------------------------------------
 -- Fresh congruence
 
-module _ {R : Rel A r} {_≈_ : Rel A e} (R≈ : R B.Respectsˡ _≈_) where
+module _ {_≈_ : Rel A ℓ} (resp : R Respectsˡ _≈_) where
 
-  fresh-respectsˡ : ∀ {x y} {xs : List# A R} → x ≈ y → x # xs → y # xs
-  fresh-respectsˡ {xs = []}      x≈y x#xs       = _
+  fresh-respectsˡ : ∀ {xs : List# A R} → (_# xs) Respects _≈_
+  fresh-respectsˡ {xs = []}      x≈y _          = _
   fresh-respectsˡ {xs = x ∷# xs} x≈y (r , x#xs) =
-    R≈ x≈y r , fresh-respectsˡ x≈y x#xs
+    resp x≈y r , fresh-respectsˡ x≈y x#xs
 
 ------------------------------------------------------------------------
 -- Empty and NotEmpty
 
-Empty⇒¬NonEmpty : {R : Rel A r} {xs : List# A R} → Empty xs → ¬ (NonEmpty xs)
+Empty⇒¬NonEmpty : Empty xs → ¬ (NonEmpty xs)
 Empty⇒¬NonEmpty [] ()
 
-NonEmpty⇒¬Empty : {R : Rel A r} {xs : List# A R} → NonEmpty xs → ¬ (Empty xs)
+NonEmpty⇒¬Empty : NonEmpty xs → ¬ (Empty xs)
 NonEmpty⇒¬Empty () []
 
-empty? : {R : Rel A r} (xs : List# A R) → Dec (Empty xs)
+empty? : (xs : List# A R) → Dec (Empty xs)
 empty? []       = yes []
-empty? (_ ∷# _) = no (λ ())
+empty? (_ ∷# _) = no λ()
 
-nonEmpty? : {R : Rel A r} (xs : List# A R) → Dec (NonEmpty xs)
-nonEmpty? []             = no (λ ())
+nonEmpty? : (xs : List# A R) → Dec (NonEmpty xs)
+nonEmpty? []             = no λ()
 nonEmpty? (cons x xs pr) = yes (cons x xs pr)
diff --git a/src/Data/List/Fresh/Relation/Unary/All.agda b/src/Data/List/Fresh/Relation/Unary/All.agda
index fffe091c24..769defadee 100644
--- a/src/Data/List/Fresh/Relation/Unary/All.agda
+++ b/src/Data/List/Fresh/Relation/Unary/All.agda
@@ -14,8 +14,8 @@ open import Data.Product.Base using (_×_; _,_; proj₁; uncurry)
 open import Data.Sum.Base as Sum using (inj₁; inj₂; [_,_]′)
 open import Function.Base using (_∘_; _$_)
 open import Level using (Level; _⊔_; Lift)
-open import Relation.Nullary.Decidable as Dec using (Dec; yes; no; _×?_)
-open import Relation.Unary as U
+open import Relation.Nullary.Decidable.Core as Dec using (Dec; yes; no; _×?_)
+open import Relation.Unary as Unary
   using (Pred; IUniversal; Universal; Decidable; _⇒_; _∪_; _∩_)
 open import Relation.Binary.Core using (Rel)
 
@@ -24,6 +24,12 @@ private
   variable
     a p q r : Level
     A : Set a
+    R : Rel A r
+    P : Pred A p
+    Q : Pred A q
+    x : A
+    xs : List# A R
+
 
 module _ {A : Set a} {R : Rel A r} (P : Pred A p) where
 
@@ -33,50 +39,41 @@ module _ {A : Set a} {R : Rel A r} (P : Pred A p) where
     []  : All []
     _∷_ : ∀ {x xs pr} → P x → All xs → All (cons x xs pr)
 
-module _ {R : Rel A r} {P : Pred A p} where
-
-  uncons : ∀ {x} {xs : List# A R} {pr} →
-           All P (cons x xs pr) → P x × All P xs
-  uncons (p ∷ ps) = p , ps
 
-module _ {R : Rel A r} where
+uncons : ∀ {pr} → All P (cons x xs pr) → P x × All P xs
+uncons (p ∷ ps) = p , ps
 
-  append   : (xs ys : List# A R) → All (_# ys) xs → List# A R
-  append-# : ∀ {x} xs ys {ps} → x # xs → x # ys → x # append xs ys ps
+append   : (xs ys : List# A R) → All (_# ys) xs → List# A R
+append-# : ∀ xs ys {ps} → x # xs → x # ys → x # append {R = R} xs ys ps
 
-  append []             ys _  = ys
-  append (cons x xs pr) ys ps =
-    let (p , ps) = uncons ps in
-    cons x (append xs ys ps) (append-# xs ys pr p)
+append []             ys _  = ys
+append (cons x xs pr) ys ps =
+  let (p , ps) = uncons ps in
+  cons x (append xs ys ps) (append-# xs ys pr p)
 
-  append-# []             ys x#xs       x#ys = x#ys
-  append-# (cons x xs pr) ys (r , x#xs) x#ys = r , append-# xs ys x#xs x#ys
+append-# []             ys x#xs       x#ys = x#ys
+append-# (cons x xs pr) ys (r , x#xs) x#ys = r , append-# xs ys x#xs x#ys
 
-module _ {R : Rel A r} {P : Pred A p} {Q : Pred A q} where
+map : ∀[ P ⇒ Q ] → All P xs → All Q xs
+map p⇒q []       = []
+map p⇒q (p ∷ ps) = p⇒q p ∷ map p⇒q ps
 
-  map : ∀ {xs : List# A R} → ∀[ P ⇒ Q ] → All P xs → All Q xs
-  map p⇒q []       = []
-  map p⇒q (p ∷ ps) = p⇒q p ∷ map p⇒q ps
+lookup : All Q xs → (ps : Any P xs) → Q (proj₁ (Any.satisfiable ps))
+lookup (q ∷ _)  (here _)  = q
+lookup (_ ∷ qs) (there k) = lookup qs k
 
-  lookup : ∀ {xs : List# A R} → All Q xs → (ps : Any P xs) →
-           Q (proj₁ (Any.witness ps))
-  lookup (q ∷ _)  (here _)  = q
-  lookup (_ ∷ qs) (there k) = lookup qs k
+module _ (P? : Decidable P) where
 
-module _ {R : Rel A r} {P : Pred A p} (P? : Decidable P) where
-
-  all? : (xs : List# A R) → Dec (All P xs)
+  all? : Decidable (All {R = R} P)
   all? []        = yes []
   all? (x ∷# xs) = Dec.map′ (uncurry _∷_) uncons (P? x ×? all? xs)
 
 ------------------------------------------------------------------------
 -- Generalised decidability procedure
 
-module _ {R : Rel A r} {P : Pred A p} {Q : Pred A q} where
-
-  decide :  Π[ P ∪ Q ] → Π[ All {R = R} P ∪ Any Q ]
-  decide p∪q [] = inj₁ []
-  decide p∪q (x ∷# xs) =
-    [ (λ px → Sum.map (px ∷_) there (decide p∪q xs))
-    , inj₂ ∘ here
-    ]′ $ p∪q x
+decide :  Π[ P ∪ Q ] → Π[ All {R = R} P ∪ Any Q ]
+decide p∪q [] = inj₁ []
+decide p∪q (x ∷# xs) =
+  [ (λ px → Sum.map (px ∷_) there (decide p∪q xs))
+  , inj₂ ∘ here
+  ]′ $ p∪q x
diff --git a/src/Data/List/Fresh/Relation/Unary/All/Properties.agda b/src/Data/List/Fresh/Relation/Unary/All/Properties.agda
index e6f1d5e556..25e1b921d7 100644
--- a/src/Data/List/Fresh/Relation/Unary/All/Properties.agda
+++ b/src/Data/List/Fresh/Relation/Unary/All/Properties.agda
@@ -8,36 +8,31 @@
 
 module Data.List.Fresh.Relation.Unary.All.Properties where
 
-open import Data.List.Fresh using (List#; []; cons; _∷#_; _#_)
+open import Data.List.Fresh using (List#; []; _∷#_; _#_)
 open import Data.List.Fresh.Relation.Unary.All using (All; []; _∷_; append)
-open import Data.Nat.Base using (ℕ; zero; suc)
 open import Data.Product.Base using (_,_)
-open import Function.Base using (_∘′_)
-open import Level using (Level; _⊔_; Lift)
-open import Relation.Unary  as U using (Pred)
+open import Level using (Level)
+open import Relation.Unary as Unary using (Pred)
 open import Relation.Binary.Core using (Rel)
-open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
-
-
 
 private
   variable
     a p r : Level
     A : Set a
+    R : Rel A r
+    P : Pred A p
+    x : A
+    xs ys : List# A R
 
-module _ {R : Rel A r} where
-
-  fromAll : ∀ {x} {xs : List# A R} → All (R x) xs → x # xs
-  fromAll []       = _
-  fromAll (p ∷ ps) = p , fromAll ps
 
-  toAll : ∀ {x} {xs : List# A R} → x # xs → All (R x) xs
-  toAll {xs = []}      _        = []
-  toAll {xs = a ∷# as} (p , ps) = p ∷ toAll ps
+fromAll : All {R = R} (R x) xs → x # xs
+fromAll []       = _
+fromAll (p ∷ ps) = p , fromAll ps
 
-module _ {R : Rel A r} {P : Pred A p} where
+toAll : x # xs → All {R = R} (R x) xs
+toAll {xs = []}      _        = []
+toAll {xs = a ∷# as} (p , ps) = p ∷ toAll ps
 
-  append⁺ : {xs ys : List# A R} {ps : All (_# ys) xs} →
-            All P xs → All P ys → All P (append xs ys ps)
-  append⁺ []         pys = pys
-  append⁺ (px ∷ pxs) pys = px ∷ append⁺ pxs pys
+append⁺ : ∀ {ps} → All P xs → All P ys → All P (append {R = R} xs ys ps)
+append⁺ []         pys = pys
+append⁺ (px ∷ pxs) pys = px ∷ append⁺ pxs pys
diff --git a/src/Data/List/Fresh/Relation/Unary/Any.agda b/src/Data/List/Fresh/Relation/Unary/Any.agda
index e86379f3ac..e884b42643 100644
--- a/src/Data/List/Fresh/Relation/Unary/Any.agda
+++ b/src/Data/List/Fresh/Relation/Unary/Any.agda
@@ -9,20 +9,27 @@
 module Data.List.Fresh.Relation.Unary.Any where
 
 open import Level using (Level; _⊔_; Lift)
-open import Data.List.Fresh using (List#; []; cons; _∷#_; _#_)
-open import Data.Product.Base using (∃; _,_; -,_)
+open import Data.List.Fresh using (List#; []; cons; _∷#_; _#_; fresh)
+open import Data.Product.Base using (_,_; -,_)
 open import Data.Sum.Base using (_⊎_; [_,_]′; inj₁; inj₂)
 open import Function.Bundles using (_⇔_; mk⇔)
-open import Level using (Level; _⊔_; Lift)
+open import Level using (Level; _⊔_)
+open import Relation.Binary.Core using (Rel)
 open import Relation.Nullary.Negation using (¬_; contradiction)
 open import Relation.Nullary.Decidable as Dec using (Dec; no; _⊎?_)
-open import Relation.Unary  as U using (Pred; IUniversal; Universal; Decidable; _⇒_; _∪_; _∩_)
-open import Relation.Binary.Core using (Rel)
+open import Relation.Unary as Unary
+  using (Pred; Satisfiable; Decidable; _⊆_; _∪_; _∩_)
 
 private
   variable
     a p q r : Level
     A : Set a
+    R : Rel A r
+    P : Pred A p
+    Q : Pred A q
+    x : A
+    xs : List# A R
+
 
 module _ {A : Set a} {R : Rel A r} (P : Pred A p) where
 
@@ -30,7 +37,7 @@ module _ {A : Set a} {R : Rel A r} (P : Pred A p) where
     here  : ∀ {x xs pr} → P x → Any (cons x xs pr)
     there : ∀ {x xs pr} → Any xs → Any (cons x xs pr)
 
-module _ {R : Rel A r} {P : Pred A p} {x} {xs : List# A R} {pr} where
+module _ {pr : fresh A R x xs} where
 
   head : ¬ Any P xs → Any P (cons x xs pr) → P x
   head ¬tail (here p)   = p
@@ -50,32 +57,44 @@ module _ {R : Rel A r} {P : Pred A p} {x} {xs : List# A R} {pr} where
   ⊎⇔Any : (P x ⊎ Any P xs) ⇔ Any P (cons x xs pr)
   ⊎⇔Any = mk⇔ fromSum toSum
 
-module _ {R : Rel A r} {P : Pred A p} {Q : Pred A q} where
+map : P ⊆ Q → Any P xs → Any Q xs
+map p⇒q (here p)  = here (p⇒q p)
+map p⇒q (there p) = there (map p⇒q p)
 
-  map : {xs : List# A R} → ∀[ P ⇒ Q ] → Any P xs → Any Q xs
-  map p⇒q (here p)  = here (p⇒q p)
-  map p⇒q (there p) = there (map p⇒q p)
+satisfiable : Any P xs → Satisfiable P
+satisfiable (here p)   = -, p
+satisfiable (there ps) = satisfiable ps
 
-module _ {R : Rel A r} {P : Pred A p} where
+remove   : ∀ xs → Any {R = R} P xs → List# A R
+remove-# : (p : Any {R = R} P xs) → x # xs → x # remove xs p
 
-  witness : {xs : List# A R} → Any P xs → ∃ P
-  witness (here p)   = -, p
-  witness (there ps) = witness ps
+remove (_ ∷# xs)      (here _)  = xs
+remove (cons x xs pr) (there k) = cons x (remove xs k) (remove-# k pr)
 
-  remove   : (xs : List# A R) → Any P xs → List# A R
-  remove-# : ∀ {x} {xs : List# A R} p → x # xs → x # (remove xs p)
-
-  remove (_ ∷# xs)      (here _)  = xs
-  remove (cons x xs pr) (there k) = cons x (remove xs k) (remove-# k pr)
-
-  remove-# (here x)  (p , ps) = ps
-  remove-# (there k) (p , ps) = p , remove-# k ps
+remove-# (here x)  (p , ps) = ps
+remove-# (there k) (p , ps) = p , remove-# k ps
 
 infixl 4 _─_
 _─_ = remove
 
-module _ {R : Rel A r} {P : Pred A p} (P? : Decidable P) where
+module _ (P? : Decidable P) where
 
-  any? : (xs : List# A R) → Dec (Any P xs)
-  any? []        = no (λ ())
+  any? : Decidable (Any {R = R} P)
+  any? []        = no λ()
   any? (x ∷# xs) = Dec.map ⊎⇔Any (P? x ⊎? any? xs)
+
+
+------------------------------------------------------------------------
+-- DEPRECATED NAMES
+------------------------------------------------------------------------
+-- Please use the new names as continuing support for the old names is
+-- not guaranteed.
+
+-- Version 2.4
+
+witness = satisfiable
+{-# WARNING_ON_USAGE witness
+"Warning: witness was deprecated in v2.4.
+Please use satisfiable instead."
+#-}
+
diff --git a/src/Data/List/Fresh/Relation/Unary/Any/Properties.agda b/src/Data/List/Fresh/Relation/Unary/Any/Properties.agda
index 1618295ece..6b07568d7b 100644
--- a/src/Data/List/Fresh/Relation/Unary/Any/Properties.agda
+++ b/src/Data/List/Fresh/Relation/Unary/Any/Properties.agda
@@ -16,51 +16,54 @@ open import Data.Nat.Base using (ℕ; zero; suc)
 open import Data.Product.Base using (_,_)
 open import Data.Sum.Base as Sum using (_⊎_; inj₁; inj₂)
 open import Function.Base using (_∘′_)
-open import Level using (Level; _⊔_; Lift)
-open import Relation.Nullary.Reflects using (invert)
-open import Relation.Nullary.Decidable.Core
-open import Relation.Unary  as U using (Pred)
+open import Level using (Level)
 open import Relation.Binary.Core using (Rel)
-open import Relation.Nary using (∀[_]; _⇒_; ∁; Decidable)
 open import Relation.Binary.PropositionalEquality.Core using (_≡_; refl; cong)
-open import Relation.Nullary.Negation.Core using (contradiction; ¬_)
+open import Relation.Nary using (∀[_]; _⇒_; ∁; Decidable)
+open import Relation.Nullary.Decidable.Core
+open import Relation.Nullary.Negation.Core using (¬_; contradiction)
+open import Relation.Nullary.Reflects using (invert)
+open import Relation.Unary as Unary using (Pred)
 
 private
   variable
     a b p q r s : Level
     A : Set a
     B : Set b
+    P : Pred A p
+    Q : Pred A q
+    R : Rel A r
+    xs ys : List# A R
+
 
 ------------------------------------------------------------------------
 -- NonEmpty
 
-module _ {R : Rel A r} {P : Pred A p} where
-
-  Any⇒NonEmpty : {xs : List# A R} → Any P xs → NonEmpty xs
-  Any⇒NonEmpty {xs = cons x xs pr} p  = cons x xs pr
+Any⇒NonEmpty : Any P xs → NonEmpty xs
+Any⇒NonEmpty {xs = cons x xs pr} p  = cons x xs pr
 
 ------------------------------------------------------------------------
 -- Correspondence between Any and All
 
-module _ {R : Rel A r} {P : Pred A p} {Q : Pred A q} (P⇒¬Q : ∀[ P ⇒ ∁ Q ]) where
+module _ (P⇒¬Q : ∀[ P ⇒ ∁ Q ]) where
 
-  Any⇒¬All : {xs : List# A R} → Any P xs → ¬ (All Q xs)
+  Any⇒¬All : Any P xs → ¬ (All Q xs)
   Any⇒¬All (here p)   (q ∷ _)  = P⇒¬Q p q
   Any⇒¬All (there ps) (_ ∷ qs) = Any⇒¬All ps qs
 
-  All⇒¬Any : {xs : List# A R} → All P xs → ¬ (Any Q xs)
+  All⇒¬Any : All P xs → ¬ (Any Q xs)
   All⇒¬Any (p ∷ _)  (here q)   = P⇒¬Q p q
   All⇒¬Any (_ ∷ ps) (there qs) = All⇒¬Any ps qs
 
-module _ {R : Rel A r} {P : Pred A p} (P? : Decidable P) where
+module _ (P? : Decidable P) where
 
-  ¬All⇒Any : {xs : List# A R} → ¬ (All P xs) → Any (∁ P) xs
+  ¬All⇒Any : ¬ (All P xs) → Any (∁ P) xs
   ¬All⇒Any {xs = []}      ¬ps = contradiction [] ¬ps
   ¬All⇒Any {xs = x ∷# xs} ¬ps with P? x
   ... |  true because  [p] = there (¬All⇒Any (¬ps ∘′ (invert [p] ∷_)))
   ... | false because [¬p] = here (invert [¬p])
 
-  ¬Any⇒All : {xs : List# A R} → ¬ (Any P xs) → All (∁ P) xs
+  ¬Any⇒All : ¬ (Any P xs) → All (∁ P) xs
   ¬Any⇒All {xs = []}      ¬ps = []
   ¬Any⇒All {xs = x ∷# xs} ¬ps with P? x
   ... |  true because  [p] = contradiction (here (invert [p])) ¬ps
@@ -69,30 +72,23 @@ module _ {R : Rel A r} {P : Pred A p} (P? : Decidable P) where
 ------------------------------------------------------------------------
 -- remove
 
-module _ {R : Rel A r} {P : Pred A p} where
-
-  length-remove : {xs : List# A R} (k : Any P xs) →
-    length xs ≡ suc (length (xs ─ k))
-  length-remove (here _)  = refl
-  length-remove (there p) = cong suc (length-remove p)
+length-remove : (k : Any P xs) → length xs ≡ suc (length (xs ─ k))
+length-remove (here _)  = refl
+length-remove (there p) = cong suc (length-remove p)
 
 ------------------------------------------------------------------------
 -- append
 
-module _ {R : Rel A r} {P : Pred A p} where
-
-  append⁺ˡ : {xs ys : List# A R} {ps : All (_# ys) xs} →
-             Any P xs → Any P (append xs ys ps)
-  append⁺ˡ (here px) = here px
-  append⁺ˡ (there p) = there (append⁺ˡ p)
+append⁺ˡ : {ps : All (_# ys) xs} → Any P xs → Any P (append xs ys ps)
+append⁺ˡ (here px) = here px
+append⁺ˡ (there p) = there (append⁺ˡ p)
 
-  append⁺ʳ : {xs ys : List# A R} {ps : All (_# ys) xs} →
-             Any P ys → Any P (append xs ys ps)
-  append⁺ʳ {xs = []}      p = p
-  append⁺ʳ {xs = x ∷# xs} p = there (append⁺ʳ p)
+append⁺ʳ : {ps : All (_# ys) xs} → Any P ys → Any P (append xs ys ps)
+append⁺ʳ {xs = []}      p = p
+append⁺ʳ {xs = x ∷# xs} p = there (append⁺ʳ p)
 
-  append⁻ : ∀ xs {ys : List# A R} {ps : All (_# ys) xs} →
-            Any P (append xs ys ps) → Any P xs ⊎ Any P ys
-  append⁻ []        p         = inj₂ p
-  append⁻ (x ∷# xs) (here px) = inj₁ (here px)
-  append⁻ (x ∷# xs) (there p) = Sum.map₁ there (append⁻ xs p)
+append⁻ : ∀ xs {ys} {ps : All {R = R} (_# ys) xs} →
+          Any P (append xs ys ps) → Any P xs ⊎ Any P ys
+append⁻ []        p         = inj₂ p
+append⁻ (x ∷# xs) (here px) = inj₁ (here px)
+append⁻ (x ∷# xs) (there p) = Sum.map₁ there (append⁻ xs p)