From 1c3da162d500cfe885fa21b4d75847c4bcbb2aa1 Mon Sep 17 00:00:00 2001
From: Helmut Grohne <grohne@cs.uni-bonn.de>
Date: Tue, 28 Jan 2014 15:15:12 +0100
Subject: define bff on a partial getlen
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The representation chosen is to give both an injection gl₁ and a
function gl₂ (formerly getlen), such that by choosing a non-identity for
gl₁ partiality of getlen can be expressed. An alternative would have
been to allow getlen to return a Maybe ℕ and have get return
  maybe (Vec A) ⊤ (getlen n)
thus sending all inputs for which getlen yields nothing to tt. It seems
that while there is no way to obtain a such a getlen predicate from an
arbitrary index Setoid I, it should be possible to manufacture a Setoid
from a predicate. Thanks to Stefan Mehner for the insightful discussion.
---
 FreeTheorems.agda | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

(limited to 'FreeTheorems.agda')

diff --git a/FreeTheorems.agda b/FreeTheorems.agda
index f37cada..aacb95a 100644
--- a/FreeTheorems.agda
+++ b/FreeTheorems.agda
@@ -1,10 +1,15 @@
 module FreeTheorems where
 
+open import Level using () renaming (zero to ℓ₀)
 open import Data.Nat using (ℕ)
 open import Data.List using (List ; map)
 open import Data.Vec using (Vec) renaming (map to mapV)
 open import Function using (_∘_)
-open import Relation.Binary.PropositionalEquality using (_≗_)
+open import Function.Equality using (_⟶_ ; _⟨$⟩_)
+open import Function.Injection using (module Injection) renaming (Injection to _↪_)
+open import Relation.Binary.PropositionalEquality using (_≗_ ; cong) renaming (setoid to EqSetoid)
+open import Relation.Binary using (Setoid)
+open Injection using (to)
 
 module ListList where
   get-type : Set₁
@@ -17,5 +22,23 @@ module VecVec where
   get-type : (ℕ → ℕ) → Set₁
   get-type getlen = {A : Set} {n : ℕ} → Vec A n → Vec A (getlen n)
 
+  free-theorem-type : Set₁
+  free-theorem-type = {getlen : ℕ → ℕ} → (get : get-type getlen) → {α β : Set} → (f : α → β) → {n : ℕ} → get {_} {n} ∘ mapV f ≗ mapV f ∘ get
+
+  postulate
+    free-theorem : free-theorem-type
+
+module PartialVecVec where
+  get-type : {I : Setoid ℓ₀ ℓ₀} → (I ↪ (EqSetoid ℕ)) → (I ⟶ (EqSetoid ℕ)) → Set₁
+  get-type {I} gl₁ gl₂ = {A : Set} {i : Setoid.Carrier I} → Vec A (to gl₁ ⟨$⟩ i) → Vec A (gl₂ ⟨$⟩ i)
+
   postulate
-    free-theorem : {getlen : ℕ → ℕ} → (get : get-type getlen) → {α β : Set} → (f : α → β) → {n : ℕ} → get {_} {n} ∘ mapV f ≗ mapV f ∘ get
+    free-theorem : {I : Setoid ℓ₀ ℓ₀} → (gl₁ : I ↪ (EqSetoid ℕ)) → (gl₂ : I ⟶ (EqSetoid ℕ)) (get : get-type gl₁ gl₂)  → {α β : Set} → (f : α → β) → {i : Setoid.Carrier I} → get {_} {i} ∘ mapV f ≗ mapV f ∘ get
+
+  open VecVec using () renaming (free-theorem-type to VecVec-free-theorem-type)
+
+  ≡-to-Π : {A B : Set} → (A → B) → EqSetoid A ⟶ EqSetoid B
+  ≡-to-Π f = record { _⟨$⟩_ = f; cong = cong f }
+
+  VecVec-free-theorem : VecVec-free-theorem-type
+  VecVec-free-theorem {getlen} get = free-theorem Function.Injection.id (≡-to-Π getlen) get
-- 
cgit v1.2.3


From 934f2003d4f47c2af3a91cd827d75caeded7ec7a Mon Sep 17 00:00:00 2001
From: Helmut Grohne <grohne@cs.uni-bonn.de>
Date: Thu, 30 Jan 2014 14:01:10 +0100
Subject: express VecBFF via PartialVecBFF

