gistfile1.txt

Checking Termination (/Users/emily/src/3ea3-final-project/Termination.agda).
 Checking Data.Maybe (/Users/emily/src/agda-stdlib/src/Data/Maybe.agda).
  Checking Function (/Users/emily/src/agda-stdlib/src/Function.agda).
   Checking Level (/Users/emily/src/agda-stdlib/src/Level.agda).
etaExpandClause
  body    =  lower
  xs      =  []
  new tel =  (lower₁ : @1)
etaExpandClause
  body    =  zero
  xs      =  []
  new tel = 
Termination checking [Level.0ℓ]
Trivially terminating: [Level.0ℓ]
   Checking Strict (/Users/emily/src/agda-stdlib/src/Strict.agda).
etaExpandClause
  body    =  force
  xs      =  []
  new tel =  {ℓ : Level} {ℓ′ : Level} {A : Set ℓ} {B : Set ℓ′}
             (_ : A) (_ : A → B)
Termination checking [Strict._.force′]
Trivially terminating: [Strict._.force′]
etaExpandClause
  body    =  force-≡
  xs      =  []
  new tel =  {ℓ : Level} {ℓ′ : Level} {A : Set ℓ} {B : Set ℓ′}
             (a : A) (f : A → B)
Termination checking [Strict._.force′-≡]
Trivially terminating: [Strict._.force′-≡]
etaExpandClause
  body    =  force a (λ _ → b)
  xs      =  []
  new tel =  {ℓ : Level} {ℓ′ : Level} {A : Set ℓ} {B : Set ℓ′}
             (a : A) (b : B)
Termination checking [Strict._.seq]
Trivially terminating: [Strict._.seq]
etaExpandClause
  body    =  force-≡ a (λ _ → b)
  xs      =  []
  new tel =  {ℓ : Level} {ℓ′ : Level} {A : Set ℓ} {B : Set ℓ′}
             (a : A) (b : B)
Termination checking [Strict._.seq-≡]
Trivially terminating: [Strict._.seq-≡]
etaExpandClause
  body    =  A → A
  xs      =  []
  new tel =  {i : Level} (A : Set i)
Termination checking [Function.Fun₁]
Trivially terminating: [Function.Fun₁]
etaExpandClause
  body    =  A → A → A
  xs      =  []
  new tel =  {i : Level} (A : Set i)
Termination checking [Function.Fun₂]
Trivially terminating: [Function.Fun₂]
etaExpandClause
  body    =  λ x → g (x x)
  xs      =  [x]
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : A → Set b} {C : {x : A} → B x → Set c}
             (f : {x : A} (y : B x) → C y) (g : (x : A) → B x) (x : A)
Termination checking [Function._∘_]
Trivially terminating: [Function._∘_]
etaExpandClause
  body    =  λ x → g (x x)
  xs      =  [x]
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (f : B → C) (g : A → B) (x : A)
Termination checking [Function._∘′_]
Trivially terminating: [Function._∘′_]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A)
Termination checking [Function.id]
Trivially terminating: [Function.id]
etaExpandClause
  body    =  λ _ → x₁
  xs      =  [_]
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A) (_ : B)
Termination checking [Function.const]
Trivially terminating: [Function.const]
etaExpandClause
  body    =  λ x → g x (x x)
  xs      =  [x]
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : A → Set b} {C : (x : A) → B x → Set c}
             (f : (x : A) (y : B x) → C x y) (g : (x : A) → B x) (x : A)
Termination checking [Function._ˢ_]
Trivially terminating: [Function._ˢ_]
etaExpandClause
  body    =  λ y x → x x y
  xs      =  [y, x]
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : A → B → Set c} (f : (x : A) (y : B) → C x y)
             (y : B) (x : A)
Termination checking [Function.flip]
Trivially terminating: [Function.flip]
etaExpandClause
  body    =  f x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : A → Set b}
             (f : (x : A) → B x) (x : A)
Termination checking [Function._$_]
Trivially terminating: [Function._$_]
etaExpandClause
  body    =  λ f → f
  xs      =  [f]
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (f : A → B) (_ : A)
Termination checking [Function._$′_]
Trivially terminating: [Function._$′_]
etaExpandClause
  body    =  λ y x → force x y
  xs      =  [y, x]
  new tel =  {a : Level} {b : Level} {A : Set a} {B : A → Set b}
             (y : (x : A) → B x) (x : A)
Termination checking [Function._$!_]
Trivially terminating: [Function._$!_]
etaExpandClause
  body    =  _$!_
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (_ : A → B) (_ : A)
Termination checking [Function._$!′_]
Trivially terminating: [Function._$!′_]
etaExpandClause
  body    =  λ y x → x y
  xs      =  [y, x]
  new tel =  {a : Level} {b : Level} {A : Set a} {B : A → Set b}
             (y : A) (x : (a₁ : A) → B a₁)
Termination checking [Function._|>_]
Trivially terminating: [Function._|>_]
etaExpandClause
  body    =  λ y x → x y
  xs      =  [y, x]
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (y : A) (x : A → B)
Termination checking [Function._|>′_]
Trivially terminating: [Function._|>′_]
etaExpandClause
  body    =  f x y
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (x : A) (f : A → B → C) (y : B)
Termination checking [Function._⟨_⟩_]
Trivially terminating: [Function._⟨_⟩_]
etaExpandClause
  body    =  λ x y → x (y x) (y y)
  xs      =  [x, y]
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (_*_ : B → B → C) (f : A → B) (x : A)
             (y : A)
Termination checking [Function._on_]
Trivially terminating: [Function._on_]
etaExpandClause
  body    =  λ x y → x (g x y) (y x y)
  xs      =  [x, y]
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {e : Level} {A : Set a} {B : Set b} {C : Set c} {D : Set d}
             {E : Set e} (f : A → B → C) (_*_ : C → D → E) (g : A → B → D)
             (x : A) (y : B)
Termination checking [Function._-[_]-_]
Trivially terminating: [Function._-[_]-_]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} (A : Set a) (x : A)
Termination checking [Function._∋_]
Trivially terminating: [Function._∋_]
etaExpandClause
  body    =  A
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A)
Termination checking [Function.typeOf]
Trivially terminating: [Function.typeOf]
etaExpandClause
  body    =  f x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} (x : A)
             (B : A → Set b) (f : (x₁ : A) → B x₁)
Termination checking [Function.case_return_of_]
Trivially terminating: [Function.case_return_of_]
etaExpandClause
  body    =  f x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A) (f : A → B)
Termination checking [Function.case_of_]
Trivially terminating: [Function.case_of_]
  Checking Relation.Nullary (/Users/emily/src/agda-stdlib/src/Relation/Nullary.agda).
   Checking Data.Empty (/Users/emily/src/agda-stdlib/src/Data/Empty.agda).
Termination checking [Data.Empty.⊥]
Trivially terminating: [Data.Empty.⊥]
Termination checking [Data.Empty.⊥-elim]
Trivially terminating: [Data.Empty.⊥-elim]
   Checking Data.Empty.Irrelevant (/Users/emily/src/agda-stdlib/src/Data/Empty/Irrelevant.agda).
Termination checking [Data.Empty.Irrelevant.⊥-elim]
Trivially terminating: [Data.Empty.Irrelevant.⊥-elim]
etaExpandClause
  body    =  P → ⊥
  xs      =  []
  new tel =  {ℓ : Level} (P : Set ℓ)
Termination checking [Relation.Nullary.¬_]
Trivially terminating: [Relation.Nullary.¬_]
Termination checking [Relation.Nullary.Dec, Relation.Nullary.Dec.yes,
 Relation.Nullary.Dec.no]
Trivially terminating: [Relation.Nullary.Dec, Relation.Nullary.Dec.yes,
 Relation.Nullary.Dec.no]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A) .(x₁ : A)
etaExpandClause
  body    =  ⊥-elim _
  xs      =  []
  new tel =  {a : Level} {A : Set a} (¬p : ¬ A) .(x : A)
Termination checking [Relation.Nullary.recompute]
Trivially terminating: [Relation.Nullary.recompute]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A) .(x₁ : A)
etaExpandClause
  body    =  ⊥-elim _
  xs      =  []
  new tel =  {a : Level} {A : Set a} (¬p : ¬ A) .(x : A)
  Checking Relation.Nullary.Decidable (/Users/emily/src/agda-stdlib/src/Relation/Nullary/Decidable.agda).
   Checking Data.Bool.Base (/Users/emily/src/agda-stdlib/src/Data/Bool/Base.agda).
    Checking Data.Unit.Base (/Users/emily/src/agda-stdlib/src/Data/Unit/Base.agda).
    Checking Relation.Binary.Core (/Users/emily/src/agda-stdlib/src/Relation/Binary/Core.agda).
     Checking Data.Product (/Users/emily/src/agda-stdlib/src/Data/Product.agda).
etaExpandClause
  body    =  Σ
  xs      =  []
  new tel =  {a : Level} {b : Level} (A : Set a) (_ : A → Set b)
Termination checking [Data.Product.Σ-syntax]
Trivially terminating: [Data.Product.Σ-syntax]
etaExpandClause
  body    =  Σ x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} (_ : A → Set b)
Termination checking [Data.Product.∃]
Trivially terminating: [Data.Product.∃]
etaExpandClause
  body    =  ∃
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} (_ : A → Set b)
Termination checking [Data.Product.∃-syntax]
Trivially terminating: [Data.Product.∃-syntax]
etaExpandClause
  body    =  ¬ ∃ P
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} (P : A → Set b)
Termination checking [Data.Product.∄]
Trivially terminating: [Data.Product.∄]
etaExpandClause
  body    =  ∄
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} (_ : A → Set b)
Termination checking [Data.Product.∄-syntax]
Trivially terminating: [Data.Product.∄-syntax]
etaExpandClause
  body    =  ∃ (λ a → ∃ (C a))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : A → Set b} (C : (x : A) → B x → Set c)
Termination checking [Data.Product.∃₂]
Trivially terminating: [Data.Product.∃₂]
etaExpandClause
  body    =  Σ-syntax A (λ x → B)
  xs      =  []
  new tel =  {a : Level} {b : Level} (A : Set a) (B : Set b)
Termination checking [Data.Product._×_]
Trivially terminating: [Data.Product._×_]
etaExpandClause
  body    =  _,_
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (_ : A) (_ : B)
Termination checking [Data.Product._,′_]
Trivially terminating: [Data.Product._,′_]
etaExpandClause
  body    =  ∃ (λ x → B x × ({y : A} → B y → x ≈ y))
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ : Level} {A : Set a}
             (_≈_ : A → A → Set ℓ) (B : A → Set b)
Termination checking [Data.Product.∃!]
Trivially terminating: [Data.Product.∃!]
etaExpandClause
  body    =  x , y
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : A → Set b}
             {x : A} (y : B x)
Termination checking [Data.Product.-,_]
Trivially terminating: [Data.Product.-,_]
etaExpandClause
  body    =  f x , g x
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : A → Set b} {C : {x : A} → B x → Set c} (f : (x : A) → B x)
             (g : (x : A) → C (f x)) (x : A)
Termination checking [Data.Product.<_,_>]
Trivially terminating: [Data.Product.<_,_>]
etaExpandClause
  body    =  f x , g y
  xs      =  []
  new tel =  {a : Level} {b : Level} {p : Level} {q : Level}
             {A : Set a} {B : Set b} {P : A → Set p} {Q : B → Set q} (f : A → B)
             (g : {x : A} → P x → Q (f x)) (x : A) (y : P x)
Termination checking [Data.Product.map]
Trivially terminating: [Data.Product.map]
etaExpandClause
  body    =  map x (λ {.x} x → x)
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (f : A → B) (_ : A × C)
Termination checking [Data.Product.map₁]
Trivially terminating: [Data.Product.map₁]
etaExpandClause
  body    =  map (λ x → x) x
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : A → Set b} {C : A → Set c} (f : {x : A} → B x → C x)
             (_ : Σ A B)
Termination checking [Data.Product.map₂]
Trivially terminating: [Data.Product.map₂]
etaExpandClause
  body    =  (a₁ ∙ b₁) , (p₁ ∘ q₁)
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {p : Level}
             {q : Level} {r : Level} {A : Set a} {B : Set b} {C : Set c}
             {P : A → Set p} {Q : B → Set q} {R : C → Set r} (_∙_ : A → B → C)
             (_∘₁_ : {x : A} {y : B} → P x → Q y → R (x ∙ y)) (a₁ : A)
             (p₁ : P a₁) (b₁ : B) (q₁ : Q b₁)
Termination checking [Data.Product.zip]
Trivially terminating: [Data.Product.zip]
etaExpandClause
  body    =  y , x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A) (y : B)
Termination checking [Data.Product.swap]
Trivially terminating: [Data.Product.swap]
etaExpandClause
  body    =  λ x y → x x y × y x y
  xs      =  [x, y]
  new tel =  {a : Level} {b : Level} {i : Level} {j : Level}
             {A : Set a} {B : Set b} (f : A → B → Set i) (g : A → B → Set j)
             (x : A) (y : B)
Termination checking [Data.Product._-×-_]
Trivially terminating: [Data.Product._-×-_]
etaExpandClause
  body    =  λ x y → x x y , y x y
  xs      =  [x, y]
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} (f : A → B → C)
             (g : A → B → D) (x : A) (y : B)
Termination checking [Data.Product._-,-_]
Trivially terminating: [Data.Product._-,-_]
etaExpandClause
  body    =  f (x , y)
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : A → Set b} {C : Σ A B → Set c} (f : (p : Σ A B) → C p) (x : A)
             (y : B x)
Termination checking [Data.Product.curry]
Trivially terminating: [Data.Product.curry]
etaExpandClause
  body    =  λ f x y → f (x , y)
  xs      =  [f, x, y]
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (f : A × B → C) (x : A) (y : B)
Termination checking [Data.Product.curry′]
Trivially terminating: [Data.Product.curry′]
etaExpandClause
  body    =  f x y
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : A → Set b} {C : Σ A B → Set c}
             (f : (x : A) (y : B x) → C (x , y)) (x : A) (y : B x)
Termination checking [Data.Product.uncurry]
Trivially terminating: [Data.Product.uncurry]
etaExpandClause
  body    =  uncurry
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (_ : A → B → C) (_ : A × B)
Termination checking [Data.Product.uncurry′]
Trivially terminating: [Data.Product.uncurry′]
     Checking Data.Sum.Base (/Users/emily/src/agda-stdlib/src/Data/Sum/Base.agda).
Termination checking [Data.Sum.Base._⊎_, Data.Sum.Base._⊎_.inj₁, Data.Sum.Base._⊎_.inj₂]
Trivially terminating: [Data.Sum.Base._⊎_, Data.Sum.Base._⊎_.inj₁, Data.Sum.Base._⊎_.inj₂]
etaExpandClause
  body    =  f x
  xs      =  []
  new tel =  {a : Level.Level} {b : Level.Level} {c : Level.Level}
             {A : Set a} {B : Set b} {C : A ⊎ B → Set c}
             (f : (x : A) → C (inj₁ x)) (g : (x : B) → C (inj₂ x)) (x : A)
etaExpandClause
  body    =  g y
  xs      =  []
  new tel =  {a : Level.Level} {b : Level.Level} {c : Level.Level}
             {A : Set a} {B : Set b} {C : A ⊎ B → Set c}
             (f : (x : A) → C (inj₁ x)) (g : (x : B) → C (inj₂ x)) (y : B)
Termination checking [Data.Sum.Base.[_,_]]
Trivially terminating: [Data.Sum.Base.[_,_]]
etaExpandClause
  body    =  [_,_]
  xs      =  []
  new tel =  {a : Level.Level} {b : Level.Level} {c : Level.Level}
             {A : Set a} {B : Set b} {C : Set c} (_ : A → C) (_ : B → C)
             (_ : A ⊎ B)
Termination checking [Data.Sum.Base.[_,_]′]
Trivially terminating: [Data.Sum.Base.[_,_]′]
etaExpandClause
  body    =  inj₂ x
  xs      =  []
  new tel =  {a : Level.Level} {b : Level.Level} {A : Set a}
             {B : Set b} (x : A)
etaExpandClause
  body    =  inj₁ x
  xs      =  []
  new tel =  {a : Level.Level} {b : Level.Level} {A : Set a}
             {B : Set b} (x : B)
Termination checking [Data.Sum.Base.swap]
Trivially terminating: [Data.Sum.Base.swap]
etaExpandClause
  body    =  [ (λ x → inj₁ (g x)) , (λ x → inj₂ (x x)) ]
  xs      =  []
  new tel =  {a : Level.Level} {b : Level.Level} {c : Level.Level}
             {d : Level.Level} {A : Set a} {B : Set b} {C : Set c} {D : Set d}
             (f : A → C) (g : B → D) (_ : A ⊎ B)
Termination checking [Data.Sum.Base.map]
Trivially terminating: [Data.Sum.Base.map]
etaExpandClause
  body    =  map x (λ x → x)
  xs      =  []
  new tel =  {a : Level.Level} {b : Level.Level} {c : Level.Level}
             {A : Set a} {B : Set b} {C : Set c} (f : A → C) (_ : A ⊎ B)
Termination checking [Data.Sum.Base.map₁]
Trivially terminating: [Data.Sum.Base.map₁]
etaExpandClause
  body    =  map (λ x → x)
  xs      =  []
  new tel =  {a : Level.Level} {b : Level.Level} {d : Level.Level}
             {A : Set a} {B : Set b} {D : Set d} (_ : B → D) (_ : A ⊎ B)
Termination checking [Data.Sum.Base.map₂]
Trivially terminating: [Data.Sum.Base.map₂]
etaExpandClause
  body    =  λ x y → x x y ⊎ y x y
  xs      =  [x, y]
  new tel =  {a : Level.Level} {b : Level.Level} {c : Level.Level}
             {d : Level.Level} {A : Set a} {B : Set b} (f : A → B → Set c)
             (g : A → B → Set d) (x : A) (y : B)
Termination checking [Data.Sum.Base._-⊎-_]
Trivially terminating: [Data.Sum.Base._-⊎-_]
etaExpandClause
  body    =  A → B → Set ℓ
  xs      =  []
  new tel =  {a : Level} {b : Level} (A : Set a) (B : Set b)
             (ℓ : Level)
Termination checking [Relation.Binary.Core.REL]
Trivially terminating: [Relation.Binary.Core.REL]
etaExpandClause
  body    =  REL A A ℓ
  xs      =  []
  new tel =  {a : Level} (A : Set a) (ℓ : Level)
Termination checking [Relation.Binary.Core.Rel]
Trivially terminating: [Relation.Binary.Core.Rel]
etaExpandClause
  body    =  {i : A} {j : B} → P i j → Q i j
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (P : REL A B ℓ₁) (Q : REL A B ℓ₂)
Termination checking [Relation.Binary.Core._⇒_]
Trivially terminating: [Relation.Binary.Core._⇒_]
etaExpandClause
  body    =  P ⇒ (Q on f)
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (P : Rel A ℓ₁) (f : A → B) (Q : Rel B ℓ₂)
Termination checking [Relation.Binary.Core._=[_]⇒_]
Trivially terminating: [Relation.Binary.Core._=[_]⇒_]
etaExpandClause
  body    =  P =[ f ]⇒ Q
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (f : A → B) (P : Rel A ℓ₁) (Q : Rel B ℓ₂)
Termination checking [Relation.Binary.Core._Preserves_⟶_]
Trivially terminating: [Relation.Binary.Core._Preserves_⟶_]
etaExpandClause
  body    =  {x y : A} {u v : B} →
             P x y → Q u v → R (x + u) (y + v)
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {ℓ₁ : Level}
             {ℓ₂ : Level} {ℓ₃ : Level} {A : Set a} {B : Set b} {C : Set c}
             (_+_ : A → B → C) (P : Rel A ℓ₁) (Q : Rel B ℓ₂) (R : Rel C ℓ₃)
Termination checking [Relation.Binary.Core._Preserves₂_⟶_⟶_]
Trivially terminating: [Relation.Binary.Core._Preserves₂_⟶_⟶_]
etaExpandClause
  body    =  {x : A} → x ∼ x
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} (_∼_ : Rel A ℓ)
Termination checking [Relation.Binary.Core.Reflexive]
Trivially terminating: [Relation.Binary.Core.Reflexive]
etaExpandClause
  body    =  {x : A} {y : B} → x ≈ y → ¬ (x < y)
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (_≈_ : REL A B ℓ₁) (_<_ : REL A B ℓ₂)
Termination checking [Relation.Binary.Core.Irreflexive]
Trivially terminating: [Relation.Binary.Core.Irreflexive]
etaExpandClause
  body    =  P ⇒ (λ y x → Q x y)
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (P : REL A B ℓ₁) (Q : REL B A ℓ₂)
Termination checking [Relation.Binary.Core.Sym]
Trivially terminating: [Relation.Binary.Core.Sym]
etaExpandClause
  body    =  Sym _∼_ _∼_
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} (_∼_ : Rel A ℓ)
Termination checking [Relation.Binary.Core.Symmetric]
Trivially terminating: [Relation.Binary.Core.Symmetric]
etaExpandClause
  body    =  {i : A} {j : B} {k : C} → P i j → Q j k → R i k
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {ℓ₁ : Level}
             {ℓ₂ : Level} {ℓ₃ : Level} {A : Set a} {B : Set b} {C : Set c}
             (P : REL A B ℓ₁) (Q : REL B C ℓ₂) (R : REL A C ℓ₃)
Termination checking [Relation.Binary.Core.Trans]
Trivially terminating: [Relation.Binary.Core.Trans]
etaExpandClause
  body    =  {i : A} {j : B} {k : C} → Q j k → P i j → R i k
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {ℓ₁ : Level}
             {ℓ₂ : Level} {ℓ₃ : Level} {A : Set a} {B : Set b} {C : Set c}
             (P : REL A B ℓ₁) (Q : REL B C ℓ₂) (R : REL A C ℓ₃)
Termination checking [Relation.Binary.Core.TransFlip]
Trivially terminating: [Relation.Binary.Core.TransFlip]
etaExpandClause
  body    =  Trans _∼_ _∼_ _∼_
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} (_∼_ : Rel A ℓ)
Termination checking [Relation.Binary.Core.Transitive]
Trivially terminating: [Relation.Binary.Core.Transitive]
etaExpandClause
  body    =  {x y : A} → x ≤ y → y ≤ x → x ≈ y
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             (_≈_ : Rel A ℓ₁) (_≤_ : Rel A ℓ₂)
Termination checking [Relation.Binary.Core.Antisymmetric]
Trivially terminating: [Relation.Binary.Core.Antisymmetric]
etaExpandClause
  body    =  {x y : A} → x < y → ¬ (y < x)
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} (_<_ : Rel A ℓ)
Termination checking [Relation.Binary.Core.Asymmetric]
Trivially terminating: [Relation.Binary.Core.Asymmetric]
etaExpandClause
  body    =  (x y : A) → (x ∼ y) ⊎ (y ∼ x)
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} (_∼_ : Rel A ℓ)
Termination checking [Relation.Binary.Core.Total]
Trivially terminating: [Relation.Binary.Core.Total]
Termination checking [Relation.Binary.Core.Tri, Relation.Binary.Core.Tri.tri<,
 Relation.Binary.Core.Tri.tri≈, Relation.Binary.Core.Tri.tri>]
Trivially terminating: [Relation.Binary.Core.Tri, Relation.Binary.Core.Tri.tri<,
 Relation.Binary.Core.Tri.tri≈, Relation.Binary.Core.Tri.tri>]
etaExpandClause
  body    =  (x y : A) → Tri (x < y) (x ≈ y) ((_≈_ > _<_) x y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             (_≈_ : Rel A ℓ₁) (_<_ : Rel A ℓ₂)
etaExpandClause
  body    =  λ y x → x x y
  xs      =  [y, x]
  new tel =  {.a : Level} {.ℓ₁ : Level} {.ℓ₂ : Level} {.A : Set .a}
             (_≈_ : Rel .A .ℓ₁) (_<_ : Rel .A .ℓ₂) (y : .A) (x : .A)
Termination checking [Relation.Binary.Core.Trichotomous, Relation.Binary.Core._._>_]
Trivially terminating: [Relation.Binary.Core.Trichotomous]
etaExpandClause
  body    =  (x : A) → x ≤ ⊤
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} (_≤_ : Rel A ℓ)
             (⊤ : A)
Termination checking [Relation.Binary.Core.Maximum]
Trivially terminating: [Relation.Binary.Core.Maximum]
etaExpandClause
  body    =  Maximum (λ y x → x x y)
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} (_≤_ : Rel A ℓ)
             (_ : A)
Termination checking [Relation.Binary.Core.Minimum]
Trivially terminating: [Relation.Binary.Core.Minimum]
etaExpandClause
  body    =  {x y : A} → x ∼ y → P x → P y
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             (P : A → Set ℓ₁) (_∼_ : Rel A ℓ₂)
Termination checking [Relation.Binary.Core._Respects_]
Trivially terminating: [Relation.Binary.Core._Respects_]
etaExpandClause
  body    =  {x : A} → P x Respects _∼_
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             (P : Rel A ℓ₁) (_∼_ : Rel A ℓ₂)
Termination checking [Relation.Binary.Core._Respectsʳ_]
Trivially terminating: [Relation.Binary.Core._Respectsʳ_]
etaExpandClause
  body    =  {y : A} → (λ x → P x y) Respects _∼_
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             (P : Rel A ℓ₁) (_∼_ : Rel A ℓ₂)
Termination checking [Relation.Binary.Core._Respectsˡ_]
Trivially terminating: [Relation.Binary.Core._Respectsˡ_]
etaExpandClause
  body    =  (P Respectsʳ _∼_) × (P Respectsˡ _∼_)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             (P : Rel A ℓ₁) (_∼_ : Rel A ℓ₂)
Termination checking [Relation.Binary.Core._Respects₂_]
Trivially terminating: [Relation.Binary.Core._Respects₂_]
etaExpandClause
  body    =  (P : A → Set p) → P Respects _∼_
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {A : Set a} (_∼_ : Rel A ℓ₁)
             (p : Level)
Termination checking [Relation.Binary.Core.Substitutive]
Trivially terminating: [Relation.Binary.Core.Substitutive]
etaExpandClause
  body    =  (x : A) (y : B) → Dec (x ∼ y)
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ : Level} {A : Set a}
             {B : Set b} (_∼_ : REL A B ℓ)
Termination checking [Relation.Binary.Core.Decidable]
Trivially terminating: [Relation.Binary.Core.Decidable]
etaExpandClause
  body    =  {x : A} {y : B} (a b : x ∼ y) → a ≡ b
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ : Level} {A : Set a}
             {B : Set b} (_∼_ : REL A B ℓ)
Termination checking [Relation.Binary.Core.Irrelevant]
Trivially terminating: [Relation.Binary.Core.Irrelevant]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {x = x₁ : @3} {y = y₁ : @3} (proof₁ : @3 x₁ y₁)
etaExpandClause
  body    =  y
  xs      =  []
  new tel =  {x = x₁ : @3} {y = y₁ : @3} (proof₁ : @3 x₁ y₁)
etaExpandClause
  body    =  proof
  xs      =  []
  new tel =  {x = x₁ : @3} {y = y₁ : @3} (proof₁ : @3 x₁ y₁)
etaExpandClause
  body    =  sym
  xs      =  []
  new tel =  (refl₁ : Reflexive @1) (sym₁ : Symmetric @2)
             (trans₁ : Transitive @3) {x : refl₁}
etaExpandClause
  body    =  j
  xs      =  []
  new tel =  (refl₁ : Reflexive @1) (sym₁ : Symmetric @2)
             (trans₁ : Transitive @3) {i : refl₁} {j : refl₁} (_ : sym₁ i j)
etaExpandClause
  body    =  x₁
  xs      =  []
  new tel =  (refl₁ : Reflexive @1) (sym₁ : Symmetric @2)
             (trans₁ : Transitive @3) {i : refl₁} {j : refl₁} {k : refl₁}
             (_ : sym₁ i j) (_ : sym₁ j k)
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a}
             {_≈_ : A → A → Set ℓ} (: IsEquivalence _≈_) {i : A}
Termination checking [Relation.Binary.Core.IsEquivalence,
 Relation.Binary.Core.IsEquivalence.refl,
 Relation.Binary.Core.IsEquivalence.sym,
 Relation.Binary.Core.IsEquivalence.trans,
 Relation.Binary.Core.IsEquivalence.reflexive,
 Relation.Binary.Core.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.Core.IsEquivalence.reflexive]
    Checking Relation.Binary.PropositionalEquality.Core (/Users/emily/src/agda-stdlib/src/Relation/Binary/PropositionalEquality/Core.agda).
etaExpandClause
  body    =  ¬ x ≡ y
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A) (y : A)
Termination checking [Relation.Binary.PropositionalEquality.Core._≢_]
Trivially terminating: [Relation.Binary.PropositionalEquality.Core._≢_]
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : Level} {A : Set a} {i : A}
Termination checking [Relation.Binary.PropositionalEquality.Core._.sym]
Trivially terminating: [Relation.Binary.PropositionalEquality.Core._.sym]
etaExpandClause
  body    =  eq
  xs      =  []
  new tel =  {a : Level} {A : Set a} {i : A} {k : A} (eq : i ≡ k)
Termination checking [Relation.Binary.PropositionalEquality.Core._.trans]
Trivially terminating: [Relation.Binary.PropositionalEquality.Core._.trans]
etaExpandClause
  body    =  p₁
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {p : Level}
             (P : A → Set p) (p₁ : P x)
Termination checking [Relation.Binary.PropositionalEquality.Core._.subst]
Trivially terminating: [Relation.Binary.PropositionalEquality.Core._.subst]
etaExpandClause
  body    =  x∼y
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {ℓ : Level}
             (_∼_ : A → A → Set ℓ) {y : A} (x∼y : x ∼ y)
Termination checking [Relation.Binary.PropositionalEquality.Core._.respˡ]
Trivially terminating: [Relation.Binary.PropositionalEquality.Core._.respˡ]
etaExpandClause
  body    =  x∼y
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {ℓ : Level}
             (_∼_ : A → A → Set ℓ) {x = x₁ : A} (x∼y : x₁ ∼ x)
Termination checking [Relation.Binary.PropositionalEquality.Core._.respʳ]
Trivially terminating: [Relation.Binary.PropositionalEquality.Core._.respʳ]
etaExpandClause
  body    =  respʳ _∼_ , respˡ _∼_
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (_∼_ : Rel A ℓ)
Termination checking [Relation.Binary.PropositionalEquality.Core._.resp₂]
Trivially terminating: [Relation.Binary.PropositionalEquality.Core._.resp₂]
etaExpandClause
  body    =  record
             { refl = λ {.x} → refl ; sym = sym ; trans = trans }
  xs      =  []
  new tel =  {a : Level} {A : Set a}
Termination checking [Relation.Binary.PropositionalEquality.Core._.isEquivalence]
Trivially terminating: [Relation.Binary.PropositionalEquality.Core._.isEquivalence]
etaExpandClause
  body    =  false
  xs      =  []
  new tel = 
etaExpandClause
  body    =  true
  xs      =  []
  new tel = 
Termination checking [Data.Bool.Base.not]
Trivially terminating: [Data.Bool.Base.not]
etaExpandClause
  body    =  ⊤
  xs      =  []
  new tel = 
etaExpandClause
  body    =  ⊥
  xs      =  []
  new tel = 
Termination checking [Data.Bool.Base.T]
Trivially terminating: [Data.Bool.Base.T]
etaExpandClause
  body    =  t
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level} {A : Set a} (t : A)
             (f : A)
etaExpandClause
  body    =  f
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level} {A : Set a} (t : A)
             (f : A)
Termination checking [Data.Bool.Base.if_then_else_]
Trivially terminating: [Data.Bool.Base.if_then_else_]
etaExpandClause
  body    =  b
  xs      =  []
  new tel =  (b : Bool)
etaExpandClause
  body    =  false
  xs      =  []
  new tel =  (b : Bool)
Termination checking [Data.Bool.Base._∧_]
Trivially terminating: [Data.Bool.Base._∧_]
etaExpandClause
  body    =  true
  xs      =  []
  new tel =  (b : Bool)
etaExpandClause
  body    =  b
  xs      =  []
  new tel =  (b : Bool)
Termination checking [Data.Bool.Base._∨_]
Trivially terminating: [Data.Bool.Base._∨_]
etaExpandClause
  body    =  not b
  xs      =  []
  new tel =  (b : Bool)
etaExpandClause
  body    =  b
  xs      =  []
  new tel =  (b : Bool)
Termination checking [Data.Bool.Base._xor_]
Trivially terminating: [Data.Bool.Base._xor_]
etaExpandClause
  body    =  yes refl
  xs      =  []
  new tel = 
etaExpandClause
  body    =  yes refl
  xs      =  []
  new tel = 
etaExpandClause
  body    =  no (λ ())
  xs      =  []
  new tel = 
etaExpandClause
  body    =  no (λ ())
  xs      =  []
  new tel = 
Termination checking [Data.Bool.Base._≟_, Data.Bool.Base..absurdlambda,
 Data.Bool.Base..absurdlambda]
Trivially terminating: [Data.Bool.Base._≟_]
   Checking Data.Unit (/Users/emily/src/agda-stdlib/src/Data/Unit.agda).
    Checking Data.Sum (/Users/emily/src/agda-stdlib/src/Data/Sum.agda).
     Checking Data.Maybe.Base (/Users/emily/src/agda-stdlib/src/Data/Maybe/Base.agda).
      Checking Data.These (/Users/emily/src/agda-stdlib/src/Data/These.agda).
Termination checking [Data.These.These, Data.These.These.this, Data.These.These.that,
 Data.These.These.these]
Trivially terminating: [Data.These.These, Data.These.These.this, Data.These.These.that,
 Data.These.These.these]
etaExpandClause
  body    =  this (f a)
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {b₁ : Level} {b₂ : Level}
             {A₁ : Set a₁} {A₂ : Set a₂} {B₁ : Set b₁} {B₂ : Set b₂}
             (f : A₁ → A₂) (g : B₁ → B₂) (a : A₁)
etaExpandClause
  body    =  that (g b)
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {b₁ : Level} {b₂ : Level}
             {A₁ : Set a₁} {A₂ : Set a₂} {B₁ : Set b₁} {B₂ : Set b₂}
             (f : A₁ → A₂) (g : B₁ → B₂) (b : B₁)
etaExpandClause
  body    =  these (f a) (g b)
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {b₁ : Level} {b₂ : Level}
             {A₁ : Set a₁} {A₂ : Set a₂} {B₁ : Set b₁} {B₂ : Set b₂}
             (f : A₁ → A₂) (g : B₁ → B₂) (a : A₁) (b : B₁)
Termination checking [Data.These.map]
Trivially terminating: [Data.These.map]
etaExpandClause
  body    =  map x (λ x → x)
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {b : Level} {A₁ : Set a₁}
             {A₂ : Set a₂} {B : Set b} (f : A₁ → A₂) (_ : These A₁ B)
Termination checking [Data.These.map₁]
Trivially terminating: [Data.These.map₁]
etaExpandClause
  body    =  map (λ x → x)
  xs      =  []
  new tel =  {a : Level} {b₁ : Level} {b₂ : Level} {A : Set a}
             {B₁ : Set b₁} {B₂ : Set b₂} (g : B₁ → B₂) (_ : These A B₁)
