feat(hott): define cubes and cubeovers

hott/hit/circle.hlean

@@ -201,7 +201,7 @@ namespace circle
     induction x,
     { exact power loop},
     { apply arrow_pathover_left, intro b, apply concato_eq, apply pathover_eq_r,
-      rewrite [power_con,transport_code_loop]},
+      rewrite [power_con,transport_code_loop]}
   end
 
   --remove this theorem after #484

hott/init/path.hlean

@@ -286,7 +286,7 @@ namespace eq
   eq.rec_on p idp
 
   -- The action of constant maps.
-  definition ap_constant (p : x = y) (z : B) : ap (λu, z) p = idp :=
+  definition ap_constant [unfold-c 5] (p : x = y) (z : B) : ap (λu, z) p = idp :=
   eq.rec_on p idp
 
   -- Naturality of [ap].

hott/init/pathover.hlean

@@ -76,7 +76,7 @@ namespace eq
   definition inverseo (r : b =[p] b₂) : b₂ =[p⁻¹] b :=
   pathover.rec_on r idpo
 
-  definition apdo (f : Πa, B a) (p : a = a₂) : f a =[p] f a₂ :=
+  definition apdo [unfold-c 6] (f : Πa, B a) (p : a = a₂) : f a =[p] f a₂ :=
   eq.rec_on p idpo
 
   -- infix `⬝` := concato
@@ -149,14 +149,22 @@ namespace eq
   by cases r; exact H
 
   --pathover with fibration B' ∘ f
