diff --git a/1FundamentalGroup/Quest2.agda b/1FundamentalGroup/Quest2.agda
index 0562894..76777aa 100644
--- a/1FundamentalGroup/Quest2.agda
+++ b/1FundamentalGroup/Quest2.agda
@@ -33,7 +33,7 @@ Your definition of ⊔NoConfusion goes here.
 
 Your definition of Path≡⊔NoConfusion goes here.
 
-Your definition of isProp⊔NoConfusion goes here.
+Your definition of isSet⊔NoConfusion goes here.
 
 Your definition of isSet⊔ goes here.
 
diff --git a/1FundamentalGroup/Quest2Solutions.agda b/1FundamentalGroup/Quest2Solutions.agda
index 30d4cfd..2e7ba12 100644
--- a/1FundamentalGroup/Quest2Solutions.agda
+++ b/1FundamentalGroup/Quest2Solutions.agda
@@ -79,17 +79,34 @@ isProp⊥ ()
 ⊔NoConfusion (inr x) (inl y) = ⊥
 ⊔NoConfusion (inr x) (inr y) = x ≡ y -- Path B x y
 
-isProp⊔NoConfusion : isSet A → isSet B
+isSet⊔NoConfusion : isSet A → isSet B
                      → (x y : A ⊔ B) → isProp (⊔NoConfusion x y)
-isProp⊔NoConfusion hA hB (inl x) (inl y) = hA x y
-isProp⊔NoConfusion hA hB (inl x) (inr y) = isProp⊥
-isProp⊔NoConfusion hA hB (inr x) (inl y) = isProp⊥
-isProp⊔NoConfusion hA hB (inr x) (inr y) = hB x y
+isSet⊔NoConfusion hA hB (inl x) (inl y) = hA x y
+isSet⊔NoConfusion hA hB (inl x) (inr y) = isProp⊥
+isSet⊔NoConfusion hA hB (inr x) (inl y) = isProp⊥
+isSet⊔NoConfusion hA hB (inr x) (inr y) = hB x y
 
 ⊔NoConfusionSelf : (x : A ⊔ B) → ⊔NoConfusion x x
 ⊔NoConfusionSelf (inl x) = refl
 ⊔NoConfusionSelf (inr x) = refl
 
+Path≅⊔NoConfusion' : (x y : A ⊔ B) → (x ≡ y) ≅ ⊔NoConfusion x y
+Path≅⊔NoConfusion' x y = iso (fun _ _) ({!!}) ({!!}) ({!!}) where
+
+  -- if you case on x and y you would have to show that inl and inr are injective
+  -- J avoids this, but leads to needing J and JRefl for showing section and retract
+  fun : (x y : A ⊔ B) → (x ≡ y) → ⊔NoConfusion x y
+  fun x y = J (λ y₂ x₂ → ⊔NoConfusion x y₂) (⊔NoConfusionSelf x)
+
+  inv : (x y : A ⊔ B) → ⊔NoConfusion x y → x ≡ y
+  inv (inl x) (inl y) p = cong inl p
+  inv (inr x) (inr y) p = cong inr p
+
+  rightInv : (x y : A ⊔ B) → section (fun x y) (inv x y)
+  rightInv {A} {B} (inl x) (inl x₁) = J ((λ y' p → fun {A} {B} (inl x) (inl y') (inv (inl x) (inl y') p) ≡ p)) {!!}
+  rightInv {A} {B} (inl x) (inr x₁) = {!!}
+  rightInv {A} {B} (inr x) y = {!!}
+
 Path≅⊔NoConfusion : (x y : A ⊔ B) → (x ≡ y) ≅ ⊔NoConfusion x y
 Path≅⊔NoConfusion x y = iso (fun _ _) (inv _ _) (rightInv _ _) (leftInv _ _) where
 
@@ -103,27 +120,21 @@ Path≅⊔NoConfusion x y = iso (fun _ _) (inv _ _) (rightInv _ _) (leftInv _ _)
   inv (inr x) (inr y) p = cong inr p
 
   rightInv : (x y : A ⊔ B) → section (fun x y) (inv x y)
-  rightInv {B = B} (inl x) (inl y) p = leml x y p where
-
-    leml : (x y : A) (p : x ≡ y) → fun {A} {B} (inl x) (inl y) (inv (inl x) (inl y) p) ≡ p
-    leml {A} x y = J (λ y' p → fun {A} {B} (inl x) (inl y') (inv (inl x) (inl y') p) ≡ p)
+  rightInv {A} {B} (inl x) (inl y) p = J (λ y' p → fun {A} {B} (inl x) (inl y') (inv (inl x) (inl y') p) ≡ p)
                         (
                           fun {A} {B} (inl x) (inl x) refl
                         ≡⟨ JRefl {x = inl x} ((λ y' p → ⊔NoConfusion {A} {B} (inl x) y')) _ ⟩
                         -- uses how J computes on refl
                           refl ∎
-                        )
+                        ) p
 
-  rightInv {A = A} (inr x) (inr y) p = lemr x y p where
-
-    lemr : (x y : B) (p : x ≡ y) → fun {A} {B} (inr x) (inr y) (inv (inr x) (inr y) p) ≡ p
-    lemr {B} x y = J (λ y' p → fun {A} {B} (inr x) (inr y') (inv (inr x) (inr y') p) ≡ p)
+  rightInv {A} {B} (inr x) (inr y) p = J (λ y' p → fun {A} {B} (inr x) (inr y') (inv (inr x) (inr y') p) ≡ p)
                      (
                        fun {A} {B} (inr x) (inr x) refl
                      ≡⟨ JRefl {x = inr x} ((λ y' p → ⊔NoConfusion {A} {B} (inr x) y')) _ ⟩
                      -- uses how J computes on refl
                        refl ∎
-                     )
+                     ) p
 
   leftInv : (x y : A ⊔ B) → retract (fun x y) (inv x y)
   leftInv x y = J (λ y' p → inv x y' (fun x y' p) ≡ p)
@@ -144,11 +155,11 @@ Path≡⊔NoConfusion x y = isoToPath (Path≅⊔NoConfusion x y)
 
 isSet⊔ : {A B : Type} → isSet A → isSet B → isSet (A ⊔ B)
 isSet⊔ hA hB x y = pathToFun (cong isProp (sym (Path≡⊔NoConfusion x y)))
-                     (isProp⊔NoConfusion hA hB x y)
+                     (isSet⊔NoConfusion hA hB x y)
 
 isSet⊔' : {A B : Type} → isSet A → isSet B → isSet (A ⊔ B)
 isSet⊔' hA hB x y = endPt (λ A → isProp A) (sym (Path≡⊔NoConfusion x y))
-                     (isProp⊔NoConfusion hA hB x y)
+                     (isSet⊔NoConfusion hA hB x y)
 
 isSetℤ : isSet ℤ
 isSetℤ = pathToFun (cong isSet (sym ℤ≡ℕ⊔ℕ)) (isSet⊔ isSetℕ isSetℕ)
diff --git a/_build/2.6.2/agda/1FundamentalGroup/Quest2Solutions.agdai b/_build/2.6.2/agda/1FundamentalGroup/Quest2Solutions.agdai
index 1e21b39..6f6bf2a 100644
Binary files a/_build/2.6.2/agda/1FundamentalGroup/Quest2Solutions.agdai and b/_build/2.6.2/agda/1FundamentalGroup/Quest2Solutions.agdai differ