Termination checking [Data.These.map₂]
Trivially terminating: [Data.These.map₂]
etaExpandClause
  body    =  l a₁
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             {c : Level} {C : Set c} (l : A → C) (r : B → C) (lr : A → B → C)
             (a₁ : A)
etaExpandClause
  body    =  r b₁
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             {c : Level} {C : Set c} (l : A → C) (r : B → C) (lr : A → B → C)
             (b₁ : B)
etaExpandClause
  body    =  lr a₁ b₁
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             {c : Level} {C : Set c} (l : A → C) (r : B → C) (lr : A → B → C)
             (a₁ : A) (b₁ : B)
Termination checking [Data.These._.fold]
Trivially terminating: [Data.These._.fold]
etaExpandClause
  body    =  fold that this (λ y x → these x y)
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (_ : These A B)
Termination checking [Data.These._.swap]
Trivially terminating: [Data.These._.swap]
etaExpandClause
  body    =  fold that this (λ y x → these x y)
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (_ : These A B)
etaExpandClause
  body    =  this (f₁ (these a₁ c₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (a₁ : A) (c₁ : C)
etaExpandClause
  body    =  these (f₁ (this a₁)) (g (that d₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (a₁ : A) (d₁ : D)
etaExpandClause
  body    =  these (f₁ (these a₁ c₁)) (g (that d₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (a₁ : A) (c₁ : C) (d₁ : D)
etaExpandClause
  body    =  these (f₁ (that c₁)) (g (this b₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (b₁ : B) (c₁ : C)
etaExpandClause
  body    =  that (g (these b₁ d₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (b₁ : B) (d₁ : D)
etaExpandClause
  body    =  these (f₁ (that c₁)) (g (these b₁ d₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (b₁ : B) (c₁ : C) (d₁ : D)
etaExpandClause
  body    =  these (f₁ (these a₁ c₁)) (g (this b₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (a₁ : A) (b₁ : B) (c₁ : C)
etaExpandClause
  body    =  these (f₁ (this a₁)) (g (these b₁ d₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (a₁ : A) (b₁ : B) (d₁ : D)
etaExpandClause
  body    =  these (f₁ (these a₁ c₁)) (g (these b₁ d₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} {e : Level}
             {f : Level} {E : Set e} {F : Set f} (f₁ : These A C → E)
             (g : These B D → F) (a₁ : A) (b₁ : B) (c₁ : C) (d₁ : D)
Termination checking [Data.These._.alignWith]
Trivially terminating: [Data.These._.alignWith]
etaExpandClause
  body    =  alignWith (λ x → x) (λ x → x)
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {d : Level}
             {A : Set a} {B : Set b} {C : Set c} {D : Set d} (_ : These A B)
             (_ : These C D)
Termination checking [Data.These._.align]
Trivially terminating: [Data.These._.align]
etaExpandClause
  body    =  fold (λ x → x) (λ x → x) (λ x _ → x)
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_ : These A A)
Termination checking [Data.These._.leftMost]
Trivially terminating: [Data.These._.leftMost]
etaExpandClause
  body    =  fold (λ x → x) (λ x → x) (λ y x → x)
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_ : These A A)
Termination checking [Data.These._.rightMost]
Trivially terminating: [Data.These._.rightMost]
etaExpandClause
  body    =  fold (λ x → x) (λ x → x)
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_ : A → A → A)
             (_ : These A A)
Termination checking [Data.These._.mergeThese]
Trivially terminating: [Data.These._.mergeThese]
Termination checking [Data.Maybe.Base.Maybe, Data.Maybe.Base.Maybe.just,
 Data.Maybe.Base.Maybe.nothing]
Trivially terminating: [Data.Maybe.Base.Maybe, Data.Maybe.Base.Maybe.just,
 Data.Maybe.Base.Maybe.nothing]
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : Level} {A : Set a} {a = a₁ : A}
Termination checking [Data.Maybe.Base.just-injective]
Trivially terminating: [Data.Maybe.Base.just-injective]
etaExpandClause
  body    =  just ⊤.tt
  xs      =  []
  new tel = 
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel = 
Termination checking [Data.Maybe.Base.boolToMaybe]
Trivially terminating: [Data.Maybe.Base.boolToMaybe]
etaExpandClause
  body    =  true
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A)
etaExpandClause
  body    =  false
  xs      =  []
  new tel =  {a : Level} {A : Set a}
Termination checking [Data.Maybe.Base.is-just]
Trivially terminating: [Data.Maybe.Base.is-just]
etaExpandClause
  body    =  λ x → not (is-just x)
  xs      =  [x]
  new tel =  {a : Level} {A : Set a} (x : Maybe A)
Termination checking [Data.Maybe.Base.is-nothing]
Trivially terminating: [Data.Maybe.Base.is-nothing]
etaExpandClause
  body    =  λ x → not (is-just x)
  xs      =  [x]
  new tel =  {a : Level} {A : Set a} (x : Maybe A)
etaExpandClause
  body    =  just x
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A)
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel =  {a : Level} {A : Set a} (¬p : ¬ A)
Termination checking [Data.Maybe.Base.decToMaybe]
Trivially terminating: [Data.Maybe.Base.decToMaybe]
etaExpandClause
  body    =  j x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a}
             {B : Maybe A → Set b} (j : (x : A) → B (just x)) (n : B nothing)
             (x : A)
etaExpandClause
  body    =  n
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a}
             {B : Maybe A → Set b} (j : (x : A) → B (just x)) (n : B nothing)
Termination checking [Data.Maybe.Base.maybe]
Trivially terminating: [Data.Maybe.Base.maybe]
etaExpandClause
  body    =  maybe
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (_ : A → B) (_ : B) (_ : Maybe A)
Termination checking [Data.Maybe.Base.maybe′]
Trivially terminating: [Data.Maybe.Base.maybe′]
etaExpandClause
  body    =  maybe′ (λ x → x)
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_ : A) (_ : Maybe A)
Termination checking [Data.Maybe.Base.fromMaybe]
Trivially terminating: [Data.Maybe.Base.fromMaybe]
etaExpandClause
  body    =  A
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A)
etaExpandClause
  body    =  Lift a ⊤
  xs      =  []
  new tel =  {a : Level} {A : Set a}
Termination checking [Data.Maybe.Base._.From-just]
Trivially terminating: [Data.Maybe.Base._.From-just]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A)
etaExpandClause
  body    =  lift ⊤.tt
  xs      =  []
  new tel =  {a : Level} {A : Set a}
Termination checking [Data.Maybe.Base._.from-just]
Trivially terminating: [Data.Maybe.Base._.from-just]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A)
etaExpandClause
  body    =  lift ⊤.tt
  xs      =  []
  new tel =  {a : Level} {A : Set a}
etaExpandClause
  body    =  maybe (λ x → just (x x)) nothing
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (f : A → B) (_ : Maybe A)
Termination checking [Data.Maybe.Base.map]
Trivially terminating: [Data.Maybe.Base.map]
Termination checking [Data.Maybe.Base.Any, Data.Maybe.Base.Any.just]
Trivially terminating: [Data.Maybe.Base.Any, Data.Maybe.Base.Any.just]
Termination checking [Data.Maybe.Base.All, Data.Maybe.Base.All.just,
 Data.Maybe.Base.All.nothing]
Trivially terminating: [Data.Maybe.Base.All, Data.Maybe.Base.All.just,
 Data.Maybe.Base.All.nothing]
etaExpandClause
  body    =  Any (λ _ → ⊤)
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_ : Maybe A)
Termination checking [Data.Maybe.Base.Is-just]
Trivially terminating: [Data.Maybe.Base.Is-just]
etaExpandClause
  body    =  Any (λ _ → ⊤)
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_ : Maybe A)
etaExpandClause
  body    =  All (λ _ → ⊥)
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_ : Maybe A)
Termination checking [Data.Maybe.Base.Is-nothing]
Trivially terminating: [Data.Maybe.Base.Is-nothing]
etaExpandClause
  body    =  All (λ _ → ⊥)
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_ : Maybe A)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {p : Level} {P : Set p} {x : P} (px : ⊤)
Termination checking [Data.Maybe.Base.to-witness]
Trivially terminating: [Data.Maybe.Base.to-witness]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {p : Level} {P : Set p} {x : P} (px : ⊤)
etaExpandClause
  body    =  p₁
  xs      =  []
  new tel =  {p : Level} {P : Set p} (p₁ : P)
             (x : T (is-just (just p₁)))
Termination checking [Data.Maybe.Base.to-witness-T]
Trivially terminating: [Data.Maybe.Base.to-witness-T]
etaExpandClause
  body    =  just (f (these a₁ b₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (f : These A B → C) (a₁ : A) (b₁ : B)
etaExpandClause
  body    =  just (f (this a₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (f : These A B → C) (a₁ : A)
etaExpandClause
  body    =  just (f (that b₁))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (f : These A B → C) (b₁ : B)
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (f : These A B → C)
Termination checking [Data.Maybe.Base._.alignWith]
Trivially terminating: [Data.Maybe.Base._.alignWith]
etaExpandClause
  body    =  just (f a₁ b₁)
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (f : A → B → C) (a₁ : A) (b₁ : B)
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {A : Set a}
             {B : Set b} {C : Set c} (x : A → B → C) (x₁ : Maybe A)
             (x₂ : Maybe B)
Termination checking [Data.Maybe.Base._.zipWith]
Trivially terminating: [Data.Maybe.Base._.zipWith]
etaExpandClause
  body    =  alignWith (λ x → x)
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (_ : Maybe A) (_ : Maybe B)
Termination checking [Data.Maybe.Base._.align]
Trivially terminating: [Data.Maybe.Base._.align]
etaExpandClause
  body    =  zipWith _,_
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (_ : Maybe A) (_ : Maybe B)
Termination checking [Data.Maybe.Base._.zip]
Trivially terminating: [Data.Maybe.Base._.zip]
etaExpandClause
  body    =  just x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A)
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (y : B)
Termination checking [Data.Sum._.isInj₁]
Trivially terminating: [Data.Sum._.isInj₁]
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A)
etaExpandClause
  body    =  just y
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (y : B)
Termination checking [Data.Sum._.isInj₂]
Trivially terminating: [Data.Sum._.isInj₂]
etaExpandClause
  body    =  A
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A)
etaExpandClause
  body    =  Lift a ⊤
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (y : B)
Termination checking [Data.Sum._.From-inj₁]
Trivially terminating: [Data.Sum._.From-inj₁]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A)
etaExpandClause
  body    =  lift tt
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (y : B)
Termination checking [Data.Sum._.from-inj₁]
Trivially terminating: [Data.Sum._.from-inj₁]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A)
etaExpandClause
  body    =  lift tt
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (y : B)
etaExpandClause
  body    =  Lift b ⊤
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A)
etaExpandClause
  body    =  B
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (y : B)
Termination checking [Data.Sum._.From-inj₂]
Trivially terminating: [Data.Sum._.From-inj₂]
etaExpandClause
  body    =  lift tt
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : B)
Termination checking [Data.Sum._.from-inj₂]
Trivially terminating: [Data.Sum._.from-inj₂]
etaExpandClause
  body    =  lift tt
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : A)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (x : B)
    Checking Relation.Binary (/Users/emily/src/agda-stdlib/src/Relation/Binary.agda).
     Checking Relation.Binary.Consequences (/Users/emily/src/agda-stdlib/src/Relation/Binary/Consequences.agda).
      Checking Relation.Unary (/Users/emily/src/agda-stdlib/src/Relation/Unary.agda).
etaExpandClause
  body    =  A → Set ℓ
  xs      =  []
  new tel =  {a : Level} (A : Set a) (ℓ : Level)
Termination checking [Relation.Unary.Pred]
Trivially terminating: [Relation.Unary.Pred]
etaExpandClause
  body    =  λ _ → ⊥
  xs      =  [_]
  new tel =  {a : Level} {A : Set a} (_ : A)
Termination checking [Relation.Unary._.∅]
Trivially terminating: [Relation.Unary._.∅]
etaExpandClause
  body    =  _≡_ x₁
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A) (_ : A)
Termination checking [Relation.Unary._.｛_｝]
Trivially terminating: [Relation.Unary._.｛_｝]
etaExpandClause
  body    =  λ _ → ⊤
  xs      =  [_]
  new tel =  {a : Level} {A : Set a} (_ : A)
Termination checking [Relation.Unary._.U]
Trivially terminating: [Relation.Unary._.U]
etaExpandClause
  body    =  P x
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (x : A)
             (P : Pred A ℓ)
Termination checking [Relation.Unary._._∈_]
Trivially terminating: [Relation.Unary._._∈_]
etaExpandClause
  body    =  ¬ P x
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (x : A)
             (P : Pred A ℓ)
Termination checking [Relation.Unary._._∉_]
Trivially terminating: [Relation.Unary._._∉_]
etaExpandClause
  body    =  {x : A} → P x → Q x
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊆_]
Trivially terminating: [Relation.Unary._._⊆_]
etaExpandClause
  body    =  Q ⊆ P
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊇_]
Trivially terminating: [Relation.Unary._._⊇_]
etaExpandClause
  body    =  ¬ P ⊆ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊈_]
Trivially terminating: [Relation.Unary._._⊈_]
etaExpandClause
  body    =  ¬ P ⊇ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊉_]
Trivially terminating: [Relation.Unary._._⊉_]
etaExpandClause
  body    =  P ⊆ Q × Q ⊈ P
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊂_]
Trivially terminating: [Relation.Unary._._⊂_]
etaExpandClause
  body    =  Q ⊂ P
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊃_]
Trivially terminating: [Relation.Unary._._⊃_]
etaExpandClause
  body    =  ¬ P ⊂ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊄_]
Trivially terminating: [Relation.Unary._._⊄_]
etaExpandClause
  body    =  ¬ P ⊃ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊅_]
Trivially terminating: [Relation.Unary._._⊅_]
etaExpandClause
  body    =  (x : A) → P x → Q x
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊆′_]
Trivially terminating: [Relation.Unary._._⊆′_]
etaExpandClause
  body    =  P ⊆′ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (Q : Pred A ℓ₁) (P : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊇′_]
Trivially terminating: [Relation.Unary._._⊇′_]
etaExpandClause
  body    =  ¬ P ⊆′ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊈′_]
Trivially terminating: [Relation.Unary._._⊈′_]
etaExpandClause
  body    =  ¬ P ⊇′ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊉′_]
Trivially terminating: [Relation.Unary._._⊉′_]
etaExpandClause
  body    =  P ⊆′ Q × Q ⊈′ P
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊂′_]
Trivially terminating: [Relation.Unary._._⊂′_]
etaExpandClause
  body    =  Q ⊂′ P
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊃′_]
Trivially terminating: [Relation.Unary._._⊃′_]
etaExpandClause
  body    =  ¬ P ⊂′ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊄′_]
Trivially terminating: [Relation.Unary._._⊄′_]
etaExpandClause
  body    =  ¬ P ⊃′ Q
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._⊅′_]
Trivially terminating: [Relation.Unary._._⊅′_]
etaExpandClause
  body    =  (x : A) → ¬ P x
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (P : Pred A ℓ)
Termination checking [Relation.Unary._.Empty]
Trivially terminating: [Relation.Unary._.Empty]
etaExpandClause
  body    =  ∃ P
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (P : Pred A ℓ)
Termination checking [Relation.Unary._.Satisfiable]
Trivially terminating: [Relation.Unary._.Satisfiable]
etaExpandClause
  body    =  (x : A) → P x
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (P : Pred A ℓ)
Termination checking [Relation.Unary._.Universal]
Trivially terminating: [Relation.Unary._.Universal]
etaExpandClause
  body    =  {x : A} → P x
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (P : Pred A ℓ)
Termination checking [Relation.Unary._.IUniversal]
Trivially terminating: [Relation.Unary._.IUniversal]
etaExpandClause
  body    =  (x : A) → Dec (P x)
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (P : Pred A ℓ)
Termination checking [Relation.Unary._.Decidable]
Trivially terminating: [Relation.Unary._.Decidable]
etaExpandClause
  body    =  {x : A} (a b : P x) → a ≡ b
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (P : Pred A ℓ)
Termination checking [Relation.Unary._.Irrelevant]
Trivially terminating: [Relation.Unary._.Irrelevant]
etaExpandClause
  body    =  λ x → ¬ x x
  xs      =  [x]
  new tel =  {a : Level} {A : Set a} {ℓ : Level} (P : Pred A ℓ)
             (x : A)
Termination checking [Relation.Unary._.∁]
Trivially terminating: [Relation.Unary._.∁]
etaExpandClause
  body    =  ∃ (λ x → P x × Q x)
  xs      =  []
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂)
Termination checking [Relation.Unary._._≬_]
Trivially terminating: [Relation.Unary._._≬_]
etaExpandClause
  body    =  λ x → Q x ⊎ x x
  xs      =  [x]
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂) (x : A)
Termination checking [Relation.Unary._._∪_]
Trivially terminating: [Relation.Unary._._∪_]
etaExpandClause
  body    =  λ x → Q x × x x
  xs      =  [x]
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂) (x : A)
Termination checking [Relation.Unary._._∩_]
Trivially terminating: [Relation.Unary._._∩_]
etaExpandClause
  body    =  λ x → Q x → x x
  xs      =  [x]
  new tel =  {a : Level} {A : Set a} {ℓ₁ : Level} {ℓ₂ : Level}
             (P : Pred A ℓ₁) (Q : Pred A ℓ₂) (x : A)
Termination checking [Relation.Unary._._⇒_]
Trivially terminating: [Relation.Unary._._⇒_]
etaExpandClause
  body    =  λ x → Σ-syntax P (λ i → x i x)
  xs      =  [x]
  new tel =  {a : Level} {A : Set a} {ℓ : Level} {i : Level}
             (I : Set i) (P : I → Pred A ℓ) (x : A)
Termination checking [Relation.Unary._.⋃]
Trivially terminating: [Relation.Unary._.⋃]
etaExpandClause
  body    =  λ x → (i : P) → x i x
  xs      =  [x]
  new tel =  {a : Level} {A : Set a} {ℓ : Level} {i : Level}
             (I : Set i) (P : I → Pred A ℓ) (x : A)
Termination checking [Relation.Unary._.⋂]
Trivially terminating: [Relation.Unary._.⋂]
etaExpandClause
  body    =  λ x → x (P x)
  xs      =  [x]
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             {ℓ : Level} (f : A → B) (P : Pred B ℓ) (x : A)
Termination checking [Relation.Unary._⊢_]
Trivially terminating: [Relation.Unary._⊢_]
etaExpandClause
  body    =  P x × Q y
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (P : Pred A ℓ₁) (Q : Pred B ℓ₂) (x : A)
             (y : B)
Termination checking [Relation.Unary._⟨×⟩_]
Trivially terminating: [Relation.Unary._⟨×⟩_]
etaExpandClause
  body    =  P x ⊎ Q y
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (P : Pred A ℓ₁) (Q : Pred B ℓ₂) (x : A)
             (y : B)
Termination checking [Relation.Unary._⟨⊙⟩_]
Trivially terminating: [Relation.Unary._⟨⊙⟩_]
etaExpandClause
  body    =  [ Q , x ]
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ : Level} {A : Set a}
             {B : Set b} (P : Pred A ℓ) (Q : Pred B ℓ) (_ : A ⊎ B)
Termination checking [Relation.Unary._⟨⊎⟩_]
Trivially terminating: [Relation.Unary._⟨⊎⟩_]
etaExpandClause
  body    =  P ⊆ (λ x → Q (f x))
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (P : Pred A ℓ₁) (Q : Pred B ℓ₂) (f : A → B)
Termination checking [Relation.Unary._⟨→⟩_]
Trivially terminating: [Relation.Unary._⟨→⟩_]
etaExpandClause
  body    =  f p
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : Set b} (P : Pred A ℓ₁) (Q : Pred B ℓ₂)
             {x : A × (A → B)} (p : P (proj₁ x)) (f : (P ⟨→⟩ Q) (proj₂ x))
Termination checking [Relation.Unary._⟨·⟩_]
Trivially terminating: [Relation.Unary._⟨·⟩_]
etaExpandClause
  body    =  λ x → x (swap x)
  xs      =  [x]
  new tel =  {a : Level} {b : Level} {ℓ : Level} {A : Set a}
             {B : Set b} (P : Pred (A × B) ℓ) (x : B × A)
Termination checking [Relation.Unary._~]
Trivially terminating: [Relation.Unary._~]
etaExpandClause
  body    =  ∃ (λ y → P (x , y) × Q (y , z))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {ℓ₁ : Level}
             {ℓ₂ : Level} {A : Set a} {B : Set b} {C : Set c}
             (P : Pred (A × B) ℓ₁) (Q : Pred (B × C) ℓ₂) (x : A) (z : C)
Termination checking [Relation.Unary._⟨∘⟩_]
Trivially terminating: [Relation.Unary._⟨∘⟩_]
etaExpandClause
  body    =  (λ x → Q (y , x)) ⊆ (λ x → P (x , x))
  xs      =  []
  new tel =  {a : Level} {b : Level} {c : Level} {ℓ₁ : Level}
             {ℓ₂ : Level} {A : Set a} {B : Set b} {C : Set c}
             (P : Pred (A × C) ℓ₁) (Q : Pred (B × C) ℓ₂) (x : A) (y : B)
Termination checking [Relation.Unary._//_]
Trivially terminating: [Relation.Unary._//_]
etaExpandClause
  body    =  λ x →
               ((λ x₁ → Q (swap x₁)) // (λ x₁ → x (swap x₁))) (swap x)
  xs      =  [x]
  new tel =  {a : Level} {b : Level} {c : Level} {ℓ₁ : Level}
             {ℓ₂ : Level} {A : Set a} {B : Set b} {C : Set c}
             (P : Pred (A × C) ℓ₁) (Q : Pred (A × B) ℓ₂) (x : B × C)
Termination checking [Relation.Unary._\\_]
Trivially terminating: [Relation.Unary._\\_]
etaExpandClause
  body    =  subst (λ x → P x y) x'∼x Px'y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ : .Agda.Primitive.Level} {p : .Agda.Primitive.Level} {A : Set a}
             {_∼_ : Rel A ℓ} (P : Rel A p) (subst : Substitutive _∼_ p) {y : A}
             {x : A} {y = y₁ : A} (x'∼x : x ∼ y₁) (Px'y : P x y)
Termination checking [Relation.Binary.Consequences._.subst⟶respˡ]
Trivially terminating: [Relation.Binary.Consequences._.subst⟶respˡ]
etaExpandClause
  body    =  subst (P x) y'∼y Pxy'
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ : .Agda.Primitive.Level} {p : .Agda.Primitive.Level} {A : Set a}
             {_∼_ : Rel A ℓ} (P : Rel A p) (subst : Substitutive _∼_ p) {x : A}
             {x = x₁ : A} {y : A} (y'∼y : x₁ ∼ y) (Pxy' : P x x₁)
Termination checking [Relation.Binary.Consequences._.subst⟶respʳ]
Trivially terminating: [Relation.Binary.Consequences._.subst⟶respʳ]
etaExpandClause
  body    =  (λ {.x} → subst (P .x)) ,
             (λ {.y} → subst (λ x → P x .y))
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ : .Agda.Primitive.Level} {p : .Agda.Primitive.Level} {A : Set a}
             {_∼_ : Rel A ℓ} (P : Rel A p) (subst : Substitutive _∼_ p)
Termination checking [Relation.Binary.Consequences._.subst⟶resp₂]
Trivially terminating: [Relation.Binary.Consequences._.subst⟶resp₂]
etaExpandClause
  body    =  ¬Px (resp (sym x∼y) Py)
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ : .Agda.Primitive.Level} {p : .Agda.Primitive.Level} {A : Set a}
             {∼ : Rel A ℓ} {P : A → Set p} (sym : Symmetric ∼)
             (resp : P Respects ∼) {x : A} {y : A} (x∼y : ∼ x y) (¬Px : ∁ P x)
             (Py : P y)
Termination checking [Relation.Binary.Consequences._.P-resp⟶¬P-resp]
Trivially terminating: [Relation.Binary.Consequences._.P-resp⟶¬P-resp]
etaExpandClause
  body    =  total⟶refl (respʳ , respˡ) sym total x≈y | total x y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂}
             (respʳ : _≤_ Respectsʳ _≈_) (respˡ : _≤_ Respectsˡ _≈_)
             (sym : Symmetric _≈_) (total : Total _≤_) {x : A} {y : A}
             (x≈y : x ≈ y)
etaExpandClause
  body    =  x∼y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_≤_ : A → A → Set ℓ₂}
             (total : (x y : A) → (x ≤ y) Data.Sum.⊎ (y ≤ x)) {x : A} {y : A}
             (x∼y : x ≤ y)
             (respʳ
              : {x = x₁ : A} {x = x₂ : A} {y = y₁ : A} →
                x₂ ≈ y₁ → x₁ ≤ x₂ → x₁ ≤ y₁)
             (respˡ
              : {y = y₁ : A} {x = x₁ : A} {y = y₂ : A} →
                x₁ ≈ y₂ → x₁ ≤ y₁ → y₂ ≤ y₁)
             (sym : {i j : A} → i ≈ j → j ≈ i) (x≈y : x ≈ y)
etaExpandClause
  body    =  respʳ x≈y (respˡ (sym x≈y) y∼x)
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_≤_ : A → A → Set ℓ₂}
             (total : (x y : A) → (x ≤ y) Data.Sum.⊎ (y ≤ x)) {x : A} {y : A}
             (y∼x : y ≤ x)
             (respʳ
              : {x = x₁ : A} {x = x₂ : A} {y = y₁ : A} →
                x₂ ≈ y₁ → x₁ ≤ x₂ → x₁ ≤ y₁)
             (respˡ
              : {y = y₁ : A} {x = x₁ : A} {y = y₂ : A} →
                x₁ ≈ y₂ → x₁ ≤ y₁ → y₂ ≤ y₁)
             (sym : {i j : A} → i ≈ j → j ≈ i) (x≈y : x ≈ y)
Termination checking [Relation.Binary.Consequences._.total⟶refl,
 Relation.Binary.Consequences._.with-106]
Trivially terminating: [Relation.Binary.Consequences._.total⟶refl]
etaExpandClause
  body    =  total+dec⟶dec refl antisym total _≟_ x y | total x y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (refl : _≈_ ⇒ _≤_)
             (antisym : Antisymmetric _≈_ _≤_) (total : Total _≤_)
             (_≟_ : Decidable _≈_) (x : A) (y : A)
etaExpandClause
  body    =  yes x≤y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_≤_ : A → A → Set ℓ₂}
             (total : (x y : A) → (x ≤ y) Data.Sum.⊎ (y ≤ x)) (x : A) (y : A)
             (x≤y : x ≤ y) (refl : {i j : A} → i ≈ j → i ≤ j)
             (antisym : {x = x₁ : A} {y = y₁ : A} → x₁ ≤ y₁ → y₁ ≤ x₁ → x₁ ≈ y₁)
             (_≟_ : (x₁ y₁ : A) → Relation.Nullary.Dec (x₁ ≈ y₁))
etaExpandClause
  body    =  .Relation.Binary.Consequences.with-156 total x y
             (inj₂ y≤x) refl antisym _≟_
             | x ≟ y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_≤_ : A → A → Set ℓ₂}
             (total : (x y : A) → (x ≤ y) Data.Sum.⊎ (y ≤ x)) (x : A) (y : A)
             (y≤x : y ≤ x) (refl : {i j : A} → i ≈ j → i ≤ j)
             (antisym : {x = x₁ : A} {y = y₁ : A} → x₁ ≤ y₁ → y₁ ≤ x₁ → x₁ ≈ y₁)
             (_≟_ : (x₁ y₁ : A) → Relation.Nullary.Dec (x₁ ≈ y₁))
etaExpandClause
  body    =  yes (refl x≈y)
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {A : Set a} {_≈_ : A → A → Set ℓ₁}
             (x : A) (y : A)
             (_≟_ : (x₁ y₁ : A) → Relation.Nullary.Dec (x₁ ≈ y₁)) (x≈y : x ≈ y)
             {ℓ₂ : .Agda.Primitive.Level} {_≤_ : A → A → Set ℓ₂}
             (total : (x₁ y₁ : A) → (x₁ ≤ y₁) Data.Sum.⊎ (y₁ ≤ x₁))
             (y≤x : y ≤ x) (refl : {i j : A} → i ≈ j → i ≤ j)
             (antisym : {x = x₁ : A} {y = y₁ : A} → x₁ ≤ y₁ → y₁ ≤ x₁ → x₁ ≈ y₁)
etaExpandClause
  body    =  no (λ x≤y → x≉y (antisym x≤y y≤x))
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {A : Set a} {_≈_ : A → A → Set ℓ₁}
             (x : A) (y : A)
             (_≟_ : (x₁ y₁ : A) → Relation.Nullary.Dec (x₁ ≈ y₁))
             (x≉y : Relation.Nullary.¬ (x ≈ y)) {ℓ₂ : .Agda.Primitive.Level}
             {_≤_ : A → A → Set ℓ₂}
             (total : (x₁ y₁ : A) → (x₁ ≤ y₁) Data.Sum.⊎ (y₁ ≤ x₁))
             (y≤x : y ≤ x) (refl : {i j : A} → i ≈ j → i ≤ j)
             (antisym : {x = x₁ : A} {y = y₁ : A} → x₁ ≤ y₁ → y₁ ≤ x₁ → x₁ ≈ y₁)
Termination checking [Relation.Binary.Consequences._.total+dec⟶dec,
 Relation.Binary.Consequences._.with-156,
 Relation.Binary.Consequences._.with-188]
Trivially terminating: [Relation.Binary.Consequences._.total+dec⟶dec]
etaExpandClause
  body    =  irrefl refl (trans x<y y<x)
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (refl : Reflexive _≈_) (trans : Transitive _<_)
             (irrefl : Irreflexive _≈_ _<_) {x : A} {y : A} (x<y : x < y)
             (y<x : y < x)
Termination checking [Relation.Binary.Consequences._.trans∧irr⟶asym]
Trivially terminating: [Relation.Binary.Consequences._.trans∧irr⟶asym]
etaExpandClause
  body    =  irrefl (antisym x<y y<x) x<y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (irrefl : Irreflexive _≈_ _<_) (antisym : Antisymmetric _≈_ _<_)
             {x : A} {y : A} (x<y : x < y) (y<x : y < x)
Termination checking [Relation.Binary.Consequences._.irr∧antisym⟶asym]
Trivially terminating: [Relation.Binary.Consequences._.irr∧antisym⟶asym]
etaExpandClause
  body    =  ⊥-elim (asym x<y y<x)
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (asym : Asymmetric _<_) {x : A} {y : A} (x<y : x < y) (y<x : y < x)
Termination checking [Relation.Binary.Consequences._.asym⟶antisym]
Trivially terminating: [Relation.Binary.Consequences._.asym⟶antisym]
etaExpandClause
  body    =  asym x<y (respʳ (sym x≈y) (respˡ x≈y x<y))
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (respʳ : _<_ Respectsʳ _≈_) (respˡ : _<_ Respectsˡ _≈_)
             (sym : Symmetric _≈_) (asym : Asymmetric _<_) {x : A} {y : A}
             (x≈y : x ≈ y) (x<y : x < y)
Termination checking [Relation.Binary.Consequences._.asym⟶irr]
Trivially terminating: [Relation.Binary.Consequences._.asym⟶irr]
etaExpandClause
  body    =  tri⟶asym tri x<y x>y | tri x y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (tri : Trichotomous _≈_ _<_) {x : A} {y : A} (x<y : x < y)
             (x>y : y < x)
etaExpandClause
  body    =  x≯y x>y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {y : A}
             (a₁ : x < y) (¬b : Relation.Nullary.¬ (x ≈ y))
             (x≯y : Relation.Nullary.¬ (y < x)) (x<y : x < y) (x>y : y < x)
etaExpandClause
  body    =  x≯y x>y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {y : A}
             (¬a : Relation.Nullary.¬ (x < y)) (b : x ≈ y)
             (x≯y : Relation.Nullary.¬ (y < x)) (x<y : x < y) (x>y : y < x)
etaExpandClause
  body    =  x≮y x<y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {y : A}
             (x≮y : Relation.Nullary.¬ (x < y))
             (¬b : Relation.Nullary.¬ (x ≈ y)) (c : y < x) (x<y : x < y)
             (x>y : y < x)
Termination checking [Relation.Binary.Consequences._.tri⟶asym,
 Relation.Binary.Consequences._.with-302]
Trivially terminating: [Relation.Binary.Consequences._.tri⟶asym]
etaExpandClause
  body    =  tri⟶irr compare x≈y x<y | compare x y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (compare : Trichotomous _≈_ _<_) {x : A} {y : A} (x≈y : x ≈ y)
             (x<y : x < y)
etaExpandClause
  body    =  x≉y x≈y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {y : A}
             (a₁ : x < y) (x≉y : Relation.Nullary.¬ (x ≈ y))
             (y≮x : Relation.Nullary.¬ (y < x)) (x≈y : x ≈ y) (x<y : x < y)
etaExpandClause
  body    =  x≉y x≈y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {y : A}
             (x≮y : Relation.Nullary.¬ (x < y))
             (x≉y : Relation.Nullary.¬ (x ≈ y)) (y<x : y < x) (x≈y : x ≈ y)
             (x<y : x < y)
etaExpandClause
  body    =  x≮y x<y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {y : A}
             (x≮y : Relation.Nullary.¬ (x < y)) (b : x ≈ y)
             (y≮x : Relation.Nullary.¬ (y < x)) (x≈y : x ≈ y) (x<y : x < y)
Termination checking [Relation.Binary.Consequences._.tri⟶irr,
 Relation.Binary.Consequences._.with-354]
Trivially terminating: [Relation.Binary.Consequences._.tri⟶irr]
etaExpandClause
  body    =  tri⟶dec≈ compare x y | compare x y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (compare : Trichotomous _≈_ _<_) (x : A) (y : A)
etaExpandClause
  body    =  no x≉y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) (x : A) (y : A)
             (a₁ : x < y) (x≉y : Relation.Nullary.¬ (x ≈ y))
             (¬c : Relation.Nullary.¬ (y < x))
etaExpandClause
  body    =  yes x≈y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) (x : A) (y : A)
             (¬a : Relation.Nullary.¬ (x < y)) (x≈y : x ≈ y)
             (¬c : Relation.Nullary.¬ (y < x))
etaExpandClause
  body    =  no x≉y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) (x : A) (y : A)
             (¬a : Relation.Nullary.¬ (x < y))
             (x≉y : Relation.Nullary.¬ (x ≈ y)) (c : y < x)
Termination checking [Relation.Binary.Consequences._.tri⟶dec≈,
 Relation.Binary.Consequences._.with-410]
Trivially terminating: [Relation.Binary.Consequences._.tri⟶dec≈]
etaExpandClause
  body    =  tri⟶dec< compare x y | compare x y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (compare : Trichotomous _≈_ _<_) (x : A) (y : A)
etaExpandClause
  body    =  yes x<y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) (x : A) (y : A)
             (x<y : x < y) (¬b : Relation.Nullary.¬ (x ≈ y))
             (¬c : Relation.Nullary.¬ (y < x))
etaExpandClause
  body    =  no x≮y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) (x : A) (y : A)
             (x≮y : Relation.Nullary.¬ (x < y)) (b : x ≈ y)
             (¬c : Relation.Nullary.¬ (y < x))