---
 BFF.agda          | 28 +++++++++++-----------------
 FreeTheorems.agda |  5 ++---
 Generic.agda      | 10 +++++++---
 3 files changed, 20 insertions(+), 23 deletions(-)

(limited to 'FreeTheorems.agda')

diff --git a/BFF.agda b/BFF.agda
index 0247bde..bf8e751 100644
--- a/BFF.agda
+++ b/BFF.agda
@@ -12,18 +12,18 @@ open import Data.List using (List ; [] ; _∷_ ; map ; length)
 open import Data.Vec using (Vec ; toList ; fromList ; tabulate ; allFin) renaming (lookup to lookupV ; map to mapV ; [] to []V ; _∷_ to _∷V_)
 open import Function using (id ; _∘_ ; flip)
 open import Function.Equality using (_⟶_ ; _⟨$⟩_)
-open import Function.Injection using (module Injection) renaming (Injection to _↪_)
+open import Function.Injection using (module Injection) renaming (Injection to _↪_ ; id to id↪)
 open import Relation.Binary using (Setoid ; DecSetoid ; module DecSetoid)
-open import Relation.Binary.PropositionalEquality using () renaming (setoid to EqSetoid)
+open import Relation.Binary.PropositionalEquality using (cong) renaming (setoid to EqSetoid)
 open Injection using (to)
 
 open import FinMap
-open import Generic using (mapMV)
+open import Generic using (mapMV ; ≡-to-Π)
 import CheckInsert
 import FreeTheorems
 
-module VecBFF (A : DecSetoid ℓ₀ ℓ₀) where
-  open FreeTheorems.VecVec public using (get-type)
+module PartialVecBFF (A : DecSetoid ℓ₀ ℓ₀) where
+  open FreeTheorems.PartialVecVec public using (get-type)
   open module A = DecSetoid A using (Carrier) renaming (_≟_ to deq)
   open CheckInsert A
 
@@ -37,7 +37,7 @@ module VecBFF (A : DecSetoid ℓ₀ ℓ₀) where
   denumerate : {n : ℕ} → Vec Carrier n → Fin n → Carrier
   denumerate = flip lookupV
 
-  bff : {getlen : ℕ → ℕ} → (get-type getlen) → ({n : ℕ} → Vec Carrier n → Vec Carrier (getlen n) → Maybe (Vec Carrier n))
+  bff : {I : Setoid ℓ₀ ℓ₀} {gl₁ : I ↪ (EqSetoid ℕ)} {gl₂ : I ⟶ EqSetoid ℕ} → get-type gl₁ gl₂ → ({i : Setoid.Carrier I} → Vec Carrier (to gl₁ ⟨$⟩ i) → Vec Carrier (gl₂ ⟨$⟩ i) → Maybe (Vec Carrier (to gl₁ ⟨$⟩ i)))
   bff get s v = let s′ = enumerate s
                     t′ = get s′
                     g  = fromFunc (denumerate s)
@@ -46,18 +46,12 @@ module VecBFF (A : DecSetoid ℓ₀ ℓ₀) where
                     h′ = (flip union g′) <$> h
                 in h′ >>= flip mapMV s′ ∘ flip lookupV
 
-module PartialVecBFF (A : DecSetoid ℓ₀ ℓ₀) where
-  open FreeTheorems.PartialVecVec public using (get-type)
+module VecBFF (A : DecSetoid ℓ₀ ℓ₀) where
+  open FreeTheorems.VecVec public using (get-type)
   open module A = DecSetoid A using (Carrier) renaming (_≟_ to deq)
   open CheckInsert A
 
-  open VecBFF A public using (assoc ; enumerate ; denumerate)
+  open PartialVecBFF A public using (assoc ; enumerate ; denumerate)
 
