# `refl ≡ loop` is empty - Defining `flipPath` via Univalence

In this part, we will define the path `flipPath : Bool ≡ Bool`.
Recall the picture of `doubleCover`.
(Insert gif.)

This means we need `flipPath` to correspond to 
the unique non-identity permutation of `Bool`
that flips `true` and `false`.

We proceed in steps :

1. Define the function `Flip : Bool → Bool`.
2. Promote this to an isomorphism `flipIso : Bool ≅ Bool`.
3. The intuition is that the univalence axiom asserts that
   paths in the space of spaces correspond to
   homotopy-equivalences of spaces.
   As a corollary,
   we can make paths in `Type` from isomorphisms of types.
   We use this to turn `flipIso` into 
   a path `flipPath : Bool ≡ Bool`.

## The function

- In `1FundamentalGroup/Quest0.agda`, navigate to :

  ```agda
  Flip : Bool → Bool
  Flip x = {!!}
  ```
- Write `x` inside the hole,
  and do `C-c C-c` with your cursor still inside.
  The `c` stands for _cases_.
  You should now see :
  ```agda
  Flip : Bool → Bool
  Flip false = {!!}
  Flip true = {!!} 
  ```
  What this is saying is that 
  the space `Bool` is made of two points `false, true` and nothing else,
  so to map out of it, 
  it suffices to give something to map `false` and `true` to respectively.
- Since we want `Flip` to flip `true` and `false`,
  fill the first hole with `true` and the second with `false`.
- To check things have worked,
  try `C-c C-d`. (`d` stands for _deduce_.)
  Then `agda` will ask you to input an expression.
  Enter `Flip`.
  In the `*Agda Information*` window,
  you should see 

  ```agda
  Bool → Bool  
  ```
  
  This means `agda` recognises `Flip` as a well-formulated term
  and is a point in the space of maps from `Bool` to `Bool`.
- We can also ask `agda` to compute outputs of `Flip`.
  Try `C-c C-n`. (`n` stands for _normalise_.)
  `agda` should again be asking for an expression.
  Enter `Flip true`.
  In the `*Agda Information*` window, you should see `false`, as desired.

## The isomorphism

- Navigate to
  ```agda
  flipIso : Bool ≅ Bool
  flipIso = {!!} 
  ```
- Write `iso` in the hole and refine with `C-c C-r`.
  You should now see 
  ```agda
  flipIso : Bool ≅ Bool
  flipIso = iso {!!} {!!} {!!} {!!}  
  ```
- Check that what `agda` is expecting in the first two holes
  are functions `Bool → Bool`.
  These are our maps back and forth which will constitute the isomorphism
  so write `Flip` and `Flip` in the first two holes.
- Check the goal of the next two holes.
  They should be 
  ```agda
  section Flip Flip 
  ```
  and 
  ```agda
  retract Flip Flip 
  ```
  This means we need to prove
  `Flip` is a right inverse and a left inverse of `Flip`.
- Write the following so that your code looks like 
  ```agda
  flipIso : Bool ≅ Bool 
  flipIso = iso Flip Flip s r where

    s : section Flip Flip
    s b = {!!}
    
    r : retract Flip Flip
    r b = {!!} 
  ```
  The `where` allows you to make definitions local to the current definition,
  in the sense that you will not be able to access `s` and `r` outside this proof.
  Note that what follows `where` must be indented.
- Check the goal of the hole `s b = {!!}`.
  In the `*Agda Information*` window, you should see 
  ```agda
  Goal: Flip (Flip b) ≡ b
  —————————————————————————————————
  b : Bool 
  ```
  Try to prove this.
  <p>
  <details>
  <summary>Hint</summary>

  You need to do cases on what `b` can be.
  Then for the case of `true` and `false`,
  try `C-c C-r` to see if `agda` can help.
  </details>
  </p>
- Do the same for `r b = {!!}`.
- Use `C-c C-d` to check that `agda` is okay with `flipIso`.

## The path

- Navigate to 
  ```agda
  flipPath : Bool ≡ Bool
  flipPath = {!!} 
  ```
- In the hole, write in `isoToPath` and refine with `C-c C-r`.
  You should now have 
  ```agda
  flipPath : Bool ≡ Bool
  flipPath = isoToPath {!!} 
  ```
  If you check the new hole, you should see that
  `agda` is expecting an isomorphism `Bool ≅ Bool`.
  
  `isoToPath` is the function from the cubical library
  that converts isomorphisms between spaces
  into paths between the corresponding points in the space of spaces `Type`.
- Fill in the hole with `flipIso`
  and use `C-c C-d` to check `agda` is happy with `flipPath`.
- Try `C-c C-n` with `transport flipPath false`.
  You should get `true` in the `*Agda Information*` window.
  
  What `transport` did is it took the path `flipPath` in the 
  space of spaces `Type` and followed the point `false`
  as `Bool` is transformed along `flipPath`.
  The end result is of course `true`,
  since `flipPath` is the path obtained from `flip`!