etaExpandClause
  body    =  no x≮y
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (compare : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) (x : A) (y : A)
             (x≮y : Relation.Nullary.¬ (x < y))
             (¬b : Relation.Nullary.¬ (x ≈ y)) (c : y < x)
Termination checking [Relation.Binary.Consequences._.tri⟶dec<,
 Relation.Binary.Consequences._.with-446]
Trivially terminating: [Relation.Binary.Consequences._.tri⟶dec<]
etaExpandClause
  body    =  trans∧tri⟶respʳ≈ sym ≈-tr <-tr tri y≈z x<y | tri x z
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (sym : Symmetric _≈_)
             (≈-tr : Transitive _≈_) (<-tr : Transitive _<_)
             (tri : Trichotomous _≈_ _<_) {x : A} {y : A} {z : A} (y≈z : y ≈ z)
             (x<y : x < y)
etaExpandClause
  body    =  x<z
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {z : A}
             (x<z : x < z) (¬b : Relation.Nullary.¬ (x ≈ z))
             (¬c : Relation.Nullary.¬ (z < x)) (sym : {i j : A} → i ≈ j → j ≈ i)
             (≈-tr : {i j k : A} → i ≈ j → j ≈ k → i ≈ k)
             (<-tr : {i j k : A} → i < j → j < k → i < k) {y : A} (y≈z : y ≈ z)
             (x<y : x < y)
etaExpandClause
  body    =  ⊥-elim (tri⟶irr tri (≈-tr x≈z (sym y≈z)) x<y)
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {z : A}
             (¬a : Relation.Nullary.¬ (x < z)) (x≈z : x ≈ z)
             (¬c : Relation.Nullary.¬ (z < x)) (sym : {i j : A} → i ≈ j → j ≈ i)
             (≈-tr : {i j k : A} → i ≈ j → j ≈ k → i ≈ k)
             (<-tr : {i j k : A} → i < j → j < k → i < k) {y : A} (y≈z : y ≈ z)
             (x<y : x < y)
etaExpandClause
  body    =  ⊥-elim (tri⟶irr tri (sym y≈z) (<-tr z<x x<y))
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {x : A} {z : A}
             (¬a : Relation.Nullary.¬ (x < z)) (¬b : Relation.Nullary.¬ (x ≈ z))
             (z<x : z < x) (sym : {i j : A} → i ≈ j → j ≈ i)
             (≈-tr : {i j k : A} → i ≈ j → j ≈ k → i ≈ k)
             (<-tr : {i j k : A} → i < j → j < k → i < k) {y : A} (y≈z : y ≈ z)
             (x<y : x < y)
Termination checking [Relation.Binary.Consequences._.trans∧tri⟶respʳ≈,
 Relation.Binary.Consequences._.with-494]
Trivially terminating: [Relation.Binary.Consequences._.trans∧tri⟶respʳ≈]
etaExpandClause
  body    =  trans∧tri⟶respˡ≈ ≈-tr <-tr tri x≈y x<z | tri y z
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (≈-tr : Transitive _≈_) (<-tr : Transitive _<_)
             (tri : Trichotomous _≈_ _<_) {z : A} {x : A} {y : A} (x≈y : x ≈ y)
             (x<z : x < z)
etaExpandClause
  body    =  y<z
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {z : A} {y : A}
             (y<z : y < z) (¬b : Relation.Nullary.¬ (y ≈ z))
             (¬c : Relation.Nullary.¬ (z < y))
             (≈-tr : {i j k : A} → i ≈ j → j ≈ k → i ≈ k)
             (<-tr : {i j k : A} → i < j → j < k → i < k) {x : A} (x≈y : x ≈ y)
             (x<z : x < z)
etaExpandClause
  body    =  ⊥-elim (tri⟶irr tri (≈-tr x≈y y≈z) x<z)
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {z : A} {y : A}
             (¬a : Relation.Nullary.¬ (y < z)) (y≈z : y ≈ z)
             (¬c : Relation.Nullary.¬ (z < y))
             (≈-tr : {i j k : A} → i ≈ j → j ≈ k → i ≈ k)
             (<-tr : {i j k : A} → i < j → j < k → i < k) {x : A} (x≈y : x ≈ y)
             (x<z : x < z)
etaExpandClause
  body    =  ⊥-elim (tri⟶irr tri x≈y (<-tr x<z z<y))
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : A → A → Set ℓ₁} {_<_ : A → A → Set ℓ₂}
             (tri : (x y : A) → Tri (x < y) (x ≈ y) (y < x)) {z : A} {y : A}
             (¬a : Relation.Nullary.¬ (y < z)) (¬b : Relation.Nullary.¬ (y ≈ z))
             (z<y : z < y) (≈-tr : {i j k : A} → i ≈ j → j ≈ k → i ≈ k)
             (<-tr : {i j k : A} → i < j → j < k → i < k) {x : A} (x≈y : x ≈ y)
             (x<z : x < z)
Termination checking [Relation.Binary.Consequences._.trans∧tri⟶respˡ≈,
 Relation.Binary.Consequences._.with-574]
Trivially terminating: [Relation.Binary.Consequences._.trans∧tri⟶respˡ≈]
etaExpandClause
  body    =  trans∧tri⟶respʳ≈ sym ≈-tr <-tr tri ,
             trans∧tri⟶respˡ≈ ≈-tr <-tr tri
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {A : Set a} {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (sym : Symmetric _≈_)
             (≈-tr : Transitive _≈_) (<-tr : Transitive _<_)
             (tri : Trichotomous _≈_ _<_)
Termination checking [Relation.Binary.Consequences._.trans∧tri⟶resp≈]
Trivially terminating: [Relation.Binary.Consequences._.trans∧tri⟶resp≈]
etaExpandClause
  body    =  nonEmpty (f (NonEmpty.proof x))
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level}
             {b : .Agda.Primitive.Level} {p : .Agda.Primitive.Level}
             {q : .Agda.Primitive.Level} {A : Set a} {B : Set b} {P : REL A B p}
             {Q : REL A B q} (f : P ⇒ Q) (x : NonEmpty P)