+  definition pathover_ap [unfold-c 10] (B' : A' → Type) (f : A → A') {p : a = a₂}
+    {b : B' (f a)} {b₂ : B' (f a₂)} (q : b =[p] b₂) : b =[ap f p] b₂ :=
+  by cases q; exact idpo
+
+  definition of_pathover_ap (B' : A' → Type) (f : A → A') {p : a = a₂}
+    {b : B' (f a)} {b₂ : B' (f a₂)} (q : b =[ap f p] b₂) : b =[p] b₂ :=
+  by cases p; apply (idp_rec_on q); apply idpo
+
   definition pathover_compose (B' : A' → Type) (f : A → A') (p : a = a₂)
     (b : B' (f a)) (b₂ : B' (f a₂)) : b =[p] b₂ ≃ b =[ap f p] b₂ :=
   begin
     fapply equiv.MK,
-    { intro r, cases r, exact idpo},
-    { intro r, cases p, apply (idp_rec_on r), apply idpo},
-    { intro r, cases p, esimp [function.compose,function.id], apply (idp_rec_on r), apply idp},
-    { intro r, cases r, exact idp},
+    { apply pathover_ap},
+    { apply of_pathover_ap},
+    { intro q, cases p, esimp, apply (idp_rec_on q), apply idp},
+    { intro q, cases q, exact idp},
   end
 
   definition apdo_con (f : Πa, B a) (p : a = a₂) (q : a₂ = a₃)

hott/types/cube.hlean

@@ -0,0 +1,48 @@
+/-
+Copyright (c) 2015 Floris van Doorn. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Author: Floris van Doorn
+
+Cubes
+-/
+
+import .square
+
+open equiv is_equiv
+
+namespace eq
+
+  inductive cube {A : Type} {a₀₀₀ : A}
+    : Π{a₂₀₀ a₀₂₀ a₂₂₀ a₀₀₂ a₂₀₂ a₀₂₂ a₂₂₂ : A}
+       {p₁₀₀ : a₀₀₀ = a₂₀₀} {p₀₁₀ : a₀₀₀ = a₀₂₀} {p₀₀₁ : a₀₀₀ = a₀₀₂}
+       {p₁₂₀ : a₀₂₀ = a₂₂₀} {p₂₁₀ : a₂₀₀ = a₂₂₀} {p₂₀₁ : a₂₀₀ = a₂₀₂}
+       {p₁₀₂ : a₀₀₂ = a₂₀₂} {p₀₁₂ : a₀₀₂ = a₀₂₂} {p₀₂₁ : a₀₂₀ = a₀₂₂}
+       {p₁₂₂ : a₀₂₂ = a₂₂₂} {p₂₁₂ : a₂₀₂ = a₂₂₂} {p₂₂₁ : a₂₂₀ = a₂₂₂}
+       (s₁₁₀ : square p₀₁₀ p₂₁₀ p₁₀₀ p₁₂₀)
+       (s₁₁₂ : square p₀₁₂ p₂₁₂ p₁₀₂ p₁₂₂)
+       (s₁₀₁ : square p₁₀₀ p₁₀₂ p₀₀₁ p₂₀₁)
+       (s₁₂₁ : square p₁₂₀ p₁₂₂ p₀₂₁ p₂₂₁)
+       (s₀₁₁ : square p₀₁₀ p₀₁₂ p₀₀₁ p₀₂₁)
+       (s₂₁₁ : square p₂₁₀ p₂₁₂ p₂₀₁ p₂₂₁), Type :=
+  idc : cube ids ids ids ids ids ids
+
+  variables {A : Type} {a₀₀₀ a₂₀₀ a₀₂₀ a₂₂₀ a₀₀₂ a₂₀₂ a₀₂₂ a₂₂₂ : A}
+            {p₁₀₀ : a₀₀₀ = a₂₀₀} {p₀₁₀ : a₀₀₀ = a₀₂₀} {p₀₀₁ : a₀₀₀ = a₀₀₂}
+            {p₁₂₀ : a₀₂₀ = a₂₂₀} {p₂₁₀ : a₂₀₀ = a₂₂₀} {p₂₀₁ : a₂₀₀ = a₂₀₂}
+            {p₁₀₂ : a₀₀₂ = a₂₀₂} {p₀₁₂ : a₀₀₂ = a₀₂₂} {p₀₂₁ : a₀₂₀ = a₀₂₂}
+            {p₁₂₂ : a₀₂₂ = a₂₂₂} {p₂₁₂ : a₂₀₂ = a₂₂₂} {p₂₂₁ : a₂₂₀ = a₂₂₂}
+            {s₁₁₀ : square p₀₁₀ p₂₁₀ p₁₀₀ p₁₂₀}
+            {s₁₁₂ : square p₀₁₂ p₂₁₂ p₁₀₂ p₁₂₂}
+            {s₁₀₁ : square p₁₀₀ p₁₀₂ p₀₀₁ p₂₀₁}
+            {s₁₂₁ : square p₁₂₀ p₁₂₂ p₀₂₁ p₂₂₁}
+            {s₀₁₁ : square p₀₁₀ p₀₁₂ p₀₀₁ p₀₂₁}
+            {s₂₁₁ : square p₂₁₀ p₂₁₂ p₂₀₁ p₂₂₁}
+
+  definition idc    [reducible] [constructor]         := @cube.idc
+  definition idcube [reducible] [constructor] (a : A) := @cube.idc A a
+  definition rfl1 : cube s₁₁₀ s₁₁₀ vrfl vrfl vrfl vrfl := by induction s₁₁₀; exact idc
+  definition rfl2 : cube hrfl hrfl s₁₀₁ s₁₀₁ hrfl hrfl := by induction s₁₀₁; exact idc
+  definition rfl3 : cube vrfl vrfl hrfl hrfl s₁₁₀ s₁₁₀ := by induction s₁₁₀; exact idc
+
+
+end eq

hott/types/cubeover.hlean

@@ -0,0 +1,59 @@
+/-
+Copyright (c) 2015 Floris van Doorn. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Author: Floris van Doorn
+
+Cubeovers
+-/
+
+import .squareover .cube
+
+open equiv is_equiv
+
+namespace eq
+
+  -- we need to specify B explicitly, also in pathovers
+  inductive cubeover {A : Type} (B : A → Type) {a₀₀₀ : A} {b₀₀₀ : B a₀₀₀}
+    : Π{a₂₀₀ a₀₂₀ a₂₂₀ a₀₀₂ a₂₀₂ a₀₂₂ a₂₂₂ : A}
+       {p₁₀₀ : a₀₀₀ = a₂₀₀} {p₀₁₀ : a₀₀₀ = a₀₂₀} {p₀₀₁ : a₀₀₀ = a₀₀₂}
+       {p₁₂₀ : a₀₂₀ = a₂₂₀} {p₂₁₀ : a₂₀₀ = a₂₂₀} {p₂₀₁ : a₂₀₀ = a₂₀₂}
+       {p₁₀₂ : a₀₀₂ = a₂₀₂} {p₀₁₂ : a₀₀₂ = a₀₂₂} {p₀₂₁ : a₀₂₀ = a₀₂₂}
+       {p₁₂₂ : a₀₂₂ = a₂₂₂} {p₂₁₂ : a₂₀₂ = a₂₂₂} {p₂₂₁ : a₂₂₀ = a₂₂₂}
+       {s₁₁₀ : square p₀₁₀ p₂₁₀ p₁₀₀ p₁₂₀}
+       {s₁₁₂ : square p₀₁₂ p₂₁₂ p₁₀₂ p₁₂₂}
+       {s₁₀₁ : square p₁₀₀ p₁₀₂ p₀₀₁ p₂₀₁}
+       {s₁₂₁ : square p₁₂₀ p₁₂₂ p₀₂₁ p₂₂₁}
+       {s₀₁₁ : square p₀₁₀ p₀₁₂ p₀₀₁ p₀₂₁}
+       {s₂₁₁ : square p₂₁₀ p₂₁₂ p₂₀₁ p₂₂₁}
+       (c : cube s₁₁₀ s₁₁₂ s₁₀₁ s₁₂₁ s₀₁₁ s₂₁₁)
+                       {b₀₂₀ : B a₀₂₀} {b₂₀₀ : B a₂₀₀} {b₂₂₀ : B a₂₂₀}
+       {b₀₀₂ : B a₀₀₂} {b₀₂₂ : B a₀₂₂} {b₂₀₂ : B a₂₀₂} {b₂₂₂ : B a₂₂₂}
+       {q₁₀₀ : pathover B b₀₀₀ p₁₀₀ b₂₀₀} {q₀₁₀ : pathover B b₀₀₀ p₀₁₀ b₀₂₀}
+       {q₀₀₁ : pathover B b₀₀₀ p₀₀₁ b₀₀₂} {q₁₂₀ : pathover B b₀₂₀ p₁₂₀ b₂₂₀}
+       {q₂₁₀ : pathover B b₂₀₀ p₂₁₀ b₂₂₀} {q₂₀₁ : pathover B b₂₀₀ p₂₀₁ b₂₀₂}
+       {q₁₀₂ : pathover B b₀₀₂ p₁₀₂ b₂₀₂} {q₀₁₂ : pathover B b₀₀₂ p₀₁₂ b₀₂₂}
+       {q₀₂₁ : pathover B b₀₂₀ p₀₂₁ b₀₂₂} {q₁₂₂ : pathover B b₀₂₂ p₁₂₂ b₂₂₂}
+       {q₂₁₂ : pathover B b₂₀₂ p₂₁₂ b₂₂₂} {q₂₂₁ : pathover B b₂₂₀ p₂₂₁ b₂₂₂}
+       (t₁₁₀ : squareover B s₁₁₀ q₀₁₀ q₂₁₀ q₁₀₀ q₁₂₀)
+       (t₁₁₂ : squareover B s₁₁₂ q₀₁₂ q₂₁₂ q₁₀₂ q₁₂₂)
+       (t₁₀₁ : squareover B s₁₀₁ q₁₀₀ q₁₀₂ q₀₀₁ q₂₀₁)
+       (t₁₂₁ : squareover B s₁₂₁ q₁₂₀ q₁₂₂ q₀₂₁ q₂₂₁)
+       (t₀₁₁ : squareover B s₀₁₁ q₀₁₀ q₀₁₂ q₀₀₁ q₀₂₁)
+       (t₂₁₁ : squareover B s₂₁₁ q₂₁₀ q₂₁₂ q₂₀₁ q₂₂₁), Type :=
+  idcubeo : cubeover B idc idso idso idso idso idso idso
+
+
+
+  -- variables {A : Type} {a₀₀₀ a₂₀₀ a₀₂₀ a₂₂₀ a₀₀₂ a₂₀₂ a₀₂₂ a₂₂₂ : A}
+  --           {p₁₀₀ : a₀₀₀ = a₂₀₀} {p₀₁₀ : a₀₀₀ = a₀₂₀} {p₀₀₁ : a₀₀₀ = a₀₀₂}
+  --           {p₁₂₀ : a₀₂₀ = a₂₂₀} {p₂₁₀ : a₂₀₀ = a₂₂₀} {p₂₀₁ : a₂₀₀ = a₂₀₂}
+  --           {p₁₀₂ : a₀₀₂ = a₂₀₂} {p₀₁₂ : a₀₀₂ = a₀₂₂} {p₀₂₁ : a₀₂₀ = a₀₂₂}
+  --           {p₁₂₂ : a₀₂₂ = a₂₂₂} {p₂₁₂ : a₂₀₂ = a₂₂₂} {p₂₂₁ : a₂₂₀ = a₂₂₂}
+  --           {s₁₁₀ : square p₀₁₀ p₂₁₀ p₁₀₀ p₁₂₀}
+  --           {s₁₁₂ : square p₀₁₂ p₂₁₂ p₁₀₂ p₁₂₂}
+  --           {s₁₀₁ : square p₁₀₀ p₁₀₂ p₀₀₁ p₂₀₁}
+  --           {s₁₂₁ : square p₁₂₀ p₁₂₂ p₀₂₁ p₂₂₁}
+  --           {s₀₁₁ : square p₀₁₀ p₀₁₂ p₀₀₁ p₀₂₁}
+  --           {s₂₁₁ : square p₂₁₀ p₂₁₂ p₂₀₁ p₂₂₁}
+
+end eq

hott/types/pathover.hlean

@@ -0,0 +1,60 @@
+/-
+Copyright (c) 2015 Floris van Doorn. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Author: Floris van Doorn
+
+Pathovers.
+Note that the basic definitions are in init.pathover
+-/
+
+import types.squareover
+
+open eq equiv is_equiv equiv.ops
+
+namespace eq
+
+  variables {A A' : Type} {B B' : A → Type} {C : Πa, B a → Type}
+            {a a₂ a₃ a₄ : A} {p : a = a₂} {p₂ : a₂ = a₃} {p₃ : a₃ = a₄}
+            {b b' : B a} {b₂ b₂' : B a₂} {b₃ : B a₃} {b₄ : B a₄}
+            {c : C a b} {c₂ : C a₂ b₂}
+            {q q' : a =[p] a₂}
+
+
+--check λa, pathover (C a) (fc a) (h a) (gc a)
+
+-- λa, pathover P (b a) (p a) (b' a)
+
+
+
+-- pathover P b p b'
+--set_option pp.notation false
+
+  --in this version A' does not depend on A
+  definition pathover_pathover_fl {a' a₂' : A'} {p : a' = a₂'} {a₂ : A} {f : A' → A}
+    {b : Πa, B (f a)} {b₂ : B a₂} {q : Π(a' : A'), f a' = a₂} (r : pathover B (b a') (q a') b₂)
+    (r₂ : pathover B (b a₂') (q a₂') b₂)
+    (s : squareover B (naturality q p) r r₂ (pathover_ap B f (apdo b p)) (!ap_constant⁻¹ ▸ idpo))
+    : r =[p] r₂ :=
+  by cases p; esimp at s; apply pathover_idp_of_eq; apply eq_of_vdeg_squareover; exact s
+
+--   definition pathover_pathover {ba ba' : Πa, B a} {pa : Πa, ba a = ba a}
+--             {ca : Πa, C a (ba a)} {ca' : Πa, C a (ba' a)}
+--             {qa : ba a =[pa a] ba' a} {qa₂ : ba a₂ =[pa a₂] ba' a₂}
+--  (r : squareover _ _ _ _ _ _) : qa =[p] qa₂ :=
+-- sorry
+
+--   definition pathover_pathover_constant_FlFr {C : A → A' → Type} {ba ba' : A → A'} {pa : Πa, ba a = ba a}
+--             {ca : Πa, C a (ba a)} {ca' : Πa, C a (ba' a)}
+--             {qa : ba a =[pa a] ba' a} {qa₂ : ba a₂ =[pa a₂] ba' a₂}
+--  (r : squareover (λa, C a _) _ _ _ _ _) : pathover _ qa p qa₂ := sorry
+
+--   definition pathover_pathover_constant_l {C : A → A' → Type} {ba ba' : A → A'} {pa : Πa, ba a = ba a}
+--             {ca : Πa, C a (ba a)} {ca' : Πa, C a (ba' a)}
+--             {qa : ba a =[pa a] ba' a} {qa₂ : ba a₂ =[pa a₂] ba' a₂}
+--  (r : squareover (λa, C a _) _ _ _ _ _) : qa =[p] qa₂ :=
+-- begin
+--   check_expr qa =[p] qa₂
+-- end
+
+
+end eq

hott/types/pi.hlean

@@ -69,6 +69,17 @@ namespace pi
     apply eq_of_pathover_idp, apply r
   end
 
+  -- a version where C is uncurried, but where the conclusion of r is still a proper pathover
+  -- instead of a heterogenous equality
+  definition pi_pathover' {C : (Σa, B a) → Type} {f : Πb, C ⟨a, b⟩} {g : Πb', C ⟨a', b'⟩}
+    {p : a = a'} (r : Π(b : B a) (b' : B a') (q : b =[p] b'), f b =[dpair_eq_dpair p q] g b')
+    : f =[p] g :=
+  begin
+    cases p, apply pathover_idp_of_eq,
+    apply eq_of_homotopy, intro b,
+    apply (@eq_of_pathover_idp _ C), exact (r b b (pathover.idpatho b)),
+  end
+
   definition pi_pathover_left {f : Πb, C a b} {g : Πb', C a' b'} {p : a = a'}
     (r : Π(b : B a), f b =[apo011 C p !pathover_tr] g (p ▸ b)) : f =[p] g :=
   begin

hott/types/square.hlean

@@ -3,14 +3,14 @@ Copyright (c) 2015 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Author: Floris van Doorn
 
-Theorems about square
+Squares in a type
 -/
 
 open eq equiv is_equiv
 
 namespace eq
 
-  variables {A : Type} {a a' a'' a₀₀ a₂₀ a₄₀ a₀₂ a₂₂ a₂₄ a₀₄ a₄₂ a₄₄ : A}
+  variables {A B : Type} {a a' a'' a₀₀ a₂₀ a₄₀ a₀₂ a₂₂ a₂₄ a₀₄ a₄₂ a₄₄ : A}
             /-a₀₀-/ {p₁₀ : a₀₀ = a₂₀} /-a₂₀-/ {p₃₀ : a₂₀ = a₄₀} /-a₄₀-/
        {p₀₁ : a₀₀ = a₀₂} /-s₁₁-/ {p₂₁ : a₂₀ = a₂₂} /-s₃₁-/ {p₄₁ : a₄₀ = a₄₂}
             /-a₀₂-/ {p₁₂ : a₀₂ = a₂₂} /-a₂₂-/ {p₃₂ : a₂₂ = a₄₂} /-a₄₂-/
@@ -35,6 +35,11 @@ namespace eq
   definition vrefl [unfold-c 4] (p : a = a') : square p p idp idp :=
   by cases p; exact ids
 
+  definition hrfl [unfold-c 4] {p : a = a'} : square idp idp p p :=
+  !hrefl
+  definition vrfl [unfold-c 4] {p : a = a'} : square p p idp idp :=
+  !vrefl
+
   definition hconcat (s₁₁ : square p₁₀ p₁₂ p₀₁ p₂₁) (s₃₁ : square p₃₀ p₃₂ p₂₁ p₄₁)
     : square (p₁₀ ⬝ p₃₀) (p₁₂ ⬝ p₃₂) p₀₁ p₄₁ :=
   by cases s₃₁; exact s₁₁
@@ -55,10 +60,10 @@ namespace eq
   definition eq_of_square (s₁₁ : square p₁₀ p₁₂ p₀₁ p₂₁) : p₁₀ ⬝ p₂₁ = p₀₁ ⬝ p₁₂ :=
   by cases s₁₁; apply idp
 
-  definition hdegen_square {p q : a = a'} (r : p = q) : square idp idp p q :=
+  definition hdeg_square {p q : a = a'} (r : p = q) : square idp idp p q :=
   by cases r;apply hrefl
 
-  definition vdegen_square {p q : a = a'} (r : p = q) : square p q idp idp :=
+  definition vdeg_square {p q : a = a'} (r : p = q) : square p q idp idp :=
   by cases r;apply vrefl
 
   definition square_of_eq (r : p₁₀ ⬝ p₂₁ = p₀₁ ⬝ p₁₂) : square p₁₀ p₁₂ p₀₁ p₂₁ :=
@@ -136,6 +141,10 @@ namespace eq
     from eq.rec_on (eq_of_square s : idp ⬝ r = l) (by cases r; exact H),
   left_inv (to_fun !square_equiv_eq) s ▸ H2
 
+  definition naturality [unfold-c 8] {f g : A → B} (p : f ∼ g) (q : a = a') :
+    square (p a) (p a') (ap f q) (ap g q) :=
+  eq.rec_on q vrfl
+
   --we can also do the other recursors (lr, tl, tr, bl, br, tbl, tbr, tlr, blr), but let's postpone this until they are needed
 
 end eq

hott/types/squareover.hlean

@@ -3,14 +3,27 @@ Copyright (c) 2015 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Author: Floris van Doorn
 
-Theorems about squareovers
+Squareovers
 -/
 
 import types.square
 
 open eq equiv is_equiv equiv.ops
 
-namespace cubical
+namespace eq
+
+  -- we give the argument B explicitly, because Lean would find (λa, B a) by itself, which
+  -- makes the type uglier (of course the two terms are definitionally equal)
+  inductive squareover {A : Type} (B : A → Type) {a₀₀ : A} {b₀₀ : B a₀₀} :
+    Π{a₂₀ a₀₂ a₂₂ : A}
+     {p₁₀ : a₀₀ = a₂₀} {p₁₂ : a₀₂ = a₂₂} {p₀₁ : a₀₀ = a₀₂} {p₂₁ : a₂₀ = a₂₂}
+     (s₁₁ : square p₁₀ p₁₂ p₀₁ p₂₁)
+     {b₂₀ : B a₂₀} {b₀₂ : B a₀₂} {b₂₂ : B a₂₂}
+     (q₁₀ : pathover B b₀₀ p₁₀ b₂₀) (q₁₂ : pathover B b₀₂ p₁₂ b₂₂)
+     (q₀₁ : pathover B b₀₀ p₀₁ b₀₂) (q₂₁ : pathover B b₂₀ p₂₁ b₂₂),
+     Type :=
+  idsquareo : squareover B ids idpo idpo idpo idpo
+
 
   variables {A A' : Type} {B : A → Type}
             {a a' a'' a₀₀ a₂₀ a₄₀ a₀₂ a₂₂ a₂₄ a₀₄ a₄₂ a₄₄ : A}
@@ -24,21 +37,27 @@ namespace cubical
             {b₀₂ : B a₀₂} {b₂₂ : B a₂₂} {b₄₂ : B a₄₂}
             {b₀₄ : B a₀₄} {b₂₄ : B a₂₄} {b₄₄ : B a₄₄}
             /-b₀₀-/ {q₁₀ : b₀₀ =[p₁₀] b₂₀} /-b₂₀-/ {q₃₀ : b₂₀ =[p₃₀] b₄₀} /-b₄₀-/
-   {q₀₁ : b₀₀ =[p₀₁] b₀₂} /-s₁₁-/ {q₂₁ : b₂₀ =[p₂₁] b₂₂} /-s₃₁-/ {q₄₁ : b₄₀ =[p₄₁] b₄₂}
+   {q₀₁ : b₀₀ =[p₀₁] b₀₂} /-t₁₁-/ {q₂₁ : b₂₀ =[p₂₁] b₂₂} /-t₃₁-/ {q₄₁ : b₄₀ =[p₄₁] b₄₂}
             /-b₀₂-/ {q₁₂ : b₀₂ =[p₁₂] b₂₂} /-b₂₂-/ {q₃₂ : b₂₂ =[p₃₂] b₄₂} /-b₄₂-/
-   {q₀₃ : b₀₂ =[p₀₃] b₀₄} /-s₁₃-/ {q₂₃ : b₂₂ =[p₂₃] b₂₄} /-s₃₃-/ {q₄₃ : b₄₂ =[p₄₃] b₄₄}
+   {q₀₃ : b₀₂ =[p₀₃] b₀₄} /-t₁₃-/ {q₂₃ : b₂₂ =[p₂₃] b₂₄} /-t₃₃-/ {q₄₃ : b₄₂ =[p₄₃] b₄₄}
             /-b₀₄-/ {q₁₄ : b₀₄ =[p₁₄] b₂₄} /-b₂₄-/ {q₃₄ : b₂₄ =[p₃₄] b₄₄} /-b₄₄-/
 
-  inductive squareover (B : A → Type) {b₀₀ : B a₀₀} :
-    Π{a₂₀ a₀₂ a₂₂ : A} {p₁₀ : a₀₀ = a₂₀} {p₁₂ : a₀₂ = a₂₂} {p₀₁ : a₀₀ = a₀₂} {p₂₁ : a₂₀ = a₂₂}
-     (s₁₁ : square p₁₀ p₁₂ p₀₁ p₂₁)
-     {b₂₀ : B a₂₀} {b₀₂ : B a₀₂} {b₂₂ : B a₂₂}
-     (q₁₀ : b₀₀ =[p₁₀] b₂₀) (q₁₂ : b₀₂ =[p₁₂] b₂₂) (q₀₁ : b₀₀ =[p₀₁] b₀₂) (q₂₁ : b₂₀ =[p₂₁] b₂₂),
-     Type :=
-  idsquareo : squareover B ids idpo idpo idpo idpo
+  definition squareo := @squareover A B a₀₀
+  definition idsquareo [reducible] [constructor] (b₀₀ : B a₀₀) := @squareover.idsquareo A B a₀₀ b₀₀
+  definition idso      [reducible] [constructor]               := @squareover.idsquareo A B a₀₀ b₀₀
 
-  definition squareo := @squareover A a₀₀ B
-  definition idsquareo [reducible] [constructor] (b₀₀ : B a₀₀) := @squareover.idsquareo A a₀₀ B b₀₀
-  definition idso [reducible] [constructor] := @squareover.idsquareo A a₀₀ B b₀₀
+  definition apds (f : Πa, B a) (s : square p₁₀ p₁₂ p₀₁ p₂₁)
+    : squareover B s (apdo f p₁₀) (apdo f p₁₂) (apdo f p₀₁) (apdo f p₂₁) :=
+  square.rec_on s idso
 
-end cubical
+  definition vrflo : squareover B vrfl q₁₀ q₁₀ idpo idpo :=
+  by cases q₁₀; exact idso
+
+  definition vdeg_squareover {q₁₀' : b₀₀ =[p₁₀] b₂₀} (p : q₁₀ = q₁₀')
+    : squareover B vrfl q₁₀ q₁₀' idpo idpo :=
+  by cases p;exact vrflo
+
+  definition eq_of_vdeg_squareover {q₁₀' : b₀₀ =[p₁₀] b₂₀}
+    (p : squareover B vrfl q₁₀ q₁₀' idpo idpo) : q₁₀ = q₁₀' :=
+  sorry
+end eq