-  bff : {I : Setoid ℓ₀ ℓ₀} {gl₁ : I ↪ (EqSetoid ℕ)} {gl₂ : I ⟶ EqSetoid ℕ} → get-type gl₁ gl₂ → ({i : Setoid.Carrier I} → Vec Carrier (to gl₁ ⟨$⟩ i) → Vec Carrier (gl₂ ⟨$⟩ i) → Maybe (Vec Carrier (to gl₁ ⟨$⟩ i)))
-  bff get s v = let s′ = enumerate s
-                    t′ = get s′
-                    g  = fromFunc (denumerate s)
-                    g′ = delete-many t′ g
-                    h  = assoc t′ v
-                    h′ = (flip union g′) <$> h
-                in h′ >>= flip mapMV s′ ∘ flip lookupV
+  bff : {getlen : ℕ → ℕ} → (get-type getlen) → ({n : ℕ} → Vec Carrier n → Vec Carrier (getlen n) → Maybe (Vec Carrier n))
+  bff {getlen} get s v = PartialVecBFF.bff A {_} {id↪} {≡-to-Π getlen} get {_} s v
diff --git a/FreeTheorems.agda b/FreeTheorems.agda
index aacb95a..c22a68d 100644
--- a/FreeTheorems.agda
+++ b/FreeTheorems.agda
@@ -11,6 +11,8 @@ open import Relation.Binary.PropositionalEquality using (_≗_ ; cong) renaming
 open import Relation.Binary using (Setoid)
 open Injection using (to)
 
+open import Generic using (≡-to-Π)
+
 module ListList where
   get-type : Set₁
   get-type = {A : Set} → List A → List A
@@ -37,8 +39,5 @@ module PartialVecVec where
 
   open VecVec using () renaming (free-theorem-type to VecVec-free-theorem-type)
 
-  ≡-to-Π : {A B : Set} → (A → B) → EqSetoid A ⟶ EqSetoid B
-  ≡-to-Π f = record { _⟨$⟩_ = f; cong = cong f }
-
   VecVec-free-theorem : VecVec-free-theorem-type
   VecVec-free-theorem {getlen} get = free-theorem Function.Injection.id (≡-to-Π getlen) get
diff --git a/Generic.agda b/Generic.agda
index 81292ff..a734ec2 100644
--- a/Generic.agda
+++ b/Generic.agda
@@ -9,16 +9,20 @@ open import Data.Product using (_×_ ; _,_)
 open import Data.Vec using (Vec ; toList ; fromList ; map) renaming ([] to []V ; _∷_ to _∷V_)
 open import Data.Vec.Equality using () renaming (module Equality to VecEq)
 open import Function using (_∘_ ; id)
+open import Function.Equality using (_⟶_)
 open import Level using () renaming (zero to ℓ₀)
 open import Relation.Binary using (Setoid ; module Setoid)
 open import Relation.Binary.Core using (_≡_ ; refl)
 open import Relation.Binary.Indexed using (_at_) renaming (Setoid to ISetoid)
-open import Relation.Binary.PropositionalEquality using (_≗_ ; cong ; subst ; trans) renaming (setoid to PropEq)
+open import Relation.Binary.PropositionalEquality using (_≗_ ; cong ; subst ; trans) renaming (setoid to EqSetoid)
 
 open Setoid using () renaming (_≈_ to _∋_≈_)
 open Category.Functor.RawFunctor {Level.zero} Data.Maybe.functor using (_<$>_)
 open Category.Monad.RawMonad {Level.zero} Data.Maybe.monad using (_>>=_)
 
+≡-to-Π : {A B : Set} → (A → B) → EqSetoid A ⟶ EqSetoid B
+≡-to-Π f = record { _⟨$⟩_ = f; cong = cong f }
+
 just-injective : {A : Set} → {x y : A} → Maybe.just x ≡ Maybe.just y → x ≡ y
 just-injective refl = refl
 
@@ -40,11 +44,11 @@ mapMV-purity : {A B : Set} {n : ℕ} → (f : A → B) → (v : Vec A n) → map
 mapMV-purity f []V = refl
 mapMV-purity f (x ∷V xs) rewrite mapMV-purity f xs = refl
 
-maybeEq-from-≡ : {A : Set} {a b : Maybe A} → a ≡ b → MaybeEq (PropEq A) ∋ a ≈ b
+maybeEq-from-≡ : {A : Set} {a b : Maybe A} → a ≡ b → MaybeEq (EqSetoid A) ∋ a ≈ b
 maybeEq-from-≡ {a = just x}  {b = .(just x)} refl = just refl
 maybeEq-from-≡ {a = nothing} {b = .nothing}  refl = nothing
 
-maybeEq-to-≡ : {A : Set} {a b : Maybe A} → MaybeEq (PropEq A) ∋ a ≈ b → a ≡ b
+maybeEq-to-≡ : {A : Set} {a b : Maybe A} → MaybeEq (EqSetoid A) ∋ a ≈ b → a ≡ b
 maybeEq-to-≡ (just refl) = refl
 maybeEq-to-≡ nothing     = refl
 
-- 
cgit v1.2.3