Termination checking [Relation.Binary.Consequences._.map-NonEmpty]
Trivially terminating: [Relation.Binary.Consequences._.map-NonEmpty]
etaExpandClause
  body    =  IsEquivalence.trans isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (r : IsPreorder _≈_ _∼_) {i : A}
             {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsEquivalence.sym isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (r : IsPreorder _≈_ _∼_) {i : A}
             {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsEquivalence.reflexive isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (r : IsPreorder _≈_ _∼_) {i : A}
             {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsEquivalence.refl isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (r : IsPreorder _≈_ _∼_) {x : A}
etaExpandClause
  body    =  isEquivalence
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (reflexive₁ : @3 ⇒ @2) (trans₁ : Transitive @3)
etaExpandClause
  body    =  j
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (reflexive₁ : @3 ⇒ @2) (trans₁ : Transitive @3) {i : @3} {j : @4}
             (_ : isEquivalence₁ i j)
etaExpandClause
  body    =  x₁
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (reflexive₁ : @3 ⇒ @2) (trans₁ : Transitive @3) {i : @3} {j : @4}
             {k : @5} (_ : reflexive₁ i j) (_ : reflexive₁ j k)
etaExpandClause
  body    =  IsEquivalence.refl (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (r : IsPreorder _≈_ _∼_) {x : A}
etaExpandClause
  body    =  IsEquivalence.reflexive (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (r : IsPreorder _≈_ _∼_) {i : A}
             {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsEquivalence.sym (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (r : IsPreorder _≈_ _∼_) {i : A}
             {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsEquivalence.trans (isEquivalence x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (r : IsPreorder _≈_ _∼_) {i : A}
             {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  reflexive (IsEquivalence.refl (isEquivalence))
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (: IsPreorder _≈_ _∼_) {x : A}
etaExpandClause
  body    =  trans
             (reflexive (IsEquivalence.sym (isEquivalence) x≈y)) x∼z
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (: IsPreorder _≈_ _∼_) {y : A}
             {x : A} {y = y₁ : A} (x≈y : x ≈ y₁) (x∼z : x ∼ y)
etaExpandClause
  body    =  trans z∼x (reflexive x≈y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (: IsPreorder _≈_ _∼_) {x : A}
             {x = x₁ : A} {y : A} (x≈y : x₁ ≈ y) (z∼x : x ∼ x₁)
etaExpandClause
  body    =  ∼-respʳ-≈ , ∼-respˡ-≈
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (: IsPreorder _≈_ _∼_)
Termination checking [Relation.Binary.IsPreorder, Relation.Binary.recCon-NOT-PRINTED,
 Relation.Binary.IsPreorder.isEquivalence,
 Relation.Binary.IsPreorder.reflexive,
 Relation.Binary.IsPreorder.trans,
 Relation.Binary.IsPreorder.Eq.refl,
 Relation.Binary.IsPreorder.Eq.reflexive,
 Relation.Binary.IsPreorder.Eq.sym,
 Relation.Binary.IsPreorder.Eq.trans,
 Relation.Binary.IsPreorder.refl,
 Relation.Binary.IsPreorder.∼-respˡ-≈,
 Relation.Binary.IsPreorder.∼-respʳ-≈,
 Relation.Binary.IsPreorder.∼-resp-≈]
Trivially terminating: [Relation.Binary.IsPreorder.refl]
Termination checking [Relation.Binary.IsPreorder, Relation.Binary.recCon-NOT-PRINTED,
 Relation.Binary.IsPreorder.isEquivalence,
 Relation.Binary.IsPreorder.reflexive,
 Relation.Binary.IsPreorder.trans,
 Relation.Binary.IsPreorder.Eq.refl,
 Relation.Binary.IsPreorder.Eq.reflexive,
 Relation.Binary.IsPreorder.Eq.sym,
 Relation.Binary.IsPreorder.Eq.trans,
 Relation.Binary.IsPreorder.refl,
 Relation.Binary.IsPreorder.∼-respˡ-≈,
 Relation.Binary.IsPreorder.∼-respʳ-≈,
 Relation.Binary.IsPreorder.∼-resp-≈]
Trivially terminating: [Relation.Binary.IsPreorder.∼-respˡ-≈]
Termination checking [Relation.Binary.IsPreorder, Relation.Binary.recCon-NOT-PRINTED,
 Relation.Binary.IsPreorder.isEquivalence,
 Relation.Binary.IsPreorder.reflexive,
 Relation.Binary.IsPreorder.trans,
 Relation.Binary.IsPreorder.Eq.refl,
 Relation.Binary.IsPreorder.Eq.reflexive,
 Relation.Binary.IsPreorder.Eq.sym,
 Relation.Binary.IsPreorder.Eq.trans,
 Relation.Binary.IsPreorder.refl,
 Relation.Binary.IsPreorder.∼-respˡ-≈,
 Relation.Binary.IsPreorder.∼-respʳ-≈,
 Relation.Binary.IsPreorder.∼-resp-≈]
Trivially terminating: [Relation.Binary.IsPreorder.∼-respʳ-≈]
Termination checking [Relation.Binary.IsPreorder, Relation.Binary.recCon-NOT-PRINTED,
 Relation.Binary.IsPreorder.isEquivalence,
 Relation.Binary.IsPreorder.reflexive,
 Relation.Binary.IsPreorder.trans,
 Relation.Binary.IsPreorder.Eq.refl,
 Relation.Binary.IsPreorder.Eq.reflexive,
 Relation.Binary.IsPreorder.Eq.sym,
 Relation.Binary.IsPreorder.Eq.trans,
 Relation.Binary.IsPreorder.refl,
 Relation.Binary.IsPreorder.∼-respˡ-≈,
 Relation.Binary.IsPreorder.∼-respʳ-≈,
 Relation.Binary.IsPreorder.∼-resp-≈]
Trivially terminating: [Relation.Binary.IsPreorder.∼-resp-≈]
etaExpandClause
  body    =  IsPreorder.Eq.trans isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} {k : Carrier}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsPreorder.Eq.sym isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsPreorder.Eq.reflexive isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≡ j)
etaExpandClause
  body    =  IsPreorder.Eq.refl isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsPreorder.∼-respˡ-≈ isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {y : Carrier} {x : Carrier}
             {y = y₁ : Carrier} (_ : x ≈ y₁) (_ : x ∼ y)
etaExpandClause
  body    =  IsPreorder.∼-respʳ-≈ isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {x : Carrier} {x = x₁ : Carrier}
             {y : Carrier} (_ : x₁ ≈ y) (_ : x ∼ x₁)
etaExpandClause
  body    =  IsPreorder.∼-resp-≈ isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPreorder.trans isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} {k : Carrier}
             (_ : i ∼ j) (_ : j ∼ k)
etaExpandClause
  body    =  IsPreorder.reflexive isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsPreorder.refl isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsPreorder.isEquivalence isPreorder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_∼₁_ : Rel Carrier₁ @3) (isPreorder₁ : IsPreorder _≈₁_ _∼₁_)
etaExpandClause
  body    =  isPreorder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_∼₁_ : Rel Carrier₁ @3) (isPreorder₁ : IsPreorder _≈₁_ _∼₁_)
             (_ : Carrier isPreorder₁) (_ : Carrier isPreorder₁)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_∼₁_ : Rel Carrier₁ @3) (isPreorder₁ : IsPreorder _≈₁_ _∼₁_)
             (_ : Carrier isPreorder₁) (_ : Carrier isPreorder₁)
etaExpandClause
  body    =  isPreorder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_∼₁_ : Rel Carrier₁ @3) (isPreorder₁ : IsPreorder _≈₁_ _∼₁_)
etaExpandClause
  body    =  IsPreorder.isEquivalence (isPreorder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPreorder.refl (isPreorder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsPreorder.reflexive (isPreorder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsPreorder.trans (isPreorder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ∼ i) j) (_ : (r ∼ j) k)
etaExpandClause
  body    =  IsPreorder.∼-resp-≈ (isPreorder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPreorder.∼-respʳ-≈ (isPreorder x₃)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {x : Carrier r} {x = x₁ : Carrier r}
             {y : Carrier r} (_ : (r ≈ x₁) y) (_ : (r ∼ x) x₁)
etaExpandClause
  body    =  IsPreorder.∼-respˡ-≈ (isPreorder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {y : Carrier r} {x : Carrier r}
             {y = y₁ : Carrier r} (_ : (r ≈ x) y₁) (_ : (r ∼ x) y)
etaExpandClause
  body    =  IsPreorder.Eq.refl (isPreorder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsPreorder.Eq.reflexive (isPreorder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r} (_ : i ≡ j)
etaExpandClause
  body    =  IsPreorder.Eq.sym (isPreorder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsPreorder.Eq.trans (isPreorder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Preorder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≈ i) j) (_ : (r ≈ j) k)
etaExpandClause
  body    =  IsEquivalence.trans isEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : Setoid c ℓ) {i : Carrier}
             {j : Carrier} {k : Carrier} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsEquivalence.sym isEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : Setoid c ℓ) {i : Carrier}
             {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsEquivalence.reflexive isEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : Setoid c ℓ) {i : Carrier}
             {j : Carrier} (_ : i ≡ j)
etaExpandClause
  body    =  IsEquivalence.refl isEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : Setoid c ℓ) {x : Carrier}
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @2) (_≈₁_ : Rel Carrier₁ @2)
             (isEquivalence₁ : IsEquivalence _≈₁_)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @2) (_≈₁_ : Rel Carrier₁ @2)
             (isEquivalence₁ : IsEquivalence _≈₁_) (_ : Carrier isEquivalence₁)
             (_ : Carrier isEquivalence₁)
etaExpandClause
  body    =  isEquivalence
  xs      =  []
  new tel =  (Carrier₁ : Set @2) (_≈₁_ : Rel Carrier₁ @2)
             (isEquivalence₁ : IsEquivalence _≈₁_)
etaExpandClause
  body    =  IsEquivalence.refl (isEquivalence x)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : Setoid c ℓ)
             {x : Carrier r}
etaExpandClause
  body    =  IsEquivalence.reflexive (isEquivalence x)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : Setoid c ℓ)
             {i : Carrier r} {j : Carrier r} (_ : i ≡ j)
etaExpandClause
  body    =  IsEquivalence.sym (isEquivalence x)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : Setoid c ℓ)
             {i : Carrier r} {j : Carrier r} (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsEquivalence.trans (isEquivalence x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : Setoid c ℓ)
             {i : Carrier r} {j : Carrier r} {k : Carrier r} (_ : (r ≈ i) j)
             (_ : (r ≈ j) k)
etaExpandClause
  body    =  record
             { isEquivalence = PropEq.isEquivalence
             ; reflexive = IsEquivalence.reflexive (isEquivalence)
             ; trans = IsEquivalence.trans (isEquivalence)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (: Setoid c ℓ)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≡_
             ; _∼_ = _≈_
             ; isPreorder = isPreorder
             }
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (: Setoid c ℓ)
Termination checking [Relation.Binary.Setoid, Relation.Binary.Setoid.Carrier,
 Relation.Binary.Setoid._≈_, Relation.Binary.Setoid.isEquivalence,
 Relation.Binary.Setoid._.refl, Relation.Binary.Setoid._.reflexive,
 Relation.Binary.Setoid._.sym, Relation.Binary.Setoid._.trans,
 Relation.Binary.Setoid.isPreorder, Relation.Binary.Setoid.preorder,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.Setoid.isPreorder]
Termination checking [Relation.Binary.Setoid, Relation.Binary.Setoid.Carrier,
 Relation.Binary.Setoid._≈_, Relation.Binary.Setoid.isEquivalence,
 Relation.Binary.Setoid._.refl, Relation.Binary.Setoid._.reflexive,
 Relation.Binary.Setoid._.sym, Relation.Binary.Setoid._.trans,
 Relation.Binary.Setoid.isPreorder, Relation.Binary.Setoid.preorder,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.Setoid.preorder]
etaExpandClause
  body    =  IsEquivalence.trans isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (r : IsDecEquivalence _≈_) {i : A} {j : A} {k : A} (_ : i ≈ j)
             (_ : j ≈ k)
etaExpandClause
  body    =  IsEquivalence.sym isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (r : IsDecEquivalence _≈_) {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsEquivalence.reflexive isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (r : IsDecEquivalence _≈_) {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsEquivalence.refl isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (r : IsDecEquivalence _≈_) {x : A}
etaExpandClause
  body    =  isEquivalence
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @1)
             (_≟₁_ : Decidable @2)
etaExpandClause
  body    =  y
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @1)
             (_≟₁_ : Decidable @2) (x : @2) (y : @3)
etaExpandClause
  body    =  IsEquivalence.refl (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (r : IsDecEquivalence _≈_) {x : A}
etaExpandClause
  body    =  IsEquivalence.reflexive (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (r : IsDecEquivalence _≈_) {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsEquivalence.sym (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (r : IsDecEquivalence _≈_) {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsEquivalence.trans (isEquivalence x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (r : IsDecEquivalence _≈_) {i : A} {j : A} {k : A} (_ : i ≈ j)
             (_ : j ≈ k)
etaExpandClause
  body    =  IsDecEquivalence.trans isDecEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             {i : Carrier} {j : Carrier} {k : Carrier} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsDecEquivalence.sym isDecEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.reflexive isDecEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             {i : Carrier} {j : Carrier} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.refl isDecEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             {x : Carrier}
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence isDecEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
etaExpandClause
  body    =  IsDecEquivalence._≟_ isDecEquivalence
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  Setoid.preorder setoid
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @2) (_≈₁_ : Rel Carrier₁ @2)
             (isDecEquivalence₁ : IsDecEquivalence _≈₁_)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @2) (_≈₁_ : Rel Carrier₁ @2)
             (isDecEquivalence₁ : IsDecEquivalence _≈₁_)
             (_ : Carrier isDecEquivalence₁) (_ : Carrier isDecEquivalence₁)
etaExpandClause
  body    =  isDecEquivalence
  xs      =  []
  new tel =  (Carrier₁ : Set @2) (_≈₁_ : Rel Carrier₁ @2)
             (isDecEquivalence₁ : IsDecEquivalence _≈₁_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ (isDecEquivalence y)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence (isDecEquivalence r)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
etaExpandClause
  body    =  IsDecEquivalence.refl (isDecEquivalence x)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             {x : Carrier r}
etaExpandClause
  body    =  IsDecEquivalence.reflexive (isDecEquivalence x)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             {i : Carrier r} {j : Carrier r} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.sym (isDecEquivalence x)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             {i : Carrier r} {j : Carrier r} (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsDecEquivalence.trans (isDecEquivalence x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
             {i : Carrier r} {j : Carrier r} {k : Carrier r} (_ : (r ≈ i) j)
             (_ : (r ≈ j) k)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; isEquivalence = IsDecEquivalence.isEquivalence (isDecEquivalence)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (: DecSetoid c ℓ)
etaExpandClause
  body    =  Setoid.preorder (setoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ : Level} (r : DecSetoid c ℓ)
Termination checking [Relation.Binary.DecSetoid, Relation.Binary.DecSetoid.Carrier,
 Relation.Binary.DecSetoid._≈_,
 Relation.Binary.DecSetoid.isDecEquivalence,
 Relation.Binary.DecSetoid._._≟_,
 Relation.Binary.DecSetoid._.isEquivalence,
 Relation.Binary.DecSetoid._.refl,
 Relation.Binary.DecSetoid._.reflexive,
 Relation.Binary.DecSetoid._.sym, Relation.Binary.DecSetoid._.trans,
 Relation.Binary.DecSetoid.setoid,
 Relation.Binary.DecSetoid._.preorder,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.DecSetoid.setoid]
etaExpandClause
  body    =  IsPreorder.Eq.trans isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsPreorder.Eq.sym isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPreorder.Eq.reflexive isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsPreorder.Eq.refl isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPreorder.∼-respˡ-≈ isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsPreorder.∼-respʳ-≈ isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsPreorder.∼-resp-≈ isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPreorder.trans isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsPreorder.reflexive isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPreorder.refl isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPreorder.isEquivalence isPreorder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  isPreorder
  xs      =  []
  new tel =  (isPreorder₁ : IsPreorder @2 @1)
             (antisym₁ : Antisymmetric @3 @2)
etaExpandClause
  body    =  x₂
  xs      =  []
  new tel =  (isPreorder₁ : IsPreorder @2 @1)
             (antisym₁ : Antisymmetric @3 @2) {x : @3} {y : @4}
             (_ : isPreorder₁ x y) (_ : isPreorder₁ y x)
etaExpandClause
  body    =  IsPreorder.isEquivalence (isPreorder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPreorder.refl (isPreorder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPreorder.reflexive (isPreorder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPreorder.trans (isPreorder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsPreorder.∼-resp-≈ (isPreorder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPreorder.∼-respʳ-≈ (isPreorder x₃)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsPreorder.∼-respˡ-≈ (isPreorder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsPreorder.Eq.refl (isPreorder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPreorder.Eq.reflexive (isPreorder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsPreorder.Eq.sym (isPreorder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPreorder.Eq.trans (isPreorder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsPartialOrder.Eq.trans isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} {k : Carrier}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsPartialOrder.Eq.sym isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.reflexive isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≡ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.refl isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsPartialOrder.≤-respˡ-≈ isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {y : Carrier} {x : Carrier} {y = y₁ : Carrier}
             (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsPartialOrder.≤-respʳ-≈ isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {x : Carrier} {x = x₁ : Carrier} {y : Carrier}
             (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsPartialOrder.≤-resp-≈ isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPartialOrder.trans isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} {k : Carrier}
             (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsPartialOrder.reflexive isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.refl isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsPartialOrder.isPreorder isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPartialOrder.isEquivalence isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPartialOrder.antisym isPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier} (_ : x ≤ y)
             (_ : y ≤ x)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isPartialOrder₁ : IsPartialOrder _≈₁_ _≤₁_)
etaExpandClause
  body    =  isPartialOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isPartialOrder₁ : IsPartialOrder _≈₁_ _≤₁_)
             (_ : Carrier isPartialOrder₁) (_ : Carrier isPartialOrder₁)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isPartialOrder₁ : IsPartialOrder _≈₁_ _≤₁_)
             (_ : Carrier isPartialOrder₁) (_ : Carrier isPartialOrder₁)
etaExpandClause
  body    =  isPartialOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isPartialOrder₁ : IsPartialOrder _≈₁_ _≤₁_)
etaExpandClause
  body    =  IsPartialOrder.antisym (isPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r} (_ : (r ≤ x) y)
             (_ : (r ≤ y) x)
etaExpandClause
  body    =  IsPartialOrder.isEquivalence (isPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPartialOrder.isPreorder (isPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPartialOrder.refl (isPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsPartialOrder.reflexive (isPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r} (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsPartialOrder.trans (isPartialOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r} {k : Carrier r}
             (_ : (r ≤ i) j) (_ : (r ≤ j) k)
etaExpandClause
  body    =  IsPartialOrder.≤-resp-≈ (isPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsPartialOrder.≤-respʳ-≈ (isPartialOrder x₃)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {x : Carrier r} {x = x₁ : Carrier r}
             {y : Carrier r} (_ : (r ≈ x₁) y) (_ : (r ≤ x) x₁)
etaExpandClause
  body    =  IsPartialOrder.≤-respˡ-≈ (isPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {y : Carrier r} {x : Carrier r}
             {y = y₁ : Carrier r} (_ : (r ≈ x) y₁) (_ : (r ≤ x) y)
etaExpandClause
  body    =  IsPartialOrder.Eq.refl (isPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsPartialOrder.Eq.reflexive (isPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r} (_ : i ≡ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.sym (isPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r} (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsPartialOrder.Eq.trans (isPartialOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : Poset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r} {k : Carrier r}
             (_ : (r ≈ i) j) (_ : (r ≈ j) k)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; _∼_ = _≤_
             ; isPreorder = IsPartialOrder.isPreorder (isPartialOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: Poset c ℓ₁ ℓ₂)
Termination checking [Relation.Binary.Poset, Relation.Binary.Poset.Carrier,
 Relation.Binary.Poset._≈_, Relation.Binary.Poset._≤_,
 Relation.Binary.Poset.isPartialOrder,
 Relation.Binary.Poset._.antisym,
 Relation.Binary.Poset._.isEquivalence,
 Relation.Binary.Poset._.isPreorder, Relation.Binary.Poset._.refl,
 Relation.Binary.Poset._.reflexive, Relation.Binary.Poset._.trans,
 Relation.Binary.Poset._.∼-resp-≈,
 Relation.Binary.Poset._.∼-respʳ-≈,
 Relation.Binary.Poset._.∼-respˡ-≈, Relation.Binary.Poset._.Eq.refl,
 Relation.Binary.Poset._.Eq.reflexive,
 Relation.Binary.Poset._.Eq.sym, Relation.Binary.Poset._.Eq.trans,
 Relation.Binary.Poset.preorder, Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.Poset.preorder]
etaExpandClause
  body    =  IsPartialOrder.Eq.trans isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsPartialOrder.Eq.sym isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.reflexive isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.refl isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPartialOrder.≤-respˡ-≈ isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsPartialOrder.≤-respʳ-≈ isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsPartialOrder.≤-resp-≈ isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.trans isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsPartialOrder.reflexive isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.refl isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPartialOrder.isPreorder isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.isEquivalence isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.antisym isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A} {y : A} (_ : x ≤ y) (_ : y ≤ x)
etaExpandClause
  body    =  IsDecEquivalence.trans isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsDecEquivalence.sym isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.reflexive isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.refl isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             (x : A) (y : A)
etaExpandClause
  body    =  isPartialOrder
  xs      =  []
  new tel =  (isPartialOrder₁ : IsPartialOrder @2 @1)
             (_≟₁_ : Decidable @3) (_≤?₁_ : Decidable @3)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (isPartialOrder₁ : IsPartialOrder @2 @1)
             (_≟₁_ : Decidable @3) (_≤?₁_ : Decidable @3) (x : @3) (y : @4)
etaExpandClause
  body    =  y
  xs      =  []
  new tel =  (isPartialOrder₁ : IsPartialOrder @2 @1)
             (_≟₁_ : Decidable @3) (_≤?₁_ : Decidable @3) (x : @3) (y : @4)
etaExpandClause
  body    =  IsPartialOrder.antisym (isPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A} {y : A} (_ : x ≤ y) (_ : y ≤ x)
etaExpandClause
  body    =  IsPartialOrder.isEquivalence (isPartialOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.isPreorder (isPartialOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.refl (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPartialOrder.reflexive (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.trans (isPartialOrder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsPartialOrder.≤-resp-≈ (isPartialOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.≤-respʳ-≈ (isPartialOrder x₃)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsPartialOrder.≤-respˡ-≈ (isPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsPartialOrder.Eq.refl (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPartialOrder.Eq.reflexive (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.sym (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.trans (isPartialOrder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  record
             { isEquivalence =
                 IsPreorder.isEquivalence
                 (IsPartialOrder.isPreorder (isPartialOrder))
             ; _≟_ = _≟_
             }
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (: IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ (isDecEquivalence y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             (x : A) (y : A)
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence (isDecEquivalence r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
etaExpandClause
  body    =  IsDecEquivalence.refl (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsDecEquivalence.reflexive (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.sym (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.trans (isDecEquivalence x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecPartialOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
Termination checking [Relation.Binary.IsDecPartialOrder,
 Relation.Binary.IsDecPartialOrder.isPartialOrder,
 Relation.Binary.IsDecPartialOrder._≟_,
 Relation.Binary.IsDecPartialOrder._≤?_,
 Relation.Binary.IsDecPartialOrder.PO.antisym,
 Relation.Binary.IsDecPartialOrder.PO.isEquivalence,
 Relation.Binary.IsDecPartialOrder.PO.isPreorder,
 Relation.Binary.IsDecPartialOrder.PO.refl,
 Relation.Binary.IsDecPartialOrder.PO.reflexive,
 Relation.Binary.IsDecPartialOrder.PO.trans,
 Relation.Binary.IsDecPartialOrder.PO.∼-resp-≈,
 Relation.Binary.IsDecPartialOrder.PO.∼-respʳ-≈,
 Relation.Binary.IsDecPartialOrder.PO.∼-respˡ-≈,
 Relation.Binary.IsDecPartialOrder.PO.Eq.refl,
 Relation.Binary.IsDecPartialOrder.PO.Eq.reflexive,
 Relation.Binary.IsDecPartialOrder.PO.Eq.sym,
 Relation.Binary.IsDecPartialOrder.PO.Eq.trans,
 Relation.Binary.IsDecPartialOrder.Eq.isDecEquivalence,
 Relation.Binary.IsDecPartialOrder.Eq._._≟_,
 Relation.Binary.IsDecPartialOrder.Eq._.isEquivalence,
 Relation.Binary.IsDecPartialOrder.Eq._.refl,
 Relation.Binary.IsDecPartialOrder.Eq._.reflexive,
 Relation.Binary.IsDecPartialOrder.Eq._.sym,
 Relation.Binary.IsDecPartialOrder.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsDecPartialOrder.Eq.isDecEquivalence]
etaExpandClause
  body    =  IsDecPartialOrder.Eq.trans isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} {k : Carrier}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.sym isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.reflexive isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.refl isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsDecPartialOrder.Eq.isEquivalence isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.isDecEquivalence
             isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.Eq._≟_ isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsDecPartialOrder.≤-respˡ-≈ isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {y : Carrier} {x : Carrier}
             {y = y₁ : Carrier} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsDecPartialOrder.≤-respʳ-≈ isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : Carrier} {x = x₁ : Carrier}
             {y : Carrier} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsDecPartialOrder.≤-resp-≈ isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.trans isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} {k : Carrier}
             (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsDecPartialOrder.reflexive isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecPartialOrder.refl isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsDecPartialOrder.isPreorder isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.isPartialOrder isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.isEquivalence isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.antisym isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier} (_ : x ≤ y)
             (_ : y ≤ x)
etaExpandClause
  body    =  IsDecPartialOrder._≤?_ isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsDecPartialOrder._≟_ isDecPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  Poset.preorder poset
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.trans decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} {k : DecSetoid.Carrier decSetoid}
             (_ : (decSetoid DecSetoid.≈ i) j) (_ : (decSetoid DecSetoid.≈ j) k)
etaExpandClause
  body    =  DecSetoid.sym decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} (_ : (decSetoid DecSetoid.≈ i) j)
etaExpandClause
  body    =  DecSetoid.setoid decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.reflexive decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} (_ : i ≡ j)
etaExpandClause
  body    =  DecSetoid.refl decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : DecSetoid.Carrier decSetoid}
etaExpandClause
  body    =  DecSetoid.preorder decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isEquivalence decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isDecEquivalence decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.Carrier decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid._≟_ decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (x : DecSetoid.Carrier decSetoid)
             (y : DecSetoid.Carrier decSetoid)
etaExpandClause
  body    =  DecSetoid._≈_ decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (_ : DecSetoid.Carrier decSetoid)
             (_ : DecSetoid.Carrier decSetoid)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isDecPartialOrder₁ : IsDecPartialOrder _≈₁_ _≤₁_)
etaExpandClause
  body    =  isDecPartialOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isDecPartialOrder₁ : IsDecPartialOrder _≈₁_ _≤₁_)
             (_ : Carrier isDecPartialOrder₁) (_ : Carrier isDecPartialOrder₁)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isDecPartialOrder₁ : IsDecPartialOrder _≈₁_ _≤₁_)
             (_ : Carrier isDecPartialOrder₁) (_ : Carrier isDecPartialOrder₁)
etaExpandClause
  body    =  isDecPartialOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isDecPartialOrder₁ : IsDecPartialOrder _≈₁_ _≤₁_)
etaExpandClause
  body    =  IsDecPartialOrder._≟_ (isDecPartialOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecPartialOrder._≤?_ (isDecPartialOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecPartialOrder.antisym (isDecPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r ≤ x) y) (_ : (r ≤ y) x)
etaExpandClause
  body    =  IsDecPartialOrder.isEquivalence (isDecPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.isPartialOrder (isDecPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.isPreorder (isDecPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.refl (isDecPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsDecPartialOrder.reflexive (isDecPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsDecPartialOrder.trans (isDecPartialOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≤ i) j) (_ : (r ≤ j) k)
etaExpandClause
  body    =  IsDecPartialOrder.≤-resp-≈ (isDecPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.≤-respʳ-≈ (isDecPartialOrder x₃)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : Carrier r} {x = x₁ : Carrier r}
             {y : Carrier r} (_ : (r ≈ x₁) y) (_ : (r ≤ x) x₁)
etaExpandClause
  body    =  IsDecPartialOrder.≤-respˡ-≈ (isDecPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {y : Carrier r} {x : Carrier r}
             {y = y₁ : Carrier r} (_ : (r ≈ x) y₁) (_ : (r ≤ x) y)
etaExpandClause
  body    =  IsDecPartialOrder.Eq._≟_ (isDecPartialOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.isDecEquivalence
             (isDecPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.isEquivalence
             (isDecPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.refl (isDecPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsDecPartialOrder.Eq.reflexive (isDecPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.sym (isDecPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsDecPartialOrder.Eq.trans (isDecPartialOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≈ i) j) (_ : (r ≈ j) k)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; _≤_ = _≤_
             ; isPartialOrder =
                 IsDecPartialOrder.isPartialOrder (isDecPartialOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  Poset.preorder (poset r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; isDecEquivalence =
                 IsDecPartialOrder.Eq.isDecEquivalence (isDecPartialOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid._≈_ (decSetoid x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (_ : DecSetoid.Carrier (decSetoid r))
             (_ : DecSetoid.Carrier (decSetoid r))
etaExpandClause
  body    =  DecSetoid._≟_ (decSetoid y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) (x : DecSetoid.Carrier (decSetoid r))
             (y : DecSetoid.Carrier (decSetoid r))
etaExpandClause
  body    =  DecSetoid.Carrier (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isDecEquivalence (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isEquivalence (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.preorder (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.refl (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {x : DecSetoid.Carrier (decSetoid r)}
etaExpandClause
  body    =  DecSetoid.reflexive (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)} (_ : i ≡ j)
etaExpandClause
  body    =  DecSetoid.setoid (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.sym (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)}
             (_ : (decSetoid r DecSetoid.≈ i) j)
etaExpandClause
  body    =  DecSetoid.trans (decSetoid x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecPoset c ℓ₁ ℓ₂) {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)}
             {k : DecSetoid.Carrier (decSetoid r)}
             (_ : (decSetoid r DecSetoid.≈ i) j)
             (_ : (decSetoid r DecSetoid.≈ j) k)
Termination checking [Relation.Binary.DecPoset, Relation.Binary.DecPoset.Carrier,
 Relation.Binary.DecPoset._≈_, Relation.Binary.DecPoset._≤_,
 Relation.Binary.DecPoset.isDecPartialOrder,
 Relation.Binary.DecPoset.DPO._≟_,
 Relation.Binary.DecPoset.DPO._≤?_,
 Relation.Binary.DecPoset.DPO.antisym,
 Relation.Binary.DecPoset.DPO.isEquivalence,
 Relation.Binary.DecPoset.DPO.isPartialOrder,
 Relation.Binary.DecPoset.DPO.isPreorder,
 Relation.Binary.DecPoset.DPO.refl,
 Relation.Binary.DecPoset.DPO.reflexive,
 Relation.Binary.DecPoset.DPO.trans,
 Relation.Binary.DecPoset.DPO.∼-resp-≈,
 Relation.Binary.DecPoset.DPO.∼-respʳ-≈,
 Relation.Binary.DecPoset.DPO.∼-respˡ-≈,
 Relation.Binary.DecPoset.DPO.Eq._≟_,
 Relation.Binary.DecPoset.DPO.Eq.isDecEquivalence,
 Relation.Binary.DecPoset.DPO.Eq.isEquivalence,
 Relation.Binary.DecPoset.DPO.Eq.refl,
 Relation.Binary.DecPoset.DPO.Eq.reflexive,
 Relation.Binary.DecPoset.DPO.Eq.sym,
 Relation.Binary.DecPoset.DPO.Eq.trans,
 Relation.Binary.DecPoset.poset,
 Relation.Binary.DecPoset._.preorder,
 Relation.Binary.DecPoset.Eq.decSetoid,
 Relation.Binary.DecPoset.Eq._._≈_,
 Relation.Binary.DecPoset.Eq._._≟_,
 Relation.Binary.DecPoset.Eq._.Carrier,
 Relation.Binary.DecPoset.Eq._.isDecEquivalence,
 Relation.Binary.DecPoset.Eq._.isEquivalence,
 Relation.Binary.DecPoset.Eq._.preorder,
 Relation.Binary.DecPoset.Eq._.refl,
 Relation.Binary.DecPoset.Eq._.reflexive,
 Relation.Binary.DecPoset.Eq._.setoid,
 Relation.Binary.DecPoset.Eq._.sym,
 Relation.Binary.DecPoset.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.DecPoset.poset]
Termination checking [Relation.Binary.DecPoset, Relation.Binary.DecPoset.Carrier,
 Relation.Binary.DecPoset._≈_, Relation.Binary.DecPoset._≤_,
 Relation.Binary.DecPoset.isDecPartialOrder,
 Relation.Binary.DecPoset.DPO._≟_,
 Relation.Binary.DecPoset.DPO._≤?_,
 Relation.Binary.DecPoset.DPO.antisym,
 Relation.Binary.DecPoset.DPO.isEquivalence,
 Relation.Binary.DecPoset.DPO.isPartialOrder,
 Relation.Binary.DecPoset.DPO.isPreorder,
 Relation.Binary.DecPoset.DPO.refl,
 Relation.Binary.DecPoset.DPO.reflexive,
 Relation.Binary.DecPoset.DPO.trans,
 Relation.Binary.DecPoset.DPO.∼-resp-≈,
 Relation.Binary.DecPoset.DPO.∼-respʳ-≈,
 Relation.Binary.DecPoset.DPO.∼-respˡ-≈,
 Relation.Binary.DecPoset.DPO.Eq._≟_,
 Relation.Binary.DecPoset.DPO.Eq.isDecEquivalence,
 Relation.Binary.DecPoset.DPO.Eq.isEquivalence,
 Relation.Binary.DecPoset.DPO.Eq.refl,
 Relation.Binary.DecPoset.DPO.Eq.reflexive,
 Relation.Binary.DecPoset.DPO.Eq.sym,
 Relation.Binary.DecPoset.DPO.Eq.trans,
 Relation.Binary.DecPoset.poset,
 Relation.Binary.DecPoset._.preorder,
 Relation.Binary.DecPoset.Eq.decSetoid,
 Relation.Binary.DecPoset.Eq._._≈_,
 Relation.Binary.DecPoset.Eq._._≟_,
 Relation.Binary.DecPoset.Eq._.Carrier,
 Relation.Binary.DecPoset.Eq._.isDecEquivalence,
 Relation.Binary.DecPoset.Eq._.isEquivalence,
 Relation.Binary.DecPoset.Eq._.preorder,
 Relation.Binary.DecPoset.Eq._.refl,
 Relation.Binary.DecPoset.Eq._.reflexive,
 Relation.Binary.DecPoset.Eq._.setoid,
 Relation.Binary.DecPoset.Eq._.sym,
 Relation.Binary.DecPoset.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.DecPoset.Eq.decSetoid]
etaExpandClause
  body    =  IsEquivalence.trans isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {i : A} {j : A} {k : A}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsEquivalence.sym isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsEquivalence.reflexive isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsEquivalence.refl isEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {x : A}
etaExpandClause
  body    =  isEquivalence
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (irrefl₁ : Irreflexive @3 @2) (trans₁ : Transitive @3)
             (<-resp-≈₁ : @4 Respects₂ @5)
etaExpandClause
  body    =  y
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (irrefl₁ : Irreflexive @3 @2) (trans₁ : Transitive @3)
             (<-resp-≈₁ : @4 Respects₂ @5) {x : isEquivalence₁}
             {y : isEquivalence₁} (_ : irrefl₁ x y) (_ : trans₁ x y)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (irrefl₁ : Irreflexive @3 @2) (trans₁ : Transitive @3)
             (<-resp-≈₁ : @4 Respects₂ @5) {i : isEquivalence₁}
             {j : isEquivalence₁} {k : isEquivalence₁} (_ : trans₁ i j)
             (_ : trans₁ j k)
etaExpandClause
  body    =  <-resp-≈
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (irrefl₁ : Irreflexive @3 @2) (trans₁ : Transitive @3)
             (<-resp-≈₁ : @4 Respects₂ @5)
etaExpandClause
  body    =  IsEquivalence.refl (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {x : A}
etaExpandClause
  body    =  IsEquivalence.reflexive (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsEquivalence.sym (isEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsEquivalence.trans (isEquivalence x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {i : A} {j : A} {k : A}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  trans∧irr⟶asym (IsEquivalence.refl (isEquivalence y))
             (trans y) (irrefl y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictPartialOrder _≈_ _<_)
             {x : A} {y : A} (_ : x < y) (_ : y < x)
etaExpandClause
  body    =  proj₁ (<-resp-≈ x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictPartialOrder _≈_ _<_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x < x₁)
etaExpandClause
  body    =  proj₂ (<-resp-≈ x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictPartialOrder _≈_ _<_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x < y)
etaExpandClause
  body    =  asym x₂
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsStrictPartialOrder _≈_ _<_) {x : A} {y : A} (_ : x < y)
             (_ : y < x)
Termination checking [Relation.Binary.IsStrictPartialOrder,
 Relation.Binary.IsStrictPartialOrder.isEquivalence,
 Relation.Binary.IsStrictPartialOrder.irrefl,
 Relation.Binary.IsStrictPartialOrder.trans,
 Relation.Binary.IsStrictPartialOrder.<-resp-≈,
 Relation.Binary.IsStrictPartialOrder.Eq.refl,
 Relation.Binary.IsStrictPartialOrder.Eq.reflexive,
 Relation.Binary.IsStrictPartialOrder.Eq.sym,
 Relation.Binary.IsStrictPartialOrder.Eq.trans,
 Relation.Binary.IsStrictPartialOrder.asym,
 Relation.Binary.IsStrictPartialOrder.<-respʳ-≈,
 Relation.Binary.IsStrictPartialOrder.<-respˡ-≈,
 Relation.Binary.IsStrictPartialOrder.asymmetric,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictPartialOrder.asym]
Termination checking [Relation.Binary.IsStrictPartialOrder,
 Relation.Binary.IsStrictPartialOrder.isEquivalence,
 Relation.Binary.IsStrictPartialOrder.irrefl,
 Relation.Binary.IsStrictPartialOrder.trans,
 Relation.Binary.IsStrictPartialOrder.<-resp-≈,
 Relation.Binary.IsStrictPartialOrder.Eq.refl,
 Relation.Binary.IsStrictPartialOrder.Eq.reflexive,
 Relation.Binary.IsStrictPartialOrder.Eq.sym,
 Relation.Binary.IsStrictPartialOrder.Eq.trans,
 Relation.Binary.IsStrictPartialOrder.asym,
 Relation.Binary.IsStrictPartialOrder.<-respʳ-≈,
 Relation.Binary.IsStrictPartialOrder.<-respˡ-≈,
 Relation.Binary.IsStrictPartialOrder.asymmetric,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictPartialOrder.<-respʳ-≈]
Termination checking [Relation.Binary.IsStrictPartialOrder,
 Relation.Binary.IsStrictPartialOrder.isEquivalence,
 Relation.Binary.IsStrictPartialOrder.irrefl,
 Relation.Binary.IsStrictPartialOrder.trans,
 Relation.Binary.IsStrictPartialOrder.<-resp-≈,
 Relation.Binary.IsStrictPartialOrder.Eq.refl,
 Relation.Binary.IsStrictPartialOrder.Eq.reflexive,
 Relation.Binary.IsStrictPartialOrder.Eq.sym,
 Relation.Binary.IsStrictPartialOrder.Eq.trans,
 Relation.Binary.IsStrictPartialOrder.asym,
 Relation.Binary.IsStrictPartialOrder.<-respʳ-≈,
 Relation.Binary.IsStrictPartialOrder.<-respˡ-≈,
 Relation.Binary.IsStrictPartialOrder.asymmetric,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictPartialOrder.<-respˡ-≈]
Termination checking [Relation.Binary.IsStrictPartialOrder,
 Relation.Binary.IsStrictPartialOrder.isEquivalence,
 Relation.Binary.IsStrictPartialOrder.irrefl,
 Relation.Binary.IsStrictPartialOrder.trans,
 Relation.Binary.IsStrictPartialOrder.<-resp-≈,
 Relation.Binary.IsStrictPartialOrder.Eq.refl,
 Relation.Binary.IsStrictPartialOrder.Eq.reflexive,
 Relation.Binary.IsStrictPartialOrder.Eq.sym,
 Relation.Binary.IsStrictPartialOrder.Eq.trans,
 Relation.Binary.IsStrictPartialOrder.asym,
 Relation.Binary.IsStrictPartialOrder.<-respʳ-≈,
 Relation.Binary.IsStrictPartialOrder.<-respˡ-≈,
 Relation.Binary.IsStrictPartialOrder.asymmetric,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictPartialOrder.asymmetric]
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.trans isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             {k : Carrier} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.sym isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             (_ : i ≈ j)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.reflexive isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             (_ : i ≡ j)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.refl isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsStrictPartialOrder.trans isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             {k : Carrier} (_ : i < j) (_ : j < k)
etaExpandClause
  body    =  IsStrictPartialOrder.isEquivalence
             isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictPartialOrder.irrefl isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier}
             (_ : x ≈ y) (_ : x < y)
etaExpandClause
  body    =  IsStrictPartialOrder.asymmetric isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier}
             (_ : x < y) (_ : y < x)
etaExpandClause
  body    =  IsStrictPartialOrder.asym isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier}
             (_ : x < y) (_ : y < x)
etaExpandClause
  body    =  IsStrictPartialOrder.<-respˡ-≈ isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {y : Carrier} {x : Carrier}
             {y = y₁ : Carrier} (_ : x ≈ y₁) (_ : x < y)
etaExpandClause
  body    =  IsStrictPartialOrder.<-respʳ-≈ isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier} {x = x₁ : Carrier}
             {y : Carrier} (_ : x₁ ≈ y) (_ : x < x₁)
etaExpandClause
  body    =  IsStrictPartialOrder.<-resp-≈ isStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isStrictPartialOrder₁ : IsStrictPartialOrder _≈₁_ _<₁_)
etaExpandClause
  body    =  isStrictPartialOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isStrictPartialOrder₁ : IsStrictPartialOrder _≈₁_ _<₁_)
             (_ : Carrier isStrictPartialOrder₁)
             (_ : Carrier isStrictPartialOrder₁)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isStrictPartialOrder₁ : IsStrictPartialOrder _≈₁_ _<₁_)
             (_ : Carrier isStrictPartialOrder₁)
             (_ : Carrier isStrictPartialOrder₁)
etaExpandClause
  body    =  isStrictPartialOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isStrictPartialOrder₁ : IsStrictPartialOrder _≈₁_ _<₁_)
etaExpandClause
  body    =  IsStrictPartialOrder.<-resp-≈ (isStrictPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictPartialOrder.<-respʳ-≈
             (isStrictPartialOrder x₃)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r}
             {x = x₁ : Carrier r} {y : Carrier r} (_ : (r ≈ x₁) y)
             (_ : (r < x) x₁)
etaExpandClause
  body    =  IsStrictPartialOrder.<-respˡ-≈
             (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {y : Carrier r} {x : Carrier r}
             {y = y₁ : Carrier r} (_ : (r ≈ x) y₁) (_ : (r < x) y)
etaExpandClause
  body    =  IsStrictPartialOrder.asym (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r < x) y) (_ : (r < y) x)
etaExpandClause
  body    =  IsStrictPartialOrder.asymmetric
             (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r < x) y) (_ : (r < y) x)
etaExpandClause
  body    =  IsStrictPartialOrder.irrefl (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r ≈ x) y) (_ : (r < x) y)
etaExpandClause
  body    =  IsStrictPartialOrder.isEquivalence
             (isStrictPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictPartialOrder.trans (isStrictPartialOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r < i) j) (_ : (r < j) k)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.refl (isStrictPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.reflexive
             (isStrictPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : i ≡ j)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.sym (isStrictPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.trans
             (isStrictPartialOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≈ i) j) (_ : (r ≈ j) k)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.trans isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} {k : A}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.sym isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.reflexive isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.refl isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A}
etaExpandClause
  body    =  IsStrictPartialOrder.trans isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} {k : A}
             (_ : i < j) (_ : j < k)
etaExpandClause
  body    =  IsStrictPartialOrder.isEquivalence
             isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_)
etaExpandClause
  body    =  IsStrictPartialOrder.irrefl isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A} {y : A} (_ : x ≈ y)
             (_ : x < y)
etaExpandClause
  body    =  IsStrictPartialOrder.asymmetric isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A} {y : A} (_ : x < y)
             (_ : y < x)
etaExpandClause
  body    =  IsStrictPartialOrder.asym isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A} {y : A} (_ : x < y)
             (_ : y < x)
etaExpandClause
  body    =  IsStrictPartialOrder.<-respˡ-≈ isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {y : A} {x : A} {y = y₁ : A}
             (_ : x ≈ y₁) (_ : x < y)
etaExpandClause
  body    =  IsStrictPartialOrder.<-respʳ-≈ isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A} {x = x₁ : A} {y : A}
             (_ : x₁ ≈ y) (_ : x < x₁)
etaExpandClause
  body    =  IsStrictPartialOrder.<-resp-≈ isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_)
etaExpandClause
  body    =  IsDecEquivalence.trans isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} {k : A}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsDecEquivalence.sym isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.reflexive isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.refl isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A}
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) (x : A) (y : A)
etaExpandClause
  body    =  isStrictPartialOrder
  xs      =  []
  new tel =  (isStrictPartialOrder₁ : IsStrictPartialOrder @2 @1)
             (_≟₁_ : Decidable @3) (_<?₁_ : Decidable @3)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (isStrictPartialOrder₁ : IsStrictPartialOrder @2 @1)
             (_≟₁_ : Decidable @3) (_<?₁_ : Decidable @3) (x : @3) (y : @4)
etaExpandClause
  body    =  y
  xs      =  []
  new tel =  (isStrictPartialOrder₁ : IsStrictPartialOrder @2 @1)
             (_≟₁_ : Decidable @3) (_<?₁_ : Decidable @3) (x : @3) (y : @4)
etaExpandClause
  body    =  IsStrictPartialOrder.<-resp-≈ (isStrictPartialOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_)
etaExpandClause
  body    =  IsStrictPartialOrder.<-respʳ-≈
             (isStrictPartialOrder x₃)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A} {x = x₁ : A} {y : A}
             (_ : x₁ ≈ y) (_ : x < x₁)
etaExpandClause
  body    =  IsStrictPartialOrder.<-respˡ-≈
             (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {y : A} {x : A} {y = y₁ : A}
             (_ : x ≈ y₁) (_ : x < y)
etaExpandClause
  body    =  IsStrictPartialOrder.asym (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A} {y : A} (_ : x < y)
             (_ : y < x)
etaExpandClause
  body    =  IsStrictPartialOrder.asymmetric
             (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A} {y : A} (_ : x < y)
             (_ : y < x)
etaExpandClause
  body    =  IsStrictPartialOrder.irrefl (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A} {y : A} (_ : x ≈ y)
             (_ : x < y)
etaExpandClause
  body    =  IsStrictPartialOrder.isEquivalence
             (isStrictPartialOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_)
etaExpandClause
  body    =  IsStrictPartialOrder.trans (isStrictPartialOrder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} {k : A}
             (_ : i < j) (_ : j < k)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.refl (isStrictPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A}
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.reflexive
             (isStrictPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.sym (isStrictPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsStrictPartialOrder.Eq.trans
             (isStrictPartialOrder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} {k : A}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  record
             { isEquivalence =
                 IsStrictPartialOrder.isEquivalence (isStrictPartialOrder)
             ; _≟_ = _≟_
             }
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (: IsDecStrictPartialOrder _≈_ _<_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ (isDecEquivalence y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) (x : A) (y : A)
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence (isDecEquivalence r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_)
etaExpandClause
  body    =  IsDecEquivalence.refl (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {x : A}
etaExpandClause
  body    =  IsDecEquivalence.reflexive (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.sym (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.trans (isDecEquivalence x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂}
             (r : IsDecStrictPartialOrder _≈_ _<_) {i : A} {j : A} {k : A}
             (_ : i ≈ j) (_ : j ≈ k)
Termination checking [Relation.Binary.IsDecStrictPartialOrder,
 Relation.Binary.IsDecStrictPartialOrder.isStrictPartialOrder,
 Relation.Binary.IsDecStrictPartialOrder._≟_,
 Relation.Binary.IsDecStrictPartialOrder._<?_,
 Relation.Binary.IsDecStrictPartialOrder.SPO.<-resp-≈,
 Relation.Binary.IsDecStrictPartialOrder.SPO.<-respʳ-≈,
 Relation.Binary.IsDecStrictPartialOrder.SPO.<-respˡ-≈,
 Relation.Binary.IsDecStrictPartialOrder.SPO.asym,
 Relation.Binary.IsDecStrictPartialOrder.SPO.asymmetric,
 Relation.Binary.IsDecStrictPartialOrder.SPO.irrefl,
 Relation.Binary.IsDecStrictPartialOrder.SPO.isEquivalence,
 Relation.Binary.IsDecStrictPartialOrder.SPO.trans,
 Relation.Binary.IsDecStrictPartialOrder.SPO.Eq.refl,
 Relation.Binary.IsDecStrictPartialOrder.SPO.Eq.reflexive,
 Relation.Binary.IsDecStrictPartialOrder.SPO.Eq.sym,
 Relation.Binary.IsDecStrictPartialOrder.SPO.Eq.trans,
 Relation.Binary.IsDecStrictPartialOrder.Eq.isDecEquivalence,
 Relation.Binary.IsDecStrictPartialOrder.Eq._._≟_,
 Relation.Binary.IsDecStrictPartialOrder.Eq._.isEquivalence,
 Relation.Binary.IsDecStrictPartialOrder.Eq._.refl,
 Relation.Binary.IsDecStrictPartialOrder.Eq._.reflexive,
 Relation.Binary.IsDecStrictPartialOrder.Eq._.sym,
 Relation.Binary.IsDecStrictPartialOrder.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsDecStrictPartialOrder.Eq.isDecEquivalence]
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.trans
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             {k : Carrier} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.sym isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             (_ : i ≈ j)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.reflexive
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             (_ : i ≡ j)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.refl
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.isEquivalence
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.isDecEquivalence
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq._≟_ isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsDecStrictPartialOrder.trans isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             {k : Carrier} (_ : i < j) (_ : j < k)
etaExpandClause
  body    =  IsDecStrictPartialOrder.isStrictPartialOrder
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.isEquivalence
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.irrefl isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier}
             (_ : x ≈ y) (_ : x < y)
etaExpandClause
  body    =  IsDecStrictPartialOrder.asymmetric
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier}
             (_ : x < y) (_ : y < x)
etaExpandClause
  body    =  IsDecStrictPartialOrder.asym isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier}
             (_ : x < y) (_ : y < x)
etaExpandClause
  body    =  IsDecStrictPartialOrder.<-respˡ-≈
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {y : Carrier} {x : Carrier}
             {y = y₁ : Carrier} (_ : x ≈ y₁) (_ : x < y)
etaExpandClause
  body    =  IsDecStrictPartialOrder.<-respʳ-≈
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier}
             {x = x₁ : Carrier} {y : Carrier} (_ : x₁ ≈ y) (_ : x < x₁)
etaExpandClause
  body    =  IsDecStrictPartialOrder.<-resp-≈
             isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder._≟_ isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsDecStrictPartialOrder._<?_ isDecStrictPartialOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  DecSetoid.trans decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier decSetoid} {j : DecSetoid.Carrier decSetoid}
             {k : DecSetoid.Carrier decSetoid} (_ : (decSetoid DecSetoid.≈ i) j)
             (_ : (decSetoid DecSetoid.≈ j) k)
etaExpandClause
  body    =  DecSetoid.sym decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier decSetoid} {j : DecSetoid.Carrier decSetoid}
             (_ : (decSetoid DecSetoid.≈ i) j)
etaExpandClause
  body    =  DecSetoid.setoid decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.reflexive decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier decSetoid} {j : DecSetoid.Carrier decSetoid}
             (_ : i ≡ j)
etaExpandClause
  body    =  DecSetoid.refl decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             {x : DecSetoid.Carrier decSetoid}
etaExpandClause
  body    =  DecSetoid.preorder decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isEquivalence decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isDecEquivalence decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.Carrier decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid._≟_ decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             (x : DecSetoid.Carrier decSetoid) (y : DecSetoid.Carrier decSetoid)
etaExpandClause
  body    =  DecSetoid._≈_ decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             (_ : DecSetoid.Carrier decSetoid) (_ : DecSetoid.Carrier decSetoid)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isDecStrictPartialOrder₁ : IsDecStrictPartialOrder _≈₁_ _<₁_)
etaExpandClause
  body    =  isDecStrictPartialOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isDecStrictPartialOrder₁ : IsDecStrictPartialOrder _≈₁_ _<₁_)
             (_ : Carrier isDecStrictPartialOrder₁)
             (_ : Carrier isDecStrictPartialOrder₁)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isDecStrictPartialOrder₁ : IsDecStrictPartialOrder _≈₁_ _<₁_)
             (_ : Carrier isDecStrictPartialOrder₁)
             (_ : Carrier isDecStrictPartialOrder₁)
etaExpandClause
  body    =  isDecStrictPartialOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isDecStrictPartialOrder₁ : IsDecStrictPartialOrder _≈₁_ _<₁_)
etaExpandClause
  body    =  IsDecStrictPartialOrder._<?_
             (isDecStrictPartialOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecStrictPartialOrder._≟_
             (isDecStrictPartialOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecStrictPartialOrder.<-resp-≈
             (isDecStrictPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.<-respʳ-≈
             (isDecStrictPartialOrder x₃)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r}
             {x = x₁ : Carrier r} {y : Carrier r} (_ : (r ≈ x₁) y)
             (_ : (r < x) x₁)
etaExpandClause
  body    =  IsDecStrictPartialOrder.<-respˡ-≈
             (isDecStrictPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {y : Carrier r} {x : Carrier r}
             {y = y₁ : Carrier r} (_ : (r ≈ x) y₁) (_ : (r < x) y)
etaExpandClause
  body    =  IsDecStrictPartialOrder.asym
             (isDecStrictPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r < x) y) (_ : (r < y) x)
etaExpandClause
  body    =  IsDecStrictPartialOrder.asymmetric
             (isDecStrictPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r < x) y) (_ : (r < y) x)
etaExpandClause
  body    =  IsDecStrictPartialOrder.irrefl
             (isDecStrictPartialOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r ≈ x) y) (_ : (r < x) y)
etaExpandClause
  body    =  IsDecStrictPartialOrder.isEquivalence
             (isDecStrictPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.isStrictPartialOrder
             (isDecStrictPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.trans
             (isDecStrictPartialOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r < i) j) (_ : (r < j) k)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq._≟_
             (isDecStrictPartialOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.isDecEquivalence
             (isDecStrictPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.isEquivalence
             (isDecStrictPartialOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.refl
             (isDecStrictPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.reflexive
             (isDecStrictPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : i ≡ j)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.sym
             (isDecStrictPartialOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsDecStrictPartialOrder.Eq.trans
             (isDecStrictPartialOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≈ i) j) (_ : (r ≈ j) k)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; _<_ = _<_
             ; isStrictPartialOrder =
                 IsDecStrictPartialOrder.isStrictPartialOrder
                 (isDecStrictPartialOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; isDecEquivalence =
                 IsDecStrictPartialOrder.Eq.isDecEquivalence
                 (isDecStrictPartialOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid._≈_ (decSetoid x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             (_ : DecSetoid.Carrier (decSetoid r))
             (_ : DecSetoid.Carrier (decSetoid r))
etaExpandClause
  body    =  DecSetoid._≟_ (decSetoid y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             (x : DecSetoid.Carrier (decSetoid r))
             (y : DecSetoid.Carrier (decSetoid r))
etaExpandClause
  body    =  DecSetoid.Carrier (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isDecEquivalence (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isEquivalence (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.preorder (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.refl (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             {x : DecSetoid.Carrier (decSetoid r)}
etaExpandClause
  body    =  DecSetoid.reflexive (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)} (_ : i ≡ j)
etaExpandClause
  body    =  DecSetoid.setoid (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.sym (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)}
             (_ : (decSetoid r DecSetoid.≈ i) j)
etaExpandClause
  body    =  DecSetoid.trans (decSetoid x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecStrictPartialOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)}
             {k : DecSetoid.Carrier (decSetoid r)}
             (_ : (decSetoid r DecSetoid.≈ i) j)
             (_ : (decSetoid r DecSetoid.≈ j) k)
Termination checking [Relation.Binary.DecStrictPartialOrder,
 Relation.Binary.DecStrictPartialOrder.Carrier,
 Relation.Binary.DecStrictPartialOrder._≈_,
 Relation.Binary.DecStrictPartialOrder._<_,
 Relation.Binary.DecStrictPartialOrder.isDecStrictPartialOrder,
 Relation.Binary.DecStrictPartialOrder.DSPO._<?_,
 Relation.Binary.DecStrictPartialOrder.DSPO._≟_,
 Relation.Binary.DecStrictPartialOrder.DSPO.<-resp-≈,
 Relation.Binary.DecStrictPartialOrder.DSPO.<-respʳ-≈,
 Relation.Binary.DecStrictPartialOrder.DSPO.<-respˡ-≈,
 Relation.Binary.DecStrictPartialOrder.DSPO.asym,
 Relation.Binary.DecStrictPartialOrder.DSPO.asymmetric,
 Relation.Binary.DecStrictPartialOrder.DSPO.irrefl,
 Relation.Binary.DecStrictPartialOrder.DSPO.isEquivalence,
 Relation.Binary.DecStrictPartialOrder.DSPO.isStrictPartialOrder,
 Relation.Binary.DecStrictPartialOrder.DSPO.trans,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq._≟_,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.isDecEquivalence,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.isEquivalence,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.refl,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.reflexive,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.sym,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.trans,
 Relation.Binary.DecStrictPartialOrder.strictPartialOrder,
 Relation.Binary.DecStrictPartialOrder.Eq.decSetoid,
 Relation.Binary.DecStrictPartialOrder.Eq._._≈_,
 Relation.Binary.DecStrictPartialOrder.Eq._._≟_,
 Relation.Binary.DecStrictPartialOrder.Eq._.Carrier,
 Relation.Binary.DecStrictPartialOrder.Eq._.isDecEquivalence,
 Relation.Binary.DecStrictPartialOrder.Eq._.isEquivalence,
 Relation.Binary.DecStrictPartialOrder.Eq._.preorder,
 Relation.Binary.DecStrictPartialOrder.Eq._.refl,
 Relation.Binary.DecStrictPartialOrder.Eq._.reflexive,
 Relation.Binary.DecStrictPartialOrder.Eq._.setoid,
 Relation.Binary.DecStrictPartialOrder.Eq._.sym,
 Relation.Binary.DecStrictPartialOrder.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.DecStrictPartialOrder.strictPartialOrder]
Termination checking [Relation.Binary.DecStrictPartialOrder,
 Relation.Binary.DecStrictPartialOrder.Carrier,
 Relation.Binary.DecStrictPartialOrder._≈_,
 Relation.Binary.DecStrictPartialOrder._<_,
 Relation.Binary.DecStrictPartialOrder.isDecStrictPartialOrder,
 Relation.Binary.DecStrictPartialOrder.DSPO._<?_,
 Relation.Binary.DecStrictPartialOrder.DSPO._≟_,
 Relation.Binary.DecStrictPartialOrder.DSPO.<-resp-≈,
 Relation.Binary.DecStrictPartialOrder.DSPO.<-respʳ-≈,
 Relation.Binary.DecStrictPartialOrder.DSPO.<-respˡ-≈,
 Relation.Binary.DecStrictPartialOrder.DSPO.asym,
 Relation.Binary.DecStrictPartialOrder.DSPO.asymmetric,
 Relation.Binary.DecStrictPartialOrder.DSPO.irrefl,
 Relation.Binary.DecStrictPartialOrder.DSPO.isEquivalence,
 Relation.Binary.DecStrictPartialOrder.DSPO.isStrictPartialOrder,
 Relation.Binary.DecStrictPartialOrder.DSPO.trans,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq._≟_,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.isDecEquivalence,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.isEquivalence,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.refl,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.reflexive,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.sym,
 Relation.Binary.DecStrictPartialOrder.DSPO.Eq.trans,
 Relation.Binary.DecStrictPartialOrder.strictPartialOrder,
 Relation.Binary.DecStrictPartialOrder.Eq.decSetoid,
 Relation.Binary.DecStrictPartialOrder.Eq._._≈_,
 Relation.Binary.DecStrictPartialOrder.Eq._._≟_,
 Relation.Binary.DecStrictPartialOrder.Eq._.Carrier,
 Relation.Binary.DecStrictPartialOrder.Eq._.isDecEquivalence,
 Relation.Binary.DecStrictPartialOrder.Eq._.isEquivalence,
 Relation.Binary.DecStrictPartialOrder.Eq._.preorder,
 Relation.Binary.DecStrictPartialOrder.Eq._.refl,
 Relation.Binary.DecStrictPartialOrder.Eq._.reflexive,
 Relation.Binary.DecStrictPartialOrder.Eq._.setoid,
 Relation.Binary.DecStrictPartialOrder.Eq._.sym,
 Relation.Binary.DecStrictPartialOrder.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.DecStrictPartialOrder.Eq.decSetoid]
etaExpandClause
  body    =  IsPartialOrder.Eq.trans isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsPartialOrder.Eq.sym isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.reflexive isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.refl isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPartialOrder.≤-respˡ-≈ isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsPartialOrder.≤-respʳ-≈ isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsPartialOrder.≤-resp-≈ isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.trans isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsPartialOrder.reflexive isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.refl isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPartialOrder.isPreorder isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.isEquivalence isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.antisym isPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {x : A} {y : A} (_ : x ≤ y) (_ : y ≤ x)
etaExpandClause
  body    =  isPartialOrder
  xs      =  []
  new tel =  (isPartialOrder₁ : IsPartialOrder @2 @1)
             (total₁ : Total @2)
etaExpandClause
  body    =  y
  xs      =  []
  new tel =  (isPartialOrder₁ : IsPartialOrder @2 @1)
             (total₁ : Total @2) (x : @3) (y : @4)
etaExpandClause
  body    =  IsPartialOrder.antisym (isPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {x : A} {y : A} (_ : x ≤ y) (_ : y ≤ x)
etaExpandClause
  body    =  IsPartialOrder.isEquivalence (isPartialOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.isPreorder (isPartialOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.refl (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPartialOrder.reflexive (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.trans (isPartialOrder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsPartialOrder.≤-resp-≈ (isPartialOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsPartialOrder.≤-respʳ-≈ (isPartialOrder x₃)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsPartialOrder.≤-respˡ-≈ (isPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsPartialOrder.Eq.refl (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsPartialOrder.Eq.reflexive (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.sym (isPartialOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsPartialOrder.Eq.trans (isPartialOrder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsTotalOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsTotalOrder.Eq.trans isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} {k : Carrier}
             (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsTotalOrder.Eq.sym isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsTotalOrder.Eq.reflexive isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≡ j)
etaExpandClause
  body    =  IsTotalOrder.Eq.refl isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsTotalOrder.≤-respˡ-≈ isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {y : Carrier} {x : Carrier}
             {y = y₁ : Carrier} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsTotalOrder.≤-respʳ-≈ isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {x : Carrier} {x = x₁ : Carrier}
             {y : Carrier} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsTotalOrder.≤-resp-≈ isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsTotalOrder.trans isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} {k : Carrier}
             (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsTotalOrder.total isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsTotalOrder.reflexive isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsTotalOrder.refl isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsTotalOrder.isPreorder isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsTotalOrder.isPartialOrder isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsTotalOrder.isEquivalence isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsTotalOrder.antisym isTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier} (_ : x ≤ y)
             (_ : y ≤ x)
etaExpandClause
  body    =  Poset.preorder poset
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3) (isTotalOrder₁ : IsTotalOrder _≈₁_ _≤₁_)
etaExpandClause
  body    =  isTotalOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3) (isTotalOrder₁ : IsTotalOrder _≈₁_ _≤₁_)
             (_ : Carrier isTotalOrder₁) (_ : Carrier isTotalOrder₁)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3) (isTotalOrder₁ : IsTotalOrder _≈₁_ _≤₁_)
             (_ : Carrier isTotalOrder₁) (_ : Carrier isTotalOrder₁)
etaExpandClause
  body    =  isTotalOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3) (isTotalOrder₁ : IsTotalOrder _≈₁_ _≤₁_)
etaExpandClause
  body    =  IsTotalOrder.antisym (isTotalOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r ≤ x) y) (_ : (r ≤ y) x)
etaExpandClause
  body    =  IsTotalOrder.isEquivalence (isTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsTotalOrder.isPartialOrder (isTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsTotalOrder.isPreorder (isTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsTotalOrder.refl (isTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsTotalOrder.reflexive (isTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsTotalOrder.total (isTotalOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsTotalOrder.trans (isTotalOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≤ i) j) (_ : (r ≤ j) k)
etaExpandClause
  body    =  IsTotalOrder.≤-resp-≈ (isTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsTotalOrder.≤-respʳ-≈ (isTotalOrder x₃)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {x : Carrier r} {x = x₁ : Carrier r}
             {y : Carrier r} (_ : (r ≈ x₁) y) (_ : (r ≤ x) x₁)
etaExpandClause
  body    =  IsTotalOrder.≤-respˡ-≈ (isTotalOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {y : Carrier r} {x : Carrier r}
             {y = y₁ : Carrier r} (_ : (r ≈ x) y₁) (_ : (r ≤ x) y)
etaExpandClause
  body    =  IsTotalOrder.Eq.refl (isTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsTotalOrder.Eq.reflexive (isTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : i ≡ j)
etaExpandClause
  body    =  IsTotalOrder.Eq.sym (isTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsTotalOrder.Eq.trans (isTotalOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≈ i) j) (_ : (r ≈ j) k)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; _≤_ = _≤_
             ; isPartialOrder = IsTotalOrder.isPartialOrder (isTotalOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: TotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  Poset.preorder (poset r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : TotalOrder c ℓ₁ ℓ₂)
Termination checking [Relation.Binary.TotalOrder, Relation.Binary.TotalOrder.Carrier,
 Relation.Binary.TotalOrder._≈_, Relation.Binary.TotalOrder._≤_,
 Relation.Binary.TotalOrder.isTotalOrder,
 Relation.Binary.TotalOrder._.antisym,
 Relation.Binary.TotalOrder._.isEquivalence,
 Relation.Binary.TotalOrder._.isPartialOrder,
 Relation.Binary.TotalOrder._.isPreorder,
 Relation.Binary.TotalOrder._.refl,
 Relation.Binary.TotalOrder._.reflexive,
 Relation.Binary.TotalOrder._.total,
 Relation.Binary.TotalOrder._.trans,
 Relation.Binary.TotalOrder._.∼-resp-≈,
 Relation.Binary.TotalOrder._.∼-respʳ-≈,
 Relation.Binary.TotalOrder._.∼-respˡ-≈,
 Relation.Binary.TotalOrder._.Eq.refl,
 Relation.Binary.TotalOrder._.Eq.reflexive,
 Relation.Binary.TotalOrder._.Eq.sym,
 Relation.Binary.TotalOrder._.Eq.trans,
 Relation.Binary.TotalOrder.poset,
 Relation.Binary.TotalOrder._.preorder,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.TotalOrder.poset]
etaExpandClause
  body    =  IsTotalOrder.≤-respˡ-≈ isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsTotalOrder.≤-respʳ-≈ isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsTotalOrder.≤-resp-≈ isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsTotalOrder.trans isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsTotalOrder.total isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             (x : A) (y : A)
etaExpandClause
  body    =  IsTotalOrder.reflexive isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsTotalOrder.refl isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsTotalOrder.isPreorder isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsTotalOrder.isPartialOrder isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsTotalOrder.isEquivalence isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsTotalOrder.antisym isTotalOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {x : A} {y : A} (_ : x ≤ y) (_ : y ≤ x)
etaExpandClause
  body    =  IsDecEquivalence.trans isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsDecEquivalence.sym isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.reflexive isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.refl isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             (x : A) (y : A)
etaExpandClause
  body    =  isTotalOrder
  xs      =  []
  new tel =  (isTotalOrder₁ : IsTotalOrder @2 @1)
             (_≟₁_ : Decidable @3) (_≤?₁_ : Decidable @3)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (isTotalOrder₁ : IsTotalOrder @2 @1)
             (_≟₁_ : Decidable @3) (_≤?₁_ : Decidable @3) (x : @3) (y : @4)
etaExpandClause
  body    =  y
  xs      =  []
  new tel =  (isTotalOrder₁ : IsTotalOrder @2 @1)
             (_≟₁_ : Decidable @3) (_≤?₁_ : Decidable @3) (x : @3) (y : @4)
etaExpandClause
  body    =  IsTotalOrder.antisym (isTotalOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {x : A} {y : A} (_ : x ≤ y) (_ : y ≤ x)
etaExpandClause
  body    =  IsTotalOrder.isEquivalence (isTotalOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsTotalOrder.isPartialOrder (isTotalOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsTotalOrder.isPreorder (isTotalOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsTotalOrder.refl (isTotalOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsTotalOrder.reflexive (isTotalOrder x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsTotalOrder.total (isTotalOrder y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             (x : A) (y : A)
etaExpandClause
  body    =  IsTotalOrder.trans (isTotalOrder x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsTotalOrder.≤-resp-≈ (isTotalOrder r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsTotalOrder.≤-respʳ-≈ (isTotalOrder x₃)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsTotalOrder.≤-respˡ-≈ (isTotalOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  record
             { isEquivalence =
                 IsPartialOrder.isEquivalence
                 (IsTotalOrder.isPartialOrder (isTotalOrder))
             ; _≟_ = _≟_
             }
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (: IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ (isDecEquivalence y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             (x : A) (y : A)
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence (isDecEquivalence r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
etaExpandClause
  body    =  IsDecEquivalence.refl (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {x : A}
etaExpandClause
  body    =  IsDecEquivalence.reflexive (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.sym (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.trans (isDecEquivalence x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_≤_ : Rel A ℓ₂} (r : IsDecTotalOrder _≈_ _≤_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
Termination checking [Relation.Binary.IsDecTotalOrder,
 Relation.Binary.IsDecTotalOrder.isTotalOrder,
 Relation.Binary.IsDecTotalOrder._≟_,
 Relation.Binary.IsDecTotalOrder._≤?_,
 Relation.Binary.IsDecTotalOrder._.antisym,
 Relation.Binary.IsDecTotalOrder._.isEquivalence,
 Relation.Binary.IsDecTotalOrder._.isPartialOrder,
 Relation.Binary.IsDecTotalOrder._.isPreorder,
 Relation.Binary.IsDecTotalOrder._.refl,
 Relation.Binary.IsDecTotalOrder._.reflexive,
 Relation.Binary.IsDecTotalOrder._.total,
 Relation.Binary.IsDecTotalOrder._.trans,
 Relation.Binary.IsDecTotalOrder._.∼-resp-≈,
 Relation.Binary.IsDecTotalOrder._.∼-respʳ-≈,
 Relation.Binary.IsDecTotalOrder._.∼-respˡ-≈,
 Relation.Binary.IsDecTotalOrder.Eq.isDecEquivalence,
 Relation.Binary.IsDecTotalOrder.Eq._._≟_,
 Relation.Binary.IsDecTotalOrder.Eq._.isEquivalence,
 Relation.Binary.IsDecTotalOrder.Eq._.refl,
 Relation.Binary.IsDecTotalOrder.Eq._.reflexive,
 Relation.Binary.IsDecTotalOrder.Eq._.sym,
 Relation.Binary.IsDecTotalOrder.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsDecTotalOrder.Eq.isDecEquivalence]
etaExpandClause
  body    =  IsDecTotalOrder.Eq.trans isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             {k : Carrier} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.sym isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.reflexive isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.refl isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsDecTotalOrder.Eq.isEquivalence isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.isDecEquivalence isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.Eq._≟_ isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsDecTotalOrder.≤-respˡ-≈ isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {y : Carrier} {x : Carrier}
             {y = y₁ : Carrier} (_ : x ≈ y₁) (_ : x ≤ y)
etaExpandClause
  body    =  IsDecTotalOrder.≤-respʳ-≈ isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : Carrier} {x = x₁ : Carrier}
             {y : Carrier} (_ : x₁ ≈ y) (_ : x ≤ x₁)
etaExpandClause
  body    =  IsDecTotalOrder.≤-resp-≈ isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.trans isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             {k : Carrier} (_ : i ≤ j) (_ : j ≤ k)
etaExpandClause
  body    =  IsDecTotalOrder.total isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsDecTotalOrder.reflexive isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecTotalOrder.refl isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : Carrier}
etaExpandClause
  body    =  IsDecTotalOrder.isTotalOrder isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.isPreorder isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.isPartialOrder isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.isEquivalence isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.antisym isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier} (_ : x ≤ y)
             (_ : y ≤ x)
etaExpandClause
  body    =  IsDecTotalOrder._≤?_ isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsDecTotalOrder._≟_ isDecTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  TotalOrder.preorder totalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  TotalOrder.poset totalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.trans decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} {k : DecSetoid.Carrier decSetoid}
             (_ : (decSetoid DecSetoid.≈ i) j) (_ : (decSetoid DecSetoid.≈ j) k)
etaExpandClause
  body    =  DecSetoid.sym decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} (_ : (decSetoid DecSetoid.≈ i) j)
etaExpandClause
  body    =  DecSetoid.setoid decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.reflexive decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} (_ : i ≡ j)
etaExpandClause
  body    =  DecSetoid.refl decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : DecSetoid.Carrier decSetoid}
etaExpandClause
  body    =  DecSetoid.preorder decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isEquivalence decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isDecEquivalence decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.Carrier decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid._≟_ decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : DecSetoid.Carrier decSetoid)
             (y : DecSetoid.Carrier decSetoid)
etaExpandClause
  body    =  DecSetoid._≈_ decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (_ : DecSetoid.Carrier decSetoid)
             (_ : DecSetoid.Carrier decSetoid)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isDecTotalOrder₁ : IsDecTotalOrder _≈₁_ _≤₁_)
etaExpandClause
  body    =  isDecTotalOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isDecTotalOrder₁ : IsDecTotalOrder _≈₁_ _≤₁_)
             (_ : Carrier isDecTotalOrder₁) (_ : Carrier isDecTotalOrder₁)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isDecTotalOrder₁ : IsDecTotalOrder _≈₁_ _≤₁_)
             (_ : Carrier isDecTotalOrder₁) (_ : Carrier isDecTotalOrder₁)
etaExpandClause
  body    =  isDecTotalOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_≤₁_ : Rel Carrier₁ @3)
             (isDecTotalOrder₁ : IsDecTotalOrder _≈₁_ _≤₁_)
etaExpandClause
  body    =  IsDecTotalOrder._≟_ (isDecTotalOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecTotalOrder._≤?_ (isDecTotalOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecTotalOrder.antisym (isDecTotalOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r ≤ x) y) (_ : (r ≤ y) x)
etaExpandClause
  body    =  IsDecTotalOrder.isEquivalence (isDecTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.isPartialOrder (isDecTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.isPreorder (isDecTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.isTotalOrder (isDecTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.refl (isDecTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsDecTotalOrder.reflexive (isDecTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsDecTotalOrder.total (isDecTotalOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecTotalOrder.trans (isDecTotalOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≤ i) j) (_ : (r ≤ j) k)
etaExpandClause
  body    =  IsDecTotalOrder.≤-resp-≈ (isDecTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.≤-respʳ-≈ (isDecTotalOrder x₃)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : Carrier r} {x = x₁ : Carrier r}
             {y : Carrier r} (_ : (r ≈ x₁) y) (_ : (r ≤ x) x₁)
etaExpandClause
  body    =  IsDecTotalOrder.≤-respˡ-≈ (isDecTotalOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {y : Carrier r} {x : Carrier r}
             {y = y₁ : Carrier r} (_ : (r ≈ x) y₁) (_ : (r ≤ x) y)
etaExpandClause
  body    =  IsDecTotalOrder.Eq._≟_ (isDecTotalOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.isDecEquivalence
             (isDecTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.isEquivalence (isDecTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.refl (isDecTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : Carrier r}
etaExpandClause
  body    =  IsDecTotalOrder.Eq.reflexive (isDecTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : i ≡ j)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.sym (isDecTotalOrder x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             (_ : (r ≈ i) j)
etaExpandClause
  body    =  IsDecTotalOrder.Eq.trans (isDecTotalOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r ≈ i) j) (_ : (r ≈ j) k)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; _≤_ = _≤_
             ; isTotalOrder = IsDecTotalOrder.isTotalOrder (isDecTotalOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  TotalOrder.poset (totalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  TotalOrder.preorder (totalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; isDecEquivalence =
                 IsDecTotalOrder.Eq.isDecEquivalence (isDecTotalOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid._≈_ (decSetoid x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (_ : DecSetoid.Carrier (decSetoid r))
             (_ : DecSetoid.Carrier (decSetoid r))
etaExpandClause
  body    =  DecSetoid._≟_ (decSetoid y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) (x : DecSetoid.Carrier (decSetoid r))
             (y : DecSetoid.Carrier (decSetoid r))
etaExpandClause
  body    =  DecSetoid.Carrier (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isDecEquivalence (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isEquivalence (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.preorder (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.refl (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {x : DecSetoid.Carrier (decSetoid r)}
etaExpandClause
  body    =  DecSetoid.reflexive (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)} (_ : i ≡ j)
etaExpandClause
  body    =  DecSetoid.setoid (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.sym (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)}
             (_ : (decSetoid r DecSetoid.≈ i) j)
etaExpandClause
  body    =  DecSetoid.trans (decSetoid x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : DecTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)}
             {k : DecSetoid.Carrier (decSetoid r)}
             (_ : (decSetoid r DecSetoid.≈ i) j)
             (_ : (decSetoid r DecSetoid.≈ j) k)
Termination checking [Relation.Binary.DecTotalOrder,
 Relation.Binary.DecTotalOrder.Carrier,
 Relation.Binary.DecTotalOrder._≈_,
 Relation.Binary.DecTotalOrder._≤_,
 Relation.Binary.DecTotalOrder.isDecTotalOrder,
 Relation.Binary.DecTotalOrder.DTO._≟_,
 Relation.Binary.DecTotalOrder.DTO._≤?_,
 Relation.Binary.DecTotalOrder.DTO.antisym,
 Relation.Binary.DecTotalOrder.DTO.isEquivalence,
 Relation.Binary.DecTotalOrder.DTO.isPartialOrder,
 Relation.Binary.DecTotalOrder.DTO.isPreorder,
 Relation.Binary.DecTotalOrder.DTO.isTotalOrder,
 Relation.Binary.DecTotalOrder.DTO.refl,
 Relation.Binary.DecTotalOrder.DTO.reflexive,
 Relation.Binary.DecTotalOrder.DTO.total,
 Relation.Binary.DecTotalOrder.DTO.trans,
 Relation.Binary.DecTotalOrder.DTO.∼-resp-≈,
 Relation.Binary.DecTotalOrder.DTO.∼-respʳ-≈,
 Relation.Binary.DecTotalOrder.DTO.∼-respˡ-≈,
 Relation.Binary.DecTotalOrder.DTO.Eq._≟_,
 Relation.Binary.DecTotalOrder.DTO.Eq.isDecEquivalence,
 Relation.Binary.DecTotalOrder.DTO.Eq.isEquivalence,
 Relation.Binary.DecTotalOrder.DTO.Eq.refl,
 Relation.Binary.DecTotalOrder.DTO.Eq.reflexive,
 Relation.Binary.DecTotalOrder.DTO.Eq.sym,
 Relation.Binary.DecTotalOrder.DTO.Eq.trans,
 Relation.Binary.DecTotalOrder.totalOrder,
 Relation.Binary.DecTotalOrder._.poset,
 Relation.Binary.DecTotalOrder._.preorder,
 Relation.Binary.DecTotalOrder.Eq.decSetoid,
 Relation.Binary.DecTotalOrder.Eq._._≈_,
 Relation.Binary.DecTotalOrder.Eq._._≟_,
 Relation.Binary.DecTotalOrder.Eq._.Carrier,
 Relation.Binary.DecTotalOrder.Eq._.isDecEquivalence,
 Relation.Binary.DecTotalOrder.Eq._.isEquivalence,
 Relation.Binary.DecTotalOrder.Eq._.preorder,
 Relation.Binary.DecTotalOrder.Eq._.refl,
 Relation.Binary.DecTotalOrder.Eq._.reflexive,
 Relation.Binary.DecTotalOrder.Eq._.setoid,
 Relation.Binary.DecTotalOrder.Eq._.sym,
 Relation.Binary.DecTotalOrder.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.DecTotalOrder.totalOrder]
Termination checking [Relation.Binary.DecTotalOrder,
 Relation.Binary.DecTotalOrder.Carrier,
 Relation.Binary.DecTotalOrder._≈_,
 Relation.Binary.DecTotalOrder._≤_,
 Relation.Binary.DecTotalOrder.isDecTotalOrder,
 Relation.Binary.DecTotalOrder.DTO._≟_,
 Relation.Binary.DecTotalOrder.DTO._≤?_,
 Relation.Binary.DecTotalOrder.DTO.antisym,
 Relation.Binary.DecTotalOrder.DTO.isEquivalence,
 Relation.Binary.DecTotalOrder.DTO.isPartialOrder,
 Relation.Binary.DecTotalOrder.DTO.isPreorder,
 Relation.Binary.DecTotalOrder.DTO.isTotalOrder,
 Relation.Binary.DecTotalOrder.DTO.refl,
 Relation.Binary.DecTotalOrder.DTO.reflexive,
 Relation.Binary.DecTotalOrder.DTO.total,
 Relation.Binary.DecTotalOrder.DTO.trans,
 Relation.Binary.DecTotalOrder.DTO.∼-resp-≈,
 Relation.Binary.DecTotalOrder.DTO.∼-respʳ-≈,
 Relation.Binary.DecTotalOrder.DTO.∼-respˡ-≈,
 Relation.Binary.DecTotalOrder.DTO.Eq._≟_,
 Relation.Binary.DecTotalOrder.DTO.Eq.isDecEquivalence,
 Relation.Binary.DecTotalOrder.DTO.Eq.isEquivalence,
 Relation.Binary.DecTotalOrder.DTO.Eq.refl,
 Relation.Binary.DecTotalOrder.DTO.Eq.reflexive,
 Relation.Binary.DecTotalOrder.DTO.Eq.sym,
 Relation.Binary.DecTotalOrder.DTO.Eq.trans,
 Relation.Binary.DecTotalOrder.totalOrder,
 Relation.Binary.DecTotalOrder._.poset,
 Relation.Binary.DecTotalOrder._.preorder,
 Relation.Binary.DecTotalOrder.Eq.decSetoid,
 Relation.Binary.DecTotalOrder.Eq._._≈_,
 Relation.Binary.DecTotalOrder.Eq._._≟_,
 Relation.Binary.DecTotalOrder.Eq._.Carrier,
 Relation.Binary.DecTotalOrder.Eq._.isDecEquivalence,
 Relation.Binary.DecTotalOrder.Eq._.isEquivalence,
 Relation.Binary.DecTotalOrder.Eq._.preorder,
 Relation.Binary.DecTotalOrder.Eq._.refl,
 Relation.Binary.DecTotalOrder.Eq._.reflexive,
 Relation.Binary.DecTotalOrder.Eq._.setoid,
 Relation.Binary.DecTotalOrder.Eq._.sym,
 Relation.Binary.DecTotalOrder.Eq._.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.DecTotalOrder.Eq.decSetoid]
etaExpandClause
  body    =  IsDecEquivalence.trans isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  IsDecEquivalence.sym isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.reflexive isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.refl isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {x : A}
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ isDecEquivalence
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             (x : A) (y : A)
etaExpandClause
  body    =  IsStrictPartialOrder.irrefl isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {x : A} {y : A} (_ : x ≈ y) (_ : x < y)
etaExpandClause
  body    =  IsStrictPartialOrder.asym isStrictPartialOrder
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {x : A} {y : A} (_ : x < y) (_ : y < x)
etaExpandClause
  body    =  isEquivalence
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (trans₁ : Transitive @2) (compare₁ : Trichotomous @4 @3)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (trans₁ : Transitive @2) (compare₁ : Trichotomous @4 @3) {i : @3}
             {j : @4} {k : @5} (_ : trans₁ i j) (_ : trans₁ j k)
etaExpandClause
  body    =  y
  xs      =  []
  new tel =  (isEquivalence₁ : IsEquivalence @2)
             (trans₁ : Transitive @2) (compare₁ : Trichotomous @4 @3) (x : @3)
             (y : @4)
etaExpandClause
  body    =  tri⟶dec≈ (compare y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictTotalOrder _≈_ _<_)
             (x : A) (y : A)
etaExpandClause
  body    =  tri⟶dec< (compare y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictTotalOrder _≈_ _<_)
             (x : A) (y : A)
etaExpandClause
  body    =  record { isEquivalence = isEquivalence ; _≟_ = _≟_ }
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictTotalOrder _≈_ _<_)
etaExpandClause
  body    =  IsDecEquivalence._≟_ (isDecEquivalence y)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             (x : A) (y : A)
etaExpandClause
  body    =  IsDecEquivalence.isEquivalence (isDecEquivalence r)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
etaExpandClause
  body    =  IsDecEquivalence.refl (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {x : A}
etaExpandClause
  body    =  IsDecEquivalence.reflexive (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {i : A} {j : A} (_ : i ≡ j)
etaExpandClause
  body    =  IsDecEquivalence.sym (isDecEquivalence x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {i : A} {j : A} (_ : i ≈ j)
etaExpandClause
  body    =  IsDecEquivalence.trans (isDecEquivalence x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {i : A} {j : A} {k : A} (_ : i ≈ j) (_ : j ≈ k)
etaExpandClause
  body    =  trans∧tri⟶respˡ≈
             (IsEquivalence.trans
              (IsDecEquivalence.isEquivalence (isDecEquivalence x)))
             (trans x) (compare x)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictTotalOrder _≈_ _<_)
             {y : A} {x : A} {y = y₁ : A} (_ : x ≈ y₁) (_ : x < y)
etaExpandClause
  body    =  trans∧tri⟶respʳ≈
             (IsEquivalence.sym
              (IsDecEquivalence.isEquivalence (isDecEquivalence x₁)))
             (IsEquivalence.trans
              (IsDecEquivalence.isEquivalence (isDecEquivalence x₁)))
             (trans x₁) (compare x₁)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictTotalOrder _≈_ _<_)
             {x : A} {x = x₁ : A} {y : A} (_ : x₁ ≈ y) (_ : x < x₁)
etaExpandClause
  body    =  <-respʳ-≈ , <-respˡ-≈
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictTotalOrder _≈_ _<_)
etaExpandClause
  body    =  record
             { isEquivalence = isEquivalence
             ; irrefl = tri⟶irr (compare)
             ; trans = trans
             ; <-resp-≈ = <-resp-≈
             }
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (: IsStrictTotalOrder _≈_ _<_)
etaExpandClause
  body    =  IsStrictPartialOrder.asym (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {x : A} {y : A} (_ : x < y) (_ : y < x)
etaExpandClause
  body    =  IsStrictPartialOrder.irrefl (isStrictPartialOrder x₂)
  xs      =  []
  new tel =  {a : Level} {ℓ₁ : Level} {ℓ₂ : Level} {A : Set a}
             {_≈_ : Rel A ℓ₁} {_<_ : Rel A ℓ₂} (r : IsStrictTotalOrder _≈_ _<_)
             {x : A} {y : A} (_ : x ≈ y) (_ : x < y)
Termination checking [Relation.Binary.IsStrictTotalOrder,
 Relation.Binary.IsStrictTotalOrder.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.trans,
 Relation.Binary.IsStrictTotalOrder.compare,
 Relation.Binary.IsStrictTotalOrder._≟_,
 Relation.Binary.IsStrictTotalOrder._<?_,
 Relation.Binary.IsStrictTotalOrder.isDecEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq._≟_,
 Relation.Binary.IsStrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq.refl,
 Relation.Binary.IsStrictTotalOrder.Eq.reflexive,
 Relation.Binary.IsStrictTotalOrder.Eq.sym,
 Relation.Binary.IsStrictTotalOrder.Eq.trans,
 Relation.Binary.IsStrictTotalOrder.<-respˡ-≈,
 Relation.Binary.IsStrictTotalOrder.<-respʳ-≈,
 Relation.Binary.IsStrictTotalOrder.<-resp-≈,
 Relation.Binary.IsStrictTotalOrder.isStrictPartialOrder,
 Relation.Binary.IsStrictTotalOrder._.asym,
 Relation.Binary.IsStrictTotalOrder._.irrefl,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictTotalOrder._≟_]
Termination checking [Relation.Binary.IsStrictTotalOrder,
 Relation.Binary.IsStrictTotalOrder.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.trans,
 Relation.Binary.IsStrictTotalOrder.compare,
 Relation.Binary.IsStrictTotalOrder._≟_,
 Relation.Binary.IsStrictTotalOrder._<?_,
 Relation.Binary.IsStrictTotalOrder.isDecEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq._≟_,
 Relation.Binary.IsStrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq.refl,
 Relation.Binary.IsStrictTotalOrder.Eq.reflexive,
 Relation.Binary.IsStrictTotalOrder.Eq.sym,
 Relation.Binary.IsStrictTotalOrder.Eq.trans,
 Relation.Binary.IsStrictTotalOrder.<-respˡ-≈,
 Relation.Binary.IsStrictTotalOrder.<-respʳ-≈,
 Relation.Binary.IsStrictTotalOrder.<-resp-≈,
 Relation.Binary.IsStrictTotalOrder.isStrictPartialOrder,
 Relation.Binary.IsStrictTotalOrder._.asym,
 Relation.Binary.IsStrictTotalOrder._.irrefl,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictTotalOrder._<?_]
Termination checking [Relation.Binary.IsStrictTotalOrder,
 Relation.Binary.IsStrictTotalOrder.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.trans,
 Relation.Binary.IsStrictTotalOrder.compare,
 Relation.Binary.IsStrictTotalOrder._≟_,
 Relation.Binary.IsStrictTotalOrder._<?_,
 Relation.Binary.IsStrictTotalOrder.isDecEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq._≟_,
 Relation.Binary.IsStrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq.refl,
 Relation.Binary.IsStrictTotalOrder.Eq.reflexive,
 Relation.Binary.IsStrictTotalOrder.Eq.sym,
 Relation.Binary.IsStrictTotalOrder.Eq.trans,
 Relation.Binary.IsStrictTotalOrder.<-respˡ-≈,
 Relation.Binary.IsStrictTotalOrder.<-respʳ-≈,
 Relation.Binary.IsStrictTotalOrder.<-resp-≈,
 Relation.Binary.IsStrictTotalOrder.isStrictPartialOrder,
 Relation.Binary.IsStrictTotalOrder._.asym,
 Relation.Binary.IsStrictTotalOrder._.irrefl,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictTotalOrder.isDecEquivalence]
Termination checking [Relation.Binary.IsStrictTotalOrder,
 Relation.Binary.IsStrictTotalOrder.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.trans,
 Relation.Binary.IsStrictTotalOrder.compare,
 Relation.Binary.IsStrictTotalOrder._≟_,
 Relation.Binary.IsStrictTotalOrder._<?_,
 Relation.Binary.IsStrictTotalOrder.isDecEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq._≟_,
 Relation.Binary.IsStrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq.refl,
 Relation.Binary.IsStrictTotalOrder.Eq.reflexive,
 Relation.Binary.IsStrictTotalOrder.Eq.sym,
 Relation.Binary.IsStrictTotalOrder.Eq.trans,
 Relation.Binary.IsStrictTotalOrder.<-respˡ-≈,
 Relation.Binary.IsStrictTotalOrder.<-respʳ-≈,
 Relation.Binary.IsStrictTotalOrder.<-resp-≈,
 Relation.Binary.IsStrictTotalOrder.isStrictPartialOrder,
 Relation.Binary.IsStrictTotalOrder._.asym,
 Relation.Binary.IsStrictTotalOrder._.irrefl,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictTotalOrder.<-respˡ-≈]
Termination checking [Relation.Binary.IsStrictTotalOrder,
 Relation.Binary.IsStrictTotalOrder.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.trans,
 Relation.Binary.IsStrictTotalOrder.compare,
 Relation.Binary.IsStrictTotalOrder._≟_,
 Relation.Binary.IsStrictTotalOrder._<?_,
 Relation.Binary.IsStrictTotalOrder.isDecEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq._≟_,
 Relation.Binary.IsStrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq.refl,
 Relation.Binary.IsStrictTotalOrder.Eq.reflexive,
 Relation.Binary.IsStrictTotalOrder.Eq.sym,
 Relation.Binary.IsStrictTotalOrder.Eq.trans,
 Relation.Binary.IsStrictTotalOrder.<-respˡ-≈,
 Relation.Binary.IsStrictTotalOrder.<-respʳ-≈,
 Relation.Binary.IsStrictTotalOrder.<-resp-≈,
 Relation.Binary.IsStrictTotalOrder.isStrictPartialOrder,
 Relation.Binary.IsStrictTotalOrder._.asym,
 Relation.Binary.IsStrictTotalOrder._.irrefl,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictTotalOrder.<-respʳ-≈]
Termination checking [Relation.Binary.IsStrictTotalOrder,
 Relation.Binary.IsStrictTotalOrder.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.trans,
 Relation.Binary.IsStrictTotalOrder.compare,
 Relation.Binary.IsStrictTotalOrder._≟_,
 Relation.Binary.IsStrictTotalOrder._<?_,
 Relation.Binary.IsStrictTotalOrder.isDecEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq._≟_,
 Relation.Binary.IsStrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq.refl,
 Relation.Binary.IsStrictTotalOrder.Eq.reflexive,
 Relation.Binary.IsStrictTotalOrder.Eq.sym,
 Relation.Binary.IsStrictTotalOrder.Eq.trans,
 Relation.Binary.IsStrictTotalOrder.<-respˡ-≈,
 Relation.Binary.IsStrictTotalOrder.<-respʳ-≈,
 Relation.Binary.IsStrictTotalOrder.<-resp-≈,
 Relation.Binary.IsStrictTotalOrder.isStrictPartialOrder,
 Relation.Binary.IsStrictTotalOrder._.asym,
 Relation.Binary.IsStrictTotalOrder._.irrefl,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictTotalOrder.<-resp-≈]
Termination checking [Relation.Binary.IsStrictTotalOrder,
 Relation.Binary.IsStrictTotalOrder.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.trans,
 Relation.Binary.IsStrictTotalOrder.compare,
 Relation.Binary.IsStrictTotalOrder._≟_,
 Relation.Binary.IsStrictTotalOrder._<?_,
 Relation.Binary.IsStrictTotalOrder.isDecEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq._≟_,
 Relation.Binary.IsStrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.IsStrictTotalOrder.Eq.refl,
 Relation.Binary.IsStrictTotalOrder.Eq.reflexive,
 Relation.Binary.IsStrictTotalOrder.Eq.sym,
 Relation.Binary.IsStrictTotalOrder.Eq.trans,
 Relation.Binary.IsStrictTotalOrder.<-respˡ-≈,
 Relation.Binary.IsStrictTotalOrder.<-respʳ-≈,
 Relation.Binary.IsStrictTotalOrder.<-resp-≈,
 Relation.Binary.IsStrictTotalOrder.isStrictPartialOrder,
 Relation.Binary.IsStrictTotalOrder._.asym,
 Relation.Binary.IsStrictTotalOrder._.irrefl,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.IsStrictTotalOrder.isStrictPartialOrder]
etaExpandClause
  body    =  IsStrictTotalOrder.trans isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {i : Carrier} {j : Carrier}
             {k : Carrier} (_ : i < j) (_ : j < k)
etaExpandClause
  body    =  IsStrictTotalOrder.isStrictPartialOrder
             isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictTotalOrder.isEquivalence isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictTotalOrder.isDecEquivalence isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictTotalOrder.irrefl isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier}
             (_ : x ≈ y) (_ : x < y)
etaExpandClause
  body    =  IsStrictTotalOrder.compare isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsStrictTotalOrder.asym isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {x : Carrier} {y : Carrier}
             (_ : x < y) (_ : y < x)
etaExpandClause
  body    =  IsStrictTotalOrder.<-respˡ-≈ isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {y : Carrier} {x : Carrier}
             {y = y₁ : Carrier} (_ : x ≈ y₁) (_ : x < y)
etaExpandClause
  body    =  IsStrictTotalOrder.<-respʳ-≈ isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {x : Carrier} {x = x₁ : Carrier}
             {y : Carrier} (_ : x₁ ≈ y) (_ : x < x₁)
etaExpandClause
  body    =  IsStrictTotalOrder.<-resp-≈ isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictTotalOrder._≟_ isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  IsStrictTotalOrder._<?_ isStrictTotalOrder
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) (x : Carrier) (y : Carrier)
etaExpandClause
  body    =  DecSetoid.trans decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} {k : DecSetoid.Carrier decSetoid}
             (_ : (decSetoid DecSetoid.≈ i) j) (_ : (decSetoid DecSetoid.≈ j) k)
etaExpandClause
  body    =  DecSetoid.sym decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} (_ : (decSetoid DecSetoid.≈ i) j)
etaExpandClause
  body    =  DecSetoid.setoid decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.reflexive decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {i : DecSetoid.Carrier decSetoid}
             {j : DecSetoid.Carrier decSetoid} (_ : i ≡ j)
etaExpandClause
  body    =  DecSetoid.refl decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {x : DecSetoid.Carrier decSetoid}
etaExpandClause
  body    =  DecSetoid.preorder decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isEquivalence decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isDecEquivalence decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.Carrier decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid._≟_ decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) (x : DecSetoid.Carrier decSetoid)
             (y : DecSetoid.Carrier decSetoid)
etaExpandClause
  body    =  DecSetoid._≈_ decSetoid
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) (_ : DecSetoid.Carrier decSetoid)
             (_ : DecSetoid.Carrier decSetoid)
etaExpandClause
  body    =  Carrier
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isStrictTotalOrder₁ : IsStrictTotalOrder _≈₁_ _<₁_)
etaExpandClause
  body    =  isStrictTotalOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isStrictTotalOrder₁ : IsStrictTotalOrder _≈₁_ _<₁_)
             (_ : Carrier isStrictTotalOrder₁) (_ : Carrier isStrictTotalOrder₁)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isStrictTotalOrder₁ : IsStrictTotalOrder _≈₁_ _<₁_)
             (_ : Carrier isStrictTotalOrder₁) (_ : Carrier isStrictTotalOrder₁)
etaExpandClause
  body    =  isStrictTotalOrder
  xs      =  []
  new tel =  (Carrier₁ : Set @3) (_≈₁_ : Rel Carrier₁ @3)
             (_<₁_ : Rel Carrier₁ @3)
             (isStrictTotalOrder₁ : IsStrictTotalOrder _≈₁_ _<₁_)
etaExpandClause
  body    =  IsStrictTotalOrder._<?_ (isStrictTotalOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsStrictTotalOrder._≟_ (isStrictTotalOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsStrictTotalOrder.<-resp-≈ (isStrictTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictTotalOrder.<-respʳ-≈ (isStrictTotalOrder x₃)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {x : Carrier r} {x = x₁ : Carrier r}
             {y : Carrier r} (_ : (r ≈ x₁) y) (_ : (r < x) x₁)
etaExpandClause
  body    =  IsStrictTotalOrder.<-respˡ-≈ (isStrictTotalOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {y : Carrier r} {x : Carrier r}
             {y = y₁ : Carrier r} (_ : (r ≈ x) y₁) (_ : (r < x) y)
etaExpandClause
  body    =  IsStrictTotalOrder.asym (isStrictTotalOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r < x) y) (_ : (r < y) x)
etaExpandClause
  body    =  IsStrictTotalOrder.compare (isStrictTotalOrder y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) (x : Carrier r) (y : Carrier r)
etaExpandClause
  body    =  IsStrictTotalOrder.irrefl (isStrictTotalOrder x₂)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {x : Carrier r} {y : Carrier r}
             (_ : (r ≈ x) y) (_ : (r < x) y)
etaExpandClause
  body    =  IsStrictTotalOrder.isDecEquivalence
             (isStrictTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictTotalOrder.isEquivalence
             (isStrictTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictTotalOrder.isStrictPartialOrder
             (isStrictTotalOrder r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsStrictTotalOrder.trans (isStrictTotalOrder x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂) {i : Carrier r} {j : Carrier r}
             {k : Carrier r} (_ : (r < i) j) (_ : (r < j) k)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; _<_ = _<_
             ; isStrictPartialOrder =
                 IsStrictTotalOrder.isStrictPartialOrder (isStrictTotalOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  record
             { Carrier = Carrier
             ; _≈_ = _≈_
             ; isDecEquivalence =
                 IsStrictTotalOrder.isDecEquivalence (isStrictTotalOrder)
             }
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (: StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid._≈_ (decSetoid x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
             (_ : DecSetoid.Carrier (decSetoid r))
             (_ : DecSetoid.Carrier (decSetoid r))
etaExpandClause
  body    =  DecSetoid._≟_ (decSetoid y)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
             (x : DecSetoid.Carrier (decSetoid r))
             (y : DecSetoid.Carrier (decSetoid r))
etaExpandClause
  body    =  DecSetoid.Carrier (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isDecEquivalence (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.isEquivalence (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.preorder (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.refl (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
             {x : DecSetoid.Carrier (decSetoid r)}
etaExpandClause
  body    =  DecSetoid.reflexive (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)} (_ : i ≡ j)
etaExpandClause
  body    =  DecSetoid.setoid (decSetoid r)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
etaExpandClause
  body    =  DecSetoid.sym (decSetoid x)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)}
             (_ : (decSetoid r DecSetoid.≈ i) j)
etaExpandClause
  body    =  DecSetoid.trans (decSetoid x₁)
  xs      =  []
  new tel =  {c : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             (r : StrictTotalOrder c ℓ₁ ℓ₂)
             {i : DecSetoid.Carrier (decSetoid r)}
             {j : DecSetoid.Carrier (decSetoid r)}
             {k : DecSetoid.Carrier (decSetoid r)}
             (_ : (decSetoid r DecSetoid.≈ i) j)
             (_ : (decSetoid r DecSetoid.≈ j) k)
Termination checking [Relation.Binary.StrictTotalOrder,
 Relation.Binary.StrictTotalOrder.Carrier,
 Relation.Binary.StrictTotalOrder._≈_,
 Relation.Binary.StrictTotalOrder._<_,
 Relation.Binary.StrictTotalOrder.isStrictTotalOrder,
 Relation.Binary.StrictTotalOrder._._<?_,
 Relation.Binary.StrictTotalOrder._._≟_,
 Relation.Binary.StrictTotalOrder._.<-resp-≈,
 Relation.Binary.StrictTotalOrder._.<-respʳ-≈,
 Relation.Binary.StrictTotalOrder._.<-respˡ-≈,
 Relation.Binary.StrictTotalOrder._.asym,
 Relation.Binary.StrictTotalOrder._.compare,
 Relation.Binary.StrictTotalOrder._.irrefl,
 Relation.Binary.StrictTotalOrder._.isDecEquivalence,
 Relation.Binary.StrictTotalOrder._.isEquivalence,
 Relation.Binary.StrictTotalOrder._.isStrictPartialOrder,
 Relation.Binary.StrictTotalOrder._.trans,
 Relation.Binary.StrictTotalOrder.strictPartialOrder,
 Relation.Binary.StrictTotalOrder.decSetoid,
 Relation.Binary.StrictTotalOrder.Eq._≈_,
 Relation.Binary.StrictTotalOrder.Eq._≟_,
 Relation.Binary.StrictTotalOrder.Eq.Carrier,
 Relation.Binary.StrictTotalOrder.Eq.isDecEquivalence,
 Relation.Binary.StrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.StrictTotalOrder.Eq.preorder,
 Relation.Binary.StrictTotalOrder.Eq.refl,
 Relation.Binary.StrictTotalOrder.Eq.reflexive,
 Relation.Binary.StrictTotalOrder.Eq.setoid,
 Relation.Binary.StrictTotalOrder.Eq.sym,
 Relation.Binary.StrictTotalOrder.Eq.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.StrictTotalOrder.strictPartialOrder]
Termination checking [Relation.Binary.StrictTotalOrder,
 Relation.Binary.StrictTotalOrder.Carrier,
 Relation.Binary.StrictTotalOrder._≈_,
 Relation.Binary.StrictTotalOrder._<_,
 Relation.Binary.StrictTotalOrder.isStrictTotalOrder,
 Relation.Binary.StrictTotalOrder._._<?_,
 Relation.Binary.StrictTotalOrder._._≟_,
 Relation.Binary.StrictTotalOrder._.<-resp-≈,
 Relation.Binary.StrictTotalOrder._.<-respʳ-≈,
 Relation.Binary.StrictTotalOrder._.<-respˡ-≈,
 Relation.Binary.StrictTotalOrder._.asym,
 Relation.Binary.StrictTotalOrder._.compare,
 Relation.Binary.StrictTotalOrder._.irrefl,
 Relation.Binary.StrictTotalOrder._.isDecEquivalence,
 Relation.Binary.StrictTotalOrder._.isEquivalence,
 Relation.Binary.StrictTotalOrder._.isStrictPartialOrder,
 Relation.Binary.StrictTotalOrder._.trans,
 Relation.Binary.StrictTotalOrder.strictPartialOrder,
 Relation.Binary.StrictTotalOrder.decSetoid,
 Relation.Binary.StrictTotalOrder.Eq._≈_,
 Relation.Binary.StrictTotalOrder.Eq._≟_,
 Relation.Binary.StrictTotalOrder.Eq.Carrier,
 Relation.Binary.StrictTotalOrder.Eq.isDecEquivalence,
 Relation.Binary.StrictTotalOrder.Eq.isEquivalence,
 Relation.Binary.StrictTotalOrder.Eq.preorder,
 Relation.Binary.StrictTotalOrder.Eq.refl,
 Relation.Binary.StrictTotalOrder.Eq.reflexive,
 Relation.Binary.StrictTotalOrder.Eq.setoid,
 Relation.Binary.StrictTotalOrder.Eq.sym,
 Relation.Binary.StrictTotalOrder.Eq.trans,
 Relation.Binary.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.StrictTotalOrder.decSetoid]
    Checking Relation.Binary.PropositionalEquality (/Users/emily/src/agda-stdlib/src/Relation/Binary/PropositionalEquality.agda).
     Checking Function.Equality (/Users/emily/src/agda-stdlib/src/Function/Equality.agda).
      Checking Relation.Binary.Indexed.Heterogeneous (/Users/emily/src/agda-stdlib/src/Relation/Binary/Indexed/Heterogeneous.agda).
       Checking Relation.Binary.Indexed.Heterogeneous.Core (/Users/emily/src/agda-stdlib/src/Relation/Binary/Indexed/Heterogeneous/Core.agda).
etaExpandClause
  body    =  {i₁ : I₁} {i₂ : I₂} → A₁ i₁ → A₂ i₂ → Set ℓ
  xs      =  []
  new tel =  {i₁ : Level} {i₂ : Level} {a₁ : Level} {a₂ : Level}
             {I₁ : Set i₁} {I₂ : Set i₂} (A₁ : I₁ → Set a₁) (A₂ : I₂ → Set a₂)
             (ℓ : Level)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Core.IREL]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Core.IREL]
etaExpandClause
  body    =  IREL A A ℓ
  xs      =  []
  new tel =  {i : Level} {a : Level} {I : Set i} (A : I → Set a)
             (ℓ : Level)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Core.IRel]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Core.IRel]
etaExpandClause
  body    =  {i : I} → B.Reflexive _∼_
  xs      =  []
  new tel =  {i : Level} {a : Level} {ℓ : Level} {I : Set i}
             (A : I → Set a) (_∼_ : IRel A ℓ)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Core.Reflexive]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Core.Reflexive]
etaExpandClause
  body    =  {i j : I} → B.Sym _∼_ _∼_
  xs      =  []
  new tel =  {i : Level} {a : Level} {ℓ : Level} {I : Set i}
             (A : I → Set a) (_∼_ : IRel A ℓ)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Core.Symmetric]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Core.Symmetric]
etaExpandClause
  body    =  {i j k : I} → B.Trans _∼_ _∼_ _∼_
  xs      =  []
  new tel =  {i : Level} {a : Level} {ℓ : Level} {I : Set i}
             (A : I → Set a) (_∼_ : IRel A ℓ)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Core.Transitive]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Core.Transitive]
etaExpandClause
  body    =  {i j : A} → P i j → Q (f i) (f j)
  xs      =  []
  new tel =  {a : Level} {b : Level} {ℓ₁ : Level} {ℓ₂ : Level}
             {A : Set a} {B : A → Set b} (P : B.Rel A ℓ₁) (f : (x : A) → B x)
             (Q : IRel B ℓ₂)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Core._=[_]⇒_]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Core._=[_]⇒_]
etaExpandClause
  body    =  trans
  xs      =  []
  new tel =  (refl₁ : Reflexive @2 @1) (sym₁ : Symmetric @3 @2)
             (trans₁ : Transitive @4 @3) {i : @3} {x : refl₁ i}
etaExpandClause
  body    =  j₁
  xs      =  []
  new tel =  (refl₁ : Reflexive @2 @1) (sym₁ : Symmetric @3 @2)
             (trans₁ : Transitive @4 @3) {i : @3} {j : @4} {i = i₁ : refl₁ i}
             {j = j₁ : refl₁ j} (_ : sym₁ i₁ j₁)
etaExpandClause
  body    =  x₁
  xs      =  []
  new tel =  (refl₁ : Reflexive @2 @1) (sym₁ : Symmetric @3 @2)
             (trans₁ : Transitive @4 @3) {i : @3} {j : @4} {k : @5}
             {i = i₁ : refl₁ i} {j = j₁ : refl₁ j} {k = k₁ : refl₁ k}
             (_ : sym₁ i₁ j₁) (_ : sym₁ j₁ k₁)
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {I : Set i}
             {A : I → Set a} {i = i₁ : I} {i = i₂ : A i₁} {ℓ : Level.Level}
             {_≈_ : {i₁ = i₃ : I} {i₂ = i₄ : I} → A i₃ → A i₄ → Set ℓ}
             (: IsIndexedEquivalence A _≈_)
Termination checking [Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.refl,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.sym,
 Relation.Binary.Indexed.Heterogeneous.recCon-NOT-PRINTED,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.trans,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.reflexive]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.reflexive]
etaExpandClause
  body    =  IsIndexedEquivalence.trans isEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ : Level.Level} (r : IndexedSetoid I c ℓ) {i = i₁ : I} {j : I}
             {k : I} {i = i₂ : Carrier i₁} {j = j₁ : Carrier j}
             {k = k₁ : Carrier k} (_ : i₂ ≈ j₁) (_ : j₁ ≈ k₁)
etaExpandClause
  body    =  IsIndexedEquivalence.sym isEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ : Level.Level} (r : IndexedSetoid I c ℓ) {i = i₁ : I} {j : I}
             {i = i₂ : Carrier i₁} {j = j₁ : Carrier j} (_ : i₂ ≈ j₁)
etaExpandClause
  body    =  IsIndexedEquivalence.reflexive isEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ : Level.Level} (r : IndexedSetoid I c ℓ) {i = i₁ : I}
             {i = i₂ : Carrier i₁} {j : Carrier i₁} (_ : i₂ ≡ j)
etaExpandClause
  body    =  IsIndexedEquivalence.refl isEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ : Level.Level} (r : IndexedSetoid I c ℓ) {i = i₁ : I}
             {x : Carrier i₁}
etaExpandClause
  body    =  _≈_
  xs      =  []
  new tel =  (Carrier₁ : @3 → Set @2) (_≈₁_ : IRel Carrier₁ @2)
             (isEquivalence₁ : IsIndexedEquivalence Carrier₁ _≈₁_) (_ : @3)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : @3 → Set @2) (_≈₁_ : IRel Carrier₁ @2)
             (isEquivalence₁ : IsIndexedEquivalence Carrier₁ _≈₁_) {i₁ : @3}
             {i₂ : @4} (_ : Carrier isEquivalence₁ i₁)
             (_ : Carrier isEquivalence₁ i₂)
etaExpandClause
  body    =  isEquivalence
  xs      =  []
  new tel =  (Carrier₁ : @3 → Set @2) (_≈₁_ : IRel Carrier₁ @2)
             (isEquivalence₁ : IsIndexedEquivalence Carrier₁ _≈₁_)
etaExpandClause
  body    =  IsIndexedEquivalence.refl (isEquivalence x)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ : Level.Level} (r : IndexedSetoid I c ℓ) {i = i₁ : I}
             {x : Carrier r i₁}
etaExpandClause
  body    =  IsIndexedEquivalence.reflexive (isEquivalence x)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ : Level.Level} (r : IndexedSetoid I c ℓ) {i = i₁ : I}
             {i = i₂ : Carrier r i₁} {j : Carrier r i₁} (_ : i₂ ≡ j)
etaExpandClause
  body    =  IsIndexedEquivalence.sym (isEquivalence x)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ : Level.Level} (r : IndexedSetoid I c ℓ) {i = i₁ : I} {j : I}
             {i = i₂ : Carrier r i₁} {j = j₁ : Carrier r j} (_ : (r ≈ i₂) j₁)
etaExpandClause
  body    =  IsIndexedEquivalence.trans (isEquivalence x₁)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ : Level.Level} (r : IndexedSetoid I c ℓ) {i = i₁ : I} {j : I}
             {k : I} {i = i₂ : Carrier r i₁} {j = j₁ : Carrier r j}
             {k = k₁ : Carrier r k} (_ : (r ≈ i₂) j₁) (_ : (r ≈ j₁) k₁)
etaExpandClause
  body    =  IsIndexedEquivalence.trans isEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (r : IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {j : I} {k : I} {i = i₂ : A i₁} {j = j₁ : A j} {k = k₁ : A k}
             (_ : i₂ ≈ j₁) (_ : j₁ ≈ k₁)
etaExpandClause
  body    =  IsIndexedEquivalence.sym isEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (r : IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {j : I} {i = i₂ : A i₁} {j = j₁ : A j} (_ : i₂ ≈ j₁)
etaExpandClause
  body    =  IsIndexedEquivalence.reflexive isEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (r : IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {i = i₂ : A i₁} {j : A i₁} (_ : i₂ ≡ j)
etaExpandClause
  body    =  IsIndexedEquivalence.refl isEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (r : IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {x : A i₁}
etaExpandClause
  body    =  isEquivalence
  xs      =  []
  new tel =  (isEquivalence₁ : IsIndexedEquivalence @3 @2)
             (reflexive₁ : {i : @5} {j : @6} → @5 ⟨ _⇒_ ⟩ @4)
             (trans₁ : Transitive @5 @3)
etaExpandClause
  body    =  j₁
  xs      =  []
  new tel =  (isEquivalence₁ : IsIndexedEquivalence @3 @2)
             (reflexive₁ : {i : @5} {j : @6} → @5 ⟨ _⇒_ ⟩ @4)
             (trans₁ : Transitive @5 @3) {i : @4} {j : @5} {i = i₁ : @5 i}
             {j = j₁ : @6 j} (_ : isEquivalence₁ i₁ j₁)
etaExpandClause
  body    =  x₁
  xs      =  []
  new tel =  (isEquivalence₁ : IsIndexedEquivalence @3 @2)
             (reflexive₁ : {i : @5} {j : @6} → @5 ⟨ _⇒_ ⟩ @4)
             (trans₁ : Transitive @5 @3) {i : @4} {j : @5} {k : @6}
             {i = i₁ : @6 i} {j = j₁ : @7 j} {k = k₁ : @8 k}
             (_ : reflexive₁ i₁ j₁) (_ : reflexive₁ j₁ k₁)
etaExpandClause
  body    =  IsIndexedEquivalence.refl (isEquivalence x)
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (r : IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {x : A i₁}
etaExpandClause
  body    =  IsIndexedEquivalence.reflexive (isEquivalence x)
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (r : IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {i = i₂ : A i₁} {j : A i₁} (_ : i₂ ≡ j)
etaExpandClause
  body    =  IsIndexedEquivalence.sym (isEquivalence x)
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (r : IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {j : I} {i = i₂ : A i₁} {j = j₁ : A j} (_ : i₂ ≈ j₁)
etaExpandClause
  body    =  IsIndexedEquivalence.trans (isEquivalence x₁)
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (r : IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {j : I} {k : I} {i = i₂ : A i₁} {j = j₁ : A j} {k = k₁ : A k}
             (_ : i₂ ≈ j₁) (_ : j₁ ≈ k₁)
etaExpandClause
  body    =  reflexive (IsIndexedEquivalence.refl (isEquivalence))
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ₁ : Level.Level}
             {ℓ₂ : Level.Level} {I : Set i} {A : I → Set a} {_≈_ : IRel A ℓ₁}
             {_∼_ : IRel A ℓ₂} (: IsIndexedPreorder A _≈_ _∼_) {i = i₁ : I}
             {x : A i₁}
Termination checking [Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.isEquivalence,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.reflexive,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.trans,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.Eq.refl,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.Eq.reflexive,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.Eq.sym,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.Eq.trans,
 Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.refl,
 Relation.Binary.Indexed.Heterogeneous.recCon-NOT-PRINTED]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.IsIndexedPreorder.refl]
etaExpandClause
  body    =  IsIndexedPreorder.Eq.trans isPreorder
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {j : I} {k : I}
             {i = i₂ : Carrier i₁} {j = j₁ : Carrier j} {k = k₁ : Carrier k}
             (_ : i₂ ≈ j₁) (_ : j₁ ≈ k₁)
etaExpandClause
  body    =  IsIndexedPreorder.Eq.sym isPreorder
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {j : I}
             {i = i₂ : Carrier i₁} {j = j₁ : Carrier j} (_ : i₂ ≈ j₁)
etaExpandClause
  body    =  IsIndexedPreorder.Eq.reflexive isPreorder
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {i = i₂ : Carrier i₁}
             {j : Carrier i₁} (_ : i₂ ≡ j)
etaExpandClause
  body    =  IsIndexedPreorder.Eq.refl isPreorder
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {x : Carrier i₁}
etaExpandClause
  body    =  IsIndexedPreorder.trans isPreorder
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {j : I} {k : I}
             {i = i₂ : Carrier i₁} {j = j₁ : Carrier j} {k = k₁ : Carrier k}
             (_ : i₂ ∼ j₁) (_ : j₁ ∼ k₁)
etaExpandClause
  body    =  IsIndexedPreorder.reflexive isPreorder
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {j : I}
             {i = i₂ : Carrier i₁} {j = j₁ : Carrier j} (_ : i₂ ≈ j₁)
etaExpandClause
  body    =  IsIndexedPreorder.refl isPreorder
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {x : Carrier i₁}
etaExpandClause
  body    =  IsIndexedPreorder.isEquivalence isPreorder
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂)
etaExpandClause
  body    =  _≈_
  xs      =  []
  new tel =  (Carrier₁ : @4 → Set @3) (_≈₁_ : IRel Carrier₁ @3)
             (_∼₁_ : IRel Carrier₁ @3)
             (isPreorder₁ : IsIndexedPreorder Carrier₁ _≈₁_ _∼₁_) (_ : @4)
etaExpandClause
  body    =  i₂
  xs      =  []
  new tel =  (Carrier₁ : @4 → Set @3) (_≈₁_ : IRel Carrier₁ @3)
             (_∼₁_ : IRel Carrier₁ @3)
             (isPreorder₁ : IsIndexedPreorder Carrier₁ _≈₁_ _∼₁_) {i₁ : @4}
             {i₂ : @5} (_ : Carrier isPreorder₁ i₁) (_ : Carrier isPreorder₁ i₂)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (Carrier₁ : @4 → Set @3) (_≈₁_ : IRel Carrier₁ @3)
             (_∼₁_ : IRel Carrier₁ @3)
             (isPreorder₁ : IsIndexedPreorder Carrier₁ _≈₁_ _∼₁_) {i₁ : @4}
             {i₂ : @5} (_ : Carrier isPreorder₁ i₁) (_ : Carrier isPreorder₁ i₂)
etaExpandClause
  body    =  isPreorder
  xs      =  []
  new tel =  (Carrier₁ : @4 → Set @3) (_≈₁_ : IRel Carrier₁ @3)
             (_∼₁_ : IRel Carrier₁ @3)
             (isPreorder₁ : IsIndexedPreorder Carrier₁ _≈₁_ _∼₁_)
etaExpandClause
  body    =  IsIndexedPreorder.isEquivalence (isPreorder r)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂)
etaExpandClause
  body    =  IsIndexedPreorder.refl (isPreorder x)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {x : Carrier r i₁}
etaExpandClause
  body    =  IsIndexedPreorder.reflexive (isPreorder x)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {j : I}
             {i = i₂ : Carrier r i₁} {j = j₁ : Carrier r j} (_ : (r ≈ i₂) j₁)
etaExpandClause
  body    =  IsIndexedPreorder.trans (isPreorder x₁)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {j : I} {k : I}
             {i = i₂ : Carrier r i₁} {j = j₁ : Carrier r j}
             {k = k₁ : Carrier r k} (_ : (r ∼ i₂) j₁) (_ : (r ∼ j₁) k₁)
etaExpandClause
  body    =  IsIndexedPreorder.Eq.refl (isPreorder x)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {x : Carrier r i₁}
etaExpandClause
  body    =  IsIndexedPreorder.Eq.reflexive (isPreorder x)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I}
             {i = i₂ : Carrier r i₁} {j : Carrier r i₁} (_ : i₂ ≡ j)
etaExpandClause
  body    =  IsIndexedPreorder.Eq.sym (isPreorder x)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {j : I}
             {i = i₂ : Carrier r i₁} {j = j₁ : Carrier r j} (_ : (r ≈ i₂) j₁)
etaExpandClause
  body    =  IsIndexedPreorder.Eq.trans (isPreorder x₁)
  xs      =  []
  new tel =  {i : Level.Level} {I : Set i} {c : Level.Level}
             {ℓ₁ : Level.Level} {ℓ₂ : Level.Level}
             (r : IndexedPreorder I c ℓ₁ ℓ₂) {i = i₁ : I} {j : I} {k : I}
             {i = i₂ : Carrier r i₁} {j = j₁ : Carrier r j}
             {k = k₁ : Carrier r k} (_ : (r ≈ i₂) j₁) (_ : (r ≈ j₁) k₁)
etaExpandClause
  body    =  IREL
  xs      =  []
  new tel =  {i₁ : Level.Level} {i₂ : Level.Level}
             {a₁ : Level.Level} {a₂ : Level.Level} {I₁ : Set i₁} {I₂ : Set i₂}
             (_ : I₁ → Set a₁) (_ : I₂ → Set a₂) (ℓ : Level.Level)
Termination checking [Relation.Binary.Indexed.Heterogeneous.REL]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.REL]
etaExpandClause
  body    =  IRel
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {I : Set i}
             (_ : I → Set a) (ℓ : Level.Level)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Rel]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Rel]
etaExpandClause
  body    =  IndexedSetoid
  xs      =  []
  new tel =  {i : Level.Level} (I : Set i) (c : Level.Level)
             (ℓ : Level.Level)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Setoid]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Setoid]
etaExpandClause
  body    =  IsIndexedEquivalence
  xs      =  []
  new tel =  {i : Level.Level} {a : Level.Level} {ℓ : Level.Level}
             {I : Set i} (A : I → Set a) (_≈_ : IRel A ℓ)
Termination checking [Relation.Binary.Indexed.Heterogeneous.IsEquivalence]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.IsEquivalence]
      Checking Relation.Binary.Indexed.Heterogeneous.Construct.Trivial (/Users/emily/src/agda-stdlib/src/Relation/Binary/Indexed/Heterogeneous/Construct/Trivial.agda).
etaExpandClause
  body    =  A
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a} (i₁ : I)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._.Aᵢ]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._.Aᵢ]
etaExpandClause
  body    =  record
             { refl = λ {.i} → IsEquivalence.refl isEq
             ; sym = λ {.i} {.j} → IsEquivalence.sym isEq
             ; trans = λ {.i} {.j} {.k} → IsEquivalence.trans isEq
             }
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a} {ℓ : .Agda.Primitive.Level}
             {_≈_ : Rel A ℓ} (isEq : IsEquivalence _≈_)
etaExpandClause
  body    =  IsEquivalence.refl x
  xs      =  []
  new tel =  (isEq : IsEquivalence @0) {x : @3}
etaExpandClause
  body    =  IsEquivalence.reflexive x
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a}
             {.ℓ : .Agda.Primitive.Level} {._≈_ : Rel A .ℓ}
             (isEq : IsEquivalence ._≈_) {i = i₁ : A} {j : A}
             (_ : i₁ .Agda.Builtin.Equality.≡ j)
etaExpandClause
  body    =  IsEquivalence.sym x
  xs      =  []
  new tel =  (isEq : IsEquivalence @0) {i : @3} {j : @4}
             (_ : @3 i j)
etaExpandClause
  body    =  IsEquivalence.trans x₁
  xs      =  []
  new tel =  (isEq : IsEquivalence @0) {i : @3} {j : @4} {k : @5}
             (_ : @4 i j) (_ : @5 j k)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._.isIndexedEquivalence,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.refl,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.reflexive,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.sym,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.trans]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._.isIndexedEquivalence]
etaExpandClause
  body    =  record
             { isEquivalence =
                 isIndexedEquivalence (IsPreorder.isEquivalence isPreorder)
             ; reflexive = λ {.i} {.j} → IsPreorder.reflexive isPreorder
             ; trans = λ {.i} {.j} {.k} → IsPreorder.trans isPreorder
             }
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a}
             {ℓ₁ : .Agda.Primitive.Level} {ℓ₂ : .Agda.Primitive.Level}
             {_≈_ : Rel A ℓ₁} {_∼_ : Rel A ℓ₂} (isPreorder : IsPreorder _≈_ _∼_)
etaExpandClause
  body    =  IsPreorder.isEquivalence isPreorder
  xs      =  []
  new tel =  (isPreorder : IsPreorder @1 @0)
etaExpandClause
  body    =  IsPreorder.refl x
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a}
             {.ℓ₁ : .Agda.Primitive.Level} {.ℓ₂ : .Agda.Primitive.Level}
             {._≈_ : Rel A .ℓ₁} {._∼_ : Rel A .ℓ₂}
             (isPreorder : IsPreorder ._≈_ ._∼_) {x : A}
etaExpandClause
  body    =  IsPreorder.reflexive x
  xs      =  []
  new tel =  (isPreorder : IsPreorder @1 @0) {i : @5} {j : @6}
             (_ : @4 i j)
etaExpandClause
  body    =  IsPreorder.trans x₁
  xs      =  []
  new tel =  (isPreorder : IsPreorder @1 @0) {i : @5} {j : @6}
             {k : @7} (_ : @4 i j) (_ : @5 j k)
etaExpandClause
  body    =  IsPreorder.∼-resp-≈ isPreorder
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a}
             {.ℓ₁ : .Agda.Primitive.Level} {.ℓ₂ : .Agda.Primitive.Level}
             {._≈_ : Rel A .ℓ₁} {._∼_ : Rel A .ℓ₂}
             (isPreorder : IsPreorder ._≈_ ._∼_)
etaExpandClause
  body    =  IsPreorder.∼-respʳ-≈ x₃
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a}
             {.ℓ₁ : .Agda.Primitive.Level} {.ℓ₂ : .Agda.Primitive.Level}
             {._≈_ : Rel A .ℓ₁} {._∼_ : Rel A .ℓ₂}
             (isPreorder : IsPreorder ._≈_ ._∼_) {x : A} {x = x₁ : A} {y : A}
             (_ : . x₁ ≈ y) (_ : . x ∼ x₁)
etaExpandClause
  body    =  IsPreorder.∼-respˡ-≈ x₂
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a}
             {.ℓ₁ : .Agda.Primitive.Level} {.ℓ₂ : .Agda.Primitive.Level}
             {._≈_ : Rel A .ℓ₁} {._∼_ : Rel A .ℓ₂}
             (isPreorder : IsPreorder ._≈_ ._∼_) {y : A} {x : A} {y = y₁ : A}
             (_ : . x ≈ y₁) (_ : . x ∼ y)
etaExpandClause
  body    =  IsPreorder.Eq.refl x
  xs      =  []
  new tel =  (isPreorder : IsPreorder @1 @0) {x : @5}
etaExpandClause
  body    =  IsPreorder.Eq.reflexive x
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {A : Set a}
             {.ℓ₁ : .Agda.Primitive.Level} {.ℓ₂ : .Agda.Primitive.Level}
             {._≈_ : Rel A .ℓ₁} {._∼_ : Rel A .ℓ₂}
             (isPreorder : IsPreorder ._≈_ ._∼_) {i = i₁ : A} {j : A}
             (_ : i₁ .Agda.Builtin.Equality.≡ j)
etaExpandClause
  body    =  IsPreorder.Eq.sym x
  xs      =  []
  new tel =  (isPreorder : IsPreorder @1 @0) {i : @5} {j : @6}
             (_ : @4 i j)
etaExpandClause
  body    =  IsPreorder.Eq.trans x₁
  xs      =  []
  new tel =  (isPreorder : IsPreorder @1 @0) {i : @5} {j : @6}
             {k : @7} (_ : @5 i j) (_ : @6 j k)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._.isIndexedPreorder,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.isEquivalence,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.refl,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.reflexive,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.trans,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.∼-resp-≈,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.∼-respʳ-≈,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.∼-respˡ-≈,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.Eq.refl,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.Eq.reflexive,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.Eq.sym,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._.Eq.trans]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._.isIndexedPreorder]
etaExpandClause
  body    =  record
             { Carrier =
                 .Relation.Binary.Indexed.Heterogeneous.Construct.Trivial.Aᵢ
             ; _≈_ = λ {.i₁} {.i₂} → Setoid._≈_ S
             ; isEquivalence = isIndexedEquivalence (Setoid.isEquivalence S)
             }
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {ℓ : .Agda.Primitive.Level}
             (S : Setoid a ℓ)
etaExpandClause
  body    =  Setoid._≈_ x₁
  xs      =  []
  new tel =  (S : Setoid @1 @0) (_ : Setoid.Carrier S)
             (_ : Setoid.Carrier S)
etaExpandClause
  body    =  Setoid.Carrier S
  xs      =  []
  new tel =  (S : Setoid @1 @0)
etaExpandClause
  body    =  Setoid.isEquivalence S
  xs      =  []
  new tel =  (S : Setoid @1 @0)
etaExpandClause
  body    =  Setoid.isPreorder S
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {.a : .Agda.Primitive.Level} {.ℓ : .Agda.Primitive.Level}
             (S : Setoid .a .ℓ)
etaExpandClause
  body    =  Setoid.preorder S
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {.a : .Agda.Primitive.Level} {.ℓ : .Agda.Primitive.Level}
             (S : Setoid .a .ℓ)
etaExpandClause
  body    =  Setoid.refl x
  xs      =  []
  new tel =  (S : Setoid @1 @0) {x : Setoid.Carrier S}
etaExpandClause
  body    =  Setoid.reflexive x
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {.a : .Agda.Primitive.Level} {.ℓ : .Agda.Primitive.Level}
             (S : Setoid .a .ℓ) {i = i₁ : Setoid.Carrier S}
             {j : Setoid.Carrier S} (_ : i₁ .Agda.Builtin.Equality.≡ j)
etaExpandClause
  body    =  Setoid.sym x
  xs      =  []
  new tel =  (S : Setoid @1 @0) {i : Setoid.Carrier S}
             {j : Setoid.Carrier S} (_ : (S Setoid.≈ i) j)
etaExpandClause
  body    =  Setoid.trans x₁
  xs      =  []
  new tel =  (S : Setoid @1 @0) {i : Setoid.Carrier S}
             {j : Setoid.Carrier S} {k : Setoid.Carrier S}
             (_ : (S Setoid.≈ i) j) (_ : (S Setoid.≈ j) k)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial.indexedSetoid,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._≈_,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.Carrier,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.isEquivalence,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.isPreorder,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.preorder,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.refl,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.reflexive,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.sym,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.trans]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial.indexedSetoid]
etaExpandClause
  body    =  record
             { Carrier =
                 .Relation.Binary.Indexed.Heterogeneous.Construct.Trivial.Aᵢ
             ; _≈_ = λ {.i₁} {.i₂} → Preorder._≈_ O
             ; _∼_ = λ {.i₁} {.i₂} → Preorder._∼_ O
             ; isPreorder = isIndexedPreorder (Preorder.isPreorder O)
             }
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {a : .Agda.Primitive.Level} {ℓ₁ : .Agda.Primitive.Level}
             {ℓ₂ : .Agda.Primitive.Level} (O : Preorder a ℓ₁ ℓ₂)
etaExpandClause
  body    =  Preorder._∼_ x₁
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0) (_ : Preorder.Carrier O)
             (_ : Preorder.Carrier O)
etaExpandClause
  body    =  Preorder._≈_ x₁
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0) (_ : Preorder.Carrier O)
             (_ : Preorder.Carrier O)
etaExpandClause
  body    =  Preorder.Carrier O
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0)
etaExpandClause
  body    =  Preorder.isEquivalence O
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0)
etaExpandClause
  body    =  Preorder.isPreorder O
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0)
etaExpandClause
  body    =  Preorder.refl x
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {.a : .Agda.Primitive.Level} {.ℓ₁ : .Agda.Primitive.Level}
             {.ℓ₂ : .Agda.Primitive.Level} (O : Preorder .a .ℓ₁ .ℓ₂)
             {x : Preorder.Carrier O}
etaExpandClause
  body    =  Preorder.reflexive x
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0) {i : Preorder.Carrier O}
             {j : Preorder.Carrier O} (_ : (O Preorder.≈ i) j)
etaExpandClause
  body    =  Preorder.trans x₁
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0) {i : Preorder.Carrier O}
             {j : Preorder.Carrier O} {k : Preorder.Carrier O}
             (_ : (O Preorder.∼ i) j) (_ : (O Preorder.∼ j) k)
etaExpandClause
  body    =  Preorder.∼-resp-≈ O
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {.a : .Agda.Primitive.Level} {.ℓ₁ : .Agda.Primitive.Level}
             {.ℓ₂ : .Agda.Primitive.Level} (O : Preorder .a .ℓ₁ .ℓ₂)
etaExpandClause
  body    =  Preorder.∼-respʳ-≈ x₃
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {.a : .Agda.Primitive.Level} {.ℓ₁ : .Agda.Primitive.Level}
             {.ℓ₂ : .Agda.Primitive.Level} (O : Preorder .a .ℓ₁ .ℓ₂)
             {x : Preorder.Carrier O} {x = x₁ : Preorder.Carrier O}
             {y : Preorder.Carrier O} (_ : (O Preorder.≈ x₁) y)
             (_ : (O Preorder.∼ x) x₁)
etaExpandClause
  body    =  Preorder.∼-respˡ-≈ x₂
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {.a : .Agda.Primitive.Level} {.ℓ₁ : .Agda.Primitive.Level}
             {.ℓ₂ : .Agda.Primitive.Level} (O : Preorder .a .ℓ₁ .ℓ₂)
             {y : Preorder.Carrier O} {x : Preorder.Carrier O}
             {y = y₁ : Preorder.Carrier O} (_ : (O Preorder.≈ x) y₁)
             (_ : (O Preorder.∼ x) y)
etaExpandClause
  body    =  Preorder.Eq.refl x
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0) {x : Preorder.Carrier O}
etaExpandClause
  body    =  Preorder.Eq.reflexive x
  xs      =  []
  new tel =  {i : .Agda.Primitive.Level} {I : Set i}
             {.a : .Agda.Primitive.Level} {.ℓ₁ : .Agda.Primitive.Level}
             {.ℓ₂ : .Agda.Primitive.Level} (O : Preorder .a .ℓ₁ .ℓ₂)
             {i = i₁ : Preorder.Carrier O} {j : Preorder.Carrier O}
             (_ : i₁ .Agda.Builtin.Equality.≡ j)
etaExpandClause
  body    =  Preorder.Eq.sym x
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0) {i : Preorder.Carrier O}
             {j : Preorder.Carrier O} (_ : (O Preorder.≈ i) j)
etaExpandClause
  body    =  Preorder.Eq.trans x₁
  xs      =  []
  new tel =  (O : Preorder @2 @1 @0) {i : Preorder.Carrier O}
             {j : Preorder.Carrier O} {k : Preorder.Carrier O}
             (_ : (O Preorder.≈ i) j) (_ : (O Preorder.≈ j) k)
Termination checking [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial.indexedPreorder,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._∼_,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._._≈_,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.Carrier,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.isEquivalence,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.isPreorder,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.refl,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.reflexive,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.trans,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.∼-resp-≈,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.∼-respʳ-≈,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.∼-respˡ-≈,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.Eq.refl,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.Eq.reflexive,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.Eq.sym,
 Relation.Binary.Indexed.Heterogeneous.Construct.Trivial._._.Eq.trans]
Trivially terminating: [Relation.Binary.Indexed.Heterogeneous.Construct.Trivial.indexedPreorder]
etaExpandClause
  body    =  cong
  xs      =  []
  new tel =  (_⟨$⟩₁_
              : (x : Setoid.Carrier @2) → IndexedSetoid.Carrier @2 x)
             (cong₁ : Setoid._≈_ @3 =[ _⟨$⟩₁_ ]⇒ IndexedSetoid._≈_ @2)
             (x : Setoid.Carrier @2)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  (_⟨$⟩₁_
              : (x : Setoid.Carrier @2) → IndexedSetoid.Carrier @2 x)
             (cong₁ : Setoid._≈_ @3 =[ _⟨$⟩₁_ ]⇒ IndexedSetoid._≈_ @2)
             {i : Setoid.Carrier @2} {j : Setoid.Carrier @3}
             (_ : (@4 Setoid.≈ i) j)
etaExpandClause
  body    =  Π From (Trivial.indexedSetoid To)
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             (From : Setoid f₁ f₂) (To : Setoid t₁ t₂)
Termination checking [Function.Equality._⟶_]
Trivially terminating: [Function.Equality._⟶_]
etaExpandClause
  body    =  record { _⟨$⟩_ = λ x → x ; cong = λ {.i} {.j} x → x }
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {A : Setoid a₁ a₂}
Termination checking [Function.Equality.id]
Trivially terminating: [Function.Equality.id]
etaExpandClause
  body    =  record
             { _⟨$⟩_ = λ x → f ⟨$⟩ (g ⟨$⟩ x)
             ; cong = λ {.i} {.j} x → cong f (cong g x)
             }
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {A : Setoid a₁ a₂}
             {b₁ : Level} {b₂ : Level} {B : Setoid b₁ b₂} {c₁ : Level}
             {c₂ : Level} {C : Setoid c₁ c₂} (f : B ⟶ C) (g : A ⟶ B)
Termination checking [Function.Equality._∘_]
Trivially terminating: [Function.Equality._∘_]
etaExpandClause
  body    =  record
             { _⟨$⟩_ = λ x → f ⟨$⟩ (g ⟨$⟩ x)
             ; cong = λ {.i} {.j} x → cong f (cong g x)
             }
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {A : Setoid a₁ a₂}
             {b₁ : Level} {b₂ : Level} {B : Setoid b₁ b₂} {c₁ : Level}
             {c₂ : Level} {C : Setoid c₁ c₂} (f : B ⟶ C) (g : A ⟶ B)
etaExpandClause
  body    =  record
             { _⟨$⟩_ = λ _ → b
             ; cong =
                 λ {.i} {.j} _ →
                   Relation.Binary.IsEquivalence.refl (Setoid.isEquivalence B)
             }
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {A : Setoid a₁ a₂}
             {b₁ : Level} {b₂ : Level} {B : Setoid b₁ b₂} (b : Setoid.Carrier B)
Termination checking [Function.Equality.const]
Trivially terminating: [Function.Equality.const]
etaExpandClause
  body    =  record
             { _⟨$⟩_ = λ _ → b
             ; cong =
                 λ {.i} {.j} _ →
                   Relation.Binary.IsEquivalence.refl (Setoid.isEquivalence B)
             }
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {A : Setoid a₁ a₂}
             {b₁ : Level} {b₂ : Level} {B : Setoid b₁ b₂} (b : Setoid.Carrier B)
etaExpandClause
  body    =  record
             { Carrier = Π From To
             ; _≈_ =
                 λ f g →
                   {x y : Setoid.Carrier From} →
                   (From Setoid.≈ x) y → (To IndexedSetoid.≈ f ⟨$⟩ x) (g ⟨$⟩ y)
             ; isEquivalence =
                 record
                 { refl = cong
                 ; sym =
                     λ {.i} {.j} f∼g {.x} {.y} x∼y →
                       Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.sym
                       (IndexedSetoid.isEquivalence To)
                       (f∼g
                        (Relation.Binary.IsEquivalence.sym (Setoid.isEquivalence From)
                         x∼y))
                 ; trans =
                     λ {.i} {.j} {.k} f∼g g∼h {.x} {.y} x∼y →
                       Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.trans
                       (IndexedSetoid.isEquivalence To)
                       (f∼g
                        (Relation.Binary.IsEquivalence.refl (Setoid.isEquivalence From)))
                       (g∼h x∼y)
                 }
             }
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             (From : Setoid f₁ f₂)
             (To : IndexedSetoid (Setoid.Carrier From) t₁ t₂)
etaExpandClause
  body    =  Setoid._≈_ x
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
             (_ : Setoid.Carrier From) (_ : Setoid.Carrier From)
etaExpandClause
  body    =  Setoid.Carrier From
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
etaExpandClause
  body    =  Setoid.isEquivalence From
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
etaExpandClause
  body    =  Setoid.isPreorder From
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
etaExpandClause
  body    =  Setoid.preorder From
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
etaExpandClause
  body    =  Setoid.refl To
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
             {x : Setoid.Carrier From}
etaExpandClause
  body    =  Setoid.reflexive j
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
             {i : Setoid.Carrier From} {j : Setoid.Carrier From}
             (_ : i .Agda.Builtin.Equality.≡ j)
etaExpandClause
  body    =  Setoid.sym j
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
             {i : Setoid.Carrier From} {j : Setoid.Carrier From}
             (_ : (From Setoid.≈ i) j)
etaExpandClause
  body    =  Setoid.trans x
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
             {i : Setoid.Carrier From} {j : Setoid.Carrier From}
             {k : Setoid.Carrier From} (_ : (From Setoid.≈ i) j)
             (_ : (From Setoid.≈ j) k)
etaExpandClause
  body    =  IndexedSetoid._≈_ x₁
  xs      =  []
  new tel =  (To : IndexedSetoid (Setoid.Carrier @0) @2 @1)
             {i₁ : Setoid.Carrier @1} {i₂ : Setoid.Carrier @2}
             (_ : IndexedSetoid.Carrier To i₁) (_ : IndexedSetoid.Carrier To i₂)
etaExpandClause
  body    =  IndexedSetoid.Carrier x
  xs      =  []
  new tel =  (To : IndexedSetoid (Setoid.Carrier @0) @2 @1)
             (_ : Setoid.Carrier @1)
etaExpandClause
  body    =  IndexedSetoid.isEquivalence To
  xs      =  []
  new tel =  (To : IndexedSetoid (Setoid.Carrier @0) @2 @1)
etaExpandClause
  body    =  IndexedSetoid.refl x
  xs      =  []
  new tel =  (To : IndexedSetoid (Setoid.Carrier @0) @2 @1)
             {i : Setoid.Carrier @1} {x : IndexedSetoid.Carrier To i}
etaExpandClause
  body    =  IndexedSetoid.reflexive x
  xs      =  []
  new tel =  {.f₁ : Level} {.f₂ : Level} {.t₁ : Level}
             {.t₂ : Level} (From : Setoid .f₁ .f₂)
             (To : IndexedSetoid (Setoid.Carrier From) .t₁ .t₂)
             {i : Setoid.Carrier From} {i = i₁ : IndexedSetoid.Carrier To i}
             {j : IndexedSetoid.Carrier To i}
             (_ : i₁ .Agda.Builtin.Equality.≡ j)
etaExpandClause
  body    =  IndexedSetoid.sym x
  xs      =  []
  new tel =  (To : IndexedSetoid (Setoid.Carrier @0) @2 @1)
             {i : Setoid.Carrier @1} {j : Setoid.Carrier @2}
             {i = i₁ : IndexedSetoid.Carrier To i}
             {j = j₁ : IndexedSetoid.Carrier To j}
             (_ : (To IndexedSetoid.≈ i₁) j₁)
etaExpandClause
  body    =  IndexedSetoid.trans x₁
  xs      =  []
  new tel =  (To : IndexedSetoid (Setoid.Carrier @0) @2 @1)
             {i : Setoid.Carrier @1} {j : Setoid.Carrier @2}
             {k : Setoid.Carrier @3} {i = i₁ : IndexedSetoid.Carrier To i}
             {j = j₁ : IndexedSetoid.Carrier To j}
             {k = k₁ : IndexedSetoid.Carrier To k}
             (_ : (To IndexedSetoid.≈ i₁) j₁) (_ : (To IndexedSetoid.≈ j₁) k₁)
Termination checking [Function.Equality.setoid, Function.Equality._.From._≈_,
 Function.Equality._.From.Carrier,
 Function.Equality._.From.isEquivalence,
 Function.Equality._.From.isPreorder,
 Function.Equality._.From.preorder, Function.Equality._.From.refl,
 Function.Equality._.From.reflexive, Function.Equality._.From.sym,
 Function.Equality._.From.trans, Function.Equality._.To._≈_,
 Function.Equality._.To.Carrier,
 Function.Equality._.To.isEquivalence, Function.Equality._.To.refl,
 Function.Equality._.To.reflexive, Function.Equality._.To.sym,
 Function.Equality._.To.trans]
Trivially terminating: [Function.Equality.setoid]
etaExpandClause
  body    =  setoid From (Trivial.indexedSetoid To)
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             (From : Setoid f₁ f₂) (To : Setoid t₁ t₂)
Termination checking [Function.Equality._⇨_]
Trivially terminating: [Function.Equality._⇨_]
etaExpandClause
  body    =  record
             { Carrier = (x : From) → IndexedSetoid.Carrier To x
             ; _≈_ = λ f g → (x : From) → (To IndexedSetoid.≈ f x) (g x)
             ; isEquivalence =
                 record
                 { refl =
                     λ {f} x →
                       Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.refl
                       (IndexedSetoid.isEquivalence To)
                 ; sym =
                     λ {.i} {.j} f∼g x →
                       Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.sym
                       (IndexedSetoid.isEquivalence To) (f∼g x)
                 ; trans =
                     λ {.i} {.j} {.k} f∼g g∼h x →
                       Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.trans
                       (IndexedSetoid.isEquivalence To) (f∼g x) (g∼h x)
                 }
             }
  xs      =  []
  new tel =  {f : Level} {t₁ : Level} {t₂ : Level} (From : Set f)
             (To : IndexedSetoid From t₁ t₂)
etaExpandClause
  body    =  IndexedSetoid._≈_ x₁
  xs      =  []
  new tel =  (To : IndexedSetoid @0 @2 @1) {i₁ : @1} {i₂ : @2}
             (_ : IndexedSetoid.Carrier To i₁) (_ : IndexedSetoid.Carrier To i₂)
etaExpandClause
  body    =  IndexedSetoid.Carrier x
  xs      =  []
  new tel =  (To : IndexedSetoid @0 @2 @1) (_ : @1)
etaExpandClause
  body    =  IndexedSetoid.isEquivalence To
  xs      =  []
  new tel =  (To : IndexedSetoid @0 @2 @1)
etaExpandClause
  body    =  IndexedSetoid.refl x
  xs      =  []
  new tel =  (To : IndexedSetoid @0 @2 @1) {i : @1}
             {x : IndexedSetoid.Carrier To i}
etaExpandClause
  body    =  IndexedSetoid.reflexive x
  xs      =  []
  new tel =  {.f : Level} {.t₁ : Level} {.t₂ : Level}
             (From : Set .f) (To : IndexedSetoid From .t₁ .t₂) {i : From}
             {i = i₁ : IndexedSetoid.Carrier To i}
             {j : IndexedSetoid.Carrier To i}
             (_ : i₁ .Agda.Builtin.Equality.≡ j)
etaExpandClause
  body    =  IndexedSetoid.sym x
  xs      =  []
  new tel =  (To : IndexedSetoid @0 @2 @1) {i : @1} {j : @2}
             {i = i₁ : IndexedSetoid.Carrier To i}
             {j = j₁ : IndexedSetoid.Carrier To j}
             (_ : (To IndexedSetoid.≈ i₁) j₁)
etaExpandClause
  body    =  IndexedSetoid.trans x₁
  xs      =  []
  new tel =  (To : IndexedSetoid @0 @2 @1) {i : @1} {j : @2}
             {k : @3} {i = i₁ : IndexedSetoid.Carrier To i}
             {j = j₁ : IndexedSetoid.Carrier To j}
             {k = k₁ : IndexedSetoid.Carrier To k}
             (_ : (To IndexedSetoid.≈ i₁) j₁) (_ : (To IndexedSetoid.≈ j₁) k₁)
Termination checking [Function.Equality.≡-setoid, Function.Equality._._._≈_,
 Function.Equality._._.Carrier, Function.Equality._._.isEquivalence,
 Function.Equality._._.refl, Function.Equality._._.reflexive,
 Function.Equality._._.sym, Function.Equality._._.trans]
Trivially terminating: [Function.Equality.≡-setoid]
etaExpandClause
  body    =  record
             { _⟨$⟩_ =
                 λ b →
                   record
                   { _⟨$⟩_ = λ a → f ⟨$⟩ a ⟨$⟩ b
                   ; cong =
                       λ {.i} {.j} a₁≈a₂ →
                         cong f a₁≈a₂
                         (Relation.Binary.IsEquivalence.refl (Setoid.isEquivalence B))
                   }
             ; cong = λ {.i} {.j} b₁≈b₂ {.x} {.y} a₁≈a₂ → cong f a₁≈a₂ b₁≈b₂
             }
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {A : Setoid a₁ a₂}
             {b₁ : Level} {b₂ : Level} {B : Setoid b₁ b₂} {c₁ : Level}
             {c₂ : Level} {C : Setoid c₁ c₂} (f : A ⟶ B ⇨ C)
Termination checking [Function.Equality.flip]
Trivially terminating: [Function.Equality.flip]
etaExpandClause
  body    =  record
             { _⟨$⟩_ =
                 λ b →
                   record
                   { _⟨$⟩_ = λ a → f ⟨$⟩ a ⟨$⟩ b
                   ; cong =
                       λ {.i} {.j} a₁≈a₂ →
                         cong f a₁≈a₂
                         (Relation.Binary.IsEquivalence.refl (Setoid.isEquivalence B))
                   }
             ; cong = λ {.i} {.j} b₁≈b₂ {.x} {.y} a₁≈a₂ → cong f a₁≈a₂ b₁≈b₂
             }
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {A : Setoid a₁ a₂}
             {b₁ : Level} {b₂ : Level} {B : Setoid b₁ b₂} {c₁ : Level}
             {c₂ : Level} {C : Setoid c₁ c₂} (f : A ⟶ B ⇨ C)
     Checking Relation.Binary.HeterogeneousEquality.Core (/Users/emily/src/agda-stdlib/src/Relation/Binary/HeterogeneousEquality/Core.agda).
Termination checking [Relation.Binary.HeterogeneousEquality.Core._≅_,
 Relation.Binary.HeterogeneousEquality.Core._≅_.refl]
Trivially terminating: [Relation.Binary.HeterogeneousEquality.Core._≅_,
 Relation.Binary.HeterogeneousEquality.Core._≅_.refl]
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : .Agda.Primitive.Level} {A : Set a} {x : A}
Termination checking [Relation.Binary.HeterogeneousEquality.Core.≅-to-≡]
Trivially terminating: [Relation.Binary.HeterogeneousEquality.Core.≅-to-≡]
etaExpandClause
  body    =  p₁
  xs      =  []
  new tel =  {b : Level} {B : Set b} {y₁ : B} {a : Level}
             {A : Set a} {x₁ : A} {p : Level} (P : A → B → Set p) (p₁ : P x₁ y₁)
Termination checking [Relation.Binary.PropositionalEquality.subst₂]
Trivially terminating: [Relation.Binary.PropositionalEquality.subst₂]
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {b : Level}
             {B : Set b} (f : A → B)
Termination checking [Relation.Binary.PropositionalEquality.cong]
Trivially terminating: [Relation.Binary.PropositionalEquality.cong]
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : A → Set b}
             {f : (x : A) → B x} (x : A)
Termination checking [Relation.Binary.PropositionalEquality.cong-app]
Trivially terminating: [Relation.Binary.PropositionalEquality.cong-app]
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {b : Level} {B : Set b} {u : B} {a : Level}
             {A : Set a} {x : A} {c : Level} {C : Set c} (f : A → B → C)
Termination checking [Relation.Binary.PropositionalEquality.cong₂]
Trivially terminating: [Relation.Binary.PropositionalEquality.cong₂]
etaExpandClause
  body    =  record
             { Carrier = A ; _≈_ = _≡_ ; isEquivalence = isEquivalence }
  xs      =  []
  new tel =  {a : Level} (A : Set a)
Termination checking [Relation.Binary.PropositionalEquality.setoid]
Trivially terminating: [Relation.Binary.PropositionalEquality.setoid]
etaExpandClause
  body    =  record
             { Carrier = A
             ; _≈_ = _≡_
             ; isDecEquivalence =
                 record { isEquivalence = isEquivalence ; _≟_ = dec }
             }
  xs      =  []
  new tel =  {a : Level} {A : Set a} (dec : Decidable _≡_)
Termination checking [Relation.Binary.PropositionalEquality.decSetoid]
Trivially terminating: [Relation.Binary.PropositionalEquality.decSetoid]
etaExpandClause
  body    =  record
             { isEquivalence = isEquivalence
             ; reflexive = λ {.i} {.j} x → x
             ; trans = trans
             }
  xs      =  []
  new tel =  {a : Level} {A : Set a}
Termination checking [Relation.Binary.PropositionalEquality.isPreorder]
Trivially terminating: [Relation.Binary.PropositionalEquality.isPreorder]
etaExpandClause
  body    =  record
             { Carrier = A ; _≈_ = _≡_ ; _∼_ = _≡_ ; isPreorder = isPreorder }
  xs      =  []
  new tel =  {a : Level} (A : Set a)
Termination checking [Relation.Binary.PropositionalEquality.preorder]
Trivially terminating: [Relation.Binary.PropositionalEquality.preorder]
etaExpandClause
  body    =  ≡-setoid A (Trivial.indexedSetoid (setoid B))
  xs      =  []
  new tel =  {a : Level} {b : Level} (A : Set a) (B : Set b)
Termination checking [Relation.Binary.PropositionalEquality._→-setoid_]
Trivially terminating: [Relation.Binary.PropositionalEquality._→-setoid_]
etaExpandClause
  body    =  Setoid._≈_ (f →-setoid g)
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : Set b}
             (f : A → B) (g : A → B)
Termination checking [Relation.Binary.PropositionalEquality._≗_]
Trivially terminating: [Relation.Binary.PropositionalEquality._≗_]
etaExpandClause
  body    =  record { _⟨$⟩_ = f ; cong = cong′ f }
  xs      =  []
  new tel =  {a : Level} {b₁ : Level} {b₂ : Level} {A : Set a}
             {B : IndexedSetoid A b₁ b₂}
             (f : (x : A) → IndexedSetoid.Carrier B x)
etaExpandClause
  body    =  IndexedSetoid._≈_ x
  xs      =  []
  new tel =  {.a : Level} {.b₁ : Level} {.b₂ : Level} {.A : Set .a}
             {B : IndexedSetoid .A .b₁ .b₂}
             (f : (x : .A) → IndexedSetoid.Carrier B x) {i₁ : .A} {i₂ : .A}
             (_ : IndexedSetoid.Carrier B i₁) (_ : IndexedSetoid.Carrier B i₂)
etaExpandClause
  body    =  Relation.Binary.Indexed.Heterogeneous.IsIndexedEquivalence.refl
             (IndexedSetoid.isEquivalence B)
  xs      =  []
  new tel =  {.a : Level} {.A : Set .a} {x : .A} {.b₁ : Level}
             {.b₂ : Level} {B : IndexedSetoid .A .b₁ .b₂}
             (f : (x₁ : .A) → IndexedSetoid.Carrier B x₁)
Termination checking [Relation.Binary.PropositionalEquality.:→-to-Π,
 Relation.Binary.PropositionalEquality._._._≈_,
 Relation.Binary.PropositionalEquality._.cong′]
Trivially terminating: [Relation.Binary.PropositionalEquality.:→-to-Π]
etaExpandClause
  body    =  :→-to-Π
  xs      =  []
  new tel =  {a : Level} {b₁ : Level} {b₂ : Level} {A : Set a}
             {B : Setoid b₁ b₂} (_ : A → Setoid.Carrier B)
Termination checking [Relation.Binary.PropositionalEquality.→-to-⟶]
Trivially terminating: [Relation.Binary.PropositionalEquality.→-to-⟶]
etaExpandClause
  body    =  eq
  xs      =  []
  new tel =  (eq₁ : @3 @2 ≡ @1)
etaExpandClause
  body    =  [ refl ]
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} {B : A → Set b}
             (f : (x : A) → B x) (x : A)
Termination checking [Relation.Binary.PropositionalEquality.inspect]
Trivially terminating: [Relation.Binary.PropositionalEquality.inspect]
etaExpandClause
  body    =  x≡y
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {y : A} (x≡y : x ≡ y)
Termination checking [Relation.Binary.PropositionalEquality.≡-Reasoning.begin_]
Trivially terminating: [Relation.Binary.PropositionalEquality.≡-Reasoning.begin_]
etaExpandClause
  body    =  x≡y
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {y : A} (x≡y : x ≡ y)
etaExpandClause
  body    =  x≡y
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A) {y : A} (x≡y : x ≡ y)
Termination checking [Relation.Binary.PropositionalEquality.≡-Reasoning._≡⟨⟩_]
Trivially terminating: [Relation.Binary.PropositionalEquality.≡-Reasoning._≡⟨⟩_]
etaExpandClause
  body    =  x≡y
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A) {y : A} (x≡y : x ≡ y)
etaExpandClause
  body    =  trans x≡y y≡z
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A) {y : A} {z : A}
             (x≡y : x ≡ y) (y≡z : y ≡ z)
Termination checking [Relation.Binary.PropositionalEquality.≡-Reasoning._≡⟨_⟩_]
Trivially terminating: [Relation.Binary.PropositionalEquality.≡-Reasoning._≡⟨_⟩_]
etaExpandClause
  body    =  trans (H.≅-to-≡ x≅y) y≡z
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A) {y : A} {z : A}
             (x≅y : x ≅ y) (y≡z : y ≡ z)
Termination checking [Relation.Binary.PropositionalEquality.≡-Reasoning._≅⟨_⟩_]
Trivially terminating: [Relation.Binary.PropositionalEquality.≡-Reasoning._≅⟨_⟩_]
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : Level} {A : Set a} (x : A)
Termination checking [Relation.Binary.PropositionalEquality.≡-Reasoning._∎]
Trivially terminating: [Relation.Binary.PropositionalEquality.≡-Reasoning._∎]
etaExpandClause
  body    =  {A : Set a} {B : A → Set b} {f g : (x : A) → B x} →
             ((x : A) → f x ≡ g x) → f ≡ g
  xs      =  []
  new tel =  (a : Level) (b : Level)
Termination checking [Relation.Binary.PropositionalEquality.Extensionality]
Trivially terminating: [Relation.Binary.PropositionalEquality.Extensionality]
etaExpandClause
  body    =  cong (λ h x → lower (h (lift x)))
             (ext (λ x → cong lift (f≡g (lower x))))
  xs      =  []
  new tel =  {a₁ : Level} {b₁ : Level} (a₂ : Level) (b₂ : Level)
             (ext : Extensionality (a₁ ⊔ a₂) (b₁ ⊔ b₂)) {A : Set a₁}
             {B : A → Set b₁} {f : (x : A) → B x} {g : (x : A) → B x}
             (f≡g : (x : A) → f x ≡ g x)
Termination checking [Relation.Binary.PropositionalEquality.extensionality-for-lower-levels]
Trivially terminating: [Relation.Binary.PropositionalEquality.extensionality-for-lower-levels]
etaExpandClause
  body    =  ∀-extensionality ext B₁ B₂ B₁≡B₂ | ext B₁≡B₂
  xs      =  []
  new tel =  {a : Level} {b : Level}
             (ext : Extensionality a (suc b)) {A : Set a} (B₁ : A → Set b)
             (B₂ : A → Set b) (B₁≡B₂ : (x : A) → B₁ x ≡ B₂ x)
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : Level} {b : Level} {A : Set a} (B : A → Set b)
             (ext
              : {A = A₁ : Set a} {B = B₁ : A₁ → Set (suc b)}
                {f g : (x : A₁) → B₁ x} →
                ((x : A₁) → f x ≡ g x) → f ≡ g)
             (B₁≡B₂ : (x : A) → B x ≡ B x)
Termination checking [Relation.Binary.PropositionalEquality.∀-extensionality,
 Relation.Binary.PropositionalEquality.with-374]
Trivially terminating: [Relation.Binary.PropositionalEquality.∀-extensionality]
etaExpandClause
  body    =  (a b : A) → a ≡ b
  xs      =  []
  new tel =  {a : Level} (A : Set a)
Termination checking [Relation.Binary.PropositionalEquality.isPropositional]
Trivially terminating: [Relation.Binary.PropositionalEquality.isPropositional]
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A}
Termination checking [Relation.Binary.PropositionalEquality.≡-irrelevance]
Trivially terminating: [Relation.Binary.PropositionalEquality.≡-irrelevance]
etaExpandClause
  body    =  ≡-≟-identity _≟_ eq | a₁ ≟ b
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_≟_ : Decidable _≡_)
             {a = a₁ : A} {b : A} (eq : a₁ ≡ b)
etaExpandClause
  body    =  cong yes (≡-irrelevance p eq)
  xs      =  []
  new tel =  {a : Level} {A : Set a}
             (_≟_ : (x y : A) → Relation.Nullary.Dec (x ≡ y)) {a = a₁ : A}
             {b : A} (p : a₁ ≡ b) (eq : a₁ ≡ b)
etaExpandClause
  body    =  ⊥-elim (¬p eq)
  xs      =  []
  new tel =  {a : Level} {A : Set a}
             (_≟_ : (x y : A) → Relation.Nullary.Dec (x ≡ y)) {a = a₁ : A}
             {b : A} (¬p : Relation.Nullary.¬ a₁ ≡ b) (eq : a₁ ≡ b)
Termination checking [Relation.Binary.PropositionalEquality._.≡-≟-identity,
 Relation.Binary.PropositionalEquality._.with-420]
Trivially terminating: [Relation.Binary.PropositionalEquality._.≡-≟-identity]
etaExpandClause
  body    =  ≢-≟-identity _≟_ ¬eq | a₁ ≟ b
  xs      =  []
  new tel =  {a : Level} {A : Set a} (_≟_ : Decidable _≡_)
             {a = a₁ : A} {b : A} (¬eq : a₁ ≢ b)
etaExpandClause
  body    =  ⊥-elim (¬eq p)
  xs      =  []
  new tel =  {a : Level} {A : Set a}
             (_≟_ : (x y : A) → Relation.Nullary.Dec (x ≡ y)) {a = a₁ : A}
             {b : A} (p : a₁ ≡ b) (¬eq : a₁ ≡ b → ⊥)
etaExpandClause
  body    =  ¬p , refl
  xs      =  []
  new tel =  {a : Level} {A : Set a}
             (_≟_ : (x y : A) → Relation.Nullary.Dec (x ≡ y)) {a = a₁ : A}
             {b : A} (¬p : Relation.Nullary.¬ a₁ ≡ b) (¬eq : a₁ ≡ b → ⊥)
Termination checking [Relation.Binary.PropositionalEquality._.≢-≟-identity,
 Relation.Binary.PropositionalEquality._.with-438]
Trivially terminating: [Relation.Binary.PropositionalEquality._.≢-≟-identity]
etaExpandClause
  body    =  ≡-irrelevance
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {y : A} (a₁ : x ≡ y)
             (b : x ≡ y)
Termination checking [Relation.Binary.PropositionalEquality.proof-irrelevance]
Trivially terminating: [Relation.Binary.PropositionalEquality.proof-irrelevance]
etaExpandClause
  body    =  yes refl
  xs      =  []
  new tel =  (x : ⊤) (y : ⊤)
Termination checking [Data.Unit._≟_]
Trivially terminating: [Data.Unit._≟_]
etaExpandClause
  body    =  yes (record {})
  xs      =  []
  new tel =  (x : ⊤) (y : ⊤)
Termination checking [Data.Unit._≤?_]
Trivially terminating: [Data.Unit._≤?_]
etaExpandClause
  body    =  inj₁ (record {})
  xs      =  []
  new tel =  (x : ⊤) (y : ⊤)
Termination checking [Data.Unit.total]
Trivially terminating: [Data.Unit.total]
etaExpandClause
  body    =  PropEq.preorder ⊤
  xs      =  []
  new tel = 
Termination checking [Data.Unit.preorder]
Trivially terminating: [Data.Unit.preorder]
etaExpandClause
  body    =  PropEq.setoid ⊤
  xs      =  []
  new tel = 
Termination checking [Data.Unit.setoid]
Trivially terminating: [Data.Unit.setoid]
etaExpandClause
  body    =  record
             { Carrier = ⊤
             ; _≈_ = _≡_
             ; _≤_ = _≤_
             ; isDecTotalOrder =
                 record
                 { isTotalOrder =
                     record
                     { isPartialOrder =
                         record
                         { isPreorder =
                             record
                             { isEquivalence = PropEq.isEquivalence
                             ; reflexive = λ {.i} {.j} _ → record {}
                             ; trans = λ {.i} {.j} {.k} _ _ → record {}
                             }
                         ; antisym = λ {.x} {.y} _ _ → refl
                         }
                     ; total = λ _ _ → inj₁ (record {})
                     }
                 ; _≟_ = λ _ _ → yes refl
                 ; _≤?_ = λ _ _ → yes (record {})
                 }
             }
  xs      =  []
  new tel = 
etaExpandClause
  body    =  refl
  xs      =  []
  new tel =  {x : ⊤} {y : ⊤} (x₁ : x ≤ y) (x₂ : y ≤ x)
Termination checking [Data.Unit.decTotalOrder, Data.Unit._.antisym]
Trivially terminating: [Data.Unit.decTotalOrder]
etaExpandClause
  body    =  DecTotalOrder.Eq.decSetoid decTotalOrder
  xs      =  []
  new tel = 
Termination checking [Data.Unit.decSetoid]
Trivially terminating: [Data.Unit.decSetoid]
etaExpandClause
  body    =  TotalOrder.poset
             (DecTotalOrder.totalOrder decTotalOrder)
  xs      =  []
  new tel = 
Termination checking [Data.Unit.poset]
Trivially terminating: [Data.Unit.poset]
   Checking Function.Equivalence (/Users/emily/src/agda-stdlib/src/Function/Equivalence.agda).
etaExpandClause
  body    =  to
  xs      =  []
  new tel =  (to₁ : @2 ⟶ @1) (from₁ : @2 ⟶ @3)
etaExpandClause
  body    =  from
  xs      =  []
  new tel =  (to₁ : @2 ⟶ @1) (from₁ : @2 ⟶ @3)
etaExpandClause
  body    =  Equivalence (P.setoid From) (P.setoid To)
  xs      =  []
  new tel =  {f : Level} {t : Level} (From : Set f) (To : Set t)
Termination checking [Function.Equivalence._⇔_]
Trivially terminating: [Function.Equivalence._⇔_]
etaExpandClause
  body    =  record { to = P.→-to-⟶ to ; from = P.→-to-⟶ from }
  xs      =  []
  new tel =  {f : Level} {t : Level} {From : Set f} {To : Set t}
             (to : From → To) (from : To → From)
Termination checking [Function.Equivalence.equivalence]
Trivially terminating: [Function.Equivalence.equivalence]
etaExpandClause
  body    =  record { to = F.id ; from = F.id }
  xs      =  []
  new tel =  {s₁ : Level} {s₂ : Level} {x : Setoid s₁ s₂}
Termination checking [Function.Equivalence.id]
Trivially terminating: [Function.Equivalence.id]
etaExpandClause
  body    =  record
             { to = to f ⟪∘⟫ to g ; from = from g ⟪∘⟫ from f }
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {m₁ : Level} {m₂ : Level}
             {t₁ : Level} {t₂ : Level} {i : Setoid f₁ f₂} {j : Setoid m₁ m₂}
             {k : Setoid t₁ t₂} (f : Equivalence j k) (g : Equivalence i j)
Termination checking [Function.Equivalence._∘_]
Trivially terminating: [Function.Equivalence._∘_]
etaExpandClause
  body    =  record
             { to = Equivalence.from eq ; from = Equivalence.to eq }
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             {i : Setoid f₁ f₂} {j : Setoid t₁ t₂} (eq : Equivalence i j)
etaExpandClause
  body    =  Equivalence.from eq
  xs      =  []
  new tel =  (eq : Equivalence @1 @0)
etaExpandClause
  body    =  Equivalence.to eq
  xs      =  []
  new tel =  (eq : Equivalence @1 @0)
Termination checking [Function.Equivalence.sym, Function.Equivalence._._.from,
 Function.Equivalence._._.to]
Trivially terminating: [Function.Equivalence.sym]
etaExpandClause
  body    =  record
             { Carrier = Setoid s₁ s₂
             ; _≈_ = Equivalence
             ; isEquivalence =
                 record
                 { refl = id ; sym = sym ; trans = λ {.i} {.j} {.k} y x → x ∘ y }
             }
  xs      =  []
  new tel =  (s₁ : Level) (s₂ : Level)
Termination checking [Function.Equivalence.setoid]
Trivially terminating: [Function.Equivalence.setoid]
etaExpandClause
  body    =  record
             { Carrier = Set ℓ
             ; _≈_ = _⇔_
             ; isEquivalence =
                 record
                 { refl = λ {.x} → id
                 ; sym = λ {.i} {.j} → sym
                 ; trans = λ {.i} {.j} {.k} y x → x ∘ y
                 }
             }
  xs      =  []
  new tel =  (ℓ : Level)
Termination checking [Function.Equivalence.⇔-setoid]
Trivially terminating: [Function.Equivalence.⇔-setoid]
etaExpandClause
  body    =  record
             { to = t (Equivalence.to eq) ; from = f (Equivalence.from eq) }
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             {From : Setoid f₁ f₂} {To : Setoid t₁ t₂} {f₁′ : Level}
             {f₂′ : Level} {t₁′ : Level} {t₂′ : Level} {From′ : Setoid f₁′ f₂′}
             {To′ : Setoid t₁′ t₂′} (t : From ⟶ To → From′ ⟶ To′)
             (f : To ⟶ From → To′ ⟶ From′) (eq : Equivalence From To)
etaExpandClause
  body    =  Equivalence.from eq
  xs      =  []
  new tel =  (eq : Equivalence @9 @8)
etaExpandClause
  body    =  Equivalence.to eq
  xs      =  []
  new tel =  (eq : Equivalence @9 @8)
Termination checking [Function.Equivalence.map, Function.Equivalence._._.from,
 Function.Equivalence._._.to]
Trivially terminating: [Function.Equivalence.map]
etaExpandClause
  body    =  record
             { to = t (to eq₁) (to eq₂) ; from = f (from eq₁) (from eq₂) }
  xs      =  []
  new tel =  {f₁₁ : Level} {f₂₁ : Level} {t₁₁ : Level}
             {t₂₁ : Level} {From₁ : Setoid f₁₁ f₂₁} {To₁ : Setoid t₁₁ t₂₁}
             {f₁₂ : Level} {f₂₂ : Level} {t₁₂ : Level} {t₂₂ : Level}
             {From₂ : Setoid f₁₂ f₂₂} {To₂ : Setoid t₁₂ t₂₂} {f₁ : Level}
             {f₂ : Level} {t₁ : Level} {t₂ : Level} {From : Setoid f₁ f₂}
             {To : Setoid t₁ t₂} (t : From₁ ⟶ To₁ → From₂ ⟶ To₂ → From ⟶ To)
             (f : To₁ ⟶ From₁ → To₂ ⟶ From₂ → To ⟶ From)
             (eq₁ : Equivalence From₁ To₁) (eq₂ : Equivalence From₂ To₂)
Termination checking [Function.Equivalence.zip]
Trivially terminating: [Function.Equivalence.zip]
   Checking Function.Injection (/Users/emily/src/agda-stdlib/src/Function/Injection.agda).
etaExpandClause
  body    =  {x y : Setoid.Carrier A} →
             (B Setoid.≈ f ⟨$⟩ x) (f ⟨$⟩ y) → (A Setoid.≈ x) y
  xs      =  []
  new tel =  {a₁ : Level} {a₂ : Level} {b₁ : Level} {b₂ : Level}
             {A : Setoid a₁ a₂} {B : Setoid b₁ b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid._≈_ f
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             (_ : Setoid.Carrier A) (_ : Setoid.Carrier A)
etaExpandClause
  body    =  Setoid.Carrier A
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid.isEquivalence A
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid.isPreorder A
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid.preorder A
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid.refl B
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             {x : Setoid.Carrier A}
etaExpandClause
  body    =  Setoid.reflexive i
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             {i : Setoid.Carrier A} {j : Setoid.Carrier A} (_ : i ≡ j)
etaExpandClause
  body    =  Setoid.sym i
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             {i : Setoid.Carrier A} {j : Setoid.Carrier A}
             (_ : (A Setoid.≈ i) j)
etaExpandClause
  body    =  Setoid.trans k
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             {i : Setoid.Carrier A} {j : Setoid.Carrier A}
             {k : Setoid.Carrier A} (_ : (A Setoid.≈ i) j)
             (_ : (A Setoid.≈ j) k)
etaExpandClause
  body    =  Setoid._≈_ x
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             (_ : Setoid.Carrier B) (_ : Setoid.Carrier B)
etaExpandClause
  body    =  Setoid.Carrier B
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid.isEquivalence B
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid.isPreorder B
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid.preorder B
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
etaExpandClause
  body    =  Setoid.refl f
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             {x : Setoid.Carrier B}
etaExpandClause
  body    =  Setoid.reflexive j
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             {i : Setoid.Carrier B} {j : Setoid.Carrier B} (_ : i ≡ j)
etaExpandClause
  body    =  Setoid.sym j
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             {i : Setoid.Carrier B} {j : Setoid.Carrier B}
             (_ : (B Setoid.≈ i) j)
etaExpandClause
  body    =  Setoid.trans x
  xs      =  []
  new tel =  {.a₁ : Level} {.a₂ : Level} {.b₁ : Level}
             {.b₂ : Level} {A : Setoid .a₁ .a₂} {B : Setoid .b₁ .b₂} (f : A ⟶ B)
             {i : Setoid.Carrier B} {j : Setoid.Carrier B}
             {k : Setoid.Carrier B} (_ : (B Setoid.≈ i) j)
             (_ : (B Setoid.≈ j) k)
Termination checking [Function.Injection.Injective, Function.Injection._._._≈_,
 Function.Injection._._.Carrier,
 Function.Injection._._.isEquivalence,
 Function.Injection._._.isPreorder, Function.Injection._._.preorder,
 Function.Injection._._.refl, Function.Injection._._.reflexive,
 Function.Injection._._.sym, Function.Injection._._.trans,
 Function.Injection._._._≈_, Function.Injection._._.Carrier,
 Function.Injection._._.isEquivalence,
 Function.Injection._._.isPreorder, Function.Injection._._.preorder,
 Function.Injection._._.refl, Function.Injection._._.reflexive,
 Function.Injection._._.sym, Function.Injection._._.trans]
Trivially terminating: [Function.Injection.Injective]
etaExpandClause
  body    =  Π.cong to
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             {From : Setoid f₁ f₂} {To : Setoid t₁ t₂} (r : Injection From To)
             {i : Setoid.Carrier From} {j : Setoid.Carrier From}
             (_ : (From Setoid.≈ i) j)
etaExpandClause
  body    =  _⟨$⟩_ to
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             {From : Setoid f₁ f₂} {To : Setoid t₁ t₂} (r : Injection From To)
             (x : Setoid.Carrier From)
etaExpandClause
  body    =  to
  xs      =  []
  new tel =  (to₁ : @2 ⟶ @1) (injective₁ : Injective to₁)
etaExpandClause
  body    =  x₁
  xs      =  []
  new tel =  (to₁ : @2 ⟶ @1) (injective₁ : Injective to₁)
             {x : Setoid.Carrier @2} {y : Setoid.Carrier @3}
             (_ : (to₁ Setoid.≈ to injective₁ ⟨$⟩ x) (to injective₁ ⟨$⟩ y))
etaExpandClause
  body    =  _⟨$⟩_ (to x)
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             {From : Setoid f₁ f₂} {To : Setoid t₁ t₂} (r : Injection From To)
             (x : Setoid.Carrier From)
etaExpandClause
  body    =  Π.cong (to x)
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {t₁ : Level} {t₂ : Level}
             {From : Setoid f₁ f₂} {To : Setoid t₁ t₂} (r : Injection From To)
             {i : Setoid.Carrier From} {j : Setoid.Carrier From}
             (_ : (From Setoid.≈ i) j)
etaExpandClause
  body    =  Injection (P.setoid From) (P.setoid To)
  xs      =  []
  new tel =  {f : Level} {t : Level} (From : Set f) (To : Set t)
Termination checking [Function.Injection._↣_]
Trivially terminating: [Function.Injection._↣_]
etaExpandClause
  body    =  record { to = P.→-to-⟶ to ; injective = injective }
  xs      =  []
  new tel =  {f : Level} {t : Level} {From : Set f} {To : Set t}
             (to : From → To) (injective : {x y : From} → to x ≡ to y → x ≡ y)
Termination checking [Function.Injection.injection]
Trivially terminating: [Function.Injection.injection]
etaExpandClause
  body    =  record { to = F.id ; injective = λ {.x} {.y} x → x }
  xs      =  []
  new tel =  {s₁ : Level} {s₂ : Level} {S : Setoid s₁ s₂}
Termination checking [Function.Injection.id]
Trivially terminating: [Function.Injection.id]
etaExpandClause
  body    =  record
             { to = to f ⟪∘⟫ to g
             ; injective = λ {.x} {.y} x → injective g (injective f x)
             }
  xs      =  []
  new tel =  {f₁ : Level} {f₂ : Level} {m₁ : Level} {m₂ : Level}
             {t₁ : Level} {t₂ : Level} {F : Setoid f₁ f₂} {M : Setoid m₁ m₂}
             {T : Setoid t₁ t₂} (f : Injection M T) (g : Injection F M)
Termination checking [Function.Injection._∘_]
Trivially terminating: [Function.Injection._∘_]
etaExpandClause
  body    =  true
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P)
etaExpandClause
  body    =  false
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P)
Termination checking [Relation.Nullary.Decidable.⌊_⌋]
Trivially terminating: [Relation.Nullary.Decidable.⌊_⌋]
etaExpandClause
  body    =  T ⌊ Q ⌋
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (Q : Dec P)
Termination checking [Relation.Nullary.Decidable.True]
Trivially terminating: [Relation.Nullary.Decidable.True]
etaExpandClause
  body    =  T ⌊ Q ⌋
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (Q : Dec P)
etaExpandClause
  body    =  T (not ⌊ Q ⌋)
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (Q : Dec P)
Termination checking [Relation.Nullary.Decidable.False]
Trivially terminating: [Relation.Nullary.Decidable.False]
etaExpandClause
  body    =  T (not ⌊ Q ⌋)
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (Q : Dec P)
etaExpandClause
  body    =  p₁
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P)
             (x : True (yes p₁))
Termination checking [Relation.Nullary.Decidable.toWitness]
Trivially terminating: [Relation.Nullary.Decidable.toWitness]
etaExpandClause
  body    =  λ _ → tt
  xs      =  [_]
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P) (_ : P)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P) (_ : P)
Termination checking [Relation.Nullary.Decidable.fromWitness]
Trivially terminating: [Relation.Nullary.Decidable.fromWitness]
etaExpandClause
  body    =  λ _ → tt
  xs      =  [_]
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P) (_ : P)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P) (_ : P)
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P)
             (x : False (no ¬p)) (_ : P)
Termination checking [Relation.Nullary.Decidable.toWitnessFalse]
Trivially terminating: [Relation.Nullary.Decidable.toWitnessFalse]
etaExpandClause
  body    =  λ x → x x
  xs      =  [x]
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P) (x : ¬ P)
etaExpandClause
  body    =  λ _ → tt
  xs      =  [_]
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P) (_ : ¬ P)
Termination checking [Relation.Nullary.Decidable.fromWitnessFalse]
Trivially terminating: [Relation.Nullary.Decidable.fromWitnessFalse]
etaExpandClause
  body    =  λ x → x x
  xs      =  [x]
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P) (x : ¬ P)
etaExpandClause
  body    =  λ _ → tt
  xs      =  [_]
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P) (_ : ¬ P)
etaExpandClause
  body    =  yes (Equivalence.to P⇔Q ⟨$⟩ p₁)
  xs      =  []
  new tel =  {p : Level.Level} {q : Level.Level} {P : Set p}
             {Q : Set q} (P⇔Q : P ⇔ Q) (p₁ : P)
etaExpandClause
  body    =  no (λ x → ¬p (Equivalence.from P⇔Q ⟨$⟩ x))
  xs      =  []
  new tel =  {p : Level.Level} {q : Level.Level} {P : Set p}
             {Q : Set q} (P⇔Q : P ⇔ Q) (¬p : ¬ P)
Termination checking [Relation.Nullary.Decidable.map]
Trivially terminating: [Relation.Nullary.Decidable.map]
etaExpandClause
  body    =  map (equivalence Q→P x)
  xs      =  []
  new tel =  {p : Level.Level} {q : Level.Level} {P : Set p}
             {Q : Set q} (P→Q : P → Q) (Q→P : Q → P) (_ : Dec P)
Termination checking [Relation.Nullary.Decidable.map′]
Trivially terminating: [Relation.Nullary.Decidable.map′]
etaExpandClause
  body    =  via-injection inj dec x y
             | dec (to inj ⟨$⟩ x) (to inj ⟨$⟩ y)
  xs      =  []
  new tel =  {a₁ : Level.Level} {a₂ : Level.Level}
             {b₁ : Level.Level} {b₂ : Level.Level} {A : Setoid a₁ a₂}
             {B : Setoid b₁ b₂} (inj : Injection A B)
             (dec : Decidable (Setoid._≈_ B)) (x : Setoid.Carrier A)
             (y : Setoid.Carrier A)
etaExpandClause
  body    =  yes (injective inj injx≈injy)
  xs      =  []
  new tel =  {a₁ : Level.Level} {a₂ : Level.Level}
             {b₁ : Level.Level} {b₂ : Level.Level} {A : Setoid a₁ a₂}
             {B : Setoid b₁ b₂} (inj : Injection A B)
             (dec : (x y : Setoid.Carrier B) → Dec ((B Setoid.≈ x) y))
             (x : Setoid.Carrier A) (y : Setoid.Carrier A)
             (injx≈injy : (B Setoid.≈ to inj ⟨$⟩ x) (to inj ⟨$⟩ y))
etaExpandClause
  body    =  no (λ x≈y → injx≉injy (Π.cong (to inj) x≈y))
  xs      =  []
  new tel =  {a₁ : Level.Level} {a₂ : Level.Level}
             {b₁ : Level.Level} {b₂ : Level.Level} {A : Setoid a₁ a₂}
             {B : Setoid b₁ b₂} (inj : Injection A B)
             (dec : (x y : Setoid.Carrier B) → Dec ((B Setoid.≈ x) y))
             (x : Setoid.Carrier A) (y : Setoid.Carrier A)
             (injx≉injy : ¬ (B Setoid.≈ to inj ⟨$⟩ x) (to inj ⟨$⟩ y))
Termination checking [Relation.Nullary.Decidable._.via-injection,
 Relation.Nullary.Decidable._.with-138]
Trivially terminating: [Relation.Nullary.Decidable._.via-injection]
etaExpandClause
  body    =  P
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P)
etaExpandClause
  body    =  Lift p ⊤
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P)
Termination checking [Relation.Nullary.Decidable._.From-yes]
Trivially terminating: [Relation.Nullary.Decidable._.From-yes]
etaExpandClause
  body    =  p₁
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P)
etaExpandClause
  body    =  Lift.lift tt
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P)
Termination checking [Relation.Nullary.Decidable._.from-yes]
Trivially terminating: [Relation.Nullary.Decidable._.from-yes]
etaExpandClause
  body    =  p₁
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P)
etaExpandClause
  body    =  Lift.lift tt
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P)
etaExpandClause
  body    =  ¬ P
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P)
etaExpandClause
  body    =  Lift p ⊤
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P)
Termination checking [Relation.Nullary.Decidable._.From-no]
Trivially terminating: [Relation.Nullary.Decidable._.From-no]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P) (_ : P)
etaExpandClause
  body    =  Lift.lift tt
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P)
Termination checking [Relation.Nullary.Decidable._.from-no]
Trivially terminating: [Relation.Nullary.Decidable._.from-no]
etaExpandClause
  body    =  x
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (¬p : ¬ P) (_ : P)
etaExpandClause
  body    =  Lift.lift tt
  xs      =  []
  new tel =  {p : Level.Level} {P : Set p} (p₁ : P)
Termination checking [Data.Maybe.Eq, Data.Maybe.Eq.just, Data.Maybe.Eq.nothing]
Trivially terminating: [Data.Maybe.Eq, Data.Maybe.Eq.just, Data.Maybe.Eq.nothing]
etaExpandClause
  body    =  x≈y
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {y : A} {ℓ : Level}
             {_≈_ : A → A → Set ℓ} (x≈y : x ≈ y)
Termination checking [Data.Maybe.drop-just]
Trivially terminating: [Data.Maybe.drop-just]
etaExpandClause
  body    =  just refl
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (refl : Reflexive _≈_) (x : A)
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (refl : Reflexive _≈_)
Termination checking [Data.Maybe.Eq-refl]
Trivially terminating: [Data.Maybe.Eq-refl]
etaExpandClause
  body    =  just (sym x≈y)
  xs      =  []
  new tel =  {a : Level} {A : Set a} {x : A} {y : A} {ℓ : Level}
             {_≈_ : A → A → Set ℓ} (sym : {i j : A} → i ≈ j → j ≈ i)
             (x≈y : x ≈ y)
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a}
             {_≈_ : A → A → Set ℓ} (sym : {i j : A} → i ≈ j → j ≈ i)
Termination checking [Data.Maybe.Eq-sym]
Trivially terminating: [Data.Maybe.Eq-sym]
etaExpandClause
  body    =  just (trans x≈y y≈z)
  xs      =  []
  new tel =  {a : Level} {A : Set a} {y : A} {y = y₁ : A} {x : A}
             {ℓ : Level} {_≈_ : A → A → Set ℓ}
             (trans : {i j k : A} → i ≈ j → j ≈ k → i ≈ k) (x≈y : x ≈ y)
             (y≈z : y ≈ y₁)