From ce4bbcc0c06b088a10881fcd66da5422571e7995 Mon Sep 17 00:00:00 2001
From: Helmut Grohne <grohne@cs.uni-bonn.de>
Date: Tue, 4 Feb 2014 11:12:42 +0100
Subject: remove unused imports

Most of the became unused by using the convenience functions introduced
in the parent commit.
---
 BFF.agda          | 4 ----
 Bidir.agda        | 3 ---
 FreeTheorems.agda | 2 --
 Precond.agda      | 5 +----
 4 files changed, 1 insertion(+), 13 deletions(-)

(limited to 'FreeTheorems.agda')

diff --git a/BFF.agda b/BFF.agda
index f5573ba..ced6ebf 100644
--- a/BFF.agda
+++ b/BFF.agda
@@ -11,11 +11,7 @@ open Category.Functor.RawFunctor {Level.zero} Data.Maybe.functor using (_<$>_)
 open import Data.List using (List ; [] ; _∷_ ; map ; length)
 open import Data.Vec using (Vec ; toList ; fromList ; tabulate ; allFin) renaming (lookup to lookupV ; map to mapV ; [] to []V ; _∷_ to _∷V_)
 open import Function using (id ; _∘_ ; flip)
-open import Function.Equality using (_⟶_ ; _⟨$⟩_)
-open import Function.Injection using (module Injection) renaming (Injection to _↪_ ; id to id↪)
 open import Relation.Binary using (Setoid ; DecSetoid ; module DecSetoid)
-open import Relation.Binary.PropositionalEquality using (cong) renaming (setoid to EqSetoid)
-open Injection using (to)
 
 open import FinMap
 open import Generic using (mapMV ; ≡-to-Π)
diff --git a/Bidir.agda b/Bidir.agda
index a77a9db..cca2ba7 100644
--- a/Bidir.agda
+++ b/Bidir.agda
@@ -18,9 +18,6 @@ open import Data.Vec.Equality using () renaming (module Equality to VecEq)
 open import Data.Vec.Properties using (tabulate-∘ ; lookup∘tabulate ; map-cong ; map-∘)
 open import Data.Product using (∃ ; _×_ ; _,_ ; proj₁ ; proj₂)
 open import Function using (id ; _∘_ ; flip)
-open import Function.Equality using (_⟶_ ; _⟨$⟩_)
-open import Function.Injection using (module Injection) renaming (Injection to _↪_)
-open Injection using (to)
 open import Relation.Binary.Core using (refl ; _≡_)
 open import Relation.Binary.Indexed using (_at_) renaming (Setoid to ISetoid)
 open import Relation.Binary.PropositionalEquality using (cong ; sym ; inspect ; [_] ; trans ; cong₂ ; decSetoid ; module ≡-Reasoning) renaming (setoid to EqSetoid)
diff --git a/FreeTheorems.agda b/FreeTheorems.agda
index 2181163..d4eb174 100644
--- a/FreeTheorems.agda
+++ b/FreeTheorems.agda
@@ -11,8 +11,6 @@ open import Relation.Binary.PropositionalEquality using (_≗_ ; cong) renaming
 open import Relation.Binary using (Setoid)
 open Injection using (to)
 
-open import Generic using (≡-to-Π)
-
 import GetTypes
 
 module ListList where
diff --git a/Precond.agda b/Precond.agda
index 81c204b..ebb5412 100644
--- a/Precond.agda
+++ b/Precond.agda
@@ -20,11 +20,8 @@ open Data.List.Any.Membership-≡ using (_∉_)
 open import Data.Maybe using (just)
 open import Data.Product using (∃ ; _,_ ; proj₂)
 open import Function using (flip ; _∘_ ; id)
-open import Function.Equality using (_⟶_ ; _⟨$⟩_)
-open import Function.Injection using (module Injection) renaming (Injection to _↪_)
-open Injection using (to)
 open import Relation.Binary using (Setoid)
-open import Relation.Binary.PropositionalEquality using (refl ; cong ; inspect ; [_] ; sym ; decSetoid) renaming (setoid to EqSetoid)
+open import Relation.Binary.PropositionalEquality using (refl ; cong ; inspect ; [_] ; sym ; decSetoid)
 open Relation.Binary.PropositionalEquality.≡-Reasoning using (begin_ ; _≡⟨_⟩_ ; _∎)
 open import Relation.Nullary using (yes ; no)
 
-- 
cgit v1.2.3