etaExpandClause
  body    =  nothing
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a}
             {_≈_ : A → A → Set ℓ} (trans : {i j k : A} → i ≈ j → j ≈ k → i ≈ k)
Termination checking [Data.Maybe.Eq-trans]
Trivially terminating: [Data.Maybe.Eq-trans]
etaExpandClause
  body    =  Eq-dec dec (just x) (just y) | dec x y
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (dec : B.Decidable _≈_) (x : A) (y : A)
etaExpandClause
  body    =  no (λ ())
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (dec : B.Decidable _≈_) (x : A)
etaExpandClause
  body    =  no (λ ())
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (dec : B.Decidable _≈_) (y : A)
etaExpandClause
  body    =  yes nothing
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (dec : B.Decidable _≈_)
etaExpandClause
  body    =  yes (just x≈y)
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a}
             {_≈_ : A → A → Set ℓ} (dec : (x y : A) → Dec (x ≈ y)) (x : A)
             (y : A) (x≈y : x ≈ y)
etaExpandClause
  body    =  no (λ x → x≉y (drop-just x))
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a}
             {_≈_ : A → A → Set ℓ} (dec : (x y : A) → Dec (x ≈ y)) (x : A)
             (y : A) (x≉y : ¬ (x ≈ y))
Termination checking [Data.Maybe.Eq-dec, Data.Maybe.with-114, Data.Maybe..absurdlambda,
 Data.Maybe..absurdlambda]
Trivially terminating: [Data.Maybe.Eq-dec]
etaExpandClause
  body    =  record
             { refl = Eq-refl (IsEquivalence.refl isEq)
             ; sym = Eq-sym (IsEquivalence.sym isEq)
             ; trans = Eq-trans (IsEquivalence.trans isEq)
             }
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (isEq : IsEquivalence _≈_)
Termination checking [Data.Maybe.Eq-isEquivalence]
Trivially terminating: [Data.Maybe.Eq-isEquivalence]
etaExpandClause
  body    =  record
             { refl = Eq-refl (IsEquivalence.refl isEq)
             ; sym = Eq-sym (IsEquivalence.sym isEq)
             ; trans = Eq-trans (IsEquivalence.trans isEq)
             }
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (isEq : IsEquivalence _≈_)
etaExpandClause
  body    =  record
             { isEquivalence =
                 Eq-isEquivalence (IsDecEquivalence.isEquivalence isDecEq)
             ; _≟_ = Eq-dec (IsDecEquivalence._≟_ isDecEq)
             }
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (isDecEq : IsDecEquivalence _≈_)
Termination checking [Data.Maybe.Eq-isDecEquivalence]
Trivially terminating: [Data.Maybe.Eq-isDecEquivalence]
etaExpandClause
  body    =  record
             { isEquivalence =
                 Eq-isEquivalence (IsDecEquivalence.isEquivalence isDecEq)
             ; _≟_ = Eq-dec (IsDecEquivalence._≟_ isDecEq)
             }
  xs      =  []
  new tel =  {a : Level} {ℓ : Level} {A : Set a} {_≈_ : Rel A ℓ}
             (isDecEq : IsDecEquivalence _≈_)
etaExpandClause
  body    =  record
             { Carrier = Maybe (Setoid.Carrier S)
             ; _≈_ = Eq (Setoid._≈_ S)
             ; isEquivalence = Eq-isEquivalence (Setoid.isEquivalence S)
             }
  xs      =  []
  new tel =  {ℓ₁ : Level} {ℓ₂ : Level} (S : Setoid ℓ₁ ℓ₂)
Termination checking [Data.Maybe.setoid]
Trivially terminating: [Data.Maybe.setoid]
etaExpandClause
  body    =  record
             { Carrier = Maybe (Setoid.Carrier S)
             ; _≈_ = Eq (Setoid._≈_ S)
             ; isEquivalence = Eq-isEquivalence (Setoid.isEquivalence S)
             }
  xs      =  []
  new tel =  {ℓ₁ : Level} {ℓ₂ : Level} (S : Setoid ℓ₁ ℓ₂)
etaExpandClause
  body    =  record
             { Carrier = Maybe (DecSetoid.Carrier D)
             ; _≈_ = Eq (DecSetoid._≈_ D)
             ; isDecEquivalence =
                 Eq-isDecEquivalence (DecSetoid.isDecEquivalence D)
             }
  xs      =  []
  new tel =  {ℓ₁ : Level} {ℓ₂ : Level} (D : DecSetoid ℓ₁ ℓ₂)
Termination checking [Data.Maybe.decSetoid]
Trivially terminating: [Data.Maybe.decSetoid]
etaExpandClause
  body    =  record
             { Carrier = Maybe (DecSetoid.Carrier D)
             ; _≈_ = Eq (DecSetoid._≈_ D)
             ; isDecEquivalence =
                 Eq-isDecEquivalence (DecSetoid.isDecEquivalence D)
             }
  xs      =  []
  new tel =  {ℓ₁ : Level} {ℓ₂ : Level} (D : DecSetoid ℓ₁ ℓ₂)
etaExpandClause
  body    =  no (λ ())
  xs      =  []
  new tel =  {a : Level} {p : Level} {A : Set a} {P : A → Set p}
             (p₁ : U.Decidable P)
etaExpandClause
  body    =  Dec.map′ just (λ { (just px) → px }) (p₁ x)
  xs      =  []
  new tel =  {a : Level} {p : Level} {A : Set a} {P : A → Set p}
             (p₁ : U.Decidable P) (x : A)
etaExpandClause
  body    =  px
  xs      =  []
  new tel =  {.a : Level} {.A : Set .a} {x : .A} {.p : Level}
             {.P : .A → Set .p} (p : (x₁ : .A) → Dec (.P x₁)) (px : .P x)
Termination checking [Data.Maybe.anyDec, Data.Maybe..extendedlambda0,
 Data.Maybe..absurdlambda]
Trivially terminating: [Data.Maybe.anyDec]
etaExpandClause
  body    =  yes nothing
  xs      =  []
  new tel =  {a : Level} {p : Level} {A : Set a} {P : A → Set p}
             (p₁ : U.Decidable P)
etaExpandClause
  body    =  Dec.map′ just (λ { (just px) → px }) (p₁ x)
  xs      =  []
  new tel =  {a : Level} {p : Level} {A : Set a} {P : A → Set p}
             (p₁ : U.Decidable P) (x : A)
etaExpandClause
  body    =  px
  xs      =  []
  new tel =  {.a : Level} {.A : Set .a} {x : .A} {.p : Level}
             {.P : .A → Set .p} (p : (x₁ : .A) → Dec (.P x₁)) (px : .P x)
Termination checking [Data.Maybe.allDec, Data.Maybe..extendedlambda1]
Trivially terminating: [Data.Maybe.allDec]
Termination checking [Termination.Unit, Termination.Unit.unit]
Trivially terminating: [Termination.Unit, Termination.Unit.unit]
etaExpandClause
  body    =  step
  xs      =  []
  new tel =  (step₁ : Unit ⊎ Stream)
etaExpandClause
  body    =  inj₂ (valid₀ x)
  xs      =  []
  new tel =  (x : Unit)
Termination checking [Termination.valid₀]
Termination checking [Termination.valid₀] with cutoff=9...
  target type ends in Termination.Stream
termination checking body of valid₀ : Unit → Stream
etaExpandClause
  body    =  inj₂ (valid₀ x)
  xs      =  []
  new tel =  (x : Unit)
termClause
  tel = (x : Unit)
  ps  = [x, step]
termination checking clause of valid₀
  lhs: x .Termination.Stream.step
  rhs: inj₂ (valid₀ x)
looking for calls in inj₂ (valid₀ x)
looking for calls in valid₀ x
termination checking function call  valid₀ x
identifier valid₀ is either not a projection or coinductive
looking for calls in x
found call from valid₀ to valid₀
comparing 1 args
checking isCoinductiveProjection Termination.Stream.step
Termination.Stream.step is coinductive; record type is Termination.Stream
using SIZELT vars after projection Termination.Stream.step
usableSizeVars = fromList []
no usuable size vars
compareElim e = $ x p = x
  e = Apply ωru(Var 0 [])
  p = Masked {getMask = False, getMasked = VarP (PatOVar x) (DBPatVar {dbPatVarName = "x", dbPatVarIndex = 0})}
 comparing term  x  to pattern  x  results in =
compareElim e = $ x p = .Termination.Stream.step
  e = Apply ωru(Var 0 [])
  p = Masked {getMask = False, getMasked = ProjP ProjPrefix Termination.Stream.step}
checking isCoinductiveProjection Termination.Stream.step
Termination.Stream.step is coinductive; record type is Termination.Stream
Termination.Stream.step must be recursive
Termination.Stream.step has been declared recursive, doing actual check now...
looking for recursive occurrences of Stream in and Unit ⊎ Stream
found Stream
compareArgs:
  projsCaller = 1
  projsCallee = 0
  guardedness of call: -1
composing with guardedness = counting as =
kept call from Termination.valid₀ x .Termination.Stream.step
  to Termination.valid₀ (x)
  call matrix (with guardedness): 
    -1    ?    ?
     ?    =    ?
Calls (no dot patterns): Source: 0
Target: 0
Matrix:   -1    ?    ?
           ?    =    ?
======================================================================
======================= Initial call matrices ========================
======================================================================

  Source: 0
  Target: 0
  Matrix:   -1    ?    ?
             ?    =    ?
======================================================================
========================= New call matrices ==========================
======================================================================

Idempotent call matrices (no dot patterns):

    -1    ?    ?
     ?    =    ?
Termination.valid₀ does termination check
etaExpandClause
  body    =  maybe (λ _ → inj₂ (invalid₀ x)) (inj₁ unit) x
  xs      =  []
  new tel =  (x : Maybe Unit)
Termination checking [Termination.invalid₀]
Termination checking [Termination.invalid₀] with cutoff=9...
  target type ends in Termination.Stream
termination checking body of invalid₀ : Maybe Unit → Stream
etaExpandClause
  body    =  maybe (λ _ → inj₂ (invalid₀ x)) (inj₁ unit) x
  xs      =  []
  new tel =  (x : Maybe Unit)
termClause
  tel = (x : Maybe Unit)
  ps  = [x, step]
termination checking clause of invalid₀
  lhs: x .Termination.Stream.step
  rhs: maybe (λ _ → inj₂ (invalid₀ x)) (inj₁ unit) x
looking for calls in maybe (λ _ → inj₂ (invalid₀ x)) (inj₁ unit) x
termination checking function call  maybe (λ _ → inj₂ (invalid₀ x))
                                    (inj₁ unit) x
identifier maybe is either not a projection or coinductive
looking for calls in .Agda.Primitive.lzero
looking for calls in .Agda.Primitive.lzero
looking for calls in Unit
termination checking function call  Unit
identifier Unit is either not a projection or coinductive
found call from invalid₀ to Unit
looking for calls in λ v → Unit ⊎ Stream
looking for calls in Unit ⊎ Stream
termination checking function call  Unit ⊎ Stream
identifier _⊎_ is either not a projection or coinductive
looking for calls in .Agda.Primitive.lzero
looking for calls in .Agda.Primitive.lzero
looking for calls in Unit
termination checking function call  Unit
identifier Unit is either not a projection or coinductive
found call from invalid₀ to Unit
looking for calls in Stream
termination checking function call  Stream
identifier Stream is either not a projection or coinductive
found call from invalid₀ to Stream
found call from invalid₀ to _⊎_
looking for calls in λ _ → inj₂ (invalid₀ x)
looking for calls in inj₂ (invalid₀ x)
looking for calls in invalid₀ x
termination checking function call  invalid₀ x
identifier invalid₀ is either not a projection or coinductive
looking for calls in x
found call from invalid₀ to invalid₀
comparing 1 args
checking isCoinductiveProjection Termination.Stream.step
Termination.Stream.step is coinductive; record type is Termination.Stream
using SIZELT vars after projection Termination.Stream.step
usableSizeVars = fromList []
no usuable size vars
compareElim e = $ x p = x
  e = Apply ωru(Var 1 [])
  p = Masked {getMask = False, getMasked = VarP (PatOVar x) (DBPatVar {dbPatVarName = "x", dbPatVarIndex = 1})}
 comparing term  x  to pattern  x  results in =
compareElim e = $ x p = .Termination.Stream.step
  e = Apply ωru(Var 1 [])
  p = Masked {getMask = False, getMasked = ProjP ProjPrefix Termination.Stream.step}
checking isCoinductiveProjection Termination.Stream.step
Termination.Stream.step is coinductive; record type is Termination.Stream
Termination.Stream.step must be recursive
Termination.Stream.step has been declared recursive, doing actual check now...
looking for recursive occurrences of Stream in and Unit ⊎ Stream
found Stream
compareArgs:
  projsCaller = 1
  projsCallee = 0
  guardedness of call: -1
composing with guardedness ? counting as ?
kept call from Termination.invalid₀ x .Termination.Stream.step
  to Termination.invalid₀ (x)
  call matrix (with guardedness): 
     ?    ?    ?
     ?    =    ?
looking for calls in inj₁ unit
looking for calls in unit
looking for calls in x
found call from invalid₀ to maybe
Calls (no dot patterns): Source: 0
Target: 0
Matrix:    ?    ?    ?
           ?    =    ?
======================================================================
======================= Initial call matrices ========================
======================================================================

  Source: 0
  Target: 0
  Matrix:    ?    ?    ?
             ?    =    ?
======================================================================
========================= New call matrices ==========================
======================================================================

Idempotent call matrices (no dot patterns):

     ?    ?    ?
     ?    =    ?
termination checking body of invalid₀ : Maybe Unit → Stream
etaExpandClause
  body    =  maybe (λ _ → inj₂ (invalid₀ x)) (inj₁ unit) x
  xs      =  []
  new tel =  (x : Maybe Unit)
termClause
  tel = (x : Maybe Unit)
  ps  = [x, step]
termination checking clause of invalid₀
  lhs: x .Termination.Stream.step
  rhs: maybe (λ _ → inj₂ (invalid₀ x)) (inj₁ unit) x
looking for calls in maybe (λ _ → inj₂ (invalid₀ x)) (inj₁ unit) x
termination checking function call  maybe (λ _ → inj₂ (invalid₀ x))
                                    (inj₁ unit) x
identifier maybe is either not a projection or coinductive
looking for calls in .Agda.Primitive.lzero
looking for calls in .Agda.Primitive.lzero
looking for calls in Unit
termination checking function call  Unit
identifier Unit is either not a projection or coinductive
found call from invalid₀ to Unit
looking for calls in λ v → Unit ⊎ Stream
looking for calls in Unit ⊎ Stream
termination checking function call  Unit ⊎ Stream
identifier _⊎_ is either not a projection or coinductive
looking for calls in .Agda.Primitive.lzero
looking for calls in .Agda.Primitive.lzero
looking for calls in Unit
termination checking function call  Unit
identifier Unit is either not a projection or coinductive
found call from invalid₀ to Unit
looking for calls in Stream
termination checking function call  Stream
identifier Stream is either not a projection or coinductive
found call from invalid₀ to Stream
found call from invalid₀ to _⊎_
looking for calls in λ _ → inj₂ (invalid₀ x)
looking for calls in inj₂ (invalid₀ x)
looking for calls in invalid₀ x
termination checking function call  invalid₀ x
identifier invalid₀ is either not a projection or coinductive
looking for calls in x
found call from invalid₀ to invalid₀
comparing 1 args
checking isCoinductiveProjection Termination.Stream.step
Termination.Stream.step is coinductive; record type is Termination.Stream
using SIZELT vars after projection Termination.Stream.step
usableSizeVars = fromList []
no usuable size vars
compareElim e = $ x p = x
  e = Apply ωru(Var 1 [])
  p = Masked {getMask = False, getMasked = VarP (PatOVar x) (DBPatVar {dbPatVarName = "x", dbPatVarIndex = 1})}
 comparing term  x  to pattern  x  results in =
compareElim e = $ x p = .Termination.Stream.step
  e = Apply ωru(Var 1 [])
  p = Masked {getMask = False, getMasked = ProjP ProjPrefix Termination.Stream.step}
checking isCoinductiveProjection Termination.Stream.step
Termination.Stream.step is coinductive; record type is Termination.Stream
Termination.Stream.step must be recursive
Termination.Stream.step has been declared recursive, doing actual check now...
looking for recursive occurrences of Stream in and Unit ⊎ Stream
found Stream
compareArgs:
  projsCaller = 1
  projsCallee = 0
  guardedness of call: -1
composing with guardedness ? counting as ?
kept call from Termination.invalid₀ x .Termination.Stream.step
  to Termination.invalid₀ (x)
  call matrix (with guardedness): 
     ?    ?    ?
     ?    =    ?
looking for calls in inj₁ unit
looking for calls in unit
looking for calls in x
found call from invalid₀ to maybe
Calls (dot patterns): Source: 0
Target: 0
Matrix:    ?    ?    ?
           ?    =    ?
======================================================================
======================= Initial call matrices ========================
======================================================================

  Source: 0
  Target: 0
  Matrix:    ?    ?    ?
             ?    =    ?
======================================================================
========================= New call matrices ==========================
======================================================================

Idempotent call matrices (dot patterns):

     ?    ?    ?
     ?    =    ?
/Users/emily/src/3ea3-final-project/Termination.agda:22,1-23,66
Termination checking failed for the following functions:
  invalid₀
Problematic calls:
  invalid₀ x